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 number of lines in a command saved while we run parse_and_execute */
254 int saved_command_line_count;
256 /* The token that currently denotes the end of parse. */
259 /* The token currently being read. */
262 /* The current parser state. */
265 /* Variables to manage the task of reading here documents, because we need to
266 defer the reading until after a complete command has been collected. */
267 static REDIRECT *redir_stack[10];
270 /* Where shell input comes from. History expansion is performed on each
271 line when the shell is interactive. */
272 static char *shell_input_line = (char *)NULL;
273 static int shell_input_line_index;
274 static int shell_input_line_size; /* Amount allocated for shell_input_line. */
275 static int shell_input_line_len; /* strlen (shell_input_line) */
277 /* Either zero or EOF. */
278 static int shell_input_line_terminator;
280 /* The line number in a script on which a function definition starts. */
281 static int function_dstart;
283 /* The line number in a script on which a function body starts. */
284 static int function_bstart;
286 /* The line number in a script at which an arithmetic for command starts. */
287 static int arith_for_lineno;
289 /* The decoded prompt string. Used if READLINE is not defined or if
290 editing is turned off. Analogous to current_readline_prompt. */
291 static char *current_decoded_prompt;
293 /* The last read token, or NULL. read_token () uses this for context
295 static int last_read_token;
297 /* The token read prior to last_read_token. */
298 static int token_before_that;
300 /* The token read prior to token_before_that. */
301 static int two_tokens_ago;
303 static int global_extglob;
305 /* The line number in a script where the word in a `case WORD', `select WORD'
306 or `for WORD' begins. This is a nested command maximum, since the array
307 index is decremented after a case, select, or for command is parsed. */
308 #define MAX_CASE_NEST 128
309 static int word_lineno[MAX_CASE_NEST];
310 static int word_top = -1;
312 /* If non-zero, it is the token that we want read_token to return
313 regardless of what text is (or isn't) present to be read. This
314 is reset by read_token. If token_to_read == WORD or
315 ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
316 static int token_to_read;
317 static WORD_DESC *word_desc_to_read;
319 static REDIRECTEE source;
320 static REDIRECTEE redir;
324 WORD_DESC *word; /* the word that we read. */
325 int number; /* the number that we read. */
326 WORD_LIST *word_list;
330 PATTERN_LIST *pattern;
333 /* Reserved words. Members of the first group are only recognized
334 in the case that they are preceded by a list_terminator. Members
335 of the second group are for [[...]] commands. Members of the
336 third group are recognized only under special circumstances. */
337 %token IF THEN ELSE ELIF FI CASE ESAC FOR SELECT WHILE UNTIL DO DONE FUNCTION COPROC
338 %token COND_START COND_END COND_ERROR
339 %token IN BANG TIME TIMEOPT TIMEIGN
341 /* More general tokens. yylex () knows how to make these. */
342 %token <word> WORD ASSIGNMENT_WORD REDIR_WORD
343 %token <number> NUMBER
344 %token <word_list> ARITH_CMD ARITH_FOR_EXPRS
345 %token <command> COND_CMD
346 %token AND_AND OR_OR GREATER_GREATER LESS_LESS LESS_AND LESS_LESS_LESS
347 %token GREATER_AND SEMI_SEMI SEMI_AND SEMI_SEMI_AND
348 %token LESS_LESS_MINUS AND_GREATER AND_GREATER_GREATER LESS_GREATER
349 %token GREATER_BAR BAR_AND
351 /* The types that the various syntactical units return. */
353 %type <command> inputunit command pipeline pipeline_command
354 %type <command> list list0 list1 compound_list simple_list simple_list1
355 %type <command> simple_command shell_command
356 %type <command> for_command select_command case_command group_command
357 %type <command> arith_command
358 %type <command> cond_command
359 %type <command> arith_for_command
360 %type <command> coproc
361 %type <command> function_def function_body if_command elif_clause subshell
362 %type <redirect> redirection redirection_list
363 %type <element> simple_command_element
364 %type <word_list> word_list pattern
365 %type <pattern> pattern_list case_clause_sequence case_clause
366 %type <number> timespec
367 %type <number> list_terminator
371 %left '&' ';' '\n' yacc_EOF
376 inputunit: simple_list simple_list_terminator
378 /* Case of regular command. Discard the error
379 safety net,and return the command just parsed. */
382 /* discard_parser_constructs (0); */
383 if (parser_state & PST_CMDSUBST)
384 parser_state |= PST_EOFTOKEN;
389 /* Case of regular command, but not a very
390 interesting one. Return a NULL command. */
391 global_command = (COMMAND *)NULL;
392 if (parser_state & PST_CMDSUBST)
393 parser_state |= PST_EOFTOKEN;
398 /* Error during parsing. Return NULL command. */
399 global_command = (COMMAND *)NULL;
401 /* discard_parser_constructs (1); */
402 if (interactive && parse_and_execute_level == 0)
413 /* Case of EOF seen by itself. Do ignoreeof or
415 global_command = (COMMAND *)NULL;
416 handle_eof_input_unit ();
422 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
424 { $$ = make_word_list ($2, $1); }
427 redirection: '>' WORD
431 $$ = make_redirection (source, r_output_direction, redir, 0);
437 $$ = make_redirection (source, r_input_direction, redir, 0);
443 $$ = make_redirection (source, r_output_direction, redir, 0);
449 $$ = make_redirection (source, r_input_direction, redir, 0);
451 | REDIR_WORD '>' WORD
453 source.filename = $1;
455 $$ = make_redirection (source, r_output_direction, redir, REDIR_VARASSIGN);
457 | REDIR_WORD '<' WORD
459 source.filename = $1;
461 $$ = make_redirection (source, r_input_direction, redir, REDIR_VARASSIGN);
463 | GREATER_GREATER WORD
467 $$ = make_redirection (source, r_appending_to, redir, 0);
469 | NUMBER GREATER_GREATER WORD
473 $$ = make_redirection (source, r_appending_to, redir, 0);
475 | REDIR_WORD GREATER_GREATER WORD
477 source.filename = $1;
479 $$ = make_redirection (source, r_appending_to, redir, REDIR_VARASSIGN);
485 $$ = make_redirection (source, r_output_force, redir, 0);
487 | NUMBER GREATER_BAR WORD
491 $$ = make_redirection (source, r_output_force, redir, 0);
493 | REDIR_WORD GREATER_BAR WORD
495 source.filename = $1;
497 $$ = make_redirection (source, r_output_force, redir, REDIR_VARASSIGN);
503 $$ = make_redirection (source, r_input_output, redir, 0);
505 | NUMBER LESS_GREATER WORD
509 $$ = make_redirection (source, r_input_output, redir, 0);
511 | REDIR_WORD LESS_GREATER WORD
513 source.filename = $1;
515 $$ = make_redirection (source, r_input_output, redir, REDIR_VARASSIGN);
521 $$ = make_redirection (source, r_reading_until, redir, 0);
522 redir_stack[need_here_doc++] = $$;
524 | NUMBER LESS_LESS WORD
528 $$ = make_redirection (source, r_reading_until, redir, 0);
529 redir_stack[need_here_doc++] = $$;
531 | REDIR_WORD LESS_LESS WORD
533 source.filename = $1;
535 $$ = make_redirection (source, r_reading_until, redir, REDIR_VARASSIGN);
536 redir_stack[need_here_doc++] = $$;
538 | LESS_LESS_MINUS WORD
542 $$ = make_redirection (source, r_deblank_reading_until, redir, 0);
543 redir_stack[need_here_doc++] = $$;
545 | NUMBER LESS_LESS_MINUS WORD
549 $$ = make_redirection (source, r_deblank_reading_until, redir, 0);
550 redir_stack[need_here_doc++] = $$;
552 | REDIR_WORD LESS_LESS_MINUS WORD
554 source.filename = $1;
556 $$ = make_redirection (source, r_deblank_reading_until, redir, REDIR_VARASSIGN);
557 redir_stack[need_here_doc++] = $$;
559 | LESS_LESS_LESS WORD
563 $$ = make_redirection (source, r_reading_string, redir, 0);
565 | NUMBER LESS_LESS_LESS WORD
569 $$ = make_redirection (source, r_reading_string, redir, 0);
571 | REDIR_WORD LESS_LESS_LESS WORD
573 source.filename = $1;
575 $$ = make_redirection (source, r_reading_string, redir, REDIR_VARASSIGN);
581 $$ = make_redirection (source, r_duplicating_input, redir, 0);
583 | NUMBER LESS_AND NUMBER
587 $$ = make_redirection (source, r_duplicating_input, redir, 0);
589 | REDIR_WORD LESS_AND NUMBER
591 source.filename = $1;
593 $$ = make_redirection (source, r_duplicating_input, redir, REDIR_VARASSIGN);
599 $$ = make_redirection (source, r_duplicating_output, redir, 0);
601 | NUMBER GREATER_AND NUMBER
605 $$ = make_redirection (source, r_duplicating_output, redir, 0);
607 | REDIR_WORD GREATER_AND NUMBER
609 source.filename = $1;
611 $$ = make_redirection (source, r_duplicating_output, redir, REDIR_VARASSIGN);
617 $$ = make_redirection (source, r_duplicating_input_word, redir, 0);
619 | NUMBER LESS_AND WORD
623 $$ = make_redirection (source, r_duplicating_input_word, redir, 0);
625 | REDIR_WORD LESS_AND WORD
627 source.filename = $1;
629 $$ = make_redirection (source, r_duplicating_input_word, redir, REDIR_VARASSIGN);
635 $$ = make_redirection (source, r_duplicating_output_word, redir, 0);
637 | NUMBER GREATER_AND WORD
641 $$ = make_redirection (source, r_duplicating_output_word, redir, 0);
643 | REDIR_WORD GREATER_AND WORD
645 source.filename = $1;
647 $$ = make_redirection (source, r_duplicating_output_word, redir, REDIR_VARASSIGN);
653 $$ = make_redirection (source, r_close_this, redir, 0);
655 | NUMBER GREATER_AND '-'
659 $$ = make_redirection (source, r_close_this, redir, 0);
661 | REDIR_WORD GREATER_AND '-'
663 source.filename = $1;
665 $$ = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
671 $$ = make_redirection (source, r_close_this, redir, 0);
673 | NUMBER LESS_AND '-'
677 $$ = make_redirection (source, r_close_this, redir, 0);
679 | REDIR_WORD LESS_AND '-'
681 source.filename = $1;
683 $$ = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
689 $$ = make_redirection (source, r_err_and_out, redir, 0);
691 | AND_GREATER_GREATER WORD
695 $$ = make_redirection (source, r_append_err_and_out, redir, 0);
699 simple_command_element: WORD
700 { $$.word = $1; $$.redirect = 0; }
702 { $$.word = $1; $$.redirect = 0; }
704 { $$.redirect = $1; $$.word = 0; }
707 redirection_list: redirection
711 | redirection_list redirection
713 register REDIRECT *t;
715 for (t = $1; t->next; t = t->next)
722 simple_command: simple_command_element
723 { $$ = make_simple_command ($1, (COMMAND *)NULL); }
724 | simple_command simple_command_element
725 { $$ = make_simple_command ($2, $1); }
728 command: simple_command
729 { $$ = clean_simple_command ($1); }
732 | shell_command redirection_list
739 register REDIRECT *t;
740 for (t = tc->redirects; t->next; t = t->next)
754 shell_command: for_command
758 | WHILE compound_list DO compound_list DONE
759 { $$ = make_while_command ($2, $4); }
760 | UNTIL compound_list DO compound_list DONE
761 { $$ = make_until_command ($2, $4); }
778 for_command: FOR WORD newline_list DO compound_list DONE
780 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
781 if (word_top > 0) word_top--;
783 | FOR WORD newline_list '{' compound_list '}'
785 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
786 if (word_top > 0) word_top--;
788 | FOR WORD ';' newline_list DO compound_list DONE
790 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
791 if (word_top > 0) word_top--;
793 | FOR WORD ';' newline_list '{' compound_list '}'
795 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
796 if (word_top > 0) word_top--;
798 | FOR WORD newline_list IN word_list list_terminator newline_list DO compound_list DONE
800 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
801 if (word_top > 0) word_top--;
803 | FOR WORD newline_list IN word_list list_terminator newline_list '{' compound_list '}'
805 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
806 if (word_top > 0) word_top--;
808 | FOR WORD newline_list IN list_terminator newline_list DO compound_list DONE
810 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
811 if (word_top > 0) word_top--;
813 | FOR WORD newline_list IN list_terminator newline_list '{' compound_list '}'
815 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
816 if (word_top > 0) word_top--;
820 arith_for_command: FOR ARITH_FOR_EXPRS list_terminator newline_list DO compound_list DONE
822 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
823 if (word_top > 0) word_top--;
825 | FOR ARITH_FOR_EXPRS list_terminator newline_list '{' compound_list '}'
827 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
828 if (word_top > 0) word_top--;
830 | FOR ARITH_FOR_EXPRS DO compound_list DONE
832 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
833 if (word_top > 0) word_top--;
835 | FOR ARITH_FOR_EXPRS '{' compound_list '}'
837 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
838 if (word_top > 0) word_top--;
842 select_command: SELECT WORD newline_list DO list DONE
844 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
845 if (word_top > 0) word_top--;
847 | SELECT WORD newline_list '{' list '}'
849 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
850 if (word_top > 0) word_top--;
852 | SELECT WORD ';' newline_list DO list DONE
854 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
855 if (word_top > 0) word_top--;
857 | SELECT WORD ';' newline_list '{' list '}'
859 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
860 if (word_top > 0) word_top--;
862 | SELECT WORD newline_list IN word_list list_terminator newline_list DO list DONE
864 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
865 if (word_top > 0) word_top--;
867 | SELECT WORD newline_list IN word_list list_terminator newline_list '{' list '}'
869 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
870 if (word_top > 0) word_top--;
874 case_command: CASE WORD newline_list IN newline_list ESAC
876 $$ = make_case_command ($2, (PATTERN_LIST *)NULL, word_lineno[word_top]);
877 if (word_top > 0) word_top--;
879 | CASE WORD newline_list IN case_clause_sequence newline_list ESAC
881 $$ = make_case_command ($2, $5, word_lineno[word_top]);
882 if (word_top > 0) word_top--;
884 | CASE WORD newline_list IN case_clause ESAC
886 $$ = make_case_command ($2, $5, word_lineno[word_top]);
887 if (word_top > 0) word_top--;
891 function_def: WORD '(' ')' newline_list function_body
892 { $$ = make_function_def ($1, $5, function_dstart, function_bstart); }
894 | FUNCTION WORD '(' ')' newline_list function_body
895 { $$ = make_function_def ($2, $6, function_dstart, function_bstart); }
897 | FUNCTION WORD newline_list function_body
898 { $$ = make_function_def ($2, $4, function_dstart, function_bstart); }
901 function_body: shell_command
903 | shell_command redirection_list
908 /* According to Posix.2 3.9.5, redirections
909 specified after the body of a function should
910 be attached to the function and performed when
911 the function is executed, not as part of the
912 function definition command. */
913 /* XXX - I don't think it matters, but we might
914 want to change this in the future to avoid
915 problems differentiating between a function
916 definition with a redirection and a function
917 definition containing a single command with a
918 redirection. The two are semantically equivalent,
919 though -- the only difference is in how the
920 command printing code displays the redirections. */
923 register REDIRECT *t;
924 for (t = tc->redirects; t->next; t = t->next)
934 subshell: '(' compound_list ')'
936 $$ = make_subshell_command ($2);
937 $$->flags |= CMD_WANT_SUBSHELL;
941 coproc: COPROC shell_command
943 $$ = make_coproc_command ("COPROC", $2);
944 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
946 | COPROC shell_command redirection_list
953 register REDIRECT *t;
954 for (t = tc->redirects; t->next; t = t->next)
960 $$ = make_coproc_command ("COPROC", $2);
961 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
963 | COPROC WORD shell_command
965 $$ = make_coproc_command ($2->word, $3);
966 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
968 | COPROC WORD shell_command redirection_list
975 register REDIRECT *t;
976 for (t = tc->redirects; t->next; t = t->next)
982 $$ = make_coproc_command ($2->word, $3);
983 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
985 | COPROC simple_command
987 $$ = make_coproc_command ("COPROC", clean_simple_command ($2));
988 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
992 if_command: IF compound_list THEN compound_list FI
993 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
994 | IF compound_list THEN compound_list ELSE compound_list FI
995 { $$ = make_if_command ($2, $4, $6); }
996 | IF compound_list THEN compound_list elif_clause FI
997 { $$ = make_if_command ($2, $4, $5); }
1001 group_command: '{' compound_list '}'
1002 { $$ = make_group_command ($2); }
1005 arith_command: ARITH_CMD
1006 { $$ = make_arith_command ($1); }
1009 cond_command: COND_START COND_CMD COND_END
1013 elif_clause: ELIF compound_list THEN compound_list
1014 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
1015 | ELIF compound_list THEN compound_list ELSE compound_list
1016 { $$ = make_if_command ($2, $4, $6); }
1017 | ELIF compound_list THEN compound_list elif_clause
1018 { $$ = make_if_command ($2, $4, $5); }
1021 case_clause: pattern_list
1022 | case_clause_sequence pattern_list
1023 { $2->next = $1; $$ = $2; }
1026 pattern_list: newline_list pattern ')' compound_list
1027 { $$ = make_pattern_list ($2, $4); }
1028 | newline_list pattern ')' newline_list
1029 { $$ = make_pattern_list ($2, (COMMAND *)NULL); }
1030 | newline_list '(' pattern ')' compound_list
1031 { $$ = make_pattern_list ($3, $5); }
1032 | newline_list '(' pattern ')' newline_list
1033 { $$ = make_pattern_list ($3, (COMMAND *)NULL); }
1036 case_clause_sequence: pattern_list SEMI_SEMI
1038 | case_clause_sequence pattern_list SEMI_SEMI
1039 { $2->next = $1; $$ = $2; }
1040 | pattern_list SEMI_AND
1041 { $1->flags |= CASEPAT_FALLTHROUGH; $$ = $1; }
1042 | case_clause_sequence pattern_list SEMI_AND
1043 { $2->flags |= CASEPAT_FALLTHROUGH; $2->next = $1; $$ = $2; }
1044 | pattern_list SEMI_SEMI_AND
1045 { $1->flags |= CASEPAT_TESTNEXT; $$ = $1; }
1046 | case_clause_sequence pattern_list SEMI_SEMI_AND
1047 { $2->flags |= CASEPAT_TESTNEXT; $2->next = $1; $$ = $2; }
1051 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
1053 { $$ = make_word_list ($3, $1); }
1056 /* A list allows leading or trailing newlines and
1057 newlines as operators (equivalent to semicolons).
1058 It must end with a newline or semicolon.
1059 Lists are used within commands such as if, for, while. */
1061 list: newline_list list0
1065 gather_here_documents ();
1070 | newline_list list1
1076 list0: list1 '\n' newline_list
1077 | list1 '&' newline_list
1079 if ($1->type == cm_connection)
1080 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
1082 $$ = command_connect ($1, (COMMAND *)NULL, '&');
1084 | list1 ';' newline_list
1088 list1: list1 AND_AND newline_list list1
1089 { $$ = command_connect ($1, $4, AND_AND); }
1090 | list1 OR_OR newline_list list1
1091 { $$ = command_connect ($1, $4, OR_OR); }
1092 | list1 '&' newline_list list1
1094 if ($1->type == cm_connection)
1095 $$ = connect_async_list ($1, $4, '&');
1097 $$ = command_connect ($1, $4, '&');
1099 | list1 ';' newline_list list1
1100 { $$ = command_connect ($1, $4, ';'); }
1101 | list1 '\n' newline_list list1
1102 { $$ = command_connect ($1, $4, ';'); }
1107 simple_list_terminator: '\n'
1111 list_terminator:'\n'
1123 /* A simple_list is a list that contains no significant newlines
1124 and no leading or trailing newlines. Newlines are allowed
1125 only following operators, where they are not significant.
1127 This is what an inputunit consists of. */
1129 simple_list: simple_list1
1133 gather_here_documents ();
1134 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1136 global_command = $1;
1137 eof_encountered = 0;
1138 rewind_input_string ();
1144 if ($1->type == cm_connection)
1145 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
1147 $$ = command_connect ($1, (COMMAND *)NULL, '&');
1149 gather_here_documents ();
1150 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1152 global_command = $1;
1153 eof_encountered = 0;
1154 rewind_input_string ();
1162 gather_here_documents ();
1163 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1165 global_command = $1;
1166 eof_encountered = 0;
1167 rewind_input_string ();
1173 simple_list1: simple_list1 AND_AND newline_list simple_list1
1174 { $$ = command_connect ($1, $4, AND_AND); }
1175 | simple_list1 OR_OR newline_list simple_list1
1176 { $$ = command_connect ($1, $4, OR_OR); }
1177 | simple_list1 '&' simple_list1
1179 if ($1->type == cm_connection)
1180 $$ = connect_async_list ($1, $3, '&');
1182 $$ = command_connect ($1, $3, '&');
1184 | simple_list1 ';' simple_list1
1185 { $$ = command_connect ($1, $3, ';'); }
1191 pipeline_command: pipeline
1193 | BANG pipeline_command
1196 $2->flags ^= CMD_INVERT_RETURN; /* toggle */
1199 | timespec pipeline_command
1205 | timespec list_terminator
1209 /* Boy, this is unclean. `time' by itself can
1210 time a null command. We cheat and push a
1211 newline back if the list_terminator was a newline
1212 to avoid the double-newline problem (one to
1213 terminate this, one to terminate the command) */
1216 $$ = make_simple_command (x, (COMMAND *)NULL);
1218 /* XXX - let's cheat and push a newline back */
1220 token_to_read = '\n';
1222 | BANG list_terminator
1226 /* This is just as unclean. Posix says that `!'
1227 by itself should be equivalent to `false'.
1229 newline back if the list_terminator was a newline
1230 to avoid the double-newline problem (one to
1231 terminate this, one to terminate the command) */
1234 $$ = make_simple_command (x, (COMMAND *)NULL);
1235 $$->flags |= CMD_INVERT_RETURN;
1236 /* XXX - let's cheat and push a newline back */
1238 token_to_read = '\n';
1242 pipeline: pipeline '|' newline_list pipeline
1243 { $$ = command_connect ($1, $4, '|'); }
1244 | pipeline BAR_AND newline_list pipeline
1246 /* Make cmd1 |& cmd2 equivalent to cmd1 2>&1 | cmd2 */
1251 tc = $1->type == cm_simple ? (COMMAND *)$1->value.Simple : $1;
1254 r = make_redirection (sd, r_duplicating_output, rd, 0);
1257 register REDIRECT *t;
1258 for (t = tc->redirects; t->next; t = t->next)
1265 $$ = command_connect ($1, $4, '|');
1272 { $$ = CMD_TIME_PIPELINE; }
1274 { $$ = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
1275 | TIME TIMEOPT TIMEIGN
1276 { $$ = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
1280 /* Initial size to allocate for tokens, and the
1281 amount to grow them by. */
1282 #define TOKEN_DEFAULT_INITIAL_SIZE 496
1283 #define TOKEN_DEFAULT_GROW_SIZE 512
1285 /* Should we call prompt_again? */
1286 #define SHOULD_PROMPT() \
1287 (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
1290 # define expanding_alias() (pushed_string_list && pushed_string_list->expander)
1292 # define expanding_alias() 0
1295 /* Global var is non-zero when end of file has been reached. */
1296 int EOF_Reached = 0;
1309 /* yy_getc () returns the next available character from input or EOF.
1310 yy_ungetc (c) makes `c' the next character to read.
1311 init_yy_io (get, unget, type, location) makes the function GET the
1312 installed function for getting the next character, makes UNGET the
1313 installed function for un-getting a character, sets the type of stream
1314 (either string or file) from TYPE, and makes LOCATION point to where
1315 the input is coming from. */
1317 /* Unconditionally returns end-of-file. */
1324 /* Variable containing the current get and unget functions.
1325 See ./input.h for a clearer description. */
1326 BASH_INPUT bash_input;
1328 /* Set all of the fields in BASH_INPUT to NULL. Free bash_input.name if it
1329 is non-null, avoiding a memory leak. */
1331 initialize_bash_input ()
1333 bash_input.type = st_none;
1334 FREE (bash_input.name);
1335 bash_input.name = (char *)NULL;
1336 bash_input.location.file = (FILE *)NULL;
1337 bash_input.location.string = (char *)NULL;
1338 bash_input.getter = (sh_cget_func_t *)NULL;
1339 bash_input.ungetter = (sh_cunget_func_t *)NULL;
1342 /* Set the contents of the current bash input stream from
1343 GET, UNGET, TYPE, NAME, and LOCATION. */
1345 init_yy_io (get, unget, type, name, location)
1346 sh_cget_func_t *get;
1347 sh_cunget_func_t *unget;
1348 enum stream_type type;
1350 INPUT_STREAM location;
1352 bash_input.type = type;
1353 FREE (bash_input.name);
1354 bash_input.name = name ? savestring (name) : (char *)NULL;
1358 memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
1360 bash_input.location = location;
1362 bash_input.getter = get;
1363 bash_input.ungetter = unget;
1369 return (bash_input.name ? bash_input.name : "stdin");
1372 /* Call this to get the next character of input. */
1376 return (*(bash_input.getter)) ();
1379 /* Call this to unget C. That is, to make C the next character
1385 return (*(bash_input.ungetter)) (c);
1388 #if defined (BUFFERED_INPUT)
1389 #ifdef INCLUDE_UNUSED
1391 input_file_descriptor ()
1393 switch (bash_input.type)
1396 return (fileno (bash_input.location.file));
1398 return (bash_input.location.buffered_fd);
1401 return (fileno (stdin));
1405 #endif /* BUFFERED_INPUT */
1407 /* **************************************************************** */
1409 /* Let input be read from readline (). */
1411 /* **************************************************************** */
1413 #if defined (READLINE)
1414 char *current_readline_prompt = (char *)NULL;
1415 char *current_readline_line = (char *)NULL;
1416 int current_readline_line_index = 0;
1421 SigHandler *old_sigint;
1425 if (!current_readline_line)
1427 if (!bash_readline_initialized)
1428 initialize_readline ();
1430 #if defined (JOB_CONTROL)
1432 give_terminal_to (shell_pgrp, 0);
1433 #endif /* JOB_CONTROL */
1435 old_sigint = (SigHandler *)IMPOSSIBLE_TRAP_HANDLER;
1436 if (signal_is_ignored (SIGINT) == 0)
1438 interrupt_immediately++;
1439 old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
1441 terminate_immediately = 1;
1443 current_readline_line = readline (current_readline_prompt ?
1444 current_readline_prompt : "");
1446 terminate_immediately = 0;
1447 if (signal_is_ignored (SIGINT) == 0)
1449 interrupt_immediately--;
1450 if (old_sigint != IMPOSSIBLE_TRAP_HANDLER)
1451 set_signal_handler (SIGINT, old_sigint);
1455 /* Reset the prompt to the decoded value of prompt_string_pointer. */
1456 reset_readline_prompt ();
1459 if (current_readline_line == 0)
1462 current_readline_line_index = 0;
1463 line_len = strlen (current_readline_line);
1465 current_readline_line = (char *)xrealloc (current_readline_line, 2 + line_len);
1466 current_readline_line[line_len++] = '\n';
1467 current_readline_line[line_len] = '\0';
1470 if (current_readline_line[current_readline_line_index] == 0)
1472 free (current_readline_line);
1473 current_readline_line = (char *)NULL;
1474 return (yy_readline_get ());
1478 c = current_readline_line[current_readline_line_index++];
1484 yy_readline_unget (c)
1487 if (current_readline_line_index && current_readline_line)
1488 current_readline_line[--current_readline_line_index] = c;
1493 with_input_from_stdin ()
1495 INPUT_STREAM location;
1497 if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
1499 location.string = current_readline_line;
1500 init_yy_io (yy_readline_get, yy_readline_unget,
1501 st_stdin, "readline stdin", location);
1505 #else /* !READLINE */
1508 with_input_from_stdin ()
1510 with_input_from_stream (stdin, "stdin");
1512 #endif /* !READLINE */
1514 /* **************************************************************** */
1516 /* Let input come from STRING. STRING is zero terminated. */
1518 /* **************************************************************** */
1523 register char *string;
1524 register unsigned char c;
1526 string = bash_input.location.string;
1528 /* If the string doesn't exist, or is empty, EOF found. */
1529 if (string && *string)
1532 bash_input.location.string = string;
1543 *(--bash_input.location.string) = c;
1548 with_input_from_string (string, name)
1552 INPUT_STREAM location;
1554 location.string = string;
1555 init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
1558 /* Count the number of characters we've consumed from bash_input.location.string
1559 and read into shell_input_line, but have not returned from shell_getc.
1560 That is the true input location. Rewind bash_input.location.string by
1561 that number of characters, so it points to the last character actually
1562 consumed by the parser. */
1564 rewind_input_string ()
1568 /* number of unconsumed characters in the input -- XXX need to take newlines
1569 into account, e.g., $(...\n) */
1570 xchars = shell_input_line_len - shell_input_line_index;
1571 if (bash_input.location.string[-1] == '\n')
1574 /* XXX - how to reflect bash_input.location.string back to string passed to
1575 parse_and_execute or xparse_dolparen? xparse_dolparen needs to know how
1576 far into the string we parsed. parse_and_execute knows where bash_input.
1577 location.string is, and how far from orig_string that is -- that's the
1578 number of characters the command consumed. */
1580 /* bash_input.location.string - xchars should be where we parsed to */
1581 /* need to do more validation on xchars value for sanity -- test cases. */
1582 bash_input.location.string -= xchars;
1585 /* **************************************************************** */
1587 /* Let input come from STREAM. */
1589 /* **************************************************************** */
1591 /* These two functions used to test the value of the HAVE_RESTARTABLE_SYSCALLS
1592 define, and just use getc/ungetc if it was defined, but since bash
1593 installs its signal handlers without the SA_RESTART flag, some signals
1594 (like SIGCHLD, SIGWINCH, etc.) received during a read(2) will not cause
1595 the read to be restarted. We need to restart it ourselves. */
1603 if (bash_input.location.file)
1607 interrupt_immediately++;
1608 terminate_immediately++;
1610 result = getc_with_restart (bash_input.location.file);
1613 interrupt_immediately--;
1614 terminate_immediately--;
1624 return (ungetc_with_restart (c, bash_input.location.file));
1628 with_input_from_stream (stream, name)
1632 INPUT_STREAM location;
1634 location.file = stream;
1635 init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
1638 typedef struct stream_saver {
1639 struct stream_saver *next;
1640 BASH_INPUT bash_input;
1642 #if defined (BUFFERED_INPUT)
1643 BUFFERED_STREAM *bstream;
1644 #endif /* BUFFERED_INPUT */
1647 /* The globally known line number. */
1648 int line_number = 0;
1650 /* The line number offset set by assigning to LINENO. Not currently used. */
1651 int line_number_base = 0;
1653 #if defined (COND_COMMAND)
1654 static int cond_lineno;
1655 static int cond_token;
1658 STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
1661 push_stream (reset_lineno)
1664 STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
1666 xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
1668 #if defined (BUFFERED_INPUT)
1669 saver->bstream = (BUFFERED_STREAM *)NULL;
1670 /* If we have a buffered stream, clear out buffers[fd]. */
1671 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1672 saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
1673 (BUFFERED_STREAM *)NULL);
1674 #endif /* BUFFERED_INPUT */
1676 saver->line = line_number;
1677 bash_input.name = (char *)NULL;
1678 saver->next = stream_list;
1679 stream_list = saver;
1692 STREAM_SAVER *saver = stream_list;
1695 stream_list = stream_list->next;
1697 init_yy_io (saver->bash_input.getter,
1698 saver->bash_input.ungetter,
1699 saver->bash_input.type,
1700 saver->bash_input.name,
1701 saver->bash_input.location);
1703 #if defined (BUFFERED_INPUT)
1704 /* If we have a buffered stream, restore buffers[fd]. */
1705 /* If the input file descriptor was changed while this was on the
1706 save stack, update the buffered fd to the new file descriptor and
1707 re-establish the buffer <-> bash_input fd correspondence. */
1708 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1710 if (bash_input_fd_changed)
1712 bash_input_fd_changed = 0;
1713 if (default_buffered_input >= 0)
1715 bash_input.location.buffered_fd = default_buffered_input;
1716 saver->bstream->b_fd = default_buffered_input;
1717 SET_CLOSE_ON_EXEC (default_buffered_input);
1720 /* XXX could free buffered stream returned as result here. */
1721 set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
1723 #endif /* BUFFERED_INPUT */
1725 line_number = saver->line;
1727 FREE (saver->bash_input.name);
1732 /* Return 1 if a stream of type TYPE is saved on the stack. */
1734 stream_on_stack (type)
1735 enum stream_type type;
1737 register STREAM_SAVER *s;
1739 for (s = stream_list; s; s = s->next)
1740 if (s->bash_input.type == type)
1745 /* Save the current token state and return it in a malloced array. */
1751 ret = (int *)xmalloc (4 * sizeof (int));
1752 ret[0] = last_read_token;
1753 ret[1] = token_before_that;
1754 ret[2] = two_tokens_ago;
1755 ret[3] = current_token;
1760 restore_token_state (ts)
1765 last_read_token = ts[0];
1766 token_before_that = ts[1];
1767 two_tokens_ago = ts[2];
1768 current_token = ts[3];
1772 * This is used to inhibit alias expansion and reserved word recognition
1773 * inside case statement pattern lists. A `case statement pattern list' is:
1775 * everything between the `in' in a `case word in' and the next ')'
1777 * everything between a `;;' and the next `)' or `esac'
1780 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1782 #define END_OF_ALIAS 0
1785 * Pseudo-global variables used in implementing token-wise alias expansion.
1789 * Pushing and popping strings. This works together with shell_getc to
1790 * implement alias expansion on a per-token basis.
1793 typedef struct string_saver {
1794 struct string_saver *next;
1795 int expand_alias; /* Value to set expand_alias to when string is popped. */
1798 alias_t *expander; /* alias that caused this line to be pushed. */
1800 int saved_line_size, saved_line_index, saved_line_terminator;
1803 STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
1806 * Push the current shell_input_line onto a stack of such lines and make S
1807 * the current input. Used when expanding aliases. EXPAND is used to set
1808 * the value of expand_next_token when the string is popped, so that the
1809 * word after the alias in the original line is handled correctly when the
1810 * alias expands to multiple words. TOKEN is the token that was expanded
1811 * into S; it is saved and used to prevent infinite recursive expansion.
1814 push_string (s, expand, ap)
1819 STRING_SAVER *temp = (STRING_SAVER *)xmalloc (sizeof (STRING_SAVER));
1821 temp->expand_alias = expand;
1822 temp->saved_line = shell_input_line;
1823 temp->saved_line_size = shell_input_line_size;
1824 temp->saved_line_index = shell_input_line_index;
1825 temp->saved_line_terminator = shell_input_line_terminator;
1827 temp->expander = ap;
1829 temp->next = pushed_string_list;
1830 pushed_string_list = temp;
1834 ap->flags |= AL_BEINGEXPANDED;
1837 shell_input_line = s;
1838 shell_input_line_size = strlen (s);
1839 shell_input_line_index = 0;
1840 shell_input_line_terminator = '\0';
1842 parser_state &= ~PST_ALEXPNEXT; /* XXX */
1845 set_line_mbstate ();
1849 * Make the top of the pushed_string stack be the current shell input.
1850 * Only called when there is something on the stack. Called from shell_getc
1851 * when it thinks it has consumed the string generated by an alias expansion
1852 * and needs to return to the original input line.
1859 FREE (shell_input_line);
1860 shell_input_line = pushed_string_list->saved_line;
1861 shell_input_line_index = pushed_string_list->saved_line_index;
1862 shell_input_line_size = pushed_string_list->saved_line_size;
1863 shell_input_line_terminator = pushed_string_list->saved_line_terminator;
1865 if (pushed_string_list->expand_alias)
1866 parser_state |= PST_ALEXPNEXT;
1868 parser_state &= ~PST_ALEXPNEXT;
1870 t = pushed_string_list;
1871 pushed_string_list = pushed_string_list->next;
1875 t->expander->flags &= ~AL_BEINGEXPANDED;
1880 set_line_mbstate ();
1886 register STRING_SAVER *t, *t1;
1888 for (t = pushed_string_list; t; )
1891 FREE (t->saved_line);
1894 t->expander->flags &= ~AL_BEINGEXPANDED;
1899 pushed_string_list = (STRING_SAVER *)NULL;
1902 #endif /* ALIAS || DPAREN_ARITHMETIC */
1905 free_pushed_string_input ()
1907 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1908 free_string_list ();
1912 /* Return a line of text, taken from wherever yylex () reads input.
1913 If there is no more input, then we return NULL. If REMOVE_QUOTED_NEWLINE
1914 is non-zero, we remove unquoted \<newline> pairs. This is used by
1915 read_secondary_line to read here documents. */
1917 read_a_line (remove_quoted_newline)
1918 int remove_quoted_newline;
1920 static char *line_buffer = (char *)NULL;
1921 static int buffer_size = 0;
1922 int indx, c, peekc, pass_next;
1924 #if defined (READLINE)
1925 if (no_line_editing && SHOULD_PROMPT ())
1927 if (SHOULD_PROMPT ())
1931 pass_next = indx = 0;
1934 /* Allow immediate exit if interrupted during input. */
1939 /* Ignore null bytes in input. */
1943 internal_warning ("read_a_line: ignored null byte in input");
1948 /* If there is no more input, then we return NULL. */
1951 if (interactive && bash_input.type == st_stream)
1954 return ((char *)NULL);
1958 /* `+2' in case the final character in the buffer is a newline. */
1959 RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
1961 /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
1962 here document with an unquoted delimiter. In this case,
1963 the line will be expanded as if it were in double quotes.
1964 We allow a backslash to escape the next character, but we
1965 need to treat the backslash specially only if a backslash
1966 quoting a backslash-newline pair appears in the line. */
1969 line_buffer[indx++] = c;
1972 else if (c == '\\' && remove_quoted_newline)
1979 continue; /* Make the unquoted \<newline> pair disappear. */
1985 line_buffer[indx++] = c; /* Preserve the backslash. */
1989 line_buffer[indx++] = c;
1993 line_buffer[indx] = '\0';
1994 return (line_buffer);
1999 /* Return a line as in read_a_line (), but insure that the prompt is
2000 the secondary prompt. This is used to read the lines of a here
2001 document. REMOVE_QUOTED_NEWLINE is non-zero if we should remove
2002 newlines quoted with backslashes while reading the line. It is
2003 non-zero unless the delimiter of the here document was quoted. */
2005 read_secondary_line (remove_quoted_newline)
2006 int remove_quoted_newline;
2011 prompt_string_pointer = &ps2_prompt;
2012 if (SHOULD_PROMPT())
2014 ret = read_a_line (remove_quoted_newline);
2015 #if defined (HISTORY)
2016 if (ret && remember_on_history && (parser_state & PST_HEREDOC))
2018 /* To make adding the the here-document body right, we need to rely
2019 on history_delimiting_chars() returning \n for the first line of
2020 the here-document body and the null string for the second and
2021 subsequent lines, so we avoid double newlines.
2022 current_command_line_count == 2 for the first line of the body. */
2024 current_command_line_count++;
2025 maybe_add_history (ret);
2027 #endif /* HISTORY */
2031 /* **************************************************************** */
2035 /* **************************************************************** */
2037 /* Reserved words. These are only recognized as the first word of a
2039 STRING_INT_ALIST word_token_alist[] = {
2048 #if defined (SELECT_COMMAND)
2049 { "select", SELECT },
2056 { "function", FUNCTION },
2057 #if defined (COMMAND_TIMING)
2063 #if defined (COND_COMMAND)
2064 { "[[", COND_START },
2067 #if defined (COPROCESS_SUPPORT)
2068 { "coproc", COPROC },
2073 /* other tokens that can be returned by read_token() */
2074 STRING_INT_ALIST other_token_alist[] = {
2075 /* Multiple-character tokens with special values */
2080 { ">>", GREATER_GREATER },
2081 { "<<", LESS_LESS },
2083 { ">&", GREATER_AND },
2084 { ";;", SEMI_SEMI },
2086 { ";;&", SEMI_SEMI_AND },
2087 { "<<-", LESS_LESS_MINUS },
2088 { "<<<", LESS_LESS_LESS },
2089 { "&>", AND_GREATER },
2090 { "&>>", AND_GREATER_GREATER },
2091 { "<>", LESS_GREATER },
2092 { ">|", GREATER_BAR },
2094 { "EOF", yacc_EOF },
2095 /* Tokens whose value is the character itself */
2106 { "newline", '\n' },
2110 /* others not listed here:
2111 WORD look at yylval.word
2112 ASSIGNMENT_WORD look at yylval.word
2113 NUMBER look at yylval.number
2114 ARITH_CMD look at yylval.word_list
2115 ARITH_FOR_EXPRS look at yylval.word_list
2116 COND_CMD look at yylval.command
2119 /* These are used by read_token_word, but appear up here so that shell_getc
2120 can use them to decide when to add otherwise blank lines to the history. */
2122 /* The primary delimiter stack. */
2123 struct dstack dstack = { (char *)NULL, 0, 0 };
2125 /* A temporary delimiter stack to be used when decoding prompt strings.
2126 This is needed because command substitutions in prompt strings (e.g., PS2)
2127 can screw up the parser's quoting state. */
2128 static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
2130 /* Macro for accessing the top delimiter on the stack. Returns the
2131 delimiter or zero if none. */
2132 #define current_delimiter(ds) \
2133 (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
2135 #define push_delimiter(ds, character) \
2138 if (ds.delimiter_depth + 2 > ds.delimiter_space) \
2139 ds.delimiters = (char *)xrealloc \
2140 (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
2141 ds.delimiters[ds.delimiter_depth] = character; \
2142 ds.delimiter_depth++; \
2146 #define pop_delimiter(ds) ds.delimiter_depth--
2148 /* Return the next shell input character. This always reads characters
2149 from shell_input_line; when that line is exhausted, it is time to
2150 read the next line. This is called by read_token when the shell is
2151 processing normal command input. */
2153 /* This implements one-character lookahead/lookbehind across physical input
2154 lines, to avoid something being lost because it's pushed back with
2155 shell_ungetc when we're at the start of a line. */
2156 static int eol_ungetc_lookahead = 0;
2159 shell_getc (remove_quoted_newline)
2160 int remove_quoted_newline;
2168 if (sigwinch_received)
2170 sigwinch_received = 0;
2171 get_new_window_size (0, (int *)0, (int *)0);
2174 if (eol_ungetc_lookahead)
2176 c = eol_ungetc_lookahead;
2177 eol_ungetc_lookahead = 0;
2181 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2182 /* If shell_input_line[shell_input_line_index] == 0, but there is
2183 something on the pushed list of strings, then we don't want to go
2184 off and get another line. We let the code down below handle it. */
2186 if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
2187 (pushed_string_list == (STRING_SAVER *)NULL)))
2188 #else /* !ALIAS && !DPAREN_ARITHMETIC */
2189 if (!shell_input_line || !shell_input_line[shell_input_line_index])
2190 #endif /* !ALIAS && !DPAREN_ARITHMETIC */
2196 /* Allow immediate exit if interrupted during input. */
2200 shell_input_line_terminator = 0;
2202 /* If the shell is interatctive, but not currently printing a prompt
2203 (interactive_shell && interactive == 0), we don't want to print
2204 notifies or cleanup the jobs -- we want to defer it until we do
2205 print the next prompt. */
2206 if (interactive_shell == 0 || SHOULD_PROMPT())
2208 #if defined (JOB_CONTROL)
2209 /* This can cause a problem when reading a command as the result
2210 of a trap, when the trap is called from flush_child. This call
2211 had better not cause jobs to disappear from the job table in
2212 that case, or we will have big trouble. */
2213 notify_and_cleanup ();
2214 #else /* !JOB_CONTROL */
2215 cleanup_dead_jobs ();
2216 #endif /* !JOB_CONTROL */
2219 #if defined (READLINE)
2220 if (no_line_editing && SHOULD_PROMPT())
2222 if (SHOULD_PROMPT())
2226 if (bash_input.type == st_stream)
2233 /* Allow immediate exit if interrupted during input. */
2239 internal_warning ("shell_getc: ignored null byte in input");
2244 RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
2248 if (bash_input.type == st_stream)
2252 shell_input_line_terminator = EOF;
2254 shell_input_line[i] = '\0';
2258 shell_input_line[i++] = c;
2262 shell_input_line[--i] = '\0';
2263 current_command_line_count++;
2268 shell_input_line_index = 0;
2269 shell_input_line_len = i; /* == strlen (shell_input_line) */
2271 set_line_mbstate ();
2273 #if defined (HISTORY)
2274 if (remember_on_history && shell_input_line && shell_input_line[0])
2277 # if defined (BANG_HISTORY)
2280 /* If the current delimiter is a single quote, we should not be
2281 performing history expansion, even if we're on a different
2282 line from the original single quote. */
2283 old_hist = history_expansion_inhibited;
2284 if (current_delimiter (dstack) == '\'')
2285 history_expansion_inhibited = 1;
2287 expansions = pre_process_line (shell_input_line, 1, 1);
2288 # if defined (BANG_HISTORY)
2289 history_expansion_inhibited = old_hist;
2291 if (expansions != shell_input_line)
2293 free (shell_input_line);
2294 shell_input_line = expansions;
2295 shell_input_line_len = shell_input_line ?
2296 strlen (shell_input_line) : 0;
2297 if (shell_input_line_len == 0)
2298 current_command_line_count--;
2300 /* We have to force the xrealloc below because we don't know
2301 the true allocated size of shell_input_line anymore. */
2302 shell_input_line_size = shell_input_line_len;
2304 set_line_mbstate ();
2307 /* Try to do something intelligent with blank lines encountered while
2308 entering multi-line commands. XXX - this is grotesque */
2309 else if (remember_on_history && shell_input_line &&
2310 shell_input_line[0] == '\0' &&
2311 current_command_line_count > 1)
2313 if (current_delimiter (dstack))
2314 /* We know shell_input_line[0] == 0 and we're reading some sort of
2315 quoted string. This means we've got a line consisting of only
2316 a newline in a quoted string. We want to make sure this line
2317 gets added to the history. */
2318 maybe_add_history (shell_input_line);
2322 hdcs = history_delimiting_chars (shell_input_line);
2323 if (hdcs && hdcs[0] == ';')
2324 maybe_add_history (shell_input_line);
2328 #endif /* HISTORY */
2330 if (shell_input_line)
2332 /* Lines that signify the end of the shell's input should not be
2334 if (echo_input_at_read && (shell_input_line[0] ||
2335 shell_input_line_terminator != EOF))
2336 fprintf (stderr, "%s\n", shell_input_line);
2340 shell_input_line_size = 0;
2341 prompt_string_pointer = ¤t_prompt_string;
2342 if (SHOULD_PROMPT ())
2347 /* Add the newline to the end of this string, iff the string does
2348 not already end in an EOF character. */
2349 if (shell_input_line_terminator != EOF)
2351 if (shell_input_line_len + 3 > shell_input_line_size)
2352 shell_input_line = (char *)xrealloc (shell_input_line,
2353 1 + (shell_input_line_size += 2));
2355 shell_input_line[shell_input_line_len] = '\n';
2356 shell_input_line[shell_input_line_len + 1] = '\0';
2358 set_line_mbstate ();
2363 uc = shell_input_line[shell_input_line_index];
2366 shell_input_line_index++;
2368 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2369 /* If UC is NULL, we have reached the end of the current input string. If
2370 pushed_string_list is non-empty, it's time to pop to the previous string
2371 because we have fully consumed the result of the last alias expansion.
2372 Do it transparently; just return the next character of the string popped
2375 if (uc == 0 && (pushed_string_list != (STRING_SAVER *)NULL))
2378 uc = shell_input_line[shell_input_line_index];
2380 shell_input_line_index++;
2382 #endif /* ALIAS || DPAREN_ARITHMETIC */
2384 if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
2386 if (SHOULD_PROMPT ())
2389 /* What do we do here if we're expanding an alias whose definition
2390 includes an escaped newline? If that's the last character in the
2391 alias expansion, we just pop the pushed string list (recall that
2392 we inhibit the appending of a space in mk_alexpansion() if newline
2393 is the last character). If it's not the last character, we need
2394 to consume the quoted newline and move to the next character in
2397 if (expanding_alias () && shell_input_line[shell_input_line_index+1] == '\0')
2402 else if (expanding_alias () && shell_input_line[shell_input_line_index+1] != '\0')
2404 shell_input_line_index++; /* skip newline */
2405 goto next_alias_char; /* and get next character */
2412 if (uc == 0 && shell_input_line_terminator == EOF)
2413 return ((shell_input_line_index != 0) ? '\n' : EOF);
2418 /* Put C back into the input for the shell. This might need changes for
2419 HANDLE_MULTIBYTE around EOLs. Since we (currently) never push back a
2420 character different than we read, shell_input_line_property doesn't need
2421 to change when manipulating shell_input_line. The define for
2422 last_shell_getc_is_singlebyte should take care of it, though. */
2427 if (shell_input_line && shell_input_line_index)
2428 shell_input_line[--shell_input_line_index] = c;
2430 eol_ungetc_lookahead = c;
2433 #ifdef INCLUDE_UNUSED
2434 /* Back the input pointer up by one, effectively `ungetting' a character. */
2438 if (shell_input_line && shell_input_line_index)
2439 shell_input_line_index--;
2443 /* Discard input until CHARACTER is seen, then push that character back
2444 onto the input stream. */
2446 discard_until (character)
2451 while ((c = shell_getc (0)) != EOF && c != character)
2459 execute_variable_command (command, vname)
2460 char *command, *vname;
2463 sh_parser_state_t ps;
2465 save_parser_state (&ps);
2466 last_lastarg = get_string_value ("_");
2468 last_lastarg = savestring (last_lastarg);
2470 parse_and_execute (savestring (command), vname, SEVAL_NONINT|SEVAL_NOHIST);
2472 restore_parser_state (&ps);
2473 bind_variable ("_", last_lastarg, 0);
2474 FREE (last_lastarg);
2476 if (token_to_read == '\n') /* reset_parser was called */
2480 /* Place to remember the token. We try to keep the buffer
2481 at a reasonable size, but it can grow. */
2482 static char *token = (char *)NULL;
2484 /* Current size of the token buffer. */
2485 static int token_buffer_size;
2487 /* Command to read_token () explaining what we want it to do. */
2490 #define prompt_is_ps1 \
2491 (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
2493 /* Function for yyparse to call. yylex keeps track of
2494 the last two tokens read, and calls read_token. */
2498 if (interactive && (current_token == 0 || current_token == '\n'))
2500 /* Before we print a prompt, we might have to check mailboxes.
2501 We do this only if it is time to do so. Notice that only here
2502 is the mail alarm reset; nothing takes place in check_mail ()
2503 except the checking of mail. Please don't change this. */
2504 if (prompt_is_ps1 && parse_and_execute_level == 0 && time_to_check_mail ())
2507 reset_mail_timer ();
2510 /* Avoid printing a prompt if we're not going to read anything, e.g.
2511 after resetting the parser with read_token (RESET). */
2512 if (token_to_read == 0 && SHOULD_PROMPT ())
2516 two_tokens_ago = token_before_that;
2517 token_before_that = last_read_token;
2518 last_read_token = current_token;
2519 current_token = read_token (READ);
2521 if ((parser_state & PST_EOFTOKEN) && current_token == shell_eof_token)
2523 current_token = yacc_EOF;
2524 if (bash_input.type == st_string)
2525 rewind_input_string ();
2527 parser_state &= ~PST_EOFTOKEN;
2529 return (current_token);
2532 /* When non-zero, we have read the required tokens
2533 which allow ESAC to be the next one read. */
2534 static int esacs_needed_count;
2537 gather_here_documents ()
2542 while (need_here_doc)
2544 parser_state |= PST_HEREDOC;
2545 make_here_document (redir_stack[r++], line_number);
2546 parser_state &= ~PST_HEREDOC;
2551 /* When non-zero, an open-brace used to create a group is awaiting a close
2553 static int open_brace_count;
2555 #define command_token_position(token) \
2556 (((token) == ASSIGNMENT_WORD) || (parser_state&PST_REDIRLIST) || \
2557 ((token) != SEMI_SEMI && (token) != SEMI_AND && (token) != SEMI_SEMI_AND && reserved_word_acceptable(token)))
2559 #define assignment_acceptable(token) \
2560 (command_token_position(token) && ((parser_state & PST_CASEPAT) == 0))
2562 /* Check to see if TOKEN is a reserved word and return the token
2564 #define CHECK_FOR_RESERVED_WORD(tok) \
2566 if (!dollar_present && !quoted && \
2567 reserved_word_acceptable (last_read_token)) \
2570 for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
2571 if (STREQ (tok, word_token_alist[i].word)) \
2573 if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
2575 if (word_token_alist[i].token == TIME && time_command_acceptable () == 0) \
2577 if (word_token_alist[i].token == ESAC) \
2578 parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
2579 else if (word_token_alist[i].token == CASE) \
2580 parser_state |= PST_CASESTMT; \
2581 else if (word_token_alist[i].token == COND_END) \
2582 parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
2583 else if (word_token_alist[i].token == COND_START) \
2584 parser_state |= PST_CONDCMD; \
2585 else if (word_token_alist[i].token == '{') \
2586 open_brace_count++; \
2587 else if (word_token_alist[i].token == '}' && open_brace_count) \
2588 open_brace_count--; \
2589 return (word_token_alist[i].token); \
2596 /* OK, we have a token. Let's try to alias expand it, if (and only if)
2599 It is eligible for expansion if EXPAND_ALIASES is set, and
2600 the token is unquoted and the last token read was a command
2601 separator (or expand_next_token is set), and we are currently
2602 processing an alias (pushed_string_list is non-empty) and this
2603 token is not the same as the current or any previously
2606 Special cases that disqualify:
2607 In a pattern list in a case statement (parser_state & PST_CASEPAT). */
2617 r = xmalloc (l + 2);
2619 /* If the last character in the alias is a newline, don't add a trailing
2620 space to the expansion. Works with shell_getc above. */
2621 if (r[l - 1] != ' ' && r[l - 1] != '\n')
2628 alias_expand_token (tokstr)
2634 if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
2635 (parser_state & PST_CASEPAT) == 0)
2637 ap = find_alias (tokstr);
2639 /* Currently expanding this token. */
2640 if (ap && (ap->flags & AL_BEINGEXPANDED))
2641 return (NO_EXPANSION);
2643 /* mk_alexpansion puts an extra space on the end of the alias expansion,
2644 so the lookahead by the parser works right. If this gets changed,
2645 make sure the code in shell_getc that deals with reaching the end of
2646 an expanded alias is changed with it. */
2647 expanded = ap ? mk_alexpansion (ap->value) : (char *)NULL;
2651 push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
2652 return (RE_READ_TOKEN);
2655 /* This is an eligible token that does not have an expansion. */
2656 return (NO_EXPANSION);
2658 return (NO_EXPANSION);
2663 time_command_acceptable ()
2665 #if defined (COMMAND_TIMING)
2668 if (posixly_correct && shell_compatibility_level > 41)
2670 /* Quick check of the rest of the line to find the next token. If it
2671 begins with a `-', Posix says to not return `time' as the token.
2672 This was interp 267. */
2673 i = shell_input_line_index;
2674 while (i < shell_input_line_len && (shell_input_line[i] == ' ' || shell_input_line[i] == '\t'))
2676 if (shell_input_line[i] == '-')
2680 switch (last_read_token)
2693 case BANG: /* ! time pipeline */
2694 case TIME: /* time time pipeline */
2695 case TIMEOPT: /* time -p time pipeline */
2696 case TIMEIGN: /* time -p -- ... */
2703 #endif /* COMMAND_TIMING */
2706 /* Handle special cases of token recognition:
2707 IN is recognized if the last token was WORD and the token
2708 before that was FOR or CASE or SELECT.
2710 DO is recognized if the last token was WORD and the token
2711 before that was FOR or SELECT.
2713 ESAC is recognized if the last token caused `esacs_needed_count'
2716 `{' is recognized if the last token as WORD and the token
2717 before that was FUNCTION, or if we just parsed an arithmetic
2720 `}' is recognized if there is an unclosed `{' present.
2722 `-p' is returned as TIMEOPT if the last read token was TIME.
2723 `--' is returned as TIMEIGN if the last read token was TIMEOPT.
2725 ']]' is returned as COND_END if the parser is currently parsing
2726 a conditional expression ((parser_state & PST_CONDEXPR) != 0)
2728 `time' is returned as TIME if and only if it is immediately
2729 preceded by one of `;', `\n', `||', `&&', or `&'.
2733 special_case_tokens (tokstr)
2736 if ((last_read_token == WORD) &&
2737 #if defined (SELECT_COMMAND)
2738 ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
2740 ((token_before_that == FOR) || (token_before_that == CASE)) &&
2742 (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
2744 if (token_before_that == CASE)
2746 parser_state |= PST_CASEPAT;
2747 esacs_needed_count++;
2752 if (last_read_token == WORD &&
2753 #if defined (SELECT_COMMAND)
2754 (token_before_that == FOR || token_before_that == SELECT) &&
2756 (token_before_that == FOR) &&
2758 (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
2761 /* Ditto for ESAC in the CASE case.
2762 Specifically, this handles "case word in esac", which is a legal
2763 construct, certainly because someone will pass an empty arg to the
2764 case construct, and we don't want it to barf. Of course, we should
2765 insist that the case construct has at least one pattern in it, but
2766 the designers disagree. */
2767 if (esacs_needed_count)
2769 esacs_needed_count--;
2770 if (STREQ (tokstr, "esac"))
2772 parser_state &= ~PST_CASEPAT;
2777 /* The start of a shell function definition. */
2778 if (parser_state & PST_ALLOWOPNBRC)
2780 parser_state &= ~PST_ALLOWOPNBRC;
2781 if (tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2784 function_bstart = line_number;
2785 return ('{'); /* } */
2789 /* We allow a `do' after a for ((...)) without an intervening
2791 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == 'd' && tokstr[1] == 'o' && !tokstr[2])
2793 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2796 return ('{'); /* } */
2799 if (open_brace_count && reserved_word_acceptable (last_read_token) && tokstr[0] == '}' && !tokstr[1])
2801 open_brace_count--; /* { */
2805 #if defined (COMMAND_TIMING)
2806 /* Handle -p after `time'. */
2807 if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == 'p' && !tokstr[2])
2809 /* Handle -- after `time -p'. */
2810 if (last_read_token == TIMEOPT && tokstr[0] == '-' && tokstr[1] == '-' && !tokstr[2])
2814 #if defined (COND_COMMAND) /* [[ */
2815 if ((parser_state & PST_CONDEXPR) && tokstr[0] == ']' && tokstr[1] == ']' && tokstr[2] == '\0')
2822 /* Called from shell.c when Control-C is typed at top level. Or
2823 by the error rule at top level. */
2827 dstack.delimiter_depth = 0; /* No delimiters found so far. */
2828 open_brace_count = 0;
2830 #if defined (EXTENDED_GLOB)
2831 /* Reset to global value of extended glob */
2832 if (parser_state & PST_EXTPAT)
2833 extended_glob = global_extglob;
2838 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2839 if (pushed_string_list)
2840 free_string_list ();
2841 #endif /* ALIAS || DPAREN_ARITHMETIC */
2843 if (shell_input_line)
2845 free (shell_input_line);
2846 shell_input_line = (char *)NULL;
2847 shell_input_line_size = shell_input_line_index = 0;
2850 FREE (word_desc_to_read);
2851 word_desc_to_read = (WORD_DESC *)NULL;
2853 current_token = '\n'; /* XXX */
2854 last_read_token = '\n';
2855 token_to_read = '\n';
2858 /* Read the next token. Command can be READ (normal operation) or
2859 RESET (to normalize state). */
2861 read_token (command)
2864 int character; /* Current character. */
2865 int peek_char; /* Temporary look-ahead character. */
2866 int result; /* The thing to return. */
2868 if (command == RESET)
2876 result = token_to_read;
2877 if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
2879 yylval.word = word_desc_to_read;
2880 word_desc_to_read = (WORD_DESC *)NULL;
2886 #if defined (COND_COMMAND)
2887 if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
2889 cond_lineno = line_number;
2890 parser_state |= PST_CONDEXPR;
2891 yylval.command = parse_cond_command ();
2892 if (cond_token != COND_END)
2897 token_to_read = COND_END;
2898 parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
2904 /* This is a place to jump back to once we have successfully expanded a
2905 token with an alias and pushed the string with push_string () */
2909 /* Read a single word from input. Start by skipping blanks. */
2910 while ((character = shell_getc (1)) != EOF && shellblank (character))
2913 if (character == EOF)
2919 if MBTEST(character == '#' && (!interactive || interactive_comments))
2921 /* A comment. Discard until EOL or EOF, and then return a newline. */
2922 discard_until ('\n');
2924 character = '\n'; /* this will take the next if statement and return. */
2927 if (character == '\n')
2929 /* If we're about to return an unquoted newline, we can go and collect
2930 the text of any pending here document. */
2932 gather_here_documents ();
2935 parser_state &= ~PST_ALEXPNEXT;
2938 parser_state &= ~PST_ASSIGNOK;
2943 if (parser_state & PST_REGEXP)
2946 /* Shell meta-characters. */
2947 if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
2950 /* Turn off alias tokenization iff this character sequence would
2951 not leave us ready to read a command. */
2952 if (character == '<' || character == '>')
2953 parser_state &= ~PST_ALEXPNEXT;
2956 parser_state &= ~PST_ASSIGNOK;
2958 peek_char = shell_getc (1);
2959 if (character == peek_char)
2964 /* If '<' then we could be at "<<" or at "<<-". We have to
2965 look ahead one more character. */
2966 peek_char = shell_getc (1);
2967 if MBTEST(peek_char == '-')
2968 return (LESS_LESS_MINUS);
2969 else if MBTEST(peek_char == '<')
2970 return (LESS_LESS_LESS);
2973 shell_ungetc (peek_char);
2978 return (GREATER_GREATER);
2981 parser_state |= PST_CASEPAT;
2983 parser_state &= ~PST_ALEXPNEXT;
2986 peek_char = shell_getc (1);
2987 if MBTEST(peek_char == '&')
2988 return (SEMI_SEMI_AND);
2991 shell_ungetc (peek_char);
3001 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
3003 result = parse_dparen (character);
3011 else if MBTEST(character == '<' && peek_char == '&')
3013 else if MBTEST(character == '>' && peek_char == '&')
3014 return (GREATER_AND);
3015 else if MBTEST(character == '<' && peek_char == '>')
3016 return (LESS_GREATER);
3017 else if MBTEST(character == '>' && peek_char == '|')
3018 return (GREATER_BAR);
3019 else if MBTEST(character == '&' && peek_char == '>')
3021 peek_char = shell_getc (1);
3022 if MBTEST(peek_char == '>')
3023 return (AND_GREATER_GREATER);
3026 shell_ungetc (peek_char);
3027 return (AND_GREATER);
3030 else if MBTEST(character == '|' && peek_char == '&')
3032 else if MBTEST(character == ';' && peek_char == '&')
3034 parser_state |= PST_CASEPAT;
3036 parser_state &= ~PST_ALEXPNEXT;
3041 shell_ungetc (peek_char);
3043 /* If we look like we are reading the start of a function
3044 definition, then let the reader know about it so that
3045 we will do the right thing with `{'. */
3046 if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
3048 parser_state |= PST_ALLOWOPNBRC;
3050 parser_state &= ~PST_ALEXPNEXT;
3052 function_dstart = line_number;
3055 /* case pattern lists may be preceded by an optional left paren. If
3056 we're not trying to parse a case pattern list, the left paren
3057 indicates a subshell. */
3058 if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
3059 parser_state |= PST_SUBSHELL;
3061 else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
3062 parser_state &= ~PST_CASEPAT;
3064 else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
3065 parser_state &= ~PST_SUBSHELL;
3067 #if defined (PROCESS_SUBSTITUTION)
3068 /* Check for the constructs which introduce process substitution.
3069 Shells running in `posix mode' don't do process substitution. */
3070 if MBTEST(posixly_correct || ((character != '>' && character != '<') || peek_char != '(')) /*)*/
3071 #endif /* PROCESS_SUBSTITUTION */
3075 /* Hack <&- (close stdin) case. Also <&N- (dup and close). */
3076 if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
3080 /* Okay, if we got this far, we have to read a word. Read one,
3081 and then check it against the known ones. */
3082 result = read_token_word (character);
3084 if (result == RE_READ_TOKEN)
3091 * Match a $(...) or other grouping construct. This has to handle embedded
3092 * quoted strings ('', ``, "") and nested constructs. It also must handle
3093 * reprompting the user, if necessary, after reading a newline, and returning
3094 * correct error values if it reads EOF.
3096 #define P_FIRSTCLOSE 0x0001
3097 #define P_ALLOWESC 0x0002
3098 #define P_DQUOTE 0x0004
3099 #define P_COMMAND 0x0008 /* parsing a command, so look for comments */
3100 #define P_BACKQUOTE 0x0010 /* parsing a backquoted command substitution */
3101 #define P_ARRAYSUB 0x0020 /* parsing a [...] array subscript for assignment */
3102 #define P_DOLBRACE 0x0040 /* parsing a ${...} construct */
3104 /* Lexical state while parsing a grouping construct or $(...). */
3105 #define LEX_WASDOL 0x001
3106 #define LEX_CKCOMMENT 0x002
3107 #define LEX_INCOMMENT 0x004
3108 #define LEX_PASSNEXT 0x008
3109 #define LEX_RESWDOK 0x010
3110 #define LEX_CKCASE 0x020
3111 #define LEX_INCASE 0x040
3112 #define LEX_INHEREDOC 0x080
3113 #define LEX_HEREDELIM 0x100 /* reading here-doc delimiter */
3114 #define LEX_STRIPDOC 0x200 /* <<- strip tabs from here doc delim */
3115 #define LEX_INWORD 0x400
3117 #define COMSUB_META(ch) ((ch) == ';' || (ch) == '&' || (ch) == '|')
3119 #define CHECK_NESTRET_ERROR() \
3121 if (nestret == &matched_pair_error) \
3124 return &matched_pair_error; \
3128 #define APPEND_NESTRET() \
3132 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64); \
3133 strcpy (ret + retind, nestret); \
3134 retind += nestlen; \
3138 static char matched_pair_error;
3141 parse_matched_pair (qc, open, close, lenp, flags)
3142 int qc; /* `"' if this construct is within double quotes */
3146 int count, ch, tflags;
3147 int nestlen, ttranslen, start_lineno;
3148 char *ret, *nestret, *ttrans;
3149 int retind, retsize, rflags;
3152 dolbrace_state = (flags & P_DOLBRACE) ? DOLBRACE_PARAM : 0;
3154 /*itrace("parse_matched_pair[%d]: open = %c close = %c flags = %d", line_number, open, close, flags);*/
3158 if ((flags & P_COMMAND) && qc != '`' && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
3159 tflags |= LEX_CKCOMMENT;
3161 /* RFLAGS is the set of flags we want to pass to recursive calls. */
3162 rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
3164 ret = (char *)xmalloc (retsize = 64);
3167 start_lineno = line_number;
3170 ch = shell_getc (qc != '\'' && (tflags & (LEX_PASSNEXT)) == 0);
3175 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
3176 EOF_Reached = 1; /* XXX */
3177 return (&matched_pair_error);
3180 /* Possible reprompting. */
3181 if (ch == '\n' && SHOULD_PROMPT ())
3184 /* Don't bother counting parens or doing anything else if in a comment
3185 or part of a case statement */
3186 if (tflags & LEX_INCOMMENT)
3188 /* Add this character. */
3189 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3193 tflags &= ~LEX_INCOMMENT;
3198 /* Not exactly right yet, should handle shell metacharacters, too. If
3199 any changes are made to this test, make analogous changes to subst.c:
3200 extract_delimited_string(). */
3201 else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || shellblank (ret[retind - 1])))
3202 tflags |= LEX_INCOMMENT;
3204 if (tflags & LEX_PASSNEXT) /* last char was backslash */
3206 tflags &= ~LEX_PASSNEXT;
3207 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3210 retind--; /* swallow previously-added backslash */
3214 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3215 if MBTEST(ch == CTLESC || ch == CTLNUL)
3216 ret[retind++] = CTLESC;
3220 /* If we're reparsing the input (e.g., from parse_string_to_word_list),
3221 we've already prepended CTLESC to single-quoted results of $'...'.
3222 We may want to do this for other CTLESC-quoted characters in
3224 else if MBTEST((parser_state & PST_REPARSE) && open == '\'' && (ch == CTLESC || ch == CTLNUL))
3226 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3230 else if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3232 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3233 ret[retind++] = CTLESC;
3237 else if MBTEST(ch == close) /* ending delimiter */
3239 /* handle nested ${...} specially. */
3240 else if MBTEST(open != close && (tflags & LEX_WASDOL) && open == '{' && ch == open) /* } */
3242 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
3245 /* Add this character. */
3246 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3249 /* If we just read the ending character, don't bother continuing. */
3253 if (open == '\'') /* '' inside grouping construct */
3255 if MBTEST((flags & P_ALLOWESC) && ch == '\\')
3256 tflags |= LEX_PASSNEXT;
3260 if MBTEST(ch == '\\') /* backslashes */
3261 tflags |= LEX_PASSNEXT;
3263 /* Based on which dolstate is currently in (param, op, or word),
3264 decide what the op is. We're really only concerned if it's % or
3265 #, so we can turn on a flag that says whether or not we should
3266 treat single quotes as special when inside a double-quoted
3267 ${...}. This logic must agree with subst.c:extract_dollar_brace_string
3268 since they share the same defines. */
3269 if (flags & P_DOLBRACE)
3271 /* ${param%[%]word} */
3272 if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '%' && retind > 1)
3273 dolbrace_state = DOLBRACE_QUOTE;
3274 /* ${param#[#]word} */
3275 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '#' && retind > 1)
3276 dolbrace_state = DOLBRACE_QUOTE;
3277 /* ${param/[/]pat/rep} */
3278 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '/' && retind > 1)
3279 dolbrace_state = DOLBRACE_QUOTE;
3280 /* ${param^[^]pat} */
3281 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '^' && retind > 1)
3282 dolbrace_state = DOLBRACE_QUOTE;
3283 /* ${param,[,]pat} */
3284 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == ',' && retind > 1)
3285 dolbrace_state = DOLBRACE_QUOTE;
3286 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && strchr ("#%^,~:-=?+/", ch) != 0)
3287 dolbrace_state = DOLBRACE_OP;
3288 else if MBTEST(dolbrace_state == DOLBRACE_OP && strchr ("#%^,~:-=?+/", ch) == 0)
3289 dolbrace_state = DOLBRACE_WORD;
3292 /* The big hammer. Single quotes aren't special in double quotes. The
3293 problem is that Posix used to say the single quotes are semi-special:
3294 within a double-quoted ${...} construct "an even number of
3295 unescaped double-quotes or single-quotes, if any, shall occur." */
3296 /* This was changed in Austin Group Interp 221 */
3297 if MBTEST(posixly_correct && shell_compatibility_level > 41 && dolbrace_state != DOLBRACE_QUOTE && (flags & P_DQUOTE) && (flags & P_DOLBRACE) && ch == '\'')
3300 /* Could also check open == '`' if we want to parse grouping constructs
3301 inside old-style command substitution. */
3302 if (open != close) /* a grouping construct */
3304 if MBTEST(shellquote (ch))
3306 /* '', ``, or "" inside $(...) or other grouping construct. */
3307 push_delimiter (dstack, ch);
3308 if MBTEST((tflags & LEX_WASDOL) && ch == '\'') /* $'...' inside group */
3309 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
3311 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
3312 pop_delimiter (dstack);
3313 CHECK_NESTRET_ERROR ();
3315 if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
3317 /* Translate $'...' here. */
3318 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
3321 if ((rflags & P_DQUOTE) == 0)
3323 nestret = sh_single_quote (ttrans);
3325 nestlen = strlen (nestret);
3330 nestlen = ttranslen;
3332 retind -= 2; /* back up before the $' */
3334 else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
3336 /* Locale expand $"..." here. */
3337 ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
3340 nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
3342 nestlen = ttranslen + 2;
3343 retind -= 2; /* back up before the $" */
3349 else if ((flags & P_ARRAYSUB) && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3350 goto parse_dollar_word;
3352 /* Parse an old-style command substitution within double quotes as a
3354 /* XXX - sh and ksh93 don't do this - XXX */
3355 else if MBTEST(open == '"' && ch == '`')
3357 nestret = parse_matched_pair (0, '`', '`', &nestlen, rflags);
3359 CHECK_NESTRET_ERROR ();
3364 else if MBTEST(open != '`' && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3365 /* check for $(), $[], or ${} inside quoted string. */
3368 if (open == ch) /* undo previous increment */
3370 if (ch == '(') /* ) */
3371 nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
3372 else if (ch == '{') /* } */
3373 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|P_DOLBRACE|rflags);
3374 else if (ch == '[') /* ] */
3375 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
3377 CHECK_NESTRET_ERROR ();
3382 if MBTEST(ch == '$')
3383 tflags |= LEX_WASDOL;
3385 tflags &= ~LEX_WASDOL;
3391 /*itrace("parse_matched_pair[%d]: returning %s", line_number, ret);*/
3395 /* Parse a $(...) command substitution. This is messier than I'd like, and
3396 reproduces a lot more of the token-reading code than I'd like. */
3398 parse_comsub (qc, open, close, lenp, flags)
3399 int qc; /* `"' if this construct is within double quotes */
3403 int count, ch, peekc, tflags, lex_rwlen, lex_wlen, lex_firstind;
3404 int nestlen, ttranslen, start_lineno;
3405 char *ret, *nestret, *ttrans, *heredelim;
3406 int retind, retsize, rflags, hdlen;
3408 /* Posix interp 217 says arithmetic expressions have precedence, so
3409 assume $(( introduces arithmetic expansion and parse accordingly. */
3410 peekc = shell_getc (0);
3411 shell_ungetc (peekc);
3413 return (parse_matched_pair (qc, open, close, lenp, 0));
3415 /*itrace("parse_comsub: qc = `%c' open = %c close = %c", qc, open, close);*/
3417 tflags = LEX_RESWDOK;
3419 if ((flags & P_COMMAND) && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
3420 tflags |= LEX_CKCASE;
3421 if ((tflags & LEX_CKCASE) && (interactive == 0 || interactive_comments))
3422 tflags |= LEX_CKCOMMENT;
3424 /* RFLAGS is the set of flags we want to pass to recursive calls. */
3425 rflags = (flags & P_DQUOTE);
3427 ret = (char *)xmalloc (retsize = 64);
3430 start_lineno = line_number;
3431 lex_rwlen = lex_wlen = 0;
3439 ch = shell_getc (qc != '\'' && (tflags & (LEX_INCOMMENT|LEX_PASSNEXT)) == 0);
3446 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
3447 EOF_Reached = 1; /* XXX */
3448 return (&matched_pair_error);
3451 /* If we hit the end of a line and are reading the contents of a here
3452 document, and it's not the same line that the document starts on,
3453 check for this line being the here doc delimiter. Otherwise, if
3454 we're in a here document, mark the next character as the beginning
3458 if ((tflags & LEX_HEREDELIM) && heredelim)
3460 tflags &= ~LEX_HEREDELIM;
3461 tflags |= LEX_INHEREDOC;
3462 lex_firstind = retind + 1;
3464 else if (tflags & LEX_INHEREDOC)
3467 tind = lex_firstind;
3468 while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
3470 if (STREQN (ret + tind, heredelim, hdlen))
3472 tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
3473 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
3479 lex_firstind = retind + 1;
3483 /* Possible reprompting. */
3484 if (ch == '\n' && SHOULD_PROMPT ())
3487 /* XXX -- possibly allow here doc to be delimited by ending right
3489 if ((tflags & LEX_INHEREDOC) && ch == close && count == 1)
3492 /*itrace("parse_comsub: in here doc, ch == close, retind - firstind = %d hdlen = %d retind = %d", retind-lex_firstind, hdlen, retind);*/
3493 tind = lex_firstind;
3494 while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
3496 if (retind-tind == hdlen && STREQN (ret + tind, heredelim, hdlen))
3498 tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
3499 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
3506 /* Don't bother counting parens or doing anything else if in a comment */
3507 if (tflags & (LEX_INCOMMENT|LEX_INHEREDOC))
3509 /* Add this character. */
3510 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3513 if ((tflags & LEX_INCOMMENT) && ch == '\n')
3515 /*itrace("parse_comsub:%d: lex_incomment -> 0 ch = `%c'", line_number, ch);*/
3516 tflags &= ~LEX_INCOMMENT;
3522 if (tflags & LEX_PASSNEXT) /* last char was backslash */
3524 /*itrace("parse_comsub:%d: lex_passnext -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3525 tflags &= ~LEX_PASSNEXT;
3526 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3529 retind--; /* swallow previously-added backslash */
3533 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3534 if MBTEST(ch == CTLESC || ch == CTLNUL)
3535 ret[retind++] = CTLESC;
3540 /* If this is a shell break character, we are not in a word. If not,
3541 we either start or continue a word. */
3542 if MBTEST(shellbreak (ch))
3544 tflags &= ~LEX_INWORD;
3545 /*itrace("parse_comsub:%d: lex_inword -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3549 if (tflags & LEX_INWORD)
3552 /*itrace("parse_comsub:%d: lex_inword == 1 ch = `%c' lex_wlen = %d (%d)", line_number, ch, lex_wlen, __LINE__);*/
3556 /*itrace("parse_comsub:%d: lex_inword -> 1 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3557 tflags |= LEX_INWORD;
3562 /* Skip whitespace */
3563 if MBTEST(shellblank (ch) && (tflags & LEX_HEREDELIM) == 0 && lex_rwlen == 0)
3565 /* Add this character. */
3566 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3571 /* Either we are looking for the start of the here-doc delimiter
3572 (lex_firstind == -1) or we are reading one (lex_firstind >= 0).
3573 If this character is a shell break character and we are reading
3574 the delimiter, save it and note that we are now reading a here
3575 document. If we've found the start of the delimiter, note it by
3576 setting lex_firstind. Backslashes can quote shell metacharacters
3577 in here-doc delimiters. */
3578 if (tflags & LEX_HEREDELIM)
3580 if (lex_firstind == -1 && shellbreak (ch) == 0)
3581 lex_firstind = retind;
3583 else if (heredelim && (tflags & LEX_PASSNEXT) == 0 && ch == '\n')
3585 tflags |= LEX_INHEREDOC;
3586 tflags &= ~LEX_HEREDELIM;
3587 lex_firstind = retind + 1;
3590 else if (lex_firstind >= 0 && (tflags & LEX_PASSNEXT) == 0 && shellbreak (ch))
3594 nestret = substring (ret, lex_firstind, retind);
3595 heredelim = string_quote_removal (nestret, 0);
3597 hdlen = STRLEN(heredelim);
3598 /*itrace("parse_comsub:%d: found here doc delimiter `%s' (%d)", line_number, heredelim, hdlen);*/
3602 tflags |= LEX_INHEREDOC;
3603 tflags &= ~LEX_HEREDELIM;
3604 lex_firstind = retind + 1;
3611 /* Meta-characters that can introduce a reserved word. Not perfect yet. */
3612 if MBTEST((tflags & LEX_RESWDOK) == 0 && (tflags & LEX_CKCASE) && (tflags & LEX_INCOMMENT) == 0 && (shellmeta(ch) || ch == '\n'))
3614 /* Add this character. */
3615 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3617 peekc = shell_getc (1);
3618 if (ch == peekc && (ch == '&' || ch == '|' || ch == ';')) /* two-character tokens */
3620 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3621 ret[retind++] = peekc;
3622 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
3623 tflags |= LEX_RESWDOK;
3627 else if (ch == '\n' || COMSUB_META(ch))
3629 shell_ungetc (peekc);
3630 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
3631 tflags |= LEX_RESWDOK;
3639 /* `unget' the character we just added and fall through */
3641 shell_ungetc (peekc);
3645 /* If we can read a reserved word, try to read one. */
3646 if (tflags & LEX_RESWDOK)
3648 if MBTEST(islower (ch))
3650 /* Add this character. */
3651 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3656 else if MBTEST(lex_rwlen == 4 && shellbreak (ch))
3658 if (STREQN (ret + retind - 4, "case", 4))
3660 tflags |= LEX_INCASE;
3661 /*itrace("parse_comsub:%d: found `case', lex_incase -> 1 lex_reswdok -> 0", line_number);*/
3663 else if (STREQN (ret + retind - 4, "esac", 4))
3665 tflags &= ~LEX_INCASE;
3666 /*itrace("parse_comsub:%d: found `esac', lex_incase -> 0 lex_reswdok -> 0", line_number);*/
3668 tflags &= ~LEX_RESWDOK;
3670 else if MBTEST((tflags & LEX_CKCOMMENT) && ch == '#' && (lex_rwlen == 0 || ((tflags & LEX_INWORD) && lex_wlen == 0)))
3671 ; /* don't modify LEX_RESWDOK if we're starting a comment */
3672 else if MBTEST((tflags & LEX_INCASE) && ch != '\n')
3673 /* If we can read a reserved word and we're in case, we're at the
3674 point where we can read a new pattern list or an esac. We
3675 handle the esac case above. If we read a newline, we want to
3676 leave LEX_RESWDOK alone. If we read anything else, we want to
3677 turn off LEX_RESWDOK, since we're going to read a pattern list. */
3679 tflags &= ~LEX_RESWDOK;
3680 /*itrace("parse_comsub:%d: lex_incase == 1 found `%c', lex_reswordok -> 0", line_number, ch);*/
3682 else if MBTEST(shellbreak (ch) == 0)
3684 tflags &= ~LEX_RESWDOK;
3685 /*itrace("parse_comsub:%d: found `%c', lex_reswordok -> 0", line_number, ch);*/
3689 /* Might be the start of a here-doc delimiter */
3690 if MBTEST((tflags & LEX_INCOMMENT) == 0 && (tflags & LEX_CKCASE) && ch == '<')
3692 /* Add this character. */
3693 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3695 peekc = shell_getc (1);
3700 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3701 ret[retind++] = peekc;
3702 peekc = shell_getc (1);
3707 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3708 ret[retind++] = peekc;
3709 tflags |= LEX_STRIPDOC;
3712 shell_ungetc (peekc);
3715 tflags |= LEX_HEREDELIM;
3721 ch = peekc; /* fall through and continue XXX */
3723 else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (((tflags & LEX_RESWDOK) && lex_rwlen == 0) || ((tflags & LEX_INWORD) && lex_wlen == 0)))
3725 /*itrace("parse_comsub:%d: lex_incomment -> 1 (%d)", line_number, __LINE__);*/
3726 tflags |= LEX_INCOMMENT;
3729 if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3731 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3732 ret[retind++] = CTLESC;
3737 else if MBTEST((tflags & LEX_INCASE) && ch == close && close == ')')
3738 tflags &= ~LEX_INCASE; /* XXX */
3740 else if MBTEST(ch == close && (tflags & LEX_INCASE) == 0) /* ending delimiter */
3743 /*itrace("parse_comsub:%d: found close: count = %d", line_number, count);*/
3745 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && (tflags & LEX_INCASE) == 0 && ch == open) /* nested begin */
3748 /*itrace("parse_comsub:%d: found open: count = %d", line_number, count);*/
3751 /* Add this character. */
3752 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3755 /* If we just read the ending character, don't bother continuing. */
3759 if MBTEST(ch == '\\') /* backslashes */
3760 tflags |= LEX_PASSNEXT;
3762 if MBTEST(shellquote (ch))
3764 /* '', ``, or "" inside $(...). */
3765 push_delimiter (dstack, ch);
3766 if MBTEST((tflags & LEX_WASDOL) && ch == '\'') /* $'...' inside group */
3767 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
3769 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
3770 pop_delimiter (dstack);
3771 CHECK_NESTRET_ERROR ();
3773 if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
3775 /* Translate $'...' here. */
3776 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
3779 if ((rflags & P_DQUOTE) == 0)
3781 nestret = sh_single_quote (ttrans);
3783 nestlen = strlen (nestret);
3788 nestlen = ttranslen;
3790 retind -= 2; /* back up before the $' */
3792 else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
3794 /* Locale expand $"..." here. */
3795 ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
3798 nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
3800 nestlen = ttranslen + 2;
3801 retind -= 2; /* back up before the $" */
3807 else if MBTEST((tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3808 /* check for $(), $[], or ${} inside command substitution. */
3810 if ((tflags & LEX_INCASE) == 0 && open == ch) /* undo previous increment */
3812 if (ch == '(') /* ) */
3813 nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
3814 else if (ch == '{') /* } */
3815 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|P_DOLBRACE|rflags);
3816 else if (ch == '[') /* ] */
3817 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
3819 CHECK_NESTRET_ERROR ();
3824 if MBTEST(ch == '$')
3825 tflags |= LEX_WASDOL;
3827 tflags &= ~LEX_WASDOL;
3834 /*itrace("parse_comsub:%d: returning `%s'", line_number, ret);*/
3838 /* Recursively call the parser to parse a $(...) command substitution. */
3840 xparse_dolparen (base, string, indp, flags)
3846 sh_parser_state_t ps;
3847 sh_input_line_state_t ls;
3848 int orig_ind, nc, sflags;
3849 char *ret, *s, *ep, *ostring;
3855 /*itrace("xparse_dolparen: size = %d shell_input_line = `%s'", shell_input_line_size, shell_input_line);*/
3856 sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE;
3857 if (flags & SX_NOLONGJMP)
3858 sflags |= SEVAL_NOLONGJMP;
3859 save_parser_state (&ps);
3860 save_input_line_state (&ls);
3863 parser_state |= PST_CMDSUBST|PST_EOFTOKEN; /* allow instant ')' */ /*(*/
3864 shell_eof_token = ')';
3865 parse_string (string, "command substitution", sflags, &ep);
3867 restore_parser_state (&ps);
3869 /* reset_parser clears shell_input_line and associated variables */
3870 restore_input_line_state (&ls);
3874 /* Need to find how many characters parse_and_execute consumed, update
3875 *indp, if flags != 0, copy the portion of the string parsed into RET
3876 and return it. If flags & 1 (EX_NOALLOC) we can return NULL. */
3883 itrace("xparse_dolparen:%d: ep[-1] != RPAREN (%d), ep = `%s'", line_number, ep[-1], ep);
3885 while (ep > ostring && ep[-1] == '\n') ep--;
3889 *indp = ep - base - 1;
3893 if (base[*indp] != ')')
3894 itrace("xparse_dolparen:%d: base[%d] != RPAREN (%d), base = `%s'", line_number, *indp, base[*indp], base);
3897 if (flags & SX_NOALLOC)
3898 return (char *)NULL;
3906 ret = substring (ostring, 0, nc - 1);
3911 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
3912 /* Parse a double-paren construct. It can be either an arithmetic
3913 command, an arithmetic `for' command, or a nested subshell. Returns
3914 the parsed token, -1 on error, or -2 if we didn't do anything and
3915 should just go on. */
3924 #if defined (ARITH_FOR_COMMAND)
3925 if (last_read_token == FOR)
3927 arith_for_lineno = line_number;
3928 cmdtyp = parse_arith_cmd (&wval, 0);
3931 wd = alloc_word_desc ();
3933 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
3934 return (ARITH_FOR_EXPRS);
3937 return -1; /* ERROR */
3941 #if defined (DPAREN_ARITHMETIC)
3942 if (reserved_word_acceptable (last_read_token))
3944 sline = line_number;
3946 cmdtyp = parse_arith_cmd (&wval, 0);
3947 if (cmdtyp == 1) /* arithmetic command */
3949 wd = alloc_word_desc ();
3951 wd->flags = W_QUOTED|W_NOSPLIT|W_NOGLOB|W_DQUOTE;
3952 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
3955 else if (cmdtyp == 0) /* nested subshell */
3957 push_string (wval, 0, (alias_t *)NULL);
3958 if ((parser_state & PST_CASEPAT) == 0)
3959 parser_state |= PST_SUBSHELL;
3967 return -2; /* XXX */
3970 /* We've seen a `(('. Look for the matching `))'. If we get it, return 1.
3971 If not, assume it's a nested subshell for backwards compatibility and
3972 return 0. In any case, put the characters we've consumed into a locally-
3973 allocated buffer and make *ep point to that buffer. Return -1 on an
3974 error, for example EOF. */
3976 parse_arith_cmd (ep, adddq)
3980 int exp_lineno, rval, c;
3981 char *ttok, *tokstr;
3984 exp_lineno = line_number;
3985 ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
3987 if (ttok == &matched_pair_error)
3989 /* Check that the next character is the closing right paren. If
3990 not, this is a syntax error. ( */
3995 tokstr = (char *)xmalloc (ttoklen + 4);
3997 /* if ADDDQ != 0 then (( ... )) -> "..." */
3998 if (rval == 1 && adddq) /* arith cmd, add double quotes */
4001 strncpy (tokstr + 1, ttok, ttoklen - 1);
4002 tokstr[ttoklen] = '"';
4003 tokstr[ttoklen+1] = '\0';
4005 else if (rval == 1) /* arith cmd, don't add double quotes */
4007 strncpy (tokstr, ttok, ttoklen - 1);
4008 tokstr[ttoklen-1] = '\0';
4010 else /* nested subshell */
4013 strncpy (tokstr + 1, ttok, ttoklen - 1);
4014 tokstr[ttoklen] = ')';
4015 tokstr[ttoklen+1] = c;
4016 tokstr[ttoklen+2] = '\0';
4023 #endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
4025 #if defined (COND_COMMAND)
4031 if (EOF_Reached && cond_token != COND_ERROR) /* [[ */
4032 parser_error (cond_lineno, _("unexpected EOF while looking for `]]'"));
4033 else if (cond_token != COND_ERROR)
4035 if (etext = error_token_from_token (cond_token))
4037 parser_error (cond_lineno, _("syntax error in conditional expression: unexpected token `%s'"), etext);
4041 parser_error (cond_lineno, _("syntax error in conditional expression"));
4048 return (cond_or ());
4057 if (cond_token == OR_OR)
4060 l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
4071 if (cond_token == AND_AND)
4074 l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
4080 cond_skip_newlines ()
4082 while ((cond_token = read_token (READ)) == '\n')
4084 if (SHOULD_PROMPT ())
4087 return (cond_token);
4090 #define COND_RETURN_ERROR() \
4091 do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
4097 COND_COM *term, *tleft, *tright;
4101 /* Read a token. It can be a left paren, a `!', a unary operator, or a
4102 word that should be the first argument of a binary operator. Start by
4103 skipping newlines, since this is a compound command. */
4104 tok = cond_skip_newlines ();
4105 lineno = line_number;
4106 if (tok == COND_END)
4108 COND_RETURN_ERROR ();
4110 else if (tok == '(')
4112 term = cond_expr ();
4113 if (cond_token != ')')
4116 dispose_cond_node (term); /* ( */
4117 if (etext = error_token_from_token (cond_token))
4119 parser_error (lineno, _("unexpected token `%s', expected `)'"), etext);
4123 parser_error (lineno, _("expected `)'"));
4124 COND_RETURN_ERROR ();
4126 term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
4127 (void)cond_skip_newlines ();
4129 else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
4132 dispose_word (yylval.word); /* not needed */
4133 term = cond_term ();
4135 term->flags |= CMD_INVERT_RETURN;
4137 else if (tok == WORD && yylval.word->word[0] == '-' && yylval.word->word[2] == 0 && test_unop (yylval.word->word))
4140 tok = read_token (READ);
4143 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4144 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
4149 if (etext = error_token_from_token (tok))
4151 parser_error (line_number, _("unexpected argument `%s' to conditional unary operator"), etext);
4155 parser_error (line_number, _("unexpected argument to conditional unary operator"));
4156 COND_RETURN_ERROR ();
4159 (void)cond_skip_newlines ();
4161 else if (tok == WORD) /* left argument to binary operator */
4164 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4167 tok = read_token (READ);
4168 if (tok == WORD && test_binop (yylval.word->word))
4171 if (op->word[0] == '=' && (op->word[1] == '\0' || (op->word[1] == '=' && op->word[2] == '\0')))
4172 parser_state |= PST_EXTPAT;
4173 else if (op->word[0] == '!' && op->word[1] == '=' && op->word[2] == '\0')
4174 parser_state |= PST_EXTPAT;
4176 #if defined (COND_REGEXP)
4177 else if (tok == WORD && STREQ (yylval.word->word, "=~"))
4180 parser_state |= PST_REGEXP;
4183 else if (tok == '<' || tok == '>')
4184 op = make_word_from_token (tok); /* ( */
4185 /* There should be a check before blindly accepting the `)' that we have
4186 seen the opening `('. */
4187 else if (tok == COND_END || tok == AND_AND || tok == OR_OR || tok == ')')
4189 /* Special case. [[ x ]] is equivalent to [[ -n x ]], just like
4190 the test command. Similarly for [[ x && expr ]] or
4191 [[ x || expr ]] or [[ (x) ]]. */
4192 op = make_word ("-n");
4193 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
4199 if (etext = error_token_from_token (tok))
4201 parser_error (line_number, _("unexpected token `%s', conditional binary operator expected"), etext);
4205 parser_error (line_number, _("conditional binary operator expected"));
4206 dispose_cond_node (tleft);
4207 COND_RETURN_ERROR ();
4211 if (parser_state & PST_EXTPAT)
4213 tok = read_token (READ);
4214 if (parser_state & PST_EXTPAT)
4215 extended_glob = global_extglob;
4216 parser_state &= ~(PST_REGEXP|PST_EXTPAT);
4220 tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4221 term = make_cond_node (COND_BINARY, op, tleft, tright);
4225 if (etext = error_token_from_token (tok))
4227 parser_error (line_number, _("unexpected argument `%s' to conditional binary operator"), etext);
4231 parser_error (line_number, _("unexpected argument to conditional binary operator"));
4232 dispose_cond_node (tleft);
4234 COND_RETURN_ERROR ();
4237 (void)cond_skip_newlines ();
4242 parser_error (line_number, _("unexpected token `%c' in conditional command"), tok);
4243 else if (etext = error_token_from_token (tok))
4245 parser_error (line_number, _("unexpected token `%s' in conditional command"), etext);
4249 parser_error (line_number, _("unexpected token %d in conditional command"), tok);
4250 COND_RETURN_ERROR ();
4255 /* This is kind of bogus -- we slip a mini recursive-descent parser in
4256 here to handle the conditional statement syntax. */
4258 parse_cond_command ()
4262 global_extglob = extended_glob;
4263 cexp = cond_expr ();
4264 return (make_cond_command (cexp));
4268 #if defined (ARRAY_VARS)
4269 /* When this is called, it's guaranteed that we don't care about anything
4270 in t beyond i. We do save and restore the chars, though. */
4272 token_is_assignment (t, i)
4276 unsigned char c, c1;
4279 c = t[i]; c1 = t[i+1];
4280 t[i] = '='; t[i+1] = '\0';
4281 r = assignment (t, (parser_state & PST_COMPASSIGN) != 0);
4282 t[i] = c; t[i+1] = c1;
4286 /* XXX - possible changes here for `+=' */
4288 token_is_ident (t, i)
4297 r = legal_identifier (t);
4304 read_token_word (character)
4307 /* The value for YYLVAL when a WORD is read. */
4308 WORD_DESC *the_word;
4310 /* Index into the token that we are building. */
4313 /* ALL_DIGITS becomes zero when we see a non-digit. */
4314 int all_digit_token;
4316 /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
4319 /* COMPOUND_ASSIGNMENT becomes non-zero if we are parsing a compound
4321 int compound_assignment;
4323 /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
4326 /* Non-zero means to ignore the value of the next character, and just
4327 to add it no matter what. */
4328 int pass_next_character;
4330 /* The current delimiting character. */
4332 int result, peek_char;
4333 char *ttok, *ttrans;
4334 int ttoklen, ttranslen;
4337 if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
4338 token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
4341 all_digit_token = DIGIT (character);
4342 dollar_present = quoted = pass_next_character = compound_assignment = 0;
4346 if (character == EOF)
4349 if (pass_next_character)
4351 pass_next_character = 0;
4352 goto got_escaped_character;
4355 cd = current_delimiter (dstack);
4357 /* Handle backslashes. Quote lots of things when not inside of
4358 double-quotes, quote some things inside of double-quotes. */
4359 if MBTEST(character == '\\')
4361 peek_char = shell_getc (0);
4363 /* Backslash-newline is ignored in all cases except
4364 when quoted with single quotes. */
4365 if (peek_char == '\n')
4368 goto next_character;
4372 shell_ungetc (peek_char);
4374 /* If the next character is to be quoted, note it now. */
4375 if (cd == 0 || cd == '`' ||
4376 (cd == '"' && peek_char >= 0 && (sh_syntaxtab[peek_char] & CBSDQUOTE)))
4377 pass_next_character++;
4384 /* Parse a matched pair of quote characters. */
4385 if MBTEST(shellquote (character))
4387 push_delimiter (dstack, character);
4388 ttok = parse_matched_pair (character, character, character, &ttoklen, (character == '`') ? P_COMMAND : 0);
4389 pop_delimiter (dstack);
4390 if (ttok == &matched_pair_error)
4391 return -1; /* Bail immediately. */
4392 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4393 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4394 token[token_index++] = character;
4395 strcpy (token + token_index, ttok);
4396 token_index += ttoklen;
4397 all_digit_token = 0;
4399 dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
4401 goto next_character;
4405 /* When parsing a regexp as a single word inside a conditional command,
4406 we need to special-case characters special to both the shell and
4407 regular expressions. Right now, that is only '(' and '|'. */ /*)*/
4408 if MBTEST((parser_state & PST_REGEXP) && (character == '(' || character == '|')) /*)*/
4410 if (character == '|')
4413 push_delimiter (dstack, character);
4414 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4415 pop_delimiter (dstack);
4416 if (ttok == &matched_pair_error)
4417 return -1; /* Bail immediately. */
4418 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4419 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4420 token[token_index++] = character;
4421 strcpy (token + token_index, ttok);
4422 token_index += ttoklen;
4424 dollar_present = all_digit_token = 0;
4425 goto next_character;
4427 #endif /* COND_REGEXP */
4429 #ifdef EXTENDED_GLOB
4430 /* Parse a ksh-style extended pattern matching specification. */
4431 if MBTEST(extended_glob && PATTERN_CHAR (character))
4433 peek_char = shell_getc (1);
4434 if MBTEST(peek_char == '(') /* ) */
4436 push_delimiter (dstack, peek_char);
4437 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4438 pop_delimiter (dstack);
4439 if (ttok == &matched_pair_error)
4440 return -1; /* Bail immediately. */
4441 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4443 TOKEN_DEFAULT_GROW_SIZE);
4444 token[token_index++] = character;
4445 token[token_index++] = peek_char;
4446 strcpy (token + token_index, ttok);
4447 token_index += ttoklen;
4449 dollar_present = all_digit_token = 0;
4450 goto next_character;
4453 shell_ungetc (peek_char);
4455 #endif /* EXTENDED_GLOB */
4457 /* If the delimiter character is not single quote, parse some of
4458 the shell expansions that must be read as a single word. */
4459 if (shellexp (character))
4461 peek_char = shell_getc (1);
4462 /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
4463 if MBTEST(peek_char == '(' || \
4464 ((peek_char == '{' || peek_char == '[') && character == '$')) /* ) ] } */
4466 if (peek_char == '{') /* } */
4467 ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE|P_DOLBRACE);
4468 else if (peek_char == '(') /* ) */
4470 /* XXX - push and pop the `(' as a delimiter for use by
4471 the command-oriented-history code. This way newlines
4472 appearing in the $(...) string get added to the
4473 history literally rather than causing a possibly-
4474 incorrect `;' to be added. ) */
4475 push_delimiter (dstack, peek_char);
4476 ttok = parse_comsub (cd, '(', ')', &ttoklen, P_COMMAND);
4477 pop_delimiter (dstack);
4480 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
4481 if (ttok == &matched_pair_error)
4482 return -1; /* Bail immediately. */
4483 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4485 TOKEN_DEFAULT_GROW_SIZE);
4486 token[token_index++] = character;
4487 token[token_index++] = peek_char;
4488 strcpy (token + token_index, ttok);
4489 token_index += ttoklen;
4492 all_digit_token = 0;
4493 goto next_character;
4495 /* This handles $'...' and $"..." new-style quoted strings. */
4496 else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
4500 first_line = line_number;
4501 push_delimiter (dstack, peek_char);
4502 ttok = parse_matched_pair (peek_char, peek_char, peek_char,
4504 (peek_char == '\'') ? P_ALLOWESC : 0);
4505 pop_delimiter (dstack);
4506 if (ttok == &matched_pair_error)
4508 if (peek_char == '\'')
4510 ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
4513 /* Insert the single quotes and correctly quote any
4514 embedded single quotes (allowed because P_ALLOWESC was
4515 passed to parse_matched_pair). */
4516 ttok = sh_single_quote (ttrans);
4518 ttranslen = strlen (ttok);
4523 /* Try to locale-expand the converted string. */
4524 ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
4527 /* Add the double quotes back */
4528 ttok = sh_mkdoublequoted (ttrans, ttranslen, 0);
4534 RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 2,
4536 TOKEN_DEFAULT_GROW_SIZE);
4537 strcpy (token + token_index, ttrans);
4538 token_index += ttranslen;
4541 all_digit_token = 0;
4542 goto next_character;
4544 /* This could eventually be extended to recognize all of the
4545 shell's single-character parameter expansions, and set flags.*/
4546 else if MBTEST(character == '$' && peek_char == '$')
4548 ttok = (char *)xmalloc (3);
4549 ttok[0] = ttok[1] = '$';
4551 RESIZE_MALLOCED_BUFFER (token, token_index, 3,
4553 TOKEN_DEFAULT_GROW_SIZE);
4554 strcpy (token + token_index, ttok);
4557 all_digit_token = 0;
4559 goto next_character;
4562 shell_ungetc (peek_char);
4565 #if defined (ARRAY_VARS)
4566 /* Identify possible array subscript assignment; match [...]. If
4567 parser_state&PST_COMPASSIGN, we need to parse [sub]=words treating
4568 `sub' as if it were enclosed in double quotes. */
4569 else if MBTEST(character == '[' && /* ] */
4570 ((token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) ||
4571 (token_index == 0 && (parser_state&PST_COMPASSIGN))))
4573 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, P_ARRAYSUB);
4574 if (ttok == &matched_pair_error)
4575 return -1; /* Bail immediately. */
4576 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4578 TOKEN_DEFAULT_GROW_SIZE);
4579 token[token_index++] = character;
4580 strcpy (token + token_index, ttok);
4581 token_index += ttoklen;
4583 all_digit_token = 0;
4584 goto next_character;
4586 /* Identify possible compound array variable assignment. */
4587 else if MBTEST(character == '=' && token_index > 0 && (assignment_acceptable (last_read_token) || (parser_state & PST_ASSIGNOK)) && token_is_assignment (token, token_index))
4589 peek_char = shell_getc (1);
4590 if MBTEST(peek_char == '(') /* ) */
4592 ttok = parse_compound_assignment (&ttoklen);
4594 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
4596 TOKEN_DEFAULT_GROW_SIZE);
4598 token[token_index++] = '=';
4599 token[token_index++] = '(';
4602 strcpy (token + token_index, ttok);
4603 token_index += ttoklen;
4605 token[token_index++] = ')';
4607 all_digit_token = 0;
4608 compound_assignment = 1;
4610 goto next_character;
4612 goto got_token; /* ksh93 seems to do this */
4616 shell_ungetc (peek_char);
4620 /* When not parsing a multi-character word construct, shell meta-
4621 characters break words. */
4622 if MBTEST(shellbreak (character))
4624 shell_ungetc (character);
4630 if (character == CTLESC || character == CTLNUL)
4631 token[token_index++] = CTLESC;
4633 got_escaped_character:
4635 all_digit_token &= DIGIT (character);
4636 dollar_present |= character == '$';
4638 token[token_index++] = character;
4640 RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
4641 TOKEN_DEFAULT_GROW_SIZE);
4644 if (character == '\n' && SHOULD_PROMPT ())
4647 /* We want to remove quoted newlines (that is, a \<newline> pair)
4648 unless we are within single quotes or pass_next_character is
4649 set (the shell equivalent of literal-next). */
4650 cd = current_delimiter (dstack);
4651 character = shell_getc (cd != '\'' && pass_next_character == 0);
4652 } /* end for (;;) */
4656 token[token_index] = '\0';
4658 /* Check to see what thing we should return. If the last_read_token
4659 is a `<', or a `&', or the character which ended this token is
4660 a '>' or '<', then, and ONLY then, is this input token a NUMBER.
4661 Otherwise, it is just a word, and should be returned as such. */
4662 if MBTEST(all_digit_token && (character == '<' || character == '>' || \
4663 last_read_token == LESS_AND || \
4664 last_read_token == GREATER_AND))
4666 if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
4667 yylval.number = lvalue;
4673 /* Check for special case tokens. */
4674 result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
4679 /* Posix.2 does not allow reserved words to be aliased, so check for all
4680 of them, including special cases, before expanding the current token
4682 if MBTEST(posixly_correct)
4683 CHECK_FOR_RESERVED_WORD (token);
4685 /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
4686 inhibits alias expansion. */
4687 if (expand_aliases && quoted == 0)
4689 result = alias_expand_token (token);
4690 if (result == RE_READ_TOKEN)
4691 return (RE_READ_TOKEN);
4692 else if (result == NO_EXPANSION)
4693 parser_state &= ~PST_ALEXPNEXT;
4696 /* If not in Posix.2 mode, check for reserved words after alias
4698 if MBTEST(posixly_correct == 0)
4700 CHECK_FOR_RESERVED_WORD (token);
4702 the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
4703 the_word->word = (char *)xmalloc (1 + token_index);
4704 the_word->flags = 0;
4705 strcpy (the_word->word, token);
4707 the_word->flags |= W_HASDOLLAR;
4709 the_word->flags |= W_QUOTED; /*(*/
4710 if (compound_assignment && token[token_index-1] == ')')
4711 the_word->flags |= W_COMPASSIGN;
4712 /* A word is an assignment if it appears at the beginning of a
4713 simple command, or after another assignment word. This is
4714 context-dependent, so it cannot be handled in the grammar. */
4715 if (assignment (token, (parser_state & PST_COMPASSIGN) != 0))
4717 the_word->flags |= W_ASSIGNMENT;
4718 /* Don't perform word splitting on assignment statements. */
4719 if (assignment_acceptable (last_read_token) || (parser_state & PST_COMPASSIGN) != 0)
4720 the_word->flags |= W_NOSPLIT;
4723 if (command_token_position (last_read_token))
4726 b = builtin_address_internal (token, 0);
4727 if (b && (b->flags & ASSIGNMENT_BUILTIN))
4728 parser_state |= PST_ASSIGNOK;
4729 else if (STREQ (token, "eval") || STREQ (token, "let"))
4730 parser_state |= PST_ASSIGNOK;
4733 yylval.word = the_word;
4735 if (token[0] == '{' && token[token_index-1] == '}' &&
4736 (character == '<' || character == '>'))
4738 /* can use token; already copied to the_word */
4739 token[token_index-1] = '\0';
4740 if (legal_identifier (token+1))
4742 strcpy (the_word->word, token+1);
4743 /*itrace("read_token_word: returning REDIR_WORD for %s", the_word->word);*/
4744 return (REDIR_WORD);
4748 result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
4749 ? ASSIGNMENT_WORD : WORD;
4751 switch (last_read_token)
4754 parser_state |= PST_ALLOWOPNBRC;
4755 function_dstart = line_number;
4760 if (word_top < MAX_CASE_NEST)
4762 word_lineno[word_top] = line_number;
4769 /* Return 1 if TOKSYM is a token that after being read would allow
4770 a reserved word to be seen, else 0. */
4772 reserved_word_acceptable (toksym)
4809 #if defined (COPROCESS_SUPPORT)
4810 if (last_read_token == WORD && token_before_that == COPROC)
4813 if (last_read_token == WORD && token_before_that == FUNCTION)
4819 /* Return the index of TOKEN in the alist of reserved words, or -1 if
4820 TOKEN is not a shell reserved word. */
4822 find_reserved_word (tokstr)
4826 for (i = 0; word_token_alist[i].word; i++)
4827 if (STREQ (tokstr, word_token_alist[i].word))
4833 #if defined (READLINE)
4834 /* Called after each time readline is called. This insures that whatever
4835 the new prompt string is gets propagated to readline's local prompt
4838 reset_readline_prompt ()
4842 if (prompt_string_pointer)
4844 temp_prompt = (*prompt_string_pointer)
4845 ? decode_prompt_string (*prompt_string_pointer)
4848 if (temp_prompt == 0)
4850 temp_prompt = (char *)xmalloc (1);
4851 temp_prompt[0] = '\0';
4854 FREE (current_readline_prompt);
4855 current_readline_prompt = temp_prompt;
4858 #endif /* READLINE */
4861 #if defined (HISTORY)
4862 /* A list of tokens which can be followed by newlines, but not by
4863 semi-colons. When concatenating multiple lines of history, the
4864 newline separator for such tokens is replaced with a space. */
4865 static const int no_semi_successors[] = {
4866 '\n', '{', '(', ')', ';', '&', '|',
4867 CASE, DO, ELSE, IF, SEMI_SEMI, SEMI_AND, SEMI_SEMI_AND, THEN, UNTIL,
4868 WHILE, AND_AND, OR_OR, IN,
4872 /* If we are not within a delimited expression, try to be smart
4873 about which separators can be semi-colons and which must be
4874 newlines. Returns the string that should be added into the
4875 history entry. LINE is the line we're about to add; it helps
4876 make some more intelligent decisions in certain cases. */
4878 history_delimiting_chars (line)
4881 static int last_was_heredoc = 0; /* was the last entry the start of a here document? */
4884 if ((parser_state & PST_HEREDOC) == 0)
4885 last_was_heredoc = 0;
4887 if (dstack.delimiter_depth != 0)
4890 /* We look for current_command_line_count == 2 because we are looking to
4891 add the first line of the body of the here document (the second line
4892 of the command). We also keep LAST_WAS_HEREDOC as a private sentinel
4893 variable to note when we think we added the first line of a here doc
4894 (the one with a "<<" somewhere in it) */
4895 if (parser_state & PST_HEREDOC)
4897 if (last_was_heredoc)
4899 last_was_heredoc = 0;
4902 return (current_command_line_count == 2 ? "\n" : "");
4905 if (parser_state & PST_COMPASSIGN)
4908 /* First, handle some special cases. */
4910 /* If we just read `()', assume it's a function definition, and don't
4911 add a semicolon. If the token before the `)' was not `(', and we're
4912 not in the midst of parsing a case statement, assume it's a
4913 parenthesized command and add the semicolon. */
4915 if (token_before_that == ')')
4917 if (two_tokens_ago == '(') /*)*/ /* function def */
4919 /* This does not work for subshells inside case statement
4920 command lists. It's a suboptimal solution. */
4921 else if (parser_state & PST_CASESTMT) /* case statement pattern */
4924 return "; "; /* (...) subshell */
4926 else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
4927 return " "; /* function def using `function name' without `()' */
4929 /* If we're not in a here document, but we think we're about to parse one,
4930 and we would otherwise return a `;', return a newline to delimit the
4931 line with the here-doc delimiter */
4932 else if ((parser_state & PST_HEREDOC) == 0 && current_command_line_count > 1 && last_read_token == '\n' && strstr (line, "<<"))
4934 last_was_heredoc = 1;
4938 else if (token_before_that == WORD && two_tokens_ago == FOR)
4940 /* Tricky. `for i\nin ...' should not have a semicolon, but
4941 `for i\ndo ...' should. We do what we can. */
4942 for (i = shell_input_line_index; whitespace (shell_input_line[i]); i++)
4944 if (shell_input_line[i] && shell_input_line[i] == 'i' && shell_input_line[i+1] == 'n')
4948 else if (two_tokens_ago == CASE && token_before_that == WORD && (parser_state & PST_CASESTMT))
4951 for (i = 0; no_semi_successors[i]; i++)
4953 if (token_before_that == no_semi_successors[i])
4959 #endif /* HISTORY */
4961 /* Issue a prompt, or prepare to issue a prompt when the next character
4968 if (interactive == 0 || expanding_alias ()) /* XXX */
4971 ps1_prompt = get_string_value ("PS1");
4972 ps2_prompt = get_string_value ("PS2");
4974 if (!prompt_string_pointer)
4975 prompt_string_pointer = &ps1_prompt;
4977 temp_prompt = *prompt_string_pointer
4978 ? decode_prompt_string (*prompt_string_pointer)
4981 if (temp_prompt == 0)
4983 temp_prompt = (char *)xmalloc (1);
4984 temp_prompt[0] = '\0';
4987 current_prompt_string = *prompt_string_pointer;
4988 prompt_string_pointer = &ps2_prompt;
4990 #if defined (READLINE)
4991 if (!no_line_editing)
4993 FREE (current_readline_prompt);
4994 current_readline_prompt = temp_prompt;
4997 #endif /* READLINE */
4999 FREE (current_decoded_prompt);
5000 current_decoded_prompt = temp_prompt;
5005 get_current_prompt_level ()
5007 return ((current_prompt_string && current_prompt_string == ps2_prompt) ? 2 : 1);
5011 set_current_prompt_level (x)
5014 prompt_string_pointer = (x == 2) ? &ps2_prompt : &ps1_prompt;
5015 current_prompt_string = *prompt_string_pointer;
5021 fprintf (stderr, "%s", current_decoded_prompt);
5025 /* Return a string which will be printed as a prompt. The string
5026 may contain special characters which are decoded as follows:
5029 \d the date in Day Mon Date format
5030 \e escape (ascii 033)
5031 \h the hostname up to the first `.'
5033 \j the number of active jobs
5034 \l the basename of the shell's tty device name
5037 \s the name of the shell
5038 \t the time in 24-hour hh:mm:ss format
5039 \T the time in 12-hour hh:mm:ss format
5040 \@ the time in 12-hour hh:mm am/pm format
5041 \A the time in 24-hour hh:mm format
5042 \D{fmt} the result of passing FMT to strftime(3)
5044 \v the version of bash (e.g., 2.00)
5045 \V the release of bash, version + patchlevel (e.g., 2.00.0)
5046 \w the current working directory
5047 \W the last element of $PWD
5048 \! the history number of this command
5049 \# the command number of this command
5050 \$ a $ or a # if you are root
5051 \nnn character code nnn in octal
5053 \[ begin a sequence of non-printing chars
5054 \] end a sequence of non-printing chars
5056 #define PROMPT_GROWTH 48
5058 decode_prompt_string (string)
5063 struct dstack save_dstack;
5064 int last_exit_value, last_comsub_pid;
5065 #if defined (PROMPT_STRING_DECODE)
5066 int result_size, result_index;
5068 char *temp, octal_string[4];
5074 result = (char *)xmalloc (result_size = PROMPT_GROWTH);
5075 result[result_index = 0] = 0;
5076 temp = (char *)NULL;
5078 while (c = *string++)
5080 if (posixly_correct && c == '!')
5084 temp = savestring ("!");
5089 #if !defined (HISTORY)
5090 temp = savestring ("1");
5092 temp = itos (history_number ());
5093 #endif /* HISTORY */
5094 string--; /* add_string increments string again. */
5112 strncpy (octal_string, string, 3);
5113 octal_string[3] = '\0';
5115 n = read_octal (octal_string);
5116 temp = (char *)xmalloc (3);
5118 if (n == CTLESC || n == CTLNUL)
5135 for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
5138 c = 0; /* tested at add_string: */
5146 /* Make the current time/date into a string. */
5147 (void) time (&the_time);
5148 #if defined (HAVE_TZSET)
5149 sv_tz ("TZ"); /* XXX -- just make sure */
5151 tm = localtime (&the_time);
5154 n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
5156 n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
5158 n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
5160 n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
5162 n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
5167 timebuf[sizeof(timebuf) - 1] = '\0';
5169 temp = savestring (timebuf);
5172 case 'D': /* strftime format */
5173 if (string[1] != '{') /* } */
5176 (void) time (&the_time);
5177 tm = localtime (&the_time);
5178 string += 2; /* skip { */
5179 timefmt = xmalloc (strlen (string) + 3);
5180 for (t = timefmt; *string && *string != '}'; )
5183 c = *string; /* tested at add_string */
5184 if (timefmt[0] == '\0')
5187 timefmt[1] = 'X'; /* locale-specific current time */
5190 n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
5196 timebuf[sizeof(timebuf) - 1] = '\0';
5198 if (promptvars || posixly_correct)
5199 /* Make sure that expand_prompt_string is called with a
5200 second argument of Q_DOUBLE_QUOTES if we use this
5202 temp = sh_backslash_quote_for_double_quotes (timebuf);
5204 temp = savestring (timebuf);
5208 temp = (char *)xmalloc (3);
5209 temp[0] = no_line_editing ? '\n' : '\r';
5210 temp[1] = no_line_editing ? '\0' : '\n';
5215 temp = base_pathname (shell_name);
5216 temp = savestring (temp);
5221 temp = (char *)xmalloc (16);
5223 strcpy (temp, dist_version);
5225 sprintf (temp, "%s.%d", dist_version, patch_level);
5231 /* Use the value of PWD because it is much more efficient. */
5232 char t_string[PATH_MAX];
5235 temp = get_string_value ("PWD");
5239 if (getcwd (t_string, sizeof(t_string)) == 0)
5245 tlen = strlen (t_string);
5249 tlen = sizeof (t_string) - 1;
5250 strncpy (t_string, temp, tlen);
5252 t_string[tlen] = '\0';
5254 #if defined (MACOSX)
5255 /* Convert from "fs" format to "input" format */
5256 temp = fnx_fromfs (t_string, strlen (t_string));
5257 if (temp != t_string)
5258 strcpy (t_string, temp);
5261 #define ROOT_PATH(x) ((x)[0] == '/' && (x)[1] == 0)
5262 #define DOUBLE_SLASH_ROOT(x) ((x)[0] == '/' && (x)[1] == '/' && (x)[2] == 0)
5263 /* Abbreviate \W as ~ if $PWD == $HOME */
5264 if (c == 'W' && (((t = get_string_value ("HOME")) == 0) || STREQ (t, t_string) == 0))
5266 if (ROOT_PATH (t_string) == 0 && DOUBLE_SLASH_ROOT (t_string) == 0)
5268 t = strrchr (t_string, '/');
5270 memmove (t_string, t + 1, strlen (t)); /* strlen(t) to copy NULL */
5274 #undef DOUBLE_SLASH_ROOT
5276 /* polite_directory_format is guaranteed to return a string
5277 no longer than PATH_MAX - 1 characters. */
5278 strcpy (t_string, polite_directory_format (t_string));
5280 temp = trim_pathname (t_string, PATH_MAX - 1);
5281 /* If we're going to be expanding the prompt string later,
5282 quote the directory name. */
5283 if (promptvars || posixly_correct)
5284 /* Make sure that expand_prompt_string is called with a
5285 second argument of Q_DOUBLE_QUOTES if we use this
5287 temp = sh_backslash_quote_for_double_quotes (t_string);
5289 temp = savestring (t_string);
5295 if (current_user.user_name == 0)
5296 get_current_user_info ();
5297 temp = savestring (current_user.user_name);
5302 temp = savestring (current_host_name);
5303 if (c == 'h' && (t = (char *)strchr (temp, '.')))
5308 temp = itos (current_command_number);
5312 #if !defined (HISTORY)
5313 temp = savestring ("1");
5315 temp = itos (history_number ());
5316 #endif /* HISTORY */
5320 t = temp = (char *)xmalloc (3);
5321 if ((promptvars || posixly_correct) && (current_user.euid != 0))
5323 *t++ = current_user.euid == 0 ? '#' : '$';
5328 temp = itos (count_all_jobs ());
5332 #if defined (HAVE_TTYNAME)
5333 temp = (char *)ttyname (fileno (stdin));
5334 t = temp ? base_pathname (temp) : "tty";
5335 temp = savestring (t);
5337 temp = savestring ("tty");
5338 #endif /* !HAVE_TTYNAME */
5341 #if defined (READLINE)
5344 if (no_line_editing)
5349 temp = (char *)xmalloc (3);
5350 n = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
5352 if (n == CTLESC || n == CTLNUL)
5357 #endif /* READLINE */
5363 temp = (char *)xmalloc (2);
5370 else /* (c == '\\') */
5377 temp = (char *)xmalloc (3);
5386 sub_append_string (temp, result, &result_index, &result_size);
5387 temp = (char *)NULL; /* Freed in sub_append_string (). */
5388 result[result_index] = '\0';
5394 RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
5395 result[result_index++] = c;
5396 result[result_index] = '\0';
5399 #else /* !PROMPT_STRING_DECODE */
5400 result = savestring (string);
5401 #endif /* !PROMPT_STRING_DECODE */
5403 /* Save the delimiter stack and point `dstack' to temp space so any
5404 command substitutions in the prompt string won't result in screwing
5405 up the parser's quoting state. */
5406 save_dstack = dstack;
5407 dstack = temp_dstack;
5408 dstack.delimiter_depth = 0;
5410 /* Perform variable and parameter expansion and command substitution on
5411 the prompt string. */
5412 if (promptvars || posixly_correct)
5414 last_exit_value = last_command_exit_value;
5415 last_comsub_pid = last_command_subst_pid;
5416 list = expand_prompt_string (result, Q_DOUBLE_QUOTES, 0);
5418 result = string_list (list);
5419 dispose_words (list);
5420 last_command_exit_value = last_exit_value;
5421 last_command_subst_pid = last_comsub_pid;
5425 t = dequote_string (result);
5430 dstack = save_dstack;
5435 /************************************************
5439 ************************************************/
5441 /* Report a syntax error, and restart the parser. Call here for fatal
5447 report_syntax_error ((char *)NULL);
5453 error_token_from_token (tok)
5458 if (t = find_token_in_alist (tok, word_token_alist, 0))
5461 if (t = find_token_in_alist (tok, other_token_alist, 0))
5465 /* This stuff is dicy and needs closer inspection */
5466 switch (current_token)
5469 case ASSIGNMENT_WORD:
5471 t = savestring (yylval.word->word);
5474 t = itos (yylval.number);
5477 if (yylval.word_list)
5478 t = string_list (yylval.word_list);
5480 case ARITH_FOR_EXPRS:
5481 if (yylval.word_list)
5482 t = string_list_internal (yylval.word_list, " ; ");
5485 t = (char *)NULL; /* punt */
5493 error_token_from_text ()
5498 t = shell_input_line;
5499 i = shell_input_line_index;
5503 if (i && t[i] == '\0')
5506 while (i && (whitespace (t[i]) || t[i] == '\n'))
5512 while (i && (member (t[i], " \n\t;|&") == 0))
5515 while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
5518 /* Return our idea of the offending token. */
5519 if (token_end || (i == 0 && token_end == 0))
5522 msg = substring (t, i, token_end);
5523 else /* one-character token */
5525 msg = (char *)xmalloc (2);
5535 print_offending_line ()
5540 msg = savestring (shell_input_line);
5541 token_end = strlen (msg);
5542 while (token_end && msg[token_end - 1] == '\n')
5543 msg[--token_end] = '\0';
5545 parser_error (line_number, "`%s'", msg);
5549 /* Report a syntax error with line numbers, etc.
5550 Call here for recoverable errors. If you have a message to print,
5551 then place it in MESSAGE, otherwise pass NULL and this will figure
5552 out an appropriate message for you. */
5554 report_syntax_error (message)
5561 parser_error (line_number, "%s", message);
5562 if (interactive && EOF_Reached)
5564 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5568 /* If the line of input we're reading is not null, try to find the
5569 objectionable token. First, try to figure out what token the
5570 parser's complaining about by looking at current_token. */
5571 if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
5573 if (ansic_shouldquote (msg))
5575 p = ansic_quote (msg, 0, NULL);
5579 parser_error (line_number, _("syntax error near unexpected token `%s'"), msg);
5582 if (interactive == 0)
5583 print_offending_line ();
5585 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5589 /* If looking at the current token doesn't prove fruitful, try to find the
5590 offending token by analyzing the text of the input line near the current
5591 input line index and report what we find. */
5592 if (shell_input_line && *shell_input_line)
5594 msg = error_token_from_text ();
5597 parser_error (line_number, _("syntax error near `%s'"), msg);
5601 /* If not interactive, print the line containing the error. */
5602 if (interactive == 0)
5603 print_offending_line ();
5607 msg = EOF_Reached ? _("syntax error: unexpected end of file") : _("syntax error");
5608 parser_error (line_number, "%s", msg);
5609 /* When the shell is interactive, this file uses EOF_Reached
5610 only for error reporting. Other mechanisms are used to
5611 decide whether or not to exit. */
5612 if (interactive && EOF_Reached)
5616 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5619 /* ??? Needed function. ??? We have to be able to discard the constructs
5620 created during parsing. In the case of error, we want to return
5621 allocated objects to the memory pool. In the case of no error, we want
5622 to throw away the information about where the allocated objects live.
5623 (dispose_command () will actually free the command.) */
5625 discard_parser_constructs (error_p)
5630 /************************************************
5634 ************************************************/
5636 /* Do that silly `type "bye" to exit' stuff. You know, "ignoreeof". */
5638 /* A flag denoting whether or not ignoreeof is set. */
5641 /* The number of times that we have encountered an EOF character without
5642 another character intervening. When this gets above the limit, the
5643 shell terminates. */
5644 int eof_encountered = 0;
5646 /* The limit for eof_encountered. */
5647 int eof_encountered_limit = 10;
5649 /* If we have EOF as the only input unit, this user wants to leave
5650 the shell. If the shell is not interactive, then just leave.
5651 Otherwise, if ignoreeof is set, and we haven't done this the
5652 required number of times in a row, print a message. */
5654 handle_eof_input_unit ()
5658 /* shell.c may use this to decide whether or not to write out the
5659 history, among other things. We use it only for error reporting
5664 /* If the user wants to "ignore" eof, then let her do so, kind of. */
5667 if (eof_encountered < eof_encountered_limit)
5669 fprintf (stderr, _("Use \"%s\" to leave the shell.\n"),
5670 login_shell ? "logout" : "exit");
5672 /* Reset the parsing state. */
5673 last_read_token = current_token = '\n';
5674 /* Reset the prompt string to be $PS1. */
5675 prompt_string_pointer = (char **)NULL;
5681 /* In this case EOF should exit the shell. Do it now. */
5683 exit_builtin ((WORD_LIST *)NULL);
5687 /* We don't write history files, etc., for non-interactive shells. */
5692 /************************************************
5694 * STRING PARSING FUNCTIONS *
5696 ************************************************/
5698 /* It's very important that these two functions treat the characters
5699 between ( and ) identically. */
5701 static WORD_LIST parse_string_error;
5703 /* Take a string and run it through the shell parser, returning the
5704 resultant word list. Used by compound array assignment. */
5706 parse_string_to_word_list (s, flags, whom)
5712 int tok, orig_current_token, orig_line_number, orig_input_terminator;
5713 int orig_line_count;
5714 int old_echo_input, old_expand_aliases;
5715 #if defined (HISTORY)
5716 int old_remember_on_history, old_history_expansion_inhibited;
5719 #if defined (HISTORY)
5720 old_remember_on_history = remember_on_history;
5721 # if defined (BANG_HISTORY)
5722 old_history_expansion_inhibited = history_expansion_inhibited;
5724 bash_history_disable ();
5727 orig_line_number = line_number;
5728 orig_line_count = current_command_line_count;
5729 orig_input_terminator = shell_input_line_terminator;
5730 old_echo_input = echo_input_at_read;
5731 old_expand_aliases = expand_aliases;
5734 last_read_token = WORD; /* WORD to allow reserved words here */
5735 current_command_line_count = 0;
5736 echo_input_at_read = expand_aliases = 0;
5738 with_input_from_string (s, whom);
5739 wl = (WORD_LIST *)NULL;
5742 parser_state |= PST_COMPASSIGN|PST_REPARSE;
5744 while ((tok = read_token (READ)) != yacc_EOF)
5746 if (tok == '\n' && *bash_input.location.string == '\0')
5748 if (tok == '\n') /* Allow newlines in compound assignments */
5750 if (tok != WORD && tok != ASSIGNMENT_WORD)
5752 line_number = orig_line_number + line_number - 1;
5753 orig_current_token = current_token;
5754 current_token = tok;
5755 yyerror (NULL); /* does the right thing */
5756 current_token = orig_current_token;
5759 wl = &parse_string_error;
5762 wl = make_word_list (yylval.word, wl);
5765 last_read_token = '\n';
5768 #if defined (HISTORY)
5769 remember_on_history = old_remember_on_history;
5770 # if defined (BANG_HISTORY)
5771 history_expansion_inhibited = old_history_expansion_inhibited;
5772 # endif /* BANG_HISTORY */
5773 #endif /* HISTORY */
5775 echo_input_at_read = old_echo_input;
5776 expand_aliases = old_expand_aliases;
5778 current_command_line_count = orig_line_count;
5779 shell_input_line_terminator = orig_input_terminator;
5782 parser_state &= ~(PST_COMPASSIGN|PST_REPARSE);
5784 if (wl == &parse_string_error)
5786 last_command_exit_value = EXECUTION_FAILURE;
5787 if (interactive_shell == 0 && posixly_correct)
5788 jump_to_top_level (FORCE_EOF);
5790 jump_to_top_level (DISCARD);
5793 return (REVERSE_LIST (wl, WORD_LIST *));
5797 parse_compound_assignment (retlenp)
5801 int tok, orig_line_number, orig_token_size, orig_last_token, assignok;
5802 char *saved_token, *ret;
5804 saved_token = token;
5805 orig_token_size = token_buffer_size;
5806 orig_line_number = line_number;
5807 orig_last_token = last_read_token;
5809 last_read_token = WORD; /* WORD to allow reserved words here */
5811 token = (char *)NULL;
5812 token_buffer_size = 0;
5814 assignok = parser_state&PST_ASSIGNOK; /* XXX */
5816 wl = (WORD_LIST *)NULL; /* ( */
5817 parser_state |= PST_COMPASSIGN;
5819 while ((tok = read_token (READ)) != ')')
5821 if (tok == '\n') /* Allow newlines in compound assignments */
5823 if (SHOULD_PROMPT ())
5827 if (tok != WORD && tok != ASSIGNMENT_WORD)
5829 current_token = tok; /* for error reporting */
5830 if (tok == yacc_EOF) /* ( */
5831 parser_error (orig_line_number, _("unexpected EOF while looking for matching `)'"));
5833 yyerror(NULL); /* does the right thing */
5836 wl = &parse_string_error;
5839 wl = make_word_list (yylval.word, wl);
5843 token = saved_token;
5844 token_buffer_size = orig_token_size;
5846 parser_state &= ~PST_COMPASSIGN;
5848 if (wl == &parse_string_error)
5850 last_command_exit_value = EXECUTION_FAILURE;
5851 last_read_token = '\n'; /* XXX */
5852 if (interactive_shell == 0 && posixly_correct)
5853 jump_to_top_level (FORCE_EOF);
5855 jump_to_top_level (DISCARD);
5858 last_read_token = orig_last_token; /* XXX - was WORD? */
5862 rl = REVERSE_LIST (wl, WORD_LIST *);
5863 ret = string_list (rl);
5870 *retlenp = (ret && *ret) ? strlen (ret) : 0;
5873 parser_state |= PST_ASSIGNOK;
5878 /************************************************
5880 * SAVING AND RESTORING PARTIAL PARSE STATE *
5882 ************************************************/
5885 save_parser_state (ps)
5886 sh_parser_state_t *ps;
5889 ps = (sh_parser_state_t *)xmalloc (sizeof (sh_parser_state_t));
5891 return ((sh_parser_state_t *)NULL);
5893 ps->parser_state = parser_state;
5894 ps->token_state = save_token_state ();
5896 ps->input_line_terminator = shell_input_line_terminator;
5897 ps->eof_encountered = eof_encountered;
5899 ps->prompt_string_pointer = prompt_string_pointer;
5901 ps->current_command_line_count = current_command_line_count;
5903 #if defined (HISTORY)
5904 ps->remember_on_history = remember_on_history;
5905 # if defined (BANG_HISTORY)
5906 ps->history_expansion_inhibited = history_expansion_inhibited;
5910 ps->last_command_exit_value = last_command_exit_value;
5911 #if defined (ARRAY_VARS)
5912 ps->pipestatus = save_pipestatus_array ();
5915 ps->last_shell_builtin = last_shell_builtin;
5916 ps->this_shell_builtin = this_shell_builtin;
5918 ps->expand_aliases = expand_aliases;
5919 ps->echo_input_at_read = echo_input_at_read;
5922 ps->token_buffer_size = token_buffer_size;
5923 /* Force reallocation on next call to read_token_word */
5925 token_buffer_size = 0;
5931 restore_parser_state (ps)
5932 sh_parser_state_t *ps;
5937 parser_state = ps->parser_state;
5938 if (ps->token_state)
5940 restore_token_state (ps->token_state);
5941 free (ps->token_state);
5944 shell_input_line_terminator = ps->input_line_terminator;
5945 eof_encountered = ps->eof_encountered;
5947 prompt_string_pointer = ps->prompt_string_pointer;
5949 current_command_line_count = ps->current_command_line_count;
5951 #if defined (HISTORY)
5952 remember_on_history = ps->remember_on_history;
5953 # if defined (BANG_HISTORY)
5954 history_expansion_inhibited = ps->history_expansion_inhibited;
5958 last_command_exit_value = ps->last_command_exit_value;
5959 #if defined (ARRAY_VARS)
5960 restore_pipestatus_array (ps->pipestatus);
5963 last_shell_builtin = ps->last_shell_builtin;
5964 this_shell_builtin = ps->this_shell_builtin;
5966 expand_aliases = ps->expand_aliases;
5967 echo_input_at_read = ps->echo_input_at_read;
5971 token_buffer_size = ps->token_buffer_size;
5974 sh_input_line_state_t *
5975 save_input_line_state (ls)
5976 sh_input_line_state_t *ls;
5979 ls = (sh_input_line_state_t *)xmalloc (sizeof (sh_input_line_state_t));
5981 return ((sh_input_line_state_t *)NULL);
5983 ls->input_line = shell_input_line;
5984 ls->input_line_size = shell_input_line_size;
5985 ls->input_line_len = shell_input_line_len;
5986 ls->input_line_index = shell_input_line_index;
5988 /* force reallocation */
5989 shell_input_line = 0;
5990 shell_input_line_size = shell_input_line_len = shell_input_line_index = 0;
5994 restore_input_line_state (ls)
5995 sh_input_line_state_t *ls;
5997 FREE (shell_input_line);
5998 shell_input_line = ls->input_line;
5999 shell_input_line_size = ls->input_line_size;
6000 shell_input_line_len = ls->input_line_len;
6001 shell_input_line_index = ls->input_line_index;
6003 set_line_mbstate ();
6006 /************************************************
6008 * MULTIBYTE CHARACTER HANDLING *
6010 ************************************************/
6012 #if defined (HANDLE_MULTIBYTE)
6016 int i, previ, len, c;
6017 mbstate_t mbs, prevs;
6020 if (shell_input_line == NULL)
6022 len = strlen (shell_input_line); /* XXX - shell_input_line_len ? */
6023 FREE (shell_input_line_property);
6024 shell_input_line_property = (char *)xmalloc (len + 1);
6026 memset (&prevs, '\0', sizeof (mbstate_t));
6027 for (i = previ = 0; i < len; i++)
6031 c = shell_input_line[i];
6035 for (j = i; j < len; j++)
6036 shell_input_line_property[j] = 1;
6040 mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
6041 if (mbclen == 1 || mbclen == (size_t)-1)
6046 else if (mbclen == (size_t)-2)
6048 else if (mbclen > 1)
6056 /* XXX - what to do if mbrlen returns 0? (null wide character) */
6058 for (j = i; j < len; j++)
6059 shell_input_line_property[j] = 1;
6063 shell_input_line_property[i] = mbclen;
6066 #endif /* HANDLE_MULTIBYTE */