commit bash-20100121 snapshot

CWRU/CWRU.chlog

@@ -9372,3 +9372,88 @@ doc/{bash.1,{bashref,version}.texi},lib/readine/doc/rluser.texi
 	- some typo fixes from Aharon Robbins <arnold@skeeve.com>
 	- added descriptions of ENV, COPROC, and MAPFILE variables
 	- added descriptions of READLINE_LINE and READLINE_POINT
+
+				   1/21
+				   ----
+arrayfunc.c
+	- free `akey', the word-expanded index into the assoc array to avoid
+	  mem leak in array_value_internal
+	- free index into assoc array in unbind_array_element
+	- change array_value_internal to take an additional argument: an
+	  arrayind_t *.  If not null, an index to an indexed array is
+	  returned there.  If not an indexed array or subscript is @ or
+	  *, the value is unchanged
+
+				   1/22
+				   ----
+builtins/ulimit.def
+	- include <ulimit.h> if we found it during configure and we don't
+	  have resources.  Fixes omission reported by Joachim Schmitz
+	  <jojo@schmitz-digital.de>
+
+{configure,config.h}.in
+	- check for <ulimit.h>, define HAVE_ULIMIT_H if found
+
+lib/sh/oslib.c
+	- include <signal.h> for extern declaration for kill(2) if
+	  HAVE_KILLPG not defined
+
+jobs.c
+	- if HAVE_KILLPG is not defined, add an extern prototype decl for
+	  killpg()
+
+				   1/24
+				   ----
+print_cmd.c
+	- when printing here-string redirections, don't quote the string.  The
+	  original quotes, if any, are still in place and don't need to be
+	  requoted.  Fixes bug reported by Arfrever Frehtes Taifersar Arahesis
+	  <arfrever.fta@gmail.com>
+
+subst.c
+	- fix array_length_reference to return 0 for variables that have not
+	  been assigned a value.  Fixes bug reported by Mart Frauenlab
+	  <mart.frauenlob@chello.at>, but is not backwards compatible
+
+arrayfunc.[ch]
+	- change array_value to take a new arrayind_t *indp parameter like
+	  get_array_value; changed extern prototype declaration
+
+subst.c
+	- changed callers of array_value to add extra parameter
+
+expr.c
+	- change expr_streval to set a new `lvalue' parameter with information
+	  about the string being evaluated: string, value, array index (if
+	  any), variable evaluated (if set).
+	- saving and restoring current context now saves and restores the
+	  current `lvalue'
+	- new function expr_bind_array_element, binds an array element with an
+	  already-computed index to a specified value
+	- anywhere we set the current token to a string (STR), save and set
+	  the current lvalue
+	- change calls to expr_bind_variable to check whether or not the
+	  current lvalue indicates an indexed array was evaluated, and, if so,
+	  call expr_bind_array_element using the already-computed index
+	  (curlval.ind).  Fixes problems with dynamic variables (e.g., RANDOM)
+	  in array indices with {pre,post}-{inc,dec}rement and op=
+	  operators reported by <dennis@netstrata.com>
+
+				   1/25
+				   ----
+expr.c
+	- fix subexpr() to initialize curlval and lastlval when resetting all
+	  of the rest of the expression-parsing variables
+
+				   1/26
+				   ----
+builtins/setattr.def
+	- in show_var_attributes, if the variable is not set (value == 0),
+	  don't print `name=""', just print `name'.  Pointed out by
+	  Mart Frauenlab <mart.frauenlob@chello.at>
+
+arrayfunc.c
+	- fix array_keys to return NULL if the variable is not set or
+	  invisible.  Pointed out by Mart Frauenlab <mart.frauenlob@chello.at>
+	- change array_value_internal to return NULL for variable which has
+	  not been set

CWRU/CWRU.chlog~

@@ -9325,6 +9325,10 @@ doc/bash.1
 
 [bash-4.1 frozen]
 
+				   12/31
+				   -----
+[bash-4.1 released]
+
 				 1/5/2010
 				 --------
 doc/bashref.texi
@@ -9344,3 +9348,110 @@ lib/readline/complete.c
 builtins/printf.def
 	- fix prototype in extern declaration for vsnprintf.  Fix for bug
 	  reported by Yann Rouillard <yann@pleiades.fr.eu.org>
+
+				    1/9
+				    ---
+parse.y
+	- fix shell_getc to handle alias expansions containing quoted
+	  newlines.  Problems in bash-4.1 with aliases containing quoted
+	  newlines in the middle of and at the end of their expansion.
+	  Fix for bug reported by Jonathan Claggett
+	  <jonathan@claggett.org>
+	- change mk_alexpansion to not append a space to an alias
+	  expansion ending with a newline.  Works with shell_getc
+
+				   1/11
+				   ----
+lib/glob/Makefile.in
+	- add dependencies on shell.h and pathnames.h.  From Mike Frysinger
+	  <vapier@gentoo.org>
+
+				   1/15
+				   ----
+doc/{bash.1,{bashref,version}.texi},lib/readine/doc/rluser.texi
+	- some typo fixes from Aharon Robbins <arnold@skeeve.com>
+	- added descriptions of ENV, COPROC, and MAPFILE variables
+	- added descriptions of READLINE_LINE and READLINE_POINT
+
+				   1/21
+				   ----
+arrayfunc.c
+	- free `akey', the word-expanded index into the assoc array to avoid
+	  mem leak in array_value_internal
+	- free index into assoc array in unbind_array_element
+	- change array_value_internal to take an additional argument: an
+	  arrayind_t *.  If not null, an index to an indexed array is
+	  returned there.  If not an indexed array or subscript is @ or
+	  *, the value is unchanged
+
+				   1/22
+				   ----
+builtins/ulimit.def
+	- include <ulimit.h> if we found it during configure and we don't
+	  have resources.  Fixes omission reported by Joachim Schmitz
+	  <jojo@schmitz-digital.de>
+
+{configure,config.h}.in
+	- check for <ulimit.h>, define HAVE_ULIMIT_H if found
+
+lib/sh/oslib.c
+	- include <signal.h> for extern declaration for kill(2) if
+	  HAVE_KILLPG not defined
+
+jobs.c
+	- if HAVE_KILLPG is not defined, add an extern prototype decl for
+	  killpg()
+
+				   1/24
+				   ----
+print_cmd.c
+	- when printing here-string redirections, don't quote the string.  The
+	  original quotes, if any, are still in place and don't need to be
+	  requoted.  Fixes bug reported by Arfrever Frehtes Taifersar Arahesis
+	  <arfrever.fta@gmail.com>
+
+subst.c
+	- fix array_length_reference to return 0 for variables that have not
+	  been assigned a value.  Fixes bug reported by Mart Frauenlab
+	  <mart.frauenlob@chello.at>, but is not backwards compatible
+
+arrayfunc.[ch]
+	- change array_value to take a new arrayind_t *indp parameter like
+	  get_array_value; changed extern prototype declaration
+
+subst.c
+	- changed callers of array_value to add extra parameter
+
+expr.c
+	- change expr_streval to set a new `lvalue' parameter with information
+	  about the string being evaluated: string, value, array index (if
+	  any), variable evaluated (if set).
+	- saving and restoring current context now saves and restores the
+	  current `lvalue'
+	- new function expr_bind_array_element, binds an array element with an
+	  already-computed index to a specified value
+	- anywhere we set the current token to a string (STR), save and set
+	  the current lvalue
+	- change calls to expr_bind_variable to check whether or not the
+	  current lvalue indicates an indexed array was evaluated, and, if so,
+	  call expr_bind_array_element using the already-computed index
+	  (curlval.ind).  Fixes problems with dynamic variables (e.g., RANDOM)
+	  in array indices with {pre,post}-{inc,dec}rement and op=
+	  operators reported by <dennis@netstrata.com>
+
+				   1/25
+				   ----
+expr.c
+	- fix subexpr() to initialize curlval and lastlval when resetting all
+	  of the rest of the expression-parsing variables
+
+				   1/26
+				   ----
+builtins/setattr.def
+	- in show_var_attributes, if the variable is not set (value == 0),
+	  don't print `name=""', just print `name'.  Pointed out by
+	  Mart Frauenlab <mart.frauenlob@chello.at>
+
+arrayfunc.c
+	- fix array_keys to return NULL if the variable is not set or
+	  invisible.  Pointed out by Mart Frauenlab <mart.frauenlob@chello.at>

arrayfunc.c

@@ -44,7 +44,7 @@ static SHELL_VAR *bind_array_var_internal __P((SHELL_VAR *, arrayind_t, char *,
 
 static char *quote_assign __P((const char *));
 static void quote_array_assignment_chars __P((WORD_LIST *));
-static char *array_value_internal __P((char *, int, int, int *));
+static char *array_value_internal __P((char *, int, int, int *, arrayind_t *));
 
 /* Standard error message to use when encountering an invalid array subscript */
 const char * const bash_badsub_errmsg = N_("bad array subscript");
@@ -658,6 +658,7 @@ unbind_array_element (var, sub)
 	  return -1;
 	}
       assoc_remove (assoc_cell (var), akey);
+      free (akey);
     }
   else
     {
@@ -848,9 +849,10 @@ array_variable_part (s, subp, lenp)
    is non-null it gets 1 if the array reference is name[*], 2 if the
    reference is name[@], and 0 otherwise. */
 static char *
-array_value_internal (s, quoted, allow_all, rtype)
+array_value_internal (s, quoted, allow_all, rtype, indp)
      char *s;
      int quoted, allow_all, *rtype;
+     arrayind_t *indp;
 {
   int len;
   arrayind_t ind;
@@ -881,7 +883,7 @@ array_value_internal (s, quoted, allow_all, rtype)
 	  err_badarraysub (s);
 	  return ((char *)NULL);
 	}
-      else if (var == 0 || value_cell (var) == 0)
+      else if (var == 0 || value_cell (var) == 0)	/* XXX - check for invisible_p(var) ? */
 	return ((char *)NULL);
       else if (array_p (var) == 0 && assoc_p (var) == 0)
 	l = add_string_to_list (value_cell (var), (WORD_LIST *)NULL);
@@ -929,6 +931,8 @@ index_error:
 		}
 	      return ((char *)NULL);
 	    }
+	  if (indp)
+	    *indp = ind;
 	}
       else if (assoc_p (var))
 	{
@@ -939,12 +943,15 @@ index_error:
 	    goto index_error;
 	}
      
-      if (var == 0)
+      if (var == 0 || value_cell (var) == 0)	/* XXX - check invisible_p(var) ? */
 	return ((char *)NULL);
       if (array_p (var) == 0 && assoc_p (var) == 0)
 	return (ind == 0 ? value_cell (var) : (char *)NULL);
       else if (assoc_p (var))
-	retval = assoc_reference (assoc_cell (var), akey);
+        {
+	  retval = assoc_reference (assoc_cell (var), akey);
+	  free (akey);
+        }
       else
 	retval = array_reference (array_cell (var), ind);
     }
@@ -955,11 +962,12 @@ index_error:
 /* Return a string containing the elements described by the array and
    subscript contained in S, obeying quoting for subscripts * and @. */
 char *
-array_value (s, quoted, rtype)
+array_value (s, quoted, rtype, indp)
      char *s;
      int quoted, *rtype;
+     arrayind_t *indp;
 {
-  return (array_value_internal (s, quoted, 1, rtype));
+  return (array_value_internal (s, quoted, 1, rtype, indp));
 }
 
 /* Return the value of the array indexing expression S as a single string.
@@ -967,11 +975,12 @@ array_value (s, quoted, rtype)
    by other parts of the shell such as the arithmetic expression evaluator
    in expr.c. */
 char *
-get_array_value (s, allow_all, rtype)
+get_array_value (s, allow_all, rtype, indp)
      char *s;
      int allow_all, *rtype;
+     arrayind_t *indp;
 {
-  return (array_value_internal (s, 0, allow_all, rtype));
+  return (array_value_internal (s, 0, allow_all, rtype, indp));
 }
 
 char *
@@ -990,6 +999,9 @@ array_keys (s, quoted)
   if (var == 0 || ALL_ELEMENT_SUB (t[0]) == 0 || t[1] != ']')
     return (char *)NULL;
 
+  if (var_isset (var) == 0 || invisible_p (var))
+    return (char *)NULL;
+
   if (array_p (var) == 0 && assoc_p (var) == 0)
     l = add_string_to_list ("0", (WORD_LIST *)NULL);
   else if (assoc_p (var))

arrayfunc.h

@@ -51,8 +51,8 @@ extern void print_assoc_assignment __P((SHELL_VAR *, int));
 
 extern arrayind_t array_expand_index __P((char *, int));
 extern int valid_array_reference __P((char *));
-extern char *array_value __P((char *, int, int *));
-extern char *get_array_value __P((char *, int, int *));
+extern char *array_value __P((char *, int, int *, arrayind_t *));
+extern char *get_array_value __P((char *, int, int *, arrayind_t *));
 
 extern char *array_keys __P((char *, int));
 

arrayfunc.h~

@@ -0,0 +1,64 @@
+/* arrayfunc.h -- declarations for miscellaneous array functions in arrayfunc.c */
+
+/* Copyright (C) 2001-2009 Free Software Foundation, Inc.
+
+   This file is part of GNU Bash, the Bourne Again SHell.
+
+   Bash is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Bash is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#if !defined (_ARRAYFUNC_H_)
+#define _ARRAYFUNC_H_
+
+/* Must include variables.h before including this file. */
+
+#if defined (ARRAY_VARS)
+
+extern SHELL_VAR *convert_var_to_array __P((SHELL_VAR *));
+extern SHELL_VAR *convert_var_to_assoc __P((SHELL_VAR *));
+
+extern SHELL_VAR *bind_array_variable __P((char *, arrayind_t, char *, int));
+extern SHELL_VAR *bind_array_element __P((SHELL_VAR *, arrayind_t, char *, int));
+extern SHELL_VAR *assign_array_element __P((char *, char *, int));
+
+extern SHELL_VAR *bind_assoc_variable __P((SHELL_VAR *, char *, char *, char *, int));
+
+extern SHELL_VAR *find_or_make_array_variable __P((char *, int));
+
+extern SHELL_VAR *assign_array_from_string  __P((char *, char *, int));
+extern SHELL_VAR *assign_array_var_from_word_list __P((SHELL_VAR *, WORD_LIST *, int));
+
+extern WORD_LIST *expand_compound_array_assignment __P((SHELL_VAR *, char *, int));
+extern void assign_compound_array_list __P((SHELL_VAR *, WORD_LIST *, int));
+extern SHELL_VAR *assign_array_var_from_string __P((SHELL_VAR *, char *, int));
+
+extern int unbind_array_element __P((SHELL_VAR *, char *));
+extern int skipsubscript __P((const char *, int, int));
+
+extern void print_array_assignment __P((SHELL_VAR *, int));
+extern void print_assoc_assignment __P((SHELL_VAR *, int));
+
+extern arrayind_t array_expand_index __P((char *, int));
+extern int valid_array_reference __P((char *));
+extern char *array_value __P((char *, int, int *));
+extern char *get_array_value __P((char *, int, int *, arrayind_t *));
+
+extern char *array_keys __P((char *, int));
+
+extern char *array_variable_name __P((char *, char **, int *));
+extern SHELL_VAR *array_variable_part __P((char *, char **, int *));
+
+#endif
+
+#endif /* !_ARRAYFUNC_H_ */

autom4te.cache/output.0

@@ -1,7 +1,7 @@
 @%:@! /bin/sh
-@%:@ From configure.in for Bash 4.1, version 4.019.
+@%:@ From configure.in for Bash 4.1, version 4.020.
 @%:@ Guess values for system-dependent variables and create Makefiles.
-@%:@ Generated by GNU Autoconf 2.63 for bash 4.1-release.
+@%:@ Generated by GNU Autoconf 2.63 for bash 4.1-maint.
 @%:@
 @%:@ Report bugs to <bug-bash@gnu.org>.
 @%:@ 
@@ -597,8 +597,8 @@ SHELL=${CONFIG_SHELL-/bin/sh}
 # Identity of this package.
 PACKAGE_NAME='bash'
 PACKAGE_TARNAME='bash'
-PACKAGE_VERSION='4.1-release'
-PACKAGE_STRING='bash 4.1-release'
+PACKAGE_VERSION='4.1-maint'
+PACKAGE_STRING='bash 4.1-maint'
 PACKAGE_BUGREPORT='bug-bash@gnu.org'
 
 ac_unique_file="shell.h"
@@ -1411,7 +1411,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures bash 4.1-release to adapt to many kinds of systems.
+\`configure' configures bash 4.1-maint to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1476,7 +1476,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of bash 4.1-release:";;
+     short | recursive ) echo "Configuration of bash 4.1-maint:";;
    esac
   cat <<\_ACEOF
 
@@ -1652,7 +1652,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-bash configure 4.1-release
+bash configure 4.1-maint
 generated by GNU Autoconf 2.63
 
 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
@@ -1666,7 +1666,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by bash $as_me 4.1-release, which was
+It was created by bash $as_me 4.1-maint, which was
 generated by GNU Autoconf 2.63.  Invocation command line was
 
   $ $0 $@
@@ -2080,7 +2080,7 @@ ac_config_headers="$ac_config_headers config.h"
 
 
 BASHVERS=4.1
-RELSTATUS=release
+RELSTATUS=maint
 
 case "$RELSTATUS" in
 alp*|bet*|dev*|rc*|maint*)	DEBUG='-DDEBUG' MALLOC_DEBUG='-DMALLOC_DEBUG' ;;
@@ -11502,12 +11502,13 @@ done
 
 
 
+
 
 
 for ac_header in unistd.h stdlib.h stdarg.h varargs.h limits.h string.h \
 		 memory.h locale.h termcap.h termio.h termios.h dlfcn.h \
 		 stddef.h stdint.h netdb.h pwd.h grp.h strings.h regex.h \
-		 syslog.h
+		 syslog.h ulimit.h
 do
 as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
 if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
@@ -31170,7 +31171,7 @@ exec 6>&1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by bash $as_me 4.1-release, which was
+This file was extended by bash $as_me 4.1-maint, which was
 generated by GNU Autoconf 2.63.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -31233,7 +31234,7 @@ Report bugs to <bug-autoconf@gnu.org>."
 _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_version="\\
-bash config.status 4.1-release
+bash config.status 4.1-maint
 configured by $0, generated by GNU Autoconf 2.63,
   with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
 

autom4te.cache/traces.0

@@ -1,4 +1,4 @@
-m4trace:configure.in:29: -1- AC_INIT([bash], [4.1-release], [bug-bash@gnu.org])
+m4trace:configure.in:29: -1- AC_INIT([bash], [4.1-maint], [bug-bash@gnu.org])
 m4trace:configure.in:29: -1- m4_pattern_forbid([^_?A[CHUM]_])
 m4trace:configure.in:29: -1- m4_pattern_forbid([_AC_])
 m4trace:configure.in:29: -1- m4_pattern_forbid([^LIBOBJS$], [do not use LIBOBJS directly, use AC_LIBOBJ (see section `AC_LIBOBJ vs LIBOBJS'])
@@ -1190,6 +1190,8 @@ m4trace:configure.in:659: -1- AH_OUTPUT([HAVE_REGEX_H], [/* Define to 1 if you h
 #undef HAVE_REGEX_H])
 m4trace:configure.in:659: -1- AH_OUTPUT([HAVE_SYSLOG_H], [/* Define to 1 if you have the <syslog.h> header file. */
 #undef HAVE_SYSLOG_H])
+m4trace:configure.in:659: -1- AH_OUTPUT([HAVE_ULIMIT_H], [/* Define to 1 if you have the <ulimit.h> header file. */
+#undef HAVE_ULIMIT_H])
 m4trace:configure.in:663: -1- AH_OUTPUT([HAVE_SYS_PTE_H], [/* Define to 1 if you have the <sys/pte.h> header file. */
 #undef HAVE_SYS_PTE_H])
 m4trace:configure.in:663: -1- AH_OUTPUT([HAVE_SYS_STREAM_H], [/* Define to 1 if you have the <sys/stream.h> header file. */

bashline.c

@@ -3421,7 +3421,10 @@ static int
 putx(c)
      int c;
 {
-  putc (c, rl_outstream);
+  int x;
+
+  x = putc (c, rl_outstream);
+  return (x);
 }
   
 static int

builtins/setattr.def

@@ -433,11 +433,11 @@ show_var_attributes (var, pattr, nodefs)
     printf ("%s\n", var->name);
   else if (function_p (var))
     printf ("%s\n", named_function_string (var->name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL));
-  else if (invisible_p (var))
+  else if (invisible_p (var) || var_isset (var) == 0)
     printf ("%s\n", var->name);
   else
     {
-      x = sh_double_quote (var_isset (var) ? value_cell (var) : "");
+      x = sh_double_quote (value_cell (var));
       printf ("%s=%s\n", var->name, x);
       free (x);
     }

builtins/setattr.def~

@@ -0,0 +1,514 @@
+This file is setattr.def, from which is created setattr.c.
+It implements the builtins "export" and "readonly", in Bash.
+
+Copyright (C) 1987-2009 Free Software Foundation, Inc.
+
+This file is part of GNU Bash, the Bourne Again SHell.
+
+Bash is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Bash is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bash.  If not, see <http://www.gnu.org/licenses/>.
+
+$PRODUCES setattr.c
+
+#include <config.h>
+
+#if defined (HAVE_UNISTD_H)
+#  ifdef _MINIX
+#    include <sys/types.h>
+#  endif
+#  include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include "../bashansi.h"
+#include "../bashintl.h"
+
+#include "../shell.h"
+#include "common.h"
+#include "bashgetopt.h"
+
+extern int posixly_correct;
+extern int array_needs_making;
+extern char *this_command_name;
+extern sh_builtin_func_t *this_shell_builtin;
+
+#ifdef ARRAY_VARS
+extern int declare_builtin __P((WORD_LIST *));
+#endif
+
+#define READONLY_OR_EXPORT \
+  (this_shell_builtin == readonly_builtin || this_shell_builtin == export_builtin)
+
+$BUILTIN export
+$FUNCTION export_builtin
+$SHORT_DOC export [-fn] [name[=value] ...] or export -p
+Set export attribute for shell variables.
+
+Marks each NAME for automatic export to the environment of subsequently
+executed commands.  If VALUE is supplied, assign VALUE before exporting.
+
+Options:
+  -f	refer to shell functions
+  -n	remove the export property from each NAME
+  -p	display a list of all exported variables and functions
+
+An argument of `--' disables further option processing.
+
+Exit Status:
+Returns success unless an invalid option is given or NAME is invalid.
+$END
+
+/* For each variable name in LIST, make that variable appear in the
+   environment passed to simple commands.  If there is no LIST, then
+   print all such variables.  An argument of `-n' says to remove the
+   exported attribute from variables named in LIST.  An argument of
+  -f indicates that the names present in LIST refer to functions. */
+int
+export_builtin (list)
+     register WORD_LIST *list;
+{
+  return (set_or_show_attributes (list, att_exported, 0));
+}
+
+$BUILTIN readonly
+$FUNCTION readonly_builtin
+$SHORT_DOC readonly [-af] [name[=value] ...] or readonly -p
+Mark shell variables as unchangeable.
+
+Mark each NAME as read-only; the values of these NAMEs may not be
+changed by subsequent assignment.  If VALUE is supplied, assign VALUE
+before marking as read-only.
+
+Options:
+  -a	refer to indexed array variables
+  -A	refer to associative array variables
+  -f	refer to shell functions
+  -p	display a list of all readonly variables and functions
+
+An argument of `--' disables further option processing.
+
+Exit Status:
+Returns success unless an invalid option is given or NAME is invalid.
+$END
+
+/* For each variable name in LIST, make that variable readonly.  Given an
+   empty LIST, print out all existing readonly variables. */
+int
+readonly_builtin (list)
+     register WORD_LIST *list;
+{
+  return (set_or_show_attributes (list, att_readonly, 0));
+}
+
+#if defined (ARRAY_VARS)
+#  define ATTROPTS	"aAfnp"
+#else
+#  define ATTROPTS	"fnp"
+#endif
+
+/* For each variable name in LIST, make that variable have the specified
+   ATTRIBUTE.  An arg of `-n' says to remove the attribute from the the
+   remaining names in LIST (doesn't work for readonly). */
+int
+set_or_show_attributes (list, attribute, nodefs)
+     register WORD_LIST *list;
+     int attribute, nodefs;
+{
+  register SHELL_VAR *var;
+  int assign, undo, any_failed, assign_error, opt;
+  int functions_only, arrays_only, assoc_only;
+  int aflags;
+  char *name;
+#if defined (ARRAY_VARS)
+  WORD_LIST *nlist, *tlist;
+  WORD_DESC *w;
+#endif
+
+  functions_only = arrays_only = assoc_only = 0;
+  undo = any_failed = assign_error = 0;
+  /* Read arguments from the front of the list. */
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, ATTROPTS)) != -1)
+    {
+      switch (opt)
+	{
+	  case 'n':
+	    undo = 1;
+	    break;
+	  case 'f':
+	    functions_only = 1;
+	    break;
+#if defined (ARRAY_VARS)
+	  case 'a':
+	    arrays_only = 1;
+	    break;
+	  case 'A':
+	    assoc_only = 1;
+	    break;
+#endif
+	  case 'p':
+	    break;
+	  default:
+	    builtin_usage ();
+	    return (EX_USAGE);
+	}
+    }
+  list = loptend;
+
+  if (list)
+    {
+      if (attribute & att_exported)
+	array_needs_making = 1;
+
+      /* Cannot undo readonly status, silently disallowed. */
+      if (undo && (attribute & att_readonly))
+	attribute &= ~att_readonly;
+
+      while (list)
+	{
+	  name = list->word->word;
+
+	  if (functions_only)		/* xxx -f name */
+	    {
+	      var = find_function (name);
+	      if (var == 0)
+		{
+		  builtin_error (_("%s: not a function"), name);
+		  any_failed++;
+		}
+	      else
+		SETVARATTR (var, attribute, undo);
+
+	      list = list->next;
+	      continue;
+	    }
+
+	  /* xxx [-np] name[=value] */
+	  assign = assignment (name, 0);
+
+	  aflags = 0;
+	  if (assign)
+	    {
+	      name[assign] = '\0';
+	      if (name[assign - 1] == '+')
+		{
+		  aflags |= ASS_APPEND;
+		  name[assign - 1] = '\0';
+		}
+	    }
+
+	  if (legal_identifier (name) == 0)
+	    {
+	      sh_invalidid (name);
+	      if (assign)
+		assign_error++;
+	      else
+		any_failed++;
+	      list = list->next;
+	      continue;
+	    }
+
+	  if (assign)	/* xxx [-np] name=value */
+	    {
+	      name[assign] = '=';
+	      if (aflags & ASS_APPEND)
+		name[assign - 1] = '+';
+#if defined (ARRAY_VARS)
+	      /* Let's try something here.  Turn readonly -a xxx=yyy into
+		 declare -ra xxx=yyy and see what that gets us. */
+	      if (arrays_only || assoc_only)
+		{
+		  tlist = list->next;
+		  list->next = (WORD_LIST *)NULL;
+		  w = arrays_only ? make_word ("-ra") : make_word ("-rA");
+		  nlist = make_word_list (w, list);
+		  opt = declare_builtin (nlist);
+		  if (opt != EXECUTION_SUCCESS)
+		    assign_error++;
+		  list->next = tlist;
+		  dispose_word (w);
+		  free (nlist);
+		}
+	      else
+#endif
+	      /* This word has already been expanded once with command
+		 and parameter expansion.  Call do_assignment_no_expand (),
+		 which does not do command or parameter substitution.  If
+		 the assignment is not performed correctly, flag an error. */
+	      if (do_assignment_no_expand (name) == 0)
+		assign_error++;
+	      name[assign] = '\0';
+	      if (aflags & ASS_APPEND)
+		name[assign - 1] = '\0';
+	    }
+
+	  set_var_attribute (name, attribute, undo);
+	  list = list->next;
+	}
+    }
+  else
+    {
+      SHELL_VAR **variable_list;
+      register int i;
+
+      if ((attribute & att_function) || functions_only)
+	{
+	  variable_list = all_shell_functions ();
+	  if (attribute != att_function)
+	    attribute &= ~att_function;	/* so declare -xf works, for example */
+	}
+      else
+	variable_list = all_shell_variables ();
+
+#if defined (ARRAY_VARS)
+      if (attribute & att_array)
+	{
+	  arrays_only++;
+	  if (attribute != att_array)
+	    attribute &= ~att_array;
+	}
+      else if (attribute & att_assoc)
+	{
+	  assoc_only++;
+	  if (attribute != att_assoc)
+	    attribute &= ~att_assoc;
+	}
+#endif
+
+      if (variable_list)
+	{
+	  for (i = 0; var = variable_list[i]; i++)
+	    {
+#if defined (ARRAY_VARS)
+	      if (arrays_only && array_p (var) == 0)
+		continue;
+	      else if (assoc_only && assoc_p (var) == 0)
+		continue;
+#endif
+	      if ((var->attributes & attribute))
+		{
+		  show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
+		  if (any_failed = sh_chkwrite (any_failed))
+		    break;
+		}
+	    }
+	  free (variable_list);
+	}
+    }
+
+  return (assign_error ? EX_BADASSIGN
+		       : ((any_failed == 0) ? EXECUTION_SUCCESS
+  					    : EXECUTION_FAILURE));
+}
+
+/* Show all variable variables (v == 1) or functions (v == 0) with
+   attributes. */
+int
+show_all_var_attributes (v, nodefs)
+     int v, nodefs;
+{
+  SHELL_VAR **variable_list, *var;
+  int any_failed;
+  register int i;
+
+  variable_list = v ? all_shell_variables () : all_shell_functions ();
+  if (variable_list == 0)  
+    return (EXECUTION_SUCCESS);
+
+  for (i = any_failed = 0; var = variable_list[i]; i++)
+    {
+      show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
+      if (any_failed = sh_chkwrite (any_failed))
+        break;
+    }
+  free (variable_list);
+  return (any_failed == 0 ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
+}
+
+/* Show the attributes for shell variable VAR.  If NODEFS is non-zero,
+   don't show function definitions along with the name.  If PATTR is
+   non-zero, it indicates we're being called from `export' or `readonly'.
+   In POSIX mode, this prints the name of the calling builtin (`export'
+   or `readonly') instead of `declare', and doesn't print function defs
+   when called by `export' or `readonly'. */
+int
+show_var_attributes (var, pattr, nodefs)
+     SHELL_VAR *var;
+     int pattr, nodefs;
+{
+  char flags[16], *x;
+  int i;
+
+  i = 0;
+
+  /* pattr == 0 means we are called from `declare'. */
+  if (pattr == 0 || posixly_correct == 0)
+    {
+#if defined (ARRAY_VARS)
+      if (array_p (var))
+	flags[i++] = 'a';
+
+      if (assoc_p (var))
+	flags[i++] = 'A';
+#endif
+
+      if (function_p (var))
+	flags[i++] = 'f';
+
+      if (integer_p (var))
+	flags[i++] = 'i';
+
+      if (readonly_p (var))
+	flags[i++] = 'r';
+
+      if (trace_p (var))
+	flags[i++] = 't';
+
+      if (exported_p (var))
+	flags[i++] = 'x';
+
+      if (capcase_p (var))
+	flags[i++] = 'c';
+
+      if (lowercase_p (var))
+	flags[i++] = 'l';
+
+      if (uppercase_p (var))
+	flags[i++] = 'u';
+    }
+  else
+    {
+#if defined (ARRAY_VARS)
+      if (array_p (var))
+	flags[i++] = 'a';
+
+      if (assoc_p (var))
+	flags[i++] = 'A';
+#endif
+
+      if (function_p (var))
+	flags[i++] = 'f';
+    }
+
+  flags[i] = '\0';
+
+  /* If we're printing functions with definitions, print the function def
+     first, then the attributes, instead of printing output that can't be
+     reused as input to recreate the current state. */
+  if (function_p (var) && nodefs == 0 && (pattr == 0 || posixly_correct == 0))
+    {
+      printf ("%s\n", named_function_string (var->name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL));
+      nodefs++;
+      if (pattr == 0 && i == 1 && flags[0] == 'f')
+	return 0;		/* don't print `declare -f name' */
+    }
+
+  if (pattr == 0 || posixly_correct == 0)
+    printf ("declare -%s ", i ? flags : "-");
+  else if (i)
+    printf ("%s -%s ", this_command_name, flags);
+  else
+    printf ("%s ", this_command_name);
+
+#if defined (ARRAY_VARS)
+  if (array_p (var))
+    print_array_assignment (var, 1);
+  else if (assoc_p (var))
+    print_assoc_assignment (var, 1);
+  else
+#endif
+  /* force `readonly' and `export' to not print out function definitions
+     when in POSIX mode. */
+  if (nodefs || (function_p (var) && pattr != 0 && posixly_correct))
+    printf ("%s\n", var->name);
+  else if (function_p (var))
+    printf ("%s\n", named_function_string (var->name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL));
+  else if (invisible_p (var) || var_isnull (var))
+    printf ("%s\n", var->name);
+  else
+    {
+      x = sh_double_quote (value_cell (var));
+      printf ("%s=%s\n", var->name, x);
+      free (x);
+    }
+  return (0);
+}
+
+int
+show_name_attributes (name, nodefs)
+     char *name;
+     int nodefs;
+{
+  SHELL_VAR *var;
+
+  var = find_variable_internal (name, 1);
+
+  if (var && invisible_p (var) == 0)
+    {
+      show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
+      return (0);
+    }
+  else
+    return (1);
+}
+
+void
+set_var_attribute (name, attribute, undo)
+     char *name;
+     int attribute, undo;
+{
+  SHELL_VAR *var, *tv;
+  char *tvalue;
+
+  if (undo)
+    var = find_variable (name);
+  else
+    {
+      tv = find_tempenv_variable (name);
+      /* XXX -- need to handle case where tv is a temp variable in a
+	 function-scope context, since function_env has been merged into
+	 the local variables table. */
+      if (tv && tempvar_p (tv))
+	{
+	  tvalue = var_isset (tv) ? savestring (value_cell (tv)) : savestring ("");
+
+	  var = bind_variable (tv->name, tvalue, 0);
+	  var->attributes |= tv->attributes & ~att_tempvar;
+	  VSETATTR (tv, att_propagate);
+	  if (var->context != 0)
+	    VSETATTR (var, att_propagate);
+	  SETVARATTR (tv, attribute, undo);	/* XXX */
+
+	  stupidly_hack_special_variables (tv->name);
+
+	  free (tvalue);
+	}
+      else
+	{
+	  var = find_variable_internal (name, 0);
+	  if (var == 0)
+	    {
+	      var = bind_variable (name, (char *)NULL, 0);
+	      VSETATTR (var, att_invisible);
+	    }
+	  else if (var->context != 0)
+	    VSETATTR (var, att_propagate);
+	}
+    }
+
+  if (var)
+    SETVARATTR (var, attribute, undo);
+
+  if (var && (exported_p (var) || (attribute & att_exported)))
+    array_needs_making++;	/* XXX */
+}

builtins/ulimit.def

@@ -118,6 +118,10 @@ extern int errno;
 #  undef HAVE_RESOURCE
 #endif
 
+#if !defined (HAVE_RESOURCE) && defined (HAVE_ULIMIT_H)
+#  include <ulimit.h>
+#endif
+
 #if !defined (RLIMTYPE)
 #  define RLIMTYPE long
 #  define string_to_rlimtype(s) strtol(s, (char **)NULL, 10)

builtins/ulimit.def~

@@ -0,0 +1,776 @@
+This file is ulimit.def, from which is created ulimit.c.
+It implements the builtin "ulimit" in Bash.
+
+Copyright (C) 1987-2009 Free Software Foundation, Inc.
+
+This file is part of GNU Bash, the Bourne Again SHell.
+
+Bash is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Bash is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Bash.  If not, see <http://www.gnu.org/licenses/>.
+
+$PRODUCES ulimit.c
+
+$BUILTIN ulimit
+$FUNCTION ulimit_builtin
+$DEPENDS_ON !_MINIX
+$SHORT_DOC ulimit [-SHacdefilmnpqrstuvx] [limit]
+Modify shell resource limits.
+
+Provides control over the resources available to the shell and processes
+it creates, on systems that allow such control.
+
+Options:
+  -S	use the `soft' resource limit
+  -H	use the `hard' resource limit
+  -a	all current limits are reported
+  -b	the socket buffer size
+  -c	the maximum size of core files created
+  -d	the maximum size of a process's data segment
+  -e	the maximum scheduling priority (`nice')
+  -f	the maximum size of files written by the shell and its children
+  -i	the maximum number of pending signals
+  -l	the maximum size a process may lock into memory
+  -m	the maximum resident set size
+  -n	the maximum number of open file descriptors
+  -p	the pipe buffer size
+  -q	the maximum number of bytes in POSIX message queues
+  -r	the maximum real-time scheduling priority
+  -s	the maximum stack size
+  -t	the maximum amount of cpu time in seconds
+  -u	the maximum number of user processes
+  -v	the size of virtual memory
+  -x	the maximum number of file locks
+
+If LIMIT is given, it is the new value of the specified resource; the
+special LIMIT values `soft', `hard', and `unlimited' stand for the
+current soft limit, the current hard limit, and no limit, respectively.
+Otherwise, the current value of the specified resource is printed.  If
+no option is given, then -f is assumed.
+
+Values are in 1024-byte increments, except for -t, which is in seconds,
+-p, which is in increments of 512 bytes, and -u, which is an unscaled
+number of processes.
+
+Exit Status:
+Returns success unless an invalid option is supplied or an error occurs.
+$END
+
+#if !defined (_MINIX)
+
+#include <config.h>
+
+#include "../bashtypes.h"
+#ifndef _MINIX
+#  include <sys/param.h>
+#endif
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+
+#include "../bashintl.h"
+
+#include "../shell.h"
+#include "common.h"
+#include "bashgetopt.h"
+#include "pipesize.h"
+
+#if !defined (errno)
+extern int errno;
+#endif
+
+/* For some reason, HPUX chose to make these definitions visible only if
+   _KERNEL is defined, so we define _KERNEL before including <sys/resource.h>
+   and #undef it afterward. */
+#if defined (HAVE_RESOURCE)
+#  include <sys/time.h>
+#  if defined (HPUX) && defined (RLIMIT_NEEDS_KERNEL)
+#    define _KERNEL
+#  endif
+#  include <sys/resource.h>
+#  if defined (HPUX) && defined (RLIMIT_NEEDS_KERNEL)
+#    undef _KERNEL
+#  endif
+#elif defined (HAVE_SYS_TIMES_H)
+#  include <sys/times.h>
+#endif
+
+#if defined (HAVE_LIMITS_H)
+#  include <limits.h>
+#endif
+
+/* Check for the most basic symbols.  If they aren't present, this
+   system's <sys/resource.h> isn't very useful to us. */
+#if !defined (RLIMIT_FSIZE) || !defined (HAVE_GETRLIMIT)
+#  undef HAVE_RESOURCE
+#endif
+
+#if !HAVE_RESOURCE && HAVE_ULIMIT_H
+#  include <ulimit.h>
+#endif
+
+#if !defined (RLIMTYPE)
+#  define RLIMTYPE long
+#  define string_to_rlimtype(s) strtol(s, (char **)NULL, 10)
+#  define print_rlimtype(num, nl) printf ("%ld%s", num, nl ? "\n" : "")
+#endif
+
+/* Some systems use RLIMIT_NOFILE, others use RLIMIT_OFILE */
+#if defined (HAVE_RESOURCE) && defined (RLIMIT_OFILE) && !defined (RLIMIT_NOFILE)
+#  define RLIMIT_NOFILE RLIMIT_OFILE
+#endif /* HAVE_RESOURCE && RLIMIT_OFILE && !RLIMIT_NOFILE */
+
+/* Some systems have these, some do not. */
+#ifdef RLIMIT_FSIZE
+#  define RLIMIT_FILESIZE	RLIMIT_FSIZE
+#else
+#  define RLIMIT_FILESIZE	256
+#endif
+
+#define RLIMIT_PIPESIZE	257
+
+#ifdef RLIMIT_NOFILE
+#  define RLIMIT_OPENFILES	RLIMIT_NOFILE
+#else
+#  define RLIMIT_OPENFILES	258
+#endif
+
+#ifdef RLIMIT_VMEM
+#  define RLIMIT_VIRTMEM	RLIMIT_VMEM
+#  define RLIMIT_VMBLKSZ	1024
+#else
+#  ifdef RLIMIT_AS
+#    define RLIMIT_VIRTMEM	RLIMIT_AS
+#    define RLIMIT_VMBLKSZ	1024
+#  else
+#    define RLIMIT_VIRTMEM	259
+#    define RLIMIT_VMBLKSZ	1
+#  endif
+#endif
+
+#ifdef RLIMIT_NPROC
+#  define RLIMIT_MAXUPROC	RLIMIT_NPROC
+#else
+#  define RLIMIT_MAXUPROC	260
+#endif
+
+#if !defined (RLIM_INFINITY)
+#  define RLIM_INFINITY 0x7fffffff
+#endif
+
+#if !defined (RLIM_SAVED_CUR)
+#  define RLIM_SAVED_CUR RLIM_INFINITY
+#endif
+
+#if !defined (RLIM_SAVED_MAX)
+#  define RLIM_SAVED_MAX RLIM_INFINITY
+#endif
+
+#define LIMIT_HARD 0x01
+#define LIMIT_SOFT 0x02
+
+/* "Blocks" are defined as 512 bytes when in Posix mode and 1024 bytes
+   otherwise. */
+#define POSIXBLK	-2
+
+#define BLOCKSIZE(x)	(((x) == POSIXBLK) ? (posixly_correct ? 512 : 1024) : (x))
+
+extern int posixly_correct;
+
+static int _findlim __P((int));
+
+static int ulimit_internal __P((int, char *, int, int));
+
+static int get_limit __P((int, RLIMTYPE *, RLIMTYPE *));
+static int set_limit __P((int, RLIMTYPE, int));
+
+static void printone __P((int, RLIMTYPE, int));
+static void print_all_limits __P((int));
+
+static int set_all_limits __P((int, RLIMTYPE));
+
+static int filesize __P((RLIMTYPE *));
+static int pipesize __P((RLIMTYPE *));
+static int getmaxuprc __P((RLIMTYPE *));
+static int getmaxvm __P((RLIMTYPE *, RLIMTYPE *));
+
+typedef struct {
+  int  option;			/* The ulimit option for this limit. */
+  int  parameter;		/* Parameter to pass to get_limit (). */
+  int  block_factor;		/* Blocking factor for specific limit. */
+  const char * const description;	/* Descriptive string to output. */
+  const char * const units;	/* scale */
+} RESOURCE_LIMITS;
+
+static RESOURCE_LIMITS limits[] = {
+#ifdef RLIMIT_PTHREAD
+  { 'T',	RLIMIT_PTHREAD,  1,	"number of threads",	(char *)NULL },
+#endif
+#ifdef RLIMIT_SBSIZE
+  { 'b',	RLIMIT_SBSIZE,  1,	"socket buffer size",	"bytes" },
+#endif
+#ifdef RLIMIT_CORE
+  { 'c',	RLIMIT_CORE,  POSIXBLK,	"core file size",	"blocks" },
+#endif
+#ifdef RLIMIT_DATA
+  { 'd',	RLIMIT_DATA,  1024,	"data seg size",	"kbytes" },
+#endif
+#ifdef RLIMIT_NICE
+  { 'e',	RLIMIT_NICE,  1,	"scheduling priority",	(char *)NULL },
+#endif
+  { 'f',	RLIMIT_FILESIZE, POSIXBLK,	"file size",		"blocks" },
+#ifdef RLIMIT_SIGPENDING
+  { 'i',	RLIMIT_SIGPENDING, 1,	"pending signals",	(char *)NULL },
+#endif
+#ifdef RLIMIT_MEMLOCK
+  { 'l',	RLIMIT_MEMLOCK, 1024,	"max locked memory",	"kbytes" },
+#endif
+#ifdef RLIMIT_RSS
+  { 'm',	RLIMIT_RSS,   1024,	"max memory size",	"kbytes" },
+#endif /* RLIMIT_RSS */
+  { 'n',	RLIMIT_OPENFILES, 1,	"open files",		(char *)NULL},
+  { 'p',	RLIMIT_PIPESIZE, 512,	"pipe size", 		"512 bytes" },
+#ifdef RLIMIT_MSGQUEUE
+  { 'q',	RLIMIT_MSGQUEUE, 1,	"POSIX message queues",	"bytes" },
+#endif
+#ifdef RLIMIT_RTPRIO
+  { 'r',	RLIMIT_RTPRIO,  1,	"real-time priority",	(char *)NULL },
+#endif
+#ifdef RLIMIT_STACK
+  { 's',	RLIMIT_STACK, 1024,	"stack size",		"kbytes" },
+#endif
+#ifdef RLIMIT_CPU
+  { 't',	RLIMIT_CPU,      1,	"cpu time",		"seconds" },
+#endif /* RLIMIT_CPU */
+  { 'u',	RLIMIT_MAXUPROC, 1,	"max user processes",	(char *)NULL },
+#if defined (HAVE_RESOURCE)
+  { 'v',	RLIMIT_VIRTMEM, RLIMIT_VMBLKSZ, "virtual memory", "kbytes" },
+#endif
+#ifdef RLIMIT_SWAP
+  { 'w',	RLIMIT_SWAP,	1024,	"swap size",		"kbytes" },
+#endif
+#ifdef RLIMIT_LOCKS
+  { 'x',	RLIMIT_LOCKS,	1,	"file locks",		(char *)NULL },
+#endif
+  { -1, -1, -1, (char *)NULL, (char *)NULL }
+};
+#define NCMDS	(sizeof(limits) / sizeof(limits[0]))
+
+typedef struct _cmd {
+  int cmd;
+  char *arg;
+} ULCMD;
+
+static ULCMD *cmdlist;
+static int ncmd;
+static int cmdlistsz;
+
+#if !defined (HAVE_RESOURCE) && !defined (HAVE_ULIMIT)
+long
+ulimit (cmd, newlim)
+     int cmd;
+     long newlim;
+{
+  errno = EINVAL;
+  return -1;
+}
+#endif /* !HAVE_RESOURCE && !HAVE_ULIMIT */
+
+static int
+_findlim (opt)
+     int opt;
+{
+  register int i;
+
+  for (i = 0; limits[i].option > 0; i++)
+    if (limits[i].option == opt)
+      return i;
+  return -1;
+}
+
+static char optstring[4 + 2 * NCMDS];
+
+/* Report or set limits associated with certain per-process resources.
+   See the help documentation in builtins.c for a full description. */
+int
+ulimit_builtin (list)
+     register WORD_LIST *list;
+{
+  register char *s;
+  int c, limind, mode, opt, all_limits;
+
+  mode = 0;
+
+  all_limits = 0;
+
+  /* Idea stolen from pdksh -- build option string the first time called. */
+  if (optstring[0] == 0)
+    {
+      s = optstring;
+      *s++ = 'a'; *s++ = 'S'; *s++ = 'H';
+      for (c = 0; limits[c].option > 0; c++)
+	{
+	  *s++ = limits[c].option;
+	  *s++ = ';';
+	}
+      *s = '\0';
+    }
+
+  /* Initialize the command list. */
+  if (cmdlistsz == 0)
+    cmdlist = (ULCMD *)xmalloc ((cmdlistsz = 16) * sizeof (ULCMD));
+  ncmd = 0;
+
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, optstring)) != -1)
+    {
+      switch (opt)
+	{
+	case 'a':
+	  all_limits++;
+	  break;
+
+	/* -S and -H are modifiers, not real options.  */
+	case 'S':
+	  mode |= LIMIT_SOFT;
+	  break;
+
+	case 'H':
+	  mode |= LIMIT_HARD;
+	  break;
+
+	case '?':
+	  builtin_usage ();
+	  return (EX_USAGE);
+
+	default:
+	  if (ncmd >= cmdlistsz)
+	    cmdlist = (ULCMD *)xrealloc (cmdlist, (cmdlistsz *= 2) * sizeof (ULCMD));
+	  cmdlist[ncmd].cmd = opt;
+	  cmdlist[ncmd++].arg = list_optarg;
+	  break;
+	}
+    }
+  list = loptend;
+
+  if (all_limits)
+    {
+#ifdef NOTYET
+      if (list)		/* setting */
+        {
+          if (STREQ (list->word->word, "unlimited") == 0)
+            {
+              builtin_error (_("%s: invalid limit argument"), list->word->word);
+              return (EXECUTION_FAILURE);
+            }
+          return (set_all_limits (mode == 0 ? LIMIT_SOFT|LIMIT_HARD : mode, RLIM_INFINITY));
+        }
+#endif
+      print_all_limits (mode == 0 ? LIMIT_SOFT : mode);
+      return (sh_chkwrite (EXECUTION_SUCCESS));
+    }
+
+  /* default is `ulimit -f' */
+  if (ncmd == 0)
+    {
+      cmdlist[ncmd].cmd = 'f';
+      /* `ulimit something' is same as `ulimit -f something' */
+      cmdlist[ncmd++].arg = list ? list->word->word : (char *)NULL;
+      if (list)
+	list = list->next;
+    }
+
+  /* verify each command in the list. */
+  for (c = 0; c < ncmd; c++)
+    {
+      limind = _findlim (cmdlist[c].cmd);
+      if (limind == -1)
+	{
+	  builtin_error (_("`%c': bad command"), cmdlist[c].cmd);
+	  return (EX_USAGE);
+	}
+    }
+
+  for (c = 0; c < ncmd; c++)
+    if (ulimit_internal (cmdlist[c].cmd, cmdlist[c].arg, mode, ncmd > 1) == EXECUTION_FAILURE)
+      return (EXECUTION_FAILURE);
+
+  return (EXECUTION_SUCCESS);
+}
+
+static int
+ulimit_internal (cmd, cmdarg, mode, multiple)
+     int cmd;
+     char *cmdarg;
+     int mode, multiple;
+{
+  int opt, limind, setting;
+  int block_factor;
+  RLIMTYPE soft_limit, hard_limit, real_limit, limit;
+
+  setting = cmdarg != 0;
+  limind = _findlim (cmd);
+  if (mode == 0)
+    mode = setting ? (LIMIT_HARD|LIMIT_SOFT) : LIMIT_SOFT;
+  opt = get_limit (limind, &soft_limit, &hard_limit);
+  if (opt < 0)
+    {
+      builtin_error (_("%s: cannot get limit: %s"), limits[limind].description,
+						 strerror (errno));
+      return (EXECUTION_FAILURE);
+    }
+
+  if (setting == 0)	/* print the value of the specified limit */
+    {
+      printone (limind, (mode & LIMIT_SOFT) ? soft_limit : hard_limit, multiple);
+      return (EXECUTION_SUCCESS);
+    }
+ 
+  /* Setting the limit. */
+  if (STREQ (cmdarg, "hard"))
+    real_limit = hard_limit;
+  else if (STREQ (cmdarg, "soft"))
+    real_limit = soft_limit;
+  else if (STREQ (cmdarg, "unlimited"))
+    real_limit = RLIM_INFINITY;
+  else if (all_digits (cmdarg))
+    {
+      limit = string_to_rlimtype (cmdarg);
+      block_factor = BLOCKSIZE(limits[limind].block_factor);
+      real_limit = limit * block_factor;
+
+      if ((real_limit / block_factor) != limit)
+	{
+	  sh_erange (cmdarg, _("limit"));
+	  return (EXECUTION_FAILURE);
+	}
+    }
+  else
+    {
+      sh_invalidnum (cmdarg);
+      return (EXECUTION_FAILURE);
+    }
+
+  if (set_limit (limind, real_limit, mode) < 0)
+    {
+      builtin_error (_("%s: cannot modify limit: %s"), limits[limind].description,
+						    strerror (errno));
+      return (EXECUTION_FAILURE);
+    }
+
+  return (EXECUTION_SUCCESS);
+}
+
+static int
+get_limit (ind, softlim, hardlim)
+     int ind;
+     RLIMTYPE *softlim, *hardlim;
+{
+  RLIMTYPE value;
+#if defined (HAVE_RESOURCE)
+  struct rlimit limit;
+#endif
+
+  if (limits[ind].parameter >= 256)
+    {
+      switch (limits[ind].parameter)
+	{
+	case RLIMIT_FILESIZE:
+	  if (filesize (&value) < 0)
+	    return -1;
+	  break;
+	case RLIMIT_PIPESIZE:
+	  if (pipesize (&value) < 0)
+	    return -1;
+	  break;
+	case RLIMIT_OPENFILES:
+	  value = (RLIMTYPE)getdtablesize ();
+	  break;
+	case RLIMIT_VIRTMEM:
+	  return (getmaxvm (softlim, hardlim));
+	case RLIMIT_MAXUPROC:
+	  if (getmaxuprc (&value) < 0)
+	    return -1;
+	  break;
+	default:
+	  errno = EINVAL;
+	  return -1;
+	}
+      *softlim = *hardlim = value;
+      return (0);
+    }
+  else
+    {
+#if defined (HAVE_RESOURCE)
+      if (getrlimit (limits[ind].parameter, &limit) < 0)
+	return -1;
+      *softlim = limit.rlim_cur;
+      *hardlim = limit.rlim_max;
+#  if defined (HPUX9)
+      if (limits[ind].parameter == RLIMIT_FILESIZE)
+	{
+	  *softlim *= 512;
+	  *hardlim *= 512;			/* Ugh. */
+	}
+      else
+#  endif /* HPUX9 */
+      return 0;
+#else
+      errno = EINVAL;
+      return -1;
+#endif
+    }
+}
+
+static int
+set_limit (ind, newlim, mode)
+     int ind;
+     RLIMTYPE newlim;
+     int mode;
+{
+#if defined (HAVE_RESOURCE)
+   struct rlimit limit;
+   RLIMTYPE val;
+#endif
+
+  if (limits[ind].parameter >= 256)
+    switch (limits[ind].parameter)
+      {
+      case RLIMIT_FILESIZE:
+#if !defined (HAVE_RESOURCE)
+	return (ulimit (2, newlim / 512L));
+#else
+	errno = EINVAL;
+	return -1;
+#endif
+
+      case RLIMIT_OPENFILES:
+#if defined (HAVE_SETDTABLESIZE)
+#  if defined (__CYGWIN__)
+	/* Grrr... Cygwin declares setdtablesize as void. */
+	setdtablesize (newlim);
+	return 0;
+#  else
+	return (setdtablesize (newlim));
+#  endif
+#endif
+      case RLIMIT_PIPESIZE:
+      case RLIMIT_VIRTMEM:
+      case RLIMIT_MAXUPROC:
+      default:
+	errno = EINVAL;
+	return -1;
+      }
+  else
+    {
+#if defined (HAVE_RESOURCE)
+      if (getrlimit (limits[ind].parameter, &limit) < 0)
+	return -1;
+#  if defined (HPUX9)
+      if (limits[ind].parameter == RLIMIT_FILESIZE)
+	newlim /= 512;				/* Ugh. */
+#  endif /* HPUX9 */
+      val = (current_user.euid != 0 && newlim == RLIM_INFINITY &&
+	       (mode & LIMIT_HARD) == 0 &&		/* XXX -- test */
+	       (limit.rlim_cur <= limit.rlim_max))
+		 ? limit.rlim_max : newlim;
+      if (mode & LIMIT_SOFT)
+	limit.rlim_cur = val;
+      if (mode & LIMIT_HARD)
+	limit.rlim_max = val;
+	  
+      return (setrlimit (limits[ind].parameter, &limit));
+#else
+      errno = EINVAL;
+      return -1;
+#endif
+    }
+}
+
+static int
+getmaxvm (softlim, hardlim)
+     RLIMTYPE *softlim, *hardlim;
+{
+#if defined (HAVE_RESOURCE)
+  struct rlimit datalim, stacklim;
+
+  if (getrlimit (RLIMIT_DATA, &datalim) < 0)
+    return -1;
+
+  if (getrlimit (RLIMIT_STACK, &stacklim) < 0)
+    return -1;
+
+  /* Protect against overflow. */
+  *softlim = (datalim.rlim_cur / 1024L) + (stacklim.rlim_cur / 1024L);
+  *hardlim = (datalim.rlim_max / 1024L) + (stacklim.rlim_max / 1024L);
+  return 0;
+#else
+  errno = EINVAL;
+  return -1;
+#endif /* HAVE_RESOURCE */
+}
+
+static int
+filesize(valuep)
+     RLIMTYPE *valuep;
+{
+#if !defined (HAVE_RESOURCE)
+  long result;
+  if ((result = ulimit (1, 0L)) < 0)
+    return -1;
+  else
+    *valuep = (RLIMTYPE) result * 512;
+  return 0;
+#else
+  errno = EINVAL;
+  return -1;
+#endif
+}
+
+static int
+pipesize (valuep)
+     RLIMTYPE *valuep;
+{
+#if defined (PIPE_BUF)
+  /* This is defined on Posix systems. */
+  *valuep = (RLIMTYPE) PIPE_BUF;
+  return 0;
+#else
+#  if defined (_POSIX_PIPE_BUF)
+  *valuep = (RLIMTYPE) _POSIX_PIPE_BUF;
+  return 0;
+#  else
+#    if defined (PIPESIZE)
+  /* This is defined by running a program from the Makefile. */
+  *valuep = (RLIMTYPE) PIPESIZE;
+  return 0;
+#    else
+  errno = EINVAL;
+  return -1;  
+#    endif /* PIPESIZE */
+#  endif /* _POSIX_PIPE_BUF */
+#endif /* PIPE_BUF */
+}
+
+static int
+getmaxuprc (valuep)
+     RLIMTYPE *valuep;
+{
+  long maxchild;
+
+  maxchild = getmaxchild ();
+  if (maxchild < 0)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+  else
+    {
+      *valuep = (RLIMTYPE) maxchild;
+      return 0;
+    }
+}
+
+static void
+print_all_limits (mode)
+     int mode;
+{
+  register int i;
+  RLIMTYPE softlim, hardlim;
+
+  if (mode == 0)
+    mode |= LIMIT_SOFT;
+
+  for (i = 0; limits[i].option > 0; i++)
+    {
+      if (get_limit (i, &softlim, &hardlim) == 0)
+	printone (i, (mode & LIMIT_SOFT) ? softlim : hardlim, 1);
+      else if (errno != EINVAL)
+	builtin_error ("%s: cannot get limit: %s", limits[i].description,
+						   strerror (errno));
+    }
+}
+
+static void
+printone (limind, curlim, pdesc)
+     int limind;
+     RLIMTYPE curlim;
+     int pdesc;
+{
+  char unitstr[64];
+  int factor;
+
+  factor = BLOCKSIZE(limits[limind].block_factor);
+  if (pdesc)
+    {
+      if (limits[limind].units)
+	sprintf (unitstr, "(%s, -%c) ", limits[limind].units, limits[limind].option);
+      else
+        sprintf (unitstr, "(-%c) ", limits[limind].option);
+
+      printf ("%-20s %16s", limits[limind].description, unitstr);
+    }
+  if (curlim == RLIM_INFINITY)
+    puts ("unlimited");
+  else if (curlim == RLIM_SAVED_MAX)
+    puts ("hard");
+  else if (curlim == RLIM_SAVED_CUR)
+    puts ("soft");
+  else
+    print_rlimtype ((curlim / factor), 1);
+}
+
+/* Set all limits to NEWLIM.  NEWLIM currently must be RLIM_INFINITY, which
+   causes all limits to be set as high as possible depending on mode (like
+   csh `unlimit').  Returns -1 if NEWLIM is invalid, 0 if all limits
+   were set successfully, and 1 if at least one limit could not be set.
+
+   To raise all soft limits to their corresponding hard limits, use
+	ulimit -S -a unlimited
+   To attempt to raise all hard limits to infinity (superuser-only), use
+	ulimit -H -a unlimited
+   To attempt to raise all soft and hard limits to infinity, use
+	ulimit -a unlimited
+*/
+
+static int
+set_all_limits (mode, newlim)
+     int mode;
+     RLIMTYPE newlim;
+{
+  register int i;
+  int retval = 0;
+
+  if (newlim != RLIM_INFINITY)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+  
+  if (mode == 0)
+    mode = LIMIT_SOFT|LIMIT_HARD;
+
+  for (retval = i = 0; limits[i].option > 0; i++)
+    if (set_limit (i, newlim, mode) < 0)
+      {
+	builtin_error (_("%s: cannot modify limit: %s"), limits[i].description,
+						      strerror (errno));
+	retval = 1;
+      }
+  return retval;
+}
+
+#endif /* !_MINIX */

config.h.in

@@ -994,6 +994,9 @@
 /* Define if you have the <termios.h> header file.  */
 #undef HAVE_TERMIOS_H
 
+/* Define if you have the <ulimit.h> header file.  */
+#undef HAVE_ULIMIT_H
+
 /* Define if you have the <unistd.h> header file.  */
 #undef HAVE_UNISTD_H
 

configure

@@ -1,7 +1,7 @@
 #! /bin/sh
-# From configure.in for Bash 4.1, version 4.019.
+# From configure.in for Bash 4.1, version 4.020.
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.63 for bash 4.1-release.
+# Generated by GNU Autoconf 2.63 for bash 4.1-maint.
 #
 # Report bugs to <bug-bash@gnu.org>.
 #
@@ -597,8 +597,8 @@ SHELL=${CONFIG_SHELL-/bin/sh}
 # Identity of this package.
 PACKAGE_NAME='bash'
 PACKAGE_TARNAME='bash'
-PACKAGE_VERSION='4.1-release'
-PACKAGE_STRING='bash 4.1-release'
+PACKAGE_VERSION='4.1-maint'
+PACKAGE_STRING='bash 4.1-maint'
 PACKAGE_BUGREPORT='bug-bash@gnu.org'
 
 ac_unique_file="shell.h"
@@ -1411,7 +1411,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures bash 4.1-release to adapt to many kinds of systems.
+\`configure' configures bash 4.1-maint to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1476,7 +1476,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of bash 4.1-release:";;
+     short | recursive ) echo "Configuration of bash 4.1-maint:";;
    esac
   cat <<\_ACEOF
 
@@ -1652,7 +1652,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-bash configure 4.1-release
+bash configure 4.1-maint
 generated by GNU Autoconf 2.63
 
 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
@@ -1666,7 +1666,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by bash $as_me 4.1-release, which was
+It was created by bash $as_me 4.1-maint, which was
 generated by GNU Autoconf 2.63.  Invocation command line was
 
   $ $0 $@
@@ -2080,7 +2080,7 @@ ac_config_headers="$ac_config_headers config.h"
 
 
 BASHVERS=4.1
-RELSTATUS=release
+RELSTATUS=maint
 
 case "$RELSTATUS" in
 alp*|bet*|dev*|rc*|maint*)	DEBUG='-DDEBUG' MALLOC_DEBUG='-DMALLOC_DEBUG' ;;
@@ -11502,12 +11502,13 @@ done
 
 
 
+
 
 
 for ac_header in unistd.h stdlib.h stdarg.h varargs.h limits.h string.h \
 		 memory.h locale.h termcap.h termio.h termios.h dlfcn.h \
 		 stddef.h stdint.h netdb.h pwd.h grp.h strings.h regex.h \
-		 syslog.h
+		 syslog.h ulimit.h
 do
 as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
 if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
@@ -31170,7 +31171,7 @@ exec 6>&1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by bash $as_me 4.1-release, which was
+This file was extended by bash $as_me 4.1-maint, which was
 generated by GNU Autoconf 2.63.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -31233,7 +31234,7 @@ Report bugs to <bug-autoconf@gnu.org>."
 _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_version="\\
-bash config.status 4.1-release
+bash config.status 4.1-maint
 configured by $0, generated by GNU Autoconf 2.63,
   with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
 

configure.in

@@ -21,10 +21,10 @@ dnl Process this file with autoconf to produce a configure script.
 #   You should have received a copy of the GNU General Public License
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-AC_REVISION([for Bash 4.1, version 4.019])dnl
+AC_REVISION([for Bash 4.1, version 4.020])dnl
 
 define(bashvers, 4.1)
-define(relstatus, release)
+define(relstatus, maint)
 
 AC_INIT([bash], bashvers-relstatus, [bug-bash@gnu.org])
 
@@ -659,7 +659,7 @@ BASH_HEADER_INTTYPES
 AC_CHECK_HEADERS(unistd.h stdlib.h stdarg.h varargs.h limits.h string.h \
 		 memory.h locale.h termcap.h termio.h termios.h dlfcn.h \
 		 stddef.h stdint.h netdb.h pwd.h grp.h strings.h regex.h \
-		 syslog.h)
+		 syslog.h ulimit.h)
 AC_CHECK_HEADERS(sys/pte.h sys/stream.h sys/select.h sys/file.h \
 		 sys/resource.h sys/param.h sys/socket.h sys/stat.h \
 		 sys/time.h sys/times.h sys/types.h sys/wait.h)

doc/bash.1

@@ -9429,7 +9429,8 @@ The maximum amount of cpu time in seconds
 The maximum number of processes available to a single user
 .TP
 .B \-v
-The maximum amount of virtual memory available to the shell
+The maximum amount of virtual memory available to the shell and, on
+some systems, to its children
 .TP
 .B \-x
 The maximum number of file locks

doc/bashref.texi

@@ -3939,7 +3939,8 @@ The maximum amount of cpu time in seconds.
 The maximum number of processes available to a single user.
 
 @item -v
-The maximum amount of virtual memory available to the process.
+The maximum amount of virtual memory available to the shell, and, on
+some systems, to its children.
 
 @item -x
 The maximum number of file locks.

expr.c

@@ -137,6 +137,28 @@
    highest precedence. */
 #define EXP_HIGHEST	expcomma
 
+#ifndef MAX_INT_LEN
+#  define MAX_INT_LEN 32
+#endif
+
+struct lvalue
+{
+  char *tokstr;		/* possibly-rewritten lvalue if not NULL */
+  intmax_t tokval;	/* expression evaluated value */
+  SHELL_VAR *tokvar;	/* variable described by array or var reference */
+  intmax_t ind;		/* array index if not -1 */
+};
+
+/* A structure defining a single expression context. */
+typedef struct {
+  int curtok, lasttok;
+  char *expression, *tp, *lasttp;
+  intmax_t tokval;
+  char *tokstr;
+  int noeval;
+  struct lvalue lval;
+} EXPR_CONTEXT;
+
 static char	*expression;	/* The current expression */
 static char	*tp;		/* token lexical position */
 static char	*lasttp;	/* pointer to last token position */
@@ -148,10 +170,17 @@ static intmax_t	tokval;		/* current token value */
 static int	noeval;		/* set to 1 if no assignment to be done */
 static procenv_t evalbuf;
 
+static struct lvalue curlval = {0, 0, 0, -1};
+static struct lvalue lastlval = {0, 0, 0, -1};
+
 static int	_is_arithop __P((int));
 static void	readtok __P((void));	/* lexical analyzer */
 
-static intmax_t	expr_streval __P((char *, int));
+static void	init_lvalue __P((struct lvalue *));
+static struct lvalue *alloc_lvalue __P((void));
+static void	free_lvalue __P((struct lvalue *));
+
+static intmax_t	expr_streval __P((char *, int, struct lvalue *));
 static intmax_t	strlong __P((char *));
 static void	evalerror __P((const char *));
 
@@ -159,6 +188,7 @@ static void	pushexp __P((void));
 static void	popexp __P((void));
 static void	expr_unwind __P((void));
 static void	expr_bind_variable __P((char *, char *));
+static void	expr_bind_array_element __P((char *, arrayind_t, char *));
 
 static intmax_t subexpr __P((char *));
 
@@ -179,23 +209,6 @@ static intmax_t	exppower __P((void));
 static intmax_t exp1 __P((void));
 static intmax_t exp0 __P((void));
 
-/* A structure defining a single expression context. */
-typedef struct {
-  int curtok, lasttok;
-  char *expression, *tp, *lasttp;
-  intmax_t tokval;
-  char *tokstr;
-  int noeval;
-} EXPR_CONTEXT;
-
-#ifdef INCLUDE_UNUSED
-/* Not used yet. */
-typedef struct {
-  char *tokstr;
-  intmax_t tokval;
-} LVALUE;
-#endif
-
 /* Global var which contains the stack of expression contexts. */
 static EXPR_CONTEXT **expr_stack;
 static int expr_depth;		   /* Location in the stack. */
@@ -217,6 +230,7 @@ extern const char * const bash_badsub_errmsg;
     (X)->tokval = tokval; \
     (X)->tokstr = tokstr; \
     (X)->noeval = noeval; \
+    (X)->lval = curlval; \
   } while (0)
 
 #define RESTORETOK(X) \
@@ -228,6 +242,7 @@ extern const char * const bash_badsub_errmsg;
     tokval = (X)->tokval; \
     tokstr = (X)->tokstr; \
     noeval = (X)->noeval; \
+    curlval = (X)->lval; \
   } while (0)
 
 /* Push and save away the contents of the globals describing the
@@ -298,6 +313,32 @@ expr_bind_variable (lhs, rhs)
   stupidly_hack_special_variables (lhs);
 }
 
+/* Rewrite tok, which is of the form vname[expression], to vname[ind], where
+   IND is the already-calculated value of expression. */
+static void
+expr_bind_array_element (tok, ind, rhs)
+     char *tok;
+     arrayind_t ind;
+     char *rhs;
+{
+  char *lhs, *vname;
+  size_t llen;
+  char ibuf[INT_STRLEN_BOUND (arrayind_t) + 1], *istr;
+
+  istr = fmtumax (ind, 10, ibuf, sizeof (ibuf), 0);
+  vname = array_variable_name (tok, (char **)NULL, (int *)NULL);
+
+  llen = strlen (vname) + sizeof (ibuf) + 3;
+  lhs = xmalloc (llen);
+
+  sprintf (lhs, "%s[%s]", vname, istr);		/* XXX */
+  
+  expr_bind_variable (lhs, rhs);
+/*itrace("expr_bind_array_element: %s=%s", lhs, rhs);*/
+  free (vname);
+  free (lhs);
+}
+
 /* Evaluate EXPR, and return the arithmetic result.  If VALIDP is
    non-null, a zero is stored into the location to which it points
    if the expression is invalid, non-zero otherwise.  If a non-zero
@@ -364,12 +405,14 @@ subexpr (expr)
     return (0);
 
   pushexp ();
-  curtok = lasttok = 0;
   expression = savestring (expr);
   tp = expression;
 
+  curtok = lasttok = 0;
   tokstr = (char *)NULL;
   tokval = 0;
+  init_lvalue (&curlval);
+  lastlval = curlval;
 
   readtok ();
 
@@ -406,6 +449,7 @@ expassign ()
 {
   register intmax_t value;
   char *lhs, *rhs;
+  arrayind_t lind;
 
   value = expcond ();
   if (curtok == EQ || curtok == OP_ASSIGN)
@@ -425,6 +469,8 @@ expassign ()
 	}
 
       lhs = savestring (tokstr);
+      /* save ind in case rhs is string var and evaluation overwrites it */
+      lind = curlval.ind;
       readtok ();
       value = expassign ();
 
@@ -476,7 +522,12 @@ expassign ()
 
       rhs = itos (value);
       if (noeval == 0)
-	expr_bind_variable (lhs, rhs);
+	{
+	  if (lind != -1)
+	    expr_bind_array_element (lhs, lind, rhs);
+	  else
+	    expr_bind_variable (lhs, rhs);
+	}
       free (rhs);
       free (lhs);
       FREE (tokstr);
@@ -828,7 +879,12 @@ exp0 ()
       v2 = tokval + ((stok == PREINC) ? 1 : -1);
       vincdec = itos (v2);
       if (noeval == 0)
-	expr_bind_variable (tokstr, vincdec);
+	{
+	  if (curlval.ind != -1)
+	    expr_bind_array_element (curlval.tokstr, curlval.ind, vincdec);
+	  else
+	    expr_bind_variable (tokstr, vincdec);
+	}
       free (vincdec);
       val = v2;
 
@@ -873,12 +929,18 @@ exp0 ()
  	      /* restore certain portions of EC */
  	      tokstr = ec.tokstr;
  	      noeval = ec.noeval;
+ 	      curlval = ec.lval;
  	      lasttok = STR;	/* ec.curtok */
 
 	      v2 = val + ((stok == POSTINC) ? 1 : -1);
 	      vincdec = itos (v2);
 	      if (noeval == 0)
-		expr_bind_variable (tokstr, vincdec);
+		{
+		  if (curlval.ind != -1)
+		    expr_bind_array_element (curlval.tokstr, curlval.ind, vincdec);
+		  else
+		    expr_bind_variable (tokstr, vincdec);
+		}
 	      free (vincdec);
 	      curtok = NUM;	/* make sure x++=7 is flagged as an error */
  	    }
@@ -899,14 +961,44 @@ exp0 ()
   return (val);
 }
 
+static void
+init_lvalue (lv)
+     struct lvalue *lv;
+{
+  lv->tokstr = 0;
+  lv->tokvar = 0;
+  lv->tokval = lv->ind = -1;
+}
+
+static struct lvalue *
+alloc_lvalue ()
+{
+  struct lvalue *lv;
+
+  lv = xmalloc (sizeof (struct lvalue));
+  init_lvalue (lv);
+  return (lv);
+}
+
+static void
+free_lvalue (lv)
+     struct lvalue *lv;
+{
+  free (lv);		/* should be inlined */
+}
+
 static intmax_t
-expr_streval (tok, e)
+expr_streval (tok, e, lvalue)
      char *tok;
      int e;
+     struct lvalue *lvalue;
 {
   SHELL_VAR *v;
   char *value;
   intmax_t tval;
+#if defined (ARRAY_VARS)
+  arrayind_t ind;
+#endif
 
   /* [[[[[ */
 #if defined (ARRAY_VARS)
@@ -941,18 +1033,27 @@ expr_streval (tok, e)
 	jump_to_top_level (FORCE_EOF);
     }
 
+  ind = -1;
 #if defined (ARRAY_VARS)
   /* Second argument of 0 to get_array_value means that we don't allow
      references like array[@].  In this case, get_array_value is just
      like get_variable_value in that it does not return newly-allocated
      memory or quote the results. */
-  value = (e == ']') ? get_array_value (tok, 0, (int *)NULL) : get_variable_value (v);
+  value = (e == ']') ? get_array_value (tok, 0, (int *)NULL, &ind) : get_variable_value (v);
 #else
   value = get_variable_value (v);
 #endif
 
   tval = (value && *value) ? subexpr (value) : 0;
 
+  if (lvalue)
+    {
+      lvalue->tokstr = tok;	/* XXX */
+      lvalue->tokval = tval;
+      lvalue->tokvar = v;	/* XXX */
+      lvalue->ind = ind;
+    }
+	  
   return (tval);
 }
 
@@ -1024,6 +1125,7 @@ readtok ()
   register char *cp, *xp;
   register unsigned char c, c1;
   register int e;
+  struct lvalue lval;
 
   /* Skip leading whitespace. */
   cp = tp;
@@ -1075,6 +1177,7 @@ readtok ()
       tokstr = savestring (tp);
       *cp = c;
 
+      /* XXX - make peektok part of saved token state? */
       SAVETOK (&ec);
       tokstr = (char *)NULL;	/* keep it from being freed */
       tp = savecp = cp;
@@ -1090,7 +1193,10 @@ readtok ()
       /* The tests for PREINC and PREDEC aren't strictly correct, but they
 	 preserve old behavior if a construct like --x=9 is given. */
       if (lasttok == PREINC || lasttok == PREDEC || peektok != EQ)
-	tokval = expr_streval (tokstr, e);
+        {
+          lastlval = curlval;
+	  tokval = expr_streval (tokstr, e, &curlval);
+        }
       else
 	tokval = 0;
 

jobs.c

@@ -77,6 +77,10 @@
 extern int errno;
 #endif /* !errno */
 
+#if !defined (HAVE_KILLPG)
+extern int killpg __P((pid_t, int));
+#endif
+
 #define DEFAULT_CHILD_MAX 32
 #if !defined (DEBUG)
 #define MAX_JOBS_IN_ARRAY 4096		/* production */

lib/sh/oslib.c

@@ -37,6 +37,10 @@
 #include <filecntl.h>
 #include <bashansi.h>
 
+#if !defined (HAVE_KILLPG)
+#  include <signal.h>
+#endif
+
 #include <stdio.h>
 #include <errno.h>
 #include <chartypes.h>
@@ -209,7 +213,8 @@ gethostname (name, namelen)
 #  else /* !HAVE_UNAME */
 int
 gethostname (name, namelen)
-     int name, namelen;
+     char *name;
+     int namelen;
 {
   strncpy (name, "unknown", namelen);
   name[namelen] = '\0';

lib/sh/oslib.c~

@@ -0,0 +1,300 @@
+/* oslib.c - functions present only in some unix versions. */
+
+/* Copyright (C) 1995 Free Software Foundation, Inc.
+
+   This file is part of GNU Bash, the Bourne Again SHell.
+
+   Bash is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Bash is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <config.h>
+
+#include <bashtypes.h>
+#ifndef _MINIX
+#  include <sys/param.h>
+#endif
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>
+#endif
+
+#if defined (HAVE_LIMITS_H)
+#  include <limits.h>
+#endif
+
+#include <posixstat.h>
+#include <filecntl.h>
+#include <bashansi.h>
+
+#if !defined (HAVE_KILLPG)
+#  include <signal.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <chartypes.h>
+
+#include <shell.h>
+
+#if !defined (errno)
+extern int errno;
+#endif /* !errno */
+
+/* Make the functions strchr and strrchr if they do not exist. */
+#if !defined (HAVE_STRCHR)
+char *
+strchr (string, c)
+     char *string;
+     int c;
+{
+  register char *s;
+
+  for (s = string; s && *s; s++)
+    if (*s == c)
+      return (s);
+
+  return ((char *) NULL);
+}
+
+char *
+strrchr (string, c)
+     char *string;
+     int c;
+{
+  register char *s, *t;
+
+  for (s = string, t = (char *)NULL; s && *s; s++)
+    if (*s == c)
+      t = s;
+  return (t);
+}
+#endif /* !HAVE_STRCHR */
+
+#if !defined (HAVE_DUP2) || defined (DUP2_BROKEN)
+/* Replacement for dup2 (), for those systems which either don't have it,
+   or supply one with broken behaviour. */
+int
+dup2 (fd1, fd2)
+     int fd1, fd2;
+{
+  int saved_errno, r;
+
+  /* If FD1 is not a valid file descriptor, then return immediately with
+     an error. */
+  if (fcntl (fd1, F_GETFL, 0) == -1)
+    return (-1);
+
+  if (fd2 < 0 || fd2 >= getdtablesize ())
+    {
+      errno = EBADF;
+      return (-1);
+    }
+
+  if (fd1 == fd2)
+    return (0);
+
+  saved_errno = errno;
+
+  (void) close (fd2);
+  r = fcntl (fd1, F_DUPFD, fd2);
+
+  if (r >= 0)
+    errno = saved_errno;
+  else
+    if (errno == EINVAL)
+      errno = EBADF;
+
+  /* Force the new file descriptor to remain open across exec () calls. */
+  SET_OPEN_ON_EXEC (fd2);
+  return (r);
+}
+#endif /* !HAVE_DUP2 */
+
+/*
+ * Return the total number of available file descriptors.
+ *
+ * On some systems, like 4.2BSD and its descendents, there is a system call
+ * that returns the size of the descriptor table: getdtablesize().  There are
+ * lots of ways to emulate this on non-BSD systems.
+ *
+ * On System V.3, this can be obtained via a call to ulimit:
+ *	return (ulimit(4, 0L));
+ *
+ * On other System V systems, NOFILE is defined in /usr/include/sys/param.h
+ * (this is what we assume below), so we can simply use it:
+ *	return (NOFILE);
+ *
+ * On POSIX systems, there are specific functions for retrieving various
+ * configuration parameters:
+ *	return (sysconf(_SC_OPEN_MAX));
+ *
+ */
+
+#if !defined (HAVE_GETDTABLESIZE)
+int
+getdtablesize ()
+{
+#  if defined (_POSIX_VERSION) && defined (HAVE_SYSCONF) && defined (_SC_OPEN_MAX)
+  return (sysconf(_SC_OPEN_MAX));	/* Posix systems use sysconf */
+#  else /* ! (_POSIX_VERSION && HAVE_SYSCONF && _SC_OPEN_MAX) */
+#    if defined (ULIMIT_MAXFDS)
+  return (ulimit (4, 0L));	/* System V.3 systems use ulimit(4, 0L) */
+#    else /* !ULIMIT_MAXFDS */
+#      if defined (NOFILE)	/* Other systems use NOFILE */
+  return (NOFILE);
+#      else /* !NOFILE */
+  return (20);			/* XXX - traditional value is 20 */
+#      endif /* !NOFILE */
+#    endif /* !ULIMIT_MAXFDS */
+#  endif /* ! (_POSIX_VERSION && _SC_OPEN_MAX) */
+}
+#endif /* !HAVE_GETDTABLESIZE */
+
+#if !defined (HAVE_BCOPY)
+#  if defined (bcopy)
+#    undef bcopy
+#  endif
+void
+bcopy (s,d,n)
+     char *d, *s;
+     int n;
+{
+  FASTCOPY (s, d, n);
+}
+#endif /* !HAVE_BCOPY */
+
+#if !defined (HAVE_BZERO)
+#  if defined (bzero)
+#    undef bzero
+#  endif
+void
+bzero (s, n)
+     char *s;
+     int n;
+{
+  register int i;
+  register char *r;
+
+  for (i = 0, r = s; i < n; i++)
+    *r++ = '\0';
+}
+#endif
+
+#if !defined (HAVE_GETHOSTNAME)
+#  if defined (HAVE_UNAME)
+#    include <sys/utsname.h>
+int
+gethostname (name, namelen)
+     char *name;
+     int namelen;
+{
+  int i;
+  struct utsname ut;
+
+  --namelen;
+
+  uname (&ut);
+  i = strlen (ut.nodename) + 1;
+  strncpy (name, ut.nodename, i < namelen ? i : namelen);
+  name[namelen] = '\0';
+  return (0);
+}
+#  else /* !HAVE_UNAME */
+int
+gethostname (name, namelen)
+     int name, namelen;
+{
+  strncpy (name, "unknown", namelen);
+  name[namelen] = '\0';
+  return 0;
+}
+#  endif /* !HAVE_UNAME */
+#endif /* !HAVE_GETHOSTNAME */
+
+#if !defined (HAVE_KILLPG)
+int
+killpg (pgrp, sig)
+     pid_t pgrp;
+     int sig;
+{
+  return (kill (-pgrp, sig));
+}
+#endif /* !HAVE_KILLPG */
+
+#if !defined (HAVE_MKFIFO) && defined (PROCESS_SUBSTITUTION)
+int
+mkfifo (path, mode)
+     char *path;
+     int mode;
+{
+#if defined (S_IFIFO)
+  return (mknod (path, (mode | S_IFIFO), 0));
+#else /* !S_IFIFO */
+  return (-1);
+#endif /* !S_IFIFO */
+}
+#endif /* !HAVE_MKFIFO && PROCESS_SUBSTITUTION */
+
+#define DEFAULT_MAXGROUPS 64
+
+int
+getmaxgroups ()
+{
+  static int maxgroups = -1;
+
+  if (maxgroups > 0)
+    return maxgroups;
+
+#if defined (HAVE_SYSCONF) && defined (_SC_NGROUPS_MAX)
+  maxgroups = sysconf (_SC_NGROUPS_MAX);
+#else
+#  if defined (NGROUPS_MAX)
+  maxgroups = NGROUPS_MAX;
+#  else /* !NGROUPS_MAX */
+#    if defined (NGROUPS)
+  maxgroups = NGROUPS;
+#    else /* !NGROUPS */
+  maxgroups = DEFAULT_MAXGROUPS;
+#    endif /* !NGROUPS */
+#  endif /* !NGROUPS_MAX */  
+#endif /* !HAVE_SYSCONF || !SC_NGROUPS_MAX */
+
+  if (maxgroups <= 0)
+    maxgroups = DEFAULT_MAXGROUPS;
+
+  return maxgroups;
+}
+
+long
+getmaxchild ()
+{
+  static long maxchild = -1L;
+
+  if (maxchild > 0)
+    return maxchild;
+
+#if defined (HAVE_SYSCONF) && defined (_SC_CHILD_MAX)
+  maxchild = sysconf (_SC_CHILD_MAX);
+#else
+#  if defined (CHILD_MAX)
+  maxchild = CHILD_MAX;
+#  else
+#    if defined (MAXUPRC)
+  maxchild = MAXUPRC;
+#    endif /* MAXUPRC */
+#  endif /* CHILD_MAX */
+#endif /* !HAVE_SYSCONF || !_SC_CHILD_MAX */
+
+  return (maxchild);
+}

print_cmd.c

@@ -1120,6 +1120,10 @@ print_redirection (redirect)
 	cprintf ("{%s}", redir_word->word);
       else if (redirector != 0)
 	cprintf ("%d", redirector);
+#if 0
+      /* Don't need to check whether or not to requote, since original quotes
+         are still intact.  The only thing that has happened is that $'...'
+         has been replaced with 'expanded ...'. */
       if (ansic_shouldquote (redirect->redirectee.filename->word))
 	{
 	  char *x;
@@ -1128,6 +1132,7 @@ print_redirection (redirect)
 	  free (x);
 	}
       else
+#endif
 	cprintf ("<<< %s", redirect->redirectee.filename->word);
       break;
 

sig.c

@@ -60,6 +60,8 @@ extern int executing_list;
 extern int comsub_ignore_return;
 extern int parse_and_execute_level, shell_initialized;
 
+extern void intialize_siglist ();
+
 /* Non-zero after SIGINT. */
 volatile int interrupt_state = 0;
 

sig.c~

@@ -0,0 +1,664 @@
+/* sig.c - interface for shell signal handlers and signal initialization. */
+
+/* Copyright (C) 1994-2009 Free Software Foundation, Inc.
+
+   This file is part of GNU Bash, the Bourne Again SHell.
+
+   Bash is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Bash is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "config.h"
+
+#include "bashtypes.h"
+
+#if defined (HAVE_UNISTD_H)
+#  ifdef _MINIX
+#    include <sys/types.h>
+#  endif
+#  include <unistd.h>
+#endif
+
+#include <stdio.h>
+#include <signal.h>
+
+#include "bashintl.h"
+
+#include "shell.h"
+#if defined (JOB_CONTROL)
+#include "jobs.h"
+#endif /* JOB_CONTROL */
+#include "siglist.h"
+#include "sig.h"
+#include "trap.h"
+
+#include "builtins/common.h"
+
+#if defined (READLINE)
+#  include "bashline.h"
+#endif
+
+#if defined (HISTORY)
+#  include "bashhist.h"
+#endif
+
+extern int last_command_exit_value;
+extern int last_command_exit_signal;
+extern int return_catch_flag;
+extern int loop_level, continuing, breaking;
+extern int executing_list;
+extern int comsub_ignore_return;
+extern int parse_and_execute_level, shell_initialized;
+
+/* Non-zero after SIGINT. */
+volatile int interrupt_state = 0;
+
+/* Non-zero after SIGWINCH */
+volatile int sigwinch_received = 0;
+
+/* Set to the value of any terminating signal received. */
+volatile int terminating_signal = 0;
+
+/* The environment at the top-level R-E loop.  We use this in
+   the case of error return. */
+procenv_t top_level;
+
+#if defined (JOB_CONTROL) || defined (HAVE_POSIX_SIGNALS)
+/* The signal masks that this shell runs with. */
+sigset_t top_level_mask;
+#endif /* JOB_CONTROL */
+
+/* When non-zero, we throw_to_top_level (). */
+int interrupt_immediately = 0;
+
+/* When non-zero, we call the terminating signal handler immediately. */
+int terminate_immediately = 0;
+
+#if defined (SIGWINCH)
+static SigHandler *old_winch = (SigHandler *)SIG_DFL;
+#endif
+
+static void initialize_shell_signals __P((void));
+
+void
+initialize_signals (reinit)
+     int reinit;
+{
+  initialize_shell_signals ();
+  initialize_job_signals ();
+#if !defined (HAVE_SYS_SIGLIST) && !defined (HAVE_UNDER_SYS_SIGLIST) && !defined (HAVE_STRSIGNAL)
+  if (reinit == 0)
+    initialize_siglist ();
+#endif /* !HAVE_SYS_SIGLIST && !HAVE_UNDER_SYS_SIGLIST && !HAVE_STRSIGNAL */
+}
+
+/* A structure describing a signal that terminates the shell if not
+   caught.  The orig_handler member is present so children can reset
+   these signals back to their original handlers. */
+struct termsig {
+     int signum;
+     SigHandler *orig_handler;
+     int orig_flags;
+};
+
+#define NULL_HANDLER (SigHandler *)SIG_DFL
+
+/* The list of signals that would terminate the shell if not caught.
+   We catch them, but just so that we can write the history file,
+   and so forth. */
+static struct termsig terminating_signals[] = {
+#ifdef SIGHUP
+{  SIGHUP, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGINT
+{  SIGINT, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGILL
+{  SIGILL, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGTRAP
+{  SIGTRAP, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGIOT
+{  SIGIOT, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGDANGER
+{  SIGDANGER, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGEMT
+{  SIGEMT, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGFPE
+{  SIGFPE, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGBUS
+{  SIGBUS, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGSEGV
+{  SIGSEGV, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGSYS
+{  SIGSYS, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGPIPE
+{  SIGPIPE, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGALRM
+{  SIGALRM, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGTERM
+{  SIGTERM, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGXCPU
+{  SIGXCPU, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGXFSZ
+{  SIGXFSZ, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGVTALRM
+{  SIGVTALRM, NULL_HANDLER, 0 },
+#endif
+
+#if 0
+#ifdef SIGPROF
+{  SIGPROF, NULL_HANDLER, 0 },
+#endif
+#endif
+
+#ifdef SIGLOST
+{  SIGLOST, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGUSR1
+{  SIGUSR1, NULL_HANDLER, 0 },
+#endif
+
+#ifdef SIGUSR2
+{  SIGUSR2, NULL_HANDLER, 0 },
+#endif
+};
+
+#define TERMSIGS_LENGTH (sizeof (terminating_signals) / sizeof (struct termsig))
+
+#define XSIG(x) (terminating_signals[x].signum)
+#define XHANDLER(x) (terminating_signals[x].orig_handler)
+#define XSAFLAGS(x) (terminating_signals[x].orig_flags)
+
+static int termsigs_initialized = 0;
+
+/* Initialize signals that will terminate the shell to do some
+   unwind protection.  For non-interactive shells, we only call
+   this when a trap is defined for EXIT (0). */
+void
+initialize_terminating_signals ()
+{
+  register int i;
+#if defined (HAVE_POSIX_SIGNALS)
+  struct sigaction act, oact;
+#endif
+
+  if (termsigs_initialized)
+    return;
+
+  /* The following code is to avoid an expensive call to
+     set_signal_handler () for each terminating_signals.  Fortunately,
+     this is possible in Posix.  Unfortunately, we have to call signal ()
+     on non-Posix systems for each signal in terminating_signals. */
+#if defined (HAVE_POSIX_SIGNALS)
+  act.sa_handler = termsig_sighandler;
+  act.sa_flags = 0;
+  sigemptyset (&act.sa_mask);
+  sigemptyset (&oact.sa_mask);
+  for (i = 0; i < TERMSIGS_LENGTH; i++)
+    sigaddset (&act.sa_mask, XSIG (i));
+  for (i = 0; i < TERMSIGS_LENGTH; i++)
+    {
+      /* If we've already trapped it, don't do anything. */
+      if (signal_is_trapped (XSIG (i)))
+	continue;
+
+      sigaction (XSIG (i), &act, &oact);
+      XHANDLER(i) = oact.sa_handler;
+      XSAFLAGS(i) = oact.sa_flags;
+      /* Don't do anything with signals that are ignored at shell entry
+	 if the shell is not interactive. */
+      if (!interactive_shell && XHANDLER (i) == SIG_IGN)
+	{
+	  sigaction (XSIG (i), &oact, &act);
+	  set_signal_ignored (XSIG (i));
+	}
+#if defined (SIGPROF) && !defined (_MINIX)
+      if (XSIG (i) == SIGPROF && XHANDLER (i) != SIG_DFL && XHANDLER (i) != SIG_IGN)
+	sigaction (XSIG (i), &oact, (struct sigaction *)NULL);
+#endif /* SIGPROF && !_MINIX */
+    }
+
+#else /* !HAVE_POSIX_SIGNALS */
+
+  for (i = 0; i < TERMSIGS_LENGTH; i++)
+    {
+      /* If we've already trapped it, don't do anything. */
+      if (signal_is_trapped (XSIG (i)))
+	continue;
+
+      XHANDLER(i) = signal (XSIG (i), termsig_sighandler);
+      XSAFLAGS(i) = 0;
+      /* Don't do anything with signals that are ignored at shell entry
+	 if the shell is not interactive. */
+      if (!interactive_shell && XHANDLER (i) == SIG_IGN)
+	{
+	  signal (XSIG (i), SIG_IGN);
+	  set_signal_ignored (XSIG (i));
+	}
+#ifdef SIGPROF
+      if (XSIG (i) == SIGPROF && XHANDLER (i) != SIG_DFL && XHANDLER (i) != SIG_IGN)
+	signal (XSIG (i), XHANDLER (i));
+#endif
+    }
+
+#endif /* !HAVE_POSIX_SIGNALS */
+
+  termsigs_initialized = 1;
+}
+
+static void
+initialize_shell_signals ()
+{
+  if (interactive)
+    initialize_terminating_signals ();
+
+#if defined (JOB_CONTROL) || defined (HAVE_POSIX_SIGNALS)
+  /* All shells use the signal mask they inherit, and pass it along
+     to child processes.  Children will never block SIGCHLD, though. */
+  sigemptyset (&top_level_mask);
+  sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &top_level_mask);
+#  if defined (SIGCHLD)
+  sigdelset (&top_level_mask, SIGCHLD);
+#  endif
+#endif /* JOB_CONTROL || HAVE_POSIX_SIGNALS */
+
+  /* And, some signals that are specifically ignored by the shell. */
+  set_signal_handler (SIGQUIT, SIG_IGN);
+
+  if (interactive)
+    {
+      set_signal_handler (SIGINT, sigint_sighandler);
+      set_signal_handler (SIGTERM, SIG_IGN);
+      set_sigwinch_handler ();
+    }
+}
+
+void
+reset_terminating_signals ()
+{
+  register int i;
+#if defined (HAVE_POSIX_SIGNALS)
+  struct sigaction act;
+#endif
+
+  if (termsigs_initialized == 0)
+    return;
+
+#if defined (HAVE_POSIX_SIGNALS)
+  act.sa_flags = 0;
+  sigemptyset (&act.sa_mask);
+  for (i = 0; i < TERMSIGS_LENGTH; i++)
+    {
+      /* Skip a signal if it's trapped or handled specially, because the
+	 trap code will restore the correct value. */
+      if (signal_is_trapped (XSIG (i)) || signal_is_special (XSIG (i)))
+	continue;
+
+      act.sa_handler = XHANDLER (i);
+      act.sa_flags = XSAFLAGS (i);
+      sigaction (XSIG (i), &act, (struct sigaction *) NULL);
+    }
+#else /* !HAVE_POSIX_SIGNALS */
+  for (i = 0; i < TERMSIGS_LENGTH; i++)
+    {
+      if (signal_is_trapped (XSIG (i)) || signal_is_special (XSIG (i)))
+	continue;
+
+      signal (XSIG (i), XHANDLER (i));
+    }
+#endif /* !HAVE_POSIX_SIGNALS */
+}
+#undef XSIG
+#undef XHANDLER
+
+/* Run some of the cleanups that should be performed when we run
+   jump_to_top_level from a builtin command context.  XXX - might want to
+   also call reset_parser here. */
+void
+top_level_cleanup ()
+{
+  /* Clean up string parser environment. */
+  while (parse_and_execute_level)
+    parse_and_execute_cleanup ();
+
+#if defined (PROCESS_SUBSTITUTION)
+  unlink_fifo_list ();
+#endif /* PROCESS_SUBSTITUTION */
+
+  run_unwind_protects ();
+  loop_level = continuing = breaking = 0;
+  executing_list = comsub_ignore_return = return_catch_flag = 0;
+}
+
+/* What to do when we've been interrupted, and it is safe to handle it. */
+void
+throw_to_top_level ()
+{
+  int print_newline = 0;
+
+  if (interrupt_state)
+    {
+      print_newline = 1;
+      DELINTERRUPT;
+    }
+
+  if (interrupt_state)
+    return;
+
+  last_command_exit_signal = (last_command_exit_value > 128) ?
+				(last_command_exit_value - 128) : 0;
+  last_command_exit_value |= 128;
+
+  /* Run any traps set on SIGINT. */
+  run_interrupt_trap ();
+
+  /* Clean up string parser environment. */
+  while (parse_and_execute_level)
+    parse_and_execute_cleanup ();
+
+#if defined (JOB_CONTROL)
+  give_terminal_to (shell_pgrp, 0);
+#endif /* JOB_CONTROL */
+
+#if defined (JOB_CONTROL) || defined (HAVE_POSIX_SIGNALS)
+  /* This should not be necessary on systems using sigsetjmp/siglongjmp. */
+  sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
+#endif
+
+  reset_parser ();
+
+#if defined (READLINE)
+  if (interactive)
+    bashline_reset ();
+#endif /* READLINE */
+
+#if defined (PROCESS_SUBSTITUTION)
+  unlink_fifo_list ();
+#endif /* PROCESS_SUBSTITUTION */
+
+  run_unwind_protects ();
+  loop_level = continuing = breaking = 0;
+  executing_list = comsub_ignore_return = return_catch_flag = 0;
+
+  if (interactive && print_newline)
+    {
+      fflush (stdout);
+      fprintf (stderr, "\n");
+      fflush (stderr);
+    }
+
+  /* An interrupted `wait' command in a script does not exit the script. */
+  if (interactive || (interactive_shell && !shell_initialized) ||
+      (print_newline && signal_is_trapped (SIGINT)))
+    jump_to_top_level (DISCARD);
+  else
+    jump_to_top_level (EXITPROG);
+}
+
+/* This is just here to isolate the longjmp calls. */
+void
+jump_to_top_level (value)
+     int value;
+{
+  longjmp (top_level, value);
+}
+
+sighandler
+termsig_sighandler (sig)
+     int sig;
+{
+  /* If we get called twice with the same signal before handling it,
+     terminate right away. */
+  if (
+#ifdef SIGHUP
+    sig != SIGHUP &&
+#endif
+#ifdef SIGINT
+    sig != SIGINT &&
+#endif
+#ifdef SIGDANGER
+    sig != SIGDANGER &&
+#endif
+#ifdef SIGPIPE
+    sig != SIGPIPE &&
+#endif
+#ifdef SIGALRM
+    sig != SIGALRM &&
+#endif
+#ifdef SIGTERM
+    sig != SIGTERM &&
+#endif
+#ifdef SIGXCPU
+    sig != SIGXCPU &&
+#endif
+#ifdef SIGXFSZ
+    sig != SIGXFSZ &&
+#endif
+#ifdef SIGVTALRM
+    sig != SIGVTALRM &&
+#endif
+#ifdef SIGLOST
+    sig != SIGLOST &&
+#endif
+#ifdef SIGUSR1
+    sig != SIGUSR1 &&
+#endif
+#ifdef SIGUSR2
+   sig != SIGUSR2 &&
+#endif
+   sig == terminating_signal)
+    terminate_immediately = 1;
+
+  terminating_signal = sig;
+
+  /* XXX - should this also trigger when interrupt_immediately is set? */
+  if (terminate_immediately)
+    {
+      terminate_immediately = 0;
+      termsig_handler (sig);
+    }
+
+  SIGRETURN (0);
+}
+
+void
+termsig_handler (sig)
+     int sig;
+{
+  static int handling_termsig = 0;
+
+  /* Simple semaphore to keep this function from being executed multiple
+     times.  Since we no longer are running as a signal handler, we don't
+     block multiple occurrences of the terminating signals while running. */
+  if (handling_termsig)
+    return;
+  handling_termsig = 1;
+  terminating_signal = 0;	/* keep macro from re-testing true. */
+
+  /* I don't believe this condition ever tests true. */
+  if (sig == SIGINT && signal_is_trapped (SIGINT))
+    run_interrupt_trap ();
+
+#if defined (HISTORY)
+  if (interactive_shell && sig != SIGABRT)
+    maybe_save_shell_history ();
+#endif /* HISTORY */
+
+#if defined (JOB_CONTROL)
+  if (sig == SIGHUP && (interactive || (subshell_environment & (SUBSHELL_COMSUB|SUBSHELL_PROCSUB))))
+    hangup_all_jobs ();
+  end_job_control ();
+#endif /* JOB_CONTROL */
+
+#if defined (PROCESS_SUBSTITUTION)
+  unlink_fifo_list ();
+#endif /* PROCESS_SUBSTITUTION */
+
+  /* Reset execution context */
+  loop_level = continuing = breaking = 0;
+  executing_list = comsub_ignore_return = return_catch_flag = 0;
+
+  run_exit_trap ();
+  set_signal_handler (sig, SIG_DFL);
+  kill (getpid (), sig);
+}
+
+/* What we really do when SIGINT occurs. */
+sighandler
+sigint_sighandler (sig)
+     int sig;
+{
+#if defined (MUST_REINSTALL_SIGHANDLERS)
+  signal (sig, sigint_sighandler);
+#endif
+
+  /* interrupt_state needs to be set for the stack of interrupts to work
+     right.  Should it be set unconditionally? */
+  if (interrupt_state == 0)
+    ADDINTERRUPT;
+
+  if (interrupt_immediately)
+    {
+      interrupt_immediately = 0;
+      last_command_exit_value = 128 + sig;
+      throw_to_top_level ();
+    }
+
+  SIGRETURN (0);
+}
+
+#if defined (SIGWINCH)
+sighandler
+sigwinch_sighandler (sig)
+     int sig;
+{
+#if defined (MUST_REINSTALL_SIGHANDLERS)
+  set_signal_handler (SIGWINCH, sigwinch_sighandler);
+#endif /* MUST_REINSTALL_SIGHANDLERS */
+  sigwinch_received = 1;
+  SIGRETURN (0);
+}
+#endif /* SIGWINCH */
+
+void
+set_sigwinch_handler ()
+{
+#if defined (SIGWINCH)
+ old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
+#endif
+}
+
+void
+unset_sigwinch_handler ()
+{
+#if defined (SIGWINCH)
+  set_signal_handler (SIGWINCH, old_winch);
+#endif
+}
+
+/* Signal functions used by the rest of the code. */
+#if !defined (HAVE_POSIX_SIGNALS)
+
+#if defined (JOB_CONTROL)
+/* Perform OPERATION on NEWSET, perhaps leaving information in OLDSET. */
+sigprocmask (operation, newset, oldset)
+     int operation, *newset, *oldset;
+{
+  int old, new;
+
+  if (newset)
+    new = *newset;
+  else
+    new = 0;
+
+  switch (operation)
+    {
+    case SIG_BLOCK:
+      old = sigblock (new);
+      break;
+
+    case SIG_SETMASK:
+      sigsetmask (new);
+      break;
+
+    default:
+      internal_error (_("sigprocmask: %d: invalid operation"), operation);
+    }
+
+  if (oldset)
+    *oldset = old;
+}
+#endif /* JOB_CONTROL */
+
+#else
+
+#if !defined (SA_INTERRUPT)
+#  define SA_INTERRUPT 0
+#endif
+
+#if !defined (SA_RESTART)
+#  define SA_RESTART 0
+#endif
+
+SigHandler *
+set_signal_handler (sig, handler)
+     int sig;
+     SigHandler *handler;
+{
+  struct sigaction act, oact;
+
+  act.sa_handler = handler;
+  act.sa_flags = 0;
+#if 0
+  if (sig == SIGALRM)
+    act.sa_flags |= SA_INTERRUPT;	/* XXX */
+  else
+    act.sa_flags |= SA_RESTART;		/* XXX */
+#endif
+  sigemptyset (&act.sa_mask);
+  sigemptyset (&oact.sa_mask);
+  sigaction (sig, &act, &oact);
+  return (oact.sa_handler);
+}
+#endif /* HAVE_POSIX_SIGNALS */

subst.c

@@ -5243,6 +5243,7 @@ array_length_reference (s)
   char *akey;
   char *t, c;
   ARRAY *array;
+  HASH_TABLE *h;
   SHELL_VAR *var;
 
   var = array_variable_part (s, &t, &len);
@@ -5266,15 +5267,16 @@ array_length_reference (s)
      v[*].  Return 0 for everything else. */
 
   array = array_p (var) ? array_cell (var) : (ARRAY *)NULL;
+  h = assoc_p (var) ? assoc_cell (var) : (HASH_TABLE *)NULL;
 
   if (ALL_ELEMENT_SUB (t[0]) && t[1] == ']')
     {
       if (assoc_p (var))
-	return (assoc_num_elements (assoc_cell (var)));
+	return (h ? assoc_num_elements (h) : 0);
       else if (array_p (var))
-	return (array_num_elements (array));
+	return (array ? array_num_elements (array) : 0);
       else
-	return 1;
+	return (var_isset (var) ? 1 : 0);
     }
 
   if (assoc_p (var))
@@ -5432,7 +5434,7 @@ parameter_brace_expand_word (name, var_is_special, quoted, pflags)
 #if defined (ARRAY_VARS)
   else if (valid_array_reference (name))
     {
-      temp = array_value (name, quoted, &atype);
+      temp = array_value (name, quoted, &atype, (arrayind_t *)NULL);
       if (atype == 0 && temp)
  	temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
  		  ? quote_string (temp)
@@ -5967,7 +5969,7 @@ get_var_and_type (varname, value, quoted, varp, valp)
 	  else
 	    {
 	      vtype = VT_ARRAYMEMBER;
-	      *valp = array_value (varname, 1, (int *)NULL);
+	      *valp = array_value (varname, 1, (int *)NULL, (arrayind_t *)NULL);
 	    }
 	  *varp = v;
 	}
@@ -5984,7 +5986,7 @@ get_var_and_type (varname, value, quoted, varp, valp)
 	{
 	  vtype = VT_ARRAYMEMBER;
 	  *varp = v;
-	  *valp = array_value (varname, 1, (int *)NULL);
+	  *valp = array_value (varname, 1, (int *)NULL, (arrayind_t *)NULL);
 	}
     }
   else if ((v = find_variable (varname)) && (invisible_p (v) == 0) && (assoc_p (v) || array_p (v)))

tests/RUN-ONE-TEST

@@ -1,4 +1,4 @@
-BUILD_DIR=/usr/local/build/chet/bash/bash-current
+BUILD_DIR=/usr/local/build/bash/bash-current
 THIS_SH=$BUILD_DIR/bash
 PATH=$PATH:$BUILD_DIR
 

tests/RUN-ONE-TEST~

@@ -0,0 +1,9 @@
+BUILD_DIR=/usr/local/build/chet/bash/bash-current
+THIS_SH=$BUILD_DIR/bash
+PATH=$PATH:$BUILD_DIR
+
+export THIS_SH PATH
+
+rm -f /tmp/xx
+
+/bin/sh "$@"

variables.c

@@ -1309,7 +1309,6 @@ get_random (var)
 
   rv = get_random_number ();
   last_random_value = rv;
-fprintf(stderr, "get_random: rv = %d\n", rv);
   p = itos (rv);
 
   FREE (value_cell (var));