1 /* parse.y - Yacc grammar for bash. */
3 /* Copyright (C) 1989-2009 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Bash is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
24 #include "bashtypes.h"
29 #if defined (HAVE_UNISTD_H)
33 #if defined (HAVE_LOCALE_H)
38 #include "chartypes.h"
45 #define NEED_STRFTIME_DECL /* used in externs.h */
51 #include "mailcheck.h"
54 #include "builtins/common.h"
55 #include "builtins/builtext.h"
59 #if defined (READLINE)
60 # include "bashline.h"
61 # include <readline/readline.h>
65 # include "bashhist.h"
66 # include <readline/history.h>
69 #if defined (JOB_CONTROL)
71 #endif /* JOB_CONTROL */
76 typedef void *alias_t;
79 #if defined (PROMPT_STRING_DECODE)
81 # include <sys/param.h>
84 # if defined (TM_IN_SYS_TIME)
85 # include <sys/types.h>
86 # include <sys/time.h>
87 # endif /* TM_IN_SYS_TIME */
89 #endif /* PROMPT_STRING_DECODE */
91 #define RE_READ_TOKEN -99
92 #define NO_EXPANSION -100
100 #if defined (HANDLE_MULTIBYTE)
101 # define last_shell_getc_is_singlebyte \
102 ((shell_input_line_index > 1) \
103 ? shell_input_line_property[shell_input_line_index - 1] \
105 # define MBTEST(x) ((x) && last_shell_getc_is_singlebyte)
107 # define last_shell_getc_is_singlebyte 1
108 # define MBTEST(x) ((x))
111 #if defined (EXTENDED_GLOB)
112 extern int extended_glob;
115 extern int eof_encountered;
116 extern int no_line_editing, running_under_emacs;
117 extern int current_command_number;
118 extern int sourcelevel, parse_and_execute_level;
119 extern int posixly_correct;
120 extern int last_command_exit_value;
121 extern char *shell_name, *current_host_name;
122 extern char *dist_version;
123 extern int patch_level;
124 extern int dump_translatable_strings, dump_po_strings;
125 extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
126 #if defined (BUFFERED_INPUT)
127 extern int bash_input_fd_changed;
131 /* **************************************************************** */
133 /* "Forward" declarations */
135 /* **************************************************************** */
138 static void debug_parser __P((int));
141 static int yy_getc __P((void));
142 static int yy_ungetc __P((int));
144 #if defined (READLINE)
145 static int yy_readline_get __P((void));
146 static int yy_readline_unget __P((int));
149 static int yy_string_get __P((void));
150 static int yy_string_unget __P((int));
151 static void rewind_input_string __P((void));
152 static int yy_stream_get __P((void));
153 static int yy_stream_unget __P((int));
155 static int shell_getc __P((int));
156 static void shell_ungetc __P((int));
157 static void discard_until __P((int));
159 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
160 static void push_string __P((char *, int, alias_t *));
161 static void pop_string __P((void));
162 static void free_string_list __P((void));
165 static char *read_a_line __P((int));
167 static int reserved_word_acceptable __P((int));
168 static int yylex __P((void));
169 static int alias_expand_token __P((char *));
170 static int time_command_acceptable __P((void));
171 static int special_case_tokens __P((char *));
172 static int read_token __P((int));
173 static char *parse_matched_pair __P((int, int, int, int *, int));
174 static char *parse_comsub __P((int, int, int, int *, int));
175 #if defined (ARRAY_VARS)
176 static char *parse_compound_assignment __P((int *));
178 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
179 static int parse_dparen __P((int));
180 static int parse_arith_cmd __P((char **, int));
182 #if defined (COND_COMMAND)
183 static void cond_error __P((void));
184 static COND_COM *cond_expr __P((void));
185 static COND_COM *cond_or __P((void));
186 static COND_COM *cond_and __P((void));
187 static COND_COM *cond_term __P((void));
188 static int cond_skip_newlines __P((void));
189 static COMMAND *parse_cond_command __P((void));
191 #if defined (ARRAY_VARS)
192 static int token_is_assignment __P((char *, int));
193 static int token_is_ident __P((char *, int));
195 static int read_token_word __P((int));
196 static void discard_parser_constructs __P((int));
198 static char *error_token_from_token __P((int));
199 static char *error_token_from_text __P((void));
200 static void print_offending_line __P((void));
201 static void report_syntax_error __P((char *));
203 static void handle_eof_input_unit __P((void));
204 static void prompt_again __P((void));
206 static void reset_readline_prompt __P((void));
208 static void print_prompt __P((void));
210 #if defined (HANDLE_MULTIBYTE)
211 static void set_line_mbstate __P((void));
212 static char *shell_input_line_property = NULL;
214 # define set_line_mbstate()
217 extern int yyerror __P((const char *));
223 /* Default prompt strings */
224 char *primary_prompt = PPROMPT;
225 char *secondary_prompt = SPROMPT;
227 /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
228 char *ps1_prompt, *ps2_prompt;
230 /* Handle on the current prompt string. Indirectly points through
231 ps1_ or ps2_prompt. */
232 char **prompt_string_pointer = (char **)NULL;
233 char *current_prompt_string;
235 /* Non-zero means we expand aliases in commands. */
236 int expand_aliases = 0;
238 /* If non-zero, the decoded prompt string undergoes parameter and
239 variable substitution, command substitution, arithmetic substitution,
240 string expansion, process substitution, and quote removal in
241 decode_prompt_string. */
244 /* If non-zero, $'...' and $"..." are expanded when they appear within
245 a ${...} expansion, even when the expansion appears within double
247 int extended_quote = 1;
249 /* The decoded prompt string. Used if READLINE is not defined or if
250 editing is turned off. Analogous to current_readline_prompt. */
251 static char *current_decoded_prompt;
253 /* The number of lines read from input while creating the current command. */
254 int current_command_line_count;
256 /* The token that currently denotes the end of parse. */
259 /* The token currently being read. */
262 /* Variables to manage the task of reading here documents, because we need to
263 defer the reading until after a complete command has been collected. */
264 static REDIRECT *redir_stack[10];
267 /* Where shell input comes from. History expansion is performed on each
268 line when the shell is interactive. */
269 static char *shell_input_line = (char *)NULL;
270 static int shell_input_line_index;
271 static int shell_input_line_size; /* Amount allocated for shell_input_line. */
272 static int shell_input_line_len; /* strlen (shell_input_line) */
274 /* Either zero or EOF. */
275 static int shell_input_line_terminator;
277 /* The line number in a script on which a function definition starts. */
278 static int function_dstart;
280 /* The line number in a script on which a function body starts. */
281 static int function_bstart;
283 /* The line number in a script at which an arithmetic for command starts. */
284 static int arith_for_lineno;
286 /* The current parser state. */
287 static int parser_state;
289 /* The last read token, or NULL. read_token () uses this for context
291 static int last_read_token;
293 /* The token read prior to last_read_token. */
294 static int token_before_that;
296 /* The token read prior to token_before_that. */
297 static int two_tokens_ago;
299 /* The line number in a script where the word in a `case WORD', `select WORD'
300 or `for WORD' begins. This is a nested command maximum, since the array
301 index is decremented after a case, select, or for command is parsed. */
302 #define MAX_CASE_NEST 128
303 static int word_lineno[MAX_CASE_NEST];
304 static int word_top = -1;
306 /* If non-zero, it is the token that we want read_token to return
307 regardless of what text is (or isn't) present to be read. This
308 is reset by read_token. If token_to_read == WORD or
309 ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
310 static int token_to_read;
311 static WORD_DESC *word_desc_to_read;
313 static REDIRECTEE redir;
317 WORD_DESC *word; /* the word that we read. */
318 int number; /* the number that we read. */
319 WORD_LIST *word_list;
323 PATTERN_LIST *pattern;
326 /* Reserved words. Members of the first group are only recognized
327 in the case that they are preceded by a list_terminator. Members
328 of the second group are for [[...]] commands. Members of the
329 third group are recognized only under special circumstances. */
330 %token IF THEN ELSE ELIF FI CASE ESAC FOR SELECT WHILE UNTIL DO DONE FUNCTION COPROC
331 %token COND_START COND_END COND_ERROR
332 %token IN BANG TIME TIMEOPT
334 /* More general tokens. yylex () knows how to make these. */
335 %token <word> WORD ASSIGNMENT_WORD
336 %token <number> NUMBER
337 %token <word_list> ARITH_CMD ARITH_FOR_EXPRS
338 %token <command> COND_CMD
339 %token AND_AND OR_OR GREATER_GREATER LESS_LESS LESS_AND LESS_LESS_LESS
340 %token GREATER_AND SEMI_SEMI SEMI_AND SEMI_SEMI_AND
341 %token LESS_LESS_MINUS AND_GREATER AND_GREATER_GREATER LESS_GREATER
342 %token GREATER_BAR BAR_AND
344 /* The types that the various syntactical units return. */
346 %type <command> inputunit command pipeline pipeline_command
347 %type <command> list list0 list1 compound_list simple_list simple_list1
348 %type <command> simple_command shell_command
349 %type <command> for_command select_command case_command group_command
350 %type <command> arith_command
351 %type <command> cond_command
352 %type <command> arith_for_command
353 %type <command> coproc
354 %type <command> function_def function_body if_command elif_clause subshell
355 %type <redirect> redirection redirection_list
356 %type <element> simple_command_element
357 %type <word_list> word_list pattern
358 %type <pattern> pattern_list case_clause_sequence case_clause
359 %type <number> timespec
360 %type <number> list_terminator
364 %left '&' ';' '\n' yacc_EOF
369 inputunit: simple_list simple_list_terminator
371 /* Case of regular command. Discard the error
372 safety net,and return the command just parsed. */
375 /* discard_parser_constructs (0); */
376 if (parser_state & PST_CMDSUBST)
377 parser_state |= PST_EOFTOKEN;
382 /* Case of regular command, but not a very
383 interesting one. Return a NULL command. */
384 global_command = (COMMAND *)NULL;
385 if (parser_state & PST_CMDSUBST)
386 parser_state |= PST_EOFTOKEN;
391 /* Error during parsing. Return NULL command. */
392 global_command = (COMMAND *)NULL;
394 /* discard_parser_constructs (1); */
395 if (interactive && parse_and_execute_level == 0)
406 /* Case of EOF seen by itself. Do ignoreeof or
408 global_command = (COMMAND *)NULL;
409 handle_eof_input_unit ();
415 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
417 { $$ = make_word_list ($2, $1); }
420 redirection: '>' WORD
423 $$ = make_redirection (1, r_output_direction, redir);
428 $$ = make_redirection (0, r_input_direction, redir);
433 $$ = make_redirection ($1, r_output_direction, redir);
438 $$ = make_redirection ($1, r_input_direction, redir);
440 | GREATER_GREATER WORD
443 $$ = make_redirection (1, r_appending_to, redir);
445 | NUMBER GREATER_GREATER WORD
448 $$ = make_redirection ($1, r_appending_to, redir);
453 $$ = make_redirection (0, r_reading_until, redir);
454 redir_stack[need_here_doc++] = $$;
456 | NUMBER LESS_LESS WORD
459 $$ = make_redirection ($1, r_reading_until, redir);
460 redir_stack[need_here_doc++] = $$;
462 | LESS_LESS_LESS WORD
465 $$ = make_redirection (0, r_reading_string, redir);
467 | NUMBER LESS_LESS_LESS WORD
470 $$ = make_redirection ($1, r_reading_string, redir);
475 $$ = make_redirection (0, r_duplicating_input, redir);
477 | NUMBER LESS_AND NUMBER
480 $$ = make_redirection ($1, r_duplicating_input, redir);
485 $$ = make_redirection (1, r_duplicating_output, redir);
487 | NUMBER GREATER_AND NUMBER
490 $$ = make_redirection ($1, r_duplicating_output, redir);
495 $$ = make_redirection (0, r_duplicating_input_word, redir);
497 | NUMBER LESS_AND WORD
500 $$ = make_redirection ($1, r_duplicating_input_word, redir);
505 $$ = make_redirection (1, r_duplicating_output_word, redir);
507 | NUMBER GREATER_AND WORD
510 $$ = make_redirection ($1, r_duplicating_output_word, redir);
512 | LESS_LESS_MINUS WORD
515 $$ = make_redirection
516 (0, r_deblank_reading_until, redir);
517 redir_stack[need_here_doc++] = $$;
519 | NUMBER LESS_LESS_MINUS WORD
522 $$ = make_redirection
523 ($1, r_deblank_reading_until, redir);
524 redir_stack[need_here_doc++] = $$;
529 $$ = make_redirection (1, r_close_this, redir);
531 | NUMBER GREATER_AND '-'
534 $$ = make_redirection ($1, r_close_this, redir);
539 $$ = make_redirection (0, r_close_this, redir);
541 | NUMBER LESS_AND '-'
544 $$ = make_redirection ($1, r_close_this, redir);
549 $$ = make_redirection (1, r_err_and_out, redir);
551 | AND_GREATER_GREATER WORD
554 $$ = make_redirection (1, r_append_err_and_out, redir);
556 | NUMBER LESS_GREATER WORD
559 $$ = make_redirection ($1, r_input_output, redir);
564 $$ = make_redirection (0, r_input_output, redir);
569 $$ = make_redirection (1, r_output_force, redir);
571 | NUMBER GREATER_BAR WORD
574 $$ = make_redirection ($1, r_output_force, redir);
578 simple_command_element: WORD
579 { $$.word = $1; $$.redirect = 0; }
581 { $$.word = $1; $$.redirect = 0; }
583 { $$.redirect = $1; $$.word = 0; }
586 redirection_list: redirection
590 | redirection_list redirection
592 register REDIRECT *t;
594 for (t = $1; t->next; t = t->next)
601 simple_command: simple_command_element
602 { $$ = make_simple_command ($1, (COMMAND *)NULL); }
603 | simple_command simple_command_element
604 { $$ = make_simple_command ($2, $1); }
607 command: simple_command
608 { $$ = clean_simple_command ($1); }
611 | shell_command redirection_list
618 register REDIRECT *t;
619 for (t = tc->redirects; t->next; t = t->next)
633 shell_command: for_command
637 | WHILE compound_list DO compound_list DONE
638 { $$ = make_while_command ($2, $4); }
639 | UNTIL compound_list DO compound_list DONE
640 { $$ = make_until_command ($2, $4); }
657 for_command: FOR WORD newline_list DO compound_list DONE
659 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
660 if (word_top > 0) word_top--;
662 | FOR WORD newline_list '{' compound_list '}'
664 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
665 if (word_top > 0) word_top--;
667 | FOR WORD ';' newline_list DO compound_list DONE
669 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
670 if (word_top > 0) word_top--;
672 | FOR WORD ';' newline_list '{' compound_list '}'
674 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
675 if (word_top > 0) word_top--;
677 | FOR WORD newline_list IN word_list list_terminator newline_list DO compound_list DONE
679 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
680 if (word_top > 0) word_top--;
682 | FOR WORD newline_list IN word_list list_terminator newline_list '{' compound_list '}'
684 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
685 if (word_top > 0) word_top--;
687 | FOR WORD newline_list IN list_terminator newline_list DO compound_list DONE
689 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
690 if (word_top > 0) word_top--;
692 | FOR WORD newline_list IN list_terminator newline_list '{' compound_list '}'
694 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
695 if (word_top > 0) word_top--;
699 arith_for_command: FOR ARITH_FOR_EXPRS list_terminator newline_list DO compound_list DONE
701 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
702 if (word_top > 0) word_top--;
704 | FOR ARITH_FOR_EXPRS list_terminator newline_list '{' compound_list '}'
706 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
707 if (word_top > 0) word_top--;
709 | FOR ARITH_FOR_EXPRS DO compound_list DONE
711 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
712 if (word_top > 0) word_top--;
714 | FOR ARITH_FOR_EXPRS '{' compound_list '}'
716 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
717 if (word_top > 0) word_top--;
721 select_command: SELECT WORD newline_list DO list DONE
723 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
724 if (word_top > 0) word_top--;
726 | SELECT WORD newline_list '{' list '}'
728 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
729 if (word_top > 0) word_top--;
731 | SELECT WORD ';' newline_list DO list DONE
733 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
734 if (word_top > 0) word_top--;
736 | SELECT WORD ';' newline_list '{' list '}'
738 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
739 if (word_top > 0) word_top--;
741 | SELECT WORD newline_list IN word_list list_terminator newline_list DO list DONE
743 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
744 if (word_top > 0) word_top--;
746 | SELECT WORD newline_list IN word_list list_terminator newline_list '{' list '}'
748 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
749 if (word_top > 0) word_top--;
753 case_command: CASE WORD newline_list IN newline_list ESAC
755 $$ = make_case_command ($2, (PATTERN_LIST *)NULL, word_lineno[word_top]);
756 if (word_top > 0) word_top--;
758 | CASE WORD newline_list IN case_clause_sequence newline_list ESAC
760 $$ = make_case_command ($2, $5, word_lineno[word_top]);
761 if (word_top > 0) word_top--;
763 | CASE WORD newline_list IN case_clause ESAC
765 $$ = make_case_command ($2, $5, word_lineno[word_top]);
766 if (word_top > 0) word_top--;
770 function_def: WORD '(' ')' newline_list function_body
771 { $$ = make_function_def ($1, $5, function_dstart, function_bstart); }
773 | FUNCTION WORD '(' ')' newline_list function_body
774 { $$ = make_function_def ($2, $6, function_dstart, function_bstart); }
776 | FUNCTION WORD newline_list function_body
777 { $$ = make_function_def ($2, $4, function_dstart, function_bstart); }
780 function_body: shell_command
782 | shell_command redirection_list
787 /* According to Posix.2 3.9.5, redirections
788 specified after the body of a function should
789 be attached to the function and performed when
790 the function is executed, not as part of the
791 function definition command. */
792 /* XXX - I don't think it matters, but we might
793 want to change this in the future to avoid
794 problems differentiating between a function
795 definition with a redirection and a function
796 definition containing a single command with a
797 redirection. The two are semantically equivalent,
798 though -- the only difference is in how the
799 command printing code displays the redirections. */
802 register REDIRECT *t;
803 for (t = tc->redirects; t->next; t = t->next)
813 subshell: '(' compound_list ')'
815 $$ = make_subshell_command ($2);
816 $$->flags |= CMD_WANT_SUBSHELL;
820 coproc: COPROC shell_command
822 $$ = make_coproc_command ("COPROC", $2);
823 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
825 | COPROC shell_command redirection_list
832 register REDIRECT *t;
833 for (t = tc->redirects; t->next; t = t->next)
839 $$ = make_coproc_command ("COPROC", $2);
840 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
842 | COPROC WORD shell_command
844 $$ = make_coproc_command ($2->word, $3);
845 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
847 | COPROC WORD shell_command redirection_list
854 register REDIRECT *t;
855 for (t = tc->redirects; t->next; t = t->next)
861 $$ = make_coproc_command ($2->word, $3);
862 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
864 | COPROC simple_command
866 $$ = make_coproc_command ("COPROC", clean_simple_command ($2));
867 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
871 if_command: IF compound_list THEN compound_list FI
872 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
873 | IF compound_list THEN compound_list ELSE compound_list FI
874 { $$ = make_if_command ($2, $4, $6); }
875 | IF compound_list THEN compound_list elif_clause FI
876 { $$ = make_if_command ($2, $4, $5); }
880 group_command: '{' compound_list '}'
881 { $$ = make_group_command ($2); }
884 arith_command: ARITH_CMD
885 { $$ = make_arith_command ($1); }
888 cond_command: COND_START COND_CMD COND_END
892 elif_clause: ELIF compound_list THEN compound_list
893 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
894 | ELIF compound_list THEN compound_list ELSE compound_list
895 { $$ = make_if_command ($2, $4, $6); }
896 | ELIF compound_list THEN compound_list elif_clause
897 { $$ = make_if_command ($2, $4, $5); }
900 case_clause: pattern_list
901 | case_clause_sequence pattern_list
902 { $2->next = $1; $$ = $2; }
905 pattern_list: newline_list pattern ')' compound_list
906 { $$ = make_pattern_list ($2, $4); }
907 | newline_list pattern ')' newline_list
908 { $$ = make_pattern_list ($2, (COMMAND *)NULL); }
909 | newline_list '(' pattern ')' compound_list
910 { $$ = make_pattern_list ($3, $5); }
911 | newline_list '(' pattern ')' newline_list
912 { $$ = make_pattern_list ($3, (COMMAND *)NULL); }
915 case_clause_sequence: pattern_list SEMI_SEMI
917 | case_clause_sequence pattern_list SEMI_SEMI
918 { $2->next = $1; $$ = $2; }
919 | pattern_list SEMI_AND
920 { $1->flags |= CASEPAT_FALLTHROUGH; $$ = $1; }
921 | case_clause_sequence pattern_list SEMI_AND
922 { $2->flags |= CASEPAT_FALLTHROUGH; $2->next = $1; $$ = $2; }
923 | pattern_list SEMI_SEMI_AND
924 { $1->flags |= CASEPAT_TESTNEXT; $$ = $1; }
925 | case_clause_sequence pattern_list SEMI_SEMI_AND
926 { $2->flags |= CASEPAT_TESTNEXT; $2->next = $1; $$ = $2; }
930 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
932 { $$ = make_word_list ($3, $1); }
935 /* A list allows leading or trailing newlines and
936 newlines as operators (equivalent to semicolons).
937 It must end with a newline or semicolon.
938 Lists are used within commands such as if, for, while. */
940 list: newline_list list0
944 gather_here_documents ();
955 list0: list1 '\n' newline_list
956 | list1 '&' newline_list
958 if ($1->type == cm_connection)
959 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
961 $$ = command_connect ($1, (COMMAND *)NULL, '&');
963 | list1 ';' newline_list
967 list1: list1 AND_AND newline_list list1
968 { $$ = command_connect ($1, $4, AND_AND); }
969 | list1 OR_OR newline_list list1
970 { $$ = command_connect ($1, $4, OR_OR); }
971 | list1 '&' newline_list list1
973 if ($1->type == cm_connection)
974 $$ = connect_async_list ($1, $4, '&');
976 $$ = command_connect ($1, $4, '&');
978 | list1 ';' newline_list list1
979 { $$ = command_connect ($1, $4, ';'); }
980 | list1 '\n' newline_list list1
981 { $$ = command_connect ($1, $4, ';'); }
986 simple_list_terminator: '\n'
1002 /* A simple_list is a list that contains no significant newlines
1003 and no leading or trailing newlines. Newlines are allowed
1004 only following operators, where they are not significant.
1006 This is what an inputunit consists of. */
1008 simple_list: simple_list1
1012 gather_here_documents ();
1013 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1015 global_command = $1;
1016 eof_encountered = 0;
1017 rewind_input_string ();
1023 if ($1->type == cm_connection)
1024 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
1026 $$ = command_connect ($1, (COMMAND *)NULL, '&');
1028 gather_here_documents ();
1029 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1031 global_command = $1;
1032 eof_encountered = 0;
1033 rewind_input_string ();
1041 gather_here_documents ();
1042 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1044 global_command = $1;
1045 eof_encountered = 0;
1046 rewind_input_string ();
1052 simple_list1: simple_list1 AND_AND newline_list simple_list1
1053 { $$ = command_connect ($1, $4, AND_AND); }
1054 | simple_list1 OR_OR newline_list simple_list1
1055 { $$ = command_connect ($1, $4, OR_OR); }
1056 | simple_list1 '&' simple_list1
1058 if ($1->type == cm_connection)
1059 $$ = connect_async_list ($1, $3, '&');
1061 $$ = command_connect ($1, $3, '&');
1063 | simple_list1 ';' simple_list1
1064 { $$ = command_connect ($1, $3, ';'); }
1070 pipeline_command: pipeline
1075 $2->flags |= CMD_INVERT_RETURN;
1084 | timespec BANG pipeline
1087 $3->flags |= $1|CMD_INVERT_RETURN;
1090 | BANG timespec pipeline
1093 $3->flags |= $2|CMD_INVERT_RETURN;
1096 | timespec list_terminator
1100 /* Boy, this is unclean. `time' by itself can
1101 time a null command. We cheat and push a
1102 newline back if the list_terminator was a newline
1103 to avoid the double-newline problem (one to
1104 terminate this, one to terminate the command) */
1107 $$ = make_simple_command (x, (COMMAND *)NULL);
1109 /* XXX - let's cheat and push a newline back */
1111 token_to_read = '\n';
1116 pipeline: pipeline '|' newline_list pipeline
1117 { $$ = command_connect ($1, $4, '|'); }
1118 | pipeline BAR_AND newline_list pipeline
1120 /* Make cmd1 |& cmd2 equivalent to cmd1 2>&1 | cmd2 */
1127 r = make_redirection (2, r_duplicating_output, rd);
1130 register REDIRECT *t;
1131 for (t = tc->redirects; t->next; t = t->next)
1138 $$ = command_connect ($1, $4, '|');
1145 { $$ = CMD_TIME_PIPELINE; }
1147 { $$ = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
1151 /* Initial size to allocate for tokens, and the
1152 amount to grow them by. */
1153 #define TOKEN_DEFAULT_INITIAL_SIZE 496
1154 #define TOKEN_DEFAULT_GROW_SIZE 512
1156 /* Should we call prompt_again? */
1157 #define SHOULD_PROMPT() \
1158 (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
1161 # define expanding_alias() (pushed_string_list && pushed_string_list->expander)
1163 # define expanding_alias() 0
1166 /* Global var is non-zero when end of file has been reached. */
1167 int EOF_Reached = 0;
1180 /* yy_getc () returns the next available character from input or EOF.
1181 yy_ungetc (c) makes `c' the next character to read.
1182 init_yy_io (get, unget, type, location) makes the function GET the
1183 installed function for getting the next character, makes UNGET the
1184 installed function for un-getting a character, sets the type of stream
1185 (either string or file) from TYPE, and makes LOCATION point to where
1186 the input is coming from. */
1188 /* Unconditionally returns end-of-file. */
1195 /* Variable containing the current get and unget functions.
1196 See ./input.h for a clearer description. */
1197 BASH_INPUT bash_input;
1199 /* Set all of the fields in BASH_INPUT to NULL. Free bash_input.name if it
1200 is non-null, avoiding a memory leak. */
1202 initialize_bash_input ()
1204 bash_input.type = st_none;
1205 FREE (bash_input.name);
1206 bash_input.name = (char *)NULL;
1207 bash_input.location.file = (FILE *)NULL;
1208 bash_input.location.string = (char *)NULL;
1209 bash_input.getter = (sh_cget_func_t *)NULL;
1210 bash_input.ungetter = (sh_cunget_func_t *)NULL;
1213 /* Set the contents of the current bash input stream from
1214 GET, UNGET, TYPE, NAME, and LOCATION. */
1216 init_yy_io (get, unget, type, name, location)
1217 sh_cget_func_t *get;
1218 sh_cunget_func_t *unget;
1219 enum stream_type type;
1221 INPUT_STREAM location;
1223 bash_input.type = type;
1224 FREE (bash_input.name);
1225 bash_input.name = name ? savestring (name) : (char *)NULL;
1229 memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
1231 bash_input.location = location;
1233 bash_input.getter = get;
1234 bash_input.ungetter = unget;
1240 return (bash_input.name ? bash_input.name : "stdin");
1243 /* Call this to get the next character of input. */
1247 return (*(bash_input.getter)) ();
1250 /* Call this to unget C. That is, to make C the next character
1256 return (*(bash_input.ungetter)) (c);
1259 #if defined (BUFFERED_INPUT)
1260 #ifdef INCLUDE_UNUSED
1262 input_file_descriptor ()
1264 switch (bash_input.type)
1267 return (fileno (bash_input.location.file));
1269 return (bash_input.location.buffered_fd);
1272 return (fileno (stdin));
1276 #endif /* BUFFERED_INPUT */
1278 /* **************************************************************** */
1280 /* Let input be read from readline (). */
1282 /* **************************************************************** */
1284 #if defined (READLINE)
1285 char *current_readline_prompt = (char *)NULL;
1286 char *current_readline_line = (char *)NULL;
1287 int current_readline_line_index = 0;
1292 SigHandler *old_sigint;
1296 if (!current_readline_line)
1298 if (!bash_readline_initialized)
1299 initialize_readline ();
1301 #if defined (JOB_CONTROL)
1303 give_terminal_to (shell_pgrp, 0);
1304 #endif /* JOB_CONTROL */
1306 old_sigint = (SigHandler *)NULL;
1307 if (signal_is_ignored (SIGINT) == 0)
1309 old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
1310 interrupt_immediately++;
1312 terminate_immediately = 1;
1314 current_readline_line = readline (current_readline_prompt ?
1315 current_readline_prompt : "");
1317 terminate_immediately = 0;
1318 if (signal_is_ignored (SIGINT) == 0 && old_sigint)
1320 interrupt_immediately--;
1321 set_signal_handler (SIGINT, old_sigint);
1325 /* Reset the prompt to the decoded value of prompt_string_pointer. */
1326 reset_readline_prompt ();
1329 if (current_readline_line == 0)
1332 current_readline_line_index = 0;
1333 line_len = strlen (current_readline_line);
1335 current_readline_line = (char *)xrealloc (current_readline_line, 2 + line_len);
1336 current_readline_line[line_len++] = '\n';
1337 current_readline_line[line_len] = '\0';
1340 if (current_readline_line[current_readline_line_index] == 0)
1342 free (current_readline_line);
1343 current_readline_line = (char *)NULL;
1344 return (yy_readline_get ());
1348 c = current_readline_line[current_readline_line_index++];
1354 yy_readline_unget (c)
1357 if (current_readline_line_index && current_readline_line)
1358 current_readline_line[--current_readline_line_index] = c;
1363 with_input_from_stdin ()
1365 INPUT_STREAM location;
1367 if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
1369 location.string = current_readline_line;
1370 init_yy_io (yy_readline_get, yy_readline_unget,
1371 st_stdin, "readline stdin", location);
1375 #else /* !READLINE */
1378 with_input_from_stdin ()
1380 with_input_from_stream (stdin, "stdin");
1382 #endif /* !READLINE */
1384 /* **************************************************************** */
1386 /* Let input come from STRING. STRING is zero terminated. */
1388 /* **************************************************************** */
1393 register char *string;
1394 register unsigned char c;
1396 string = bash_input.location.string;
1398 /* If the string doesn't exist, or is empty, EOF found. */
1399 if (string && *string)
1402 bash_input.location.string = string;
1413 *(--bash_input.location.string) = c;
1418 with_input_from_string (string, name)
1422 INPUT_STREAM location;
1424 location.string = string;
1425 init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
1428 /* Count the number of characters we've consumed from bash_input.location.string
1429 and read into shell_input_line, but have not returned from shell_getc.
1430 That is the true input location. Rewind bash_input.location.string by
1431 that number of characters, so it points to the last character actually
1432 consumed by the parser. */
1434 rewind_input_string ()
1438 /* number of unconsumed characters in the input -- XXX need to take newlines
1439 into account, e.g., $(...\n) */
1440 xchars = shell_input_line_len - shell_input_line_index;
1441 if (bash_input.location.string[-1] == '\n')
1444 /* XXX - how to reflect bash_input.location.string back to string passed to
1445 parse_and_execute or xparse_dolparen? xparse_dolparen needs to know how
1446 far into the string we parsed. parse_and_execute knows where bash_input.
1447 location.string is, and how far from orig_string that is -- that's the
1448 number of characters the command consumed. */
1450 /* bash_input.location.string - xchars should be where we parsed to */
1451 /* need to do more validation on xchars value for sanity -- test cases. */
1452 bash_input.location.string -= xchars;
1455 /* **************************************************************** */
1457 /* Let input come from STREAM. */
1459 /* **************************************************************** */
1461 /* These two functions used to test the value of the HAVE_RESTARTABLE_SYSCALLS
1462 define, and just use getc/ungetc if it was defined, but since bash
1463 installs its signal handlers without the SA_RESTART flag, some signals
1464 (like SIGCHLD, SIGWINCH, etc.) received during a read(2) will not cause
1465 the read to be restarted. We need to restart it ourselves. */
1473 if (bash_input.location.file)
1477 interrupt_immediately++;
1478 terminate_immediately++;
1480 result = getc_with_restart (bash_input.location.file);
1483 interrupt_immediately--;
1484 terminate_immediately--;
1494 return (ungetc_with_restart (c, bash_input.location.file));
1498 with_input_from_stream (stream, name)
1502 INPUT_STREAM location;
1504 location.file = stream;
1505 init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
1508 typedef struct stream_saver {
1509 struct stream_saver *next;
1510 BASH_INPUT bash_input;
1512 #if defined (BUFFERED_INPUT)
1513 BUFFERED_STREAM *bstream;
1514 #endif /* BUFFERED_INPUT */
1517 /* The globally known line number. */
1518 int line_number = 0;
1520 #if defined (COND_COMMAND)
1521 static int cond_lineno;
1522 static int cond_token;
1525 STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
1528 push_stream (reset_lineno)
1531 STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
1533 xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
1535 #if defined (BUFFERED_INPUT)
1536 saver->bstream = (BUFFERED_STREAM *)NULL;
1537 /* If we have a buffered stream, clear out buffers[fd]. */
1538 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1539 saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
1540 (BUFFERED_STREAM *)NULL);
1541 #endif /* BUFFERED_INPUT */
1543 saver->line = line_number;
1544 bash_input.name = (char *)NULL;
1545 saver->next = stream_list;
1546 stream_list = saver;
1559 STREAM_SAVER *saver = stream_list;
1562 stream_list = stream_list->next;
1564 init_yy_io (saver->bash_input.getter,
1565 saver->bash_input.ungetter,
1566 saver->bash_input.type,
1567 saver->bash_input.name,
1568 saver->bash_input.location);
1570 #if defined (BUFFERED_INPUT)
1571 /* If we have a buffered stream, restore buffers[fd]. */
1572 /* If the input file descriptor was changed while this was on the
1573 save stack, update the buffered fd to the new file descriptor and
1574 re-establish the buffer <-> bash_input fd correspondence. */
1575 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1577 if (bash_input_fd_changed)
1579 bash_input_fd_changed = 0;
1580 if (default_buffered_input >= 0)
1582 bash_input.location.buffered_fd = default_buffered_input;
1583 saver->bstream->b_fd = default_buffered_input;
1584 SET_CLOSE_ON_EXEC (default_buffered_input);
1587 /* XXX could free buffered stream returned as result here. */
1588 set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
1590 #endif /* BUFFERED_INPUT */
1592 line_number = saver->line;
1594 FREE (saver->bash_input.name);
1599 /* Return 1 if a stream of type TYPE is saved on the stack. */
1601 stream_on_stack (type)
1602 enum stream_type type;
1604 register STREAM_SAVER *s;
1606 for (s = stream_list; s; s = s->next)
1607 if (s->bash_input.type == type)
1612 /* Save the current token state and return it in a malloced array. */
1618 ret = (int *)xmalloc (3 * sizeof (int));
1619 ret[0] = last_read_token;
1620 ret[1] = token_before_that;
1621 ret[2] = two_tokens_ago;
1626 restore_token_state (ts)
1631 last_read_token = ts[0];
1632 token_before_that = ts[1];
1633 two_tokens_ago = ts[2];
1637 * This is used to inhibit alias expansion and reserved word recognition
1638 * inside case statement pattern lists. A `case statement pattern list' is:
1640 * everything between the `in' in a `case word in' and the next ')'
1642 * everything between a `;;' and the next `)' or `esac'
1645 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1647 #define END_OF_ALIAS 0
1650 * Pseudo-global variables used in implementing token-wise alias expansion.
1654 * Pushing and popping strings. This works together with shell_getc to
1655 * implement alias expansion on a per-token basis.
1658 typedef struct string_saver {
1659 struct string_saver *next;
1660 int expand_alias; /* Value to set expand_alias to when string is popped. */
1663 alias_t *expander; /* alias that caused this line to be pushed. */
1665 int saved_line_size, saved_line_index, saved_line_terminator;
1668 STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
1671 * Push the current shell_input_line onto a stack of such lines and make S
1672 * the current input. Used when expanding aliases. EXPAND is used to set
1673 * the value of expand_next_token when the string is popped, so that the
1674 * word after the alias in the original line is handled correctly when the
1675 * alias expands to multiple words. TOKEN is the token that was expanded
1676 * into S; it is saved and used to prevent infinite recursive expansion.
1679 push_string (s, expand, ap)
1684 STRING_SAVER *temp = (STRING_SAVER *)xmalloc (sizeof (STRING_SAVER));
1686 temp->expand_alias = expand;
1687 temp->saved_line = shell_input_line;
1688 temp->saved_line_size = shell_input_line_size;
1689 temp->saved_line_index = shell_input_line_index;
1690 temp->saved_line_terminator = shell_input_line_terminator;
1692 temp->expander = ap;
1694 temp->next = pushed_string_list;
1695 pushed_string_list = temp;
1699 ap->flags |= AL_BEINGEXPANDED;
1702 shell_input_line = s;
1703 shell_input_line_size = strlen (s);
1704 shell_input_line_index = 0;
1705 shell_input_line_terminator = '\0';
1707 parser_state &= ~PST_ALEXPNEXT; /* XXX */
1710 set_line_mbstate ();
1714 * Make the top of the pushed_string stack be the current shell input.
1715 * Only called when there is something on the stack. Called from shell_getc
1716 * when it thinks it has consumed the string generated by an alias expansion
1717 * and needs to return to the original input line.
1724 FREE (shell_input_line);
1725 shell_input_line = pushed_string_list->saved_line;
1726 shell_input_line_index = pushed_string_list->saved_line_index;
1727 shell_input_line_size = pushed_string_list->saved_line_size;
1728 shell_input_line_terminator = pushed_string_list->saved_line_terminator;
1730 if (pushed_string_list->expand_alias)
1731 parser_state |= PST_ALEXPNEXT;
1733 parser_state &= ~PST_ALEXPNEXT;
1735 t = pushed_string_list;
1736 pushed_string_list = pushed_string_list->next;
1740 t->expander->flags &= ~AL_BEINGEXPANDED;
1745 set_line_mbstate ();
1751 register STRING_SAVER *t, *t1;
1753 for (t = pushed_string_list; t; )
1756 FREE (t->saved_line);
1759 t->expander->flags &= ~AL_BEINGEXPANDED;
1764 pushed_string_list = (STRING_SAVER *)NULL;
1767 #endif /* ALIAS || DPAREN_ARITHMETIC */
1770 free_pushed_string_input ()
1772 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1773 free_string_list ();
1777 /* Return a line of text, taken from wherever yylex () reads input.
1778 If there is no more input, then we return NULL. If REMOVE_QUOTED_NEWLINE
1779 is non-zero, we remove unquoted \<newline> pairs. This is used by
1780 read_secondary_line to read here documents. */
1782 read_a_line (remove_quoted_newline)
1783 int remove_quoted_newline;
1785 static char *line_buffer = (char *)NULL;
1786 static int buffer_size = 0;
1787 int indx = 0, c, peekc, pass_next;
1789 #if defined (READLINE)
1790 if (no_line_editing && SHOULD_PROMPT ())
1792 if (SHOULD_PROMPT ())
1799 /* Allow immediate exit if interrupted during input. */
1804 /* Ignore null bytes in input. */
1808 internal_warning ("read_a_line: ignored null byte in input");
1813 /* If there is no more input, then we return NULL. */
1816 if (interactive && bash_input.type == st_stream)
1819 return ((char *)NULL);
1823 /* `+2' in case the final character in the buffer is a newline. */
1824 RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
1826 /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
1827 here document with an unquoted delimiter. In this case,
1828 the line will be expanded as if it were in double quotes.
1829 We allow a backslash to escape the next character, but we
1830 need to treat the backslash specially only if a backslash
1831 quoting a backslash-newline pair appears in the line. */
1834 line_buffer[indx++] = c;
1837 else if (c == '\\' && remove_quoted_newline)
1843 continue; /* Make the unquoted \<newline> pair disappear. */
1849 line_buffer[indx++] = c; /* Preserve the backslash. */
1853 line_buffer[indx++] = c;
1857 line_buffer[indx] = '\0';
1858 return (line_buffer);
1863 /* Return a line as in read_a_line (), but insure that the prompt is
1864 the secondary prompt. This is used to read the lines of a here
1865 document. REMOVE_QUOTED_NEWLINE is non-zero if we should remove
1866 newlines quoted with backslashes while reading the line. It is
1867 non-zero unless the delimiter of the here document was quoted. */
1869 read_secondary_line (remove_quoted_newline)
1870 int remove_quoted_newline;
1875 prompt_string_pointer = &ps2_prompt;
1876 if (SHOULD_PROMPT())
1878 ret = read_a_line (remove_quoted_newline);
1879 #if defined (HISTORY)
1880 if (remember_on_history && (parser_state & PST_HEREDOC))
1882 /* To make adding the the here-document body right, we need to rely
1883 on history_delimiting_chars() returning \n for the first line of
1884 the here-document body and the null string for the second and
1885 subsequent lines, so we avoid double newlines.
1886 current_command_line_count == 2 for the first line of the body. */
1888 current_command_line_count++;
1889 maybe_add_history (ret);
1891 #endif /* HISTORY */
1895 /* **************************************************************** */
1899 /* **************************************************************** */
1901 /* Reserved words. These are only recognized as the first word of a
1903 STRING_INT_ALIST word_token_alist[] = {
1912 #if defined (SELECT_COMMAND)
1913 { "select", SELECT },
1920 { "function", FUNCTION },
1921 #if defined (COMMAND_TIMING)
1927 #if defined (COND_COMMAND)
1928 { "[[", COND_START },
1931 #if defined (COPROCESS_SUPPORT)
1932 { "coproc", COPROC },
1937 /* other tokens that can be returned by read_token() */
1938 STRING_INT_ALIST other_token_alist[] = {
1939 /* Multiple-character tokens with special values */
1943 { ">>", GREATER_GREATER },
1944 { "<<", LESS_LESS },
1946 { ">&", GREATER_AND },
1947 { ";;", SEMI_SEMI },
1949 { ";;&", SEMI_SEMI_AND },
1950 { "<<-", LESS_LESS_MINUS },
1951 { "<<<", LESS_LESS_LESS },
1952 { "&>", AND_GREATER },
1953 { "&>>", AND_GREATER_GREATER },
1954 { "<>", LESS_GREATER },
1955 { ">|", GREATER_BAR },
1957 { "EOF", yacc_EOF },
1958 /* Tokens whose value is the character itself */
1969 { "newline", '\n' },
1973 /* others not listed here:
1974 WORD look at yylval.word
1975 ASSIGNMENT_WORD look at yylval.word
1976 NUMBER look at yylval.number
1977 ARITH_CMD look at yylval.word_list
1978 ARITH_FOR_EXPRS look at yylval.word_list
1979 COND_CMD look at yylval.command
1982 /* These are used by read_token_word, but appear up here so that shell_getc
1983 can use them to decide when to add otherwise blank lines to the history. */
1985 /* The primary delimiter stack. */
1986 struct dstack dstack = { (char *)NULL, 0, 0 };
1988 /* A temporary delimiter stack to be used when decoding prompt strings.
1989 This is needed because command substitutions in prompt strings (e.g., PS2)
1990 can screw up the parser's quoting state. */
1991 static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
1993 /* Macro for accessing the top delimiter on the stack. Returns the
1994 delimiter or zero if none. */
1995 #define current_delimiter(ds) \
1996 (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
1998 #define push_delimiter(ds, character) \
2001 if (ds.delimiter_depth + 2 > ds.delimiter_space) \
2002 ds.delimiters = (char *)xrealloc \
2003 (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
2004 ds.delimiters[ds.delimiter_depth] = character; \
2005 ds.delimiter_depth++; \
2009 #define pop_delimiter(ds) ds.delimiter_depth--
2011 /* Return the next shell input character. This always reads characters
2012 from shell_input_line; when that line is exhausted, it is time to
2013 read the next line. This is called by read_token when the shell is
2014 processing normal command input. */
2016 /* This implements one-character lookahead/lookbehind across physical input
2017 lines, to avoid something being lost because it's pushed back with
2018 shell_ungetc when we're at the start of a line. */
2019 static int eol_ungetc_lookahead = 0;
2022 shell_getc (remove_quoted_newline)
2023 int remove_quoted_newline;
2031 if (sigwinch_received)
2033 sigwinch_received = 0;
2034 get_new_window_size (0, (int *)0, (int *)0);
2037 if (eol_ungetc_lookahead)
2039 c = eol_ungetc_lookahead;
2040 eol_ungetc_lookahead = 0;
2044 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2045 /* If shell_input_line[shell_input_line_index] == 0, but there is
2046 something on the pushed list of strings, then we don't want to go
2047 off and get another line. We let the code down below handle it. */
2049 if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
2050 (pushed_string_list == (STRING_SAVER *)NULL)))
2051 #else /* !ALIAS && !DPAREN_ARITHMETIC */
2052 if (!shell_input_line || !shell_input_line[shell_input_line_index])
2053 #endif /* !ALIAS && !DPAREN_ARITHMETIC */
2059 /* Allow immediate exit if interrupted during input. */
2063 shell_input_line_terminator = 0;
2065 /* If the shell is interatctive, but not currently printing a prompt
2066 (interactive_shell && interactive == 0), we don't want to print
2067 notifies or cleanup the jobs -- we want to defer it until we do
2068 print the next prompt. */
2069 if (interactive_shell == 0 || SHOULD_PROMPT())
2071 #if defined (JOB_CONTROL)
2072 /* This can cause a problem when reading a command as the result
2073 of a trap, when the trap is called from flush_child. This call
2074 had better not cause jobs to disappear from the job table in
2075 that case, or we will have big trouble. */
2076 notify_and_cleanup ();
2077 #else /* !JOB_CONTROL */
2078 cleanup_dead_jobs ();
2079 #endif /* !JOB_CONTROL */
2082 #if defined (READLINE)
2083 if (no_line_editing && SHOULD_PROMPT())
2085 if (SHOULD_PROMPT())
2089 if (bash_input.type == st_stream)
2096 /* Allow immediate exit if interrupted during input. */
2102 internal_warning ("shell_getc: ignored null byte in input");
2107 RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
2111 if (bash_input.type == st_stream)
2115 shell_input_line_terminator = EOF;
2117 shell_input_line[i] = '\0';
2121 shell_input_line[i++] = c;
2125 shell_input_line[--i] = '\0';
2126 current_command_line_count++;
2131 shell_input_line_index = 0;
2132 shell_input_line_len = i; /* == strlen (shell_input_line) */
2134 set_line_mbstate ();
2136 #if defined (HISTORY)
2137 if (remember_on_history && shell_input_line && shell_input_line[0])
2140 # if defined (BANG_HISTORY)
2143 /* If the current delimiter is a single quote, we should not be
2144 performing history expansion, even if we're on a different
2145 line from the original single quote. */
2146 old_hist = history_expansion_inhibited;
2147 if (current_delimiter (dstack) == '\'')
2148 history_expansion_inhibited = 1;
2150 expansions = pre_process_line (shell_input_line, 1, 1);
2151 # if defined (BANG_HISTORY)
2152 history_expansion_inhibited = old_hist;
2154 if (expansions != shell_input_line)
2156 free (shell_input_line);
2157 shell_input_line = expansions;
2158 shell_input_line_len = shell_input_line ?
2159 strlen (shell_input_line) : 0;
2160 if (!shell_input_line_len)
2161 current_command_line_count--;
2163 /* We have to force the xrealloc below because we don't know
2164 the true allocated size of shell_input_line anymore. */
2165 shell_input_line_size = shell_input_line_len;
2167 set_line_mbstate ();
2170 /* Try to do something intelligent with blank lines encountered while
2171 entering multi-line commands. XXX - this is grotesque */
2172 else if (remember_on_history && shell_input_line &&
2173 shell_input_line[0] == '\0' &&
2174 current_command_line_count > 1)
2176 if (current_delimiter (dstack))
2177 /* We know shell_input_line[0] == 0 and we're reading some sort of
2178 quoted string. This means we've got a line consisting of only
2179 a newline in a quoted string. We want to make sure this line
2180 gets added to the history. */
2181 maybe_add_history (shell_input_line);
2185 hdcs = history_delimiting_chars ();
2186 if (hdcs && hdcs[0] == ';')
2187 maybe_add_history (shell_input_line);
2191 #endif /* HISTORY */
2193 if (shell_input_line)
2195 /* Lines that signify the end of the shell's input should not be
2197 if (echo_input_at_read && (shell_input_line[0] ||
2198 shell_input_line_terminator != EOF))
2199 fprintf (stderr, "%s\n", shell_input_line);
2203 shell_input_line_size = 0;
2204 prompt_string_pointer = ¤t_prompt_string;
2205 if (SHOULD_PROMPT ())
2210 /* Add the newline to the end of this string, iff the string does
2211 not already end in an EOF character. */
2212 if (shell_input_line_terminator != EOF)
2214 if (shell_input_line_len + 3 > shell_input_line_size)
2215 shell_input_line = (char *)xrealloc (shell_input_line,
2216 1 + (shell_input_line_size += 2));
2218 shell_input_line[shell_input_line_len] = '\n';
2219 shell_input_line[shell_input_line_len + 1] = '\0';
2221 set_line_mbstate ();
2225 uc = shell_input_line[shell_input_line_index];
2228 shell_input_line_index++;
2230 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2231 /* If UC is NULL, we have reached the end of the current input string. If
2232 pushed_string_list is non-empty, it's time to pop to the previous string
2233 because we have fully consumed the result of the last alias expansion.
2234 Do it transparently; just return the next character of the string popped
2236 if (!uc && (pushed_string_list != (STRING_SAVER *)NULL))
2239 uc = shell_input_line[shell_input_line_index];
2241 shell_input_line_index++;
2243 #endif /* ALIAS || DPAREN_ARITHMETIC */
2245 if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
2247 if (SHOULD_PROMPT ())
2253 if (!uc && shell_input_line_terminator == EOF)
2254 return ((shell_input_line_index != 0) ? '\n' : EOF);
2259 /* Put C back into the input for the shell. This might need changes for
2260 HANDLE_MULTIBYTE around EOLs. Since we (currently) never push back a
2261 character different than we read, shell_input_line_property doesn't need
2262 to change when manipulating shell_input_line. The define for
2263 last_shell_getc_is_singlebyte should take care of it, though. */
2268 if (shell_input_line && shell_input_line_index)
2269 shell_input_line[--shell_input_line_index] = c;
2271 eol_ungetc_lookahead = c;
2274 #ifdef INCLUDE_UNUSED
2275 /* Back the input pointer up by one, effectively `ungetting' a character. */
2279 if (shell_input_line && shell_input_line_index)
2280 shell_input_line_index--;
2284 /* Discard input until CHARACTER is seen, then push that character back
2285 onto the input stream. */
2287 discard_until (character)
2292 while ((c = shell_getc (0)) != EOF && c != character)
2300 execute_variable_command (command, vname)
2301 char *command, *vname;
2304 sh_parser_state_t ps;
2306 save_parser_state (&ps);
2307 last_lastarg = get_string_value ("_");
2309 last_lastarg = savestring (last_lastarg);
2311 parse_and_execute (savestring (command), vname, SEVAL_NONINT|SEVAL_NOHIST);
2313 restore_parser_state (&ps);
2314 bind_variable ("_", last_lastarg, 0);
2315 FREE (last_lastarg);
2317 if (token_to_read == '\n') /* reset_parser was called */
2321 /* Place to remember the token. We try to keep the buffer
2322 at a reasonable size, but it can grow. */
2323 static char *token = (char *)NULL;
2325 /* Current size of the token buffer. */
2326 static int token_buffer_size;
2328 /* Command to read_token () explaining what we want it to do. */
2331 #define prompt_is_ps1 \
2332 (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
2334 /* Function for yyparse to call. yylex keeps track of
2335 the last two tokens read, and calls read_token. */
2339 if (interactive && (current_token == 0 || current_token == '\n'))
2341 /* Before we print a prompt, we might have to check mailboxes.
2342 We do this only if it is time to do so. Notice that only here
2343 is the mail alarm reset; nothing takes place in check_mail ()
2344 except the checking of mail. Please don't change this. */
2345 if (prompt_is_ps1 && time_to_check_mail ())
2348 reset_mail_timer ();
2351 /* Avoid printing a prompt if we're not going to read anything, e.g.
2352 after resetting the parser with read_token (RESET). */
2353 if (token_to_read == 0 && SHOULD_PROMPT ())
2357 two_tokens_ago = token_before_that;
2358 token_before_that = last_read_token;
2359 last_read_token = current_token;
2360 current_token = read_token (READ);
2362 if ((parser_state & PST_EOFTOKEN) && current_token == shell_eof_token)
2364 current_token = yacc_EOF;
2365 if (bash_input.type == st_string)
2366 rewind_input_string ();
2368 parser_state &= ~PST_EOFTOKEN;
2370 return (current_token);
2373 /* When non-zero, we have read the required tokens
2374 which allow ESAC to be the next one read. */
2375 static int esacs_needed_count;
2378 gather_here_documents ()
2383 while (need_here_doc)
2385 parser_state |= PST_HEREDOC;
2386 make_here_document (redir_stack[r++], line_number);
2387 parser_state &= ~PST_HEREDOC;
2392 /* When non-zero, an open-brace used to create a group is awaiting a close
2394 static int open_brace_count;
2396 #define command_token_position(token) \
2397 (((token) == ASSIGNMENT_WORD) || \
2398 ((token) != SEMI_SEMI && (token) != SEMI_AND && (token) != SEMI_SEMI_AND && reserved_word_acceptable(token)))
2400 #define assignment_acceptable(token) \
2401 (command_token_position(token) && ((parser_state & PST_CASEPAT) == 0))
2403 /* Check to see if TOKEN is a reserved word and return the token
2405 #define CHECK_FOR_RESERVED_WORD(tok) \
2407 if (!dollar_present && !quoted && \
2408 reserved_word_acceptable (last_read_token)) \
2411 for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
2412 if (STREQ (tok, word_token_alist[i].word)) \
2414 if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
2416 if (word_token_alist[i].token == TIME && time_command_acceptable () == 0) \
2418 if (word_token_alist[i].token == ESAC) \
2419 parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
2420 else if (word_token_alist[i].token == CASE) \
2421 parser_state |= PST_CASESTMT; \
2422 else if (word_token_alist[i].token == COND_END) \
2423 parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
2424 else if (word_token_alist[i].token == COND_START) \
2425 parser_state |= PST_CONDCMD; \
2426 else if (word_token_alist[i].token == '{') \
2427 open_brace_count++; \
2428 else if (word_token_alist[i].token == '}' && open_brace_count) \
2429 open_brace_count--; \
2430 return (word_token_alist[i].token); \
2437 /* OK, we have a token. Let's try to alias expand it, if (and only if)
2440 It is eligible for expansion if EXPAND_ALIASES is set, and
2441 the token is unquoted and the last token read was a command
2442 separator (or expand_next_token is set), and we are currently
2443 processing an alias (pushed_string_list is non-empty) and this
2444 token is not the same as the current or any previously
2447 Special cases that disqualify:
2448 In a pattern list in a case statement (parser_state & PST_CASEPAT). */
2458 r = xmalloc (l + 2);
2467 alias_expand_token (tokstr)
2473 if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
2474 (parser_state & PST_CASEPAT) == 0)
2476 ap = find_alias (tokstr);
2478 /* Currently expanding this token. */
2479 if (ap && (ap->flags & AL_BEINGEXPANDED))
2480 return (NO_EXPANSION);
2482 /* mk_alexpansion puts an extra space on the end of the alias expansion,
2483 so the lookahead by the parser works right. If this gets changed,
2484 make sure the code in shell_getc that deals with reaching the end of
2485 an expanded alias is changed with it. */
2486 expanded = ap ? mk_alexpansion (ap->value) : (char *)NULL;
2490 push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
2491 return (RE_READ_TOKEN);
2494 /* This is an eligible token that does not have an expansion. */
2495 return (NO_EXPANSION);
2497 return (NO_EXPANSION);
2502 time_command_acceptable ()
2504 #if defined (COMMAND_TIMING)
2505 switch (last_read_token)
2524 #endif /* COMMAND_TIMING */
2527 /* Handle special cases of token recognition:
2528 IN is recognized if the last token was WORD and the token
2529 before that was FOR or CASE or SELECT.
2531 DO is recognized if the last token was WORD and the token
2532 before that was FOR or SELECT.
2534 ESAC is recognized if the last token caused `esacs_needed_count'
2537 `{' is recognized if the last token as WORD and the token
2538 before that was FUNCTION, or if we just parsed an arithmetic
2541 `}' is recognized if there is an unclosed `{' present.
2543 `-p' is returned as TIMEOPT if the last read token was TIME.
2545 ']]' is returned as COND_END if the parser is currently parsing
2546 a conditional expression ((parser_state & PST_CONDEXPR) != 0)
2548 `time' is returned as TIME if and only if it is immediately
2549 preceded by one of `;', `\n', `||', `&&', or `&'.
2553 special_case_tokens (tokstr)
2556 if ((last_read_token == WORD) &&
2557 #if defined (SELECT_COMMAND)
2558 ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
2560 ((token_before_that == FOR) || (token_before_that == CASE)) &&
2562 (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
2564 if (token_before_that == CASE)
2566 parser_state |= PST_CASEPAT;
2567 esacs_needed_count++;
2572 if (last_read_token == WORD &&
2573 #if defined (SELECT_COMMAND)
2574 (token_before_that == FOR || token_before_that == SELECT) &&
2576 (token_before_that == FOR) &&
2578 (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
2581 /* Ditto for ESAC in the CASE case.
2582 Specifically, this handles "case word in esac", which is a legal
2583 construct, certainly because someone will pass an empty arg to the
2584 case construct, and we don't want it to barf. Of course, we should
2585 insist that the case construct has at least one pattern in it, but
2586 the designers disagree. */
2587 if (esacs_needed_count)
2589 esacs_needed_count--;
2590 if (STREQ (tokstr, "esac"))
2592 parser_state &= ~PST_CASEPAT;
2597 /* The start of a shell function definition. */
2598 if (parser_state & PST_ALLOWOPNBRC)
2600 parser_state &= ~PST_ALLOWOPNBRC;
2601 if (tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2604 function_bstart = line_number;
2605 return ('{'); /* } */
2609 /* We allow a `do' after a for ((...)) without an intervening
2611 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == 'd' && tokstr[1] == 'o' && !tokstr[2])
2613 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2616 return ('{'); /* } */
2619 if (open_brace_count && reserved_word_acceptable (last_read_token) && tokstr[0] == '}' && !tokstr[1])
2621 open_brace_count--; /* { */
2625 #if defined (COMMAND_TIMING)
2626 /* Handle -p after `time'. */
2627 if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == 'p' && !tokstr[2])
2632 #if defined (COMMAND_TIMING)
2633 if (STREQ (token, "time") && ((parser_state & PST_CASEPAT) == 0) && time_command_acceptable ())
2635 #endif /* COMMAND_TIMING */
2638 #if defined (COND_COMMAND) /* [[ */
2639 if ((parser_state & PST_CONDEXPR) && tokstr[0] == ']' && tokstr[1] == ']' && tokstr[2] == '\0')
2646 /* Called from shell.c when Control-C is typed at top level. Or
2647 by the error rule at top level. */
2651 dstack.delimiter_depth = 0; /* No delimiters found so far. */
2652 open_brace_count = 0;
2656 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2657 if (pushed_string_list)
2658 free_string_list ();
2659 #endif /* ALIAS || DPAREN_ARITHMETIC */
2661 if (shell_input_line)
2663 free (shell_input_line);
2664 shell_input_line = (char *)NULL;
2665 shell_input_line_size = shell_input_line_index = 0;
2668 FREE (word_desc_to_read);
2669 word_desc_to_read = (WORD_DESC *)NULL;
2671 last_read_token = '\n';
2672 token_to_read = '\n';
2675 /* Read the next token. Command can be READ (normal operation) or
2676 RESET (to normalize state). */
2678 read_token (command)
2681 int character; /* Current character. */
2682 int peek_char; /* Temporary look-ahead character. */
2683 int result; /* The thing to return. */
2685 if (command == RESET)
2693 result = token_to_read;
2694 if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
2696 yylval.word = word_desc_to_read;
2697 word_desc_to_read = (WORD_DESC *)NULL;
2703 #if defined (COND_COMMAND)
2704 if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
2706 cond_lineno = line_number;
2707 parser_state |= PST_CONDEXPR;
2708 yylval.command = parse_cond_command ();
2709 if (cond_token != COND_END)
2714 token_to_read = COND_END;
2715 parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
2721 /* This is a place to jump back to once we have successfully expanded a
2722 token with an alias and pushed the string with push_string () */
2726 /* Read a single word from input. Start by skipping blanks. */
2727 while ((character = shell_getc (1)) != EOF && shellblank (character))
2730 if (character == EOF)
2736 if MBTEST(character == '#' && (!interactive || interactive_comments))
2738 /* A comment. Discard until EOL or EOF, and then return a newline. */
2739 discard_until ('\n');
2741 character = '\n'; /* this will take the next if statement and return. */
2744 if (character == '\n')
2746 /* If we're about to return an unquoted newline, we can go and collect
2747 the text of any pending here document. */
2749 gather_here_documents ();
2752 parser_state &= ~PST_ALEXPNEXT;
2755 parser_state &= ~PST_ASSIGNOK;
2760 if (parser_state & PST_REGEXP)
2763 /* Shell meta-characters. */
2764 if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
2767 /* Turn off alias tokenization iff this character sequence would
2768 not leave us ready to read a command. */
2769 if (character == '<' || character == '>')
2770 parser_state &= ~PST_ALEXPNEXT;
2773 parser_state &= ~PST_ASSIGNOK;
2775 peek_char = shell_getc (1);
2776 if (character == peek_char)
2781 /* If '<' then we could be at "<<" or at "<<-". We have to
2782 look ahead one more character. */
2783 peek_char = shell_getc (1);
2784 if MBTEST(peek_char == '-')
2785 return (LESS_LESS_MINUS);
2786 else if MBTEST(peek_char == '<')
2787 return (LESS_LESS_LESS);
2790 shell_ungetc (peek_char);
2795 return (GREATER_GREATER);
2798 parser_state |= PST_CASEPAT;
2800 parser_state &= ~PST_ALEXPNEXT;
2803 peek_char = shell_getc (1);
2804 if MBTEST(peek_char == '&')
2805 return (SEMI_SEMI_AND);
2808 shell_ungetc (peek_char);
2818 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
2820 result = parse_dparen (character);
2828 else if MBTEST(character == '<' && peek_char == '&')
2830 else if MBTEST(character == '>' && peek_char == '&')
2831 return (GREATER_AND);
2832 else if MBTEST(character == '<' && peek_char == '>')
2833 return (LESS_GREATER);
2834 else if MBTEST(character == '>' && peek_char == '|')
2835 return (GREATER_BAR);
2836 else if MBTEST(character == '&' && peek_char == '>')
2838 peek_char = shell_getc (1);
2839 if MBTEST(peek_char == '>')
2840 return (AND_GREATER_GREATER);
2843 shell_ungetc (peek_char);
2844 return (AND_GREATER);
2847 else if MBTEST(character == '|' && peek_char == '&')
2849 else if MBTEST(character == ';' && peek_char == '&')
2851 parser_state |= PST_CASEPAT;
2853 parser_state &= ~PST_ALEXPNEXT;
2858 shell_ungetc (peek_char);
2860 /* If we look like we are reading the start of a function
2861 definition, then let the reader know about it so that
2862 we will do the right thing with `{'. */
2863 if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
2865 parser_state |= PST_ALLOWOPNBRC;
2867 parser_state &= ~PST_ALEXPNEXT;
2869 function_dstart = line_number;
2872 /* case pattern lists may be preceded by an optional left paren. If
2873 we're not trying to parse a case pattern list, the left paren
2874 indicates a subshell. */
2875 if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
2876 parser_state |= PST_SUBSHELL;
2878 else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
2879 parser_state &= ~PST_CASEPAT;
2881 else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
2882 parser_state &= ~PST_SUBSHELL;
2884 #if defined (PROCESS_SUBSTITUTION)
2885 /* Check for the constructs which introduce process substitution.
2886 Shells running in `posix mode' don't do process substitution. */
2887 if MBTEST(posixly_correct || ((character != '>' && character != '<') || peek_char != '(')) /*)*/
2888 #endif /* PROCESS_SUBSTITUTION */
2892 /* Hack <&- (close stdin) case. Also <&N- (dup and close). */
2893 if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
2897 /* Okay, if we got this far, we have to read a word. Read one,
2898 and then check it against the known ones. */
2899 result = read_token_word (character);
2901 if (result == RE_READ_TOKEN)
2908 * Match a $(...) or other grouping construct. This has to handle embedded
2909 * quoted strings ('', ``, "") and nested constructs. It also must handle
2910 * reprompting the user, if necessary, after reading a newline, and returning
2911 * correct error values if it reads EOF.
2913 #define P_FIRSTCLOSE 0x01
2914 #define P_ALLOWESC 0x02
2915 #define P_DQUOTE 0x04
2916 #define P_COMMAND 0x08 /* parsing a command, so look for comments */
2917 #define P_BACKQUOTE 0x10 /* parsing a backquoted command substitution */
2919 /* Lexical state while parsing a grouping construct or $(...). */
2920 #define LEX_WASDOL 0x001
2921 #define LEX_CKCOMMENT 0x002
2922 #define LEX_INCOMMENT 0x004
2923 #define LEX_PASSNEXT 0x008
2924 #define LEX_RESWDOK 0x010
2925 #define LEX_CKCASE 0x020
2926 #define LEX_INCASE 0x040
2927 #define LEX_INHEREDOC 0x080
2928 #define LEX_HEREDELIM 0x100 /* reading here-doc delimiter */
2929 #define LEX_STRIPDOC 0x200 /* <<- strip tabs from here doc delim */
2931 #define COMSUB_META(ch) ((ch) == ';' || (ch) == '&' || (ch) == '|')
2933 #define CHECK_NESTRET_ERROR() \
2935 if (nestret == &matched_pair_error) \
2938 return &matched_pair_error; \
2942 #define APPEND_NESTRET() \
2946 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64); \
2947 strcpy (ret + retind, nestret); \
2948 retind += nestlen; \
2952 static char matched_pair_error;
2955 parse_matched_pair (qc, open, close, lenp, flags)
2956 int qc; /* `"' if this construct is within double quotes */
2960 int count, ch, tflags;
2961 int nestlen, ttranslen, start_lineno;
2962 char *ret, *nestret, *ttrans;
2963 int retind, retsize, rflags;
2965 /* itrace("parse_matched_pair: open = %c close = %c flags = %d", open, close, flags); */
2969 if ((flags & P_COMMAND) && qc != '`' && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
2970 tflags |= LEX_CKCOMMENT;
2972 /* RFLAGS is the set of flags we want to pass to recursive calls. */
2973 rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
2975 ret = (char *)xmalloc (retsize = 64);
2978 start_lineno = line_number;
2981 ch = shell_getc (qc != '\'' && (tflags & LEX_PASSNEXT) == 0);
2986 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
2987 EOF_Reached = 1; /* XXX */
2988 return (&matched_pair_error);
2991 /* Possible reprompting. */
2992 if (ch == '\n' && SHOULD_PROMPT ())
2995 /* Don't bother counting parens or doing anything else if in a comment
2996 or part of a case statement */
2997 if (tflags & LEX_INCOMMENT)
2999 /* Add this character. */
3000 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3004 tflags &= ~LEX_INCOMMENT;
3009 /* Not exactly right yet, should handle shell metacharacters, too. If
3010 any changes are made to this test, make analogous changes to subst.c:
3011 extract_delimited_string(). */
3012 else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || shellblank (ret[retind - 1])))
3013 tflags |= LEX_INCOMMENT;
3015 if (tflags & LEX_PASSNEXT) /* last char was backslash */
3017 tflags &= ~LEX_PASSNEXT;
3018 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3021 retind--; /* swallow previously-added backslash */
3025 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3026 if MBTEST(ch == CTLESC || ch == CTLNUL)
3027 ret[retind++] = CTLESC;
3031 /* If we're reparsing the input (e.g., from parse_string_to_word_list),
3032 we've already prepended CTLESC to single-quoted results of $'...'.
3033 We may want to do this for other CTLESC-quoted characters in
3035 else if MBTEST((parser_state & PST_REPARSE) && open == '\'' && (ch == CTLESC || ch == CTLNUL))
3037 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3041 else if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3043 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3044 ret[retind++] = CTLESC;
3048 else if MBTEST(ch == close) /* ending delimiter */
3050 /* handle nested ${...} specially. */
3051 else if MBTEST(open != close && (tflags & LEX_WASDOL) && open == '{' && ch == open) /* } */
3053 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
3056 /* Add this character. */
3057 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3060 /* If we just read the ending character, don't bother continuing. */
3064 if (open == '\'') /* '' inside grouping construct */
3066 if MBTEST((flags & P_ALLOWESC) && ch == '\\')
3067 tflags |= LEX_PASSNEXT;
3071 if MBTEST(ch == '\\') /* backslashes */
3072 tflags |= LEX_PASSNEXT;
3075 /* The big hammer. Single quotes aren't special in double quotes. The
3076 problem is that Posix says the single quotes are semi-special:
3077 within a double-quoted ${...} construct "an even number of
3078 unescaped double-quotes or single-quotes, if any, shall occur." */
3079 if MBTEST(open == '{' && (flags & P_DQUOTE) && ch == '\'') /* } */
3083 /* Could also check open == '`' if we want to parse grouping constructs
3084 inside old-style command substitution. */
3085 if (open != close) /* a grouping construct */
3087 if MBTEST(shellquote (ch))
3089 /* '', ``, or "" inside $(...) or other grouping construct. */
3090 push_delimiter (dstack, ch);
3091 if MBTEST((tflags & LEX_WASDOL) && ch == '\'') /* $'...' inside group */
3092 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
3094 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
3095 pop_delimiter (dstack);
3096 CHECK_NESTRET_ERROR ();
3098 if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
3100 /* Translate $'...' here. */
3101 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
3104 if ((rflags & P_DQUOTE) == 0)
3106 nestret = sh_single_quote (ttrans);
3108 nestlen = strlen (nestret);
3113 nestlen = ttranslen;
3115 retind -= 2; /* back up before the $' */
3117 else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
3119 /* Locale expand $"..." here. */
3120 ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
3123 nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
3125 nestlen = ttranslen + 2;
3126 retind -= 2; /* back up before the $" */
3133 /* Parse an old-style command substitution within double quotes as a
3135 /* XXX - sh and ksh93 don't do this - XXX */
3136 else if MBTEST(open == '"' && ch == '`')
3138 nestret = parse_matched_pair (0, '`', '`', &nestlen, rflags);
3140 CHECK_NESTRET_ERROR ();
3145 else if MBTEST(open != '`' && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3146 /* check for $(), $[], or ${} inside quoted string. */
3148 if (open == ch) /* undo previous increment */
3150 if (ch == '(') /* ) */
3151 nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
3152 else if (ch == '{') /* } */
3153 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
3154 else if (ch == '[') /* ] */
3155 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
3157 CHECK_NESTRET_ERROR ();
3162 if MBTEST(ch == '$')
3163 tflags |= LEX_WASDOL;
3165 tflags &= ~LEX_WASDOL;
3174 /* Parse a $(...) command substitution. This is messier than I'd like, and
3175 reproduces a lot more of the token-reading code than I'd like. */
3177 parse_comsub (qc, open, close, lenp, flags)
3178 int qc; /* `"' if this construct is within double quotes */
3182 int count, ch, peekc, tflags, lex_rwlen, lex_firstind;
3183 int nestlen, ttranslen, start_lineno;
3184 char *ret, *nestret, *ttrans, *heredelim;
3185 int retind, retsize, rflags, hdlen;
3187 /*itrace("parse_comsub: qc = `%c' open = %c close = %c", qc, open, close);*/
3189 tflags = LEX_RESWDOK;
3191 if ((flags & P_COMMAND) && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
3192 tflags |= LEX_CKCASE;
3193 if ((tflags & LEX_CKCASE) && (interactive == 0 || interactive_comments))
3194 tflags |= LEX_CKCOMMENT;
3196 /* RFLAGS is the set of flags we want to pass to recursive calls. */
3197 rflags = (flags & P_DQUOTE);
3199 ret = (char *)xmalloc (retsize = 64);
3202 start_lineno = line_number;
3211 ch = shell_getc (qc != '\'' && (tflags & LEX_PASSNEXT) == 0);
3218 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
3219 EOF_Reached = 1; /* XXX */
3220 return (&matched_pair_error);
3223 /* If we hit the end of a line and are reading the contents of a here
3224 document, and it's not the same line that the document starts on,
3225 check for this line being the here doc delimiter. Otherwise, if
3226 we're in a here document, mark the next character as the beginning
3230 if ((tflags & LEX_HEREDELIM) && heredelim)
3232 tflags &= ~LEX_HEREDELIM;
3233 tflags |= LEX_INHEREDOC;
3234 lex_firstind = retind + 1;
3236 else if (tflags & LEX_INHEREDOC)
3239 tind = lex_firstind;
3240 while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
3242 if (STREQN (ret + tind, heredelim, hdlen))
3244 tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
3245 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
3249 lex_firstind = retind + 1;
3253 /* Possible reprompting. */
3254 if (ch == '\n' && SHOULD_PROMPT ())
3257 /* Don't bother counting parens or doing anything else if in a comment */
3258 if (tflags & (LEX_INCOMMENT|LEX_INHEREDOC))
3260 /* Add this character. */
3261 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3264 if ((tflags & LEX_INCOMMENT) && ch == '\n')
3265 tflags &= ~LEX_INCOMMENT;
3270 /* Skip whitespace */
3271 if MBTEST(shellblank (ch) && lex_rwlen == 0)
3273 /* Add this character. */
3274 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3279 /* Either we are looking for the start of the here-doc delimiter
3280 (lex_firstind == -1) or we are reading one (lex_firstind >= 0).
3281 If this character is a shell break character and we are reading
3282 the delimiter, save it and note that we are now reading a here
3283 document. If we've found the start of the delimiter, note it by
3284 setting lex_firstind. Backslashes can quote shell metacharacters
3285 in here-doc delimiters. */
3286 if (tflags & LEX_HEREDELIM)
3288 if (lex_firstind == -1 && shellbreak (ch) == 0)
3289 lex_firstind = retind;
3290 else if (lex_firstind >= 0 && (tflags & LEX_PASSNEXT) == 0 && shellbreak (ch))
3292 nestret = substring (ret, lex_firstind, retind);
3293 heredelim = string_quote_removal (nestret, 0);
3295 hdlen = STRLEN(heredelim);
3296 /*itrace("parse_comsub:%d: found here doc delimiter `%s' (%d)", line_number, heredelim, hdlen);*/
3299 tflags |= LEX_INHEREDOC;
3300 tflags &= ~LEX_HEREDELIM;
3301 lex_firstind = retind + 1;
3308 /* Meta-characters that can introduce a reserved word. Not perfect yet. */
3309 if MBTEST((tflags & LEX_RESWDOK) == 0 && (tflags & LEX_CKCASE) && (tflags & LEX_INCOMMENT) == 0 && shellmeta(ch))
3311 /* Add this character. */
3312 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3314 peekc = shell_getc (1);
3315 if (ch == peekc && (ch == '&' || ch == '|' || ch == ';')) /* two-character tokens */
3317 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3318 ret[retind++] = peekc;
3319 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch); */
3320 tflags |= LEX_RESWDOK;
3324 else if (ch == '\n' || COMSUB_META(ch))
3326 shell_ungetc (peekc);
3327 tflags |= LEX_RESWDOK;
3328 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
3336 /* `unget' the character we just added and fall through */
3338 shell_ungetc (peekc);
3342 /* If we can read a reserved word, try to read one. */
3343 if (tflags & LEX_RESWDOK)
3345 if MBTEST(islower (ch))
3347 /* Add this character. */
3348 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3353 else if MBTEST(lex_rwlen == 4 && shellbreak (ch))
3355 if (STREQN (ret + retind - 4, "case", 4))
3357 tflags |= LEX_INCASE;
3358 /*itrace("parse_comsub:%d: found `case', lex_incase -> 1", line_number);*/
3360 else if (STREQN (ret + retind - 4, "esac", 4))
3362 tflags &= ~LEX_INCASE;
3363 /*itrace("parse_comsub:%d: found `esac', lex_incase -> 0", line_number);*/
3365 tflags &= ~LEX_RESWDOK;
3367 else if (shellbreak (ch) == 0)
3369 tflags &= ~LEX_RESWDOK;
3370 /*itrace("parse_comsub:%d: found `%c', lex_reswordok -> 0", line_number, ch);*/
3374 if MBTEST((tflags & LEX_INCOMMENT) == 0 && (tflags & LEX_CKCASE) && ch == '<')
3376 /* Add this character. */
3377 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3379 peekc = shell_getc (1);
3384 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3385 ret[retind++] = peekc;
3386 peekc = shell_getc (1);
3391 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3392 ret[retind++] = peekc;
3393 tflags |= LEX_STRIPDOC;
3396 shell_ungetc (peekc);
3397 tflags |= LEX_HEREDELIM;
3402 ch = peekc; /* fall through and continue XXX - this skips comments if peekc == '#' */
3404 /* Not exactly right yet, should handle shell metacharacters, too. If
3405 any changes are made to this test, make analogous changes to subst.c:
3406 extract_delimited_string(). */
3407 else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || shellblank (ret[retind - 1])))
3408 tflags |= LEX_INCOMMENT;
3410 if (tflags & LEX_PASSNEXT) /* last char was backslash */
3412 tflags &= ~LEX_PASSNEXT;
3413 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3416 retind--; /* swallow previously-added backslash */
3420 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3421 if MBTEST(ch == CTLESC || ch == CTLNUL)
3422 ret[retind++] = CTLESC;
3426 else if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3428 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3429 ret[retind++] = CTLESC;
3434 else if MBTEST((tflags & LEX_INCASE) && ch == close && close == ')')
3435 tflags &= ~LEX_INCASE; /* XXX */
3437 else if MBTEST(ch == close && (tflags & LEX_INCASE) == 0) /* ending delimiter */
3440 /*itrace("parse_comsub:%d: found close: count = %d", line_number, count);*/
3442 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && (tflags & LEX_INCASE) == 0 && ch == open) /* nested begin */
3445 /* Add this character. */
3446 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3449 /* If we just read the ending character, don't bother continuing. */
3453 if MBTEST(ch == '\\') /* backslashes */
3454 tflags |= LEX_PASSNEXT;
3456 if MBTEST(shellquote (ch))
3458 /* '', ``, or "" inside $(...). */
3459 push_delimiter (dstack, ch);
3460 if MBTEST((tflags & LEX_WASDOL) && ch == '\'') /* $'...' inside group */
3461 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
3463 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
3464 pop_delimiter (dstack);
3465 CHECK_NESTRET_ERROR ();
3467 if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
3469 /* Translate $'...' here. */
3470 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
3473 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 MBTEST((tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3502 /* check for $(), $[], or ${} inside command substitution. */
3504 if ((tflags & LEX_INCASE) == 0 && open == ch) /* undo previous increment */
3506 if (ch == '(') /* ) */
3507 nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
3508 else if (ch == '{') /* } */
3509 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
3510 else if (ch == '[') /* ] */
3511 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
3513 CHECK_NESTRET_ERROR ();
3518 if MBTEST(ch == '$')
3519 tflags |= LEX_WASDOL;
3521 tflags &= ~LEX_WASDOL;
3528 /*itrace("parse_comsub:%d: returning `%s'", line_number, ret);*/
3532 /* XXX - this needs to handle functionality like subst.c:no_longjmp_on_fatal_error;
3533 maybe extract_command_subst should handle it. */
3535 xparse_dolparen (base, string, indp, flags)
3541 sh_parser_state_t ps;
3542 int orig_ind, nc, sflags;
3543 char *ret, *s, *ep, *ostring;
3549 sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE;
3550 if (flags & SX_NOLONGJMP)
3551 sflags |= SEVAL_NOLONGJMP;
3552 save_parser_state (&ps);
3555 parser_state |= PST_CMDSUBST|PST_EOFTOKEN; /* allow instant ')' */ /*(*/
3556 shell_eof_token = ')';
3557 parse_string (string, "command substitution", sflags, &ep);
3559 restore_parser_state (&ps);
3564 /* Need to find how many characters parse_and_execute consumed, update
3565 *indp, if flags != 0, copy the portion of the string parsed into RET
3566 and return it. If flags & 1 (EX_NOALLOC) we can return NULL. */
3573 itrace("xparse_dolparen:%d: ep[-1] != RPAREN (%d), ep = `%s'", line_number, ep[-1], ep);
3575 while (ep > ostring && ep[-1] == '\n') ep--;
3579 *indp = ep - base - 1;
3583 if (base[*indp] != ')')
3584 itrace("xparse_dolparen:%d: base[%d] != RPAREN (%d), base = `%s'", line_number, *indp, base[*indp], base);
3587 if (flags & SX_NOALLOC)
3588 return (char *)NULL;
3596 ret = substring (ostring, 0, nc - 1);
3601 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
3602 /* Parse a double-paren construct. It can be either an arithmetic
3603 command, an arithmetic `for' command, or a nested subshell. Returns
3604 the parsed token, -1 on error, or -2 if we didn't do anything and
3605 should just go on. */
3614 #if defined (ARITH_FOR_COMMAND)
3615 if (last_read_token == FOR)
3617 arith_for_lineno = line_number;
3618 cmdtyp = parse_arith_cmd (&wval, 0);
3621 wd = alloc_word_desc ();
3623 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
3624 return (ARITH_FOR_EXPRS);
3627 return -1; /* ERROR */
3631 #if defined (DPAREN_ARITHMETIC)
3632 if (reserved_word_acceptable (last_read_token))
3634 sline = line_number;
3636 cmdtyp = parse_arith_cmd (&wval, 0);
3637 if (cmdtyp == 1) /* arithmetic command */
3639 wd = alloc_word_desc ();
3641 wd->flags = W_QUOTED|W_NOSPLIT|W_NOGLOB|W_DQUOTE;
3642 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
3645 else if (cmdtyp == 0) /* nested subshell */
3647 push_string (wval, 0, (alias_t *)NULL);
3648 if ((parser_state & PST_CASEPAT) == 0)
3649 parser_state |= PST_SUBSHELL;
3657 return -2; /* XXX */
3660 /* We've seen a `(('. Look for the matching `))'. If we get it, return 1.
3661 If not, assume it's a nested subshell for backwards compatibility and
3662 return 0. In any case, put the characters we've consumed into a locally-
3663 allocated buffer and make *ep point to that buffer. Return -1 on an
3664 error, for example EOF. */
3666 parse_arith_cmd (ep, adddq)
3670 int exp_lineno, rval, c;
3671 char *ttok, *tokstr;
3674 exp_lineno = line_number;
3675 ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
3677 if (ttok == &matched_pair_error)
3679 /* Check that the next character is the closing right paren. If
3680 not, this is a syntax error. ( */
3685 tokstr = (char *)xmalloc (ttoklen + 4);
3687 /* if ADDDQ != 0 then (( ... )) -> "..." */
3688 if (rval == 1 && adddq) /* arith cmd, add double quotes */
3691 strncpy (tokstr + 1, ttok, ttoklen - 1);
3692 tokstr[ttoklen] = '"';
3693 tokstr[ttoklen+1] = '\0';
3695 else if (rval == 1) /* arith cmd, don't add double quotes */
3697 strncpy (tokstr, ttok, ttoklen - 1);
3698 tokstr[ttoklen-1] = '\0';
3700 else /* nested subshell */
3703 strncpy (tokstr + 1, ttok, ttoklen - 1);
3704 tokstr[ttoklen] = ')';
3705 tokstr[ttoklen+1] = c;
3706 tokstr[ttoklen+2] = '\0';
3713 #endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
3715 #if defined (COND_COMMAND)
3721 if (EOF_Reached && cond_token != COND_ERROR) /* [[ */
3722 parser_error (cond_lineno, _("unexpected EOF while looking for `]]'"));
3723 else if (cond_token != COND_ERROR)
3725 if (etext = error_token_from_token (cond_token))
3727 parser_error (cond_lineno, _("syntax error in conditional expression: unexpected token `%s'"), etext);
3731 parser_error (cond_lineno, _("syntax error in conditional expression"));
3738 return (cond_or ());
3747 if (cond_token == OR_OR)
3750 l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
3761 if (cond_token == AND_AND)
3764 l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
3770 cond_skip_newlines ()
3772 while ((cond_token = read_token (READ)) == '\n')
3774 if (SHOULD_PROMPT ())
3777 return (cond_token);
3780 #define COND_RETURN_ERROR() \
3781 do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
3787 COND_COM *term, *tleft, *tright;
3791 /* Read a token. It can be a left paren, a `!', a unary operator, or a
3792 word that should be the first argument of a binary operator. Start by
3793 skipping newlines, since this is a compound command. */
3794 tok = cond_skip_newlines ();
3795 lineno = line_number;
3796 if (tok == COND_END)
3798 COND_RETURN_ERROR ();
3800 else if (tok == '(')
3802 term = cond_expr ();
3803 if (cond_token != ')')
3806 dispose_cond_node (term); /* ( */
3807 if (etext = error_token_from_token (cond_token))
3809 parser_error (lineno, _("unexpected token `%s', expected `)'"), etext);
3813 parser_error (lineno, _("expected `)'"));
3814 COND_RETURN_ERROR ();
3816 term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
3817 (void)cond_skip_newlines ();
3819 else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
3822 dispose_word (yylval.word); /* not needed */
3823 term = cond_term ();
3825 term->flags |= CMD_INVERT_RETURN;
3827 else if (tok == WORD && yylval.word->word[0] == '-' && yylval.word->word[2] == 0 && test_unop (yylval.word->word))
3830 tok = read_token (READ);
3833 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3834 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
3839 if (etext = error_token_from_token (tok))
3841 parser_error (line_number, _("unexpected argument `%s' to conditional unary operator"), etext);
3845 parser_error (line_number, _("unexpected argument to conditional unary operator"));
3846 COND_RETURN_ERROR ();
3849 (void)cond_skip_newlines ();
3851 else if (tok == WORD) /* left argument to binary operator */
3854 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3857 tok = read_token (READ);
3858 if (tok == WORD && test_binop (yylval.word->word))
3860 #if defined (COND_REGEXP)
3861 else if (tok == WORD && STREQ (yylval.word->word, "=~"))
3864 parser_state |= PST_REGEXP;
3867 else if (tok == '<' || tok == '>')
3868 op = make_word_from_token (tok); /* ( */
3869 /* There should be a check before blindly accepting the `)' that we have
3870 seen the opening `('. */
3871 else if (tok == COND_END || tok == AND_AND || tok == OR_OR || tok == ')')
3873 /* Special case. [[ x ]] is equivalent to [[ -n x ]], just like
3874 the test command. Similarly for [[ x && expr ]] or
3875 [[ x || expr ]] or [[ (x) ]]. */
3876 op = make_word ("-n");
3877 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
3883 if (etext = error_token_from_token (tok))
3885 parser_error (line_number, _("unexpected token `%s', conditional binary operator expected"), etext);
3889 parser_error (line_number, _("conditional binary operator expected"));
3890 dispose_cond_node (tleft);
3891 COND_RETURN_ERROR ();
3895 tok = read_token (READ);
3896 parser_state &= ~PST_REGEXP;
3899 tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3900 term = make_cond_node (COND_BINARY, op, tleft, tright);
3904 if (etext = error_token_from_token (tok))
3906 parser_error (line_number, _("unexpected argument `%s' to conditional binary operator"), etext);
3910 parser_error (line_number, _("unexpected argument to conditional binary operator"));
3911 dispose_cond_node (tleft);
3913 COND_RETURN_ERROR ();
3916 (void)cond_skip_newlines ();
3921 parser_error (line_number, _("unexpected token `%c' in conditional command"), tok);
3922 else if (etext = error_token_from_token (tok))
3924 parser_error (line_number, _("unexpected token `%s' in conditional command"), etext);
3928 parser_error (line_number, _("unexpected token %d in conditional command"), tok);
3929 COND_RETURN_ERROR ();
3934 /* This is kind of bogus -- we slip a mini recursive-descent parser in
3935 here to handle the conditional statement syntax. */
3937 parse_cond_command ()
3941 cexp = cond_expr ();
3942 return (make_cond_command (cexp));
3946 #if defined (ARRAY_VARS)
3947 /* When this is called, it's guaranteed that we don't care about anything
3948 in t beyond i. We do save and restore the chars, though. */
3950 token_is_assignment (t, i)
3954 unsigned char c, c1;
3957 c = t[i]; c1 = t[i+1];
3958 t[i] = '='; t[i+1] = '\0';
3959 r = assignment (t, (parser_state & PST_COMPASSIGN) != 0);
3960 t[i] = c; t[i+1] = c1;
3964 /* XXX - possible changes here for `+=' */
3966 token_is_ident (t, i)
3975 r = legal_identifier (t);
3982 read_token_word (character)
3985 /* The value for YYLVAL when a WORD is read. */
3986 WORD_DESC *the_word;
3988 /* Index into the token that we are building. */
3991 /* ALL_DIGITS becomes zero when we see a non-digit. */
3992 int all_digit_token;
3994 /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
3997 /* COMPOUND_ASSIGNMENT becomes non-zero if we are parsing a compound
3999 int compound_assignment;
4001 /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
4004 /* Non-zero means to ignore the value of the next character, and just
4005 to add it no matter what. */
4006 int pass_next_character;
4008 /* The current delimiting character. */
4010 int result, peek_char;
4011 char *ttok, *ttrans;
4012 int ttoklen, ttranslen;
4015 if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
4016 token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
4019 all_digit_token = DIGIT (character);
4020 dollar_present = quoted = pass_next_character = compound_assignment = 0;
4024 if (character == EOF)
4027 if (pass_next_character)
4029 pass_next_character = 0;
4030 goto got_escaped_character;
4033 cd = current_delimiter (dstack);
4035 /* Handle backslashes. Quote lots of things when not inside of
4036 double-quotes, quote some things inside of double-quotes. */
4037 if MBTEST(character == '\\')
4039 peek_char = shell_getc (0);
4041 /* Backslash-newline is ignored in all cases except
4042 when quoted with single quotes. */
4043 if (peek_char == '\n')
4046 goto next_character;
4050 shell_ungetc (peek_char);
4052 /* If the next character is to be quoted, note it now. */
4053 if (cd == 0 || cd == '`' ||
4054 (cd == '"' && peek_char >= 0 && (sh_syntaxtab[peek_char] & CBSDQUOTE)))
4055 pass_next_character++;
4062 /* Parse a matched pair of quote characters. */
4063 if MBTEST(shellquote (character))
4065 push_delimiter (dstack, character);
4066 ttok = parse_matched_pair (character, character, character, &ttoklen, (character == '`') ? P_COMMAND : 0);
4067 pop_delimiter (dstack);
4068 if (ttok == &matched_pair_error)
4069 return -1; /* Bail immediately. */
4070 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4071 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4072 token[token_index++] = character;
4073 strcpy (token + token_index, ttok);
4074 token_index += ttoklen;
4075 all_digit_token = 0;
4077 dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
4079 goto next_character;
4083 /* When parsing a regexp as a single word inside a conditional command,
4084 we need to special-case characters special to both the shell and
4085 regular expressions. Right now, that is only '(' and '|'. */ /*)*/
4086 if MBTEST((parser_state & PST_REGEXP) && (character == '(' || character == '|')) /*)*/
4088 if (character == '|')
4091 push_delimiter (dstack, character);
4092 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4093 pop_delimiter (dstack);
4094 if (ttok == &matched_pair_error)
4095 return -1; /* Bail immediately. */
4096 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4097 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4098 token[token_index++] = character;
4099 strcpy (token + token_index, ttok);
4100 token_index += ttoklen;
4102 dollar_present = all_digit_token = 0;
4103 goto next_character;
4105 #endif /* COND_REGEXP */
4107 #ifdef EXTENDED_GLOB
4108 /* Parse a ksh-style extended pattern matching specification. */
4109 if MBTEST(extended_glob && PATTERN_CHAR (character))
4111 peek_char = shell_getc (1);
4112 if MBTEST(peek_char == '(') /* ) */
4114 push_delimiter (dstack, peek_char);
4115 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4116 pop_delimiter (dstack);
4117 if (ttok == &matched_pair_error)
4118 return -1; /* Bail immediately. */
4119 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4121 TOKEN_DEFAULT_GROW_SIZE);
4122 token[token_index++] = character;
4123 token[token_index++] = peek_char;
4124 strcpy (token + token_index, ttok);
4125 token_index += ttoklen;
4127 dollar_present = all_digit_token = 0;
4128 goto next_character;
4131 shell_ungetc (peek_char);
4133 #endif /* EXTENDED_GLOB */
4135 /* If the delimiter character is not single quote, parse some of
4136 the shell expansions that must be read as a single word. */
4137 if (shellexp (character))
4139 peek_char = shell_getc (1);
4140 /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
4141 if MBTEST(peek_char == '(' || \
4142 ((peek_char == '{' || peek_char == '[') && character == '$')) /* ) ] } */
4144 if (peek_char == '{') /* } */
4145 ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE);
4146 else if (peek_char == '(') /* ) */
4148 /* XXX - push and pop the `(' as a delimiter for use by
4149 the command-oriented-history code. This way newlines
4150 appearing in the $(...) string get added to the
4151 history literally rather than causing a possibly-
4152 incorrect `;' to be added. ) */
4153 push_delimiter (dstack, peek_char);
4154 ttok = parse_comsub (cd, '(', ')', &ttoklen, P_COMMAND);
4155 pop_delimiter (dstack);
4158 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
4159 if (ttok == &matched_pair_error)
4160 return -1; /* Bail immediately. */
4161 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4163 TOKEN_DEFAULT_GROW_SIZE);
4164 token[token_index++] = character;
4165 token[token_index++] = peek_char;
4166 strcpy (token + token_index, ttok);
4167 token_index += ttoklen;
4170 all_digit_token = 0;
4171 goto next_character;
4173 /* This handles $'...' and $"..." new-style quoted strings. */
4174 else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
4178 first_line = line_number;
4179 push_delimiter (dstack, peek_char);
4180 ttok = parse_matched_pair (peek_char, peek_char, peek_char,
4182 (peek_char == '\'') ? P_ALLOWESC : 0);
4183 pop_delimiter (dstack);
4184 if (ttok == &matched_pair_error)
4186 if (peek_char == '\'')
4188 ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
4191 /* Insert the single quotes and correctly quote any
4192 embedded single quotes (allowed because P_ALLOWESC was
4193 passed to parse_matched_pair). */
4194 ttok = sh_single_quote (ttrans);
4196 ttranslen = strlen (ttok);
4201 /* Try to locale-expand the converted string. */
4202 ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
4205 /* Add the double quotes back */
4206 ttok = sh_mkdoublequoted (ttrans, ttranslen, 0);
4212 RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 2,
4214 TOKEN_DEFAULT_GROW_SIZE);
4215 strcpy (token + token_index, ttrans);
4216 token_index += ttranslen;
4219 all_digit_token = 0;
4220 goto next_character;
4222 /* This could eventually be extended to recognize all of the
4223 shell's single-character parameter expansions, and set flags.*/
4224 else if MBTEST(character == '$' && peek_char == '$')
4226 ttok = (char *)xmalloc (3);
4227 ttok[0] = ttok[1] = '$';
4229 RESIZE_MALLOCED_BUFFER (token, token_index, 3,
4231 TOKEN_DEFAULT_GROW_SIZE);
4232 strcpy (token + token_index, ttok);
4235 all_digit_token = 0;
4237 goto next_character;
4240 shell_ungetc (peek_char);
4243 #if defined (ARRAY_VARS)
4244 /* Identify possible array subscript assignment; match [...]. If
4245 parser_state&PST_COMPASSIGN, we need to parse [sub]=words treating
4246 `sub' as if it were enclosed in double quotes. */
4247 else if MBTEST(character == '[' && /* ] */
4248 ((token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) ||
4249 (token_index == 0 && (parser_state&PST_COMPASSIGN))))
4251 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
4252 if (ttok == &matched_pair_error)
4253 return -1; /* Bail immediately. */
4254 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4256 TOKEN_DEFAULT_GROW_SIZE);
4257 token[token_index++] = character;
4258 strcpy (token + token_index, ttok);
4259 token_index += ttoklen;
4261 all_digit_token = 0;
4262 goto next_character;
4264 /* Identify possible compound array variable assignment. */
4265 else if MBTEST(character == '=' && token_index > 0 && (assignment_acceptable (last_read_token) || (parser_state & PST_ASSIGNOK)) && token_is_assignment (token, token_index))
4267 peek_char = shell_getc (1);
4268 if MBTEST(peek_char == '(') /* ) */
4270 ttok = parse_compound_assignment (&ttoklen);
4272 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
4274 TOKEN_DEFAULT_GROW_SIZE);
4276 token[token_index++] = '=';
4277 token[token_index++] = '(';
4280 strcpy (token + token_index, ttok);
4281 token_index += ttoklen;
4283 token[token_index++] = ')';
4285 all_digit_token = 0;
4286 compound_assignment = 1;
4288 goto next_character;
4290 goto got_token; /* ksh93 seems to do this */
4294 shell_ungetc (peek_char);
4298 /* When not parsing a multi-character word construct, shell meta-
4299 characters break words. */
4300 if MBTEST(shellbreak (character))
4302 shell_ungetc (character);
4308 if (character == CTLESC || character == CTLNUL)
4309 token[token_index++] = CTLESC;
4311 got_escaped_character:
4313 all_digit_token &= DIGIT (character);
4314 dollar_present |= character == '$';
4316 token[token_index++] = character;
4318 RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
4319 TOKEN_DEFAULT_GROW_SIZE);
4322 if (character == '\n' && SHOULD_PROMPT ())
4325 /* We want to remove quoted newlines (that is, a \<newline> pair)
4326 unless we are within single quotes or pass_next_character is
4327 set (the shell equivalent of literal-next). */
4328 cd = current_delimiter (dstack);
4329 character = shell_getc (cd != '\'' && pass_next_character == 0);
4330 } /* end for (;;) */
4334 token[token_index] = '\0';
4336 /* Check to see what thing we should return. If the last_read_token
4337 is a `<', or a `&', or the character which ended this token is
4338 a '>' or '<', then, and ONLY then, is this input token a NUMBER.
4339 Otherwise, it is just a word, and should be returned as such. */
4340 if MBTEST(all_digit_token && (character == '<' || character == '>' || \
4341 last_read_token == LESS_AND || \
4342 last_read_token == GREATER_AND))
4344 if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
4345 yylval.number = lvalue;
4351 /* Check for special case tokens. */
4352 result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
4357 /* Posix.2 does not allow reserved words to be aliased, so check for all
4358 of them, including special cases, before expanding the current token
4360 if MBTEST(posixly_correct)
4361 CHECK_FOR_RESERVED_WORD (token);
4363 /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
4364 inhibits alias expansion. */
4365 if (expand_aliases && quoted == 0)
4367 result = alias_expand_token (token);
4368 if (result == RE_READ_TOKEN)
4369 return (RE_READ_TOKEN);
4370 else if (result == NO_EXPANSION)
4371 parser_state &= ~PST_ALEXPNEXT;
4374 /* If not in Posix.2 mode, check for reserved words after alias
4376 if MBTEST(posixly_correct == 0)
4378 CHECK_FOR_RESERVED_WORD (token);
4380 the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
4381 the_word->word = (char *)xmalloc (1 + token_index);
4382 the_word->flags = 0;
4383 strcpy (the_word->word, token);
4385 the_word->flags |= W_HASDOLLAR;
4387 the_word->flags |= W_QUOTED; /*(*/
4388 if (compound_assignment && token[token_index-1] == ')')
4389 the_word->flags |= W_COMPASSIGN;
4390 /* A word is an assignment if it appears at the beginning of a
4391 simple command, or after another assignment word. This is
4392 context-dependent, so it cannot be handled in the grammar. */
4393 if (assignment (token, (parser_state & PST_COMPASSIGN) != 0))
4395 the_word->flags |= W_ASSIGNMENT;
4396 /* Don't perform word splitting on assignment statements. */
4397 if (assignment_acceptable (last_read_token) || (parser_state & PST_COMPASSIGN) != 0)
4398 the_word->flags |= W_NOSPLIT;
4401 if (command_token_position (last_read_token))
4404 b = builtin_address_internal (token, 0);
4405 if (b && (b->flags & ASSIGNMENT_BUILTIN))
4406 parser_state |= PST_ASSIGNOK;
4407 else if (STREQ (token, "eval") || STREQ (token, "let"))
4408 parser_state |= PST_ASSIGNOK;
4411 yylval.word = the_word;
4413 result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
4414 ? ASSIGNMENT_WORD : WORD;
4416 switch (last_read_token)
4419 parser_state |= PST_ALLOWOPNBRC;
4420 function_dstart = line_number;
4425 if (word_top < MAX_CASE_NEST)
4427 word_lineno[word_top] = line_number;
4434 /* Return 1 if TOKSYM is a token that after being read would allow
4435 a reserved word to be seen, else 0. */
4437 reserved_word_acceptable (toksym)
4472 #if defined (COPROCESS_SUPPORT)
4473 if (last_read_token == WORD && token_before_that == COPROC)
4480 /* Return the index of TOKEN in the alist of reserved words, or -1 if
4481 TOKEN is not a shell reserved word. */
4483 find_reserved_word (tokstr)
4487 for (i = 0; word_token_alist[i].word; i++)
4488 if (STREQ (tokstr, word_token_alist[i].word))
4494 #if defined (READLINE)
4495 /* Called after each time readline is called. This insures that whatever
4496 the new prompt string is gets propagated to readline's local prompt
4499 reset_readline_prompt ()
4503 if (prompt_string_pointer)
4505 temp_prompt = (*prompt_string_pointer)
4506 ? decode_prompt_string (*prompt_string_pointer)
4509 if (temp_prompt == 0)
4511 temp_prompt = (char *)xmalloc (1);
4512 temp_prompt[0] = '\0';
4515 FREE (current_readline_prompt);
4516 current_readline_prompt = temp_prompt;
4519 #endif /* READLINE */
4522 #if defined (HISTORY)
4523 /* A list of tokens which can be followed by newlines, but not by
4524 semi-colons. When concatenating multiple lines of history, the
4525 newline separator for such tokens is replaced with a space. */
4526 static const int no_semi_successors[] = {
4527 '\n', '{', '(', ')', ';', '&', '|',
4528 CASE, DO, ELSE, IF, SEMI_SEMI, SEMI_AND, SEMI_SEMI_AND, THEN, UNTIL,
4529 WHILE, AND_AND, OR_OR, IN,
4533 /* If we are not within a delimited expression, try to be smart
4534 about which separators can be semi-colons and which must be
4535 newlines. Returns the string that should be added into the
4538 history_delimiting_chars ()
4542 if (dstack.delimiter_depth != 0)
4545 /* We look for current_command_line_count == 2 because we are looking to
4546 add the first line of the body of the here document (the second line
4548 if (parser_state & PST_HEREDOC)
4549 return (current_command_line_count == 2 ? "\n" : "");
4551 /* First, handle some special cases. */
4553 /* If we just read `()', assume it's a function definition, and don't
4554 add a semicolon. If the token before the `)' was not `(', and we're
4555 not in the midst of parsing a case statement, assume it's a
4556 parenthesized command and add the semicolon. */
4558 if (token_before_that == ')')
4560 if (two_tokens_ago == '(') /*)*/ /* function def */
4562 /* This does not work for subshells inside case statement
4563 command lists. It's a suboptimal solution. */
4564 else if (parser_state & PST_CASESTMT) /* case statement pattern */
4567 return "; "; /* (...) subshell */
4569 else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
4570 return " "; /* function def using `function name' without `()' */
4572 else if (token_before_that == WORD && two_tokens_ago == FOR)
4574 /* Tricky. `for i\nin ...' should not have a semicolon, but
4575 `for i\ndo ...' should. We do what we can. */
4576 for (i = shell_input_line_index; whitespace (shell_input_line[i]); i++)
4578 if (shell_input_line[i] && shell_input_line[i] == 'i' && shell_input_line[i+1] == 'n')
4582 else if (two_tokens_ago == CASE && token_before_that == WORD && (parser_state & PST_CASESTMT))
4585 for (i = 0; no_semi_successors[i]; i++)
4587 if (token_before_that == no_semi_successors[i])
4593 #endif /* HISTORY */
4595 /* Issue a prompt, or prepare to issue a prompt when the next character
4602 if (interactive == 0 || expanding_alias()) /* XXX */
4605 ps1_prompt = get_string_value ("PS1");
4606 ps2_prompt = get_string_value ("PS2");
4608 if (!prompt_string_pointer)
4609 prompt_string_pointer = &ps1_prompt;
4611 temp_prompt = *prompt_string_pointer
4612 ? decode_prompt_string (*prompt_string_pointer)
4615 if (temp_prompt == 0)
4617 temp_prompt = (char *)xmalloc (1);
4618 temp_prompt[0] = '\0';
4621 current_prompt_string = *prompt_string_pointer;
4622 prompt_string_pointer = &ps2_prompt;
4624 #if defined (READLINE)
4625 if (!no_line_editing)
4627 FREE (current_readline_prompt);
4628 current_readline_prompt = temp_prompt;
4631 #endif /* READLINE */
4633 FREE (current_decoded_prompt);
4634 current_decoded_prompt = temp_prompt;
4639 get_current_prompt_level ()
4641 return ((current_prompt_string && current_prompt_string == ps2_prompt) ? 2 : 1);
4645 set_current_prompt_level (x)
4648 prompt_string_pointer = (x == 2) ? &ps2_prompt : &ps1_prompt;
4649 current_prompt_string = *prompt_string_pointer;
4655 fprintf (stderr, "%s", current_decoded_prompt);
4659 /* Return a string which will be printed as a prompt. The string
4660 may contain special characters which are decoded as follows:
4663 \d the date in Day Mon Date format
4664 \e escape (ascii 033)
4665 \h the hostname up to the first `.'
4667 \j the number of active jobs
4668 \l the basename of the shell's tty device name
4671 \s the name of the shell
4672 \t the time in 24-hour hh:mm:ss format
4673 \T the time in 12-hour hh:mm:ss format
4674 \@ the time in 12-hour hh:mm am/pm format
4675 \A the time in 24-hour hh:mm format
4676 \D{fmt} the result of passing FMT to strftime(3)
4678 \v the version of bash (e.g., 2.00)
4679 \V the release of bash, version + patchlevel (e.g., 2.00.0)
4680 \w the current working directory
4681 \W the last element of $PWD
4682 \! the history number of this command
4683 \# the command number of this command
4684 \$ a $ or a # if you are root
4685 \nnn character code nnn in octal
4687 \[ begin a sequence of non-printing chars
4688 \] end a sequence of non-printing chars
4690 #define PROMPT_GROWTH 48
4692 decode_prompt_string (string)
4697 struct dstack save_dstack;
4698 int last_exit_value;
4699 #if defined (PROMPT_STRING_DECODE)
4700 int result_size, result_index;
4702 char *temp, octal_string[4];
4708 result = (char *)xmalloc (result_size = PROMPT_GROWTH);
4709 result[result_index = 0] = 0;
4710 temp = (char *)NULL;
4712 while (c = *string++)
4714 if (posixly_correct && c == '!')
4718 temp = savestring ("!");
4723 #if !defined (HISTORY)
4724 temp = savestring ("1");
4726 temp = itos (history_number ());
4727 #endif /* HISTORY */
4728 string--; /* add_string increments string again. */
4746 strncpy (octal_string, string, 3);
4747 octal_string[3] = '\0';
4749 n = read_octal (octal_string);
4750 temp = (char *)xmalloc (3);
4752 if (n == CTLESC || n == CTLNUL)
4769 for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
4772 c = 0; /* tested at add_string: */
4780 /* Make the current time/date into a string. */
4781 (void) time (&the_time);
4782 tm = localtime (&the_time);
4785 n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
4787 n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
4789 n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
4791 n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
4793 n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
4798 timebuf[sizeof(timebuf) - 1] = '\0';
4800 temp = savestring (timebuf);
4803 case 'D': /* strftime format */
4804 if (string[1] != '{') /* } */
4807 (void) time (&the_time);
4808 tm = localtime (&the_time);
4809 string += 2; /* skip { */
4810 timefmt = xmalloc (strlen (string) + 3);
4811 for (t = timefmt; *string && *string != '}'; )
4814 c = *string; /* tested at add_string */
4815 if (timefmt[0] == '\0')
4818 timefmt[1] = 'X'; /* locale-specific current time */
4821 n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
4827 timebuf[sizeof(timebuf) - 1] = '\0';
4829 if (promptvars || posixly_correct)
4830 /* Make sure that expand_prompt_string is called with a
4831 second argument of Q_DOUBLE_QUOTES if we use this
4833 temp = sh_backslash_quote_for_double_quotes (timebuf);
4835 temp = savestring (timebuf);
4839 temp = (char *)xmalloc (3);
4840 temp[0] = no_line_editing ? '\n' : '\r';
4841 temp[1] = no_line_editing ? '\0' : '\n';
4846 temp = base_pathname (shell_name);
4847 temp = savestring (temp);
4852 temp = (char *)xmalloc (16);
4854 strcpy (temp, dist_version);
4856 sprintf (temp, "%s.%d", dist_version, patch_level);
4862 /* Use the value of PWD because it is much more efficient. */
4863 char t_string[PATH_MAX];
4866 temp = get_string_value ("PWD");
4870 if (getcwd (t_string, sizeof(t_string)) == 0)
4876 tlen = strlen (t_string);
4880 tlen = sizeof (t_string) - 1;
4881 strncpy (t_string, temp, tlen);
4883 t_string[tlen] = '\0';
4885 #define ROOT_PATH(x) ((x)[0] == '/' && (x)[1] == 0)
4886 #define DOUBLE_SLASH_ROOT(x) ((x)[0] == '/' && (x)[1] == '/' && (x)[2] == 0)
4887 /* Abbreviate \W as ~ if $PWD == $HOME */
4888 if (c == 'W' && (((t = get_string_value ("HOME")) == 0) || STREQ (t, t_string) == 0))
4890 if (ROOT_PATH (t_string) == 0 && DOUBLE_SLASH_ROOT (t_string) == 0)
4892 t = strrchr (t_string, '/');
4894 strcpy (t_string, t + 1);
4898 #undef DOUBLE_SLASH_ROOT
4900 /* polite_directory_format is guaranteed to return a string
4901 no longer than PATH_MAX - 1 characters. */
4902 strcpy (t_string, polite_directory_format (t_string));
4904 temp = trim_pathname (t_string, PATH_MAX - 1);
4905 /* If we're going to be expanding the prompt string later,
4906 quote the directory name. */
4907 if (promptvars || posixly_correct)
4908 /* Make sure that expand_prompt_string is called with a
4909 second argument of Q_DOUBLE_QUOTES if we use this
4911 temp = sh_backslash_quote_for_double_quotes (t_string);
4913 temp = savestring (t_string);
4919 if (current_user.user_name == 0)
4920 get_current_user_info ();
4921 temp = savestring (current_user.user_name);
4926 temp = savestring (current_host_name);
4927 if (c == 'h' && (t = (char *)strchr (temp, '.')))
4932 temp = itos (current_command_number);
4936 #if !defined (HISTORY)
4937 temp = savestring ("1");
4939 temp = itos (history_number ());
4940 #endif /* HISTORY */
4944 t = temp = (char *)xmalloc (3);
4945 if ((promptvars || posixly_correct) && (current_user.euid != 0))
4947 *t++ = current_user.euid == 0 ? '#' : '$';
4952 temp = itos (count_all_jobs ());
4956 #if defined (HAVE_TTYNAME)
4957 temp = (char *)ttyname (fileno (stdin));
4958 t = temp ? base_pathname (temp) : "tty";
4959 temp = savestring (t);
4961 temp = savestring ("tty");
4962 #endif /* !HAVE_TTYNAME */
4965 #if defined (READLINE)
4968 if (no_line_editing)
4973 temp = (char *)xmalloc (3);
4974 n = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
4976 if (n == CTLESC || n == CTLNUL)
4981 #endif /* READLINE */
4987 temp = (char *)xmalloc (2);
4994 else /* (c == '\\') */
5001 temp = (char *)xmalloc (3);
5010 sub_append_string (temp, result, &result_index, &result_size);
5011 temp = (char *)NULL; /* Freed in sub_append_string (). */
5012 result[result_index] = '\0';
5018 RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
5019 result[result_index++] = c;
5020 result[result_index] = '\0';
5023 #else /* !PROMPT_STRING_DECODE */
5024 result = savestring (string);
5025 #endif /* !PROMPT_STRING_DECODE */
5027 /* Save the delimiter stack and point `dstack' to temp space so any
5028 command substitutions in the prompt string won't result in screwing
5029 up the parser's quoting state. */
5030 save_dstack = dstack;
5031 dstack = temp_dstack;
5032 dstack.delimiter_depth = 0;
5034 /* Perform variable and parameter expansion and command substitution on
5035 the prompt string. */
5036 if (promptvars || posixly_correct)
5038 last_exit_value = last_command_exit_value;
5039 list = expand_prompt_string (result, Q_DOUBLE_QUOTES, 0);
5041 result = string_list (list);
5042 dispose_words (list);
5043 last_command_exit_value = last_exit_value;
5047 t = dequote_string (result);
5052 dstack = save_dstack;
5057 /************************************************
5061 ************************************************/
5063 /* Report a syntax error, and restart the parser. Call here for fatal
5069 report_syntax_error ((char *)NULL);
5075 error_token_from_token (tok)
5080 if (t = find_token_in_alist (tok, word_token_alist, 0))
5083 if (t = find_token_in_alist (tok, other_token_alist, 0))
5087 /* This stuff is dicy and needs closer inspection */
5088 switch (current_token)
5091 case ASSIGNMENT_WORD:
5093 t = savestring (yylval.word->word);
5096 t = itos (yylval.number);
5099 if (yylval.word_list)
5100 t = string_list (yylval.word_list);
5102 case ARITH_FOR_EXPRS:
5103 if (yylval.word_list)
5104 t = string_list_internal (yylval.word_list, " ; ");
5107 t = (char *)NULL; /* punt */
5115 error_token_from_text ()
5120 t = shell_input_line;
5121 i = shell_input_line_index;
5125 if (i && t[i] == '\0')
5128 while (i && (whitespace (t[i]) || t[i] == '\n'))
5134 while (i && (member (t[i], " \n\t;|&") == 0))
5137 while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
5140 /* Return our idea of the offending token. */
5141 if (token_end || (i == 0 && token_end == 0))
5144 msg = substring (t, i, token_end);
5145 else /* one-character token */
5147 msg = (char *)xmalloc (2);
5157 print_offending_line ()
5162 msg = savestring (shell_input_line);
5163 token_end = strlen (msg);
5164 while (token_end && msg[token_end - 1] == '\n')
5165 msg[--token_end] = '\0';
5167 parser_error (line_number, "`%s'", msg);
5171 /* Report a syntax error with line numbers, etc.
5172 Call here for recoverable errors. If you have a message to print,
5173 then place it in MESSAGE, otherwise pass NULL and this will figure
5174 out an appropriate message for you. */
5176 report_syntax_error (message)
5183 parser_error (line_number, "%s", message);
5184 if (interactive && EOF_Reached)
5186 last_command_exit_value = EX_USAGE;
5190 /* If the line of input we're reading is not null, try to find the
5191 objectionable token. First, try to figure out what token the
5192 parser's complaining about by looking at current_token. */
5193 if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
5195 parser_error (line_number, _("syntax error near unexpected token `%s'"), msg);
5198 if (interactive == 0)
5199 print_offending_line ();
5201 last_command_exit_value = EX_USAGE;
5205 /* If looking at the current token doesn't prove fruitful, try to find the
5206 offending token by analyzing the text of the input line near the current
5207 input line index and report what we find. */
5208 if (shell_input_line && *shell_input_line)
5210 msg = error_token_from_text ();
5213 parser_error (line_number, _("syntax error near `%s'"), msg);
5217 /* If not interactive, print the line containing the error. */
5218 if (interactive == 0)
5219 print_offending_line ();
5223 msg = EOF_Reached ? _("syntax error: unexpected end of file") : _("syntax error");
5224 parser_error (line_number, "%s", msg);
5225 /* When the shell is interactive, this file uses EOF_Reached
5226 only for error reporting. Other mechanisms are used to
5227 decide whether or not to exit. */
5228 if (interactive && EOF_Reached)
5232 last_command_exit_value = EX_USAGE;
5235 /* ??? Needed function. ??? We have to be able to discard the constructs
5236 created during parsing. In the case of error, we want to return
5237 allocated objects to the memory pool. In the case of no error, we want
5238 to throw away the information about where the allocated objects live.
5239 (dispose_command () will actually free the command.) */
5241 discard_parser_constructs (error_p)
5246 /************************************************
5250 ************************************************/
5252 /* Do that silly `type "bye" to exit' stuff. You know, "ignoreeof". */
5254 /* A flag denoting whether or not ignoreeof is set. */
5257 /* The number of times that we have encountered an EOF character without
5258 another character intervening. When this gets above the limit, the
5259 shell terminates. */
5260 int eof_encountered = 0;
5262 /* The limit for eof_encountered. */
5263 int eof_encountered_limit = 10;
5265 /* If we have EOF as the only input unit, this user wants to leave
5266 the shell. If the shell is not interactive, then just leave.
5267 Otherwise, if ignoreeof is set, and we haven't done this the
5268 required number of times in a row, print a message. */
5270 handle_eof_input_unit ()
5274 /* shell.c may use this to decide whether or not to write out the
5275 history, among other things. We use it only for error reporting
5280 /* If the user wants to "ignore" eof, then let her do so, kind of. */
5283 if (eof_encountered < eof_encountered_limit)
5285 fprintf (stderr, _("Use \"%s\" to leave the shell.\n"),
5286 login_shell ? "logout" : "exit");
5288 /* Reset the parsing state. */
5289 last_read_token = current_token = '\n';
5290 /* Reset the prompt string to be $PS1. */
5291 prompt_string_pointer = (char **)NULL;
5297 /* In this case EOF should exit the shell. Do it now. */
5299 exit_builtin ((WORD_LIST *)NULL);
5303 /* We don't write history files, etc., for non-interactive shells. */
5308 /************************************************
5310 * STRING PARSING FUNCTIONS *
5312 ************************************************/
5314 /* It's very important that these two functions treat the characters
5315 between ( and ) identically. */
5317 static WORD_LIST parse_string_error;
5319 /* Take a string and run it through the shell parser, returning the
5320 resultant word list. Used by compound array assignment. */
5322 parse_string_to_word_list (s, flags, whom)
5328 int tok, orig_current_token, orig_line_number, orig_input_terminator;
5329 int orig_line_count;
5330 int old_echo_input, old_expand_aliases;
5331 #if defined (HISTORY)
5332 int old_remember_on_history, old_history_expansion_inhibited;
5335 #if defined (HISTORY)
5336 old_remember_on_history = remember_on_history;
5337 # if defined (BANG_HISTORY)
5338 old_history_expansion_inhibited = history_expansion_inhibited;
5340 bash_history_disable ();
5343 orig_line_number = line_number;
5344 orig_line_count = current_command_line_count;
5345 orig_input_terminator = shell_input_line_terminator;
5346 old_echo_input = echo_input_at_read;
5347 old_expand_aliases = expand_aliases;
5350 last_read_token = WORD; /* WORD to allow reserved words here */
5351 current_command_line_count = 0;
5352 echo_input_at_read = expand_aliases = 0;
5354 with_input_from_string (s, whom);
5355 wl = (WORD_LIST *)NULL;
5358 parser_state |= PST_COMPASSIGN|PST_REPARSE;
5360 while ((tok = read_token (READ)) != yacc_EOF)
5362 if (tok == '\n' && *bash_input.location.string == '\0')
5364 if (tok == '\n') /* Allow newlines in compound assignments */
5366 if (tok != WORD && tok != ASSIGNMENT_WORD)
5368 line_number = orig_line_number + line_number - 1;
5369 orig_current_token = current_token;
5370 current_token = tok;
5371 yyerror (NULL); /* does the right thing */
5372 current_token = orig_current_token;
5375 wl = &parse_string_error;
5378 wl = make_word_list (yylval.word, wl);
5381 last_read_token = '\n';
5384 #if defined (HISTORY)
5385 remember_on_history = old_remember_on_history;
5386 # if defined (BANG_HISTORY)
5387 history_expansion_inhibited = old_history_expansion_inhibited;
5388 # endif /* BANG_HISTORY */
5389 #endif /* HISTORY */
5391 echo_input_at_read = old_echo_input;
5392 expand_aliases = old_expand_aliases;
5394 current_command_line_count = orig_line_count;
5395 shell_input_line_terminator = orig_input_terminator;
5398 parser_state &= ~(PST_COMPASSIGN|PST_REPARSE);
5400 if (wl == &parse_string_error)
5402 last_command_exit_value = EXECUTION_FAILURE;
5403 if (interactive_shell == 0 && posixly_correct)
5404 jump_to_top_level (FORCE_EOF);
5406 jump_to_top_level (DISCARD);
5409 return (REVERSE_LIST (wl, WORD_LIST *));
5413 parse_compound_assignment (retlenp)
5417 int tok, orig_line_number, orig_token_size, orig_last_token, assignok;
5418 char *saved_token, *ret;
5420 saved_token = token;
5421 orig_token_size = token_buffer_size;
5422 orig_line_number = line_number;
5423 orig_last_token = last_read_token;
5425 last_read_token = WORD; /* WORD to allow reserved words here */
5427 token = (char *)NULL;
5428 token_buffer_size = 0;
5430 assignok = parser_state&PST_ASSIGNOK; /* XXX */
5432 wl = (WORD_LIST *)NULL; /* ( */
5433 parser_state |= PST_COMPASSIGN;
5435 while ((tok = read_token (READ)) != ')')
5437 if (tok == '\n') /* Allow newlines in compound assignments */
5439 if (SHOULD_PROMPT ())
5443 if (tok != WORD && tok != ASSIGNMENT_WORD)
5445 current_token = tok; /* for error reporting */
5446 if (tok == yacc_EOF) /* ( */
5447 parser_error (orig_line_number, _("unexpected EOF while looking for matching `)'"));
5449 yyerror(NULL); /* does the right thing */
5452 wl = &parse_string_error;
5455 wl = make_word_list (yylval.word, wl);
5459 token = saved_token;
5460 token_buffer_size = orig_token_size;
5462 parser_state &= ~PST_COMPASSIGN;
5464 if (wl == &parse_string_error)
5466 last_command_exit_value = EXECUTION_FAILURE;
5467 last_read_token = '\n'; /* XXX */
5468 if (interactive_shell == 0 && posixly_correct)
5469 jump_to_top_level (FORCE_EOF);
5471 jump_to_top_level (DISCARD);
5474 last_read_token = orig_last_token; /* XXX - was WORD? */
5478 rl = REVERSE_LIST (wl, WORD_LIST *);
5479 ret = string_list (rl);
5486 *retlenp = (ret && *ret) ? strlen (ret) : 0;
5489 parser_state |= PST_ASSIGNOK;
5494 /************************************************
5496 * SAVING AND RESTORING PARTIAL PARSE STATE *
5498 ************************************************/
5501 save_parser_state (ps)
5502 sh_parser_state_t *ps;
5504 #if defined (ARRAY_VARS)
5509 ps = (sh_parser_state_t *)xmalloc (sizeof (sh_parser_state_t));
5511 return ((sh_parser_state_t *)NULL);
5513 ps->parser_state = parser_state;
5514 ps->token_state = save_token_state ();
5516 ps->input_line_terminator = shell_input_line_terminator;
5517 ps->eof_encountered = eof_encountered;
5519 ps->current_command_line_count = current_command_line_count;
5521 #if defined (HISTORY)
5522 ps->remember_on_history = remember_on_history;
5523 # if defined (BANG_HISTORY)
5524 ps->history_expansion_inhibited = history_expansion_inhibited;
5528 ps->last_command_exit_value = last_command_exit_value;
5529 #if defined (ARRAY_VARS)
5530 v = find_variable ("PIPESTATUS");
5531 if (v && array_p (v) && array_cell (v))
5532 ps->pipestatus = array_copy (array_cell (v));
5534 ps->pipestatus = (ARRAY *)NULL;
5537 ps->last_shell_builtin = last_shell_builtin;
5538 ps->this_shell_builtin = this_shell_builtin;
5540 ps->expand_aliases = expand_aliases;
5541 ps->echo_input_at_read = echo_input_at_read;
5547 restore_parser_state (ps)
5548 sh_parser_state_t *ps;
5550 #if defined (ARRAY_VARS)
5557 parser_state = ps->parser_state;
5558 if (ps->token_state)
5560 restore_token_state (ps->token_state);
5561 free (ps->token_state);
5564 shell_input_line_terminator = ps->input_line_terminator;
5565 eof_encountered = ps->eof_encountered;
5567 current_command_line_count = ps->current_command_line_count;
5569 #if defined (HISTORY)
5570 remember_on_history = ps->remember_on_history;
5571 # if defined (BANG_HISTORY)
5572 history_expansion_inhibited = ps->history_expansion_inhibited;
5576 last_command_exit_value = ps->last_command_exit_value;
5577 #if defined (ARRAY_VARS)
5578 v = find_variable ("PIPESTATUS");
5579 if (v && array_p (v) && array_cell (v))
5581 array_dispose (array_cell (v));
5582 var_setarray (v, ps->pipestatus);
5586 last_shell_builtin = ps->last_shell_builtin;
5587 this_shell_builtin = ps->this_shell_builtin;
5589 expand_aliases = ps->expand_aliases;
5590 echo_input_at_read = ps->echo_input_at_read;
5593 /************************************************
5595 * MULTIBYTE CHARACTER HANDLING *
5597 ************************************************/
5599 #if defined (HANDLE_MULTIBYTE)
5603 int i, previ, len, c;
5604 mbstate_t mbs, prevs;
5607 if (shell_input_line == NULL)
5609 len = strlen (shell_input_line); /* XXX - shell_input_line_len ? */
5610 FREE (shell_input_line_property);
5611 shell_input_line_property = (char *)xmalloc (len + 1);
5613 memset (&prevs, '\0', sizeof (mbstate_t));
5614 for (i = previ = 0; i < len; i++)
5618 c = shell_input_line[i];
5622 for (j = i; j < len; j++)
5623 shell_input_line_property[j] = 1;
5627 mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
5628 if (mbclen == 1 || mbclen == (size_t)-1)
5633 else if (mbclen == (size_t)-2)
5635 else if (mbclen > 1)
5643 /* XXX - what to do if mbrlen returns 0? (null wide character) */
5645 for (j = i; j < len; j++)
5646 shell_input_line_property[j] = 1;
5650 shell_input_line_property[i] = mbclen;
5653 #endif /* HANDLE_MULTIBYTE */