diff -r 71503088f51b -r f880f219c566 openpkg/bash.patch.vendor --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/openpkg/bash.patch.vendor Tue Jul 31 12:23:42 2012 +0200 @@ -0,0 +1,1507 @@ +Index: assoc.c +--- assoc.c.orig 2009-08-06 02:19:40.000000000 +0200 ++++ assoc.c 2012-06-27 10:31:02.000000000 +0200 +@@ -77,6 +77,11 @@ + b = hash_search (key, hash, HASH_CREATE); + if (b == 0) + return -1; ++ /* If we are overwriting an existing element's value, we're not going to ++ use the key. Nothing in the array assignment code path frees the key ++ string, so we can free it here to avoid a memory leak. */ ++ if (b->key != key) ++ free (key); + FREE (b->data); + b->data = value ? savestring (value) : (char *)0; + return (0); +Index: bashline.c +--- bashline.c.orig 2011-01-16 21:32:47.000000000 +0100 ++++ bashline.c 2012-06-27 10:31:03.000000000 +0200 +@@ -121,6 +121,9 @@ + static int filename_completion_ignore __P((char **)); + static int bash_push_line __P((void)); + ++static rl_icppfunc_t *save_directory_hook __P((void)); ++static void reset_directory_hook __P((rl_icppfunc_t *)); ++ + static void cleanup_expansion_error __P((void)); + static void maybe_make_readline_line __P((char *)); + static void set_up_new_line __P((char *)); +@@ -243,10 +246,17 @@ + /* Perform spelling correction on directory names during word completion */ + int dircomplete_spelling = 0; + ++/* Expand directory names during word/filename completion. */ ++int dircomplete_expand = 0; ++int dircomplete_expand_relpath = 0; ++ + static char *bash_completer_word_break_characters = " \t\n\"'@><=;|&(:"; + static char *bash_nohostname_word_break_characters = " \t\n\"'><=;|&(:"; + /* )) */ + ++static const char *default_filename_quote_characters = " \t\n\\\"'@<>=;|&()#$`?*[!:{~"; /*}*/ ++static char *custom_filename_quote_characters = 0; ++ + static rl_hook_func_t *old_rl_startup_hook = (rl_hook_func_t *)NULL; + + static int dot_in_path = 0; +@@ -501,7 +511,7 @@ + + /* Tell the completer that we might want to follow symbolic links or + do other expansion on directory names. */ +- rl_directory_rewrite_hook = bash_directory_completion_hook; ++ set_directory_hook (); + + rl_filename_rewrite_hook = bash_filename_rewrite_hook; + +@@ -529,7 +539,7 @@ + enable_hostname_completion (perform_hostname_completion); + + /* characters that need to be quoted when appearing in filenames. */ +- rl_filename_quote_characters = " \t\n\\\"'@<>=;|&()#$`?*[!:{~"; /*}*/ ++ rl_filename_quote_characters = default_filename_quote_characters; + + rl_filename_quoting_function = bash_quote_filename; + rl_filename_dequoting_function = bash_dequote_filename; +@@ -564,8 +574,10 @@ + tilde_initialize (); + rl_attempted_completion_function = attempt_shell_completion; + rl_completion_entry_function = NULL; +- rl_directory_rewrite_hook = bash_directory_completion_hook; + rl_ignore_some_completions_function = filename_completion_ignore; ++ rl_filename_quote_characters = default_filename_quote_characters; ++ ++ set_directory_hook (); + } + + /* Contains the line to push into readline. */ +@@ -1279,6 +1291,9 @@ + matches = (char **)NULL; + rl_ignore_some_completions_function = filename_completion_ignore; + ++ rl_filename_quote_characters = default_filename_quote_characters; ++ set_directory_hook (); ++ + /* Determine if this could be a command word. It is if it appears at + the start of the line (ignoring preceding whitespace), or if it + appears after a character that separates commands. It cannot be a +@@ -1591,6 +1606,12 @@ + } + else + { ++ if (dircomplete_expand && dot_or_dotdot (filename_hint)) ++ { ++ dircomplete_expand = 0; ++ set_directory_hook (); ++ dircomplete_expand = 1; ++ } + mapping_over = 4; + goto inner; + } +@@ -1791,6 +1812,9 @@ + + inner: + val = rl_filename_completion_function (filename_hint, istate); ++ if (mapping_over == 4 && dircomplete_expand) ++ set_directory_hook (); ++ + istate = 1; + + if (val == 0) +@@ -2693,6 +2717,52 @@ + return conv; + } + ++/* Functions to save and restore the appropriate directory hook */ ++/* This is not static so the shopt code can call it */ ++void ++set_directory_hook () ++{ ++ if (dircomplete_expand) ++ { ++ rl_directory_completion_hook = bash_directory_completion_hook; ++ rl_directory_rewrite_hook = (rl_icppfunc_t *)0; ++ } ++ else ++ { ++ rl_directory_rewrite_hook = bash_directory_completion_hook; ++ rl_directory_completion_hook = (rl_icppfunc_t *)0; ++ } ++} ++ ++static rl_icppfunc_t * ++save_directory_hook () ++{ ++ rl_icppfunc_t *ret; ++ ++ if (dircomplete_expand) ++ { ++ ret = rl_directory_completion_hook; ++ rl_directory_completion_hook = (rl_icppfunc_t *)NULL; ++ } ++ else ++ { ++ ret = rl_directory_rewrite_hook; ++ rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL; ++ } ++ ++ return ret; ++} ++ ++static void ++restore_directory_hook (hookf) ++ rl_icppfunc_t *hookf; ++{ ++ if (dircomplete_expand) ++ rl_directory_completion_hook = hookf; ++ else ++ rl_directory_rewrite_hook = hookf; ++} ++ + /* Handle symbolic link references and other directory name + expansions while hacking completion. This should return 1 if it modifies + the DIRNAME argument, 0 otherwise. It should make sure not to modify +@@ -2702,20 +2772,31 @@ + char **dirname; + { + char *local_dirname, *new_dirname, *t; +- int return_value, should_expand_dirname; ++ int return_value, should_expand_dirname, nextch, closer; + WORD_LIST *wl; + struct stat sb; + +- return_value = should_expand_dirname = 0; ++ return_value = should_expand_dirname = nextch = closer = 0; + local_dirname = *dirname; + +- if (mbschr (local_dirname, '$')) +- should_expand_dirname = 1; ++ if (t = mbschr (local_dirname, '$')) ++ { ++ should_expand_dirname = '$'; ++ nextch = t[1]; ++ /* Deliberately does not handle the deprecated $[...] arithmetic ++ expansion syntax */ ++ if (nextch == '(') ++ closer = ')'; ++ else if (nextch == '{') ++ closer = '}'; ++ else ++ nextch = 0; ++ } + else + { + t = mbschr (local_dirname, '`'); + if (t && unclosed_pair (local_dirname, strlen (local_dirname), "`") == 0) +- should_expand_dirname = 1; ++ should_expand_dirname = '`'; + } + + #if defined (HAVE_LSTAT) +@@ -2739,6 +2820,23 @@ + free (new_dirname); + dispose_words (wl); + local_dirname = *dirname; ++ /* XXX - change rl_filename_quote_characters here based on ++ should_expand_dirname/nextch/closer. This is the only place ++ custom_filename_quote_characters is modified. */ ++ if (rl_filename_quote_characters && *rl_filename_quote_characters) ++ { ++ int i, j, c; ++ i = strlen (default_filename_quote_characters); ++ custom_filename_quote_characters = xrealloc (custom_filename_quote_characters, i+1); ++ for (i = j = 0; c = default_filename_quote_characters[i]; i++) ++ { ++ if (c == should_expand_dirname || c == nextch || c == closer) ++ continue; ++ custom_filename_quote_characters[j++] = c; ++ } ++ custom_filename_quote_characters[j] = '\0'; ++ rl_filename_quote_characters = custom_filename_quote_characters; ++ } + } + else + { +@@ -2758,11 +2856,31 @@ + local_dirname = *dirname = new_dirname; + } + ++ /* no_symbolic_links == 0 -> use (default) logical view of the file system. ++ local_dirname[0] == '.' && local_dirname[1] == '/' means files in the ++ current directory (./). ++ local_dirname[0] == '.' && local_dirname[1] == 0 means relative pathnames ++ in the current directory (e.g., lib/sh). ++ XXX - should we do spelling correction on these? */ ++ ++ /* This is test as it was in bash-4.2: skip relative pathnames in current ++ directory. Change test to ++ (local_dirname[0] != '.' || (local_dirname[1] && local_dirname[1] != '/')) ++ if we want to skip paths beginning with ./ also. */ + if (no_symbolic_links == 0 && (local_dirname[0] != '.' || local_dirname[1])) + { + char *temp1, *temp2; + int len1, len2; + ++ /* If we have a relative path ++ (local_dirname[0] != '/' && local_dirname[0] != '.') ++ that is canonical after appending it to the current directory, then ++ temp1 = temp2+'/' ++ That is, ++ strcmp (temp1, temp2) == 0 ++ after adding a slash to temp2 below. It should be safe to not ++ change those. ++ */ + t = get_working_directory ("symlink-hook"); + temp1 = make_absolute (local_dirname, t); + free (t); +@@ -2797,7 +2915,15 @@ + temp2[len2 + 1] = '\0'; + } + } +- return_value |= STREQ (local_dirname, temp2) == 0; ++ ++ /* dircomplete_expand_relpath == 0 means we want to leave relative ++ pathnames that are unchanged by canonicalization alone. ++ *local_dirname != '/' && *local_dirname != '.' == relative pathname ++ (consistent with general.c:absolute_pathname()) ++ temp1 == temp2 (after appending a slash to temp2) means the pathname ++ is not changed by canonicalization as described above. */ ++ if (dircomplete_expand_relpath || ((local_dirname[0] != '/' && local_dirname[0] != '.') && STREQ (temp1, temp2) == 0)) ++ return_value |= STREQ (local_dirname, temp2) == 0; + free (local_dirname); + *dirname = temp2; + free (temp1); +@@ -3002,12 +3128,13 @@ + + orig_func = rl_completion_entry_function; + orig_attempt_func = rl_attempted_completion_function; +- orig_dir_func = rl_directory_rewrite_hook; + orig_ignore_func = rl_ignore_some_completions_function; + orig_rl_completer_word_break_characters = rl_completer_word_break_characters; ++ ++ orig_dir_func = save_directory_hook (); ++ + rl_completion_entry_function = rl_filename_completion_function; + rl_attempted_completion_function = (rl_completion_func_t *)NULL; +- rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL; + rl_ignore_some_completions_function = filename_completion_ignore; + rl_completer_word_break_characters = " \t\n\"\'"; + +@@ -3015,10 +3142,11 @@ + + rl_completion_entry_function = orig_func; + rl_attempted_completion_function = orig_attempt_func; +- rl_directory_rewrite_hook = orig_dir_func; + rl_ignore_some_completions_function = orig_ignore_func; + rl_completer_word_break_characters = orig_rl_completer_word_break_characters; + ++ restore_directory_hook (orig_dir_func); ++ + return r; + } + +Index: bashline.h +--- bashline.h.orig 2009-01-04 20:32:22.000000000 +0100 ++++ bashline.h 2012-06-27 10:31:03.000000000 +0200 +@@ -33,10 +33,15 @@ + extern void bashline_reinitialize __P((void)); + extern int bash_re_edit __P((char *)); + ++extern void bashline_set_event_hook __P((void)); ++extern void bashline_reset_event_hook __P((void)); ++ + extern int bind_keyseq_to_unix_command __P((char *)); + + extern char **bash_default_completion __P((const char *, int, int, int, int)); + ++void set_directory_hook __P((void)); ++ + /* Used by programmable completion code. */ + extern char *command_word_completion_function __P((const char *, int)); + extern char *bash_groupname_completion_function __P((const char *, int)); +Index: builtins/declare.def +--- builtins/declare.def.orig 2010-05-31 00:25:21.000000000 +0200 ++++ builtins/declare.def 2012-06-27 10:31:02.000000000 +0200 +@@ -513,6 +513,11 @@ + *subscript_start = '['; /* ] */ + var = assign_array_element (name, value, 0); /* XXX - not aflags */ + *subscript_start = '\0'; ++ if (var == 0) /* some kind of assignment error */ ++ { ++ assign_error++; ++ NEXT_VARIABLE (); ++ } + } + else if (simple_array_assign) + { +Index: builtins/fc.def +--- builtins/fc.def.orig 2010-05-31 00:25:38.000000000 +0200 ++++ builtins/fc.def 2012-06-27 10:31:02.000000000 +0200 +@@ -304,7 +304,7 @@ + last_hist = i - rh - hist_last_line_added; + + /* XXX */ +- if (saved_command_line_count > 0 && i == last_hist && hlist[last_hist] == 0) ++ if (i == last_hist && hlist[last_hist] == 0) + while (last_hist >= 0 && hlist[last_hist] == 0) + last_hist--; + if (last_hist < 0) +@@ -475,7 +475,7 @@ + HIST_ENTRY **hlist; + { + int sign, n, clen, rh; +- register int i, j; ++ register int i, j, last_hist; + register char *s; + + sign = 1; +@@ -495,7 +495,15 @@ + has been enabled (interactive or not) should use it in the last_hist + calculation as if it were on. */ + rh = remember_on_history || ((subshell_environment & SUBSHELL_COMSUB) && enable_history_list); +- i -= rh + hist_last_line_added; ++ last_hist = i - rh - hist_last_line_added; ++ ++ if (i == last_hist && hlist[last_hist] == 0) ++ while (last_hist >= 0 && hlist[last_hist] == 0) ++ last_hist--; ++ if (last_hist < 0) ++ return (-1); ++ ++ i = last_hist; + + /* No specification defaults to most recent command. */ + if (command == NULL) +Index: builtins/printf.def +--- builtins/printf.def.orig 2010-11-23 16:02:55.000000000 +0100 ++++ builtins/printf.def 2012-06-27 10:31:02.000000000 +0200 +@@ -255,6 +255,8 @@ + #endif + { + vflag = 1; ++ if (vbsize == 0) ++ vbuf = xmalloc (vbsize = 16); + vblen = 0; + if (vbuf) + vbuf[0] = 0; +@@ -465,6 +467,9 @@ + secs = shell_start_time; /* roughly $SECONDS */ + else + secs = arg; ++#if defined (HAVE_TZSET) ++ sv_tz ("TZ"); /* XXX -- just make sure */ ++#endif + tm = localtime (&secs); + n = strftime (timebuf, sizeof (timebuf), timefmt, tm); + free (timefmt); +Index: builtins/read.def +--- builtins/read.def.orig 2011-01-04 17:43:36.000000000 +0100 ++++ builtins/read.def 2012-06-27 10:31:02.000000000 +0200 +@@ -642,6 +642,12 @@ + xfree (input_string); + return EXECUTION_FAILURE; /* readonly or noassign */ + } ++ if (assoc_p (var)) ++ { ++ builtin_error (_("%s: cannot convert associative to indexed array"), arrayname); ++ xfree (input_string); ++ return EXECUTION_FAILURE; /* existing associative array */ ++ } + array_flush (array_cell (var)); + + alist = list_string (input_string, ifs_chars, 0); +@@ -731,7 +737,7 @@ + xfree (t1); + } + else +- var = bind_read_variable (varname, t); ++ var = bind_read_variable (varname, t ? t : ""); + } + else + { +@@ -792,7 +798,7 @@ + xfree (t); + } + else +- var = bind_read_variable (list->word->word, input_string); ++ var = bind_read_variable (list->word->word, input_string ? input_string : ""); + + if (var) + { +Index: builtins/shopt.def +--- builtins/shopt.def.orig 2010-07-03 04:42:44.000000000 +0200 ++++ builtins/shopt.def 2012-06-27 10:31:03.000000000 +0200 +@@ -61,6 +61,10 @@ + #include "common.h" + #include "bashgetopt.h" + ++#if defined (READLINE) ++# include "../bashline.h" ++#endif ++ + #if defined (HISTORY) + # include "../bashhist.h" + #endif +@@ -94,7 +98,7 @@ + extern int hist_verify, history_reediting, perform_hostname_completion; + extern int no_empty_command_completion; + extern int force_fignore; +-extern int dircomplete_spelling; ++extern int dircomplete_spelling, dircomplete_expand; + + extern int enable_hostname_completion __P((int)); + #endif +@@ -121,6 +125,10 @@ + static int set_restricted_shell __P((char *, int)); + #endif + ++#if defined (READLINE) ++static int shopt_set_complete_direxpand __P((char *, int)); ++#endif ++ + static int shopt_login_shell; + static int shopt_compat31; + static int shopt_compat32; +@@ -150,6 +158,7 @@ + { "compat40", &shopt_compat40, set_compatibility_level }, + { "compat41", &shopt_compat41, set_compatibility_level }, + #if defined (READLINE) ++ { "direxpand", &dircomplete_expand, shopt_set_complete_direxpand }, + { "dirspell", &dircomplete_spelling, (shopt_set_func_t *)NULL }, + #endif + { "dotglob", &glob_dot_filenames, (shopt_set_func_t *)NULL }, +@@ -535,6 +544,17 @@ + return 0; + } + ++#if defined (READLINE) ++static int ++shopt_set_complete_direxpand (option_name, mode) ++ char *option_name; ++ int mode; ++{ ++ set_directory_hook (); ++ return 0; ++} ++#endif ++ + #if defined (RESTRICTED_SHELL) + /* Don't allow the value of restricted_shell to be modified. */ + +Index: command.h +--- command.h.orig 2010-08-03 01:36:51.000000000 +0200 ++++ command.h 2012-06-27 10:31:02.000000000 +0200 +@@ -97,6 +97,7 @@ + #define W_HASCTLESC 0x200000 /* word contains literal CTLESC characters */ + #define W_ASSIGNASSOC 0x400000 /* word looks like associative array assignment */ + #define W_ARRAYIND 0x800000 /* word is an array index being expanded */ ++#define W_ASSNGLOBAL 0x1000000 /* word is a global assignment to declare (declare/typeset -g) */ + + /* Possible values for subshell_environment */ + #define SUBSHELL_ASYNC 0x01 /* subshell caused by `command &' */ +Index: doc/bash.1 +--- doc/bash.1.orig 2011-01-16 21:31:39.000000000 +0100 ++++ doc/bash.1 2012-06-27 10:31:03.000000000 +0200 +@@ -8948,6 +8948,16 @@ + quoted. This is the behavior of posix mode through version 4.1. + The default bash behavior remains as in previous versions. + .TP 8 ++.B direxpand ++If set, ++.B bash ++replaces directory names with the results of word expansion when performing ++filename completion. This changes the contents of the readline editing ++buffer. ++If not set, ++.B bash ++attempts to preserve what the user typed. ++.TP 8 + .B dirspell + If set, + .B bash +Index: doc/bashref.texi +--- doc/bashref.texi.orig 2011-01-16 21:31:57.000000000 +0100 ++++ doc/bashref.texi 2012-06-27 10:31:03.000000000 +0200 +@@ -4535,6 +4535,13 @@ + quoted. This is the behavior of @sc{posix} mode through version 4.1. + The default Bash behavior remains as in previous versions. + ++@item direxpand ++If set, Bash ++replaces directory names with the results of word expansion when performing ++filename completion. This changes the contents of the readline editing ++buffer. ++If not set, Bash attempts to preserve what the user typed. ++ + @item dirspell + If set, Bash + attempts spelling correction on directory names during word completion +Index: error.c +--- error.c.orig 2009-08-22 04:31:31.000000000 +0200 ++++ error.c 2012-06-27 10:31:02.000000000 +0200 +@@ -200,7 +200,11 @@ + + va_end (args); + if (exit_immediately_on_error) +- exit_shell (1); ++ { ++ if (last_command_exit_value == 0) ++ last_command_exit_value = 1; ++ exit_shell (last_command_exit_value); ++ } + } + + void +Index: execute_cmd.c +--- execute_cmd.c.orig 2011-02-09 23:32:25.000000000 +0100 ++++ execute_cmd.c 2012-06-27 10:31:03.000000000 +0200 +@@ -2196,6 +2196,7 @@ + if (ignore_return && cmd) + cmd->flags |= CMD_IGNORE_RETURN; + ++#if defined (JOB_CONTROL) + lastpipe_flag = 0; + begin_unwind_frame ("lastpipe-exec"); + lstdin = -1; +@@ -2204,7 +2205,7 @@ + current shell environment. */ + if (lastpipe_opt && job_control == 0 && asynchronous == 0 && pipe_out == NO_PIPE && prev > 0) + { +- lstdin = move_to_high_fd (0, 0, 255); ++ lstdin = move_to_high_fd (0, 1, -1); + if (lstdin > 0) + { + do_piping (prev, pipe_out); +@@ -2215,15 +2216,19 @@ + lastpipe_jid = stop_pipeline (0, (COMMAND *)NULL); /* XXX */ + add_unwind_protect (lastpipe_cleanup, lastpipe_jid); + } +- cmd->flags |= CMD_LASTPIPE; ++ if (cmd) ++ cmd->flags |= CMD_LASTPIPE; + } + if (prev >= 0) + add_unwind_protect (close, prev); ++#endif + + exec_result = execute_command_internal (cmd, asynchronous, prev, pipe_out, fds_to_close); + ++#if defined (JOB_CONTROL) + if (lstdin > 0) + restore_stdin (lstdin); ++#endif + + if (prev >= 0) + close (prev); +@@ -2246,7 +2251,9 @@ + unfreeze_jobs_list (); + } + ++#if defined (JOB_CONTROL) + discard_unwind_frame ("lastpipe-exec"); ++#endif + + return (exec_result); + } +@@ -3575,13 +3582,13 @@ + { + WORD_LIST *w; + struct builtin *b; +- int assoc; ++ int assoc, global; + + if (words == 0) + return; + + b = 0; +- assoc = 0; ++ assoc = global = 0; + + for (w = words; w; w = w->next) + if (w->word->flags & W_ASSIGNMENT) +@@ -3598,12 +3605,17 @@ + #if defined (ARRAY_VARS) + if (assoc) + w->word->flags |= W_ASSIGNASSOC; ++ if (global) ++ w->word->flags |= W_ASSNGLOBAL; + #endif + } + #if defined (ARRAY_VARS) + /* Note that we saw an associative array option to a builtin that takes + assignment statements. This is a bit of a kludge. */ +- else if (w->word->word[0] == '-' && strchr (w->word->word, 'A')) ++ else if (w->word->word[0] == '-' && (strchr (w->word->word+1, 'A') || strchr (w->word->word+1, 'g'))) ++#else ++ else if (w->word->word[0] == '-' && strchr (w->word->word+1, 'g')) ++#endif + { + if (b == 0) + { +@@ -3613,10 +3625,11 @@ + else if (b && (b->flags & ASSIGNMENT_BUILTIN)) + words->word->flags |= W_ASSNBLTIN; + } +- if (words->word->flags & W_ASSNBLTIN) ++ if ((words->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'A')) + assoc = 1; ++ if ((words->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'g')) ++ global = 1; + } +-#endif + } + + /* Return 1 if the file found by searching $PATH for PATHNAME, defaulting +Index: expr.c +--- expr.c.orig 2010-12-21 17:12:13.000000000 +0100 ++++ expr.c 2012-06-27 10:31:02.000000000 +0200 +@@ -476,19 +476,23 @@ + + if (special) + { ++ if ((op == DIV || op == MOD) && value == 0) ++ { ++ if (noeval == 0) ++ evalerror (_("division by 0")); ++ else ++ value = 1; ++ } ++ + switch (op) + { + case MUL: + lvalue *= value; + break; + case DIV: +- if (value == 0) +- evalerror (_("division by 0")); + lvalue /= value; + break; + case MOD: +- if (value == 0) +- evalerror (_("division by 0")); + lvalue %= value; + break; + case PLUS: +@@ -804,7 +808,12 @@ + val2 = exppower (); + + if (((op == DIV) || (op == MOD)) && (val2 == 0)) +- evalerror (_("division by 0")); ++ { ++ if (noeval == 0) ++ evalerror (_("division by 0")); ++ else ++ val2 = 1; ++ } + + if (op == MUL) + val1 *= val2; +Index: lib/glob/gmisc.c +--- lib/glob/gmisc.c.orig 2011-02-05 22:11:17.000000000 +0100 ++++ lib/glob/gmisc.c 2012-06-27 10:31:02.000000000 +0200 +@@ -77,8 +77,8 @@ + wchar_t *wpat; + size_t wmax; + { +- wchar_t wc, *wbrack; +- int matlen, t, in_cclass, in_collsym, in_equiv; ++ wchar_t wc; ++ int matlen, bracklen, t, in_cclass, in_collsym, in_equiv; + + if (*wpat == 0) + return (0); +@@ -118,58 +118,80 @@ + break; + case L'[': + /* scan for ending `]', skipping over embedded [:...:] */ +- wbrack = wpat; ++ bracklen = 1; + wc = *wpat++; + do + { + if (wc == 0) + { +- matlen += wpat - wbrack - 1; /* incremented below */ +- break; ++ wpat--; /* back up to NUL */ ++ matlen += bracklen; ++ goto bad_bracket; + } + else if (wc == L'\\') + { +- wc = *wpat++; +- if (*wpat == 0) +- break; ++ /* *wpat == backslash-escaped character */ ++ bracklen++; ++ /* If the backslash or backslash-escape ends the string, ++ bail. The ++wpat skips over the backslash escape */ ++ if (*wpat == 0 || *++wpat == 0) ++ { ++ matlen += bracklen; ++ goto bad_bracket; ++ } + } + else if (wc == L'[' && *wpat == L':') /* character class */ + { + wpat++; ++ bracklen++; + in_cclass = 1; + } + else if (in_cclass && wc == L':' && *wpat == L']') + { + wpat++; ++ bracklen++; + in_cclass = 0; + } + else if (wc == L'[' && *wpat == L'.') /* collating symbol */ + { + wpat++; ++ bracklen++; + if (*wpat == L']') /* right bracket can appear as collating symbol */ +- wpat++; ++ { ++ wpat++; ++ bracklen++; ++ } + in_collsym = 1; + } + else if (in_collsym && wc == L'.' && *wpat == L']') + { + wpat++; ++ bracklen++; + in_collsym = 0; + } + else if (wc == L'[' && *wpat == L'=') /* equivalence class */ + { + wpat++; ++ bracklen++; + if (*wpat == L']') /* right bracket can appear as equivalence class */ +- wpat++; ++ { ++ wpat++; ++ bracklen++; ++ } + in_equiv = 1; + } + else if (in_equiv && wc == L'=' && *wpat == L']') + { + wpat++; ++ bracklen++; + in_equiv = 0; + } ++ else ++ bracklen++; + } + while ((wc = *wpat++) != L']'); + matlen++; /* bracket expression can only match one char */ ++bad_bracket: + break; + } + } +@@ -213,8 +235,8 @@ + char *pat; + size_t max; + { +- char c, *brack; +- int matlen, t, in_cclass, in_collsym, in_equiv; ++ char c; ++ int matlen, bracklen, t, in_cclass, in_collsym, in_equiv; + + if (*pat == 0) + return (0); +@@ -254,58 +276,80 @@ + break; + case '[': + /* scan for ending `]', skipping over embedded [:...:] */ +- brack = pat; ++ bracklen = 1; + c = *pat++; + do + { + if (c == 0) + { +- matlen += pat - brack - 1; /* incremented below */ +- break; ++ pat--; /* back up to NUL */ ++ matlen += bracklen; ++ goto bad_bracket; + } + else if (c == '\\') + { +- c = *pat++; +- if (*pat == 0) +- break; ++ /* *pat == backslash-escaped character */ ++ bracklen++; ++ /* If the backslash or backslash-escape ends the string, ++ bail. The ++pat skips over the backslash escape */ ++ if (*pat == 0 || *++pat == 0) ++ { ++ matlen += bracklen; ++ goto bad_bracket; ++ } + } + else if (c == '[' && *pat == ':') /* character class */ + { + pat++; ++ bracklen++; + in_cclass = 1; + } + else if (in_cclass && c == ':' && *pat == ']') + { + pat++; ++ bracklen++; + in_cclass = 0; + } + else if (c == '[' && *pat == '.') /* collating symbol */ + { + pat++; ++ bracklen++; + if (*pat == ']') /* right bracket can appear as collating symbol */ +- pat++; ++ { ++ pat++; ++ bracklen++; ++ } + in_collsym = 1; + } + else if (in_collsym && c == '.' && *pat == ']') + { + pat++; ++ bracklen++; + in_collsym = 0; + } + else if (c == '[' && *pat == '=') /* equivalence class */ + { + pat++; ++ bracklen++; + if (*pat == ']') /* right bracket can appear as equivalence class */ +- pat++; ++ { ++ pat++; ++ bracklen++; ++ } + in_equiv = 1; + } + else if (in_equiv && c == '=' && *pat == ']') + { + pat++; ++ bracklen++; + in_equiv = 0; + } ++ else ++ bracklen++; + } + while ((c = *pat++) != ']'); + matlen++; /* bracket expression can only match one char */ ++bad_bracket: + break; + } + } +Index: lib/readline/callback.c +--- lib/readline/callback.c.orig 2010-06-06 18:18:58.000000000 +0200 ++++ lib/readline/callback.c 2012-06-27 10:31:02.000000000 +0200 +@@ -148,6 +148,9 @@ + eof = _rl_vi_domove_callback (_rl_vimvcxt); + /* Should handle everything, including cleanup, numeric arguments, + and turning off RL_STATE_VIMOTION */ ++ if (RL_ISSTATE (RL_STATE_NUMERICARG) == 0) ++ _rl_internal_char_cleanup (); ++ + return; + } + #endif +Index: lib/readline/vi_mode.c +--- lib/readline/vi_mode.c.orig 2010-11-21 01:51:39.000000000 +0100 ++++ lib/readline/vi_mode.c 2012-06-27 10:31:02.000000000 +0200 +@@ -1114,7 +1114,7 @@ + rl_beg_of_line (1, c); + _rl_vi_last_motion = c; + RL_UNSETSTATE (RL_STATE_VIMOTION); +- return (0); ++ return (vidomove_dispatch (m)); + } + #if defined (READLINE_CALLBACKS) + /* XXX - these need to handle rl_universal_argument bindings */ +Index: lib/sh/zread.c +--- lib/sh/zread.c.orig 2009-03-02 14:54:45.000000000 +0100 ++++ lib/sh/zread.c 2012-06-27 10:31:02.000000000 +0200 +@@ -160,14 +160,13 @@ + zsyncfd (fd) + int fd; + { +- off_t off; +- int r; ++ off_t off, r; + + off = lused - lind; + r = 0; + if (off > 0) + r = lseek (fd, -off, SEEK_CUR); + +- if (r >= 0) ++ if (r != -1) + lused = lind = 0; + } +Index: parse.y +--- parse.y.orig 2011-01-02 21:48:11.000000000 +0100 ++++ parse.y 2012-06-27 10:31:02.000000000 +0200 +@@ -2499,7 +2499,7 @@ + We do this only if it is time to do so. Notice that only here + is the mail alarm reset; nothing takes place in check_mail () + except the checking of mail. Please don't change this. */ +- if (prompt_is_ps1 && time_to_check_mail ()) ++ if (prompt_is_ps1 && parse_and_execute_level == 0 && time_to_check_mail ()) + { + check_mail (); + reset_mail_timer (); +@@ -3842,6 +3842,7 @@ + int flags; + { + sh_parser_state_t ps; ++ sh_input_line_state_t ls; + int orig_ind, nc, sflags; + char *ret, *s, *ep, *ostring; + +@@ -3849,10 +3850,12 @@ + orig_ind = *indp; + ostring = string; + ++/*itrace("xparse_dolparen: size = %d shell_input_line = `%s'", shell_input_line_size, shell_input_line);*/ + sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE; + if (flags & SX_NOLONGJMP) + sflags |= SEVAL_NOLONGJMP; + save_parser_state (&ps); ++ save_input_line_state (&ls); + + /*(*/ + parser_state |= PST_CMDSUBST|PST_EOFTOKEN; /* allow instant ')' */ /*(*/ +@@ -3861,6 +3864,8 @@ + + restore_parser_state (&ps); + reset_parser (); ++ /* reset_parser clears shell_input_line and associated variables */ ++ restore_input_line_state (&ls); + if (interactive) + token_to_read = 0; + +@@ -5135,6 +5140,9 @@ + case 'A': + /* Make the current time/date into a string. */ + (void) time (&the_time); ++#if defined (HAVE_TZSET) ++ sv_tz ("TZ"); /* XXX -- just make sure */ ++#endif + tm = localtime (&the_time); + + if (c == 'd') +@@ -5905,6 +5913,12 @@ + ps->expand_aliases = expand_aliases; + ps->echo_input_at_read = echo_input_at_read; + ++ ps->token = token; ++ ps->token_buffer_size = token_buffer_size; ++ /* Force reallocation on next call to read_token_word */ ++ token = 0; ++ token_buffer_size = 0; ++ + return (ps); + } + +@@ -5946,6 +5960,42 @@ + + expand_aliases = ps->expand_aliases; + echo_input_at_read = ps->echo_input_at_read; ++ ++ FREE (token); ++ token = ps->token; ++ token_buffer_size = ps->token_buffer_size; ++} ++ ++sh_input_line_state_t * ++save_input_line_state (ls) ++ sh_input_line_state_t *ls; ++{ ++ if (ls == 0) ++ ls = (sh_input_line_state_t *)xmalloc (sizeof (sh_input_line_state_t)); ++ if (ls == 0) ++ return ((sh_input_line_state_t *)NULL); ++ ++ ls->input_line = shell_input_line; ++ ls->input_line_size = shell_input_line_size; ++ ls->input_line_len = shell_input_line_len; ++ ls->input_line_index = shell_input_line_index; ++ ++ /* force reallocation */ ++ shell_input_line = 0; ++ shell_input_line_size = shell_input_line_len = shell_input_line_index = 0; ++} ++ ++void ++restore_input_line_state (ls) ++ sh_input_line_state_t *ls; ++{ ++ FREE (shell_input_line); ++ shell_input_line = ls->input_line; ++ shell_input_line_size = ls->input_line_size; ++ shell_input_line_len = ls->input_line_len; ++ shell_input_line_index = ls->input_line_index; ++ ++ set_line_mbstate (); + } + + /************************************************ +Index: patchlevel.h +--- patchlevel.h.orig 2010-06-13 02:14:48.000000000 +0200 ++++ patchlevel.h 2012-06-27 10:31:03.000000000 +0200 +@@ -25,6 +25,6 @@ + regexp `^#define[ ]*PATCHLEVEL', since that's what support/mkversion.sh + looks for to find the patch level (for the sccs version string). */ + +-#define PATCHLEVEL 0 ++#define PATCHLEVEL 29 + + #endif /* _PATCHLEVEL_H_ */ +Index: pathexp.c +--- pathexp.c.orig 2010-08-14 05:21:57.000000000 +0200 ++++ pathexp.c 2012-06-27 10:31:02.000000000 +0200 +@@ -196,7 +196,7 @@ + { + if ((qflags & QGLOB_FILENAME) && pathname[i+1] == '/') + continue; +- if ((qflags & QGLOB_REGEXP) && ere_char (pathname[i+1]) == 0) ++ if (pathname[i+1] != CTLESC && (qflags & QGLOB_REGEXP) && ere_char (pathname[i+1]) == 0) + continue; + temp[j++] = '\\'; + i++; +Index: print_cmd.c +--- print_cmd.c.orig 2010-05-31 00:34:08.000000000 +0200 ++++ print_cmd.c 2012-06-27 10:31:02.000000000 +0200 +@@ -315,6 +315,7 @@ + cprintf ("( "); + skip_this_indent++; + make_command_string_internal (command->value.Subshell->command); ++ PRINT_DEFERRED_HEREDOCS (""); + cprintf (" )"); + break; + +@@ -592,6 +593,7 @@ + newline ("do\n"); + indentation += indentation_amount; + make_command_string_internal (arith_for_command->action); ++ PRINT_DEFERRED_HEREDOCS (""); + semicolon (); + indentation -= indentation_amount; + newline ("done"); +@@ -653,6 +655,7 @@ + } + + make_command_string_internal (group_command->command); ++ PRINT_DEFERRED_HEREDOCS (""); + + if (inside_function_def) + { +Index: shell.h +--- shell.h.orig 2011-01-07 04:16:55.000000000 +0100 ++++ shell.h 2012-06-27 10:31:02.000000000 +0200 +@@ -136,6 +136,9 @@ + int parser_state; + int *token_state; + ++ char *token; ++ int token_buffer_size; ++ + /* input line state -- line number saved elsewhere */ + int input_line_terminator; + int eof_encountered; +@@ -166,6 +169,16 @@ + + } sh_parser_state_t; + ++typedef struct _sh_input_line_state_t { ++ char *input_line; ++ int input_line_index; ++ int input_line_size; ++ int input_line_len; ++} sh_input_line_state_t; ++ + /* Let's try declaring these here. */ + extern sh_parser_state_t *save_parser_state __P((sh_parser_state_t *)); + extern void restore_parser_state __P((sh_parser_state_t *)); ++ ++extern sh_input_line_state_t *save_input_line_state __P((sh_input_line_state_t *)); ++extern void restore_input_line_state __P((sh_input_line_state_t *)); +Index: sig.c +--- sig.c.orig 2010-11-23 14:21:22.000000000 +0100 ++++ sig.c 2012-06-27 10:31:02.000000000 +0200 +@@ -46,6 +46,7 @@ + + #if defined (READLINE) + # include "bashline.h" ++# include + #endif + + #if defined (HISTORY) +@@ -62,6 +63,7 @@ + #if defined (HISTORY) + extern int history_lines_this_session; + #endif ++extern int no_line_editing; + + extern void initialize_siglist (); + +@@ -505,7 +507,10 @@ + { + #if defined (HISTORY) + /* XXX - will inhibit history file being written */ +- history_lines_this_session = 0; ++# if defined (READLINE) ++ if (interactive_shell == 0 || interactive == 0 || (sig != SIGHUP && sig != SIGTERM) || no_line_editing || (RL_ISSTATE (RL_STATE_READCMD) == 0)) ++# endif ++ history_lines_this_session = 0; + #endif + terminate_immediately = 0; + termsig_handler (sig); +Index: subst.c +--- subst.c.orig 2011-01-02 22:12:51.000000000 +0100 ++++ subst.c 2012-06-27 10:31:03.000000000 +0200 +@@ -366,6 +366,11 @@ + f &= ~W_ASSNBLTIN; + fprintf (stderr, "W_ASSNBLTIN%s", f ? "|" : ""); + } ++ if (f & W_ASSNGLOBAL) ++ { ++ f &= ~W_ASSNGLOBAL; ++ fprintf (stderr, "W_ASSNGLOBAL%s", f ? "|" : ""); ++ } + if (f & W_COMPASSIGN) + { + f &= ~W_COMPASSIGN; +@@ -1379,10 +1384,12 @@ + slen = strlen (string + *sindex) + *sindex; + + /* The handling of dolbrace_state needs to agree with the code in parse.y: +- parse_matched_pair() */ +- dolbrace_state = 0; +- if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) +- dolbrace_state = (flags & SX_POSIXEXP) ? DOLBRACE_QUOTE : DOLBRACE_PARAM; ++ parse_matched_pair(). The different initial value is to handle the ++ case where this function is called to parse the word in ++ ${param op word} (SX_WORD). */ ++ dolbrace_state = (flags & SX_WORD) ? DOLBRACE_WORD : DOLBRACE_PARAM; ++ if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && (flags & SX_POSIXEXP)) ++ dolbrace_state = DOLBRACE_QUOTE; + + i = *sindex; + while (c = string[i]) +@@ -2801,7 +2808,7 @@ + } + else if (assign_list) + { +- if (word->flags & W_ASSIGNARG) ++ if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL) == 0) + aflags |= ASS_MKLOCAL; + if (word->flags & W_ASSIGNASSOC) + aflags |= ASS_MKASSOC; +@@ -3371,7 +3378,7 @@ + if (string == 0 || *string == '\0') + return (WORD_LIST *)NULL; + +- td.flags = 0; ++ td.flags = W_NOSPLIT2; /* no splitting, remove "" and '' */ + td.word = string; + tresult = call_expand_word_internal (&td, quoted, 1, dollar_at_p, has_dollar_at); + return (tresult); +@@ -3704,7 +3711,10 @@ + break; + } + else if (string[i] == CTLNUL) +- i++; ++ { ++ i++; ++ continue; ++ } + + prev_i = i; + ADVANCE_CHAR (string, slen, i); +@@ -4156,7 +4166,7 @@ + simple = (wpat[0] != L'\\' && wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'['); + #if defined (EXTENDED_GLOB) + if (extended_glob) +- simple |= (wpat[1] != L'(' || (wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'+' && wpat[0] != L'!' && wpat[0] != L'@')); /*)*/ ++ simple &= (wpat[1] != L'(' || (wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'+' && wpat[0] != L'!' && wpat[0] != L'@')); /*)*/ + #endif + + /* If the pattern doesn't match anywhere in the string, go ahead and +@@ -4607,6 +4617,7 @@ + if (ifs_firstc == 0) + #endif + word->flags |= W_NOSPLIT; ++ word->flags |= W_NOSPLIT2; + result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL); + expand_no_split_dollar_star = 0; + +@@ -5798,6 +5809,16 @@ + is the only expansion that creates more than one word. */ + if (qdollaratp && ((hasdol && quoted) || l->next)) + *qdollaratp = 1; ++ /* If we have a quoted null result (QUOTED_NULL(temp)) and the word is ++ a quoted null (l->next == 0 && QUOTED_NULL(l->word->word)), the ++ flags indicate it (l->word->flags & W_HASQUOTEDNULL), and the ++ expansion is quoted (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ++ (which is more paranoia than anything else), we need to return the ++ quoted null string and set the flags to indicate it. */ ++ if (l->next == 0 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && QUOTED_NULL(temp) && QUOTED_NULL(l->word->word) && (l->word->flags & W_HASQUOTEDNULL)) ++ { ++ w->flags |= W_HASQUOTEDNULL; ++ } + dispose_words (l); + } + else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && hasdol) +@@ -7176,7 +7197,7 @@ + { + /* Extract the contents of the ${ ... } expansion + according to the Posix.2 rules. */ +- value = extract_dollar_brace_string (string, &sindex, quoted, (c == '%' || c == '#') ? SX_POSIXEXP : 0); ++ value = extract_dollar_brace_string (string, &sindex, quoted, (c == '%' || c == '#' || c =='/' || c == '^' || c == ',' || c ==':') ? SX_POSIXEXP|SX_WORD : SX_WORD); + if (string[sindex] == RBRACE) + sindex++; + else +@@ -7268,6 +7289,7 @@ + default: + case '\0': + bad_substitution: ++ last_command_exit_value = EXECUTION_FAILURE; + report_error (_("%s: bad substitution"), string ? string : "??"); + FREE (value); + FREE (temp); +Index: subst.h +--- subst.h.orig 2010-12-03 02:21:29.000000000 +0100 ++++ subst.h 2012-06-27 10:31:02.000000000 +0200 +@@ -56,6 +56,7 @@ + #define SX_NOLONGJMP 0x0040 /* don't longjmp on fatal error */ + #define SX_ARITHSUB 0x0080 /* extracting $(( ... )) (currently unused) */ + #define SX_POSIXEXP 0x0100 /* extracting new Posix pattern removal expansions in extract_dollar_brace_string */ ++#define SX_WORD 0x0200 /* extracting word in ${param op word} */ + + /* Remove backslashes which are quoting backquotes from STRING. Modifies + STRING, and returns a pointer to it. */ +Index: support/shobj-conf +--- support/shobj-conf.orig 2009-10-28 14:20:21.000000000 +0100 ++++ support/shobj-conf 2012-06-27 10:31:02.000000000 +0200 +@@ -157,7 +157,7 @@ + ;; + + # Darwin/MacOS X +-darwin[89]*|darwin10*) ++darwin[89]*|darwin1[012]*) + SHOBJ_STATUS=supported + SHLIB_STATUS=supported + +@@ -186,7 +186,7 @@ + SHLIB_LIBSUFF='dylib' + + case "${host_os}" in +- darwin[789]*|darwin10*) SHOBJ_LDFLAGS='' ++ darwin[789]*|darwin1[012]*) SHOBJ_LDFLAGS='' + SHLIB_XLDFLAGS='-dynamiclib -arch_only `/usr/bin/arch` -install_name $(libdir)/$@ -current_version $(SHLIB_MAJOR)$(SHLIB_MINOR) -compatibility_version $(SHLIB_MAJOR) -v' + ;; + *) SHOBJ_LDFLAGS='-dynamic' +Index: tests/shopt.right +--- tests/shopt.right.orig 2010-07-03 05:36:30.000000000 +0200 ++++ tests/shopt.right 2012-06-27 10:31:03.000000000 +0200 +@@ -12,6 +12,7 @@ + shopt -u compat32 + shopt -u compat40 + shopt -u compat41 ++shopt -u direxpand + shopt -u dirspell + shopt -u dotglob + shopt -u execfail +@@ -68,6 +69,7 @@ + shopt -u compat32 + shopt -u compat40 + shopt -u compat41 ++shopt -u direxpand + shopt -u dirspell + shopt -u dotglob + shopt -u execfail +@@ -101,6 +103,7 @@ + compat32 off + compat40 off + compat41 off ++direxpand off + dirspell off + dotglob off + execfail off +Index: variables.c +--- variables.c.orig 2011-01-25 02:07:48.000000000 +0100 ++++ variables.c 2012-06-27 10:31:02.000000000 +0200 +@@ -3653,6 +3653,22 @@ + return n; + } + ++int ++chkexport (name) ++ char *name; ++{ ++ SHELL_VAR *v; ++ ++ v = find_variable (name); ++ if (v && exported_p (v)) ++ { ++ array_needs_making = 1; ++ maybe_make_export_env (); ++ return 1; ++ } ++ return 0; ++} ++ + void + maybe_make_export_env () + { +@@ -4214,7 +4230,7 @@ + { "TEXTDOMAIN", sv_locale }, + { "TEXTDOMAINDIR", sv_locale }, + +-#if defined (HAVE_TZSET) && defined (PROMPT_STRING_DECODE) ++#if defined (HAVE_TZSET) + { "TZ", sv_tz }, + #endif + +@@ -4558,12 +4574,13 @@ + } + #endif /* HISTORY */ + +-#if defined (HAVE_TZSET) && defined (PROMPT_STRING_DECODE) ++#if defined (HAVE_TZSET) + void + sv_tz (name) + char *name; + { +- tzset (); ++ if (chkexport (name)) ++ tzset (); + } + #endif + +Index: variables.h +--- variables.h.orig 2010-12-03 02:22:01.000000000 +0100 ++++ variables.h 2012-06-27 10:31:02.000000000 +0200 +@@ -313,6 +313,7 @@ + + extern void sort_variables __P((SHELL_VAR **)); + ++extern int chkexport __P((char *)); + extern void maybe_make_export_env __P((void)); + extern void update_export_env_inplace __P((char *, int, char *)); + extern void put_command_name_into_env __P((char *)); +Index: y.tab.c +--- y.tab.c.orig 2011-01-04 15:57:56.000000000 +0100 ++++ y.tab.c 2012-06-27 10:31:03.000000000 +0200 +@@ -4811,7 +4811,7 @@ + We do this only if it is time to do so. Notice that only here + is the mail alarm reset; nothing takes place in check_mail () + except the checking of mail. Please don't change this. */ +- if (prompt_is_ps1 && time_to_check_mail ()) ++ if (prompt_is_ps1 && parse_and_execute_level == 0 && time_to_check_mail ()) + { + check_mail (); + reset_mail_timer (); +@@ -6154,6 +6154,7 @@ + int flags; + { + sh_parser_state_t ps; ++ sh_input_line_state_t ls; + int orig_ind, nc, sflags; + char *ret, *s, *ep, *ostring; + +@@ -6161,10 +6162,12 @@ + orig_ind = *indp; + ostring = string; + ++/*itrace("xparse_dolparen: size = %d shell_input_line = `%s'", shell_input_line_size, shell_input_line);*/ + sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE; + if (flags & SX_NOLONGJMP) + sflags |= SEVAL_NOLONGJMP; + save_parser_state (&ps); ++ save_input_line_state (&ls); + + /*(*/ + parser_state |= PST_CMDSUBST|PST_EOFTOKEN; /* allow instant ')' */ /*(*/ +@@ -6173,6 +6176,8 @@ + + restore_parser_state (&ps); + reset_parser (); ++ /* reset_parser clears shell_input_line and associated variables */ ++ restore_input_line_state (&ls); + if (interactive) + token_to_read = 0; + +@@ -7447,6 +7452,9 @@ + case 'A': + /* Make the current time/date into a string. */ + (void) time (&the_time); ++#if defined (HAVE_TZSET) ++ sv_tz ("TZ"); /* XXX -- just make sure */ ++#endif + tm = localtime (&the_time); + + if (c == 'd') +@@ -8217,6 +8225,12 @@ + ps->expand_aliases = expand_aliases; + ps->echo_input_at_read = echo_input_at_read; + ++ ps->token = token; ++ ps->token_buffer_size = token_buffer_size; ++ /* Force reallocation on next call to read_token_word */ ++ token = 0; ++ token_buffer_size = 0; ++ + return (ps); + } + +@@ -8258,6 +8272,42 @@ + + expand_aliases = ps->expand_aliases; + echo_input_at_read = ps->echo_input_at_read; ++ ++ FREE (token); ++ token = ps->token; ++ token_buffer_size = ps->token_buffer_size; ++} ++ ++sh_input_line_state_t * ++save_input_line_state (ls) ++ sh_input_line_state_t *ls; ++{ ++ if (ls == 0) ++ ls = (sh_input_line_state_t *)xmalloc (sizeof (sh_input_line_state_t)); ++ if (ls == 0) ++ return ((sh_input_line_state_t *)NULL); ++ ++ ls->input_line = shell_input_line; ++ ls->input_line_size = shell_input_line_size; ++ ls->input_line_len = shell_input_line_len; ++ ls->input_line_index = shell_input_line_index; ++ ++ /* force reallocation */ ++ shell_input_line = 0; ++ shell_input_line_size = shell_input_line_len = shell_input_line_index = 0; ++} ++ ++void ++restore_input_line_state (ls) ++ sh_input_line_state_t *ls; ++{ ++ FREE (shell_input_line); ++ shell_input_line = ls->input_line; ++ shell_input_line_size = ls->input_line_size; ++ shell_input_line_len = ls->input_line_len; ++ shell_input_line_index = ls->input_line_index; ++ ++ set_line_mbstate (); + } + + /************************************************