/* Yacc grammar for bash. */
-/* Copyright (C) 1989-2005 Free Software Foundation, Inc.
+/* Copyright (C) 1989-2006 Free Software Foundation, Inc.
This file is part of GNU Bash, the Bourne Again SHell.
extern int sourcelevel;
extern int posixly_correct;
extern int last_command_exit_value;
-extern int interrupt_immediately;
extern char *shell_name, *current_host_name;
extern char *dist_version;
extern int patch_level;
#endif
static void print_prompt __P((void));
-#if defined (HISTORY)
-char *history_delimiting_chars __P((void));
-#endif
-
#if defined (HANDLE_MULTIBYTE)
static void set_line_mbstate __P((void));
static char *shell_input_line_property = NULL;
#define PST_CMDTOKEN 0x1000 /* command token OK - unused */
#define PST_COMPASSIGN 0x2000 /* parsing x=(...) compound assignment */
#define PST_ASSIGNOK 0x4000 /* assignment statement ok in this context */
+#define PST_REGEXP 0x8000 /* parsing an ERE/BRE as a single word */
/* Initial size to allocate for tokens, and the
amount to grow them by. */
old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
interrupt_immediately++;
}
+ terminate_immediately = 1;
current_readline_line = readline (current_readline_prompt ?
current_readline_prompt : "");
+ terminate_immediately = 0;
if (signal_is_ignored (SIGINT) == 0 && old_sigint)
{
interrupt_immediately--;
if (bash_input.location.file)
{
if (interactive)
- interrupt_immediately++;
+ {
+ interrupt_immediately++;
+ terminate_immediately++;
+ }
result = getc_with_restart (bash_input.location.file);
if (interactive)
- interrupt_immediately--;
+ {
+ interrupt_immediately--;
+ terminate_immediately--;
+ }
}
return (result);
}
register int i;
int c;
unsigned char uc;
- static int mustpop = 0;
QUIT;
}
void
-execute_prompt_command (command)
- char *command;
+execute_variable_command (command, vname)
+ char *command, *vname;
{
char *last_lastarg;
sh_parser_state_t ps;
if (last_lastarg)
last_lastarg = savestring (last_lastarg);
- parse_and_execute (savestring (command), "PROMPT_COMMAND", SEVAL_NONINT|SEVAL_NOHIST);
+ parse_and_execute (savestring (command), vname, SEVAL_NONINT|SEVAL_NOHIST);
restore_parser_state (&ps);
bind_variable ("_", last_lastarg, 0);
#endif /* ALIAS */
/* Read a single word from input. Start by skipping blanks. */
- while ((character = shell_getc (1)) != EOF && whitespace (character))
+ while ((character = shell_getc (1)) != EOF && shellblank (character))
;
if (character == EOF)
return (character);
}
+ if (parser_state & PST_REGEXP)
+ goto tokword;
+
/* Shell meta-characters. */
if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
{
if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
return (character);
+tokword:
/* Okay, if we got this far, we have to read a word. Read one,
and then check it against the known ones. */
result = read_token_word (character);
#define P_ALLOWESC 0x02
#define P_DQUOTE 0x04
#define P_COMMAND 0x08 /* parsing a command, so look for comments */
+#define P_BACKQUOTE 0x10 /* parsing a backquoted command substitution */
static char matched_pair_error;
static char *
int *lenp, flags;
{
int count, ch, was_dollar, in_comment, check_comment;
- int pass_next_character, nestlen, ttranslen, start_lineno;
+ int pass_next_character, backq_backslash, nestlen, ttranslen, start_lineno;
char *ret, *nestret, *ttrans;
int retind, retsize, rflags;
+/* itrace("parse_matched_pair: open = %c close = %c", open, close); */
count = 1;
- pass_next_character = was_dollar = in_comment = 0;
- check_comment = (flags & P_COMMAND) && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0;
+ pass_next_character = backq_backslash = was_dollar = in_comment = 0;
+ check_comment = (flags & P_COMMAND) && qc != '`' && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0;
/* RFLAGS is the set of flags we want to pass to recursive calls. */
rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
start_lineno = line_number;
while (count)
{
-#if 0
- ch = shell_getc ((qc != '\'' || (flags & P_ALLOWESC)) && pass_next_character == 0);
-#else
- ch = shell_getc (qc != '\'' && pass_next_character == 0);
-#endif
+ ch = shell_getc (qc != '\'' && pass_next_character == 0 && backq_backslash == 0);
+
if (ch == EOF)
{
free (ret);
continue;
}
- /* Not exactly right yet */
- else if (check_comment && in_comment == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || whitespace (ret[retind -1])))
+ /* Not exactly right yet, should handle shell metacharacters, too. If
+ any changes are made to this test, make analogous changes to subst.c:
+ extract_delimited_string(). */
+ else if MBTEST(check_comment && in_comment == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || whitespace (ret[retind - 1])))
in_comment = 1;
+ /* last char was backslash inside backquoted command substitution */
+ if (backq_backslash)
+ {
+ backq_backslash = 0;
+ /* Placeholder for adding special characters */
+ }
+
if (pass_next_character) /* last char was backslash */
{
pass_next_character = 0;
}
else if MBTEST(ch == close) /* ending delimiter */
count--;
-#if 1
/* handle nested ${...} specially. */
else if MBTEST(open != close && was_dollar && open == '{' && ch == open) /* } */
count++;
-#endif
else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
count++;
{
if MBTEST((flags & P_ALLOWESC) && ch == '\\')
pass_next_character++;
+#if 0
+ else if MBTEST((flags & P_BACKQUOTE) && ch == '\\')
+ backq_backslash++;
+#endif
continue;
}
}
FREE (nestret);
}
+#if 0
else if MBTEST(qc == '`' && (ch == '"' || ch == '\'') && in_comment == 0)
{
- nestret = parse_matched_pair (0, ch, ch, &nestlen, rflags);
+ /* Add P_BACKQUOTE so backslash quotes the next character and
+ shell_getc does the right thing with \<newline>. We do this for
+ a measure of backwards compatibility -- it's not strictly the
+ right POSIX thing. */
+ nestret = parse_matched_pair (0, ch, ch, &nestlen, rflags|P_BACKQUOTE);
goto add_nestret;
}
- else if MBTEST(was_dollar && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
+#endif
+ else if MBTEST(open != '`' && was_dollar && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
/* check for $(), $[], or ${} inside quoted string. */
{
if (open == ch) /* undo previous increment */
count--;
if (ch == '(') /* ) */
- nestret = parse_matched_pair (0, '(', ')', &nestlen, rflags);
+ nestret = parse_matched_pair (0, '(', ')', &nestlen, rflags & ~P_DQUOTE);
else if (ch == '{') /* } */
nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
else if (ch == '[') /* ] */
parse_dparen (c)
int c;
{
- int cmdtyp, len, sline;
- char *wval, *wv2;
+ int cmdtyp, sline;
+ char *wval;
WORD_DESC *wd;
#if defined (ARITH_FOR_COMMAND)
{
wd = alloc_word_desc ();
wd->word = wval;
- wd = make_word (wval);
yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
return (ARITH_FOR_EXPRS);
}
if (tok == WORD && test_binop (yylval.word->word))
op = yylval.word;
#if defined (COND_REGEXP)
- else if (tok == WORD && STREQ (yylval.word->word,"=~"))
- op = yylval.word;
+ else if (tok == WORD && STREQ (yylval.word->word, "=~"))
+ {
+ op = yylval.word;
+ parser_state |= PST_REGEXP;
+ }
#endif
else if (tok == '<' || tok == '>')
op = make_word_from_token (tok); /* ( */
/* rhs */
tok = read_token (READ);
+ parser_state &= ~PST_REGEXP;
if (tok == WORD)
{
tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
if (pass_next_character)
{
pass_next_character = 0;
- goto got_character;
+ goto got_escaped_character;
}
cd = current_delimiter (dstack);
goto next_character;
}
+#ifdef COND_REGEXP
+ /* When parsing a regexp as a single word inside a conditional command,
+ we need to special-case characters special to both the shell and
+ regular expressions. Right now, that is only '(' and '|'. */ /*)*/
+ if MBTEST((parser_state & PST_REGEXP) && (character == '(' || character == '|')) /*)*/
+ {
+ if (character == '|')
+ goto got_character;
+
+ push_delimiter (dstack, character);
+ ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
+ pop_delimiter (dstack);
+ if (ttok == &matched_pair_error)
+ return -1; /* Bail immediately. */
+ RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
+ token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
+ token[token_index++] = character;
+ strcpy (token + token_index, ttok);
+ token_index += ttoklen;
+ FREE (ttok);
+ dollar_present = all_digit_token = 0;
+ goto next_character;
+ }
+#endif /* COND_REGEXP */
+
#ifdef EXTENDED_GLOB
/* Parse a ksh-style extended pattern matching specification. */
- if (extended_glob && PATTERN_CHAR (character))
+ if MBTEST(extended_glob && PATTERN_CHAR (character))
{
peek_char = shell_getc (1);
if MBTEST(peek_char == '(') /* ) */
}
else
{
- /* Try to locale)-expand the converted string. */
+ /* Try to locale-expand the converted string. */
ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
free (ttok);
FREE (ttok);
all_digit_token = 0;
compound_assignment = 1;
-#if 0
+#if 1
goto next_character;
#else
goto got_token; /* ksh93 seems to do this */
got_character:
- all_digit_token &= DIGIT (character);
- dollar_present |= character == '$';
-
if (character == CTLESC || character == CTLNUL)
token[token_index++] = CTLESC;
+ got_escaped_character:
+
+ all_digit_token &= DIGIT (character);
+ dollar_present |= character == '$';
+
token[token_index++] = character;
RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
if (dollar_present)
the_word->flags |= W_HASDOLLAR;
if (quoted)
- the_word->flags |= W_QUOTED;
- if (compound_assignment)
+ the_word->flags |= W_QUOTED; /*(*/
+ if (compound_assignment && token[token_index-1] == ')')
the_word->flags |= W_COMPASSIGN;
/* A word is an assignment if it appears at the beginning of a
simple command, or after another assignment word. This is
struct builtin *b;
b = builtin_address_internal (token, 0);
if (b && (b->flags & ASSIGNMENT_BUILTIN))
- parser_state |= PST_ASSIGNOK;
+ parser_state |= PST_ASSIGNOK;
+ else if (STREQ (token, "eval") || STREQ (token, "let"))
+ parser_state |= PST_ASSIGNOK;
}
yylval.word = the_word;
int last_exit_value;
#if defined (PROMPT_STRING_DECODE)
int result_size, result_index;
- int c, n;
+ int c, n, i;
char *temp, octal_string[4];
struct tm *tm;
time_t the_time;
case 'W':
{
/* Use the value of PWD because it is much more efficient. */
- char t_string[PATH_MAX], *t;
+ char t_string[PATH_MAX];
int tlen;
temp = get_string_value ("PWD");
break;
}
temp = (char *)xmalloc (3);
- temp[0] = '\001';
- temp[1] = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
- temp[2] = '\0';
+ n = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
+ i = 0;
+ if (n == CTLESC || n == CTLNUL)
+ temp[i++] = CTLESC;
+ temp[i++] = n;
+ temp[i] = '\0';
goto add_string;
#endif /* READLINE */
if (promptvars || posixly_correct)
{
last_exit_value = last_command_exit_value;
- list = expand_prompt_string (result, Q_DOUBLE_QUOTES);
+ list = expand_prompt_string (result, Q_DOUBLE_QUOTES, 0);
free (result);
result = string_list (list);
dispose_words (list);
}
static char *
-error_token_from_token (token)
- int token;
+error_token_from_token (tok)
+ int tok;
{
char *t;
- if (t = find_token_in_alist (token, word_token_alist, 0))
+ if (t = find_token_in_alist (tok, word_token_alist, 0))
return t;
- if (t = find_token_in_alist (token, other_token_alist, 0))
+ if (t = find_token_in_alist (tok, other_token_alist, 0))
return t;
t = (char *)NULL;
int *retlenp;
{
WORD_LIST *wl, *rl;
- int tok, orig_line_number, orig_token_size;
+ int tok, orig_line_number, orig_token_size, orig_last_token, assignok;
char *saved_token, *ret;
saved_token = token;
orig_token_size = token_buffer_size;
orig_line_number = line_number;
+ orig_last_token = last_read_token;
last_read_token = WORD; /* WORD to allow reserved words here */
token = (char *)NULL;
token_buffer_size = 0;
+ assignok = parser_state&PST_ASSIGNOK; /* XXX */
+
wl = (WORD_LIST *)NULL; /* ( */
parser_state |= PST_COMPASSIGN;
jump_to_top_level (DISCARD);
}
- last_read_token = WORD;
+ last_read_token = orig_last_token; /* XXX - was WORD? */
+
if (wl)
{
rl = REVERSE_LIST (wl, WORD_LIST *);
if (retlenp)
*retlenp = (ret && *ret) ? strlen (ret) : 0;
+
+ if (assignok)
+ parser_state |= PST_ASSIGNOK;
+
return ret;
}
projects / platform / upstream / bash.git / blobdiff