1 /* parse.y - Yacc grammar for bash. */
3 /* Copyright (C) 1989-2012 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 */
48 #include "typemax.h" /* SIZE_MAX if needed */
52 #include "mailcheck.h"
55 #include "builtins/common.h"
56 #include "builtins/builtext.h"
60 #if defined (READLINE)
61 # include "bashline.h"
62 # include <readline/readline.h>
66 # include "bashhist.h"
67 # include <readline/history.h>
70 #if defined (JOB_CONTROL)
72 #endif /* JOB_CONTROL */
77 typedef void *alias_t;
80 #if defined (PROMPT_STRING_DECODE)
82 # include <sys/param.h>
85 # if defined (TM_IN_SYS_TIME)
86 # include <sys/types.h>
87 # include <sys/time.h>
88 # endif /* TM_IN_SYS_TIME */
90 #endif /* PROMPT_STRING_DECODE */
92 #define RE_READ_TOKEN -99
93 #define NO_EXPANSION -100
101 #if defined (HANDLE_MULTIBYTE)
102 # define last_shell_getc_is_singlebyte \
103 ((shell_input_line_index > 1) \
104 ? shell_input_line_property[shell_input_line_index - 1] \
106 # define MBTEST(x) ((x) && last_shell_getc_is_singlebyte)
108 # define last_shell_getc_is_singlebyte 1
109 # define MBTEST(x) ((x))
112 #if defined (EXTENDED_GLOB)
113 extern int extended_glob;
116 extern int eof_encountered;
117 extern int no_line_editing, running_under_emacs;
118 extern int current_command_number;
119 extern int sourcelevel, parse_and_execute_level;
120 extern int posixly_correct;
121 extern int last_command_exit_value;
122 extern pid_t last_command_subst_pid;
123 extern char *shell_name, *current_host_name;
124 extern char *dist_version;
125 extern int patch_level;
126 extern int dump_translatable_strings, dump_po_strings;
127 extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
128 #if defined (BUFFERED_INPUT)
129 extern int bash_input_fd_changed;
133 /* **************************************************************** */
135 /* "Forward" declarations */
137 /* **************************************************************** */
140 static void debug_parser __P((int));
143 static int yy_getc __P((void));
144 static int yy_ungetc __P((int));
146 #if defined (READLINE)
147 static int yy_readline_get __P((void));
148 static int yy_readline_unget __P((int));
151 static int yy_string_get __P((void));
152 static int yy_string_unget __P((int));
153 static void rewind_input_string __P((void));
154 static int yy_stream_get __P((void));
155 static int yy_stream_unget __P((int));
157 static int shell_getc __P((int));
158 static void shell_ungetc __P((int));
159 static void discard_until __P((int));
161 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
162 static void push_string __P((char *, int, alias_t *));
163 static void pop_string __P((void));
164 static void free_string_list __P((void));
167 static char *read_a_line __P((int));
169 static int reserved_word_acceptable __P((int));
170 static int yylex __P((void));
172 static void push_heredoc __P((REDIRECT *));
173 static char *mk_alexpansion __P((char *));
174 static int alias_expand_token __P((char *));
175 static int time_command_acceptable __P((void));
176 static int special_case_tokens __P((char *));
177 static int read_token __P((int));
178 static char *parse_matched_pair __P((int, int, int, int *, int));
179 static char *parse_comsub __P((int, int, int, int *, int));
180 #if defined (ARRAY_VARS)
181 static char *parse_compound_assignment __P((int *));
183 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
184 static int parse_dparen __P((int));
185 static int parse_arith_cmd __P((char **, int));
187 #if defined (COND_COMMAND)
188 static void cond_error __P((void));
189 static COND_COM *cond_expr __P((void));
190 static COND_COM *cond_or __P((void));
191 static COND_COM *cond_and __P((void));
192 static COND_COM *cond_term __P((void));
193 static int cond_skip_newlines __P((void));
194 static COMMAND *parse_cond_command __P((void));
196 #if defined (ARRAY_VARS)
197 static int token_is_assignment __P((char *, int));
198 static int token_is_ident __P((char *, int));
200 static int read_token_word __P((int));
201 static void discard_parser_constructs __P((int));
203 static char *error_token_from_token __P((int));
204 static char *error_token_from_text __P((void));
205 static void print_offending_line __P((void));
206 static void report_syntax_error __P((char *));
208 static void handle_eof_input_unit __P((void));
209 static void prompt_again __P((void));
211 static void reset_readline_prompt __P((void));
213 static void print_prompt __P((void));
215 #if defined (HANDLE_MULTIBYTE)
216 static void set_line_mbstate __P((void));
217 static char *shell_input_line_property = NULL;
219 # define set_line_mbstate()
222 extern int yyerror __P((const char *));
228 /* Default prompt strings */
229 char *primary_prompt = PPROMPT;
230 char *secondary_prompt = SPROMPT;
232 /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
233 char *ps1_prompt, *ps2_prompt;
235 /* Handle on the current prompt string. Indirectly points through
236 ps1_ or ps2_prompt. */
237 char **prompt_string_pointer = (char **)NULL;
238 char *current_prompt_string;
240 /* Non-zero means we expand aliases in commands. */
241 int expand_aliases = 0;
243 /* If non-zero, the decoded prompt string undergoes parameter and
244 variable substitution, command substitution, arithmetic substitution,
245 string expansion, process substitution, and quote removal in
246 decode_prompt_string. */
249 /* If non-zero, $'...' and $"..." are expanded when they appear within
250 a ${...} expansion, even when the expansion appears within double
252 int extended_quote = 1;
254 /* The number of lines read from input while creating the current command. */
255 int current_command_line_count;
257 /* The number of lines in a command saved while we run parse_and_execute */
258 int saved_command_line_count;
260 /* The token that currently denotes the end of parse. */
263 /* The token currently being read. */
266 /* The current parser state. */
269 /* Variables to manage the task of reading here documents, because we need to
270 defer the reading until after a complete command has been collected. */
271 #define HEREDOC_MAX 16
273 static REDIRECT *redir_stack[HEREDOC_MAX];
276 /* Where shell input comes from. History expansion is performed on each
277 line when the shell is interactive. */
278 static char *shell_input_line = (char *)NULL;
279 static size_t shell_input_line_index;
280 static size_t shell_input_line_size; /* Amount allocated for shell_input_line. */
281 static size_t shell_input_line_len; /* strlen (shell_input_line) */
283 /* Either zero or EOF. */
284 static int shell_input_line_terminator;
286 /* The line number in a script on which a function definition starts. */
287 static int function_dstart;
289 /* The line number in a script on which a function body starts. */
290 static int function_bstart;
292 /* The line number in a script at which an arithmetic for command starts. */
293 static int arith_for_lineno;
295 /* The decoded prompt string. Used if READLINE is not defined or if
296 editing is turned off. Analogous to current_readline_prompt. */
297 static char *current_decoded_prompt;
299 /* The last read token, or NULL. read_token () uses this for context
301 static int last_read_token;
303 /* The token read prior to last_read_token. */
304 static int token_before_that;
306 /* The token read prior to token_before_that. */
307 static int two_tokens_ago;
309 static int global_extglob;
311 /* The line number in a script where the word in a `case WORD', `select WORD'
312 or `for WORD' begins. This is a nested command maximum, since the array
313 index is decremented after a case, select, or for command is parsed. */
314 #define MAX_CASE_NEST 128
315 static int word_lineno[MAX_CASE_NEST+1];
316 static int word_top = -1;
318 /* If non-zero, it is the token that we want read_token to return
319 regardless of what text is (or isn't) present to be read. This
320 is reset by read_token. If token_to_read == WORD or
321 ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
322 static int token_to_read;
323 static WORD_DESC *word_desc_to_read;
325 static REDIRECTEE source;
326 static REDIRECTEE redir;
330 WORD_DESC *word; /* the word that we read. */
331 int number; /* the number that we read. */
332 WORD_LIST *word_list;
336 PATTERN_LIST *pattern;
339 /* Reserved words. Members of the first group are only recognized
340 in the case that they are preceded by a list_terminator. Members
341 of the second group are for [[...]] commands. Members of the
342 third group are recognized only under special circumstances. */
343 %token IF THEN ELSE ELIF FI CASE ESAC FOR SELECT WHILE UNTIL DO DONE FUNCTION COPROC
344 %token COND_START COND_END COND_ERROR
345 %token IN BANG TIME TIMEOPT TIMEIGN
347 /* More general tokens. yylex () knows how to make these. */
348 %token <word> WORD ASSIGNMENT_WORD REDIR_WORD
349 %token <number> NUMBER
350 %token <word_list> ARITH_CMD ARITH_FOR_EXPRS
351 %token <command> COND_CMD
352 %token AND_AND OR_OR GREATER_GREATER LESS_LESS LESS_AND LESS_LESS_LESS
353 %token GREATER_AND SEMI_SEMI SEMI_AND SEMI_SEMI_AND
354 %token LESS_LESS_MINUS AND_GREATER AND_GREATER_GREATER LESS_GREATER
355 %token GREATER_BAR BAR_AND
357 /* The types that the various syntactical units return. */
359 %type <command> inputunit command pipeline pipeline_command
360 %type <command> list list0 list1 compound_list simple_list simple_list1
361 %type <command> simple_command shell_command
362 %type <command> for_command select_command case_command group_command
363 %type <command> arith_command
364 %type <command> cond_command
365 %type <command> arith_for_command
366 %type <command> coproc
367 %type <command> function_def function_body if_command elif_clause subshell
368 %type <redirect> redirection redirection_list
369 %type <element> simple_command_element
370 %type <word_list> word_list pattern
371 %type <pattern> pattern_list case_clause_sequence case_clause
372 %type <number> timespec
373 %type <number> list_terminator
377 %left '&' ';' '\n' yacc_EOF
382 inputunit: simple_list simple_list_terminator
384 /* Case of regular command. Discard the error
385 safety net,and return the command just parsed. */
388 /* discard_parser_constructs (0); */
389 if (parser_state & PST_CMDSUBST)
390 parser_state |= PST_EOFTOKEN;
395 /* Case of regular command, but not a very
396 interesting one. Return a NULL command. */
397 global_command = (COMMAND *)NULL;
398 if (parser_state & PST_CMDSUBST)
399 parser_state |= PST_EOFTOKEN;
404 /* Error during parsing. Return NULL command. */
405 global_command = (COMMAND *)NULL;
407 /* discard_parser_constructs (1); */
408 if (interactive && parse_and_execute_level == 0)
419 /* Case of EOF seen by itself. Do ignoreeof or
421 global_command = (COMMAND *)NULL;
422 handle_eof_input_unit ();
428 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
430 { $$ = make_word_list ($2, $1); }
433 redirection: '>' WORD
437 $$ = make_redirection (source, r_output_direction, redir, 0);
443 $$ = make_redirection (source, r_input_direction, redir, 0);
449 $$ = make_redirection (source, r_output_direction, redir, 0);
455 $$ = make_redirection (source, r_input_direction, redir, 0);
457 | REDIR_WORD '>' WORD
459 source.filename = $1;
461 $$ = make_redirection (source, r_output_direction, redir, REDIR_VARASSIGN);
463 | REDIR_WORD '<' WORD
465 source.filename = $1;
467 $$ = make_redirection (source, r_input_direction, redir, REDIR_VARASSIGN);
469 | GREATER_GREATER WORD
473 $$ = make_redirection (source, r_appending_to, redir, 0);
475 | NUMBER GREATER_GREATER WORD
479 $$ = make_redirection (source, r_appending_to, redir, 0);
481 | REDIR_WORD GREATER_GREATER WORD
483 source.filename = $1;
485 $$ = make_redirection (source, r_appending_to, redir, REDIR_VARASSIGN);
491 $$ = make_redirection (source, r_output_force, redir, 0);
493 | NUMBER GREATER_BAR WORD
497 $$ = make_redirection (source, r_output_force, redir, 0);
499 | REDIR_WORD GREATER_BAR WORD
501 source.filename = $1;
503 $$ = make_redirection (source, r_output_force, redir, REDIR_VARASSIGN);
509 $$ = make_redirection (source, r_input_output, redir, 0);
511 | NUMBER LESS_GREATER WORD
515 $$ = make_redirection (source, r_input_output, redir, 0);
517 | REDIR_WORD LESS_GREATER WORD
519 source.filename = $1;
521 $$ = make_redirection (source, r_input_output, redir, REDIR_VARASSIGN);
527 $$ = make_redirection (source, r_reading_until, redir, 0);
530 | NUMBER LESS_LESS WORD
534 $$ = make_redirection (source, r_reading_until, redir, 0);
537 | REDIR_WORD LESS_LESS WORD
539 source.filename = $1;
541 $$ = make_redirection (source, r_reading_until, redir, REDIR_VARASSIGN);
544 | LESS_LESS_MINUS WORD
548 $$ = make_redirection (source, r_deblank_reading_until, redir, 0);
551 | NUMBER LESS_LESS_MINUS WORD
555 $$ = make_redirection (source, r_deblank_reading_until, redir, 0);
558 | REDIR_WORD LESS_LESS_MINUS WORD
560 source.filename = $1;
562 $$ = make_redirection (source, r_deblank_reading_until, redir, REDIR_VARASSIGN);
565 | LESS_LESS_LESS WORD
569 $$ = make_redirection (source, r_reading_string, redir, 0);
571 | NUMBER LESS_LESS_LESS WORD
575 $$ = make_redirection (source, r_reading_string, redir, 0);
577 | REDIR_WORD LESS_LESS_LESS WORD
579 source.filename = $1;
581 $$ = make_redirection (source, r_reading_string, redir, REDIR_VARASSIGN);
587 $$ = make_redirection (source, r_duplicating_input, redir, 0);
589 | NUMBER LESS_AND NUMBER
593 $$ = make_redirection (source, r_duplicating_input, redir, 0);
595 | REDIR_WORD LESS_AND NUMBER
597 source.filename = $1;
599 $$ = make_redirection (source, r_duplicating_input, redir, REDIR_VARASSIGN);
605 $$ = make_redirection (source, r_duplicating_output, redir, 0);
607 | NUMBER GREATER_AND NUMBER
611 $$ = make_redirection (source, r_duplicating_output, redir, 0);
613 | REDIR_WORD GREATER_AND NUMBER
615 source.filename = $1;
617 $$ = make_redirection (source, r_duplicating_output, redir, REDIR_VARASSIGN);
623 $$ = make_redirection (source, r_duplicating_input_word, redir, 0);
625 | NUMBER LESS_AND WORD
629 $$ = make_redirection (source, r_duplicating_input_word, redir, 0);
631 | REDIR_WORD LESS_AND WORD
633 source.filename = $1;
635 $$ = make_redirection (source, r_duplicating_input_word, redir, REDIR_VARASSIGN);
641 $$ = make_redirection (source, r_duplicating_output_word, redir, 0);
643 | NUMBER GREATER_AND WORD
647 $$ = make_redirection (source, r_duplicating_output_word, redir, 0);
649 | REDIR_WORD GREATER_AND WORD
651 source.filename = $1;
653 $$ = make_redirection (source, r_duplicating_output_word, redir, REDIR_VARASSIGN);
659 $$ = make_redirection (source, r_close_this, redir, 0);
661 | NUMBER GREATER_AND '-'
665 $$ = make_redirection (source, r_close_this, redir, 0);
667 | REDIR_WORD GREATER_AND '-'
669 source.filename = $1;
671 $$ = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
677 $$ = make_redirection (source, r_close_this, redir, 0);
679 | NUMBER LESS_AND '-'
683 $$ = make_redirection (source, r_close_this, redir, 0);
685 | REDIR_WORD LESS_AND '-'
687 source.filename = $1;
689 $$ = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
695 $$ = make_redirection (source, r_err_and_out, redir, 0);
697 | AND_GREATER_GREATER WORD
701 $$ = make_redirection (source, r_append_err_and_out, redir, 0);
705 simple_command_element: WORD
706 { $$.word = $1; $$.redirect = 0; }
708 { $$.word = $1; $$.redirect = 0; }
710 { $$.redirect = $1; $$.word = 0; }
713 redirection_list: redirection
717 | redirection_list redirection
719 register REDIRECT *t;
721 for (t = $1; t->next; t = t->next)
728 simple_command: simple_command_element
729 { $$ = make_simple_command ($1, (COMMAND *)NULL); }
730 | simple_command simple_command_element
731 { $$ = make_simple_command ($2, $1); }
734 command: simple_command
735 { $$ = clean_simple_command ($1); }
738 | shell_command redirection_list
745 register REDIRECT *t;
746 for (t = tc->redirects; t->next; t = t->next)
760 shell_command: for_command
764 | WHILE compound_list DO compound_list DONE
765 { $$ = make_while_command ($2, $4); }
766 | UNTIL compound_list DO compound_list DONE
767 { $$ = make_until_command ($2, $4); }
784 for_command: FOR WORD newline_list DO compound_list DONE
786 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
787 if (word_top > 0) word_top--;
789 | FOR WORD newline_list '{' compound_list '}'
791 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
792 if (word_top > 0) word_top--;
794 | FOR WORD ';' newline_list DO compound_list DONE
796 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
797 if (word_top > 0) word_top--;
799 | FOR WORD ';' newline_list '{' compound_list '}'
801 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
802 if (word_top > 0) word_top--;
804 | FOR WORD newline_list IN word_list list_terminator newline_list DO compound_list DONE
806 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
807 if (word_top > 0) word_top--;
809 | FOR WORD newline_list IN word_list list_terminator newline_list '{' compound_list '}'
811 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
812 if (word_top > 0) word_top--;
814 | FOR WORD newline_list IN list_terminator newline_list DO compound_list DONE
816 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
817 if (word_top > 0) word_top--;
819 | FOR WORD newline_list IN list_terminator newline_list '{' compound_list '}'
821 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
822 if (word_top > 0) word_top--;
826 arith_for_command: FOR ARITH_FOR_EXPRS list_terminator newline_list DO compound_list DONE
828 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
829 if (word_top > 0) word_top--;
831 | FOR ARITH_FOR_EXPRS list_terminator newline_list '{' compound_list '}'
833 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
834 if (word_top > 0) word_top--;
836 | FOR ARITH_FOR_EXPRS DO compound_list DONE
838 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
839 if (word_top > 0) word_top--;
841 | FOR ARITH_FOR_EXPRS '{' compound_list '}'
843 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
844 if (word_top > 0) word_top--;
848 select_command: SELECT WORD newline_list DO list DONE
850 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
851 if (word_top > 0) word_top--;
853 | SELECT WORD newline_list '{' list '}'
855 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
856 if (word_top > 0) word_top--;
858 | SELECT WORD ';' newline_list DO list DONE
860 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
861 if (word_top > 0) word_top--;
863 | SELECT WORD ';' newline_list '{' list '}'
865 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
866 if (word_top > 0) word_top--;
868 | SELECT WORD newline_list IN word_list list_terminator newline_list DO list DONE
870 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
871 if (word_top > 0) word_top--;
873 | SELECT WORD newline_list IN word_list list_terminator newline_list '{' list '}'
875 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
876 if (word_top > 0) word_top--;
880 case_command: CASE WORD newline_list IN newline_list ESAC
882 $$ = make_case_command ($2, (PATTERN_LIST *)NULL, word_lineno[word_top]);
883 if (word_top > 0) word_top--;
885 | CASE WORD newline_list IN case_clause_sequence newline_list ESAC
887 $$ = make_case_command ($2, $5, word_lineno[word_top]);
888 if (word_top > 0) word_top--;
890 | CASE WORD newline_list IN case_clause ESAC
892 $$ = make_case_command ($2, $5, word_lineno[word_top]);
893 if (word_top > 0) word_top--;
897 function_def: WORD '(' ')' newline_list function_body
898 { $$ = make_function_def ($1, $5, function_dstart, function_bstart); }
900 | FUNCTION WORD '(' ')' newline_list function_body
901 { $$ = make_function_def ($2, $6, function_dstart, function_bstart); }
903 | FUNCTION WORD newline_list function_body
904 { $$ = make_function_def ($2, $4, function_dstart, function_bstart); }
907 function_body: shell_command
909 | shell_command redirection_list
914 /* According to Posix.2 3.9.5, redirections
915 specified after the body of a function should
916 be attached to the function and performed when
917 the function is executed, not as part of the
918 function definition command. */
919 /* XXX - I don't think it matters, but we might
920 want to change this in the future to avoid
921 problems differentiating between a function
922 definition with a redirection and a function
923 definition containing a single command with a
924 redirection. The two are semantically equivalent,
925 though -- the only difference is in how the
926 command printing code displays the redirections. */
929 register REDIRECT *t;
930 for (t = tc->redirects; t->next; t = t->next)
940 subshell: '(' compound_list ')'
942 $$ = make_subshell_command ($2);
943 $$->flags |= CMD_WANT_SUBSHELL;
947 coproc: COPROC shell_command
949 $$ = make_coproc_command ("COPROC", $2);
950 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
952 | COPROC shell_command redirection_list
959 register REDIRECT *t;
960 for (t = tc->redirects; t->next; t = t->next)
966 $$ = make_coproc_command ("COPROC", $2);
967 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
969 | COPROC WORD shell_command
971 $$ = make_coproc_command ($2->word, $3);
972 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
974 | COPROC WORD shell_command redirection_list
981 register REDIRECT *t;
982 for (t = tc->redirects; t->next; t = t->next)
988 $$ = make_coproc_command ($2->word, $3);
989 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
991 | COPROC simple_command
993 $$ = make_coproc_command ("COPROC", clean_simple_command ($2));
994 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
998 if_command: IF compound_list THEN compound_list FI
999 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
1000 | IF compound_list THEN compound_list ELSE compound_list FI
1001 { $$ = make_if_command ($2, $4, $6); }
1002 | IF compound_list THEN compound_list elif_clause FI
1003 { $$ = make_if_command ($2, $4, $5); }
1007 group_command: '{' compound_list '}'
1008 { $$ = make_group_command ($2); }
1011 arith_command: ARITH_CMD
1012 { $$ = make_arith_command ($1); }
1015 cond_command: COND_START COND_CMD COND_END
1019 elif_clause: ELIF compound_list THEN compound_list
1020 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
1021 | ELIF compound_list THEN compound_list ELSE compound_list
1022 { $$ = make_if_command ($2, $4, $6); }
1023 | ELIF compound_list THEN compound_list elif_clause
1024 { $$ = make_if_command ($2, $4, $5); }
1027 case_clause: pattern_list
1028 | case_clause_sequence pattern_list
1029 { $2->next = $1; $$ = $2; }
1032 pattern_list: newline_list pattern ')' compound_list
1033 { $$ = make_pattern_list ($2, $4); }
1034 | newline_list pattern ')' newline_list
1035 { $$ = make_pattern_list ($2, (COMMAND *)NULL); }
1036 | newline_list '(' pattern ')' compound_list
1037 { $$ = make_pattern_list ($3, $5); }
1038 | newline_list '(' pattern ')' newline_list
1039 { $$ = make_pattern_list ($3, (COMMAND *)NULL); }
1042 case_clause_sequence: pattern_list SEMI_SEMI
1044 | case_clause_sequence pattern_list SEMI_SEMI
1045 { $2->next = $1; $$ = $2; }
1046 | pattern_list SEMI_AND
1047 { $1->flags |= CASEPAT_FALLTHROUGH; $$ = $1; }
1048 | case_clause_sequence pattern_list SEMI_AND
1049 { $2->flags |= CASEPAT_FALLTHROUGH; $2->next = $1; $$ = $2; }
1050 | pattern_list SEMI_SEMI_AND
1051 { $1->flags |= CASEPAT_TESTNEXT; $$ = $1; }
1052 | case_clause_sequence pattern_list SEMI_SEMI_AND
1053 { $2->flags |= CASEPAT_TESTNEXT; $2->next = $1; $$ = $2; }
1057 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
1059 { $$ = make_word_list ($3, $1); }
1062 /* A list allows leading or trailing newlines and
1063 newlines as operators (equivalent to semicolons).
1064 It must end with a newline or semicolon.
1065 Lists are used within commands such as if, for, while. */
1067 list: newline_list list0
1071 gather_here_documents ();
1076 | newline_list list1
1082 list0: list1 '\n' newline_list
1083 | list1 '&' newline_list
1085 if ($1->type == cm_connection)
1086 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
1088 $$ = command_connect ($1, (COMMAND *)NULL, '&');
1090 | list1 ';' newline_list
1094 list1: list1 AND_AND newline_list list1
1095 { $$ = command_connect ($1, $4, AND_AND); }
1096 | list1 OR_OR newline_list list1
1097 { $$ = command_connect ($1, $4, OR_OR); }
1098 | list1 '&' newline_list list1
1100 if ($1->type == cm_connection)
1101 $$ = connect_async_list ($1, $4, '&');
1103 $$ = command_connect ($1, $4, '&');
1105 | list1 ';' newline_list list1
1106 { $$ = command_connect ($1, $4, ';'); }
1107 | list1 '\n' newline_list list1
1108 { $$ = command_connect ($1, $4, ';'); }
1113 simple_list_terminator: '\n'
1117 list_terminator:'\n'
1129 /* A simple_list is a list that contains no significant newlines
1130 and no leading or trailing newlines. Newlines are allowed
1131 only following operators, where they are not significant.
1133 This is what an inputunit consists of. */
1135 simple_list: simple_list1
1139 gather_here_documents ();
1140 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1142 global_command = $1;
1143 eof_encountered = 0;
1144 rewind_input_string ();
1150 if ($1->type == cm_connection)
1151 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
1153 $$ = command_connect ($1, (COMMAND *)NULL, '&');
1155 gather_here_documents ();
1156 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1158 global_command = $1;
1159 eof_encountered = 0;
1160 rewind_input_string ();
1168 gather_here_documents ();
1169 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1171 global_command = $1;
1172 eof_encountered = 0;
1173 rewind_input_string ();
1179 simple_list1: simple_list1 AND_AND newline_list simple_list1
1180 { $$ = command_connect ($1, $4, AND_AND); }
1181 | simple_list1 OR_OR newline_list simple_list1
1182 { $$ = command_connect ($1, $4, OR_OR); }
1183 | simple_list1 '&' simple_list1
1185 if ($1->type == cm_connection)
1186 $$ = connect_async_list ($1, $3, '&');
1188 $$ = command_connect ($1, $3, '&');
1190 | simple_list1 ';' simple_list1
1191 { $$ = command_connect ($1, $3, ';'); }
1197 pipeline_command: pipeline
1199 | BANG pipeline_command
1202 $2->flags ^= CMD_INVERT_RETURN; /* toggle */
1205 | timespec pipeline_command
1211 | timespec list_terminator
1215 /* Boy, this is unclean. `time' by itself can
1216 time a null command. We cheat and push a
1217 newline back if the list_terminator was a newline
1218 to avoid the double-newline problem (one to
1219 terminate this, one to terminate the command) */
1222 $$ = make_simple_command (x, (COMMAND *)NULL);
1224 /* XXX - let's cheat and push a newline back */
1226 token_to_read = '\n';
1228 | BANG list_terminator
1232 /* This is just as unclean. Posix says that `!'
1233 by itself should be equivalent to `false'.
1235 newline back if the list_terminator was a newline
1236 to avoid the double-newline problem (one to
1237 terminate this, one to terminate the command) */
1240 $$ = make_simple_command (x, (COMMAND *)NULL);
1241 $$->flags |= CMD_INVERT_RETURN;
1242 /* XXX - let's cheat and push a newline back */
1244 token_to_read = '\n';
1248 pipeline: pipeline '|' newline_list pipeline
1249 { $$ = command_connect ($1, $4, '|'); }
1250 | pipeline BAR_AND newline_list pipeline
1252 /* Make cmd1 |& cmd2 equivalent to cmd1 2>&1 | cmd2 */
1257 tc = $1->type == cm_simple ? (COMMAND *)$1->value.Simple : $1;
1260 r = make_redirection (sd, r_duplicating_output, rd, 0);
1263 register REDIRECT *t;
1264 for (t = tc->redirects; t->next; t = t->next)
1271 $$ = command_connect ($1, $4, '|');
1278 { $$ = CMD_TIME_PIPELINE; }
1280 { $$ = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
1281 | TIME TIMEOPT TIMEIGN
1282 { $$ = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
1286 /* Initial size to allocate for tokens, and the
1287 amount to grow them by. */
1288 #define TOKEN_DEFAULT_INITIAL_SIZE 496
1289 #define TOKEN_DEFAULT_GROW_SIZE 512
1291 /* Should we call prompt_again? */
1292 #define SHOULD_PROMPT() \
1293 (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
1296 # define expanding_alias() (pushed_string_list && pushed_string_list->expander)
1298 # define expanding_alias() 0
1301 /* Global var is non-zero when end of file has been reached. */
1302 int EOF_Reached = 0;
1315 /* yy_getc () returns the next available character from input or EOF.
1316 yy_ungetc (c) makes `c' the next character to read.
1317 init_yy_io (get, unget, type, location) makes the function GET the
1318 installed function for getting the next character, makes UNGET the
1319 installed function for un-getting a character, sets the type of stream
1320 (either string or file) from TYPE, and makes LOCATION point to where
1321 the input is coming from. */
1323 /* Unconditionally returns end-of-file. */
1330 /* Variable containing the current get and unget functions.
1331 See ./input.h for a clearer description. */
1332 BASH_INPUT bash_input;
1334 /* Set all of the fields in BASH_INPUT to NULL. Free bash_input.name if it
1335 is non-null, avoiding a memory leak. */
1337 initialize_bash_input ()
1339 bash_input.type = st_none;
1340 FREE (bash_input.name);
1341 bash_input.name = (char *)NULL;
1342 bash_input.location.file = (FILE *)NULL;
1343 bash_input.location.string = (char *)NULL;
1344 bash_input.getter = (sh_cget_func_t *)NULL;
1345 bash_input.ungetter = (sh_cunget_func_t *)NULL;
1348 /* Set the contents of the current bash input stream from
1349 GET, UNGET, TYPE, NAME, and LOCATION. */
1351 init_yy_io (get, unget, type, name, location)
1352 sh_cget_func_t *get;
1353 sh_cunget_func_t *unget;
1354 enum stream_type type;
1356 INPUT_STREAM location;
1358 bash_input.type = type;
1359 FREE (bash_input.name);
1360 bash_input.name = name ? savestring (name) : (char *)NULL;
1364 memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
1366 bash_input.location = location;
1368 bash_input.getter = get;
1369 bash_input.ungetter = unget;
1375 return (bash_input.name ? bash_input.name : "stdin");
1378 /* Call this to get the next character of input. */
1382 return (*(bash_input.getter)) ();
1385 /* Call this to unget C. That is, to make C the next character
1391 return (*(bash_input.ungetter)) (c);
1394 #if defined (BUFFERED_INPUT)
1395 #ifdef INCLUDE_UNUSED
1397 input_file_descriptor ()
1399 switch (bash_input.type)
1402 return (fileno (bash_input.location.file));
1404 return (bash_input.location.buffered_fd);
1407 return (fileno (stdin));
1411 #endif /* BUFFERED_INPUT */
1413 /* **************************************************************** */
1415 /* Let input be read from readline (). */
1417 /* **************************************************************** */
1419 #if defined (READLINE)
1420 char *current_readline_prompt = (char *)NULL;
1421 char *current_readline_line = (char *)NULL;
1422 int current_readline_line_index = 0;
1427 SigHandler *old_sigint;
1431 if (!current_readline_line)
1433 if (!bash_readline_initialized)
1434 initialize_readline ();
1436 #if defined (JOB_CONTROL)
1438 give_terminal_to (shell_pgrp, 0);
1439 #endif /* JOB_CONTROL */
1441 old_sigint = (SigHandler *)IMPOSSIBLE_TRAP_HANDLER;
1442 if (signal_is_ignored (SIGINT) == 0)
1444 /* interrupt_immediately++; */
1445 old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
1448 current_readline_line = readline (current_readline_prompt ?
1449 current_readline_prompt : "");
1452 if (signal_is_ignored (SIGINT) == 0)
1454 /* interrupt_immediately--; */
1455 if (old_sigint != IMPOSSIBLE_TRAP_HANDLER)
1456 set_signal_handler (SIGINT, old_sigint);
1460 /* Reset the prompt to the decoded value of prompt_string_pointer. */
1461 reset_readline_prompt ();
1464 if (current_readline_line == 0)
1467 current_readline_line_index = 0;
1468 line_len = strlen (current_readline_line);
1470 current_readline_line = (char *)xrealloc (current_readline_line, 2 + line_len);
1471 current_readline_line[line_len++] = '\n';
1472 current_readline_line[line_len] = '\0';
1475 if (current_readline_line[current_readline_line_index] == 0)
1477 free (current_readline_line);
1478 current_readline_line = (char *)NULL;
1479 return (yy_readline_get ());
1483 c = current_readline_line[current_readline_line_index++];
1489 yy_readline_unget (c)
1492 if (current_readline_line_index && current_readline_line)
1493 current_readline_line[--current_readline_line_index] = c;
1498 with_input_from_stdin ()
1500 INPUT_STREAM location;
1502 if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
1504 location.string = current_readline_line;
1505 init_yy_io (yy_readline_get, yy_readline_unget,
1506 st_stdin, "readline stdin", location);
1510 #else /* !READLINE */
1513 with_input_from_stdin ()
1515 with_input_from_stream (stdin, "stdin");
1517 #endif /* !READLINE */
1519 /* **************************************************************** */
1521 /* Let input come from STRING. STRING is zero terminated. */
1523 /* **************************************************************** */
1528 register char *string;
1529 register unsigned char c;
1531 string = bash_input.location.string;
1533 /* If the string doesn't exist, or is empty, EOF found. */
1534 if (string && *string)
1537 bash_input.location.string = string;
1548 *(--bash_input.location.string) = c;
1553 with_input_from_string (string, name)
1557 INPUT_STREAM location;
1559 location.string = string;
1560 init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
1563 /* Count the number of characters we've consumed from bash_input.location.string
1564 and read into shell_input_line, but have not returned from shell_getc.
1565 That is the true input location. Rewind bash_input.location.string by
1566 that number of characters, so it points to the last character actually
1567 consumed by the parser. */
1569 rewind_input_string ()
1573 /* number of unconsumed characters in the input -- XXX need to take newlines
1574 into account, e.g., $(...\n) */
1575 xchars = shell_input_line_len - shell_input_line_index;
1576 if (bash_input.location.string[-1] == '\n')
1579 /* XXX - how to reflect bash_input.location.string back to string passed to
1580 parse_and_execute or xparse_dolparen? xparse_dolparen needs to know how
1581 far into the string we parsed. parse_and_execute knows where bash_input.
1582 location.string is, and how far from orig_string that is -- that's the
1583 number of characters the command consumed. */
1585 /* bash_input.location.string - xchars should be where we parsed to */
1586 /* need to do more validation on xchars value for sanity -- test cases. */
1587 bash_input.location.string -= xchars;
1590 /* **************************************************************** */
1592 /* Let input come from STREAM. */
1594 /* **************************************************************** */
1596 /* These two functions used to test the value of the HAVE_RESTARTABLE_SYSCALLS
1597 define, and just use getc/ungetc if it was defined, but since bash
1598 installs its signal handlers without the SA_RESTART flag, some signals
1599 (like SIGCHLD, SIGWINCH, etc.) received during a read(2) will not cause
1600 the read to be restarted. We need to restart it ourselves. */
1608 if (bash_input.location.file)
1612 interrupt_immediately++;
1615 /* XXX - don't need terminate_immediately; getc_with_restart checks
1616 for terminating signals itself if read returns < 0 */
1617 result = getc_with_restart (bash_input.location.file);
1621 interrupt_immediately--;
1631 return (ungetc_with_restart (c, bash_input.location.file));
1635 with_input_from_stream (stream, name)
1639 INPUT_STREAM location;
1641 location.file = stream;
1642 init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
1645 typedef struct stream_saver {
1646 struct stream_saver *next;
1647 BASH_INPUT bash_input;
1649 #if defined (BUFFERED_INPUT)
1650 BUFFERED_STREAM *bstream;
1651 #endif /* BUFFERED_INPUT */
1654 /* The globally known line number. */
1655 int line_number = 0;
1657 /* The line number offset set by assigning to LINENO. Not currently used. */
1658 int line_number_base = 0;
1660 #if defined (COND_COMMAND)
1661 static int cond_lineno;
1662 static int cond_token;
1665 STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
1668 push_stream (reset_lineno)
1671 STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
1673 xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
1675 #if defined (BUFFERED_INPUT)
1676 saver->bstream = (BUFFERED_STREAM *)NULL;
1677 /* If we have a buffered stream, clear out buffers[fd]. */
1678 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1679 saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
1680 (BUFFERED_STREAM *)NULL);
1681 #endif /* BUFFERED_INPUT */
1683 saver->line = line_number;
1684 bash_input.name = (char *)NULL;
1685 saver->next = stream_list;
1686 stream_list = saver;
1699 STREAM_SAVER *saver = stream_list;
1702 stream_list = stream_list->next;
1704 init_yy_io (saver->bash_input.getter,
1705 saver->bash_input.ungetter,
1706 saver->bash_input.type,
1707 saver->bash_input.name,
1708 saver->bash_input.location);
1710 #if defined (BUFFERED_INPUT)
1711 /* If we have a buffered stream, restore buffers[fd]. */
1712 /* If the input file descriptor was changed while this was on the
1713 save stack, update the buffered fd to the new file descriptor and
1714 re-establish the buffer <-> bash_input fd correspondence. */
1715 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1717 if (bash_input_fd_changed)
1719 bash_input_fd_changed = 0;
1720 if (default_buffered_input >= 0)
1722 bash_input.location.buffered_fd = default_buffered_input;
1723 saver->bstream->b_fd = default_buffered_input;
1724 SET_CLOSE_ON_EXEC (default_buffered_input);
1727 /* XXX could free buffered stream returned as result here. */
1728 set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
1730 #endif /* BUFFERED_INPUT */
1732 line_number = saver->line;
1734 FREE (saver->bash_input.name);
1739 /* Return 1 if a stream of type TYPE is saved on the stack. */
1741 stream_on_stack (type)
1742 enum stream_type type;
1744 register STREAM_SAVER *s;
1746 for (s = stream_list; s; s = s->next)
1747 if (s->bash_input.type == type)
1752 /* Save the current token state and return it in a malloced array. */
1758 ret = (int *)xmalloc (4 * sizeof (int));
1759 ret[0] = last_read_token;
1760 ret[1] = token_before_that;
1761 ret[2] = two_tokens_ago;
1762 ret[3] = current_token;
1767 restore_token_state (ts)
1772 last_read_token = ts[0];
1773 token_before_that = ts[1];
1774 two_tokens_ago = ts[2];
1775 current_token = ts[3];
1779 * This is used to inhibit alias expansion and reserved word recognition
1780 * inside case statement pattern lists. A `case statement pattern list' is:
1782 * everything between the `in' in a `case word in' and the next ')'
1784 * everything between a `;;' and the next `)' or `esac'
1787 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1789 #define END_OF_ALIAS 0
1792 * Pseudo-global variables used in implementing token-wise alias expansion.
1796 * Pushing and popping strings. This works together with shell_getc to
1797 * implement alias expansion on a per-token basis.
1800 #define PSH_ALIAS 0x01
1801 #define PSH_DPAREN 0x02
1802 #define PSH_SOURCE 0x04
1804 typedef struct string_saver {
1805 struct string_saver *next;
1806 int expand_alias; /* Value to set expand_alias to when string is popped. */
1809 alias_t *expander; /* alias that caused this line to be pushed. */
1811 size_t saved_line_size, saved_line_index;
1812 int saved_line_terminator;
1816 STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
1819 * Push the current shell_input_line onto a stack of such lines and make S
1820 * the current input. Used when expanding aliases. EXPAND is used to set
1821 * the value of expand_next_token when the string is popped, so that the
1822 * word after the alias in the original line is handled correctly when the
1823 * alias expands to multiple words. TOKEN is the token that was expanded
1824 * into S; it is saved and used to prevent infinite recursive expansion.
1827 push_string (s, expand, ap)
1832 STRING_SAVER *temp = (STRING_SAVER *)xmalloc (sizeof (STRING_SAVER));
1834 temp->expand_alias = expand;
1835 temp->saved_line = shell_input_line;
1836 temp->saved_line_size = shell_input_line_size;
1837 temp->saved_line_index = shell_input_line_index;
1838 temp->saved_line_terminator = shell_input_line_terminator;
1841 temp->expander = ap;
1843 temp->flags = PSH_ALIAS;
1845 temp->next = pushed_string_list;
1846 pushed_string_list = temp;
1850 ap->flags |= AL_BEINGEXPANDED;
1853 shell_input_line = s;
1854 shell_input_line_size = STRLEN (s);
1855 shell_input_line_index = 0;
1856 shell_input_line_terminator = '\0';
1858 parser_state &= ~PST_ALEXPNEXT; /* XXX */
1861 set_line_mbstate ();
1865 * Make the top of the pushed_string stack be the current shell input.
1866 * Only called when there is something on the stack. Called from shell_getc
1867 * when it thinks it has consumed the string generated by an alias expansion
1868 * and needs to return to the original input line.
1875 FREE (shell_input_line);
1876 shell_input_line = pushed_string_list->saved_line;
1877 shell_input_line_index = pushed_string_list->saved_line_index;
1878 shell_input_line_size = pushed_string_list->saved_line_size;
1879 shell_input_line_terminator = pushed_string_list->saved_line_terminator;
1881 if (pushed_string_list->expand_alias)
1882 parser_state |= PST_ALEXPNEXT;
1884 parser_state &= ~PST_ALEXPNEXT;
1886 t = pushed_string_list;
1887 pushed_string_list = pushed_string_list->next;
1891 t->expander->flags &= ~AL_BEINGEXPANDED;
1896 set_line_mbstate ();
1902 register STRING_SAVER *t, *t1;
1904 for (t = pushed_string_list; t; )
1907 FREE (t->saved_line);
1910 t->expander->flags &= ~AL_BEINGEXPANDED;
1915 pushed_string_list = (STRING_SAVER *)NULL;
1918 #endif /* ALIAS || DPAREN_ARITHMETIC */
1921 free_pushed_string_input ()
1923 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1924 free_string_list ();
1929 parser_expanding_alias ()
1931 return (expanding_alias ());
1935 parser_save_alias ()
1937 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1938 push_string ((char *)NULL, 0, (alias_t *)NULL);
1939 pushed_string_list->flags = PSH_SOURCE; /* XXX - for now */
1946 parser_restore_alias ()
1948 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1949 if (pushed_string_list)
1956 /* Return a line of text, taken from wherever yylex () reads input.
1957 If there is no more input, then we return NULL. If REMOVE_QUOTED_NEWLINE
1958 is non-zero, we remove unquoted \<newline> pairs. This is used by
1959 read_secondary_line to read here documents. */
1961 read_a_line (remove_quoted_newline)
1962 int remove_quoted_newline;
1964 static char *line_buffer = (char *)NULL;
1965 static int buffer_size = 0;
1966 int indx, c, peekc, pass_next;
1968 #if defined (READLINE)
1969 if (no_line_editing && SHOULD_PROMPT ())
1971 if (SHOULD_PROMPT ())
1975 pass_next = indx = 0;
1978 /* Allow immediate exit if interrupted during input. */
1983 /* Ignore null bytes in input. */
1987 internal_warning ("read_a_line: ignored null byte in input");
1992 /* If there is no more input, then we return NULL. */
1995 if (interactive && bash_input.type == st_stream)
1998 return ((char *)NULL);
2002 /* `+2' in case the final character in the buffer is a newline. */
2003 RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
2005 /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
2006 here document with an unquoted delimiter. In this case,
2007 the line will be expanded as if it were in double quotes.
2008 We allow a backslash to escape the next character, but we
2009 need to treat the backslash specially only if a backslash
2010 quoting a backslash-newline pair appears in the line. */
2013 line_buffer[indx++] = c;
2016 else if (c == '\\' && remove_quoted_newline)
2023 continue; /* Make the unquoted \<newline> pair disappear. */
2029 line_buffer[indx++] = c; /* Preserve the backslash. */
2033 line_buffer[indx++] = c;
2037 line_buffer[indx] = '\0';
2038 return (line_buffer);
2043 /* Return a line as in read_a_line (), but insure that the prompt is
2044 the secondary prompt. This is used to read the lines of a here
2045 document. REMOVE_QUOTED_NEWLINE is non-zero if we should remove
2046 newlines quoted with backslashes while reading the line. It is
2047 non-zero unless the delimiter of the here document was quoted. */
2049 read_secondary_line (remove_quoted_newline)
2050 int remove_quoted_newline;
2055 prompt_string_pointer = &ps2_prompt;
2056 if (SHOULD_PROMPT())
2058 ret = read_a_line (remove_quoted_newline);
2059 #if defined (HISTORY)
2060 if (ret && remember_on_history && (parser_state & PST_HEREDOC))
2062 /* To make adding the the here-document body right, we need to rely
2063 on history_delimiting_chars() returning \n for the first line of
2064 the here-document body and the null string for the second and
2065 subsequent lines, so we avoid double newlines.
2066 current_command_line_count == 2 for the first line of the body. */
2068 current_command_line_count++;
2069 maybe_add_history (ret);
2071 #endif /* HISTORY */
2075 /* **************************************************************** */
2079 /* **************************************************************** */
2081 /* Reserved words. These are only recognized as the first word of a
2083 STRING_INT_ALIST word_token_alist[] = {
2092 #if defined (SELECT_COMMAND)
2093 { "select", SELECT },
2100 { "function", FUNCTION },
2101 #if defined (COMMAND_TIMING)
2107 #if defined (COND_COMMAND)
2108 { "[[", COND_START },
2111 #if defined (COPROCESS_SUPPORT)
2112 { "coproc", COPROC },
2117 /* other tokens that can be returned by read_token() */
2118 STRING_INT_ALIST other_token_alist[] = {
2119 /* Multiple-character tokens with special values */
2124 { ">>", GREATER_GREATER },
2125 { "<<", LESS_LESS },
2127 { ">&", GREATER_AND },
2128 { ";;", SEMI_SEMI },
2130 { ";;&", SEMI_SEMI_AND },
2131 { "<<-", LESS_LESS_MINUS },
2132 { "<<<", LESS_LESS_LESS },
2133 { "&>", AND_GREATER },
2134 { "&>>", AND_GREATER_GREATER },
2135 { "<>", LESS_GREATER },
2136 { ">|", GREATER_BAR },
2138 { "EOF", yacc_EOF },
2139 /* Tokens whose value is the character itself */
2150 { "newline", '\n' },
2154 /* others not listed here:
2155 WORD look at yylval.word
2156 ASSIGNMENT_WORD look at yylval.word
2157 NUMBER look at yylval.number
2158 ARITH_CMD look at yylval.word_list
2159 ARITH_FOR_EXPRS look at yylval.word_list
2160 COND_CMD look at yylval.command
2163 /* These are used by read_token_word, but appear up here so that shell_getc
2164 can use them to decide when to add otherwise blank lines to the history. */
2166 /* The primary delimiter stack. */
2167 struct dstack dstack = { (char *)NULL, 0, 0 };
2169 /* A temporary delimiter stack to be used when decoding prompt strings.
2170 This is needed because command substitutions in prompt strings (e.g., PS2)
2171 can screw up the parser's quoting state. */
2172 static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
2174 /* Macro for accessing the top delimiter on the stack. Returns the
2175 delimiter or zero if none. */
2176 #define current_delimiter(ds) \
2177 (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
2179 #define push_delimiter(ds, character) \
2182 if (ds.delimiter_depth + 2 > ds.delimiter_space) \
2183 ds.delimiters = (char *)xrealloc \
2184 (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
2185 ds.delimiters[ds.delimiter_depth] = character; \
2186 ds.delimiter_depth++; \
2190 #define pop_delimiter(ds) ds.delimiter_depth--
2192 /* Return the next shell input character. This always reads characters
2193 from shell_input_line; when that line is exhausted, it is time to
2194 read the next line. This is called by read_token when the shell is
2195 processing normal command input. */
2197 /* This implements one-character lookahead/lookbehind across physical input
2198 lines, to avoid something being lost because it's pushed back with
2199 shell_ungetc when we're at the start of a line. */
2200 static int eol_ungetc_lookahead = 0;
2203 shell_getc (remove_quoted_newline)
2204 int remove_quoted_newline;
2212 if (sigwinch_received)
2214 sigwinch_received = 0;
2215 get_new_window_size (0, (int *)0, (int *)0);
2218 if (eol_ungetc_lookahead)
2220 c = eol_ungetc_lookahead;
2221 eol_ungetc_lookahead = 0;
2225 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2226 /* If shell_input_line[shell_input_line_index] == 0, but there is
2227 something on the pushed list of strings, then we don't want to go
2228 off and get another line. We let the code down below handle it. */
2230 if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
2231 (pushed_string_list == (STRING_SAVER *)NULL)))
2232 #else /* !ALIAS && !DPAREN_ARITHMETIC */
2233 if (!shell_input_line || !shell_input_line[shell_input_line_index])
2234 #endif /* !ALIAS && !DPAREN_ARITHMETIC */
2238 /* Let's not let one really really long line blow up memory allocation */
2239 if (shell_input_line && shell_input_line_size >= 32768)
2241 free (shell_input_line);
2242 shell_input_line = 0;
2243 shell_input_line_size = 0;
2248 /* Allow immediate exit if interrupted during input. */
2252 shell_input_line_terminator = 0;
2254 /* If the shell is interatctive, but not currently printing a prompt
2255 (interactive_shell && interactive == 0), we don't want to print
2256 notifies or cleanup the jobs -- we want to defer it until we do
2257 print the next prompt. */
2258 if (interactive_shell == 0 || SHOULD_PROMPT())
2260 #if defined (JOB_CONTROL)
2261 /* This can cause a problem when reading a command as the result
2262 of a trap, when the trap is called from flush_child. This call
2263 had better not cause jobs to disappear from the job table in
2264 that case, or we will have big trouble. */
2265 notify_and_cleanup ();
2266 #else /* !JOB_CONTROL */
2267 cleanup_dead_jobs ();
2268 #endif /* !JOB_CONTROL */
2271 #if defined (READLINE)
2272 if (no_line_editing && SHOULD_PROMPT())
2274 if (SHOULD_PROMPT())
2278 if (bash_input.type == st_stream)
2285 /* Allow immediate exit if interrupted during input. */
2291 internal_warning ("shell_getc: ignored null byte in input");
2296 /* Theoretical overflow */
2297 /* If we can't put 256 bytes more into the buffer, allocate
2298 everything we can and fill it as full as we can. */
2299 /* XXX - we ignore rest of line using `truncating' flag */
2300 if (shell_input_line_size > (SIZE_MAX - 256))
2304 n = SIZE_MAX - i; /* how much more can we put into the buffer? */
2305 if (n <= 2) /* we have to save 1 for the newline added below */
2307 if (truncating == 0)
2308 internal_warning("shell_getc: shell_input_line_size (%zu) exceeds SIZE_MAX (%llu): line truncated", shell_input_line_size, SIZE_MAX);
2309 shell_input_line[i] = '\0';
2312 if (shell_input_line_size < SIZE_MAX)
2314 shell_input_line_size = SIZE_MAX;
2315 shell_input_line = xrealloc (shell_input_line, shell_input_line_size);
2319 RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
2323 if (bash_input.type == st_stream)
2327 shell_input_line_terminator = EOF;
2329 shell_input_line[i] = '\0';
2333 if (truncating == 0 || c == '\n')
2334 shell_input_line[i++] = c;
2338 shell_input_line[--i] = '\0';
2339 current_command_line_count++;
2344 shell_input_line_index = 0;
2345 shell_input_line_len = i; /* == strlen (shell_input_line) */
2347 set_line_mbstate ();
2349 #if defined (HISTORY)
2350 if (remember_on_history && shell_input_line && shell_input_line[0])
2353 # if defined (BANG_HISTORY)
2356 /* If the current delimiter is a single quote, we should not be
2357 performing history expansion, even if we're on a different
2358 line from the original single quote. */
2359 old_hist = history_expansion_inhibited;
2360 if (current_delimiter (dstack) == '\'')
2361 history_expansion_inhibited = 1;
2363 expansions = pre_process_line (shell_input_line, 1, 1);
2364 # if defined (BANG_HISTORY)
2365 history_expansion_inhibited = old_hist;
2367 if (expansions != shell_input_line)
2369 free (shell_input_line);
2370 shell_input_line = expansions;
2371 shell_input_line_len = shell_input_line ?
2372 strlen (shell_input_line) : 0;
2373 if (shell_input_line_len == 0)
2374 current_command_line_count--;
2376 /* We have to force the xrealloc below because we don't know
2377 the true allocated size of shell_input_line anymore. */
2378 shell_input_line_size = shell_input_line_len;
2380 set_line_mbstate ();
2383 /* Try to do something intelligent with blank lines encountered while
2384 entering multi-line commands. XXX - this is grotesque */
2385 else if (remember_on_history && shell_input_line &&
2386 shell_input_line[0] == '\0' &&
2387 current_command_line_count > 1)
2389 if (current_delimiter (dstack))
2390 /* We know shell_input_line[0] == 0 and we're reading some sort of
2391 quoted string. This means we've got a line consisting of only
2392 a newline in a quoted string. We want to make sure this line
2393 gets added to the history. */
2394 maybe_add_history (shell_input_line);
2398 hdcs = history_delimiting_chars (shell_input_line);
2399 if (hdcs && hdcs[0] == ';')
2400 maybe_add_history (shell_input_line);
2404 #endif /* HISTORY */
2406 if (shell_input_line)
2408 /* Lines that signify the end of the shell's input should not be
2409 echoed. We should not echo lines while parsing command
2410 substitutions with recursive calls into the parsing engine; those
2411 should only be echoed once when we read the word. That is the
2412 reason for the test against shell_eof_token, which is set to a
2413 right paren when parsing the contents of command substitutions. */
2414 if (echo_input_at_read && (shell_input_line[0] ||
2415 shell_input_line_terminator != EOF) &&
2416 shell_eof_token == 0)
2417 fprintf (stderr, "%s\n", shell_input_line);
2421 shell_input_line_size = 0;
2422 prompt_string_pointer = ¤t_prompt_string;
2423 if (SHOULD_PROMPT ())
2428 /* Add the newline to the end of this string, iff the string does
2429 not already end in an EOF character. */
2430 if (shell_input_line_terminator != EOF)
2432 if (shell_input_line_size < SIZE_MAX-3 && (shell_input_line_len+3 > shell_input_line_size))
2433 shell_input_line = (char *)xrealloc (shell_input_line,
2434 1 + (shell_input_line_size += 2));
2436 shell_input_line[shell_input_line_len] = '\n';
2437 shell_input_line[shell_input_line_len + 1] = '\0';
2439 set_line_mbstate ();
2444 uc = shell_input_line[shell_input_line_index];
2447 shell_input_line_index++;
2449 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2450 /* If UC is NULL, we have reached the end of the current input string. If
2451 pushed_string_list is non-empty, it's time to pop to the previous string
2452 because we have fully consumed the result of the last alias expansion.
2453 Do it transparently; just return the next character of the string popped
2455 /* If pushed_string_list != 0 but pushed_string_list->expander == 0 (not
2456 currently tested) and the flags value is not PSH_SOURCE, we are not
2457 parsing an alias, we have just saved one (push_string, when called by
2458 the parse_dparen code) In this case, just go on as well. The PSH_SOURCE
2459 case is handled below. */
2461 if (uc == 0 && pushed_string_list && pushed_string_list->flags != PSH_SOURCE)
2464 uc = shell_input_line[shell_input_line_index];
2466 shell_input_line_index++;
2468 #endif /* ALIAS || DPAREN_ARITHMETIC */
2470 if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
2472 if (SHOULD_PROMPT ())
2475 /* What do we do here if we're expanding an alias whose definition
2476 includes an escaped newline? If that's the last character in the
2477 alias expansion, we just pop the pushed string list (recall that
2478 we inhibit the appending of a space in mk_alexpansion() if newline
2479 is the last character). If it's not the last character, we need
2480 to consume the quoted newline and move to the next character in
2483 if (expanding_alias () && shell_input_line[shell_input_line_index+1] == '\0')
2488 else if (expanding_alias () && shell_input_line[shell_input_line_index+1] != '\0')
2490 shell_input_line_index++; /* skip newline */
2491 goto next_alias_char; /* and get next character */
2498 if (uc == 0 && shell_input_line_terminator == EOF)
2499 return ((shell_input_line_index != 0) ? '\n' : EOF);
2501 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2502 /* We already know that we are not parsing an alias expansion because of the
2503 check for expanding_alias() above. This knows how parse_and_execute
2504 handles switching to st_string input while an alias is being expanded,
2505 hence the check for pushed_string_list without pushed_string_list->expander
2506 and the check for PSH_SOURCE as pushed_string_list->flags.
2507 parse_and_execute and parse_string both change the input type to st_string
2508 and place the string to be parsed and executed into location.string, so
2509 we should not stop reading that until the pointer is '\0'.
2510 The check for shell_input_line_terminator may be superfluous.
2512 This solves the problem of `.' inside a multi-line alias with embedded
2513 newlines executing things out of order. */
2514 if (uc == 0 && bash_input.type == st_string && *bash_input.location.string &&
2515 pushed_string_list && pushed_string_list->flags == PSH_SOURCE &&
2516 shell_input_line_terminator == 0)
2518 shell_input_line_index = 0;
2526 /* Put C back into the input for the shell. This might need changes for
2527 HANDLE_MULTIBYTE around EOLs. Since we (currently) never push back a
2528 character different than we read, shell_input_line_property doesn't need
2529 to change when manipulating shell_input_line. The define for
2530 last_shell_getc_is_singlebyte should take care of it, though. */
2535 if (shell_input_line && shell_input_line_index)
2536 shell_input_line[--shell_input_line_index] = c;
2538 eol_ungetc_lookahead = c;
2542 parser_remaining_input ()
2544 if (shell_input_line == 0)
2546 if (shell_input_line_index < 0 || shell_input_line_index >= shell_input_line_len)
2547 return '\0'; /* XXX */
2548 return (shell_input_line + shell_input_line_index);
2551 #ifdef INCLUDE_UNUSED
2552 /* Back the input pointer up by one, effectively `ungetting' a character. */
2556 if (shell_input_line && shell_input_line_index)
2557 shell_input_line_index--;
2561 /* Discard input until CHARACTER is seen, then push that character back
2562 onto the input stream. */
2564 discard_until (character)
2569 while ((c = shell_getc (0)) != EOF && c != character)
2577 execute_variable_command (command, vname)
2578 char *command, *vname;
2581 sh_parser_state_t ps;
2583 save_parser_state (&ps);
2584 last_lastarg = get_string_value ("_");
2586 last_lastarg = savestring (last_lastarg);
2588 parse_and_execute (savestring (command), vname, SEVAL_NONINT|SEVAL_NOHIST);
2590 restore_parser_state (&ps);
2591 bind_variable ("_", last_lastarg, 0);
2592 FREE (last_lastarg);
2594 if (token_to_read == '\n') /* reset_parser was called */
2598 /* Place to remember the token. We try to keep the buffer
2599 at a reasonable size, but it can grow. */
2600 static char *token = (char *)NULL;
2602 /* Current size of the token buffer. */
2603 static int token_buffer_size;
2605 /* Command to read_token () explaining what we want it to do. */
2608 #define prompt_is_ps1 \
2609 (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
2611 /* Function for yyparse to call. yylex keeps track of
2612 the last two tokens read, and calls read_token. */
2616 if (interactive && (current_token == 0 || current_token == '\n'))
2618 /* Before we print a prompt, we might have to check mailboxes.
2619 We do this only if it is time to do so. Notice that only here
2620 is the mail alarm reset; nothing takes place in check_mail ()
2621 except the checking of mail. Please don't change this. */
2622 if (prompt_is_ps1 && parse_and_execute_level == 0 && time_to_check_mail ())
2625 reset_mail_timer ();
2628 /* Avoid printing a prompt if we're not going to read anything, e.g.
2629 after resetting the parser with read_token (RESET). */
2630 if (token_to_read == 0 && SHOULD_PROMPT ())
2634 two_tokens_ago = token_before_that;
2635 token_before_that = last_read_token;
2636 last_read_token = current_token;
2637 current_token = read_token (READ);
2639 if ((parser_state & PST_EOFTOKEN) && current_token == shell_eof_token)
2641 current_token = yacc_EOF;
2642 if (bash_input.type == st_string)
2643 rewind_input_string ();
2645 parser_state &= ~PST_EOFTOKEN;
2647 return (current_token);
2650 /* When non-zero, we have read the required tokens
2651 which allow ESAC to be the next one read. */
2652 static int esacs_needed_count;
2658 if (need_here_doc >= HEREDOC_MAX)
2660 last_command_exit_value = EX_BADUSAGE;
2662 report_syntax_error (_("maximum here-document count exceeded"));
2664 exit_shell (last_command_exit_value);
2666 redir_stack[need_here_doc++] = r;
2670 gather_here_documents ()
2675 while (need_here_doc > 0)
2677 parser_state |= PST_HEREDOC;
2678 make_here_document (redir_stack[r++], line_number);
2679 parser_state &= ~PST_HEREDOC;
2684 /* When non-zero, an open-brace used to create a group is awaiting a close
2686 static int open_brace_count;
2688 #define command_token_position(token) \
2689 (((token) == ASSIGNMENT_WORD) || (parser_state&PST_REDIRLIST) || \
2690 ((token) != SEMI_SEMI && (token) != SEMI_AND && (token) != SEMI_SEMI_AND && reserved_word_acceptable(token)))
2692 #define assignment_acceptable(token) \
2693 (command_token_position(token) && ((parser_state & PST_CASEPAT) == 0))
2695 /* Check to see if TOKEN is a reserved word and return the token
2697 #define CHECK_FOR_RESERVED_WORD(tok) \
2699 if (!dollar_present && !quoted && \
2700 reserved_word_acceptable (last_read_token)) \
2703 for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
2704 if (STREQ (tok, word_token_alist[i].word)) \
2706 if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
2708 if (word_token_alist[i].token == TIME && time_command_acceptable () == 0) \
2710 if (word_token_alist[i].token == ESAC) \
2711 parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
2712 else if (word_token_alist[i].token == CASE) \
2713 parser_state |= PST_CASESTMT; \
2714 else if (word_token_alist[i].token == COND_END) \
2715 parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
2716 else if (word_token_alist[i].token == COND_START) \
2717 parser_state |= PST_CONDCMD; \
2718 else if (word_token_alist[i].token == '{') \
2719 open_brace_count++; \
2720 else if (word_token_alist[i].token == '}' && open_brace_count) \
2721 open_brace_count--; \
2722 return (word_token_alist[i].token); \
2729 /* OK, we have a token. Let's try to alias expand it, if (and only if)
2732 It is eligible for expansion if EXPAND_ALIASES is set, and
2733 the token is unquoted and the last token read was a command
2734 separator (or expand_next_token is set), and we are currently
2735 processing an alias (pushed_string_list is non-empty) and this
2736 token is not the same as the current or any previously
2739 Special cases that disqualify:
2740 In a pattern list in a case statement (parser_state & PST_CASEPAT). */
2750 r = xmalloc (l + 2);
2752 /* If the last character in the alias is a newline, don't add a trailing
2753 space to the expansion. Works with shell_getc above. */
2754 if (r[l - 1] != ' ' && r[l - 1] != '\n')
2761 alias_expand_token (tokstr)
2767 if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
2768 (parser_state & PST_CASEPAT) == 0)
2770 ap = find_alias (tokstr);
2772 /* Currently expanding this token. */
2773 if (ap && (ap->flags & AL_BEINGEXPANDED))
2774 return (NO_EXPANSION);
2776 /* mk_alexpansion puts an extra space on the end of the alias expansion,
2777 so the lookahead by the parser works right. If this gets changed,
2778 make sure the code in shell_getc that deals with reaching the end of
2779 an expanded alias is changed with it. */
2780 expanded = ap ? mk_alexpansion (ap->value) : (char *)NULL;
2784 push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
2785 return (RE_READ_TOKEN);
2788 /* This is an eligible token that does not have an expansion. */
2789 return (NO_EXPANSION);
2791 return (NO_EXPANSION);
2796 time_command_acceptable ()
2798 #if defined (COMMAND_TIMING)
2801 if (posixly_correct && shell_compatibility_level > 41)
2803 /* Quick check of the rest of the line to find the next token. If it
2804 begins with a `-', Posix says to not return `time' as the token.
2805 This was interp 267. */
2806 i = shell_input_line_index;
2807 while (i < shell_input_line_len && (shell_input_line[i] == ' ' || shell_input_line[i] == '\t'))
2809 if (shell_input_line[i] == '-')
2813 switch (last_read_token)
2830 case ')': /* only valid in case statement */
2831 case BANG: /* ! time pipeline */
2832 case TIME: /* time time pipeline */
2833 case TIMEOPT: /* time -p time pipeline */
2834 case TIMEIGN: /* time -p -- ... */
2841 #endif /* COMMAND_TIMING */
2844 /* Handle special cases of token recognition:
2845 IN is recognized if the last token was WORD and the token
2846 before that was FOR or CASE or SELECT.
2848 DO is recognized if the last token was WORD and the token
2849 before that was FOR or SELECT.
2851 ESAC is recognized if the last token caused `esacs_needed_count'
2854 `{' is recognized if the last token as WORD and the token
2855 before that was FUNCTION, or if we just parsed an arithmetic
2858 `}' is recognized if there is an unclosed `{' present.
2860 `-p' is returned as TIMEOPT if the last read token was TIME.
2861 `--' is returned as TIMEIGN if the last read token was TIMEOPT.
2863 ']]' is returned as COND_END if the parser is currently parsing
2864 a conditional expression ((parser_state & PST_CONDEXPR) != 0)
2866 `time' is returned as TIME if and only if it is immediately
2867 preceded by one of `;', `\n', `||', `&&', or `&'.
2871 special_case_tokens (tokstr)
2874 if ((last_read_token == WORD) &&
2875 #if defined (SELECT_COMMAND)
2876 ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
2878 ((token_before_that == FOR) || (token_before_that == CASE)) &&
2880 (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
2882 if (token_before_that == CASE)
2884 parser_state |= PST_CASEPAT;
2885 esacs_needed_count++;
2890 if (last_read_token == WORD &&
2891 #if defined (SELECT_COMMAND)
2892 (token_before_that == FOR || token_before_that == SELECT) &&
2894 (token_before_that == FOR) &&
2896 (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
2899 /* Ditto for ESAC in the CASE case.
2900 Specifically, this handles "case word in esac", which is a legal
2901 construct, certainly because someone will pass an empty arg to the
2902 case construct, and we don't want it to barf. Of course, we should
2903 insist that the case construct has at least one pattern in it, but
2904 the designers disagree. */
2905 if (esacs_needed_count)
2907 esacs_needed_count--;
2908 if (STREQ (tokstr, "esac"))
2910 parser_state &= ~PST_CASEPAT;
2915 /* The start of a shell function definition. */
2916 if (parser_state & PST_ALLOWOPNBRC)
2918 parser_state &= ~PST_ALLOWOPNBRC;
2919 if (tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2922 function_bstart = line_number;
2923 return ('{'); /* } */
2927 /* We allow a `do' after a for ((...)) without an intervening
2929 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == 'd' && tokstr[1] == 'o' && !tokstr[2])
2931 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2934 return ('{'); /* } */
2937 if (open_brace_count && reserved_word_acceptable (last_read_token) && tokstr[0] == '}' && !tokstr[1])
2939 open_brace_count--; /* { */
2943 #if defined (COMMAND_TIMING)
2944 /* Handle -p after `time'. */
2945 if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == 'p' && !tokstr[2])
2947 /* Handle -- after `time -p'. */
2948 if (last_read_token == TIMEOPT && tokstr[0] == '-' && tokstr[1] == '-' && !tokstr[2])
2952 #if defined (COND_COMMAND) /* [[ */
2953 if ((parser_state & PST_CONDEXPR) && tokstr[0] == ']' && tokstr[1] == ']' && tokstr[2] == '\0')
2960 /* Called from shell.c when Control-C is typed at top level. Or
2961 by the error rule at top level. */
2965 dstack.delimiter_depth = 0; /* No delimiters found so far. */
2966 open_brace_count = 0;
2968 #if defined (EXTENDED_GLOB)
2969 /* Reset to global value of extended glob */
2970 if (parser_state & PST_EXTPAT)
2971 extended_glob = global_extglob;
2976 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2977 if (pushed_string_list)
2978 free_string_list ();
2979 #endif /* ALIAS || DPAREN_ARITHMETIC */
2981 if (shell_input_line)
2983 free (shell_input_line);
2984 shell_input_line = (char *)NULL;
2985 shell_input_line_size = shell_input_line_index = 0;
2988 FREE (word_desc_to_read);
2989 word_desc_to_read = (WORD_DESC *)NULL;
2991 eol_ungetc_lookahead = 0;
2993 current_token = '\n'; /* XXX */
2994 last_read_token = '\n';
2995 token_to_read = '\n';
2998 /* Read the next token. Command can be READ (normal operation) or
2999 RESET (to normalize state). */
3001 read_token (command)
3004 int character; /* Current character. */
3005 int peek_char; /* Temporary look-ahead character. */
3006 int result; /* The thing to return. */
3008 if (command == RESET)
3016 result = token_to_read;
3017 if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
3019 yylval.word = word_desc_to_read;
3020 word_desc_to_read = (WORD_DESC *)NULL;
3026 #if defined (COND_COMMAND)
3027 if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
3029 cond_lineno = line_number;
3030 parser_state |= PST_CONDEXPR;
3031 yylval.command = parse_cond_command ();
3032 if (cond_token != COND_END)
3037 token_to_read = COND_END;
3038 parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
3044 /* This is a place to jump back to once we have successfully expanded a
3045 token with an alias and pushed the string with push_string () */
3049 /* Read a single word from input. Start by skipping blanks. */
3050 while ((character = shell_getc (1)) != EOF && shellblank (character))
3053 if (character == EOF)
3059 if MBTEST(character == '#' && (!interactive || interactive_comments))
3061 /* A comment. Discard until EOL or EOF, and then return a newline. */
3062 discard_until ('\n');
3064 character = '\n'; /* this will take the next if statement and return. */
3067 if (character == '\n')
3069 /* If we're about to return an unquoted newline, we can go and collect
3070 the text of any pending here document. */
3072 gather_here_documents ();
3075 parser_state &= ~PST_ALEXPNEXT;
3078 parser_state &= ~PST_ASSIGNOK;
3083 if (parser_state & PST_REGEXP)
3086 /* Shell meta-characters. */
3087 if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
3090 /* Turn off alias tokenization iff this character sequence would
3091 not leave us ready to read a command. */
3092 if (character == '<' || character == '>')
3093 parser_state &= ~PST_ALEXPNEXT;
3096 parser_state &= ~PST_ASSIGNOK;
3098 peek_char = shell_getc (1);
3099 if (character == peek_char)
3104 /* If '<' then we could be at "<<" or at "<<-". We have to
3105 look ahead one more character. */
3106 peek_char = shell_getc (1);
3107 if MBTEST(peek_char == '-')
3108 return (LESS_LESS_MINUS);
3109 else if MBTEST(peek_char == '<')
3110 return (LESS_LESS_LESS);
3113 shell_ungetc (peek_char);
3118 return (GREATER_GREATER);
3121 parser_state |= PST_CASEPAT;
3123 parser_state &= ~PST_ALEXPNEXT;
3126 peek_char = shell_getc (1);
3127 if MBTEST(peek_char == '&')
3128 return (SEMI_SEMI_AND);
3131 shell_ungetc (peek_char);
3141 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
3143 result = parse_dparen (character);
3151 else if MBTEST(character == '<' && peek_char == '&')
3153 else if MBTEST(character == '>' && peek_char == '&')
3154 return (GREATER_AND);
3155 else if MBTEST(character == '<' && peek_char == '>')
3156 return (LESS_GREATER);
3157 else if MBTEST(character == '>' && peek_char == '|')
3158 return (GREATER_BAR);
3159 else if MBTEST(character == '&' && peek_char == '>')
3161 peek_char = shell_getc (1);
3162 if MBTEST(peek_char == '>')
3163 return (AND_GREATER_GREATER);
3166 shell_ungetc (peek_char);
3167 return (AND_GREATER);
3170 else if MBTEST(character == '|' && peek_char == '&')
3172 else if MBTEST(character == ';' && peek_char == '&')
3174 parser_state |= PST_CASEPAT;
3176 parser_state &= ~PST_ALEXPNEXT;
3181 shell_ungetc (peek_char);
3183 /* If we look like we are reading the start of a function
3184 definition, then let the reader know about it so that
3185 we will do the right thing with `{'. */
3186 if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
3188 parser_state |= PST_ALLOWOPNBRC;
3190 parser_state &= ~PST_ALEXPNEXT;
3192 function_dstart = line_number;
3195 /* case pattern lists may be preceded by an optional left paren. If
3196 we're not trying to parse a case pattern list, the left paren
3197 indicates a subshell. */
3198 if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
3199 parser_state |= PST_SUBSHELL;
3201 else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
3202 parser_state &= ~PST_CASEPAT;
3204 else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
3205 parser_state &= ~PST_SUBSHELL;
3207 #if defined (PROCESS_SUBSTITUTION)
3208 /* Check for the constructs which introduce process substitution.
3209 Shells running in `posix mode' don't do process substitution. */
3210 if MBTEST(posixly_correct || ((character != '>' && character != '<') || peek_char != '(')) /*)*/
3211 #endif /* PROCESS_SUBSTITUTION */
3215 /* Hack <&- (close stdin) case. Also <&N- (dup and close). */
3216 if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
3220 /* Okay, if we got this far, we have to read a word. Read one,
3221 and then check it against the known ones. */
3222 result = read_token_word (character);
3224 if (result == RE_READ_TOKEN)
3231 * Match a $(...) or other grouping construct. This has to handle embedded
3232 * quoted strings ('', ``, "") and nested constructs. It also must handle
3233 * reprompting the user, if necessary, after reading a newline, and returning
3234 * correct error values if it reads EOF.
3236 #define P_FIRSTCLOSE 0x0001
3237 #define P_ALLOWESC 0x0002
3238 #define P_DQUOTE 0x0004
3239 #define P_COMMAND 0x0008 /* parsing a command, so look for comments */
3240 #define P_BACKQUOTE 0x0010 /* parsing a backquoted command substitution */
3241 #define P_ARRAYSUB 0x0020 /* parsing a [...] array subscript for assignment */
3242 #define P_DOLBRACE 0x0040 /* parsing a ${...} construct */
3244 /* Lexical state while parsing a grouping construct or $(...). */
3245 #define LEX_WASDOL 0x001
3246 #define LEX_CKCOMMENT 0x002
3247 #define LEX_INCOMMENT 0x004
3248 #define LEX_PASSNEXT 0x008
3249 #define LEX_RESWDOK 0x010
3250 #define LEX_CKCASE 0x020
3251 #define LEX_INCASE 0x040
3252 #define LEX_INHEREDOC 0x080
3253 #define LEX_HEREDELIM 0x100 /* reading here-doc delimiter */
3254 #define LEX_STRIPDOC 0x200 /* <<- strip tabs from here doc delim */
3255 #define LEX_INWORD 0x400
3257 #define COMSUB_META(ch) ((ch) == ';' || (ch) == '&' || (ch) == '|')
3259 #define CHECK_NESTRET_ERROR() \
3261 if (nestret == &matched_pair_error) \
3264 return &matched_pair_error; \
3268 #define APPEND_NESTRET() \
3272 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64); \
3273 strcpy (ret + retind, nestret); \
3274 retind += nestlen; \
3278 static char matched_pair_error;
3281 parse_matched_pair (qc, open, close, lenp, flags)
3282 int qc; /* `"' if this construct is within double quotes */
3286 int count, ch, tflags;
3287 int nestlen, ttranslen, start_lineno;
3288 char *ret, *nestret, *ttrans;
3289 int retind, retsize, rflags;
3292 dolbrace_state = (flags & P_DOLBRACE) ? DOLBRACE_PARAM : 0;
3294 /*itrace("parse_matched_pair[%d]: open = %c close = %c flags = %d", line_number, open, close, flags);*/
3298 if ((flags & P_COMMAND) && qc != '`' && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
3299 tflags |= LEX_CKCOMMENT;
3301 /* RFLAGS is the set of flags we want to pass to recursive calls. */
3302 rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
3304 ret = (char *)xmalloc (retsize = 64);
3307 start_lineno = line_number;
3310 ch = shell_getc (qc != '\'' && (tflags & (LEX_PASSNEXT)) == 0);
3315 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
3316 EOF_Reached = 1; /* XXX */
3317 return (&matched_pair_error);
3320 /* Possible reprompting. */
3321 if (ch == '\n' && SHOULD_PROMPT ())
3324 /* Don't bother counting parens or doing anything else if in a comment
3325 or part of a case statement */
3326 if (tflags & LEX_INCOMMENT)
3328 /* Add this character. */
3329 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3333 tflags &= ~LEX_INCOMMENT;
3338 /* Not exactly right yet, should handle shell metacharacters, too. If
3339 any changes are made to this test, make analogous changes to subst.c:
3340 extract_delimited_string(). */
3341 else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || shellblank (ret[retind - 1])))
3342 tflags |= LEX_INCOMMENT;
3344 if (tflags & LEX_PASSNEXT) /* last char was backslash */
3346 tflags &= ~LEX_PASSNEXT;
3347 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3350 retind--; /* swallow previously-added backslash */
3354 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3355 if MBTEST(ch == CTLESC)
3356 ret[retind++] = CTLESC;
3360 /* If we're reparsing the input (e.g., from parse_string_to_word_list),
3361 we've already prepended CTLESC to single-quoted results of $'...'.
3362 We may want to do this for other CTLESC-quoted characters in
3364 else if MBTEST((parser_state & PST_REPARSE) && open == '\'' && (ch == CTLESC || ch == CTLNUL))
3366 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3370 else if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3372 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3373 ret[retind++] = CTLESC;
3377 else if MBTEST(ch == close) /* ending delimiter */
3379 /* handle nested ${...} specially. */
3380 else if MBTEST(open != close && (tflags & LEX_WASDOL) && open == '{' && ch == open) /* } */
3382 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
3385 /* Add this character. */
3386 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3389 /* If we just read the ending character, don't bother continuing. */
3393 if (open == '\'') /* '' inside grouping construct */
3395 if MBTEST((flags & P_ALLOWESC) && ch == '\\')
3396 tflags |= LEX_PASSNEXT;
3400 if MBTEST(ch == '\\') /* backslashes */
3401 tflags |= LEX_PASSNEXT;
3403 /* Based on which dolstate is currently in (param, op, or word),
3404 decide what the op is. We're really only concerned if it's % or
3405 #, so we can turn on a flag that says whether or not we should
3406 treat single quotes as special when inside a double-quoted
3407 ${...}. This logic must agree with subst.c:extract_dollar_brace_string
3408 since they share the same defines. */
3409 /* FLAG POSIX INTERP 221 */
3410 if (flags & P_DOLBRACE)
3412 /* ${param%[%]word} */
3413 if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '%' && retind > 1)
3414 dolbrace_state = DOLBRACE_QUOTE;
3415 /* ${param#[#]word} */
3416 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '#' && retind > 1)
3417 dolbrace_state = DOLBRACE_QUOTE;
3418 /* ${param/[/]pat/rep} */
3419 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '/' && retind > 1)
3420 dolbrace_state = DOLBRACE_QUOTE2; /* XXX */
3421 /* ${param^[^]pat} */
3422 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '^' && retind > 1)
3423 dolbrace_state = DOLBRACE_QUOTE;
3424 /* ${param,[,]pat} */
3425 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == ',' && retind > 1)
3426 dolbrace_state = DOLBRACE_QUOTE;
3427 else if MBTEST(dolbrace_state == DOLBRACE_PARAM && strchr ("#%^,~:-=?+/", ch) != 0)
3428 dolbrace_state = DOLBRACE_OP;
3429 else if MBTEST(dolbrace_state == DOLBRACE_OP && strchr ("#%^,~:-=?+/", ch) == 0)
3430 dolbrace_state = DOLBRACE_WORD;
3433 /* The big hammer. Single quotes aren't special in double quotes. The
3434 problem is that Posix used to say the single quotes are semi-special:
3435 within a double-quoted ${...} construct "an even number of
3436 unescaped double-quotes or single-quotes, if any, shall occur." */
3437 /* This was changed in Austin Group Interp 221 */
3438 if MBTEST(posixly_correct && shell_compatibility_level > 41 && dolbrace_state != DOLBRACE_QUOTE && dolbrace_state != DOLBRACE_QUOTE2 && (flags & P_DQUOTE) && (flags & P_DOLBRACE) && ch == '\'')
3441 /* Could also check open == '`' if we want to parse grouping constructs
3442 inside old-style command substitution. */
3443 if (open != close) /* a grouping construct */
3445 if MBTEST(shellquote (ch))
3447 /* '', ``, or "" inside $(...) or other grouping construct. */
3448 push_delimiter (dstack, ch);
3449 if MBTEST((tflags & LEX_WASDOL) && ch == '\'') /* $'...' inside group */
3450 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
3452 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
3453 pop_delimiter (dstack);
3454 CHECK_NESTRET_ERROR ();
3456 if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
3458 /* Translate $'...' here. */
3459 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
3462 /* If we're parsing a double-quoted brace expansion and we are
3463 not in a place where single quotes are treated specially,
3464 make sure we single-quote the results of the ansi
3465 expansion because quote removal should remove them later */
3466 /* FLAG POSIX INTERP 221 */
3467 if ((shell_compatibility_level > 42) && (rflags & P_DQUOTE) && (dolbrace_state == DOLBRACE_QUOTE2) && (flags & P_DOLBRACE))
3469 nestret = sh_single_quote (ttrans);
3471 nestlen = strlen (nestret);
3473 else if ((rflags & P_DQUOTE) == 0)
3475 nestret = sh_single_quote (ttrans);
3477 nestlen = strlen (nestret);
3482 nestlen = ttranslen;
3484 retind -= 2; /* back up before the $' */
3486 else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
3488 /* Locale expand $"..." here. */
3489 ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
3492 nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
3494 nestlen = ttranslen + 2;
3495 retind -= 2; /* back up before the $" */
3501 else if ((flags & P_ARRAYSUB) && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3502 goto parse_dollar_word;
3504 /* Parse an old-style command substitution within double quotes as a
3506 /* XXX - sh and ksh93 don't do this - XXX */
3507 else if MBTEST(open == '"' && ch == '`')
3509 nestret = parse_matched_pair (0, '`', '`', &nestlen, rflags);
3511 CHECK_NESTRET_ERROR ();
3516 else if MBTEST(open != '`' && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3517 /* check for $(), $[], or ${} inside quoted string. */
3520 if (open == ch) /* undo previous increment */
3522 if (ch == '(') /* ) */
3523 nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
3524 else if (ch == '{') /* } */
3525 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|P_DOLBRACE|rflags);
3526 else if (ch == '[') /* ] */
3527 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
3529 CHECK_NESTRET_ERROR ();
3534 if MBTEST(ch == '$')
3535 tflags |= LEX_WASDOL;
3537 tflags &= ~LEX_WASDOL;
3543 /*itrace("parse_matched_pair[%d]: returning %s", line_number, ret);*/
3547 /* Parse a $(...) command substitution. This is messier than I'd like, and
3548 reproduces a lot more of the token-reading code than I'd like. */
3550 parse_comsub (qc, open, close, lenp, flags)
3551 int qc; /* `"' if this construct is within double quotes */
3555 int count, ch, peekc, tflags, lex_rwlen, lex_wlen, lex_firstind;
3556 int nestlen, ttranslen, start_lineno;
3557 char *ret, *nestret, *ttrans, *heredelim;
3558 int retind, retsize, rflags, hdlen;
3560 /* Posix interp 217 says arithmetic expressions have precedence, so
3561 assume $(( introduces arithmetic expansion and parse accordingly. */
3562 peekc = shell_getc (0);
3563 shell_ungetc (peekc);
3565 return (parse_matched_pair (qc, open, close, lenp, 0));
3567 /*itrace("parse_comsub: qc = `%c' open = %c close = %c", qc, open, close);*/
3569 tflags = LEX_RESWDOK;
3571 if ((flags & P_COMMAND) && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
3572 tflags |= LEX_CKCASE;
3573 if ((tflags & LEX_CKCASE) && (interactive == 0 || interactive_comments))
3574 tflags |= LEX_CKCOMMENT;
3576 /* RFLAGS is the set of flags we want to pass to recursive calls. */
3577 rflags = (flags & P_DQUOTE);
3579 ret = (char *)xmalloc (retsize = 64);
3582 start_lineno = line_number;
3583 lex_rwlen = lex_wlen = 0;
3591 ch = shell_getc (qc != '\'' && (tflags & (LEX_INCOMMENT|LEX_PASSNEXT)) == 0);
3598 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
3599 EOF_Reached = 1; /* XXX */
3600 return (&matched_pair_error);
3603 /* If we hit the end of a line and are reading the contents of a here
3604 document, and it's not the same line that the document starts on,
3605 check for this line being the here doc delimiter. Otherwise, if
3606 we're in a here document, mark the next character as the beginning
3610 if ((tflags & LEX_HEREDELIM) && heredelim)
3612 tflags &= ~LEX_HEREDELIM;
3613 tflags |= LEX_INHEREDOC;
3614 lex_firstind = retind + 1;
3616 else if (tflags & LEX_INHEREDOC)
3619 tind = lex_firstind;
3620 while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
3622 if (STREQN (ret + tind, heredelim, hdlen))
3624 tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
3625 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
3631 lex_firstind = retind + 1;
3635 /* Possible reprompting. */
3636 if (ch == '\n' && SHOULD_PROMPT ())
3639 /* XXX -- possibly allow here doc to be delimited by ending right
3641 if ((tflags & LEX_INHEREDOC) && ch == close && count == 1)
3644 /*itrace("parse_comsub: in here doc, ch == close, retind - firstind = %d hdlen = %d retind = %d", retind-lex_firstind, hdlen, retind);*/
3645 tind = lex_firstind;
3646 while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
3648 if (retind-tind == hdlen && STREQN (ret + tind, heredelim, hdlen))
3650 tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
3651 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
3658 /* Don't bother counting parens or doing anything else if in a comment */
3659 if (tflags & (LEX_INCOMMENT|LEX_INHEREDOC))
3661 /* Add this character. */
3662 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3665 if ((tflags & LEX_INCOMMENT) && ch == '\n')
3667 /*itrace("parse_comsub:%d: lex_incomment -> 0 ch = `%c'", line_number, ch);*/
3668 tflags &= ~LEX_INCOMMENT;
3674 if (tflags & LEX_PASSNEXT) /* last char was backslash */
3676 /*itrace("parse_comsub:%d: lex_passnext -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3677 tflags &= ~LEX_PASSNEXT;
3678 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3681 retind--; /* swallow previously-added backslash */
3685 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3686 if MBTEST(ch == CTLESC)
3687 ret[retind++] = CTLESC;
3692 /* If this is a shell break character, we are not in a word. If not,
3693 we either start or continue a word. */
3694 if MBTEST(shellbreak (ch))
3696 tflags &= ~LEX_INWORD;
3697 /*itrace("parse_comsub:%d: lex_inword -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3701 if (tflags & LEX_INWORD)
3704 /*itrace("parse_comsub:%d: lex_inword == 1 ch = `%c' lex_wlen = %d (%d)", line_number, ch, lex_wlen, __LINE__);*/
3708 /*itrace("parse_comsub:%d: lex_inword -> 1 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3709 tflags |= LEX_INWORD;
3714 /* Skip whitespace */
3715 if MBTEST(shellblank (ch) && (tflags & LEX_HEREDELIM) == 0 && lex_rwlen == 0)
3717 /* Add this character. */
3718 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3723 /* Either we are looking for the start of the here-doc delimiter
3724 (lex_firstind == -1) or we are reading one (lex_firstind >= 0).
3725 If this character is a shell break character and we are reading
3726 the delimiter, save it and note that we are now reading a here
3727 document. If we've found the start of the delimiter, note it by
3728 setting lex_firstind. Backslashes can quote shell metacharacters
3729 in here-doc delimiters. */
3730 if (tflags & LEX_HEREDELIM)
3732 if (lex_firstind == -1 && shellbreak (ch) == 0)
3733 lex_firstind = retind;
3735 else if (heredelim && (tflags & LEX_PASSNEXT) == 0 && ch == '\n')
3737 tflags |= LEX_INHEREDOC;
3738 tflags &= ~LEX_HEREDELIM;
3739 lex_firstind = retind + 1;
3742 else if (lex_firstind >= 0 && (tflags & LEX_PASSNEXT) == 0 && shellbreak (ch))
3746 nestret = substring (ret, lex_firstind, retind);
3747 heredelim = string_quote_removal (nestret, 0);
3749 hdlen = STRLEN(heredelim);
3750 /*itrace("parse_comsub:%d: found here doc delimiter `%s' (%d)", line_number, heredelim, hdlen);*/
3754 tflags |= LEX_INHEREDOC;
3755 tflags &= ~LEX_HEREDELIM;
3756 lex_firstind = retind + 1;
3763 /* Meta-characters that can introduce a reserved word. Not perfect yet. */
3764 if MBTEST((tflags & LEX_RESWDOK) == 0 && (tflags & LEX_CKCASE) && (tflags & LEX_INCOMMENT) == 0 && (shellmeta(ch) || ch == '\n'))
3766 /* Add this character. */
3767 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3769 peekc = shell_getc (1);
3770 if (ch == peekc && (ch == '&' || ch == '|' || ch == ';')) /* two-character tokens */
3772 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3773 ret[retind++] = peekc;
3774 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
3775 tflags |= LEX_RESWDOK;
3779 else if (ch == '\n' || COMSUB_META(ch))
3781 shell_ungetc (peekc);
3782 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
3783 tflags |= LEX_RESWDOK;
3791 /* `unget' the character we just added and fall through */
3793 shell_ungetc (peekc);
3797 /* If we can read a reserved word, try to read one. */
3798 if (tflags & LEX_RESWDOK)
3800 if MBTEST(islower (ch))
3802 /* Add this character. */
3803 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3808 else if MBTEST(lex_rwlen == 4 && shellbreak (ch))
3810 if (STREQN (ret + retind - 4, "case", 4))
3812 tflags |= LEX_INCASE;
3813 /*itrace("parse_comsub:%d: found `case', lex_incase -> 1 lex_reswdok -> 0", line_number);*/
3815 else if (STREQN (ret + retind - 4, "esac", 4))
3817 tflags &= ~LEX_INCASE;
3818 /*itrace("parse_comsub:%d: found `esac', lex_incase -> 0 lex_reswdok -> 0", line_number);*/
3820 tflags &= ~LEX_RESWDOK;
3822 else if MBTEST((tflags & LEX_CKCOMMENT) && ch == '#' && (lex_rwlen == 0 || ((tflags & LEX_INWORD) && lex_wlen == 0)))
3823 ; /* don't modify LEX_RESWDOK if we're starting a comment */
3824 /* Allow `do' followed by space, tab, or newline to preserve the
3825 RESWDOK flag, but reset the reserved word length counter so we
3826 can read another one. */
3827 else if MBTEST(((tflags & LEX_INCASE) == 0) &&
3828 (isblank(ch) || ch == '\n') &&
3830 STREQN (ret + retind - 2, "do", 2))
3832 /*itrace("parse_comsub:%d: lex_incase == 1 found `%c', found \"do\"", line_number, ch);*/
3835 else if MBTEST((tflags & LEX_INCASE) && ch != '\n')
3836 /* If we can read a reserved word and we're in case, we're at the
3837 point where we can read a new pattern list or an esac. We
3838 handle the esac case above. If we read a newline, we want to
3839 leave LEX_RESWDOK alone. If we read anything else, we want to
3840 turn off LEX_RESWDOK, since we're going to read a pattern list. */
3842 tflags &= ~LEX_RESWDOK;
3843 /*itrace("parse_comsub:%d: lex_incase == 1 found `%c', lex_reswordok -> 0", line_number, ch);*/
3845 else if MBTEST(shellbreak (ch) == 0)
3847 tflags &= ~LEX_RESWDOK;
3848 /*itrace("parse_comsub:%d: found `%c', lex_reswordok -> 0", line_number, ch);*/
3851 /* If we find a space or tab but have read something and it's not
3852 `do', turn off the reserved-word-ok flag */
3853 else if MBTEST(isblank (ch) && lex_rwlen > 0)
3855 tflags &= ~LEX_RESWDOK;
3856 /*itrace("parse_comsub:%d: found `%c', lex_reswordok -> 0", line_number, ch);*/
3861 /* Might be the start of a here-doc delimiter */
3862 if MBTEST((tflags & LEX_INCOMMENT) == 0 && (tflags & LEX_CKCASE) && ch == '<')
3864 /* Add this character. */
3865 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3867 peekc = shell_getc (1);
3872 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3873 ret[retind++] = peekc;
3874 peekc = shell_getc (1);
3879 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3880 ret[retind++] = peekc;
3881 tflags |= LEX_STRIPDOC;
3884 shell_ungetc (peekc);
3887 tflags |= LEX_HEREDELIM;
3893 ch = peekc; /* fall through and continue XXX */
3895 else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (((tflags & LEX_RESWDOK) && lex_rwlen == 0) || ((tflags & LEX_INWORD) && lex_wlen == 0)))
3897 /*itrace("parse_comsub:%d: lex_incomment -> 1 (%d)", line_number, __LINE__);*/
3898 tflags |= LEX_INCOMMENT;
3901 if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3903 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3904 ret[retind++] = CTLESC;
3909 else if MBTEST((tflags & LEX_INCASE) && ch == close && close == ')')
3910 tflags &= ~LEX_INCASE; /* XXX */
3912 else if MBTEST(ch == close && (tflags & LEX_INCASE) == 0) /* ending delimiter */
3915 /*itrace("parse_comsub:%d: found close: count = %d", line_number, count);*/
3917 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && (tflags & LEX_INCASE) == 0 && ch == open) /* nested begin */
3920 /*itrace("parse_comsub:%d: found open: count = %d", line_number, count);*/
3923 /* Add this character. */
3924 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3927 /* If we just read the ending character, don't bother continuing. */
3931 if MBTEST(ch == '\\') /* backslashes */
3932 tflags |= LEX_PASSNEXT;
3934 if MBTEST(shellquote (ch))
3936 /* '', ``, or "" inside $(...). */
3937 push_delimiter (dstack, ch);
3938 if MBTEST((tflags & LEX_WASDOL) && ch == '\'') /* $'...' inside group */
3939 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
3941 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
3942 pop_delimiter (dstack);
3943 CHECK_NESTRET_ERROR ();
3945 if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
3947 /* Translate $'...' here. */
3948 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
3951 if ((rflags & P_DQUOTE) == 0)
3953 nestret = sh_single_quote (ttrans);
3955 nestlen = strlen (nestret);
3960 nestlen = ttranslen;
3962 retind -= 2; /* back up before the $' */
3964 else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
3966 /* Locale expand $"..." here. */
3967 ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
3970 nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
3972 nestlen = ttranslen + 2;
3973 retind -= 2; /* back up before the $" */
3979 else if MBTEST((tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3980 /* check for $(), $[], or ${} inside command substitution. */
3982 if ((tflags & LEX_INCASE) == 0 && open == ch) /* undo previous increment */
3984 if (ch == '(') /* ) */
3985 nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
3986 else if (ch == '{') /* } */
3987 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|P_DOLBRACE|rflags);
3988 else if (ch == '[') /* ] */
3989 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
3991 CHECK_NESTRET_ERROR ();
3996 if MBTEST(ch == '$')
3997 tflags |= LEX_WASDOL;
3999 tflags &= ~LEX_WASDOL;
4006 /*itrace("parse_comsub:%d: returning `%s'", line_number, ret);*/
4010 /* Recursively call the parser to parse a $(...) command substitution. */
4012 xparse_dolparen (base, string, indp, flags)
4018 sh_parser_state_t ps;
4019 sh_input_line_state_t ls;
4020 int orig_ind, nc, sflags, orig_eof_token;
4021 char *ret, *s, *ep, *ostring;
4027 /*itrace("xparse_dolparen: size = %d shell_input_line = `%s'", shell_input_line_size, shell_input_line);*/
4028 sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE;
4029 if (flags & SX_NOLONGJMP)
4030 sflags |= SEVAL_NOLONGJMP;
4031 save_parser_state (&ps);
4032 save_input_line_state (&ls);
4033 orig_eof_token = shell_eof_token;
4036 parser_state |= PST_CMDSUBST|PST_EOFTOKEN; /* allow instant ')' */ /*(*/
4037 shell_eof_token = ')';
4038 parse_string (string, "command substitution", sflags, &ep);
4040 shell_eof_token = orig_eof_token;
4041 restore_parser_state (&ps);
4043 /* reset_parser clears shell_input_line and associated variables */
4044 restore_input_line_state (&ls);
4048 /* Need to find how many characters parse_and_execute consumed, update
4049 *indp, if flags != 0, copy the portion of the string parsed into RET
4050 and return it. If flags & 1 (EX_NOALLOC) we can return NULL. */
4057 itrace("xparse_dolparen:%d: ep[-1] != RPAREN (%d), ep = `%s'", line_number, ep[-1], ep);
4059 while (ep > ostring && ep[-1] == '\n') ep--;
4063 *indp = ep - base - 1;
4067 if (base[*indp] != ')')
4068 itrace("xparse_dolparen:%d: base[%d] != RPAREN (%d), base = `%s'", line_number, *indp, base[*indp], base);
4071 if (flags & SX_NOALLOC)
4072 return (char *)NULL;
4080 ret = substring (ostring, 0, nc - 1);
4085 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
4086 /* Parse a double-paren construct. It can be either an arithmetic
4087 command, an arithmetic `for' command, or a nested subshell. Returns
4088 the parsed token, -1 on error, or -2 if we didn't do anything and
4089 should just go on. */
4098 #if defined (ARITH_FOR_COMMAND)
4099 if (last_read_token == FOR)
4101 arith_for_lineno = line_number;
4102 cmdtyp = parse_arith_cmd (&wval, 0);
4105 wd = alloc_word_desc ();
4107 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
4108 return (ARITH_FOR_EXPRS);
4111 return -1; /* ERROR */
4115 #if defined (DPAREN_ARITHMETIC)
4116 if (reserved_word_acceptable (last_read_token))
4118 sline = line_number;
4120 cmdtyp = parse_arith_cmd (&wval, 0);
4121 if (cmdtyp == 1) /* arithmetic command */
4123 wd = alloc_word_desc ();
4125 wd->flags = W_QUOTED|W_NOSPLIT|W_NOGLOB|W_DQUOTE;
4126 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
4129 else if (cmdtyp == 0) /* nested subshell */
4131 push_string (wval, 0, (alias_t *)NULL);
4132 pushed_string_list->flags = PSH_DPAREN;
4133 if ((parser_state & PST_CASEPAT) == 0)
4134 parser_state |= PST_SUBSHELL;
4142 return -2; /* XXX */
4145 /* We've seen a `(('. Look for the matching `))'. If we get it, return 1.
4146 If not, assume it's a nested subshell for backwards compatibility and
4147 return 0. In any case, put the characters we've consumed into a locally-
4148 allocated buffer and make *ep point to that buffer. Return -1 on an
4149 error, for example EOF. */
4151 parse_arith_cmd (ep, adddq)
4155 int exp_lineno, rval, c;
4156 char *ttok, *tokstr;
4159 exp_lineno = line_number;
4160 ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
4162 if (ttok == &matched_pair_error)
4164 /* Check that the next character is the closing right paren. If
4165 not, this is a syntax error. ( */
4170 tokstr = (char *)xmalloc (ttoklen + 4);
4172 /* if ADDDQ != 0 then (( ... )) -> "..." */
4173 if (rval == 1 && adddq) /* arith cmd, add double quotes */
4176 strncpy (tokstr + 1, ttok, ttoklen - 1);
4177 tokstr[ttoklen] = '"';
4178 tokstr[ttoklen+1] = '\0';
4180 else if (rval == 1) /* arith cmd, don't add double quotes */
4182 strncpy (tokstr, ttok, ttoklen - 1);
4183 tokstr[ttoklen-1] = '\0';
4185 else /* nested subshell */
4188 strncpy (tokstr + 1, ttok, ttoklen - 1);
4189 tokstr[ttoklen] = ')';
4190 tokstr[ttoklen+1] = c;
4191 tokstr[ttoklen+2] = '\0';
4198 #endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
4200 #if defined (COND_COMMAND)
4206 if (EOF_Reached && cond_token != COND_ERROR) /* [[ */
4207 parser_error (cond_lineno, _("unexpected EOF while looking for `]]'"));
4208 else if (cond_token != COND_ERROR)
4210 if (etext = error_token_from_token (cond_token))
4212 parser_error (cond_lineno, _("syntax error in conditional expression: unexpected token `%s'"), etext);
4216 parser_error (cond_lineno, _("syntax error in conditional expression"));
4223 return (cond_or ());
4232 if (cond_token == OR_OR)
4235 l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
4246 if (cond_token == AND_AND)
4249 l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
4255 cond_skip_newlines ()
4257 while ((cond_token = read_token (READ)) == '\n')
4259 if (SHOULD_PROMPT ())
4262 return (cond_token);
4265 #define COND_RETURN_ERROR() \
4266 do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
4272 COND_COM *term, *tleft, *tright;
4276 /* Read a token. It can be a left paren, a `!', a unary operator, or a
4277 word that should be the first argument of a binary operator. Start by
4278 skipping newlines, since this is a compound command. */
4279 tok = cond_skip_newlines ();
4280 lineno = line_number;
4281 if (tok == COND_END)
4283 COND_RETURN_ERROR ();
4285 else if (tok == '(')
4287 term = cond_expr ();
4288 if (cond_token != ')')
4291 dispose_cond_node (term); /* ( */
4292 if (etext = error_token_from_token (cond_token))
4294 parser_error (lineno, _("unexpected token `%s', expected `)'"), etext);
4298 parser_error (lineno, _("expected `)'"));
4299 COND_RETURN_ERROR ();
4301 term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
4302 (void)cond_skip_newlines ();
4304 else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
4307 dispose_word (yylval.word); /* not needed */
4308 term = cond_term ();
4310 term->flags |= CMD_INVERT_RETURN;
4312 else if (tok == WORD && yylval.word->word[0] == '-' && yylval.word->word[2] == 0 && test_unop (yylval.word->word))
4315 tok = read_token (READ);
4318 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4319 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
4324 if (etext = error_token_from_token (tok))
4326 parser_error (line_number, _("unexpected argument `%s' to conditional unary operator"), etext);
4330 parser_error (line_number, _("unexpected argument to conditional unary operator"));
4331 COND_RETURN_ERROR ();
4334 (void)cond_skip_newlines ();
4336 else if (tok == WORD) /* left argument to binary operator */
4339 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4342 tok = read_token (READ);
4343 if (tok == WORD && test_binop (yylval.word->word))
4346 if (op->word[0] == '=' && (op->word[1] == '\0' || (op->word[1] == '=' && op->word[2] == '\0')))
4347 parser_state |= PST_EXTPAT;
4348 else if (op->word[0] == '!' && op->word[1] == '=' && op->word[2] == '\0')
4349 parser_state |= PST_EXTPAT;
4351 #if defined (COND_REGEXP)
4352 else if (tok == WORD && STREQ (yylval.word->word, "=~"))
4355 parser_state |= PST_REGEXP;
4358 else if (tok == '<' || tok == '>')
4359 op = make_word_from_token (tok); /* ( */
4360 /* There should be a check before blindly accepting the `)' that we have
4361 seen the opening `('. */
4362 else if (tok == COND_END || tok == AND_AND || tok == OR_OR || tok == ')')
4364 /* Special case. [[ x ]] is equivalent to [[ -n x ]], just like
4365 the test command. Similarly for [[ x && expr ]] or
4366 [[ x || expr ]] or [[ (x) ]]. */
4367 op = make_word ("-n");
4368 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
4374 if (etext = error_token_from_token (tok))
4376 parser_error (line_number, _("unexpected token `%s', conditional binary operator expected"), etext);
4380 parser_error (line_number, _("conditional binary operator expected"));
4381 dispose_cond_node (tleft);
4382 COND_RETURN_ERROR ();
4386 if (parser_state & PST_EXTPAT)
4388 tok = read_token (READ);
4389 if (parser_state & PST_EXTPAT)
4390 extended_glob = global_extglob;
4391 parser_state &= ~(PST_REGEXP|PST_EXTPAT);
4395 tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4396 term = make_cond_node (COND_BINARY, op, tleft, tright);
4400 if (etext = error_token_from_token (tok))
4402 parser_error (line_number, _("unexpected argument `%s' to conditional binary operator"), etext);
4406 parser_error (line_number, _("unexpected argument to conditional binary operator"));
4407 dispose_cond_node (tleft);
4409 COND_RETURN_ERROR ();
4412 (void)cond_skip_newlines ();
4417 parser_error (line_number, _("unexpected token `%c' in conditional command"), tok);
4418 else if (etext = error_token_from_token (tok))
4420 parser_error (line_number, _("unexpected token `%s' in conditional command"), etext);
4424 parser_error (line_number, _("unexpected token %d in conditional command"), tok);
4425 COND_RETURN_ERROR ();
4430 /* This is kind of bogus -- we slip a mini recursive-descent parser in
4431 here to handle the conditional statement syntax. */
4433 parse_cond_command ()
4437 global_extglob = extended_glob;
4438 cexp = cond_expr ();
4439 return (make_cond_command (cexp));
4443 #if defined (ARRAY_VARS)
4444 /* When this is called, it's guaranteed that we don't care about anything
4445 in t beyond i. We do save and restore the chars, though. */
4447 token_is_assignment (t, i)
4451 unsigned char c, c1;
4454 c = t[i]; c1 = t[i+1];
4455 t[i] = '='; t[i+1] = '\0';
4456 r = assignment (t, (parser_state & PST_COMPASSIGN) != 0);
4457 t[i] = c; t[i+1] = c1;
4461 /* XXX - possible changes here for `+=' */
4463 token_is_ident (t, i)
4472 r = legal_identifier (t);
4479 read_token_word (character)
4482 /* The value for YYLVAL when a WORD is read. */
4483 WORD_DESC *the_word;
4485 /* Index into the token that we are building. */
4488 /* ALL_DIGITS becomes zero when we see a non-digit. */
4489 int all_digit_token;
4491 /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
4494 /* COMPOUND_ASSIGNMENT becomes non-zero if we are parsing a compound
4496 int compound_assignment;
4498 /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
4501 /* Non-zero means to ignore the value of the next character, and just
4502 to add it no matter what. */
4503 int pass_next_character;
4505 /* The current delimiting character. */
4507 int result, peek_char;
4508 char *ttok, *ttrans;
4509 int ttoklen, ttranslen;
4512 if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
4513 token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
4516 all_digit_token = DIGIT (character);
4517 dollar_present = quoted = pass_next_character = compound_assignment = 0;
4521 if (character == EOF)
4524 if (pass_next_character)
4526 pass_next_character = 0;
4527 goto got_escaped_character;
4530 cd = current_delimiter (dstack);
4532 /* Handle backslashes. Quote lots of things when not inside of
4533 double-quotes, quote some things inside of double-quotes. */
4534 if MBTEST(character == '\\')
4536 peek_char = shell_getc (0);
4538 /* Backslash-newline is ignored in all cases except
4539 when quoted with single quotes. */
4540 if (peek_char == '\n')
4543 goto next_character;
4547 shell_ungetc (peek_char);
4549 /* If the next character is to be quoted, note it now. */
4550 if (cd == 0 || cd == '`' ||
4551 (cd == '"' && peek_char >= 0 && (sh_syntaxtab[peek_char] & CBSDQUOTE)))
4552 pass_next_character++;
4559 /* Parse a matched pair of quote characters. */
4560 if MBTEST(shellquote (character))
4562 push_delimiter (dstack, character);
4563 ttok = parse_matched_pair (character, character, character, &ttoklen, (character == '`') ? P_COMMAND : 0);
4564 pop_delimiter (dstack);
4565 if (ttok == &matched_pair_error)
4566 return -1; /* Bail immediately. */
4567 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4568 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4569 token[token_index++] = character;
4570 strcpy (token + token_index, ttok);
4571 token_index += ttoklen;
4572 all_digit_token = 0;
4574 dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
4576 goto next_character;
4580 /* When parsing a regexp as a single word inside a conditional command,
4581 we need to special-case characters special to both the shell and
4582 regular expressions. Right now, that is only '(' and '|'. */ /*)*/
4583 if MBTEST((parser_state & PST_REGEXP) && (character == '(' || character == '|')) /*)*/
4585 if (character == '|')
4588 push_delimiter (dstack, character);
4589 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4590 pop_delimiter (dstack);
4591 if (ttok == &matched_pair_error)
4592 return -1; /* Bail immediately. */
4593 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4594 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4595 token[token_index++] = character;
4596 strcpy (token + token_index, ttok);
4597 token_index += ttoklen;
4599 dollar_present = all_digit_token = 0;
4600 goto next_character;
4602 #endif /* COND_REGEXP */
4604 #ifdef EXTENDED_GLOB
4605 /* Parse a ksh-style extended pattern matching specification. */
4606 if MBTEST(extended_glob && PATTERN_CHAR (character))
4608 peek_char = shell_getc (1);
4609 if MBTEST(peek_char == '(') /* ) */
4611 push_delimiter (dstack, peek_char);
4612 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4613 pop_delimiter (dstack);
4614 if (ttok == &matched_pair_error)
4615 return -1; /* Bail immediately. */
4616 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 3,
4618 TOKEN_DEFAULT_GROW_SIZE);
4619 token[token_index++] = character;
4620 token[token_index++] = peek_char;
4621 strcpy (token + token_index, ttok);
4622 token_index += ttoklen;
4624 dollar_present = all_digit_token = 0;
4625 goto next_character;
4628 shell_ungetc (peek_char);
4630 #endif /* EXTENDED_GLOB */
4632 /* If the delimiter character is not single quote, parse some of
4633 the shell expansions that must be read as a single word. */
4634 if (shellexp (character))
4636 peek_char = shell_getc (1);
4637 /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
4638 if MBTEST(peek_char == '(' ||
4639 ((peek_char == '{' || peek_char == '[') && character == '$')) /* ) ] } */
4641 if (peek_char == '{') /* } */
4642 ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE|P_DOLBRACE);
4643 else if (peek_char == '(') /* ) */
4645 /* XXX - push and pop the `(' as a delimiter for use by
4646 the command-oriented-history code. This way newlines
4647 appearing in the $(...) string get added to the
4648 history literally rather than causing a possibly-
4649 incorrect `;' to be added. ) */
4650 push_delimiter (dstack, peek_char);
4651 ttok = parse_comsub (cd, '(', ')', &ttoklen, P_COMMAND);
4652 pop_delimiter (dstack);
4655 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
4656 if (ttok == &matched_pair_error)
4657 return -1; /* Bail immediately. */
4658 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 3,
4660 TOKEN_DEFAULT_GROW_SIZE);
4661 token[token_index++] = character;
4662 token[token_index++] = peek_char;
4663 strcpy (token + token_index, ttok);
4664 token_index += ttoklen;
4667 all_digit_token = 0;
4668 goto next_character;
4670 /* This handles $'...' and $"..." new-style quoted strings. */
4671 else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
4675 first_line = line_number;
4676 push_delimiter (dstack, peek_char);
4677 ttok = parse_matched_pair (peek_char, peek_char, peek_char,
4679 (peek_char == '\'') ? P_ALLOWESC : 0);
4680 pop_delimiter (dstack);
4681 if (ttok == &matched_pair_error)
4683 if (peek_char == '\'')
4685 ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
4688 /* Insert the single quotes and correctly quote any
4689 embedded single quotes (allowed because P_ALLOWESC was
4690 passed to parse_matched_pair). */
4691 ttok = sh_single_quote (ttrans);
4693 ttranslen = strlen (ttok);
4698 /* Try to locale-expand the converted string. */
4699 ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
4702 /* Add the double quotes back */
4703 ttok = sh_mkdoublequoted (ttrans, ttranslen, 0);
4709 RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 1,
4711 TOKEN_DEFAULT_GROW_SIZE);
4712 strcpy (token + token_index, ttrans);
4713 token_index += ttranslen;
4716 all_digit_token = 0;
4717 goto next_character;
4719 /* This could eventually be extended to recognize all of the
4720 shell's single-character parameter expansions, and set flags.*/
4721 else if MBTEST(character == '$' && peek_char == '$')
4723 RESIZE_MALLOCED_BUFFER (token, token_index, 3,
4725 TOKEN_DEFAULT_GROW_SIZE);
4726 token[token_index++] = '$';
4727 token[token_index++] = peek_char;
4729 all_digit_token = 0;
4730 goto next_character;
4733 shell_ungetc (peek_char);
4736 #if defined (ARRAY_VARS)
4737 /* Identify possible array subscript assignment; match [...]. If
4738 parser_state&PST_COMPASSIGN, we need to parse [sub]=words treating
4739 `sub' as if it were enclosed in double quotes. */
4740 else if MBTEST(character == '[' && /* ] */
4741 ((token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) ||
4742 (token_index == 0 && (parser_state&PST_COMPASSIGN))))
4744 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, P_ARRAYSUB);
4745 if (ttok == &matched_pair_error)
4746 return -1; /* Bail immediately. */
4747 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4749 TOKEN_DEFAULT_GROW_SIZE);
4750 token[token_index++] = character;
4751 strcpy (token + token_index, ttok);
4752 token_index += ttoklen;
4754 all_digit_token = 0;
4755 goto next_character;
4757 /* Identify possible compound array variable assignment. */
4758 else if MBTEST(character == '=' && token_index > 0 && (assignment_acceptable (last_read_token) || (parser_state & PST_ASSIGNOK)) && token_is_assignment (token, token_index))
4760 peek_char = shell_getc (1);
4761 if MBTEST(peek_char == '(') /* ) */
4763 ttok = parse_compound_assignment (&ttoklen);
4765 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
4767 TOKEN_DEFAULT_GROW_SIZE);
4769 token[token_index++] = '=';
4770 token[token_index++] = '(';
4773 strcpy (token + token_index, ttok);
4774 token_index += ttoklen;
4776 token[token_index++] = ')';
4778 all_digit_token = 0;
4779 compound_assignment = 1;
4781 goto next_character;
4783 goto got_token; /* ksh93 seems to do this */
4787 shell_ungetc (peek_char);
4791 /* When not parsing a multi-character word construct, shell meta-
4792 characters break words. */
4793 if MBTEST(shellbreak (character))
4795 shell_ungetc (character);
4801 if (character == CTLESC || character == CTLNUL)
4803 RESIZE_MALLOCED_BUFFER (token, token_index, 2, token_buffer_size,
4804 TOKEN_DEFAULT_GROW_SIZE);
4805 token[token_index++] = CTLESC;
4808 got_escaped_character:
4809 RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
4810 TOKEN_DEFAULT_GROW_SIZE);
4812 token[token_index++] = character;
4814 all_digit_token &= DIGIT (character);
4815 dollar_present |= character == '$';
4818 if (character == '\n' && SHOULD_PROMPT ())
4821 /* We want to remove quoted newlines (that is, a \<newline> pair)
4822 unless we are within single quotes or pass_next_character is
4823 set (the shell equivalent of literal-next). */
4824 cd = current_delimiter (dstack);
4825 character = shell_getc (cd != '\'' && pass_next_character == 0);
4826 } /* end for (;;) */
4830 /* Calls to RESIZE_MALLOCED_BUFFER ensure there is sufficient room. */
4831 token[token_index] = '\0';
4833 /* Check to see what thing we should return. If the last_read_token
4834 is a `<', or a `&', or the character which ended this token is
4835 a '>' or '<', then, and ONLY then, is this input token a NUMBER.
4836 Otherwise, it is just a word, and should be returned as such. */
4837 if MBTEST(all_digit_token && (character == '<' || character == '>' ||
4838 last_read_token == LESS_AND ||
4839 last_read_token == GREATER_AND))
4841 if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
4843 yylval.number = lvalue;
4848 /* Check for special case tokens. */
4849 result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
4854 /* Posix.2 does not allow reserved words to be aliased, so check for all
4855 of them, including special cases, before expanding the current token
4857 if MBTEST(posixly_correct)
4858 CHECK_FOR_RESERVED_WORD (token);
4860 /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
4861 inhibits alias expansion. */
4862 if (expand_aliases && quoted == 0)
4864 result = alias_expand_token (token);
4865 if (result == RE_READ_TOKEN)
4866 return (RE_READ_TOKEN);
4867 else if (result == NO_EXPANSION)
4868 parser_state &= ~PST_ALEXPNEXT;
4871 /* If not in Posix.2 mode, check for reserved words after alias
4873 if MBTEST(posixly_correct == 0)
4875 CHECK_FOR_RESERVED_WORD (token);
4877 the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
4878 the_word->word = (char *)xmalloc (1 + token_index);
4879 the_word->flags = 0;
4880 strcpy (the_word->word, token);
4882 the_word->flags |= W_HASDOLLAR;
4884 the_word->flags |= W_QUOTED; /*(*/
4885 if (compound_assignment && token[token_index-1] == ')')
4886 the_word->flags |= W_COMPASSIGN;
4887 /* A word is an assignment if it appears at the beginning of a
4888 simple command, or after another assignment word. This is
4889 context-dependent, so it cannot be handled in the grammar. */
4890 if (assignment (token, (parser_state & PST_COMPASSIGN) != 0))
4892 the_word->flags |= W_ASSIGNMENT;
4893 /* Don't perform word splitting on assignment statements. */
4894 if (assignment_acceptable (last_read_token) || (parser_state & PST_COMPASSIGN) != 0)
4896 the_word->flags |= W_NOSPLIT;
4897 if (parser_state & PST_COMPASSIGN)
4898 the_word->flags |= W_NOGLOB; /* XXX - W_NOBRACE? */
4902 if (command_token_position (last_read_token))
4905 b = builtin_address_internal (token, 0);
4906 if (b && (b->flags & ASSIGNMENT_BUILTIN))
4907 parser_state |= PST_ASSIGNOK;
4908 else if (STREQ (token, "eval") || STREQ (token, "let"))
4909 parser_state |= PST_ASSIGNOK;
4912 yylval.word = the_word;
4914 if (token[0] == '{' && token[token_index-1] == '}' &&
4915 (character == '<' || character == '>'))
4917 /* can use token; already copied to the_word */
4918 token[token_index-1] = '\0';
4919 #if defined (ARRAY_VARS)
4920 if (legal_identifier (token+1) || valid_array_reference (token+1))
4922 if (legal_identifier (token+1))
4925 strcpy (the_word->word, token+1);
4926 /*itrace("read_token_word: returning REDIR_WORD for %s", the_word->word);*/
4927 return (REDIR_WORD);
4931 result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
4932 ? ASSIGNMENT_WORD : WORD;
4934 switch (last_read_token)
4937 parser_state |= PST_ALLOWOPNBRC;
4938 function_dstart = line_number;
4943 if (word_top < MAX_CASE_NEST)
4945 word_lineno[word_top] = line_number;
4952 /* Return 1 if TOKSYM is a token that after being read would allow
4953 a reserved word to be seen, else 0. */
4955 reserved_word_acceptable (toksym)
4992 #if defined (COPROCESS_SUPPORT)
4993 if (last_read_token == WORD && token_before_that == COPROC)
4996 if (last_read_token == WORD && token_before_that == FUNCTION)
5002 /* Return the index of TOKEN in the alist of reserved words, or -1 if
5003 TOKEN is not a shell reserved word. */
5005 find_reserved_word (tokstr)
5009 for (i = 0; word_token_alist[i].word; i++)
5010 if (STREQ (tokstr, word_token_alist[i].word))
5015 /* An interface to let the rest of the shell (primarily the completion
5016 system) know what the parser is expecting. */
5018 parser_in_command_position ()
5020 return (command_token_position (last_read_token));
5024 #if defined (READLINE)
5025 /* Called after each time readline is called. This insures that whatever
5026 the new prompt string is gets propagated to readline's local prompt
5029 reset_readline_prompt ()
5033 if (prompt_string_pointer)
5035 temp_prompt = (*prompt_string_pointer)
5036 ? decode_prompt_string (*prompt_string_pointer)
5039 if (temp_prompt == 0)
5041 temp_prompt = (char *)xmalloc (1);
5042 temp_prompt[0] = '\0';
5045 FREE (current_readline_prompt);
5046 current_readline_prompt = temp_prompt;
5049 #endif /* READLINE */
5052 #if defined (HISTORY)
5053 /* A list of tokens which can be followed by newlines, but not by
5054 semi-colons. When concatenating multiple lines of history, the
5055 newline separator for such tokens is replaced with a space. */
5056 static const int no_semi_successors[] = {
5057 '\n', '{', '(', ')', ';', '&', '|',
5058 CASE, DO, ELSE, IF, SEMI_SEMI, SEMI_AND, SEMI_SEMI_AND, THEN, UNTIL,
5059 WHILE, AND_AND, OR_OR, IN,
5063 /* If we are not within a delimited expression, try to be smart
5064 about which separators can be semi-colons and which must be
5065 newlines. Returns the string that should be added into the
5066 history entry. LINE is the line we're about to add; it helps
5067 make some more intelligent decisions in certain cases. */
5069 history_delimiting_chars (line)
5072 static int last_was_heredoc = 0; /* was the last entry the start of a here document? */
5075 if ((parser_state & PST_HEREDOC) == 0)
5076 last_was_heredoc = 0;
5078 if (dstack.delimiter_depth != 0)
5081 /* We look for current_command_line_count == 2 because we are looking to
5082 add the first line of the body of the here document (the second line
5083 of the command). We also keep LAST_WAS_HEREDOC as a private sentinel
5084 variable to note when we think we added the first line of a here doc
5085 (the one with a "<<" somewhere in it) */
5086 if (parser_state & PST_HEREDOC)
5088 if (last_was_heredoc)
5090 last_was_heredoc = 0;
5093 return (current_command_line_count == 2 ? "\n" : "");
5096 if (parser_state & PST_COMPASSIGN)
5099 /* First, handle some special cases. */
5101 /* If we just read `()', assume it's a function definition, and don't
5102 add a semicolon. If the token before the `)' was not `(', and we're
5103 not in the midst of parsing a case statement, assume it's a
5104 parenthesized command and add the semicolon. */
5106 if (token_before_that == ')')
5108 if (two_tokens_ago == '(') /*)*/ /* function def */
5110 /* This does not work for subshells inside case statement
5111 command lists. It's a suboptimal solution. */
5112 else if (parser_state & PST_CASESTMT) /* case statement pattern */
5115 return "; "; /* (...) subshell */
5117 else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
5118 return " "; /* function def using `function name' without `()' */
5120 /* If we're not in a here document, but we think we're about to parse one,
5121 and we would otherwise return a `;', return a newline to delimit the
5122 line with the here-doc delimiter */
5123 else if ((parser_state & PST_HEREDOC) == 0 && current_command_line_count > 1 && last_read_token == '\n' && strstr (line, "<<"))
5125 last_was_heredoc = 1;
5129 else if (token_before_that == WORD && two_tokens_ago == FOR)
5131 /* Tricky. `for i\nin ...' should not have a semicolon, but
5132 `for i\ndo ...' should. We do what we can. */
5133 for (i = shell_input_line_index; whitespace (shell_input_line[i]); i++)
5135 if (shell_input_line[i] && shell_input_line[i] == 'i' && shell_input_line[i+1] == 'n')
5139 else if (two_tokens_ago == CASE && token_before_that == WORD && (parser_state & PST_CASESTMT))
5142 for (i = 0; no_semi_successors[i]; i++)
5144 if (token_before_that == no_semi_successors[i])
5150 #endif /* HISTORY */
5152 /* Issue a prompt, or prepare to issue a prompt when the next character
5159 if (interactive == 0 || expanding_alias ()) /* XXX */
5162 ps1_prompt = get_string_value ("PS1");
5163 ps2_prompt = get_string_value ("PS2");
5165 if (!prompt_string_pointer)
5166 prompt_string_pointer = &ps1_prompt;
5168 temp_prompt = *prompt_string_pointer
5169 ? decode_prompt_string (*prompt_string_pointer)
5172 if (temp_prompt == 0)
5174 temp_prompt = (char *)xmalloc (1);
5175 temp_prompt[0] = '\0';
5178 current_prompt_string = *prompt_string_pointer;
5179 prompt_string_pointer = &ps2_prompt;
5181 #if defined (READLINE)
5182 if (!no_line_editing)
5184 FREE (current_readline_prompt);
5185 current_readline_prompt = temp_prompt;
5188 #endif /* READLINE */
5190 FREE (current_decoded_prompt);
5191 current_decoded_prompt = temp_prompt;
5196 get_current_prompt_level ()
5198 return ((current_prompt_string && current_prompt_string == ps2_prompt) ? 2 : 1);
5202 set_current_prompt_level (x)
5205 prompt_string_pointer = (x == 2) ? &ps2_prompt : &ps1_prompt;
5206 current_prompt_string = *prompt_string_pointer;
5212 fprintf (stderr, "%s", current_decoded_prompt);
5216 /* Return a string which will be printed as a prompt. The string
5217 may contain special characters which are decoded as follows:
5220 \d the date in Day Mon Date format
5221 \e escape (ascii 033)
5222 \h the hostname up to the first `.'
5224 \j the number of active jobs
5225 \l the basename of the shell's tty device name
5228 \s the name of the shell
5229 \t the time in 24-hour hh:mm:ss format
5230 \T the time in 12-hour hh:mm:ss format
5231 \@ the time in 12-hour hh:mm am/pm format
5232 \A the time in 24-hour hh:mm format
5233 \D{fmt} the result of passing FMT to strftime(3)
5235 \v the version of bash (e.g., 2.00)
5236 \V the release of bash, version + patchlevel (e.g., 2.00.0)
5237 \w the current working directory
5238 \W the last element of $PWD
5239 \! the history number of this command
5240 \# the command number of this command
5241 \$ a $ or a # if you are root
5242 \nnn character code nnn in octal
5244 \[ begin a sequence of non-printing chars
5245 \] end a sequence of non-printing chars
5247 #define PROMPT_GROWTH 48
5249 decode_prompt_string (string)
5254 struct dstack save_dstack;
5255 int last_exit_value, last_comsub_pid;
5256 #if defined (PROMPT_STRING_DECODE)
5257 int result_size, result_index;
5259 char *temp, octal_string[4];
5265 result = (char *)xmalloc (result_size = PROMPT_GROWTH);
5266 result[result_index = 0] = 0;
5267 temp = (char *)NULL;
5269 while (c = *string++)
5271 if (posixly_correct && c == '!')
5275 temp = savestring ("!");
5280 #if !defined (HISTORY)
5281 temp = savestring ("1");
5283 temp = itos (history_number ());
5284 #endif /* HISTORY */
5285 string--; /* add_string increments string again. */
5303 strncpy (octal_string, string, 3);
5304 octal_string[3] = '\0';
5306 n = read_octal (octal_string);
5307 temp = (char *)xmalloc (3);
5309 if (n == CTLESC || n == CTLNUL)
5326 for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
5329 c = 0; /* tested at add_string: */
5337 /* Make the current time/date into a string. */
5338 (void) time (&the_time);
5339 #if defined (HAVE_TZSET)
5340 sv_tz ("TZ"); /* XXX -- just make sure */
5342 tm = localtime (&the_time);
5345 n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
5347 n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
5349 n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
5351 n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
5353 n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
5358 timebuf[sizeof(timebuf) - 1] = '\0';
5360 temp = savestring (timebuf);
5363 case 'D': /* strftime format */
5364 if (string[1] != '{') /* } */
5367 (void) time (&the_time);
5368 tm = localtime (&the_time);
5369 string += 2; /* skip { */
5370 timefmt = xmalloc (strlen (string) + 3);
5371 for (t = timefmt; *string && *string != '}'; )
5374 c = *string; /* tested at add_string */
5375 if (timefmt[0] == '\0')
5378 timefmt[1] = 'X'; /* locale-specific current time */
5381 n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
5387 timebuf[sizeof(timebuf) - 1] = '\0';
5389 if (promptvars || posixly_correct)
5390 /* Make sure that expand_prompt_string is called with a
5391 second argument of Q_DOUBLE_QUOTES if we use this
5393 temp = sh_backslash_quote_for_double_quotes (timebuf);
5395 temp = savestring (timebuf);
5399 temp = (char *)xmalloc (3);
5400 temp[0] = no_line_editing ? '\n' : '\r';
5401 temp[1] = no_line_editing ? '\0' : '\n';
5406 temp = base_pathname (shell_name);
5407 temp = savestring (temp);
5412 temp = (char *)xmalloc (16);
5414 strcpy (temp, dist_version);
5416 sprintf (temp, "%s.%d", dist_version, patch_level);
5422 /* Use the value of PWD because it is much more efficient. */
5423 char t_string[PATH_MAX];
5426 temp = get_string_value ("PWD");
5430 if (getcwd (t_string, sizeof(t_string)) == 0)
5436 tlen = strlen (t_string);
5440 tlen = sizeof (t_string) - 1;
5441 strncpy (t_string, temp, tlen);
5443 t_string[tlen] = '\0';
5445 #if defined (MACOSX)
5446 /* Convert from "fs" format to "input" format */
5447 temp = fnx_fromfs (t_string, strlen (t_string));
5448 if (temp != t_string)
5449 strcpy (t_string, temp);
5452 #define ROOT_PATH(x) ((x)[0] == '/' && (x)[1] == 0)
5453 #define DOUBLE_SLASH_ROOT(x) ((x)[0] == '/' && (x)[1] == '/' && (x)[2] == 0)
5454 /* Abbreviate \W as ~ if $PWD == $HOME */
5455 if (c == 'W' && (((t = get_string_value ("HOME")) == 0) || STREQ (t, t_string) == 0))
5457 if (ROOT_PATH (t_string) == 0 && DOUBLE_SLASH_ROOT (t_string) == 0)
5459 t = strrchr (t_string, '/');
5461 memmove (t_string, t + 1, strlen (t)); /* strlen(t) to copy NULL */
5465 #undef DOUBLE_SLASH_ROOT
5468 /* polite_directory_format is guaranteed to return a string
5469 no longer than PATH_MAX - 1 characters. */
5470 temp = polite_directory_format (t_string);
5471 if (temp != t_string)
5472 strcpy (t_string, temp);
5475 temp = trim_pathname (t_string, PATH_MAX - 1);
5476 /* If we're going to be expanding the prompt string later,
5477 quote the directory name. */
5478 if (promptvars || posixly_correct)
5479 /* Make sure that expand_prompt_string is called with a
5480 second argument of Q_DOUBLE_QUOTES if we use this
5482 temp = sh_backslash_quote_for_double_quotes (t_string);
5484 temp = savestring (t_string);
5490 if (current_user.user_name == 0)
5491 get_current_user_info ();
5492 temp = savestring (current_user.user_name);
5497 temp = savestring (current_host_name);
5498 if (c == 'h' && (t = (char *)strchr (temp, '.')))
5503 temp = itos (current_command_number);
5507 #if !defined (HISTORY)
5508 temp = savestring ("1");
5510 temp = itos (history_number ());
5511 #endif /* HISTORY */
5515 t = temp = (char *)xmalloc (3);
5516 if ((promptvars || posixly_correct) && (current_user.euid != 0))
5518 *t++ = current_user.euid == 0 ? '#' : '$';
5523 temp = itos (count_all_jobs ());
5527 #if defined (HAVE_TTYNAME)
5528 temp = (char *)ttyname (fileno (stdin));
5529 t = temp ? base_pathname (temp) : "tty";
5530 temp = savestring (t);
5532 temp = savestring ("tty");
5533 #endif /* !HAVE_TTYNAME */
5536 #if defined (READLINE)
5539 if (no_line_editing)
5544 temp = (char *)xmalloc (3);
5545 n = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
5547 if (n == CTLESC || n == CTLNUL)
5552 #endif /* READLINE */
5558 temp = (char *)xmalloc (2);
5565 else /* (c == '\\') */
5572 temp = (char *)xmalloc (3);
5581 sub_append_string (temp, result, &result_index, &result_size);
5582 temp = (char *)NULL; /* Freed in sub_append_string (). */
5583 result[result_index] = '\0';
5589 RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
5590 result[result_index++] = c;
5591 result[result_index] = '\0';
5594 #else /* !PROMPT_STRING_DECODE */
5595 result = savestring (string);
5596 #endif /* !PROMPT_STRING_DECODE */
5598 /* Save the delimiter stack and point `dstack' to temp space so any
5599 command substitutions in the prompt string won't result in screwing
5600 up the parser's quoting state. */
5601 save_dstack = dstack;
5602 dstack = temp_dstack;
5603 dstack.delimiter_depth = 0;
5605 /* Perform variable and parameter expansion and command substitution on
5606 the prompt string. */
5607 if (promptvars || posixly_correct)
5609 last_exit_value = last_command_exit_value;
5610 last_comsub_pid = last_command_subst_pid;
5611 list = expand_prompt_string (result, Q_DOUBLE_QUOTES, 0);
5613 result = string_list (list);
5614 dispose_words (list);
5615 last_command_exit_value = last_exit_value;
5616 last_command_subst_pid = last_comsub_pid;
5620 t = dequote_string (result);
5625 dstack = save_dstack;
5630 /************************************************
5634 ************************************************/
5636 /* Report a syntax error, and restart the parser. Call here for fatal
5642 report_syntax_error ((char *)NULL);
5648 error_token_from_token (tok)
5653 if (t = find_token_in_alist (tok, word_token_alist, 0))
5656 if (t = find_token_in_alist (tok, other_token_alist, 0))
5660 /* This stuff is dicy and needs closer inspection */
5661 switch (current_token)
5664 case ASSIGNMENT_WORD:
5666 t = savestring (yylval.word->word);
5669 t = itos (yylval.number);
5672 if (yylval.word_list)
5673 t = string_list (yylval.word_list);
5675 case ARITH_FOR_EXPRS:
5676 if (yylval.word_list)
5677 t = string_list_internal (yylval.word_list, " ; ");
5680 t = (char *)NULL; /* punt */
5688 error_token_from_text ()
5693 t = shell_input_line;
5694 i = shell_input_line_index;
5698 if (i && t[i] == '\0')
5701 while (i && (whitespace (t[i]) || t[i] == '\n'))
5707 while (i && (member (t[i], " \n\t;|&") == 0))
5710 while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
5713 /* Return our idea of the offending token. */
5714 if (token_end || (i == 0 && token_end == 0))
5717 msg = substring (t, i, token_end);
5718 else /* one-character token */
5720 msg = (char *)xmalloc (2);
5730 print_offending_line ()
5735 msg = savestring (shell_input_line);
5736 token_end = strlen (msg);
5737 while (token_end && msg[token_end - 1] == '\n')
5738 msg[--token_end] = '\0';
5740 parser_error (line_number, "`%s'", msg);
5744 /* Report a syntax error with line numbers, etc.
5745 Call here for recoverable errors. If you have a message to print,
5746 then place it in MESSAGE, otherwise pass NULL and this will figure
5747 out an appropriate message for you. */
5749 report_syntax_error (message)
5756 parser_error (line_number, "%s", message);
5757 if (interactive && EOF_Reached)
5759 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5763 /* If the line of input we're reading is not null, try to find the
5764 objectionable token. First, try to figure out what token the
5765 parser's complaining about by looking at current_token. */
5766 if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
5768 if (ansic_shouldquote (msg))
5770 p = ansic_quote (msg, 0, NULL);
5774 parser_error (line_number, _("syntax error near unexpected token `%s'"), msg);
5777 if (interactive == 0)
5778 print_offending_line ();
5780 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5784 /* If looking at the current token doesn't prove fruitful, try to find the
5785 offending token by analyzing the text of the input line near the current
5786 input line index and report what we find. */
5787 if (shell_input_line && *shell_input_line)
5789 msg = error_token_from_text ();
5792 parser_error (line_number, _("syntax error near `%s'"), msg);
5796 /* If not interactive, print the line containing the error. */
5797 if (interactive == 0)
5798 print_offending_line ();
5802 msg = EOF_Reached ? _("syntax error: unexpected end of file") : _("syntax error");
5803 parser_error (line_number, "%s", msg);
5804 /* When the shell is interactive, this file uses EOF_Reached
5805 only for error reporting. Other mechanisms are used to
5806 decide whether or not to exit. */
5807 if (interactive && EOF_Reached)
5811 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5814 /* ??? Needed function. ??? We have to be able to discard the constructs
5815 created during parsing. In the case of error, we want to return
5816 allocated objects to the memory pool. In the case of no error, we want
5817 to throw away the information about where the allocated objects live.
5818 (dispose_command () will actually free the command.) */
5820 discard_parser_constructs (error_p)
5825 /************************************************
5829 ************************************************/
5831 /* Do that silly `type "bye" to exit' stuff. You know, "ignoreeof". */
5833 /* A flag denoting whether or not ignoreeof is set. */
5836 /* The number of times that we have encountered an EOF character without
5837 another character intervening. When this gets above the limit, the
5838 shell terminates. */
5839 int eof_encountered = 0;
5841 /* The limit for eof_encountered. */
5842 int eof_encountered_limit = 10;
5844 /* If we have EOF as the only input unit, this user wants to leave
5845 the shell. If the shell is not interactive, then just leave.
5846 Otherwise, if ignoreeof is set, and we haven't done this the
5847 required number of times in a row, print a message. */
5849 handle_eof_input_unit ()
5853 /* shell.c may use this to decide whether or not to write out the
5854 history, among other things. We use it only for error reporting
5859 /* If the user wants to "ignore" eof, then let her do so, kind of. */
5862 if (eof_encountered < eof_encountered_limit)
5864 fprintf (stderr, _("Use \"%s\" to leave the shell.\n"),
5865 login_shell ? "logout" : "exit");
5867 /* Reset the parsing state. */
5868 last_read_token = current_token = '\n';
5869 /* Reset the prompt string to be $PS1. */
5870 prompt_string_pointer = (char **)NULL;
5876 /* In this case EOF should exit the shell. Do it now. */
5878 exit_builtin ((WORD_LIST *)NULL);
5882 /* We don't write history files, etc., for non-interactive shells. */
5887 /************************************************
5889 * STRING PARSING FUNCTIONS *
5891 ************************************************/
5893 /* It's very important that these two functions treat the characters
5894 between ( and ) identically. */
5896 static WORD_LIST parse_string_error;
5898 /* Take a string and run it through the shell parser, returning the
5899 resultant word list. Used by compound array assignment. */
5901 parse_string_to_word_list (s, flags, whom)
5907 int tok, orig_current_token, orig_line_number, orig_input_terminator;
5908 int orig_line_count;
5909 int old_echo_input, old_expand_aliases;
5910 #if defined (HISTORY)
5911 int old_remember_on_history, old_history_expansion_inhibited;
5914 #if defined (HISTORY)
5915 old_remember_on_history = remember_on_history;
5916 # if defined (BANG_HISTORY)
5917 old_history_expansion_inhibited = history_expansion_inhibited;
5919 bash_history_disable ();
5922 orig_line_number = line_number;
5923 orig_line_count = current_command_line_count;
5924 orig_input_terminator = shell_input_line_terminator;
5925 old_echo_input = echo_input_at_read;
5926 old_expand_aliases = expand_aliases;
5929 last_read_token = WORD; /* WORD to allow reserved words here */
5930 current_command_line_count = 0;
5931 echo_input_at_read = expand_aliases = 0;
5933 with_input_from_string (s, whom);
5934 wl = (WORD_LIST *)NULL;
5937 parser_state |= PST_COMPASSIGN|PST_REPARSE;
5939 while ((tok = read_token (READ)) != yacc_EOF)
5941 if (tok == '\n' && *bash_input.location.string == '\0')
5943 if (tok == '\n') /* Allow newlines in compound assignments */
5945 if (tok != WORD && tok != ASSIGNMENT_WORD)
5947 line_number = orig_line_number + line_number - 1;
5948 orig_current_token = current_token;
5949 current_token = tok;
5950 yyerror (NULL); /* does the right thing */
5951 current_token = orig_current_token;
5954 wl = &parse_string_error;
5957 wl = make_word_list (yylval.word, wl);
5960 last_read_token = '\n';
5963 #if defined (HISTORY)
5964 remember_on_history = old_remember_on_history;
5965 # if defined (BANG_HISTORY)
5966 history_expansion_inhibited = old_history_expansion_inhibited;
5967 # endif /* BANG_HISTORY */
5968 #endif /* HISTORY */
5970 echo_input_at_read = old_echo_input;
5971 expand_aliases = old_expand_aliases;
5973 current_command_line_count = orig_line_count;
5974 shell_input_line_terminator = orig_input_terminator;
5977 parser_state &= ~(PST_COMPASSIGN|PST_REPARSE);
5979 if (wl == &parse_string_error)
5981 last_command_exit_value = EXECUTION_FAILURE;
5982 if (interactive_shell == 0 && posixly_correct)
5983 jump_to_top_level (FORCE_EOF);
5985 jump_to_top_level (DISCARD);
5988 return (REVERSE_LIST (wl, WORD_LIST *));
5992 parse_compound_assignment (retlenp)
5996 int tok, orig_line_number, orig_token_size, orig_last_token, assignok;
5997 char *saved_token, *ret;
5999 saved_token = token;
6000 orig_token_size = token_buffer_size;
6001 orig_line_number = line_number;
6002 orig_last_token = last_read_token;
6004 last_read_token = WORD; /* WORD to allow reserved words here */
6006 token = (char *)NULL;
6007 token_buffer_size = 0;
6009 assignok = parser_state&PST_ASSIGNOK; /* XXX */
6011 wl = (WORD_LIST *)NULL; /* ( */
6012 parser_state |= PST_COMPASSIGN;
6014 while ((tok = read_token (READ)) != ')')
6016 if (tok == '\n') /* Allow newlines in compound assignments */
6018 if (SHOULD_PROMPT ())
6022 if (tok != WORD && tok != ASSIGNMENT_WORD)
6024 current_token = tok; /* for error reporting */
6025 if (tok == yacc_EOF) /* ( */
6026 parser_error (orig_line_number, _("unexpected EOF while looking for matching `)'"));
6028 yyerror(NULL); /* does the right thing */
6031 wl = &parse_string_error;
6034 wl = make_word_list (yylval.word, wl);
6038 token = saved_token;
6039 token_buffer_size = orig_token_size;
6041 parser_state &= ~PST_COMPASSIGN;
6043 if (wl == &parse_string_error)
6045 last_command_exit_value = EXECUTION_FAILURE;
6046 last_read_token = '\n'; /* XXX */
6047 if (interactive_shell == 0 && posixly_correct)
6048 jump_to_top_level (FORCE_EOF);
6050 jump_to_top_level (DISCARD);
6053 last_read_token = orig_last_token; /* XXX - was WORD? */
6057 rl = REVERSE_LIST (wl, WORD_LIST *);
6058 ret = string_list (rl);
6065 *retlenp = (ret && *ret) ? strlen (ret) : 0;
6068 parser_state |= PST_ASSIGNOK;
6073 /************************************************
6075 * SAVING AND RESTORING PARTIAL PARSE STATE *
6077 ************************************************/
6080 save_parser_state (ps)
6081 sh_parser_state_t *ps;
6084 ps = (sh_parser_state_t *)xmalloc (sizeof (sh_parser_state_t));
6086 return ((sh_parser_state_t *)NULL);
6088 ps->parser_state = parser_state;
6089 ps->token_state = save_token_state ();
6091 ps->input_line_terminator = shell_input_line_terminator;
6092 ps->eof_encountered = eof_encountered;
6094 ps->prompt_string_pointer = prompt_string_pointer;
6096 ps->current_command_line_count = current_command_line_count;
6098 #if defined (HISTORY)
6099 ps->remember_on_history = remember_on_history;
6100 # if defined (BANG_HISTORY)
6101 ps->history_expansion_inhibited = history_expansion_inhibited;
6105 ps->last_command_exit_value = last_command_exit_value;
6106 #if defined (ARRAY_VARS)
6107 ps->pipestatus = save_pipestatus_array ();
6110 ps->last_shell_builtin = last_shell_builtin;
6111 ps->this_shell_builtin = this_shell_builtin;
6113 ps->expand_aliases = expand_aliases;
6114 ps->echo_input_at_read = echo_input_at_read;
6115 ps->need_here_doc = need_here_doc;
6118 ps->token_buffer_size = token_buffer_size;
6119 /* Force reallocation on next call to read_token_word */
6121 token_buffer_size = 0;
6127 restore_parser_state (ps)
6128 sh_parser_state_t *ps;
6133 parser_state = ps->parser_state;
6134 if (ps->token_state)
6136 restore_token_state (ps->token_state);
6137 free (ps->token_state);
6140 shell_input_line_terminator = ps->input_line_terminator;
6141 eof_encountered = ps->eof_encountered;
6143 prompt_string_pointer = ps->prompt_string_pointer;
6145 current_command_line_count = ps->current_command_line_count;
6147 #if defined (HISTORY)
6148 remember_on_history = ps->remember_on_history;
6149 # if defined (BANG_HISTORY)
6150 history_expansion_inhibited = ps->history_expansion_inhibited;
6154 last_command_exit_value = ps->last_command_exit_value;
6155 #if defined (ARRAY_VARS)
6156 restore_pipestatus_array (ps->pipestatus);
6159 last_shell_builtin = ps->last_shell_builtin;
6160 this_shell_builtin = ps->this_shell_builtin;
6162 expand_aliases = ps->expand_aliases;
6163 echo_input_at_read = ps->echo_input_at_read;
6164 need_here_doc = ps->need_here_doc;
6168 token_buffer_size = ps->token_buffer_size;
6171 sh_input_line_state_t *
6172 save_input_line_state (ls)
6173 sh_input_line_state_t *ls;
6176 ls = (sh_input_line_state_t *)xmalloc (sizeof (sh_input_line_state_t));
6178 return ((sh_input_line_state_t *)NULL);
6180 ls->input_line = shell_input_line;
6181 ls->input_line_size = shell_input_line_size;
6182 ls->input_line_len = shell_input_line_len;
6183 ls->input_line_index = shell_input_line_index;
6185 /* force reallocation */
6186 shell_input_line = 0;
6187 shell_input_line_size = shell_input_line_len = shell_input_line_index = 0;
6193 restore_input_line_state (ls)
6194 sh_input_line_state_t *ls;
6196 FREE (shell_input_line);
6197 shell_input_line = ls->input_line;
6198 shell_input_line_size = ls->input_line_size;
6199 shell_input_line_len = ls->input_line_len;
6200 shell_input_line_index = ls->input_line_index;
6202 set_line_mbstate ();
6205 /************************************************
6207 * MULTIBYTE CHARACTER HANDLING *
6209 ************************************************/
6211 #if defined (HANDLE_MULTIBYTE)
6216 size_t i, previ, len;
6217 mbstate_t mbs, prevs;
6220 if (shell_input_line == NULL)
6222 len = strlen (shell_input_line); /* XXX - shell_input_line_len ? */
6223 FREE (shell_input_line_property);
6224 shell_input_line_property = (char *)xmalloc (len + 1);
6226 memset (&prevs, '\0', sizeof (mbstate_t));
6227 for (i = previ = 0; i < len; i++)
6231 c = shell_input_line[i];
6235 for (j = i; j < len; j++)
6236 shell_input_line_property[j] = 1;
6240 mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
6241 if (mbclen == 1 || mbclen == (size_t)-1)
6246 else if (mbclen == (size_t)-2)
6248 else if (mbclen > 1)
6256 /* XXX - what to do if mbrlen returns 0? (null wide character) */
6258 for (j = i; j < len; j++)
6259 shell_input_line_property[j] = 1;
6263 shell_input_line_property[i] = mbclen;
6266 #endif /* HANDLE_MULTIBYTE */