1 /* Yacc grammar for bash. */
3 /* Copyright (C) 1989-2005 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 it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License along
18 with Bash; see the file LICENSE. If not, write to the Free Software
19 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
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;
119 extern int posixly_correct;
120 extern int last_command_exit_value;
121 extern int interrupt_immediately;
122 extern char *shell_name, *current_host_name;
123 extern char *dist_version;
124 extern int patch_level;
125 extern int dump_translatable_strings, dump_po_strings;
126 extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
127 #if defined (BUFFERED_INPUT)
128 extern int bash_input_fd_changed;
132 /* **************************************************************** */
134 /* "Forward" declarations */
136 /* **************************************************************** */
139 static void debug_parser __P((int));
142 static int yy_getc __P((void));
143 static int yy_ungetc __P((int));
145 #if defined (READLINE)
146 static int yy_readline_get __P((void));
147 static int yy_readline_unget __P((int));
150 static int yy_string_get __P((void));
151 static int yy_string_unget __P((int));
152 static 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 #if defined (ARRAY_VARS)
175 static char *parse_compound_assignment __P((int *));
177 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
178 static int parse_dparen __P((int));
179 static int parse_arith_cmd __P((char **, int));
181 #if defined (COND_COMMAND)
182 static void cond_error __P((void));
183 static COND_COM *cond_expr __P((void));
184 static COND_COM *cond_or __P((void));
185 static COND_COM *cond_and __P((void));
186 static COND_COM *cond_term __P((void));
187 static int cond_skip_newlines __P((void));
188 static COMMAND *parse_cond_command __P((void));
190 #if defined (ARRAY_VARS)
191 static int token_is_assignment __P((char *, int));
192 static int token_is_ident __P((char *, int));
194 static int read_token_word __P((int));
195 static void discard_parser_constructs __P((int));
197 static char *error_token_from_token __P((int));
198 static char *error_token_from_text __P((void));
199 static void print_offending_line __P((void));
200 static void report_syntax_error __P((char *));
202 static void handle_eof_input_unit __P((void));
203 static void prompt_again __P((void));
205 static void reset_readline_prompt __P((void));
207 static void print_prompt __P((void));
209 #if defined (HISTORY)
210 char *history_delimiting_chars __P((void));
213 #if defined (HANDLE_MULTIBYTE)
214 static void set_line_mbstate __P((void));
215 static char *shell_input_line_property = NULL;
217 # define set_line_mbstate()
220 extern int yyerror __P((const char *));
226 /* Default prompt strings */
227 char *primary_prompt = PPROMPT;
228 char *secondary_prompt = SPROMPT;
230 /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
231 char *ps1_prompt, *ps2_prompt;
233 /* Handle on the current prompt string. Indirectly points through
234 ps1_ or ps2_prompt. */
235 char **prompt_string_pointer = (char **)NULL;
236 char *current_prompt_string;
238 /* Non-zero means we expand aliases in commands. */
239 int expand_aliases = 0;
241 /* If non-zero, the decoded prompt string undergoes parameter and
242 variable substitution, command substitution, arithmetic substitution,
243 string expansion, process substitution, and quote removal in
244 decode_prompt_string. */
247 /* If non-zero, $'...' and $"..." are expanded when they appear within
248 a ${...} expansion, even when the expansion appears within double
250 int extended_quote = 1;
252 /* The decoded prompt string. Used if READLINE is not defined or if
253 editing is turned off. Analogous to current_readline_prompt. */
254 static char *current_decoded_prompt;
256 /* The number of lines read from input while creating the current command. */
257 int current_command_line_count;
259 /* Variables to manage the task of reading here documents, because we need to
260 defer the reading until after a complete command has been collected. */
261 static REDIRECT *redir_stack[10];
264 /* Where shell input comes from. History expansion is performed on each
265 line when the shell is interactive. */
266 static char *shell_input_line = (char *)NULL;
267 static int shell_input_line_index;
268 static int shell_input_line_size; /* Amount allocated for shell_input_line. */
269 static int shell_input_line_len; /* strlen (shell_input_line) */
271 /* Either zero or EOF. */
272 static int shell_input_line_terminator;
274 /* The line number in a script on which a function definition starts. */
275 static int function_dstart;
277 /* The line number in a script on which a function body starts. */
278 static int function_bstart;
280 /* The line number in a script at which an arithmetic for command starts. */
281 static int arith_for_lineno;
283 /* The line number in a script where the word in a `case WORD', `select WORD'
284 or `for WORD' begins. This is a nested command maximum, since the array
285 index is decremented after a case, select, or for command is parsed. */
286 #define MAX_CASE_NEST 128
287 static int word_lineno[MAX_CASE_NEST];
288 static int word_top = -1;
290 /* If non-zero, it is the token that we want read_token to return
291 regardless of what text is (or isn't) present to be read. This
292 is reset by read_token. If token_to_read == WORD or
293 ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
294 static int token_to_read;
295 static WORD_DESC *word_desc_to_read;
297 static REDIRECTEE redir;
301 WORD_DESC *word; /* the word that we read. */
302 int number; /* the number that we read. */
303 WORD_LIST *word_list;
307 PATTERN_LIST *pattern;
310 /* Reserved words. Members of the first group are only recognized
311 in the case that they are preceded by a list_terminator. Members
312 of the second group are for [[...]] commands. Members of the
313 third group are recognized only under special circumstances. */
314 %token IF THEN ELSE ELIF FI CASE ESAC FOR SELECT WHILE UNTIL DO DONE FUNCTION
315 %token COND_START COND_END COND_ERROR
316 %token IN BANG TIME TIMEOPT
318 /* More general tokens. yylex () knows how to make these. */
319 %token <word> WORD ASSIGNMENT_WORD
320 %token <number> NUMBER
321 %token <word_list> ARITH_CMD ARITH_FOR_EXPRS
322 %token <command> COND_CMD
323 %token AND_AND OR_OR GREATER_GREATER LESS_LESS LESS_AND LESS_LESS_LESS
324 %token GREATER_AND SEMI_SEMI LESS_LESS_MINUS AND_GREATER LESS_GREATER
327 /* The types that the various syntactical units return. */
329 %type <command> inputunit command pipeline pipeline_command
330 %type <command> list list0 list1 compound_list simple_list simple_list1
331 %type <command> simple_command shell_command
332 %type <command> for_command select_command case_command group_command
333 %type <command> arith_command
334 %type <command> cond_command
335 %type <command> arith_for_command
336 %type <command> function_def function_body if_command elif_clause subshell
337 %type <redirect> redirection redirection_list
338 %type <element> simple_command_element
339 %type <word_list> word_list pattern
340 %type <pattern> pattern_list case_clause_sequence case_clause
341 %type <number> timespec
342 %type <number> list_terminator
346 %left '&' ';' '\n' yacc_EOF
351 inputunit: simple_list simple_list_terminator
353 /* Case of regular command. Discard the error
354 safety net,and return the command just parsed. */
357 /* discard_parser_constructs (0); */
362 /* Case of regular command, but not a very
363 interesting one. Return a NULL command. */
364 global_command = (COMMAND *)NULL;
369 /* Error during parsing. Return NULL command. */
370 global_command = (COMMAND *)NULL;
372 /* discard_parser_constructs (1); */
384 /* Case of EOF seen by itself. Do ignoreeof or
386 global_command = (COMMAND *)NULL;
387 handle_eof_input_unit ();
393 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
395 { $$ = make_word_list ($2, $1); }
398 redirection: '>' WORD
401 $$ = make_redirection (1, r_output_direction, redir);
406 $$ = make_redirection (0, r_input_direction, redir);
411 $$ = make_redirection ($1, r_output_direction, redir);
416 $$ = make_redirection ($1, r_input_direction, redir);
418 | GREATER_GREATER WORD
421 $$ = make_redirection (1, r_appending_to, redir);
423 | NUMBER GREATER_GREATER WORD
426 $$ = make_redirection ($1, r_appending_to, redir);
431 $$ = make_redirection (0, r_reading_until, redir);
432 redir_stack[need_here_doc++] = $$;
434 | NUMBER LESS_LESS WORD
437 $$ = make_redirection ($1, r_reading_until, redir);
438 redir_stack[need_here_doc++] = $$;
440 | LESS_LESS_LESS WORD
443 $$ = make_redirection (0, r_reading_string, redir);
445 | NUMBER LESS_LESS_LESS WORD
448 $$ = make_redirection ($1, r_reading_string, redir);
453 $$ = make_redirection (0, r_duplicating_input, redir);
455 | NUMBER LESS_AND NUMBER
458 $$ = make_redirection ($1, r_duplicating_input, redir);
463 $$ = make_redirection (1, r_duplicating_output, redir);
465 | NUMBER GREATER_AND NUMBER
468 $$ = make_redirection ($1, r_duplicating_output, redir);
473 $$ = make_redirection (0, r_duplicating_input_word, redir);
475 | NUMBER LESS_AND WORD
478 $$ = make_redirection ($1, r_duplicating_input_word, redir);
483 $$ = make_redirection (1, r_duplicating_output_word, redir);
485 | NUMBER GREATER_AND WORD
488 $$ = make_redirection ($1, r_duplicating_output_word, redir);
490 | LESS_LESS_MINUS WORD
493 $$ = make_redirection
494 (0, r_deblank_reading_until, redir);
495 redir_stack[need_here_doc++] = $$;
497 | NUMBER LESS_LESS_MINUS WORD
500 $$ = make_redirection
501 ($1, r_deblank_reading_until, redir);
502 redir_stack[need_here_doc++] = $$;
507 $$ = make_redirection (1, r_close_this, redir);
509 | NUMBER GREATER_AND '-'
512 $$ = make_redirection ($1, r_close_this, redir);
517 $$ = make_redirection (0, r_close_this, redir);
519 | NUMBER LESS_AND '-'
522 $$ = make_redirection ($1, r_close_this, redir);
527 $$ = make_redirection (1, r_err_and_out, redir);
529 | NUMBER LESS_GREATER WORD
532 $$ = make_redirection ($1, r_input_output, redir);
537 $$ = make_redirection (0, r_input_output, redir);
542 $$ = make_redirection (1, r_output_force, redir);
544 | NUMBER GREATER_BAR WORD
547 $$ = make_redirection ($1, r_output_force, redir);
551 simple_command_element: WORD
552 { $$.word = $1; $$.redirect = 0; }
554 { $$.word = $1; $$.redirect = 0; }
556 { $$.redirect = $1; $$.word = 0; }
559 redirection_list: redirection
563 | redirection_list redirection
565 register REDIRECT *t;
567 for (t = $1; t->next; t = t->next)
574 simple_command: simple_command_element
575 { $$ = make_simple_command ($1, (COMMAND *)NULL); }
576 | simple_command simple_command_element
577 { $$ = make_simple_command ($2, $1); }
580 command: simple_command
581 { $$ = clean_simple_command ($1); }
584 | shell_command redirection_list
591 register REDIRECT *t;
592 for (t = tc->redirects; t->next; t = t->next)
604 shell_command: for_command
608 | WHILE compound_list DO compound_list DONE
609 { $$ = make_while_command ($2, $4); }
610 | UNTIL compound_list DO compound_list DONE
611 { $$ = make_until_command ($2, $4); }
628 for_command: FOR WORD newline_list DO compound_list DONE
630 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
631 if (word_top > 0) word_top--;
633 | FOR WORD newline_list '{' compound_list '}'
635 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
636 if (word_top > 0) word_top--;
638 | FOR WORD ';' newline_list DO compound_list DONE
640 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
641 if (word_top > 0) word_top--;
643 | FOR WORD ';' newline_list '{' compound_list '}'
645 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
646 if (word_top > 0) word_top--;
648 | FOR WORD newline_list IN word_list list_terminator newline_list DO compound_list DONE
650 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
651 if (word_top > 0) word_top--;
653 | FOR WORD newline_list IN word_list list_terminator newline_list '{' compound_list '}'
655 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
656 if (word_top > 0) word_top--;
658 | FOR WORD newline_list IN list_terminator newline_list DO compound_list DONE
660 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
661 if (word_top > 0) word_top--;
663 | FOR WORD newline_list IN list_terminator newline_list '{' compound_list '}'
665 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
666 if (word_top > 0) word_top--;
670 arith_for_command: FOR ARITH_FOR_EXPRS list_terminator newline_list DO compound_list DONE
672 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
673 if (word_top > 0) word_top--;
675 | FOR ARITH_FOR_EXPRS list_terminator newline_list '{' compound_list '}'
677 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
678 if (word_top > 0) word_top--;
680 | FOR ARITH_FOR_EXPRS DO compound_list DONE
682 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
683 if (word_top > 0) word_top--;
685 | FOR ARITH_FOR_EXPRS '{' compound_list '}'
687 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
688 if (word_top > 0) word_top--;
692 select_command: SELECT WORD newline_list DO list DONE
694 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
695 if (word_top > 0) word_top--;
697 | SELECT WORD newline_list '{' list '}'
699 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
700 if (word_top > 0) word_top--;
702 | SELECT WORD ';' newline_list DO list DONE
704 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
705 if (word_top > 0) word_top--;
707 | SELECT WORD ';' newline_list '{' list '}'
709 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
710 if (word_top > 0) word_top--;
712 | SELECT WORD newline_list IN word_list list_terminator newline_list DO list DONE
714 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
715 if (word_top > 0) word_top--;
717 | SELECT WORD newline_list IN word_list list_terminator newline_list '{' list '}'
719 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
720 if (word_top > 0) word_top--;
724 case_command: CASE WORD newline_list IN newline_list ESAC
726 $$ = make_case_command ($2, (PATTERN_LIST *)NULL, word_lineno[word_top]);
727 if (word_top > 0) word_top--;
729 | CASE WORD newline_list IN case_clause_sequence newline_list ESAC
731 $$ = make_case_command ($2, $5, word_lineno[word_top]);
732 if (word_top > 0) word_top--;
734 | CASE WORD newline_list IN case_clause ESAC
736 $$ = make_case_command ($2, $5, word_lineno[word_top]);
737 if (word_top > 0) word_top--;
741 function_def: WORD '(' ')' newline_list function_body
742 { $$ = make_function_def ($1, $5, function_dstart, function_bstart); }
744 | FUNCTION WORD '(' ')' newline_list function_body
745 { $$ = make_function_def ($2, $6, function_dstart, function_bstart); }
747 | FUNCTION WORD newline_list function_body
748 { $$ = make_function_def ($2, $4, function_dstart, function_bstart); }
752 function_body: shell_command
754 | shell_command redirection_list
759 /* According to Posix.2 3.9.5, redirections
760 specified after the body of a function should
761 be attached to the function and performed when
762 the function is executed, not as part of the
763 function definition command. */
764 /* XXX - I don't think it matters, but we might
765 want to change this in the future to avoid
766 problems differentiating between a function
767 definition with a redirection and a function
768 definition containing a single command with a
769 redirection. The two are semantically equivalent,
770 though -- the only difference is in how the
771 command printing code displays the redirections. */
774 register REDIRECT *t;
775 for (t = tc->redirects; t->next; t = t->next)
785 subshell: '(' compound_list ')'
787 $$ = make_subshell_command ($2);
788 $$->flags |= CMD_WANT_SUBSHELL;
792 if_command: IF compound_list THEN compound_list FI
793 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
794 | IF compound_list THEN compound_list ELSE compound_list FI
795 { $$ = make_if_command ($2, $4, $6); }
796 | IF compound_list THEN compound_list elif_clause FI
797 { $$ = make_if_command ($2, $4, $5); }
801 group_command: '{' compound_list '}'
802 { $$ = make_group_command ($2); }
805 arith_command: ARITH_CMD
806 { $$ = make_arith_command ($1); }
809 cond_command: COND_START COND_CMD COND_END
813 elif_clause: ELIF compound_list THEN compound_list
814 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
815 | ELIF compound_list THEN compound_list ELSE compound_list
816 { $$ = make_if_command ($2, $4, $6); }
817 | ELIF compound_list THEN compound_list elif_clause
818 { $$ = make_if_command ($2, $4, $5); }
821 case_clause: pattern_list
822 | case_clause_sequence pattern_list
823 { $2->next = $1; $$ = $2; }
826 pattern_list: newline_list pattern ')' compound_list
827 { $$ = make_pattern_list ($2, $4); }
828 | newline_list pattern ')' newline_list
829 { $$ = make_pattern_list ($2, (COMMAND *)NULL); }
830 | newline_list '(' pattern ')' compound_list
831 { $$ = make_pattern_list ($3, $5); }
832 | newline_list '(' pattern ')' newline_list
833 { $$ = make_pattern_list ($3, (COMMAND *)NULL); }
836 case_clause_sequence: pattern_list SEMI_SEMI
837 | case_clause_sequence pattern_list SEMI_SEMI
838 { $2->next = $1; $$ = $2; }
842 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
844 { $$ = make_word_list ($3, $1); }
847 /* A list allows leading or trailing newlines and
848 newlines as operators (equivalent to semicolons).
849 It must end with a newline or semicolon.
850 Lists are used within commands such as if, for, while. */
852 list: newline_list list0
856 gather_here_documents ();
867 list0: list1 '\n' newline_list
868 | list1 '&' newline_list
870 if ($1->type == cm_connection)
871 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
873 $$ = command_connect ($1, (COMMAND *)NULL, '&');
875 | list1 ';' newline_list
879 list1: list1 AND_AND newline_list list1
880 { $$ = command_connect ($1, $4, AND_AND); }
881 | list1 OR_OR newline_list list1
882 { $$ = command_connect ($1, $4, OR_OR); }
883 | list1 '&' newline_list list1
885 if ($1->type == cm_connection)
886 $$ = connect_async_list ($1, $4, '&');
888 $$ = command_connect ($1, $4, '&');
890 | list1 ';' newline_list list1
891 { $$ = command_connect ($1, $4, ';'); }
892 | list1 '\n' newline_list list1
893 { $$ = command_connect ($1, $4, ';'); }
898 simple_list_terminator: '\n'
914 /* A simple_list is a list that contains no significant newlines
915 and no leading or trailing newlines. Newlines are allowed
916 only following operators, where they are not significant.
918 This is what an inputunit consists of. */
920 simple_list: simple_list1
924 gather_here_documents ();
928 if ($1->type == cm_connection)
929 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
931 $$ = command_connect ($1, (COMMAND *)NULL, '&');
933 gather_here_documents ();
939 gather_here_documents ();
943 simple_list1: simple_list1 AND_AND newline_list simple_list1
944 { $$ = command_connect ($1, $4, AND_AND); }
945 | simple_list1 OR_OR newline_list simple_list1
946 { $$ = command_connect ($1, $4, OR_OR); }
947 | simple_list1 '&' simple_list1
949 if ($1->type == cm_connection)
950 $$ = connect_async_list ($1, $3, '&');
952 $$ = command_connect ($1, $3, '&');
954 | simple_list1 ';' simple_list1
955 { $$ = command_connect ($1, $3, ';'); }
961 pipeline_command: pipeline
966 $2->flags |= CMD_INVERT_RETURN;
975 | timespec BANG pipeline
978 $3->flags |= $1|CMD_INVERT_RETURN;
981 | BANG timespec pipeline
984 $3->flags |= $2|CMD_INVERT_RETURN;
987 | timespec list_terminator
991 /* Boy, this is unclean. `time' by itself can
992 time a null command. We cheat and push a
993 newline back if the list_terminator was a newline
994 to avoid the double-newline problem (one to
995 terminate this, one to terminate the command) */
998 $$ = make_simple_command (x, (COMMAND *)NULL);
1000 /* XXX - let's cheat and push a newline back */
1002 token_to_read = '\n';
1008 pipeline '|' newline_list pipeline
1009 { $$ = command_connect ($1, $4, '|'); }
1015 { $$ = CMD_TIME_PIPELINE; }
1017 { $$ = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
1021 /* Possible states for the parser that require it to do special things. */
1022 #define PST_CASEPAT 0x0001 /* in a case pattern list */
1023 #define PST_ALEXPNEXT 0x0002 /* expand next word for aliases */
1024 #define PST_ALLOWOPNBRC 0x0004 /* allow open brace for function def */
1025 #define PST_NEEDCLOSBRC 0x0008 /* need close brace */
1026 #define PST_DBLPAREN 0x0010 /* double-paren parsing */
1027 #define PST_SUBSHELL 0x0020 /* ( ... ) subshell */
1028 #define PST_CMDSUBST 0x0040 /* $( ... ) command substitution */
1029 #define PST_CASESTMT 0x0080 /* parsing a case statement */
1030 #define PST_CONDCMD 0x0100 /* parsing a [[...]] command */
1031 #define PST_CONDEXPR 0x0200 /* parsing the guts of [[...]] */
1032 #define PST_ARITHFOR 0x0400 /* parsing an arithmetic for command */
1033 #define PST_ALEXPAND 0x0800 /* OK to expand aliases - unused */
1034 #define PST_CMDTOKEN 0x1000 /* command token OK - unused */
1035 #define PST_COMPASSIGN 0x2000 /* parsing x=(...) compound assignment */
1036 #define PST_ASSIGNOK 0x4000 /* assignment statement ok in this context */
1038 /* Initial size to allocate for tokens, and the
1039 amount to grow them by. */
1040 #define TOKEN_DEFAULT_INITIAL_SIZE 496
1041 #define TOKEN_DEFAULT_GROW_SIZE 512
1043 /* Should we call prompt_again? */
1044 #define SHOULD_PROMPT() \
1045 (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
1048 # define expanding_alias() (pushed_string_list && pushed_string_list->expander)
1050 # define expanding_alias() 0
1053 /* The token currently being read. */
1054 static int current_token;
1056 /* The last read token, or NULL. read_token () uses this for context
1058 static int last_read_token;
1060 /* The token read prior to last_read_token. */
1061 static int token_before_that;
1063 /* The token read prior to token_before_that. */
1064 static int two_tokens_ago;
1066 /* The current parser state. */
1067 static int parser_state;
1069 /* Global var is non-zero when end of file has been reached. */
1070 int EOF_Reached = 0;
1083 /* yy_getc () returns the next available character from input or EOF.
1084 yy_ungetc (c) makes `c' the next character to read.
1085 init_yy_io (get, unget, type, location) makes the function GET the
1086 installed function for getting the next character, makes UNGET the
1087 installed function for un-getting a character, sets the type of stream
1088 (either string or file) from TYPE, and makes LOCATION point to where
1089 the input is coming from. */
1091 /* Unconditionally returns end-of-file. */
1098 /* Variable containing the current get and unget functions.
1099 See ./input.h for a clearer description. */
1100 BASH_INPUT bash_input;
1102 /* Set all of the fields in BASH_INPUT to NULL. Free bash_input.name if it
1103 is non-null, avoiding a memory leak. */
1105 initialize_bash_input ()
1107 bash_input.type = st_none;
1108 FREE (bash_input.name);
1109 bash_input.name = (char *)NULL;
1110 bash_input.location.file = (FILE *)NULL;
1111 bash_input.location.string = (char *)NULL;
1112 bash_input.getter = (sh_cget_func_t *)NULL;
1113 bash_input.ungetter = (sh_cunget_func_t *)NULL;
1116 /* Set the contents of the current bash input stream from
1117 GET, UNGET, TYPE, NAME, and LOCATION. */
1119 init_yy_io (get, unget, type, name, location)
1120 sh_cget_func_t *get;
1121 sh_cunget_func_t *unget;
1122 enum stream_type type;
1124 INPUT_STREAM location;
1126 bash_input.type = type;
1127 FREE (bash_input.name);
1128 bash_input.name = name ? savestring (name) : (char *)NULL;
1132 memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
1134 bash_input.location = location;
1136 bash_input.getter = get;
1137 bash_input.ungetter = unget;
1143 return (bash_input.name ? bash_input.name : "stdin");
1146 /* Call this to get the next character of input. */
1150 return (*(bash_input.getter)) ();
1153 /* Call this to unget C. That is, to make C the next character
1159 return (*(bash_input.ungetter)) (c);
1162 #if defined (BUFFERED_INPUT)
1163 #ifdef INCLUDE_UNUSED
1165 input_file_descriptor ()
1167 switch (bash_input.type)
1170 return (fileno (bash_input.location.file));
1172 return (bash_input.location.buffered_fd);
1175 return (fileno (stdin));
1179 #endif /* BUFFERED_INPUT */
1181 /* **************************************************************** */
1183 /* Let input be read from readline (). */
1185 /* **************************************************************** */
1187 #if defined (READLINE)
1188 char *current_readline_prompt = (char *)NULL;
1189 char *current_readline_line = (char *)NULL;
1190 int current_readline_line_index = 0;
1195 SigHandler *old_sigint;
1199 if (!current_readline_line)
1201 if (!bash_readline_initialized)
1202 initialize_readline ();
1204 #if defined (JOB_CONTROL)
1206 give_terminal_to (shell_pgrp, 0);
1207 #endif /* JOB_CONTROL */
1209 old_sigint = (SigHandler *)NULL;
1210 if (signal_is_ignored (SIGINT) == 0)
1212 old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
1213 interrupt_immediately++;
1216 current_readline_line = readline (current_readline_prompt ?
1217 current_readline_prompt : "");
1219 if (signal_is_ignored (SIGINT) == 0 && old_sigint)
1221 interrupt_immediately--;
1222 set_signal_handler (SIGINT, old_sigint);
1226 /* Reset the prompt to the decoded value of prompt_string_pointer. */
1227 reset_readline_prompt ();
1230 if (current_readline_line == 0)
1233 current_readline_line_index = 0;
1234 line_len = strlen (current_readline_line);
1236 current_readline_line = (char *)xrealloc (current_readline_line, 2 + line_len);
1237 current_readline_line[line_len++] = '\n';
1238 current_readline_line[line_len] = '\0';
1241 if (current_readline_line[current_readline_line_index] == 0)
1243 free (current_readline_line);
1244 current_readline_line = (char *)NULL;
1245 return (yy_readline_get ());
1249 c = current_readline_line[current_readline_line_index++];
1255 yy_readline_unget (c)
1258 if (current_readline_line_index && current_readline_line)
1259 current_readline_line[--current_readline_line_index] = c;
1264 with_input_from_stdin ()
1266 INPUT_STREAM location;
1268 if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
1270 location.string = current_readline_line;
1271 init_yy_io (yy_readline_get, yy_readline_unget,
1272 st_stdin, "readline stdin", location);
1276 #else /* !READLINE */
1279 with_input_from_stdin ()
1281 with_input_from_stream (stdin, "stdin");
1283 #endif /* !READLINE */
1285 /* **************************************************************** */
1287 /* Let input come from STRING. STRING is zero terminated. */
1289 /* **************************************************************** */
1294 register char *string;
1295 register unsigned char c;
1297 string = bash_input.location.string;
1299 /* If the string doesn't exist, or is empty, EOF found. */
1300 if (string && *string)
1303 bash_input.location.string = string;
1314 *(--bash_input.location.string) = c;
1319 with_input_from_string (string, name)
1323 INPUT_STREAM location;
1325 location.string = string;
1326 init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
1329 /* **************************************************************** */
1331 /* Let input come from STREAM. */
1333 /* **************************************************************** */
1335 /* These two functions used to test the value of the HAVE_RESTARTABLE_SYSCALLS
1336 define, and just use getc/ungetc if it was defined, but since bash
1337 installs its signal handlers without the SA_RESTART flag, some signals
1338 (like SIGCHLD, SIGWINCH, etc.) received during a read(2) will not cause
1339 the read to be restarted. We need to restart it ourselves. */
1347 if (bash_input.location.file)
1350 interrupt_immediately++;
1351 result = getc_with_restart (bash_input.location.file);
1353 interrupt_immediately--;
1362 return (ungetc_with_restart (c, bash_input.location.file));
1366 with_input_from_stream (stream, name)
1370 INPUT_STREAM location;
1372 location.file = stream;
1373 init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
1376 typedef struct stream_saver {
1377 struct stream_saver *next;
1378 BASH_INPUT bash_input;
1380 #if defined (BUFFERED_INPUT)
1381 BUFFERED_STREAM *bstream;
1382 #endif /* BUFFERED_INPUT */
1385 /* The globally known line number. */
1386 int line_number = 0;
1388 #if defined (COND_COMMAND)
1389 static int cond_lineno;
1390 static int cond_token;
1393 STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
1396 push_stream (reset_lineno)
1399 STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
1401 xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
1403 #if defined (BUFFERED_INPUT)
1404 saver->bstream = (BUFFERED_STREAM *)NULL;
1405 /* If we have a buffered stream, clear out buffers[fd]. */
1406 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1407 saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
1408 (BUFFERED_STREAM *)NULL);
1409 #endif /* BUFFERED_INPUT */
1411 saver->line = line_number;
1412 bash_input.name = (char *)NULL;
1413 saver->next = stream_list;
1414 stream_list = saver;
1427 STREAM_SAVER *saver = stream_list;
1430 stream_list = stream_list->next;
1432 init_yy_io (saver->bash_input.getter,
1433 saver->bash_input.ungetter,
1434 saver->bash_input.type,
1435 saver->bash_input.name,
1436 saver->bash_input.location);
1438 #if defined (BUFFERED_INPUT)
1439 /* If we have a buffered stream, restore buffers[fd]. */
1440 /* If the input file descriptor was changed while this was on the
1441 save stack, update the buffered fd to the new file descriptor and
1442 re-establish the buffer <-> bash_input fd correspondence. */
1443 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1445 if (bash_input_fd_changed)
1447 bash_input_fd_changed = 0;
1448 if (default_buffered_input >= 0)
1450 bash_input.location.buffered_fd = default_buffered_input;
1451 saver->bstream->b_fd = default_buffered_input;
1452 SET_CLOSE_ON_EXEC (default_buffered_input);
1455 /* XXX could free buffered stream returned as result here. */
1456 set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
1458 #endif /* BUFFERED_INPUT */
1460 line_number = saver->line;
1462 FREE (saver->bash_input.name);
1467 /* Return 1 if a stream of type TYPE is saved on the stack. */
1469 stream_on_stack (type)
1470 enum stream_type type;
1472 register STREAM_SAVER *s;
1474 for (s = stream_list; s; s = s->next)
1475 if (s->bash_input.type == type)
1480 /* Save the current token state and return it in a malloced array. */
1486 ret = (int *)xmalloc (3 * sizeof (int));
1487 ret[0] = last_read_token;
1488 ret[1] = token_before_that;
1489 ret[2] = two_tokens_ago;
1494 restore_token_state (ts)
1499 last_read_token = ts[0];
1500 token_before_that = ts[1];
1501 two_tokens_ago = ts[2];
1505 * This is used to inhibit alias expansion and reserved word recognition
1506 * inside case statement pattern lists. A `case statement pattern list' is:
1508 * everything between the `in' in a `case word in' and the next ')'
1510 * everything between a `;;' and the next `)' or `esac'
1513 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1515 #define END_OF_ALIAS 0
1518 * Pseudo-global variables used in implementing token-wise alias expansion.
1522 * Pushing and popping strings. This works together with shell_getc to
1523 * implement alias expansion on a per-token basis.
1526 typedef struct string_saver {
1527 struct string_saver *next;
1528 int expand_alias; /* Value to set expand_alias to when string is popped. */
1531 alias_t *expander; /* alias that caused this line to be pushed. */
1533 int saved_line_size, saved_line_index, saved_line_terminator;
1536 STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
1539 * Push the current shell_input_line onto a stack of such lines and make S
1540 * the current input. Used when expanding aliases. EXPAND is used to set
1541 * the value of expand_next_token when the string is popped, so that the
1542 * word after the alias in the original line is handled correctly when the
1543 * alias expands to multiple words. TOKEN is the token that was expanded
1544 * into S; it is saved and used to prevent infinite recursive expansion.
1547 push_string (s, expand, ap)
1552 STRING_SAVER *temp = (STRING_SAVER *)xmalloc (sizeof (STRING_SAVER));
1554 temp->expand_alias = expand;
1555 temp->saved_line = shell_input_line;
1556 temp->saved_line_size = shell_input_line_size;
1557 temp->saved_line_index = shell_input_line_index;
1558 temp->saved_line_terminator = shell_input_line_terminator;
1560 temp->expander = ap;
1562 temp->next = pushed_string_list;
1563 pushed_string_list = temp;
1567 ap->flags |= AL_BEINGEXPANDED;
1570 shell_input_line = s;
1571 shell_input_line_size = strlen (s);
1572 shell_input_line_index = 0;
1573 shell_input_line_terminator = '\0';
1575 parser_state &= ~PST_ALEXPNEXT; /* XXX */
1578 set_line_mbstate ();
1582 * Make the top of the pushed_string stack be the current shell input.
1583 * Only called when there is something on the stack. Called from shell_getc
1584 * when it thinks it has consumed the string generated by an alias expansion
1585 * and needs to return to the original input line.
1592 FREE (shell_input_line);
1593 shell_input_line = pushed_string_list->saved_line;
1594 shell_input_line_index = pushed_string_list->saved_line_index;
1595 shell_input_line_size = pushed_string_list->saved_line_size;
1596 shell_input_line_terminator = pushed_string_list->saved_line_terminator;
1598 if (pushed_string_list->expand_alias)
1599 parser_state |= PST_ALEXPNEXT;
1601 parser_state &= ~PST_ALEXPNEXT;
1603 t = pushed_string_list;
1604 pushed_string_list = pushed_string_list->next;
1608 t->expander->flags &= ~AL_BEINGEXPANDED;
1613 set_line_mbstate ();
1619 register STRING_SAVER *t, *t1;
1621 for (t = pushed_string_list; t; )
1624 FREE (t->saved_line);
1627 t->expander->flags &= ~AL_BEINGEXPANDED;
1632 pushed_string_list = (STRING_SAVER *)NULL;
1635 #endif /* ALIAS || DPAREN_ARITHMETIC */
1638 free_pushed_string_input ()
1640 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1641 free_string_list ();
1645 /* Return a line of text, taken from wherever yylex () reads input.
1646 If there is no more input, then we return NULL. If REMOVE_QUOTED_NEWLINE
1647 is non-zero, we remove unquoted \<newline> pairs. This is used by
1648 read_secondary_line to read here documents. */
1650 read_a_line (remove_quoted_newline)
1651 int remove_quoted_newline;
1653 static char *line_buffer = (char *)NULL;
1654 static int buffer_size = 0;
1655 int indx = 0, c, peekc, pass_next;
1657 #if defined (READLINE)
1658 if (no_line_editing && SHOULD_PROMPT ())
1660 if (SHOULD_PROMPT ())
1667 /* Allow immediate exit if interrupted during input. */
1672 /* Ignore null bytes in input. */
1676 internal_warning ("read_a_line: ignored null byte in input");
1681 /* If there is no more input, then we return NULL. */
1684 if (interactive && bash_input.type == st_stream)
1687 return ((char *)NULL);
1691 /* `+2' in case the final character in the buffer is a newline. */
1692 RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
1694 /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
1695 here document with an unquoted delimiter. In this case,
1696 the line will be expanded as if it were in double quotes.
1697 We allow a backslash to escape the next character, but we
1698 need to treat the backslash specially only if a backslash
1699 quoting a backslash-newline pair appears in the line. */
1702 line_buffer[indx++] = c;
1705 else if (c == '\\' && remove_quoted_newline)
1711 continue; /* Make the unquoted \<newline> pair disappear. */
1717 line_buffer[indx++] = c; /* Preserve the backslash. */
1721 line_buffer[indx++] = c;
1725 line_buffer[indx] = '\0';
1726 return (line_buffer);
1731 /* Return a line as in read_a_line (), but insure that the prompt is
1732 the secondary prompt. This is used to read the lines of a here
1733 document. REMOVE_QUOTED_NEWLINE is non-zero if we should remove
1734 newlines quoted with backslashes while reading the line. It is
1735 non-zero unless the delimiter of the here document was quoted. */
1737 read_secondary_line (remove_quoted_newline)
1738 int remove_quoted_newline;
1740 prompt_string_pointer = &ps2_prompt;
1741 if (SHOULD_PROMPT())
1743 return (read_a_line (remove_quoted_newline));
1746 /* **************************************************************** */
1750 /* **************************************************************** */
1752 /* Reserved words. These are only recognized as the first word of a
1754 STRING_INT_ALIST word_token_alist[] = {
1763 #if defined (SELECT_COMMAND)
1764 { "select", SELECT },
1771 { "function", FUNCTION },
1772 #if defined (COMMAND_TIMING)
1778 #if defined (COND_COMMAND)
1779 { "[[", COND_START },
1785 /* other tokens that can be returned by read_token() */
1786 STRING_INT_ALIST other_token_alist[] = {
1787 /* Multiple-character tokens with special values */
1791 { ">>", GREATER_GREATER },
1792 { "<<", LESS_LESS },
1794 { ">&", GREATER_AND },
1795 { ";;", SEMI_SEMI },
1796 { "<<-", LESS_LESS_MINUS },
1797 { "<<<", LESS_LESS_LESS },
1798 { "&>", AND_GREATER },
1799 { "<>", LESS_GREATER },
1800 { ">|", GREATER_BAR },
1801 { "EOF", yacc_EOF },
1802 /* Tokens whose value is the character itself */
1813 { "newline", '\n' },
1817 /* others not listed here:
1818 WORD look at yylval.word
1819 ASSIGNMENT_WORD look at yylval.word
1820 NUMBER look at yylval.number
1821 ARITH_CMD look at yylval.word_list
1822 ARITH_FOR_EXPRS look at yylval.word_list
1823 COND_CMD look at yylval.command
1826 /* These are used by read_token_word, but appear up here so that shell_getc
1827 can use them to decide when to add otherwise blank lines to the history. */
1829 /* The primary delimiter stack. */
1830 struct dstack dstack = { (char *)NULL, 0, 0 };
1832 /* A temporary delimiter stack to be used when decoding prompt strings.
1833 This is needed because command substitutions in prompt strings (e.g., PS2)
1834 can screw up the parser's quoting state. */
1835 static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
1837 /* Macro for accessing the top delimiter on the stack. Returns the
1838 delimiter or zero if none. */
1839 #define current_delimiter(ds) \
1840 (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
1842 #define push_delimiter(ds, character) \
1845 if (ds.delimiter_depth + 2 > ds.delimiter_space) \
1846 ds.delimiters = (char *)xrealloc \
1847 (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
1848 ds.delimiters[ds.delimiter_depth] = character; \
1849 ds.delimiter_depth++; \
1853 #define pop_delimiter(ds) ds.delimiter_depth--
1855 /* Return the next shell input character. This always reads characters
1856 from shell_input_line; when that line is exhausted, it is time to
1857 read the next line. This is called by read_token when the shell is
1858 processing normal command input. */
1860 /* This implements one-character lookahead/lookbehind across physical input
1861 lines, to avoid something being lost because it's pushed back with
1862 shell_ungetc when we're at the start of a line. */
1863 static int eol_ungetc_lookahead = 0;
1866 shell_getc (remove_quoted_newline)
1867 int remove_quoted_newline;
1872 static int mustpop = 0;
1876 if (sigwinch_received)
1878 sigwinch_received = 0;
1879 get_new_window_size (0, (int *)0, (int *)0);
1882 if (eol_ungetc_lookahead)
1884 c = eol_ungetc_lookahead;
1885 eol_ungetc_lookahead = 0;
1889 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1890 /* If shell_input_line[shell_input_line_index] == 0, but there is
1891 something on the pushed list of strings, then we don't want to go
1892 off and get another line. We let the code down below handle it. */
1894 if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
1895 (pushed_string_list == (STRING_SAVER *)NULL)))
1896 #else /* !ALIAS && !DPAREN_ARITHMETIC */
1897 if (!shell_input_line || !shell_input_line[shell_input_line_index])
1898 #endif /* !ALIAS && !DPAREN_ARITHMETIC */
1904 /* Allow immediate exit if interrupted during input. */
1908 shell_input_line_terminator = 0;
1910 /* If the shell is interatctive, but not currently printing a prompt
1911 (interactive_shell && interactive == 0), we don't want to print
1912 notifies or cleanup the jobs -- we want to defer it until we do
1913 print the next prompt. */
1914 if (interactive_shell == 0 || SHOULD_PROMPT())
1916 #if defined (JOB_CONTROL)
1917 /* This can cause a problem when reading a command as the result
1918 of a trap, when the trap is called from flush_child. This call
1919 had better not cause jobs to disappear from the job table in
1920 that case, or we will have big trouble. */
1921 notify_and_cleanup ();
1922 #else /* !JOB_CONTROL */
1923 cleanup_dead_jobs ();
1924 #endif /* !JOB_CONTROL */
1927 #if defined (READLINE)
1928 if (no_line_editing && SHOULD_PROMPT())
1930 if (SHOULD_PROMPT())
1934 if (bash_input.type == st_stream)
1941 /* Allow immediate exit if interrupted during input. */
1947 internal_warning ("shell_getc: ignored null byte in input");
1952 RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
1956 if (bash_input.type == st_stream)
1960 shell_input_line_terminator = EOF;
1962 shell_input_line[i] = '\0';
1966 shell_input_line[i++] = c;
1970 shell_input_line[--i] = '\0';
1971 current_command_line_count++;
1976 shell_input_line_index = 0;
1977 shell_input_line_len = i; /* == strlen (shell_input_line) */
1979 set_line_mbstate ();
1981 #if defined (HISTORY)
1982 if (remember_on_history && shell_input_line && shell_input_line[0])
1985 # if defined (BANG_HISTORY)
1988 /* If the current delimiter is a single quote, we should not be
1989 performing history expansion, even if we're on a different
1990 line from the original single quote. */
1991 old_hist = history_expansion_inhibited;
1992 if (current_delimiter (dstack) == '\'')
1993 history_expansion_inhibited = 1;
1995 expansions = pre_process_line (shell_input_line, 1, 1);
1996 # if defined (BANG_HISTORY)
1997 history_expansion_inhibited = old_hist;
1999 if (expansions != shell_input_line)
2001 free (shell_input_line);
2002 shell_input_line = expansions;
2003 shell_input_line_len = shell_input_line ?
2004 strlen (shell_input_line) : 0;
2005 if (!shell_input_line_len)
2006 current_command_line_count--;
2008 /* We have to force the xrealloc below because we don't know
2009 the true allocated size of shell_input_line anymore. */
2010 shell_input_line_size = shell_input_line_len;
2012 set_line_mbstate ();
2015 /* Try to do something intelligent with blank lines encountered while
2016 entering multi-line commands. XXX - this is grotesque */
2017 else if (remember_on_history && shell_input_line &&
2018 shell_input_line[0] == '\0' &&
2019 current_command_line_count > 1)
2021 if (current_delimiter (dstack))
2022 /* We know shell_input_line[0] == 0 and we're reading some sort of
2023 quoted string. This means we've got a line consisting of only
2024 a newline in a quoted string. We want to make sure this line
2025 gets added to the history. */
2026 maybe_add_history (shell_input_line);
2030 hdcs = history_delimiting_chars ();
2031 if (hdcs && hdcs[0] == ';')
2032 maybe_add_history (shell_input_line);
2036 #endif /* HISTORY */
2038 if (shell_input_line)
2040 /* Lines that signify the end of the shell's input should not be
2042 if (echo_input_at_read && (shell_input_line[0] ||
2043 shell_input_line_terminator != EOF))
2044 fprintf (stderr, "%s\n", shell_input_line);
2048 shell_input_line_size = 0;
2049 prompt_string_pointer = ¤t_prompt_string;
2050 if (SHOULD_PROMPT ())
2055 /* Add the newline to the end of this string, iff the string does
2056 not already end in an EOF character. */
2057 if (shell_input_line_terminator != EOF)
2059 if (shell_input_line_len + 3 > shell_input_line_size)
2060 shell_input_line = (char *)xrealloc (shell_input_line,
2061 1 + (shell_input_line_size += 2));
2063 shell_input_line[shell_input_line_len] = '\n';
2064 shell_input_line[shell_input_line_len + 1] = '\0';
2066 set_line_mbstate ();
2070 uc = shell_input_line[shell_input_line_index];
2073 shell_input_line_index++;
2075 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2076 /* If UC is NULL, we have reached the end of the current input string. If
2077 pushed_string_list is non-empty, it's time to pop to the previous string
2078 because we have fully consumed the result of the last alias expansion.
2079 Do it transparently; just return the next character of the string popped
2081 if (!uc && (pushed_string_list != (STRING_SAVER *)NULL))
2084 uc = shell_input_line[shell_input_line_index];
2086 shell_input_line_index++;
2088 #endif /* ALIAS || DPAREN_ARITHMETIC */
2090 if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
2092 if (SHOULD_PROMPT ())
2098 if (!uc && shell_input_line_terminator == EOF)
2099 return ((shell_input_line_index != 0) ? '\n' : EOF);
2104 /* Put C back into the input for the shell. This might need changes for
2105 HANDLE_MULTIBYTE around EOLs. Since we (currently) never push back a
2106 character different than we read, shell_input_line_property doesn't need
2107 to change when manipulating shell_input_line. The define for
2108 last_shell_getc_is_singlebyte should take care of it, though. */
2113 if (shell_input_line && shell_input_line_index)
2114 shell_input_line[--shell_input_line_index] = c;
2116 eol_ungetc_lookahead = c;
2119 #ifdef INCLUDE_UNUSED
2120 /* Back the input pointer up by one, effectively `ungetting' a character. */
2124 if (shell_input_line && shell_input_line_index)
2125 shell_input_line_index--;
2129 /* Discard input until CHARACTER is seen, then push that character back
2130 onto the input stream. */
2132 discard_until (character)
2137 while ((c = shell_getc (0)) != EOF && c != character)
2145 execute_prompt_command (command)
2149 sh_parser_state_t ps;
2151 save_parser_state (&ps);
2152 last_lastarg = get_string_value ("_");
2154 last_lastarg = savestring (last_lastarg);
2156 parse_and_execute (savestring (command), "PROMPT_COMMAND", SEVAL_NONINT|SEVAL_NOHIST);
2158 restore_parser_state (&ps);
2159 bind_variable ("_", last_lastarg, 0);
2160 FREE (last_lastarg);
2162 if (token_to_read == '\n') /* reset_parser was called */
2166 /* Place to remember the token. We try to keep the buffer
2167 at a reasonable size, but it can grow. */
2168 static char *token = (char *)NULL;
2170 /* Current size of the token buffer. */
2171 static int token_buffer_size;
2173 /* Command to read_token () explaining what we want it to do. */
2176 #define prompt_is_ps1 \
2177 (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
2179 /* Function for yyparse to call. yylex keeps track of
2180 the last two tokens read, and calls read_token. */
2184 if (interactive && (current_token == 0 || current_token == '\n'))
2186 /* Before we print a prompt, we might have to check mailboxes.
2187 We do this only if it is time to do so. Notice that only here
2188 is the mail alarm reset; nothing takes place in check_mail ()
2189 except the checking of mail. Please don't change this. */
2190 if (prompt_is_ps1 && time_to_check_mail ())
2193 reset_mail_timer ();
2196 /* Avoid printing a prompt if we're not going to read anything, e.g.
2197 after resetting the parser with read_token (RESET). */
2198 if (token_to_read == 0 && SHOULD_PROMPT ())
2202 two_tokens_ago = token_before_that;
2203 token_before_that = last_read_token;
2204 last_read_token = current_token;
2205 current_token = read_token (READ);
2206 return (current_token);
2209 /* When non-zero, we have read the required tokens
2210 which allow ESAC to be the next one read. */
2211 static int esacs_needed_count;
2214 gather_here_documents ()
2217 while (need_here_doc)
2219 make_here_document (redir_stack[r++]);
2224 /* When non-zero, an open-brace used to create a group is awaiting a close
2226 static int open_brace_count;
2228 #define command_token_position(token) \
2229 (((token) == ASSIGNMENT_WORD) || \
2230 ((token) != SEMI_SEMI && reserved_word_acceptable(token)))
2232 #define assignment_acceptable(token) \
2233 (command_token_position(token) && ((parser_state & PST_CASEPAT) == 0))
2235 /* Check to see if TOKEN is a reserved word and return the token
2237 #define CHECK_FOR_RESERVED_WORD(tok) \
2239 if (!dollar_present && !quoted && \
2240 reserved_word_acceptable (last_read_token)) \
2243 for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
2244 if (STREQ (tok, word_token_alist[i].word)) \
2246 if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
2248 if (word_token_alist[i].token == TIME && time_command_acceptable () == 0) \
2250 if (word_token_alist[i].token == ESAC) \
2251 parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
2252 else if (word_token_alist[i].token == CASE) \
2253 parser_state |= PST_CASESTMT; \
2254 else if (word_token_alist[i].token == COND_END) \
2255 parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
2256 else if (word_token_alist[i].token == COND_START) \
2257 parser_state |= PST_CONDCMD; \
2258 else if (word_token_alist[i].token == '{') \
2259 open_brace_count++; \
2260 else if (word_token_alist[i].token == '}' && open_brace_count) \
2261 open_brace_count--; \
2262 return (word_token_alist[i].token); \
2269 /* OK, we have a token. Let's try to alias expand it, if (and only if)
2272 It is eligible for expansion if EXPAND_ALIASES is set, and
2273 the token is unquoted and the last token read was a command
2274 separator (or expand_next_token is set), and we are currently
2275 processing an alias (pushed_string_list is non-empty) and this
2276 token is not the same as the current or any previously
2279 Special cases that disqualify:
2280 In a pattern list in a case statement (parser_state & PST_CASEPAT). */
2290 r = xmalloc (l + 2);
2299 alias_expand_token (tokstr)
2305 if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
2306 (parser_state & PST_CASEPAT) == 0)
2308 ap = find_alias (tokstr);
2310 /* Currently expanding this token. */
2311 if (ap && (ap->flags & AL_BEINGEXPANDED))
2312 return (NO_EXPANSION);
2314 /* mk_alexpansion puts an extra space on the end of the alias expansion,
2315 so the lookahead by the parser works right. If this gets changed,
2316 make sure the code in shell_getc that deals with reaching the end of
2317 an expanded alias is changed with it. */
2318 expanded = ap ? mk_alexpansion (ap->value) : (char *)NULL;
2322 push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
2323 return (RE_READ_TOKEN);
2326 /* This is an eligible token that does not have an expansion. */
2327 return (NO_EXPANSION);
2329 return (NO_EXPANSION);
2334 time_command_acceptable ()
2336 #if defined (COMMAND_TIMING)
2337 switch (last_read_token)
2356 #endif /* COMMAND_TIMING */
2359 /* Handle special cases of token recognition:
2360 IN is recognized if the last token was WORD and the token
2361 before that was FOR or CASE or SELECT.
2363 DO is recognized if the last token was WORD and the token
2364 before that was FOR or SELECT.
2366 ESAC is recognized if the last token caused `esacs_needed_count'
2369 `{' is recognized if the last token as WORD and the token
2370 before that was FUNCTION, or if we just parsed an arithmetic
2373 `}' is recognized if there is an unclosed `{' present.
2375 `-p' is returned as TIMEOPT if the last read token was TIME.
2377 ']]' is returned as COND_END if the parser is currently parsing
2378 a conditional expression ((parser_state & PST_CONDEXPR) != 0)
2380 `time' is returned as TIME if and only if it is immediately
2381 preceded by one of `;', `\n', `||', `&&', or `&'.
2385 special_case_tokens (tokstr)
2388 if ((last_read_token == WORD) &&
2389 #if defined (SELECT_COMMAND)
2390 ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
2392 ((token_before_that == FOR) || (token_before_that == CASE)) &&
2394 (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
2396 if (token_before_that == CASE)
2398 parser_state |= PST_CASEPAT;
2399 esacs_needed_count++;
2404 if (last_read_token == WORD &&
2405 #if defined (SELECT_COMMAND)
2406 (token_before_that == FOR || token_before_that == SELECT) &&
2408 (token_before_that == FOR) &&
2410 (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
2413 /* Ditto for ESAC in the CASE case.
2414 Specifically, this handles "case word in esac", which is a legal
2415 construct, certainly because someone will pass an empty arg to the
2416 case construct, and we don't want it to barf. Of course, we should
2417 insist that the case construct has at least one pattern in it, but
2418 the designers disagree. */
2419 if (esacs_needed_count)
2421 esacs_needed_count--;
2422 if (STREQ (tokstr, "esac"))
2424 parser_state &= ~PST_CASEPAT;
2429 /* The start of a shell function definition. */
2430 if (parser_state & PST_ALLOWOPNBRC)
2432 parser_state &= ~PST_ALLOWOPNBRC;
2433 if (tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2436 function_bstart = line_number;
2437 return ('{'); /* } */
2441 /* We allow a `do' after a for ((...)) without an intervening
2443 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == 'd' && tokstr[1] == 'o' && !tokstr[2])
2445 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2448 return ('{'); /* } */
2451 if (open_brace_count && reserved_word_acceptable (last_read_token) && tokstr[0] == '}' && !tokstr[1])
2453 open_brace_count--; /* { */
2457 #if defined (COMMAND_TIMING)
2458 /* Handle -p after `time'. */
2459 if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == 'p' && !tokstr[2])
2464 #if defined (COMMAND_TIMING)
2465 if (STREQ (token, "time") && ((parser_state & PST_CASEPAT) == 0) && time_command_acceptable ())
2467 #endif /* COMMAND_TIMING */
2470 #if defined (COND_COMMAND) /* [[ */
2471 if ((parser_state & PST_CONDEXPR) && tokstr[0] == ']' && tokstr[1] == ']' && tokstr[2] == '\0')
2478 /* Called from shell.c when Control-C is typed at top level. Or
2479 by the error rule at top level. */
2483 dstack.delimiter_depth = 0; /* No delimiters found so far. */
2484 open_brace_count = 0;
2488 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2489 if (pushed_string_list)
2490 free_string_list ();
2491 #endif /* ALIAS || DPAREN_ARITHMETIC */
2493 if (shell_input_line)
2495 free (shell_input_line);
2496 shell_input_line = (char *)NULL;
2497 shell_input_line_size = shell_input_line_index = 0;
2500 FREE (word_desc_to_read);
2501 word_desc_to_read = (WORD_DESC *)NULL;
2503 last_read_token = '\n';
2504 token_to_read = '\n';
2507 /* Read the next token. Command can be READ (normal operation) or
2508 RESET (to normalize state). */
2510 read_token (command)
2513 int character; /* Current character. */
2514 int peek_char; /* Temporary look-ahead character. */
2515 int result; /* The thing to return. */
2517 if (command == RESET)
2525 result = token_to_read;
2526 if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
2528 yylval.word = word_desc_to_read;
2529 word_desc_to_read = (WORD_DESC *)NULL;
2535 #if defined (COND_COMMAND)
2536 if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
2538 cond_lineno = line_number;
2539 parser_state |= PST_CONDEXPR;
2540 yylval.command = parse_cond_command ();
2541 if (cond_token != COND_END)
2546 token_to_read = COND_END;
2547 parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
2553 /* This is a place to jump back to once we have successfully expanded a
2554 token with an alias and pushed the string with push_string () */
2558 /* Read a single word from input. Start by skipping blanks. */
2559 while ((character = shell_getc (1)) != EOF && whitespace (character))
2562 if (character == EOF)
2568 if MBTEST(character == '#' && (!interactive || interactive_comments))
2570 /* A comment. Discard until EOL or EOF, and then return a newline. */
2571 discard_until ('\n');
2573 character = '\n'; /* this will take the next if statement and return. */
2576 if (character == '\n')
2578 /* If we're about to return an unquoted newline, we can go and collect
2579 the text of any pending here document. */
2581 gather_here_documents ();
2584 parser_state &= ~PST_ALEXPNEXT;
2587 parser_state &= ~PST_ASSIGNOK;
2592 /* Shell meta-characters. */
2593 if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
2596 /* Turn off alias tokenization iff this character sequence would
2597 not leave us ready to read a command. */
2598 if (character == '<' || character == '>')
2599 parser_state &= ~PST_ALEXPNEXT;
2602 parser_state &= ~PST_ASSIGNOK;
2604 peek_char = shell_getc (1);
2605 if (character == peek_char)
2610 /* If '<' then we could be at "<<" or at "<<-". We have to
2611 look ahead one more character. */
2612 peek_char = shell_getc (1);
2613 if (peek_char == '-')
2614 return (LESS_LESS_MINUS);
2615 else if (peek_char == '<')
2616 return (LESS_LESS_LESS);
2619 shell_ungetc (peek_char);
2624 return (GREATER_GREATER);
2627 parser_state |= PST_CASEPAT;
2629 parser_state &= ~PST_ALEXPNEXT;
2640 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
2642 result = parse_dparen (character);
2650 else if MBTEST(character == '<' && peek_char == '&')
2652 else if MBTEST(character == '>' && peek_char == '&')
2653 return (GREATER_AND);
2654 else if MBTEST(character == '<' && peek_char == '>')
2655 return (LESS_GREATER);
2656 else if MBTEST(character == '>' && peek_char == '|')
2657 return (GREATER_BAR);
2658 else if MBTEST(peek_char == '>' && character == '&')
2659 return (AND_GREATER);
2661 shell_ungetc (peek_char);
2663 /* If we look like we are reading the start of a function
2664 definition, then let the reader know about it so that
2665 we will do the right thing with `{'. */
2666 if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
2668 parser_state |= PST_ALLOWOPNBRC;
2670 parser_state &= ~PST_ALEXPNEXT;
2672 function_dstart = line_number;
2675 /* case pattern lists may be preceded by an optional left paren. If
2676 we're not trying to parse a case pattern list, the left paren
2677 indicates a subshell. */
2678 if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
2679 parser_state |= PST_SUBSHELL;
2681 else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
2682 parser_state &= ~PST_CASEPAT;
2684 else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
2685 parser_state &= ~PST_SUBSHELL;
2687 #if defined (PROCESS_SUBSTITUTION)
2688 /* Check for the constructs which introduce process substitution.
2689 Shells running in `posix mode' don't do process substitution. */
2690 if MBTEST(posixly_correct || ((character != '>' && character != '<') || peek_char != '(')) /*)*/
2691 #endif /* PROCESS_SUBSTITUTION */
2695 /* Hack <&- (close stdin) case. Also <&N- (dup and close). */
2696 if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
2699 /* Okay, if we got this far, we have to read a word. Read one,
2700 and then check it against the known ones. */
2701 result = read_token_word (character);
2703 if (result == RE_READ_TOKEN)
2710 * Match a $(...) or other grouping construct. This has to handle embedded
2711 * quoted strings ('', ``, "") and nested constructs. It also must handle
2712 * reprompting the user, if necessary, after reading a newline, and returning
2713 * correct error values if it reads EOF.
2715 #define P_FIRSTCLOSE 0x01
2716 #define P_ALLOWESC 0x02
2717 #define P_DQUOTE 0x04
2718 #define P_COMMAND 0x08 /* parsing a command, so look for comments */
2720 static char matched_pair_error;
2722 parse_matched_pair (qc, open, close, lenp, flags)
2723 int qc; /* `"' if this construct is within double quotes */
2727 int count, ch, was_dollar, in_comment, check_comment;
2728 int pass_next_character, nestlen, ttranslen, start_lineno;
2729 char *ret, *nestret, *ttrans;
2730 int retind, retsize, rflags;
2733 pass_next_character = was_dollar = in_comment = 0;
2734 check_comment = (flags & P_COMMAND) && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0;
2736 /* RFLAGS is the set of flags we want to pass to recursive calls. */
2737 rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
2739 ret = (char *)xmalloc (retsize = 64);
2742 start_lineno = line_number;
2745 ch = shell_getc (qc != '\'' && pass_next_character == 0);
2750 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
2751 EOF_Reached = 1; /* XXX */
2752 return (&matched_pair_error);
2755 /* Possible reprompting. */
2756 if (ch == '\n' && SHOULD_PROMPT ())
2761 /* Add this character. */
2762 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
2770 /* Not exactly right yet */
2771 else if MBTEST(check_comment && in_comment == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || whitespace (ret[retind - 1])))
2774 if (pass_next_character) /* last char was backslash */
2776 pass_next_character = 0;
2777 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
2779 if (retind > 0) retind--; /* swallow previously-added backslash */
2783 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
2784 if MBTEST(ch == CTLESC || ch == CTLNUL)
2785 ret[retind++] = CTLESC;
2789 else if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
2791 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
2792 ret[retind++] = CTLESC;
2796 else if MBTEST(ch == close) /* ending delimiter */
2798 /* handle nested ${...} specially. */
2799 else if MBTEST(open != close && was_dollar && open == '{' && ch == open) /* } */
2801 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
2804 /* Add this character. */
2805 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
2808 if (open == '\'') /* '' inside grouping construct */
2810 if MBTEST((flags & P_ALLOWESC) && ch == '\\')
2811 pass_next_character++;
2815 if MBTEST(ch == '\\') /* backslashes */
2816 pass_next_character++;
2818 if (open != close) /* a grouping construct */
2820 if MBTEST(shellquote (ch))
2822 /* '', ``, or "" inside $(...) or other grouping construct. */
2823 push_delimiter (dstack, ch);
2824 if MBTEST(was_dollar && ch == '\'') /* $'...' inside group */
2825 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
2827 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
2828 pop_delimiter (dstack);
2829 if (nestret == &matched_pair_error)
2832 return &matched_pair_error;
2834 if MBTEST(was_dollar && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
2836 /* Translate $'...' here. */
2837 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
2840 if ((rflags & P_DQUOTE) == 0)
2842 nestret = sh_single_quote (ttrans);
2844 nestlen = strlen (nestret);
2849 nestlen = ttranslen;
2851 retind -= 2; /* back up before the $' */
2853 else if MBTEST(was_dollar && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
2855 /* Locale expand $"..." here. */
2856 ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
2859 nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
2861 nestlen = ttranslen + 2;
2862 retind -= 2; /* back up before the $" */
2867 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64);
2868 strcpy (ret + retind, nestret);
2874 /* Parse an old-style command substitution within double quotes as a
2876 /* XXX - sh and ksh93 don't do this - XXX */
2877 else if MBTEST(open == '"' && ch == '`')
2879 nestret = parse_matched_pair (0, '`', '`', &nestlen, rflags);
2881 if (nestret == &matched_pair_error)
2884 return &matched_pair_error;
2888 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64);
2889 strcpy (ret + retind, nestret);
2894 else if MBTEST(qc == '`' && (ch == '"' || ch == '\'') && in_comment == 0)
2896 /* Add P_ALLOWESC so backslash quotes the next character and
2897 shell_getc does the right thing with \<newline>. We do this for
2898 a measure of backwards compatibility -- it's not strictly the
2899 right POSIX thing. */
2900 nestret = parse_matched_pair (0, ch, ch, &nestlen, rflags|P_ALLOWESC);
2903 else if MBTEST(was_dollar && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
2904 /* check for $(), $[], or ${} inside quoted string. */
2906 if (open == ch) /* undo previous increment */
2908 if (ch == '(') /* ) */
2909 nestret = parse_matched_pair (0, '(', ')', &nestlen, rflags & ~P_DQUOTE);
2910 else if (ch == '{') /* } */
2911 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
2912 else if (ch == '[') /* ] */
2913 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
2917 was_dollar = MBTEST(ch == '$');
2926 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
2927 /* Parse a double-paren construct. It can be either an arithmetic
2928 command, an arithmetic `for' command, or a nested subshell. Returns
2929 the parsed token, -1 on error, or -2 if we didn't do anything and
2930 should just go on. */
2935 int cmdtyp, len, sline;
2939 #if defined (ARITH_FOR_COMMAND)
2940 if (last_read_token == FOR)
2942 arith_for_lineno = line_number;
2943 cmdtyp = parse_arith_cmd (&wval, 0);
2946 wd = alloc_word_desc ();
2948 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
2949 return (ARITH_FOR_EXPRS);
2952 return -1; /* ERROR */
2956 #if defined (DPAREN_ARITHMETIC)
2957 if (reserved_word_acceptable (last_read_token))
2959 sline = line_number;
2961 cmdtyp = parse_arith_cmd (&wval, 0);
2962 if (cmdtyp == 1) /* arithmetic command */
2964 wd = alloc_word_desc ();
2966 wd->flags = W_QUOTED|W_NOSPLIT|W_NOGLOB|W_DQUOTE;
2967 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
2970 else if (cmdtyp == 0) /* nested subshell */
2972 push_string (wval, 0, (alias_t *)NULL);
2973 if ((parser_state & PST_CASEPAT) == 0)
2974 parser_state |= PST_SUBSHELL;
2982 return -2; /* XXX */
2985 /* We've seen a `(('. Look for the matching `))'. If we get it, return 1.
2986 If not, assume it's a nested subshell for backwards compatibility and
2987 return 0. In any case, put the characters we've consumed into a locally-
2988 allocated buffer and make *ep point to that buffer. Return -1 on an
2989 error, for example EOF. */
2991 parse_arith_cmd (ep, adddq)
2995 int exp_lineno, rval, c;
2996 char *ttok, *tokstr;
2999 exp_lineno = line_number;
3000 ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
3002 if (ttok == &matched_pair_error)
3004 /* Check that the next character is the closing right paren. If
3005 not, this is a syntax error. ( */
3010 tokstr = (char *)xmalloc (ttoklen + 4);
3012 /* if ADDDQ != 0 then (( ... )) -> "..." */
3013 if (rval == 1 && adddq) /* arith cmd, add double quotes */
3016 strncpy (tokstr + 1, ttok, ttoklen - 1);
3017 tokstr[ttoklen] = '"';
3018 tokstr[ttoklen+1] = '\0';
3020 else if (rval == 1) /* arith cmd, don't add double quotes */
3022 strncpy (tokstr, ttok, ttoklen - 1);
3023 tokstr[ttoklen-1] = '\0';
3025 else /* nested subshell */
3028 strncpy (tokstr + 1, ttok, ttoklen - 1);
3029 tokstr[ttoklen] = ')';
3030 tokstr[ttoklen+1] = c;
3031 tokstr[ttoklen+2] = '\0';
3038 #endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
3040 #if defined (COND_COMMAND)
3046 if (EOF_Reached && cond_token != COND_ERROR) /* [[ */
3047 parser_error (cond_lineno, _("unexpected EOF while looking for `]]'"));
3048 else if (cond_token != COND_ERROR)
3050 if (etext = error_token_from_token (cond_token))
3052 parser_error (cond_lineno, _("syntax error in conditional expression: unexpected token `%s'"), etext);
3056 parser_error (cond_lineno, _("syntax error in conditional expression"));
3063 return (cond_or ());
3072 if (cond_token == OR_OR)
3075 l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
3086 if (cond_token == AND_AND)
3089 l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
3095 cond_skip_newlines ()
3097 while ((cond_token = read_token (READ)) == '\n')
3099 if (SHOULD_PROMPT ())
3102 return (cond_token);
3105 #define COND_RETURN_ERROR() \
3106 do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
3112 COND_COM *term, *tleft, *tright;
3116 /* Read a token. It can be a left paren, a `!', a unary operator, or a
3117 word that should be the first argument of a binary operator. Start by
3118 skipping newlines, since this is a compound command. */
3119 tok = cond_skip_newlines ();
3120 lineno = line_number;
3121 if (tok == COND_END)
3123 COND_RETURN_ERROR ();
3125 else if (tok == '(')
3127 term = cond_expr ();
3128 if (cond_token != ')')
3131 dispose_cond_node (term); /* ( */
3132 if (etext = error_token_from_token (cond_token))
3134 parser_error (lineno, _("unexpected token `%s', expected `)'"), etext);
3138 parser_error (lineno, _("expected `)'"));
3139 COND_RETURN_ERROR ();
3141 term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
3142 (void)cond_skip_newlines ();
3144 else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
3147 dispose_word (yylval.word); /* not needed */
3148 term = cond_term ();
3150 term->flags |= CMD_INVERT_RETURN;
3152 else if (tok == WORD && test_unop (yylval.word->word))
3155 tok = read_token (READ);
3158 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3159 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
3164 if (etext = error_token_from_token (tok))
3166 parser_error (line_number, _("unexpected argument `%s' to conditional unary operator"), etext);
3170 parser_error (line_number, _("unexpected argument to conditional unary operator"));
3171 COND_RETURN_ERROR ();
3174 (void)cond_skip_newlines ();
3176 else if (tok == WORD) /* left argument to binary operator */
3179 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3182 tok = read_token (READ);
3183 if (tok == WORD && test_binop (yylval.word->word))
3185 #if defined (COND_REGEXP)
3186 else if (tok == WORD && STREQ (yylval.word->word,"=~"))
3189 else if (tok == '<' || tok == '>')
3190 op = make_word_from_token (tok); /* ( */
3191 /* There should be a check before blindly accepting the `)' that we have
3192 seen the opening `('. */
3193 else if (tok == COND_END || tok == AND_AND || tok == OR_OR || tok == ')')
3195 /* Special case. [[ x ]] is equivalent to [[ -n x ]], just like
3196 the test command. Similarly for [[ x && expr ]] or
3197 [[ x || expr ]] or [[ (x) ]]. */
3198 op = make_word ("-n");
3199 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
3205 if (etext = error_token_from_token (tok))
3207 parser_error (line_number, _("unexpected token `%s', conditional binary operator expected"), etext);
3211 parser_error (line_number, _("conditional binary operator expected"));
3212 dispose_cond_node (tleft);
3213 COND_RETURN_ERROR ();
3217 tok = read_token (READ);
3220 tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3221 term = make_cond_node (COND_BINARY, op, tleft, tright);
3225 if (etext = error_token_from_token (tok))
3227 parser_error (line_number, _("unexpected argument `%s' to conditional binary operator"), etext);
3231 parser_error (line_number, _("unexpected argument to conditional binary operator"));
3232 dispose_cond_node (tleft);
3234 COND_RETURN_ERROR ();
3237 (void)cond_skip_newlines ();
3242 parser_error (line_number, _("unexpected token `%c' in conditional command"), tok);
3243 else if (etext = error_token_from_token (tok))
3245 parser_error (line_number, _("unexpected token `%s' in conditional command"), etext);
3249 parser_error (line_number, _("unexpected token %d in conditional command"), tok);
3250 COND_RETURN_ERROR ();
3255 /* This is kind of bogus -- we slip a mini recursive-descent parser in
3256 here to handle the conditional statement syntax. */
3258 parse_cond_command ()
3262 cexp = cond_expr ();
3263 return (make_cond_command (cexp));
3267 #if defined (ARRAY_VARS)
3268 /* When this is called, it's guaranteed that we don't care about anything
3269 in t beyond i. We do save and restore the chars, though. */
3271 token_is_assignment (t, i)
3275 unsigned char c, c1;
3278 c = t[i]; c1 = t[i+1];
3279 t[i] = '='; t[i+1] = '\0';
3280 r = assignment (t, (parser_state & PST_COMPASSIGN) != 0);
3281 t[i] = c; t[i+1] = c1;
3285 /* XXX - possible changes here for `+=' */
3287 token_is_ident (t, i)
3296 r = legal_identifier (t);
3303 read_token_word (character)
3306 /* The value for YYLVAL when a WORD is read. */
3307 WORD_DESC *the_word;
3309 /* Index into the token that we are building. */
3312 /* ALL_DIGITS becomes zero when we see a non-digit. */
3313 int all_digit_token;
3315 /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
3318 /* COMPOUND_ASSIGNMENT becomes non-zero if we are parsing a compound
3320 int compound_assignment;
3322 /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
3325 /* Non-zero means to ignore the value of the next character, and just
3326 to add it no matter what. */
3327 int pass_next_character;
3329 /* The current delimiting character. */
3331 int result, peek_char;
3332 char *ttok, *ttrans;
3333 int ttoklen, ttranslen;
3336 if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
3337 token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
3340 all_digit_token = DIGIT (character);
3341 dollar_present = quoted = pass_next_character = compound_assignment = 0;
3345 if (character == EOF)
3348 if (pass_next_character)
3350 pass_next_character = 0;
3354 cd = current_delimiter (dstack);
3356 /* Handle backslashes. Quote lots of things when not inside of
3357 double-quotes, quote some things inside of double-quotes. */
3358 if MBTEST(character == '\\')
3360 peek_char = shell_getc (0);
3362 /* Backslash-newline is ignored in all cases except
3363 when quoted with single quotes. */
3364 if (peek_char == '\n')
3367 goto next_character;
3371 shell_ungetc (peek_char);
3373 /* If the next character is to be quoted, note it now. */
3374 if (cd == 0 || cd == '`' ||
3375 (cd == '"' && peek_char >= 0 && (sh_syntaxtab[peek_char] & CBSDQUOTE)))
3376 pass_next_character++;
3383 /* Parse a matched pair of quote characters. */
3384 if MBTEST(shellquote (character))
3386 push_delimiter (dstack, character);
3387 ttok = parse_matched_pair (character, character, character, &ttoklen, (character == '`') ? P_COMMAND : 0);
3388 pop_delimiter (dstack);
3389 if (ttok == &matched_pair_error)
3390 return -1; /* Bail immediately. */
3391 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
3392 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
3393 token[token_index++] = character;
3394 strcpy (token + token_index, ttok);
3395 token_index += ttoklen;
3396 all_digit_token = 0;
3398 dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
3400 goto next_character;
3403 #ifdef EXTENDED_GLOB
3404 /* Parse a ksh-style extended pattern matching specification. */
3405 if (extended_glob && PATTERN_CHAR (character))
3407 peek_char = shell_getc (1);
3408 if MBTEST(peek_char == '(') /* ) */
3410 push_delimiter (dstack, peek_char);
3411 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
3412 pop_delimiter (dstack);
3413 if (ttok == &matched_pair_error)
3414 return -1; /* Bail immediately. */
3415 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
3417 TOKEN_DEFAULT_GROW_SIZE);
3418 token[token_index++] = character;
3419 token[token_index++] = peek_char;
3420 strcpy (token + token_index, ttok);
3421 token_index += ttoklen;
3423 dollar_present = all_digit_token = 0;
3424 goto next_character;
3427 shell_ungetc (peek_char);
3429 #endif /* EXTENDED_GLOB */
3431 /* If the delimiter character is not single quote, parse some of
3432 the shell expansions that must be read as a single word. */
3433 if (shellexp (character))
3435 peek_char = shell_getc (1);
3436 /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
3437 if MBTEST(peek_char == '(' || \
3438 ((peek_char == '{' || peek_char == '[') && character == '$')) /* ) ] } */
3440 if (peek_char == '{') /* } */
3441 ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE);
3442 else if (peek_char == '(') /* ) */
3444 /* XXX - push and pop the `(' as a delimiter for use by
3445 the command-oriented-history code. This way newlines
3446 appearing in the $(...) string get added to the
3447 history literally rather than causing a possibly-
3448 incorrect `;' to be added. ) */
3449 push_delimiter (dstack, peek_char);
3450 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, P_COMMAND);
3451 pop_delimiter (dstack);
3454 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
3455 if (ttok == &matched_pair_error)
3456 return -1; /* Bail immediately. */
3457 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
3459 TOKEN_DEFAULT_GROW_SIZE);
3460 token[token_index++] = character;
3461 token[token_index++] = peek_char;
3462 strcpy (token + token_index, ttok);
3463 token_index += ttoklen;
3466 all_digit_token = 0;
3467 goto next_character;
3469 /* This handles $'...' and $"..." new-style quoted strings. */
3470 else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
3474 first_line = line_number;
3475 push_delimiter (dstack, peek_char);
3476 ttok = parse_matched_pair (peek_char, peek_char, peek_char,
3478 (peek_char == '\'') ? P_ALLOWESC : 0);
3479 pop_delimiter (dstack);
3480 if (ttok == &matched_pair_error)
3482 if (peek_char == '\'')
3484 ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
3487 /* Insert the single quotes and correctly quote any
3488 embedded single quotes (allowed because P_ALLOWESC was
3489 passed to parse_matched_pair). */
3490 ttok = sh_single_quote (ttrans);
3492 ttranslen = strlen (ttok);
3497 /* Try to locale-expand the converted string. */
3498 ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
3501 /* Add the double quotes back */
3502 ttok = sh_mkdoublequoted (ttrans, ttranslen, 0);
3508 RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 2,
3510 TOKEN_DEFAULT_GROW_SIZE);
3511 strcpy (token + token_index, ttrans);
3512 token_index += ttranslen;
3515 all_digit_token = 0;
3516 goto next_character;
3518 /* This could eventually be extended to recognize all of the
3519 shell's single-character parameter expansions, and set flags.*/
3520 else if MBTEST(character == '$' && peek_char == '$')
3522 ttok = (char *)xmalloc (3);
3523 ttok[0] = ttok[1] = '$';
3525 RESIZE_MALLOCED_BUFFER (token, token_index, 3,
3527 TOKEN_DEFAULT_GROW_SIZE);
3528 strcpy (token + token_index, ttok);
3531 all_digit_token = 0;
3533 goto next_character;
3536 shell_ungetc (peek_char);
3539 #if defined (ARRAY_VARS)
3540 /* Identify possible array subscript assignment; match [...] */
3541 else if MBTEST(character == '[' && token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) /* ] */
3543 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
3544 if (ttok == &matched_pair_error)
3545 return -1; /* Bail immediately. */
3546 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
3548 TOKEN_DEFAULT_GROW_SIZE);
3549 token[token_index++] = character;
3550 strcpy (token + token_index, ttok);
3551 token_index += ttoklen;
3553 all_digit_token = 0;
3554 goto next_character;
3556 /* Identify possible compound array variable assignment. */
3557 else if MBTEST(character == '=' && token_index > 0 && (assignment_acceptable (last_read_token) || (parser_state & PST_ASSIGNOK)) && token_is_assignment (token, token_index))
3559 peek_char = shell_getc (1);
3560 if MBTEST(peek_char == '(') /* ) */
3562 ttok = parse_compound_assignment (&ttoklen);
3564 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
3566 TOKEN_DEFAULT_GROW_SIZE);
3568 token[token_index++] = '=';
3569 token[token_index++] = '(';
3572 strcpy (token + token_index, ttok);
3573 token_index += ttoklen;
3575 token[token_index++] = ')';
3577 all_digit_token = 0;
3578 compound_assignment = 1;
3580 goto next_character;
3582 goto got_token; /* ksh93 seems to do this */
3586 shell_ungetc (peek_char);
3590 /* When not parsing a multi-character word construct, shell meta-
3591 characters break words. */
3592 if MBTEST(shellbreak (character))
3594 shell_ungetc (character);
3600 all_digit_token &= DIGIT (character);
3601 dollar_present |= character == '$';
3603 if (character == CTLESC || character == CTLNUL)
3604 token[token_index++] = CTLESC;
3606 token[token_index++] = character;
3608 RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
3609 TOKEN_DEFAULT_GROW_SIZE);
3612 if (character == '\n' && SHOULD_PROMPT ())
3615 /* We want to remove quoted newlines (that is, a \<newline> pair)
3616 unless we are within single quotes or pass_next_character is
3617 set (the shell equivalent of literal-next). */
3618 cd = current_delimiter (dstack);
3619 character = shell_getc (cd != '\'' && pass_next_character == 0);
3620 } /* end for (;;) */
3624 token[token_index] = '\0';
3626 /* Check to see what thing we should return. If the last_read_token
3627 is a `<', or a `&', or the character which ended this token is
3628 a '>' or '<', then, and ONLY then, is this input token a NUMBER.
3629 Otherwise, it is just a word, and should be returned as such. */
3630 if MBTEST(all_digit_token && (character == '<' || character == '>' || \
3631 last_read_token == LESS_AND || \
3632 last_read_token == GREATER_AND))
3634 if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
3635 yylval.number = lvalue;
3641 /* Check for special case tokens. */
3642 result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
3647 /* Posix.2 does not allow reserved words to be aliased, so check for all
3648 of them, including special cases, before expanding the current token
3650 if MBTEST(posixly_correct)
3651 CHECK_FOR_RESERVED_WORD (token);
3653 /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
3654 inhibits alias expansion. */
3655 if (expand_aliases && quoted == 0)
3657 result = alias_expand_token (token);
3658 if (result == RE_READ_TOKEN)
3659 return (RE_READ_TOKEN);
3660 else if (result == NO_EXPANSION)
3661 parser_state &= ~PST_ALEXPNEXT;
3664 /* If not in Posix.2 mode, check for reserved words after alias
3666 if MBTEST(posixly_correct == 0)
3668 CHECK_FOR_RESERVED_WORD (token);
3670 the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
3671 the_word->word = (char *)xmalloc (1 + token_index);
3672 the_word->flags = 0;
3673 strcpy (the_word->word, token);
3675 the_word->flags |= W_HASDOLLAR;
3677 the_word->flags |= W_QUOTED;
3678 if (compound_assignment)
3679 the_word->flags |= W_COMPASSIGN;
3680 /* A word is an assignment if it appears at the beginning of a
3681 simple command, or after another assignment word. This is
3682 context-dependent, so it cannot be handled in the grammar. */
3683 if (assignment (token, (parser_state & PST_COMPASSIGN) != 0))
3685 the_word->flags |= W_ASSIGNMENT;
3686 /* Don't perform word splitting on assignment statements. */
3687 if (assignment_acceptable (last_read_token) || (parser_state & PST_COMPASSIGN) != 0)
3688 the_word->flags |= W_NOSPLIT;
3691 if (command_token_position (last_read_token))
3694 b = builtin_address_internal (token, 0);
3695 if (b && (b->flags & ASSIGNMENT_BUILTIN))
3696 parser_state |= PST_ASSIGNOK;
3697 else if (STREQ (token, "eval") || STREQ (token, "let"))
3698 parser_state |= PST_ASSIGNOK;
3701 yylval.word = the_word;
3703 result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
3704 ? ASSIGNMENT_WORD : WORD;
3706 switch (last_read_token)
3709 parser_state |= PST_ALLOWOPNBRC;
3710 function_dstart = line_number;
3715 if (word_top < MAX_CASE_NEST)
3717 word_lineno[word_top] = line_number;
3724 /* Return 1 if TOKSYM is a token that after being read would allow
3725 a reserved word to be seen, else 0. */
3727 reserved_word_acceptable (toksym)
3763 /* Return the index of TOKEN in the alist of reserved words, or -1 if
3764 TOKEN is not a shell reserved word. */
3766 find_reserved_word (tokstr)
3770 for (i = 0; word_token_alist[i].word; i++)
3771 if (STREQ (tokstr, word_token_alist[i].word))
3777 #if defined (READLINE)
3778 /* Called after each time readline is called. This insures that whatever
3779 the new prompt string is gets propagated to readline's local prompt
3782 reset_readline_prompt ()
3786 if (prompt_string_pointer)
3788 temp_prompt = (*prompt_string_pointer)
3789 ? decode_prompt_string (*prompt_string_pointer)
3792 if (temp_prompt == 0)
3794 temp_prompt = (char *)xmalloc (1);
3795 temp_prompt[0] = '\0';
3798 FREE (current_readline_prompt);
3799 current_readline_prompt = temp_prompt;
3802 #endif /* READLINE */
3805 #if defined (HISTORY)
3806 /* A list of tokens which can be followed by newlines, but not by
3807 semi-colons. When concatenating multiple lines of history, the
3808 newline separator for such tokens is replaced with a space. */
3809 static int no_semi_successors[] = {
3810 '\n', '{', '(', ')', ';', '&', '|',
3811 CASE, DO, ELSE, IF, SEMI_SEMI, THEN, UNTIL, WHILE, AND_AND, OR_OR, IN,
3815 /* If we are not within a delimited expression, try to be smart
3816 about which separators can be semi-colons and which must be
3817 newlines. Returns the string that should be added into the
3820 history_delimiting_chars ()
3824 if (dstack.delimiter_depth != 0)
3827 /* First, handle some special cases. */
3829 /* If we just read `()', assume it's a function definition, and don't
3830 add a semicolon. If the token before the `)' was not `(', and we're
3831 not in the midst of parsing a case statement, assume it's a
3832 parenthesized command and add the semicolon. */
3834 if (token_before_that == ')')
3836 if (two_tokens_ago == '(') /*)*/ /* function def */
3838 /* This does not work for subshells inside case statement
3839 command lists. It's a suboptimal solution. */
3840 else if (parser_state & PST_CASESTMT) /* case statement pattern */
3843 return "; "; /* (...) subshell */
3845 else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
3846 return " "; /* function def using `function name' without `()' */
3848 else if (token_before_that == WORD && two_tokens_ago == FOR)
3850 /* Tricky. `for i\nin ...' should not have a semicolon, but
3851 `for i\ndo ...' should. We do what we can. */
3852 for (i = shell_input_line_index; whitespace(shell_input_line[i]); i++)
3854 if (shell_input_line[i] && shell_input_line[i] == 'i' && shell_input_line[i+1] == 'n')
3858 else if (two_tokens_ago == CASE && token_before_that == WORD && (parser_state & PST_CASESTMT))
3861 for (i = 0; no_semi_successors[i]; i++)
3863 if (token_before_that == no_semi_successors[i])
3869 #endif /* HISTORY */
3871 /* Issue a prompt, or prepare to issue a prompt when the next character
3878 if (interactive == 0 || expanding_alias()) /* XXX */
3881 ps1_prompt = get_string_value ("PS1");
3882 ps2_prompt = get_string_value ("PS2");
3884 if (!prompt_string_pointer)
3885 prompt_string_pointer = &ps1_prompt;
3887 temp_prompt = *prompt_string_pointer
3888 ? decode_prompt_string (*prompt_string_pointer)
3891 if (temp_prompt == 0)
3893 temp_prompt = (char *)xmalloc (1);
3894 temp_prompt[0] = '\0';
3897 current_prompt_string = *prompt_string_pointer;
3898 prompt_string_pointer = &ps2_prompt;
3900 #if defined (READLINE)
3901 if (!no_line_editing)
3903 FREE (current_readline_prompt);
3904 current_readline_prompt = temp_prompt;
3907 #endif /* READLINE */
3909 FREE (current_decoded_prompt);
3910 current_decoded_prompt = temp_prompt;
3915 get_current_prompt_level ()
3917 return ((current_prompt_string && current_prompt_string == ps2_prompt) ? 2 : 1);
3921 set_current_prompt_level (x)
3924 prompt_string_pointer = (x == 2) ? &ps2_prompt : &ps1_prompt;
3925 current_prompt_string = *prompt_string_pointer;
3931 fprintf (stderr, "%s", current_decoded_prompt);
3935 /* Return a string which will be printed as a prompt. The string
3936 may contain special characters which are decoded as follows:
3939 \d the date in Day Mon Date format
3940 \e escape (ascii 033)
3941 \h the hostname up to the first `.'
3943 \j the number of active jobs
3944 \l the basename of the shell's tty device name
3947 \s the name of the shell
3948 \t the time in 24-hour hh:mm:ss format
3949 \T the time in 12-hour hh:mm:ss format
3950 \@ the time in 12-hour hh:mm am/pm format
3951 \A the time in 24-hour hh:mm format
3952 \D{fmt} the result of passing FMT to strftime(3)
3954 \v the version of bash (e.g., 2.00)
3955 \V the release of bash, version + patchlevel (e.g., 2.00.0)
3956 \w the current working directory
3957 \W the last element of $PWD
3958 \! the history number of this command
3959 \# the command number of this command
3960 \$ a $ or a # if you are root
3961 \nnn character code nnn in octal
3963 \[ begin a sequence of non-printing chars
3964 \] end a sequence of non-printing chars
3966 #define PROMPT_GROWTH 48
3968 decode_prompt_string (string)
3973 struct dstack save_dstack;
3974 int last_exit_value;
3975 #if defined (PROMPT_STRING_DECODE)
3976 int result_size, result_index;
3978 char *temp, octal_string[4];
3984 result = (char *)xmalloc (result_size = PROMPT_GROWTH);
3985 result[result_index = 0] = 0;
3986 temp = (char *)NULL;
3988 while (c = *string++)
3990 if (posixly_correct && c == '!')
3994 temp = savestring ("!");
3999 #if !defined (HISTORY)
4000 temp = savestring ("1");
4002 temp = itos (history_number ());
4003 #endif /* HISTORY */
4004 string--; /* add_string increments string again. */
4022 strncpy (octal_string, string, 3);
4023 octal_string[3] = '\0';
4025 n = read_octal (octal_string);
4026 temp = (char *)xmalloc (3);
4028 if (n == CTLESC || n == CTLNUL)
4045 for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
4048 c = 0; /* tested at add_string: */
4056 /* Make the current time/date into a string. */
4057 (void) time (&the_time);
4058 tm = localtime (&the_time);
4061 n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
4063 n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
4065 n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
4067 n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
4069 n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
4074 timebuf[sizeof(timebuf) - 1] = '\0';
4076 temp = savestring (timebuf);
4079 case 'D': /* strftime format */
4080 if (string[1] != '{') /* } */
4083 (void) time (&the_time);
4084 tm = localtime (&the_time);
4085 string += 2; /* skip { */
4086 timefmt = xmalloc (strlen (string) + 3);
4087 for (t = timefmt; *string && *string != '}'; )
4090 c = *string; /* tested at add_string */
4091 if (timefmt[0] == '\0')
4094 timefmt[1] = 'X'; /* locale-specific current time */
4097 n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
4103 timebuf[sizeof(timebuf) - 1] = '\0';
4105 if (promptvars || posixly_correct)
4106 /* Make sure that expand_prompt_string is called with a
4107 second argument of Q_DOUBLE_QUOTES if we use this
4109 temp = sh_backslash_quote_for_double_quotes (timebuf);
4111 temp = savestring (timebuf);
4115 temp = (char *)xmalloc (3);
4116 temp[0] = no_line_editing ? '\n' : '\r';
4117 temp[1] = no_line_editing ? '\0' : '\n';
4122 temp = base_pathname (shell_name);
4123 temp = savestring (temp);
4128 temp = (char *)xmalloc (16);
4130 strcpy (temp, dist_version);
4132 sprintf (temp, "%s.%d", dist_version, patch_level);
4138 /* Use the value of PWD because it is much more efficient. */
4139 char t_string[PATH_MAX], *t;
4142 temp = get_string_value ("PWD");
4146 if (getcwd (t_string, sizeof(t_string)) == 0)
4152 tlen = strlen (t_string);
4156 tlen = sizeof (t_string) - 1;
4157 strncpy (t_string, temp, tlen);
4159 t_string[tlen] = '\0';
4161 #define ROOT_PATH(x) ((x)[0] == '/' && (x)[1] == 0)
4162 #define DOUBLE_SLASH_ROOT(x) ((x)[0] == '/' && (x)[1] == '/' && (x)[2] == 0)
4163 /* Abbreviate \W as ~ if $PWD == $HOME */
4164 if (c == 'W' && (((t = get_string_value ("HOME")) == 0) || STREQ (t, t_string) == 0))
4166 if (ROOT_PATH (t_string) == 0 && DOUBLE_SLASH_ROOT (t_string) == 0)
4168 t = strrchr (t_string, '/');
4170 strcpy (t_string, t + 1);
4174 #undef DOUBLE_SLASH_ROOT
4176 /* polite_directory_format is guaranteed to return a string
4177 no longer than PATH_MAX - 1 characters. */
4178 strcpy (t_string, polite_directory_format (t_string));
4180 /* If we're going to be expanding the prompt string later,
4181 quote the directory name. */
4182 if (promptvars || posixly_correct)
4183 /* Make sure that expand_prompt_string is called with a
4184 second argument of Q_DOUBLE_QUOTES if we use this
4186 temp = sh_backslash_quote_for_double_quotes (t_string);
4188 temp = savestring (t_string);
4194 if (current_user.user_name == 0)
4195 get_current_user_info ();
4196 temp = savestring (current_user.user_name);
4201 temp = savestring (current_host_name);
4202 if (c == 'h' && (t = (char *)strchr (temp, '.')))
4207 temp = itos (current_command_number);
4211 #if !defined (HISTORY)
4212 temp = savestring ("1");
4214 temp = itos (history_number ());
4215 #endif /* HISTORY */
4219 t = temp = (char *)xmalloc (3);
4220 if ((promptvars || posixly_correct) && (current_user.euid != 0))
4222 *t++ = current_user.euid == 0 ? '#' : '$';
4227 temp = itos (count_all_jobs ());
4231 #if defined (HAVE_TTYNAME)
4232 temp = (char *)ttyname (fileno (stdin));
4233 t = temp ? base_pathname (temp) : "tty";
4234 temp = savestring (t);
4236 temp = savestring ("tty");
4237 #endif /* !HAVE_TTYNAME */
4240 #if defined (READLINE)
4243 if (no_line_editing)
4248 temp = (char *)xmalloc (3);
4250 temp[1] = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
4253 #endif /* READLINE */
4259 temp = (char *)xmalloc (2);
4266 else /* (c == '\\') */
4273 temp = (char *)xmalloc (3);
4282 sub_append_string (temp, result, &result_index, &result_size);
4283 temp = (char *)NULL; /* Freed in sub_append_string (). */
4284 result[result_index] = '\0';
4290 RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
4291 result[result_index++] = c;
4292 result[result_index] = '\0';
4295 #else /* !PROMPT_STRING_DECODE */
4296 result = savestring (string);
4297 #endif /* !PROMPT_STRING_DECODE */
4299 /* Save the delimiter stack and point `dstack' to temp space so any
4300 command substitutions in the prompt string won't result in screwing
4301 up the parser's quoting state. */
4302 save_dstack = dstack;
4303 dstack = temp_dstack;
4304 dstack.delimiter_depth = 0;
4306 /* Perform variable and parameter expansion and command substitution on
4307 the prompt string. */
4308 if (promptvars || posixly_correct)
4310 last_exit_value = last_command_exit_value;
4311 list = expand_prompt_string (result, Q_DOUBLE_QUOTES);
4313 result = string_list (list);
4314 dispose_words (list);
4315 last_command_exit_value = last_exit_value;
4319 t = dequote_string (result);
4324 dstack = save_dstack;
4329 /************************************************
4333 ************************************************/
4335 /* Report a syntax error, and restart the parser. Call here for fatal
4341 report_syntax_error ((char *)NULL);
4347 error_token_from_token (token)
4352 if (t = find_token_in_alist (token, word_token_alist, 0))
4355 if (t = find_token_in_alist (token, other_token_alist, 0))
4359 /* This stuff is dicy and needs closer inspection */
4360 switch (current_token)
4363 case ASSIGNMENT_WORD:
4365 t = savestring (yylval.word->word);
4368 t = itos (yylval.number);
4371 if (yylval.word_list)
4372 t = string_list (yylval.word_list);
4374 case ARITH_FOR_EXPRS:
4375 if (yylval.word_list)
4376 t = string_list_internal (yylval.word_list, " ; ");
4379 t = (char *)NULL; /* punt */
4387 error_token_from_text ()
4392 t = shell_input_line;
4393 i = shell_input_line_index;
4397 if (i && t[i] == '\0')
4400 while (i && (whitespace (t[i]) || t[i] == '\n'))
4406 while (i && (member (t[i], " \n\t;|&") == 0))
4409 while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
4412 /* Return our idea of the offending token. */
4413 if (token_end || (i == 0 && token_end == 0))
4416 msg = substring (t, i, token_end);
4417 else /* one-character token */
4419 msg = (char *)xmalloc (2);
4429 print_offending_line ()
4434 msg = savestring (shell_input_line);
4435 token_end = strlen (msg);
4436 while (token_end && msg[token_end - 1] == '\n')
4437 msg[--token_end] = '\0';
4439 parser_error (line_number, "`%s'", msg);
4443 /* Report a syntax error with line numbers, etc.
4444 Call here for recoverable errors. If you have a message to print,
4445 then place it in MESSAGE, otherwise pass NULL and this will figure
4446 out an appropriate message for you. */
4448 report_syntax_error (message)
4455 parser_error (line_number, "%s", message);
4456 if (interactive && EOF_Reached)
4458 last_command_exit_value = EX_USAGE;
4462 /* If the line of input we're reading is not null, try to find the
4463 objectionable token. First, try to figure out what token the
4464 parser's complaining about by looking at current_token. */
4465 if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
4467 parser_error (line_number, _("syntax error near unexpected token `%s'"), msg);
4470 if (interactive == 0)
4471 print_offending_line ();
4473 last_command_exit_value = EX_USAGE;
4477 /* If looking at the current token doesn't prove fruitful, try to find the
4478 offending token by analyzing the text of the input line near the current
4479 input line index and report what we find. */
4480 if (shell_input_line && *shell_input_line)
4482 msg = error_token_from_text ();
4485 parser_error (line_number, _("syntax error near `%s'"), msg);
4489 /* If not interactive, print the line containing the error. */
4490 if (interactive == 0)
4491 print_offending_line ();
4495 msg = EOF_Reached ? _("syntax error: unexpected end of file") : _("syntax error");
4496 parser_error (line_number, "%s", msg);
4497 /* When the shell is interactive, this file uses EOF_Reached
4498 only for error reporting. Other mechanisms are used to
4499 decide whether or not to exit. */
4500 if (interactive && EOF_Reached)
4504 last_command_exit_value = EX_USAGE;
4507 /* ??? Needed function. ??? We have to be able to discard the constructs
4508 created during parsing. In the case of error, we want to return
4509 allocated objects to the memory pool. In the case of no error, we want
4510 to throw away the information about where the allocated objects live.
4511 (dispose_command () will actually free the command.) */
4513 discard_parser_constructs (error_p)
4518 /************************************************
4522 ************************************************/
4524 /* Do that silly `type "bye" to exit' stuff. You know, "ignoreeof". */
4526 /* A flag denoting whether or not ignoreeof is set. */
4529 /* The number of times that we have encountered an EOF character without
4530 another character intervening. When this gets above the limit, the
4531 shell terminates. */
4532 int eof_encountered = 0;
4534 /* The limit for eof_encountered. */
4535 int eof_encountered_limit = 10;
4537 /* If we have EOF as the only input unit, this user wants to leave
4538 the shell. If the shell is not interactive, then just leave.
4539 Otherwise, if ignoreeof is set, and we haven't done this the
4540 required number of times in a row, print a message. */
4542 handle_eof_input_unit ()
4546 /* shell.c may use this to decide whether or not to write out the
4547 history, among other things. We use it only for error reporting
4552 /* If the user wants to "ignore" eof, then let her do so, kind of. */
4555 if (eof_encountered < eof_encountered_limit)
4557 fprintf (stderr, _("Use \"%s\" to leave the shell.\n"),
4558 login_shell ? "logout" : "exit");
4560 /* Reset the parsing state. */
4561 last_read_token = current_token = '\n';
4562 /* Reset the prompt string to be $PS1. */
4563 prompt_string_pointer = (char **)NULL;
4569 /* In this case EOF should exit the shell. Do it now. */
4571 exit_builtin ((WORD_LIST *)NULL);
4575 /* We don't write history files, etc., for non-interactive shells. */
4580 /************************************************
4582 * STRING PARSING FUNCTIONS *
4584 ************************************************/
4586 /* It's very important that these two functions treat the characters
4587 between ( and ) identically. */
4589 static WORD_LIST parse_string_error;
4591 /* Take a string and run it through the shell parser, returning the
4592 resultant word list. Used by compound array assignment. */
4594 parse_string_to_word_list (s, flags, whom)
4600 int tok, orig_current_token, orig_line_number, orig_input_terminator;
4601 int orig_line_count;
4602 int old_echo_input, old_expand_aliases;
4603 #if defined (HISTORY)
4604 int old_remember_on_history, old_history_expansion_inhibited;
4607 #if defined (HISTORY)
4608 old_remember_on_history = remember_on_history;
4609 # if defined (BANG_HISTORY)
4610 old_history_expansion_inhibited = history_expansion_inhibited;
4612 bash_history_disable ();
4615 orig_line_number = line_number;
4616 orig_line_count = current_command_line_count;
4617 orig_input_terminator = shell_input_line_terminator;
4618 old_echo_input = echo_input_at_read;
4619 old_expand_aliases = expand_aliases;
4622 last_read_token = WORD; /* WORD to allow reserved words here */
4623 current_command_line_count = 0;
4624 echo_input_at_read = expand_aliases = 0;
4626 with_input_from_string (s, whom);
4627 wl = (WORD_LIST *)NULL;
4630 parser_state |= PST_COMPASSIGN;
4632 while ((tok = read_token (READ)) != yacc_EOF)
4634 if (tok == '\n' && *bash_input.location.string == '\0')
4636 if (tok == '\n') /* Allow newlines in compound assignments */
4638 if (tok != WORD && tok != ASSIGNMENT_WORD)
4640 line_number = orig_line_number + line_number - 1;
4641 orig_current_token = current_token;
4642 current_token = tok;
4643 yyerror (NULL); /* does the right thing */
4644 current_token = orig_current_token;
4647 wl = &parse_string_error;
4650 wl = make_word_list (yylval.word, wl);
4653 last_read_token = '\n';
4656 #if defined (HISTORY)
4657 remember_on_history = old_remember_on_history;
4658 # if defined (BANG_HISTORY)
4659 history_expansion_inhibited = old_history_expansion_inhibited;
4660 # endif /* BANG_HISTORY */
4661 #endif /* HISTORY */
4663 echo_input_at_read = old_echo_input;
4664 expand_aliases = old_expand_aliases;
4666 current_command_line_count = orig_line_count;
4667 shell_input_line_terminator = orig_input_terminator;
4670 parser_state &= ~PST_COMPASSIGN;
4672 if (wl == &parse_string_error)
4674 last_command_exit_value = EXECUTION_FAILURE;
4675 if (interactive_shell == 0 && posixly_correct)
4676 jump_to_top_level (FORCE_EOF);
4678 jump_to_top_level (DISCARD);
4681 return (REVERSE_LIST (wl, WORD_LIST *));
4685 parse_compound_assignment (retlenp)
4689 int tok, orig_line_number, orig_token_size, orig_last_token, assignok;
4690 char *saved_token, *ret;
4692 saved_token = token;
4693 orig_token_size = token_buffer_size;
4694 orig_line_number = line_number;
4695 orig_last_token = last_read_token;
4697 last_read_token = WORD; /* WORD to allow reserved words here */
4699 token = (char *)NULL;
4700 token_buffer_size = 0;
4702 assignok = parser_state&PST_ASSIGNOK; /* XXX */
4704 wl = (WORD_LIST *)NULL; /* ( */
4705 parser_state |= PST_COMPASSIGN;
4707 while ((tok = read_token (READ)) != ')')
4709 if (tok == '\n') /* Allow newlines in compound assignments */
4711 if (SHOULD_PROMPT ())
4715 if (tok != WORD && tok != ASSIGNMENT_WORD)
4717 current_token = tok; /* for error reporting */
4718 if (tok == yacc_EOF) /* ( */
4719 parser_error (orig_line_number, _("unexpected EOF while looking for matching `)'"));
4721 yyerror(NULL); /* does the right thing */
4724 wl = &parse_string_error;
4727 wl = make_word_list (yylval.word, wl);
4731 token = saved_token;
4732 token_buffer_size = orig_token_size;
4734 parser_state &= ~PST_COMPASSIGN;
4736 if (wl == &parse_string_error)
4738 last_command_exit_value = EXECUTION_FAILURE;
4739 last_read_token = '\n'; /* XXX */
4740 if (interactive_shell == 0 && posixly_correct)
4741 jump_to_top_level (FORCE_EOF);
4743 jump_to_top_level (DISCARD);
4746 last_read_token = orig_last_token; /* XXX - was WORD? */
4750 rl = REVERSE_LIST (wl, WORD_LIST *);
4751 ret = string_list (rl);
4758 *retlenp = (ret && *ret) ? strlen (ret) : 0;
4761 parser_state |= PST_ASSIGNOK;
4766 /************************************************
4768 * SAVING AND RESTORING PARTIAL PARSE STATE *
4770 ************************************************/
4773 save_parser_state (ps)
4774 sh_parser_state_t *ps;
4776 #if defined (ARRAY_VARS)
4781 ps = (sh_parser_state_t *)xmalloc (sizeof (sh_parser_state_t));
4783 return ((sh_parser_state_t *)NULL);
4785 ps->parser_state = parser_state;
4786 ps->token_state = save_token_state ();
4788 ps->input_line_terminator = shell_input_line_terminator;
4789 ps->eof_encountered = eof_encountered;
4791 ps->current_command_line_count = current_command_line_count;
4793 #if defined (HISTORY)
4794 ps->remember_on_history = remember_on_history;
4795 # if defined (BANG_HISTORY)
4796 ps->history_expansion_inhibited = history_expansion_inhibited;
4800 ps->last_command_exit_value = last_command_exit_value;
4801 #if defined (ARRAY_VARS)
4802 v = find_variable ("PIPESTATUS");
4803 if (v && array_p (v) && array_cell (v))
4804 ps->pipestatus = array_copy (array_cell (v));
4806 ps->pipestatus = (ARRAY *)NULL;
4809 ps->last_shell_builtin = last_shell_builtin;
4810 ps->this_shell_builtin = this_shell_builtin;
4812 ps->expand_aliases = expand_aliases;
4813 ps->echo_input_at_read = echo_input_at_read;
4819 restore_parser_state (ps)
4820 sh_parser_state_t *ps;
4822 #if defined (ARRAY_VARS)
4829 parser_state = ps->parser_state;
4830 if (ps->token_state)
4832 restore_token_state (ps->token_state);
4833 free (ps->token_state);
4836 shell_input_line_terminator = ps->input_line_terminator;
4837 eof_encountered = ps->eof_encountered;
4839 current_command_line_count = ps->current_command_line_count;
4841 #if defined (HISTORY)
4842 remember_on_history = ps->remember_on_history;
4843 # if defined (BANG_HISTORY)
4844 history_expansion_inhibited = ps->history_expansion_inhibited;
4848 last_command_exit_value = ps->last_command_exit_value;
4849 #if defined (ARRAY_VARS)
4850 v = find_variable ("PIPESTATUS");
4851 if (v && array_p (v) && array_cell (v))
4853 array_dispose (array_cell (v));
4854 var_setarray (v, ps->pipestatus);
4858 last_shell_builtin = ps->last_shell_builtin;
4859 this_shell_builtin = ps->this_shell_builtin;
4861 expand_aliases = ps->expand_aliases;
4862 echo_input_at_read = ps->echo_input_at_read;
4865 /************************************************
4867 * MULTIBYTE CHARACTER HANDLING *
4869 ************************************************/
4871 #if defined (HANDLE_MULTIBYTE)
4875 int i, previ, len, c;
4876 mbstate_t mbs, prevs;
4879 if (shell_input_line == NULL)
4881 len = strlen (shell_input_line); /* XXX - shell_input_line_len ? */
4882 FREE (shell_input_line_property);
4883 shell_input_line_property = (char *)xmalloc (len + 1);
4885 memset (&prevs, '\0', sizeof (mbstate_t));
4886 for (i = previ = 0; i < len; i++)
4890 c = shell_input_line[i];
4894 for (j = i; j < len; j++)
4895 shell_input_line_property[j] = 1;
4899 mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
4900 if (mbclen == 1 || mbclen == (size_t)-1)
4905 else if (mbclen == (size_t)-2)
4907 else if (mbclen > 1)
4915 /* XXX - what to do if mbrlen returns 0? (null wide character) */
4917 for (j = i; j < len; j++)
4918 shell_input_line_property[j] = 1;
4922 shell_input_line_property[i] = mbclen;
4925 #endif /* HANDLE_MULTIBYTE */