CWRU/CWRU.chlog

@@ -9260,3 +9260,45 @@ examples/loadables/stat.c
 
 examples/loadables/Makefile.in
 	- stat: now built and installed by default
+
+				   12/31
+				   -----
+command.h
+	- SUBSHELL_IGNTRAP: new flag value
+
+jobs.c
+	- make_child: set SUBSHELL_IGNTRAP in subshell_environment in the
+	  child process, meaning that we should not execute trap handlers for
+	  trapped signals
+
+execute_cmd.c
+	- execute_in_subshell, execute_simple_command, execute_disk_command:
+	  make sure to unset SUBSHELL_IGNTRAP after a child process restores
+	  the original signal dispositions
+	- execute_simple_command: make sure to set SUBSHELL_IGNTRAP after
+	  make_child returns and we're setting subshell_environment directly
+
+subst.c
+	- command_substitute,process_substitute: unset SUBSHELL_IGNTRAP after
+	  the child process has reset the trapped signal dispositions
+
+trap.c
+	- trap_handler: if we get a signal for which we have set a trap, but
+	  SUBSHELL_IGNTRAP is set in subshell_environmnent, make sure we
+	  restore the original signal disposition and resend the signal to
+	  ourselves. Fixes issue reported by Nikolay Borisov <nborisov@suse.com>
+	  (or at least makes the race window much smaller)
+
+sig.c
+	- initialize_terminating_signal: set the original signal handler from
+	  the return value from sigaction; a minor optimization that saves a
+	  system call or two
+
+				 1/5/2021
+				 --------
+builtins/declare.def
+	- declare_internal: make some option combinations that don't make
+	  sense errors (e.g., -f and -a/-A/-i/-n)
+	- declare_internal: if we build a new variable name by expanding the
+	  value of a nameref variable, make sure to chop the `+' in a `+='
+	  off before going on

MANIFEST

@@ -1214,6 +1214,7 @@ tests/nameref18.sub	f
 tests/nameref19.sub	f
 tests/nameref20.sub	f
 tests/nameref21.sub	f
+tests/nameref22.sub	f
 tests/nameref.right	f
 tests/new-exp.tests	f
 tests/new-exp1.sub	f

builtins/declare.def

 This file is declare.def, from which is created declare.c.
 It implements the builtins "declare" and "local" in Bash.
 
-Copyright (C) 1987-2020 Free Software Foundation, Inc.
+Copyright (C) 1987-2021 Free Software Foundation, Inc.
 
 This file is part of GNU Bash, the Bourne Again SHell.
 
@@ -306,6 +306,24 @@ declare_internal (list, local_var)
       return (sh_chkwrite (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS));
     }
 
+  /* Some option combinations that don't make any sense */
+  if ((flags_on & att_function) && (flags_on & (att_array|att_assoc|att_integer|att_nameref)))
+    {
+      char *optchar;
+
+      if (flags_on & att_nameref)
+	optchar = "-n";
+      else if (flags_on & att_integer)
+	optchar = "-i";
+      else if (flags_on & att_assoc)
+	optchar = "-A";
+      else if (flags_on & att_array)
+	optchar = "-a";
+
+      sh_invalidopt (optchar);	
+      return (EXECUTION_FAILURE);
+    }
+
 #define NEXT_VARIABLE() free (name); list = list->next; continue
 
   /* There are arguments left, so we are making variables. */
@@ -698,8 +716,8 @@ restart_new_var_name:
 			  assign_error++;
 			  NEXT_VARIABLE ();
 			}
-		      name[offset] = '\0';
-		      value = name + namelen;
+		      name[(aflags & ASS_APPEND) ? offset - 1 : offset] = '\0';
+		      value = name + namelen;	/* XXX name + offset + 1? */
 		    }
 		  free (oldname);
 

builtins/declare.def.1

+This file is declare.def, from which is created declare.c.
+It implements the builtins "declare" and "local" in Bash.
+
+Copyright (C) 1987-2021 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 declare.c
+
+$BUILTIN declare
+$FUNCTION declare_builtin
+$SHORT_DOC declare [-aAfFgiIlnrtux] [-p] [name[=value] ...]
+Set variable values and attributes.
+
+Declare variables and give them attributes.  If no NAMEs are given,
+display the attributes and values of all variables.
+
+Options:
+  -f	restrict action or display to function names and definitions
+  -F	restrict display to function names only (plus line number and
+		source file when debugging)
+  -g	create global variables when used in a shell function; otherwise
+		ignored
+  -I	if creating a local variable, inherit the attributes and value
+		of a variable with the same name at a previous scope
+  -p	display the attributes and value of each NAME
+
+Options which set attributes:
+  -a	to make NAMEs indexed arrays (if supported)
+  -A	to make NAMEs associative arrays (if supported)
+  -i	to make NAMEs have the `integer' attribute
+  -l	to convert the value of each NAME to lower case on assignment
+  -n	make NAME a reference to the variable named by its value
+  -r	to make NAMEs readonly
+  -t	to make NAMEs have the `trace' attribute
+  -u	to convert the value of each NAME to upper case on assignment
+  -x	to make NAMEs export
+
+Using `+' instead of `-' turns off the given attribute.
+
+Variables with the integer attribute have arithmetic evaluation (see
+the `let' command) performed when the variable is assigned a value.
+
+When used in a function, `declare' makes NAMEs local, as with the `local'
+command.  The `-g' option suppresses this behavior.
+
+Exit Status:
+Returns success unless an invalid option is supplied or a variable
+assignment error occurs.
+$END
+
+$BUILTIN typeset
+$FUNCTION declare_builtin
+$SHORT_DOC typeset [-aAfFgiIlnrtux] [-p] name[=value] ...
+Set variable values and attributes.
+
+A synonym for `declare'.  See `help declare'.
+$END
+
+#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 "../flags.h"
+#include "common.h"
+#include "builtext.h"
+#include "bashgetopt.h"
+
+static SHELL_VAR *declare_find_variable PARAMS((const char *, int, int));
+static int declare_internal PARAMS((register WORD_LIST *, int));
+
+/* Declare or change variable attributes. */
+int
+declare_builtin (list)
+     register WORD_LIST *list;
+{
+  return (declare_internal (list, 0));
+}
+
+$BUILTIN local
+$FUNCTION local_builtin
+$SHORT_DOC local [option] name[=value] ...
+Define local variables.
+
+Create a local variable called NAME, and give it VALUE.  OPTION can
+be any option accepted by `declare'.
+
+Local variables can only be used within a function; they are visible
+only to the function where they are defined and its children.
+
+Exit Status:
+Returns success unless an invalid option is supplied, a variable
+assignment error occurs, or the shell is not executing a function.
+$END
+int
+local_builtin (list)
+     register WORD_LIST *list;
+{
+  /* Catch a straight `local --help' before checking function context */
+  if (list && list->word && STREQ (list->word->word, "--help"))
+    {
+      builtin_help ();
+      return (EX_USAGE);
+    }
+    
+  if (variable_context)
+    return (declare_internal (list, 1));
+  else
+    {
+      builtin_error (_("can only be used in a function"));
+      return (EXECUTION_FAILURE);
+    }
+}
+
+#if defined (ARRAY_VARS)
+#  define DECLARE_OPTS	"+acfgilnprtuxAFGI"
+#else
+#  define DECLARE_OPTS	"+cfgilnprtuxFGI"
+#endif
+
+static SHELL_VAR *
+declare_find_variable (name, mkglobal, chklocal)
+     const char *name;
+     int mkglobal, chklocal;
+{
+  SHELL_VAR *var;
+
+  if (mkglobal == 0)
+    return (find_variable (name));
+  else if (chklocal)
+    {
+      var = find_variable (name);
+      if (var && local_p (var) && var->context == variable_context)
+	return var;
+      return (find_global_variable (name));
+    }
+  else
+    return (find_global_variable (name));
+}
+
+/* Build a new string
+	NAME[SUBSCRIPT][[+]=VALUE]
+   from expanding a nameref into NAME */
+static char *
+declare_build_newname (name, subscript_start, value, offset, aflags)
+     char *name, *subscript_start, *value;
+     int offset, aflags;
+{
+  size_t namelen, savelen;
+  char *ret;
+
+  savelen = namelen = strlen (name);
+  if (subscript_start)
+    {
+      *subscript_start = '[';		/* ] */
+      namelen += strlen (subscript_start);
+    }
+  ret = xmalloc (namelen + 2 + strlen (value) + 1);
+  strcpy (ret, name);
+  if (subscript_start)
+    strcpy (ret + savelen, subscript_start);
+  if (offset)
+    {
+      if (aflags & ASS_APPEND)
+	ret[namelen++] = '+';
+      ret[namelen++] = '=';
+      if (value && *value)
+	strcpy (ret + namelen, value);
+      else
+	ret[namelen] = '\0';
+    }
+
+  return (ret);
+}
+
+/* The workhorse function. */
+static int
+declare_internal (list, local_var)
+     register WORD_LIST *list;
+     int local_var;
+{
+  int flags_on, flags_off, *flags;
+  int any_failed, assign_error, pflag, nodefs, opt, onref, offref;
+  int mkglobal, chklocal, inherit_flag;
+  char *t, *subscript_start;
+  SHELL_VAR *var, *refvar, *v;
+  FUNCTION_DEF *shell_fn;
+
+  flags_on = flags_off = any_failed = assign_error = pflag = nodefs = 0;
+  mkglobal = chklocal = inherit_flag = 0;
+  refvar = (SHELL_VAR *)NULL;
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, DECLARE_OPTS)) != -1)
+    {
+      flags = list_opttype == '+' ? &flags_off : &flags_on;
+
+      /* If you add options here, see whether or not they need to be added to
+	 the loop in subst.c:shell_expand_word_list() */
+      switch (opt)
+	{
+	case 'a':
+#if defined (ARRAY_VARS)
+	  *flags |= att_array;
+	  break;
+#else
+	  builtin_usage ();
+	  return (EX_USAGE);
+#endif
+	case 'A':
+#if defined (ARRAY_VARS)
+	  *flags |= att_assoc;
+	  break;
+#else
+	  builtin_usage ();
+	  return (EX_USAGE);
+#endif
+	case 'p':
+/*	  if (local_var == 0) */
+	    pflag++;
+	  break;
+        case 'F':
+	  nodefs++;
+	  *flags |= att_function;
+	  break;
+	case 'f':
+	  *flags |= att_function;
+	  break;
+	case 'G':
+	  if (flags == &flags_on)
+	    chklocal = 1;
+	  /*FALLTHROUGH*/
+	case 'g':
+	  if (flags == &flags_on)
+	    mkglobal = 1;
+	  break;
+	case 'i':
+	  *flags |= att_integer;
+	  break;
+	case 'n':
+	  *flags |= att_nameref;
+	  break;
+	case 'r':
+	  *flags |= att_readonly;
+	  break;
+	case 't':
+	  *flags |= att_trace;
+	  break;
+	case 'x':
+	  *flags |= att_exported;
+	  array_needs_making = 1;
+	  break;
+#if defined (CASEMOD_ATTRS)
+#  if defined (CASEMOD_CAPCASE)
+	 case 'c':
+	  *flags |= att_capcase;
+	  if (flags == &flags_on)
+	    flags_off |= att_uppercase|att_lowercase;
+	  break;
+#  endif
+	case 'l':
+	  *flags |= att_lowercase;
+	  if (flags == &flags_on)
+	    flags_off |= att_capcase|att_uppercase;
+	  break;
+	case 'u':
+	  *flags |= att_uppercase;
+	  if (flags == &flags_on)
+	    flags_off |= att_capcase|att_lowercase;
+	  break;
+#endif /* CASEMOD_ATTRS */
+	case 'I':
+	  inherit_flag = MKLOC_INHERIT;
+	  break;
+	CASE_HELPOPT;
+	default:
+	  builtin_usage ();
+	  return (EX_USAGE);
+	}
+    }
+
+  list = loptend;
+
+  /* If there are no more arguments left, then we just want to show
+     some variables. */
+  if (list == 0)	/* declare -[aAfFirtx] */
+    {
+      /* Show local variables defined at this context level if this is
+	 the `local' builtin. */
+      if (local_var)
+	show_local_var_attributes (0, nodefs);	/* XXX - fix up args later */
+      else if (pflag && (flags_on == 0 || flags_on == att_function))
+	show_all_var_attributes (flags_on == 0, nodefs);
+      else if (flags_on == 0)
+	return (set_builtin ((WORD_LIST *)NULL));
+      else
+	set_or_show_attributes ((WORD_LIST *)NULL, flags_on, nodefs);
+
+      return (sh_chkwrite (EXECUTION_SUCCESS));
+    }
+
+  if (pflag)	/* declare -p [-aAfFirtx] name [name...] */
+    {
+      for (any_failed = 0; list; list = list->next)
+	{
+	  if (flags_on & att_function)
+	    pflag = show_func_attributes (list->word->word, nodefs);
+	  else if (local_var)
+	    pflag = show_localname_attributes (list->word->word, nodefs);
+	  else
+	    pflag = show_name_attributes (list->word->word, nodefs);
+	  if (pflag)
+	    {
+	      sh_notfound (list->word->word);
+	      any_failed++;
+	    }
+	}
+      return (sh_chkwrite (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS));
+    }
+
+  /* Some option combinations that don't make any sense */
+  if ((flags_on & att_function) && (flags_on & (att_array|att_assoc|att_integer|att_nameref)))
+    {
+      char *optchar;
+
+      if (flags_on & att_nameref)
+	optchar = "-n";
+      else if (flags_on & att_integer)
+	optchar = "-i";
+      else if (flags_on & att_assoc)
+	optchar = "-A";
+      else if (flags_on & att_array)
+	optchar = "-a";
+
+      sh_invalidopt (optchar);	
+      return (EXECUTION_FAILURE);
+    }
+
+#define NEXT_VARIABLE() free (name); list = list->next; continue
+
+  /* There are arguments left, so we are making variables. */
+  while (list)		/* declare [-aAfFirx] name [name ...] */
+    {
+      char *value, *name, *oldname;
+      int offset, aflags, wflags, created_var;
+      int assoc_noexpand;
+#if defined (ARRAY_VARS)
+      int making_array_special, compound_array_assign, simple_array_assign;
+      int var_exists, array_exists, creating_array, array_subscript_assignment;
+#endif
+
+      name = savestring (list->word->word);
+      wflags = list->word->flags;
+#if defined (ARRAY_VARS)
+      assoc_noexpand = assoc_expand_once && (wflags & W_ASSIGNMENT);
+#else
+      assoc_noexpand = 0;
+#endif
+      offset = assignment (name, assoc_noexpand ? 2 : 0);
+      aflags = 0;
+      created_var = 0;
+
+      if (local_var && variable_context && STREQ (name, "-"))
+	{
+	  var = make_local_variable ("-", 0);
+	  FREE (value_cell (var));		/* just in case */
+	  value = get_current_options ();
+	  var_setvalue (var, value);
+	  VSETATTR (var, att_invisible);
+	  NEXT_VARIABLE ();
+	}
+
+      /* Can't define functions using assignment statements */
+      if (offset && (flags_on & att_function))	/* declare -f [-rix] foo=bar */
+	{
+	  builtin_error (_("cannot use `-f' to make functions"));
+	  free (name);
+	  return (EXECUTION_FAILURE);
+	}
+
+      /* If we are declaring a function, then complain about it in some way.
+	 We don't let people make functions by saying `typeset -f foo=bar'. */
+
+      /* There should be a way, however, to let people look at a particular
+	 function definition by saying `typeset -f foo'.  This is the only
+	 place we deal with functions. */
+
+      if (flags_on & att_function)
+	{
+	  /* Should we restrict this when the shell is in posix mode even if
+	     the function was created before the shell entered posix mode?
+	     Previous versions of the shell enforced the restriction. */
+	  if (posixly_correct && legal_identifier (name) == 0)
+	    {
+	      sh_invalidid (name);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+
+	  var = find_function (name);
+
+	  if (var)
+	    {
+	      if (readonly_p (var) && (flags_off & att_readonly))
+		{
+		  builtin_error (_("%s: readonly function"), name);
+		  any_failed++;
+		  NEXT_VARIABLE ();
+		}
+	      /* declare -[Ff] name [name...] */
+	      if (flags_on == att_function && flags_off == 0)
+		{
+#if defined (DEBUGGER)
+		  if (nodefs && debugging_mode)
+		    {
+		      shell_fn = find_function_def (var->name);
+		      if (shell_fn)
+			printf ("%s %d %s\n", var->name, shell_fn->line, shell_fn->source_file);
+		      else
+			printf ("%s\n", var->name);
+		    }
+		  else
+#endif /* DEBUGGER */
+		    {	
+		      t = nodefs ? var->name : named_function_string (name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL);
+		      printf ("%s\n", t);
+		      any_failed = sh_chkwrite (any_failed);
+		    }
+		}
+	      else		/* declare -[fF] -[rx] name [name...] */
+		{
+		  VSETATTR (var, flags_on);
+		  flags_off &= ~att_function;	/* makes no sense */
+		  VUNSETATTR (var, flags_off);
+		}
+	    }
+	  else
+	    any_failed++;
+
+	  NEXT_VARIABLE ();
+	}
+
+      if (offset)	/* declare [-aAfFirx] name=value */
+	{
+	  name[offset] = '\0';
+	  value = name + offset + 1;
+	  if (name[offset - 1] == '+')
+	    {
+	      aflags |= ASS_APPEND;
+	      name[offset - 1] = '\0';
+	    }
+	}
+      else
+	value = "";
+
+      /* Do some lexical error checking on the LHS and RHS of the assignment
+	 that is specific to nameref variables. */
+      if (flags_on & att_nameref)
+	{
+#if defined (ARRAY_VARS)
+	  if (valid_array_reference (name, 0))
+	    {
+	      builtin_error (_("%s: reference variable cannot be an array"), name);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+	  else
+#endif
+	  /* disallow self references at global scope, warn at function scope */
+	  if (check_selfref (name, value, 0))
+	    {
+	      if (variable_context == 0)
+		{
+		  builtin_error (_("%s: nameref variable self references not allowed"), name);
+		  assign_error++;
+		  NEXT_VARIABLE ();
+		}
+	      else
+		builtin_warning (_("%s: circular name reference"), name);
+	    }
+	  if (value && *value && (aflags & ASS_APPEND) == 0 && valid_nameref_value (value, 1) == 0)
+	    {
+	      builtin_error (_("`%s': invalid variable name for name reference"), value);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+	}
+
+restart_new_var_name:
+
+      /* The rest of the loop body deals with declare -[aAinrx] name [name...] */
+
+      subscript_start = (char *)NULL;	/* used below */
+#if defined (ARRAY_VARS)
+      /* Determine whether we are creating or assigning an array variable */
+      var_exists = array_exists = creating_array = 0;
+      compound_array_assign = simple_array_assign = 0;
+      array_subscript_assignment = 0;
+      if (t = strchr (name, '['))	/* ] */
+	{
+	  /* If offset != 0 we have already validated any array reference
+	     because assignment() calls skipsubscript() */
+	  if (offset == 0 && valid_array_reference (name, 0) == 0)
+	    {
+	      sh_invalidid (name);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+	  subscript_start = t;
+	  *t = '\0';
+	  making_array_special = 1;	/* XXX - should this check offset? */
+	  array_subscript_assignment = offset != 0;
+	}
+      else
+	making_array_special = 0;
+#endif
+
+      /* Ensure the argument is a valid, well-formed shell identifier. */
+      if (legal_identifier (name) == 0)
+	{
+	  sh_invalidid (name);
+	  assign_error++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* If VARIABLE_CONTEXT has a non-zero value, then we are executing
+	 inside of a function.  This means we should make local variables,
+	 not global ones. */
+
+      /* XXX - this has consequences when we're making a local copy of a
+	       variable that was in the temporary environment.  Watch out
+	       for this. */
+      refvar = (SHELL_VAR *)NULL;
+      if (variable_context && mkglobal == 0)
+	{
+	  char *newname;
+
+	  /* We don't check newname for validity here. We should not have an
+	     invalid name assigned as the value of a nameref, but this could
+	     cause problems. */
+	  var = find_variable (name);
+	  if (var == 0)
+	    newname = nameref_transform_name (name, ASS_MKLOCAL);
+	  else if ((flags_on & att_nameref) == 0 && (flags_off & att_nameref) == 0)
+	    {
+	      /* Ok, we're following namerefs here, so let's make sure that if
+		 we followed one, it was at the same context (see below for
+		 more details). */
+	      refvar = find_variable_last_nameref (name, 1);
+	      newname = (refvar && refvar->context != variable_context) ? name : var->name;
+	      refvar = (SHELL_VAR *)NULL;
+	    }
+	  else
+	    newname = name;	/* dealing with nameref attribute */
+
+#if defined (ARRAY_VARS)
+	  /* Pass 1 as second argument to make_local_{assoc,array}_variable
+	     return an existing {array,assoc} variable to be flagged as an
+	     error below. */
+	  if (flags_on & att_assoc)
+	    var = make_local_assoc_variable (newname, MKLOC_ARRAYOK|inherit_flag);
+	  else if ((flags_on & att_array) || making_array_special)
+	    var = make_local_array_variable (newname, MKLOC_ASSOCOK|inherit_flag);
+	  else
+#endif
+	  if (offset == 0 && (flags_on & att_nameref))
+	    {
+	      /* First look for refvar at current scope */
+	      refvar = find_variable_last_nameref (name, 1);
+	      /* VARIABLE_CONTEXT != 0, so we are attempting to create or modify
+		 the attributes for a local variable at the same scope.  If we've
+		 used a reference from a previous context to resolve VAR, we
+		 want to throw REFVAR and VAR away and create a new local var. */
+	      if (refvar && refvar->context != variable_context)
+		{
+		  refvar = 0;
+		  var = make_local_variable (name, inherit_flag);
+		}
+	      else if (refvar && refvar->context == variable_context)
+		var = refvar;
+	      /* Maybe we just want to create a new local variable */
+	      else if (var == 0 || var->context != variable_context)
+		var = make_local_variable (name, inherit_flag);
+	      /* otherwise we have a var at the right context */
+	    }
+	  else
+	    /* XXX - check name for validity here with valid_nameref_value? */
+	    var = make_local_variable ((flags_on & att_nameref) ? name : newname, inherit_flag);	/* sets att_invisible for new vars */
+
+	  if (var == 0)
+	    {
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+	  if (var && nameref_p (var) && readonly_p (var) && nameref_cell (var) && (flags_off & att_nameref))
+	    {
+	      sh_readonly (name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+	}
+      else
+	var = (SHELL_VAR *)NULL;
+
+      /* VAR is non-null if we just created or fetched a local variable. */
+
+      /* Here's what ksh93 seems to do as of the 2012 version: if we are
+	 using declare -n to modify the value of an existing nameref
+	 variable, don't follow the nameref chain at all and just search
+	 for a nameref at the current context.  If we have a nameref,
+	 modify its value (changing which variable it references). */
+      if (var == 0 && (flags_on & att_nameref))
+	{
+	  /* See if we are trying to modify an existing nameref variable,
+	     but don't follow the nameref chain. */
+	  var = mkglobal ? find_global_variable_noref (name) : find_variable_noref (name);
+	  if (var && nameref_p (var) == 0)
+	    var = 0;
+	}
+
+      /* However, if we're turning off the nameref attribute on an existing
+	 nameref variable, we first follow the nameref chain to the end,
+	 modify the value of the variable this nameref variable references
+	 if there is an assignment statement argument,
+	 *CHANGING ITS VALUE AS A SIDE EFFECT*, then turn off the nameref
+	 flag *LEAVING THE NAMEREF VARIABLE'S VALUE UNCHANGED* */
+      else if (var == 0 && (flags_off & att_nameref))
+	{
+	  /* See if we are trying to modify an existing nameref variable */
+	     refvar = mkglobal ? find_global_variable_last_nameref (name, 0) : find_variable_last_nameref (name, 0);
+	  if (refvar && nameref_p (refvar) == 0)
+	    refvar = 0;
+	  /* If the nameref is readonly but doesn't have a value, ksh93
+	     allows the nameref attribute to be removed.  If it's readonly
+	     and has a value, even if the value doesn't reference an
+	     existing variable, we disallow the modification */
+	  if (refvar && nameref_cell (refvar) && readonly_p (refvar))
+	    {
+	      sh_readonly (name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+
+	  /* If all we're doing is turning off the nameref attribute, don't
+	     bother with VAR at all, whether it exists or not. Just turn it
+	     off and go on. */
+	  if (refvar && flags_on == 0 && offset == 0 && (flags_off & ~att_nameref) == 0)
+	    {
+	      VUNSETATTR (refvar, att_nameref);
+	      NEXT_VARIABLE ();
+	    }
+
+	  if (refvar)
+	    var = declare_find_variable (nameref_cell (refvar), mkglobal, 0);
+	}
+#if defined (ARRAY_VARS)
+      /* If we have an array assignment to a nameref, remove the nameref
+	 attribute and go on.  This handles
+	 declare -n xref[=value]; declare -a xref[1]=one */
+      else if (var == 0 && offset && array_subscript_assignment)
+	{
+	  var = mkglobal ? find_global_variable_noref (name) : find_variable_noref (name);
+	  if (var && nameref_p (var))
+	    {
+	      internal_warning (_("%s: removing nameref attribute"), name);
+	      FREE (value_cell (var));		/* XXX - bash-4.3 compat */
+	      var_setvalue (var, (char *)NULL);
+	      VUNSETATTR (var, att_nameref);
+	    }
+	}
+#endif
+
+      /* See if we are trying to set flags or value (or create) for an
+	 existing nameref that points to a non-existent variable: e.g.,
+		declare -n foo=bar
+		unset foo	# unsets bar
+		declare -i foo
+		foo=4+4
+		declare -p foo
+      */
+      if (var == 0 && (mkglobal || flags_on || flags_off || offset))
+	{
+	  refvar = mkglobal ? find_global_variable_last_nameref (name, 0) : find_variable_last_nameref (name, 0);
+	  if (refvar && nameref_p (refvar) == 0)
+	    refvar = 0;
+	  if (refvar)
+	    var = declare_find_variable (nameref_cell (refvar), mkglobal, 0);
+	  if (refvar && var == 0)
+	    {
+	      oldname = name;	/* need to free this */
+
+	      /* I'm not sure subscript_start is ever non-null here. In any
+		 event, build a new name from the nameref value, including any
+		 subscript, and add the [[+]=value] if offset != 0 */
+	      name = declare_build_newname (nameref_cell (refvar), subscript_start, value, offset, aflags);
+
+	      if (offset)
+	        {
+		  offset = assignment (name, 0);
+		  /* If offset was valid previously, but substituting the
+		     the nameref value results in an invalid assignment,
+		     throw an invalid identifier error */
+		  if (offset == 0)
+		    {
+		      free (oldname);
+		      sh_invalidid (name);
+		      assign_error++;
+		      NEXT_VARIABLE ();
+		    }
+		  name[(aflags & ASS_APPEND) ? offset - 1 : offset] = '\0';
+		  value = name + offset + 1;
+		}
+	      free (oldname);
+
+	      /* OK, let's turn off the nameref attribute.
+		 Now everything else applies to VAR. */
+	      if (flags_off & att_nameref)
+		VUNSETATTR (refvar, att_nameref);
+
+	      goto restart_new_var_name;
+	      /* NOTREACHED */
+	    }
+	}
+      if (var == 0)
+	var = declare_find_variable (name, mkglobal, chklocal);
+
+      /* At this point, VAR is the variable we are dealing with; REFVAR is the
+	 nameref variable we dereferenced to get VAR, if any. */
+#if defined (ARRAY_VARS)
+      var_exists = var != 0;
+      array_exists = var && (array_p (var) || assoc_p (var));
+      creating_array = flags_on & (att_array|att_assoc);
+#endif
+
+      /* Make a new variable if we need to. */
+      if (var == 0)
+	{
+#if defined (ARRAY_VARS)
+	  if (flags_on & att_assoc)
+	    {
+	      var = make_new_assoc_variable (name);
+	      if (var && offset == 0)
+		VSETATTR (var, att_invisible);
+	    }
+	  else if ((flags_on & att_array) || making_array_special)
+	    {
+	      var = make_new_array_variable (name);
+	      if (var && offset == 0)
+	        VSETATTR (var, att_invisible);
+	    }
+	  else
+#endif
+	    {
+	      var = mkglobal ? bind_global_variable (name, (char *)NULL, ASS_FORCE) : bind_variable (name, (char *)NULL, ASS_FORCE);
+	      if (var && offset == 0)
+	        VSETATTR (var, att_invisible);
+	    }
+	  if (var == 0)
+	    {
+	      /* Has to appear in brackets */
+	      NEXT_VARIABLE ();
+	    }
+	  created_var = 1;
+	}
+      /* Nameref variable error checking. */
+
+      /* Can't take an existing array variable and make it a nameref */
+      else if ((array_p (var) || assoc_p (var)) && (flags_on & att_nameref))
+	{
+	  builtin_error (_("%s: reference variable cannot be an array"), name);
+	  assign_error++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't have an invalid identifier as nameref value */
+      else if (nameref_p (var) && (flags_on & att_nameref) == 0 && (flags_off & att_nameref) == 0 && offset && valid_nameref_value (value, 1) == 0)
+	{
+	  builtin_error (_("`%s': invalid variable name for name reference"), value);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't make an existing variable a nameref if its current value is not
+	 a valid identifier. Check of offset is to allow an assignment to a
+	 nameref var as part of the declare word to override existing value. */
+      else if ((flags_on & att_nameref) && nameref_p (var) == 0 && var_isset (var) && offset == 0 && valid_nameref_value (value_cell (var), 0) == 0)
+	{
+	  builtin_error (_("`%s': invalid variable name for name reference"), value_cell (var));
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't make an existing readonly variable a nameref. */
+      else if ((flags_on & att_nameref) && readonly_p (var))
+	{
+	  sh_readonly (name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* ksh93 compat: turning on nameref attribute turns off -ilu */
+      if (flags_on & att_nameref)
+	VUNSETATTR (var, att_integer|att_uppercase|att_lowercase|att_capcase);
+
+      /* Readonly variable error checking. */
+
+      /* Cannot use declare +r to turn off readonly attribute. */ 
+      if (readonly_p (var) && (flags_off & att_readonly))
+	{
+	  sh_readonly (name_cell (var));
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Cannot use declare to assign value to readonly or noassign variable. */
+      else if ((readonly_p (var) || noassign_p (var)) && offset)
+	{
+	  if (readonly_p (var))
+	    sh_readonly (name);
+	  assign_error++;
+	  NEXT_VARIABLE ();
+	}
+
+#if defined (ARRAY_VARS)
+      /* make declare a[2]=foo as similar to a[2]=foo as possible if a is
+	 already an array or assoc variable. */
+      if (array_subscript_assignment && array_exists && creating_array == 0)
+	simple_array_assign = 1;
+      else if ((making_array_special || creating_array || array_exists) && offset)
+	{
+	  int vlen;
+	  vlen = STRLEN (value);
+/*itrace("declare_builtin: name = %s value = %s flags = %d", name, value, wflags);*/
+
+	  /* Print a warning for a construct like
+		declare -a array='(quoted compound value)'
+	     if the array variable doesn't already exist. */
+	  if (shell_compatibility_level > 43 && (wflags & W_COMPASSIGN) == 0 &&
+		value[0] == '(' && value[vlen-1] == ')')
+	    {
+	      /* The warning is only printed when using compound assignment
+		 to an array variable that doesn't already exist.  We use
+		 creating_array to allow things like
+		     declare -a foo$bar='(abc)' to work. */		     
+	      if (array_exists == 0 && creating_array == 0)
+		internal_warning (_("%s: quoted compound array assignment deprecated"), list->word->word);
+	      compound_array_assign = array_exists || creating_array;
+	      simple_array_assign = making_array_special;
+	    }
+	  else if (value[0] == '(' && value[vlen-1] == ')' && (shell_compatibility_level < 44 || (wflags & W_COMPASSIGN)))
+	    compound_array_assign = 1;
+	  else
+	    simple_array_assign = 1;
+	}
+
+      /* Array variable error checking. */
+
+      /* Cannot use declare +a name or declare +A name to remove an array variable. */
+      if (((flags_off & att_array) && array_p (var)) || ((flags_off & att_assoc) && assoc_p (var)))
+	{
+	  builtin_error (_("%s: cannot destroy array variables in this way"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      else if ((flags_on & att_array) && assoc_p (var))
+	{
+	  builtin_error (_("%s: cannot convert associative to indexed array"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      else if ((flags_on & att_assoc) && array_p (var))
+	{
+	  builtin_error (_("%s: cannot convert indexed to associative array"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* declare -A name[[n]] makes name an associative array variable. */
+      if (flags_on & att_assoc)
+	{
+	  if (assoc_p (var) == 0)
+	    var = convert_var_to_assoc (var);
+	}
+      /* declare -a name[[n]] or declare name[n] makes NAME an indexed
+	 array variable. */
+      else if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0 && assoc_p (var) == 0)
+	var = convert_var_to_array (var);
+#endif /* ARRAY_VARS */
+
+      /* XXX - we note that we are turning on nameref attribute and defer
+	 setting it until the assignment has been made so we don't do an
+	 inadvertent nameref lookup.  Might have to do the same thing for
+	 flags_off&att_nameref. */
+      /* XXX - ksh93 makes it an error to set a readonly nameref variable
+	 using a single typeset command. */
+      onref = (flags_on & att_nameref);
+      flags_on &= ~att_nameref;
+#if defined (ARRAY_VARS)
+      /* I don't believe this condition ever tests true, but array variables
+	 may not be namerefs */
+      if (array_p (var) || assoc_p (var) || (offset && compound_array_assign)
+	    || simple_array_assign)
+	onref = 0;
+#endif
+
+      /* ksh93 seems to do this */
+      offref = (flags_off & att_nameref);
+      flags_off &= ~att_nameref;
+
+      VSETATTR (var, flags_on);
+      VUNSETATTR (var, flags_off);
+
+#if defined (ARRAY_VARS)
+      if (offset && compound_array_assign)
+	assign_array_var_from_string (var, value, aflags|ASS_FORCE);
+      else if (simple_array_assign && subscript_start)
+	{
+	  int local_aflags;
+	  /* declare [-aA] name[N]=value */
+	  *subscript_start = '[';	/* ] */
+	  /* XXX - problem here with appending */
+	  local_aflags = aflags&ASS_APPEND;
+	  local_aflags |= assoc_noexpand ? ASS_NOEXPAND : 0;
+	  var = assign_array_element (name, value, local_aflags);	/* XXX - not aflags */
+	  *subscript_start = '\0';
+	  if (var == 0)	/* some kind of assignment error */
+	    {
+	      assign_error++;
+	      flags_on |= onref;
+	      flags_off |= offref;
+	      NEXT_VARIABLE ();
+	    }
+	}
+      else if (simple_array_assign)
+	{
+	  /* let bind_{array,assoc}_variable take care of this. */
+	  if (assoc_p (var))
+	    bind_assoc_variable (var, name, savestring ("0"), value, aflags|ASS_FORCE);
+	  else
+	    bind_array_variable (name, 0, value, aflags|ASS_FORCE);
+	}
+      else
+#endif
+      /* XXX - no ASS_FORCE here */
+      /* bind_variable_value duplicates the essential internals of bind_variable() */
+      if (offset)
+	{
+	  if (onref || nameref_p (var))
+	    aflags |= ASS_NAMEREF;
+	  v = bind_variable_value (var, value, aflags);
+	  if (v == 0 && (onref || nameref_p (var)))
+	    {
+	      if (valid_nameref_value (value, 1) == 0)
+		sh_invalidid (value);
+	      assign_error++;
+	      /* XXX - unset this variable? or leave it as normal var? */
+	      if (created_var)
+		delete_var (var->name, mkglobal ? global_variables : shell_variables);
+	      flags_on |= onref;		/* undo change from above */
+	      flags_off |= offref;
+	      NEXT_VARIABLE ();
+	    }
+	}
+
+      /* If we found this variable in the temporary environment, as with
+	 `var=value declare -x var', make sure it is treated identically
+	 to `var=value export var'.  Do the same for `declare -r' and
+	 `readonly'.  Preserve the attributes, except for att_tempvar. */
+      /* XXX -- should this create a variable in the global scope, or
+	 modify the local variable flags?  ksh93 has it modify the
+	 global scope.
+	 Need to handle case like in set_var_attribute where a temporary
+	 variable is in the same table as the function local vars. */
+      if ((flags_on & (att_exported|att_readonly)) && tempvar_p (var))
+	{
+	  SHELL_VAR *tv;
+	  char *tvalue;
+
+	  tv = find_tempenv_variable (var->name);
+	  if (tv)
+	    {
+	      tvalue = var_isset (var) ? savestring (value_cell (var)) : savestring ("");
+	      tv = bind_variable (var->name, tvalue, 0);
+	      if (tv)
+		{
+		  tv->attributes |= var->attributes & ~att_tempvar;
+		  if (tv->context > 0)
+		    VSETATTR (tv, att_propagate);
+		}
+	      free (tvalue);
+	    }
+	  VSETATTR (var, att_propagate);
+	}
+
+      /* Turn on nameref attribute we deferred above. */
+      /* XXX - should we turn on the noassign attribute for consistency with
+	 ksh93 when we turn on the nameref attribute? */
+      VSETATTR (var, onref);
+      flags_on |= onref;
+      VUNSETATTR (var, offref);
+      flags_off |= offref;
+      /* Yuck.  ksh93 compatibility.  XXX - need to investigate more but
+	 definitely happens when turning off nameref attribute on nameref
+	 (see comments above).  Under no circumstances allow this to turn
+	 off readonly attribute on readonly nameref variable. */
+      if (refvar)
+	{
+	  if (flags_off & att_readonly)
+	    flags_off &= ~att_readonly;
+ 	  VUNSETATTR (refvar, flags_off);
+	}
+
+      stupidly_hack_special_variables (name);
+
+      NEXT_VARIABLE ();
+    }
+
+  return (assign_error ? EX_BADASSIGN
+		       : ((any_failed == 0) ? EXECUTION_SUCCESS
+  					    : EXECUTION_FAILURE));
+}

builtins/declare.def.2

+This file is declare.def, from which is created declare.c.
+It implements the builtins "declare" and "local" in Bash.
+
+Copyright (C) 1987-2021 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 declare.c
+
+$BUILTIN declare
+$FUNCTION declare_builtin
+$SHORT_DOC declare [-aAfFgiIlnrtux] [-p] [name[=value] ...]
+Set variable values and attributes.
+
+Declare variables and give them attributes.  If no NAMEs are given,
+display the attributes and values of all variables.
+
+Options:
+  -f	restrict action or display to function names and definitions
+  -F	restrict display to function names only (plus line number and
+		source file when debugging)
+  -g	create global variables when used in a shell function; otherwise
+		ignored
+  -I	if creating a local variable, inherit the attributes and value
+		of a variable with the same name at a previous scope
+  -p	display the attributes and value of each NAME
+
+Options which set attributes:
+  -a	to make NAMEs indexed arrays (if supported)
+  -A	to make NAMEs associative arrays (if supported)
+  -i	to make NAMEs have the `integer' attribute
+  -l	to convert the value of each NAME to lower case on assignment
+  -n	make NAME a reference to the variable named by its value
+  -r	to make NAMEs readonly
+  -t	to make NAMEs have the `trace' attribute
+  -u	to convert the value of each NAME to upper case on assignment
+  -x	to make NAMEs export
+
+Using `+' instead of `-' turns off the given attribute.
+
+Variables with the integer attribute have arithmetic evaluation (see
+the `let' command) performed when the variable is assigned a value.
+
+When used in a function, `declare' makes NAMEs local, as with the `local'
+command.  The `-g' option suppresses this behavior.
+
+Exit Status:
+Returns success unless an invalid option is supplied or a variable
+assignment error occurs.
+$END
+
+$BUILTIN typeset
+$FUNCTION declare_builtin
+$SHORT_DOC typeset [-aAfFgiIlnrtux] [-p] name[=value] ...
+Set variable values and attributes.
+
+A synonym for `declare'.  See `help declare'.
+$END
+
+#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 "../flags.h"
+#include "common.h"
+#include "builtext.h"
+#include "bashgetopt.h"
+
+static SHELL_VAR *declare_find_variable PARAMS((const char *, int, int));
+static int declare_internal PARAMS((register WORD_LIST *, int));
+
+/* Declare or change variable attributes. */
+int
+declare_builtin (list)
+     register WORD_LIST *list;
+{
+  return (declare_internal (list, 0));
+}
+
+$BUILTIN local
+$FUNCTION local_builtin
+$SHORT_DOC local [option] name[=value] ...
+Define local variables.
+
+Create a local variable called NAME, and give it VALUE.  OPTION can
+be any option accepted by `declare'.
+
+Local variables can only be used within a function; they are visible
+only to the function where they are defined and its children.
+
+Exit Status:
+Returns success unless an invalid option is supplied, a variable
+assignment error occurs, or the shell is not executing a function.
+$END
+int
+local_builtin (list)
+     register WORD_LIST *list;
+{
+  /* Catch a straight `local --help' before checking function context */
+  if (list && list->word && STREQ (list->word->word, "--help"))
+    {
+      builtin_help ();
+      return (EX_USAGE);
+    }
+    
+  if (variable_context)
+    return (declare_internal (list, 1));
+  else
+    {
+      builtin_error (_("can only be used in a function"));
+      return (EXECUTION_FAILURE);
+    }
+}
+
+#if defined (ARRAY_VARS)
+#  define DECLARE_OPTS	"+acfgilnprtuxAFGI"
+#else
+#  define DECLARE_OPTS	"+cfgilnprtuxFGI"
+#endif
+
+static SHELL_VAR *
+declare_find_variable (name, mkglobal, chklocal)
+     const char *name;
+     int mkglobal, chklocal;
+{
+  SHELL_VAR *var;
+
+  if (mkglobal == 0)
+    return (find_variable (name));
+  else if (chklocal)
+    {
+      var = find_variable (name);
+      if (var && local_p (var) && var->context == variable_context)
+	return var;
+      return (find_global_variable (name));
+    }
+  else
+    return (find_global_variable (name));
+}
+
+/* Build a new string
+	NAME[SUBSCRIPT][[+]=VALUE]
+   from expanding a nameref into NAME */
+static char *
+declare_build_newname (name, subscript_start, offset, value, aflags)
+     char *name, *subscript_start, *value;
+     int offset, aflags;
+{
+  size_t namelen, savelen;
+  char *ret;
+
+  savelen = namelen = strlen (name);
+  if (subscript_start)
+    {
+      *subscript_start = '[';		/* ] */
+      namelen += strlen (subscript_start);
+    }
+  ret = xmalloc (namelen + 2 + strlen (value) + 1);
+  strcpy (ret, name);
+  if (subscript_start)
+    strcpy (ret + savelen, subscript_start);
+  if (offset)
+    {
+      if (aflags & ASS_APPEND)
+	ret[namelen++] = '+';
+      ret[namelen++] = '=';
+      if (value && *value)
+	strcpy (ret + namelen, value);
+      else
+	ret[namelen] = '\0';
+    }
+
+  return (ret);
+}
+
+/* The workhorse function. */
+static int
+declare_internal (list, local_var)
+     register WORD_LIST *list;
+     int local_var;
+{
+  int flags_on, flags_off, *flags;
+  int any_failed, assign_error, pflag, nodefs, opt, onref, offref;
+  int mkglobal, chklocal, inherit_flag;
+  char *t, *subscript_start;
+  SHELL_VAR *var, *refvar, *v;
+  FUNCTION_DEF *shell_fn;
+
+  flags_on = flags_off = any_failed = assign_error = pflag = nodefs = 0;
+  mkglobal = chklocal = inherit_flag = 0;
+  refvar = (SHELL_VAR *)NULL;
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, DECLARE_OPTS)) != -1)
+    {
+      flags = list_opttype == '+' ? &flags_off : &flags_on;
+
+      /* If you add options here, see whether or not they need to be added to
+	 the loop in subst.c:shell_expand_word_list() */
+      switch (opt)
+	{
+	case 'a':
+#if defined (ARRAY_VARS)
+	  *flags |= att_array;
+	  break;
+#else
+	  builtin_usage ();
+	  return (EX_USAGE);
+#endif
+	case 'A':
+#if defined (ARRAY_VARS)
+	  *flags |= att_assoc;
+	  break;
+#else
+	  builtin_usage ();
+	  return (EX_USAGE);
+#endif
+	case 'p':
+	  pflag++;
+	  break;
+        case 'F':
+	  nodefs++;
+	  *flags |= att_function;
+	  break;
+	case 'f':
+	  *flags |= att_function;
+	  break;
+	case 'G':
+	  if (flags == &flags_on)
+	    chklocal = 1;
+	  /*FALLTHROUGH*/
+	case 'g':
+	  if (flags == &flags_on)
+	    mkglobal = 1;
+	  break;
+	case 'i':
+	  *flags |= att_integer;
+	  break;
+	case 'n':
+	  *flags |= att_nameref;
+	  break;
+	case 'r':
+	  *flags |= att_readonly;
+	  break;
+	case 't':
+	  *flags |= att_trace;
+	  break;
+	case 'x':
+	  *flags |= att_exported;
+	  array_needs_making = 1;
+	  break;
+#if defined (CASEMOD_ATTRS)
+#  if defined (CASEMOD_CAPCASE)
+	 case 'c':
+	  *flags |= att_capcase;
+	  if (flags == &flags_on)
+	    flags_off |= att_uppercase|att_lowercase;
+	  break;
+#  endif
+	case 'l':
+	  *flags |= att_lowercase;
+	  if (flags == &flags_on)
+	    flags_off |= att_capcase|att_uppercase;
+	  break;
+	case 'u':
+	  *flags |= att_uppercase;
+	  if (flags == &flags_on)
+	    flags_off |= att_capcase|att_lowercase;
+	  break;
+#endif /* CASEMOD_ATTRS */
+	case 'I':
+	  inherit_flag = MKLOC_INHERIT;
+	  break;
+	CASE_HELPOPT;
+	default:
+	  builtin_usage ();
+	  return (EX_USAGE);
+	}
+    }
+
+  list = loptend;
+
+  /* If there are no more arguments left, then we just want to show
+     some variables. */
+  if (list == 0)	/* declare -[aAfFirtx] */
+    {
+      /* Show local variables defined at this context level if this is
+	 the `local' builtin. */
+      if (local_var)
+	show_local_var_attributes (0, nodefs);	/* XXX - fix up args later */
+      else if (pflag && (flags_on == 0 || flags_on == att_function))
+	show_all_var_attributes (flags_on == 0, nodefs);
+      else if (flags_on == 0)
+	return (set_builtin ((WORD_LIST *)NULL));
+      else
+	set_or_show_attributes ((WORD_LIST *)NULL, flags_on, nodefs);
+
+      return (sh_chkwrite (EXECUTION_SUCCESS));
+    }
+
+  if (pflag)	/* declare -p [-aAfFirtx] name [name...] */
+    {
+      for (any_failed = 0; list; list = list->next)
+	{
+	  if (flags_on & att_function)
+	    pflag = show_func_attributes (list->word->word, nodefs);
+	  else if (local_var)
+	    pflag = show_localname_attributes (list->word->word, nodefs);
+	  else
+	    pflag = show_name_attributes (list->word->word, nodefs);
+	  if (pflag)
+	    {
+	      sh_notfound (list->word->word);
+	      any_failed++;
+	    }
+	}
+      return (sh_chkwrite (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS));
+    }
+
+  /* Some option combinations that don't make any sense */
+  if ((flags_on & att_function) && (flags_on & (att_array|att_assoc|att_integer|att_nameref)))
+    {
+      char *optchar;
+
+      if (flags_on & att_nameref)
+	optchar = "-n";
+      else if (flags_on & att_integer)
+	optchar = "-i";
+      else if (flags_on & att_assoc)
+	optchar = "-A";
+      else if (flags_on & att_array)
+	optchar = "-a";
+
+      sh_invalidopt (optchar);	
+      return (EXECUTION_FAILURE);
+    }
+
+#define NEXT_VARIABLE() free (name); list = list->next; continue
+
+  /* There are arguments left, so we are making variables. */
+  while (list)		/* declare [-aAfFirx] name [name ...] */
+    {
+      char *value, *name, *oldname;
+      int offset, aflags, wflags, created_var;
+      int assoc_noexpand;
+#if defined (ARRAY_VARS)
+      int making_array_special, compound_array_assign, simple_array_assign;
+      int var_exists, array_exists, creating_array, array_subscript_assignment;
+#endif
+
+      name = savestring (list->word->word);
+      wflags = list->word->flags;
+#if defined (ARRAY_VARS)
+      assoc_noexpand = assoc_expand_once && (wflags & W_ASSIGNMENT);
+#else
+      assoc_noexpand = 0;
+#endif
+      offset = assignment (name, assoc_noexpand ? 2 : 0);
+      aflags = 0;
+      created_var = 0;
+
+      if (local_var && variable_context && STREQ (name, "-"))
+	{
+	  var = make_local_variable ("-", 0);
+	  FREE (value_cell (var));		/* just in case */
+	  value = get_current_options ();
+	  var_setvalue (var, value);
+	  VSETATTR (var, att_invisible);
+	  NEXT_VARIABLE ();
+	}
+
+      /* If we are declaring a function, then complain about it in some way.
+	 We don't let people make functions by saying `typeset -f foo=bar'. */
+
+      /* Can't define functions using assignment statements */
+      if (offset && (flags_on & att_function))	/* declare -f [-rix] foo=bar */
+	{
+	  builtin_error (_("cannot use `-f' to make functions"));
+	  free (name);
+	  return (EXECUTION_FAILURE);
+	}
+
+      /* There should be a way, however, to let people look at a particular
+	 function definition by saying `typeset -f foo'.  This is the only
+	 place in this builtin where we deal with functions. */
+
+      if (flags_on & att_function)
+	{
+	  /* Should we restrict this when the shell is in posix mode even if
+	     the function was created before the shell entered posix mode?
+	     Previous versions of the shell enforced the restriction. */
+	  if (posixly_correct && legal_identifier (name) == 0)
+	    {
+	      sh_invalidid (name);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+
+	  var = find_function (name);
+
+	  if (var)
+	    {
+	      if (readonly_p (var) && (flags_off & att_readonly))
+		{
+		  builtin_error (_("%s: readonly function"), name);
+		  any_failed++;
+		  NEXT_VARIABLE ();
+		}
+	      /* declare -[Ff] name [name...] */
+	      if (flags_on == att_function && flags_off == 0)
+		{
+#if defined (DEBUGGER)
+		  if (nodefs && debugging_mode)
+		    {
+		      shell_fn = find_function_def (var->name);
+		      if (shell_fn)
+			printf ("%s %d %s\n", var->name, shell_fn->line, shell_fn->source_file);
+		      else
+			printf ("%s\n", var->name);
+		    }
+		  else
+#endif /* DEBUGGER */
+		    {	
+		      t = nodefs ? var->name : named_function_string (name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL);
+		      printf ("%s\n", t);
+		      any_failed = sh_chkwrite (any_failed);
+		    }
+		}
+	      else		/* declare -[fF] -[rx] name [name...] */
+		{
+		  VSETATTR (var, flags_on);
+		  flags_off &= ~att_function;	/* makes no sense */
+		  VUNSETATTR (var, flags_off);
+		}
+	    }
+	  else
+	    any_failed++;
+
+	  NEXT_VARIABLE ();
+	}
+
+      if (offset)	/* declare [-aAfFirx] name=value */
+	{
+	  name[offset] = '\0';
+	  value = name + offset + 1;
+	  if (name[offset - 1] == '+')
+	    {
+	      aflags |= ASS_APPEND;
+	      name[offset - 1] = '\0';
+	    }
+	}
+      else
+	value = "";
+
+      /* Do some lexical error checking on the LHS and RHS of the assignment
+	 that is specific to nameref variables. */
+      if (flags_on & att_nameref)
+	{
+#if defined (ARRAY_VARS)
+	  if (valid_array_reference (name, 0))
+	    {
+	      builtin_error (_("%s: reference variable cannot be an array"), name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+	  else
+#endif
+	  /* disallow self references at global scope, warn at function scope */
+	  if (check_selfref (name, value, 0))
+	    {
+	      if (variable_context == 0)
+		{
+		  builtin_error (_("%s: nameref variable self references not allowed"), name);
+		  assign_error++;	/* XXX any_failed++ instead? */
+		  NEXT_VARIABLE ();
+		}
+	      else
+		builtin_warning (_("%s: circular name reference"), name);
+	    }
+	  if (value && *value && (aflags & ASS_APPEND) == 0 && valid_nameref_value (value, 1) == 0)
+	    {
+	      builtin_error (_("`%s': invalid variable name for name reference"), value);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+	}
+
+restart_new_var_name:
+
+      /* The rest of the loop body deals with declare -[aAinrx] name [name...] */
+
+      subscript_start = (char *)NULL;	/* used below */
+#if defined (ARRAY_VARS)
+      /* Determine whether we are creating or assigning an array variable */
+      var_exists = array_exists = creating_array = 0;
+      compound_array_assign = simple_array_assign = 0;
+      array_subscript_assignment = 0;
+      if (t = strchr (name, '['))	/* ] */
+	{
+	  /* If offset != 0 we have already validated any array reference
+	     because assignment() calls skipsubscript() */
+	  if (offset == 0 && valid_array_reference (name, 0) == 0)
+	    {
+	      sh_invalidid (name);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+	  subscript_start = t;
+	  *t = '\0';
+	  making_array_special = 1;	/* XXX - should this check offset? */
+	  array_subscript_assignment = offset != 0;
+	}
+      else
+	making_array_special = 0;
+#endif
+
+      /* Ensure the argument is a valid, well-formed shell identifier. */
+      if (legal_identifier (name) == 0)
+	{
+	  sh_invalidid (name);
+	  assign_error++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* If VARIABLE_CONTEXT has a non-zero value, then we are executing
+	 inside of a function.  This means we should make local variables,
+	 not global ones. */
+
+      /* XXX - this has consequences when we're making a local copy of a
+	       variable that was in the temporary environment.  Watch out
+	       for this. */
+      refvar = (SHELL_VAR *)NULL;
+      if (variable_context && mkglobal == 0)
+	{
+	  char *newname;
+
+	  /* We don't check newname for validity here. We should not have an
+	     invalid name assigned as the value of a nameref, but this could
+	     cause problems. */
+	  var = find_variable (name);
+	  if (var == 0)
+	    newname = nameref_transform_name (name, ASS_MKLOCAL);
+	  else if ((flags_on & att_nameref) == 0 && (flags_off & att_nameref) == 0)
+	    {
+	      /* Ok, we're following namerefs here, so let's make sure that if
+		 we followed one, it was at the same context (see below for
+		 more details). */
+	      refvar = find_variable_last_nameref (name, 1);
+	      newname = (refvar && refvar->context != variable_context) ? name : var->name;
+	      refvar = (SHELL_VAR *)NULL;
+	    }
+	  else
+	    newname = name;	/* dealing with nameref attribute */
+
+#if defined (ARRAY_VARS)
+	  /* Pass 1 as second argument to make_local_{assoc,array}_variable
+	     return an existing {array,assoc} variable to be flagged as an
+	     error below. */
+	  if (flags_on & att_assoc)
+	    var = make_local_assoc_variable (newname, MKLOC_ARRAYOK|inherit_flag);
+	  else if ((flags_on & att_array) || making_array_special)
+	    var = make_local_array_variable (newname, MKLOC_ASSOCOK|inherit_flag);
+	  else
+#endif
+	  if (offset == 0 && (flags_on & att_nameref))
+	    {
+	      /* First look for refvar at current scope */
+	      refvar = find_variable_last_nameref (name, 1);
+	      /* VARIABLE_CONTEXT != 0, so we are attempting to create or modify
+		 the attributes for a local variable at the same scope.  If we've
+		 used a reference from a previous context to resolve VAR, we
+		 want to throw REFVAR and VAR away and create a new local var. */
+	      if (refvar && refvar->context != variable_context)
+		{
+		  refvar = 0;
+		  var = make_local_variable (name, inherit_flag);
+		}
+	      else if (refvar && refvar->context == variable_context)
+		var = refvar;
+	      /* Maybe we just want to create a new local variable */
+	      else if (var == 0 || var->context != variable_context)
+		var = make_local_variable (name, inherit_flag);
+	      /* otherwise we have a var at the right context */
+	    }
+	  else
+	    /* XXX - check name for validity here with valid_nameref_value? */
+	    var = make_local_variable ((flags_on & att_nameref) ? name : newname, inherit_flag);	/* sets att_invisible for new vars */
+
+	  if (var == 0)
+	    {
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+	  if (var && nameref_p (var) && readonly_p (var) && nameref_cell (var) && (flags_off & att_nameref))
+	    {
+	      sh_readonly (name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+	}
+      else
+	var = (SHELL_VAR *)NULL;
+
+      /* VAR is non-null if we just created or fetched a local variable. */
+
+      /* Here's what ksh93 seems to do as of the 2012 version: if we are
+	 using declare -n to modify the value of an existing nameref
+	 variable, don't follow the nameref chain at all and just search
+	 for a nameref at the current context.  If we have a nameref,
+	 modify its value (changing which variable it references). */
+      if (var == 0 && (flags_on & att_nameref))
+	{
+	  /* See if we are trying to modify an existing nameref variable,
+	     but don't follow the nameref chain. */
+	  var = mkglobal ? find_global_variable_noref (name) : find_variable_noref (name);
+	  if (var && nameref_p (var) == 0)
+	    var = 0;
+	}
+
+      /* However, if we're turning off the nameref attribute on an existing
+	 nameref variable, we first follow the nameref chain to the end,
+	 modify the value of the variable this nameref variable references
+	 if there is an assignment statement argument,
+	 *CHANGING ITS VALUE AS A SIDE EFFECT*, then turn off the nameref
+	 flag *LEAVING THE NAMEREF VARIABLE'S VALUE UNCHANGED* */
+      else if (var == 0 && (flags_off & att_nameref))
+	{
+	  /* See if we are trying to modify an existing nameref variable */
+	     refvar = mkglobal ? find_global_variable_last_nameref (name, 0) : find_variable_last_nameref (name, 0);
+	  if (refvar && nameref_p (refvar) == 0)
+	    refvar = 0;
+	  /* If the nameref is readonly but doesn't have a value, ksh93
+	     allows the nameref attribute to be removed.  If it's readonly
+	     and has a value, even if the value doesn't reference an
+	     existing variable, we disallow the modification */
+	  if (refvar && nameref_cell (refvar) && readonly_p (refvar))
+	    {
+	      sh_readonly (name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+
+	  /* If all we're doing is turning off the nameref attribute, don't
+	     bother with VAR at all, whether it exists or not. Just turn it
+	     off and go on. */
+	  if (refvar && flags_on == 0 && offset == 0 && (flags_off & ~att_nameref) == 0)
+	    {
+	      VUNSETATTR (refvar, att_nameref);
+	      NEXT_VARIABLE ();
+	    }
+
+	  if (refvar)
+	    var = declare_find_variable (nameref_cell (refvar), mkglobal, 0);
+	}
+#if defined (ARRAY_VARS)
+      /* If we have an array assignment to a nameref, remove the nameref
+	 attribute and go on.  This handles
+	 declare -n xref[=value]; declare [-a] xref[1]=one */
+      else if (var == 0 && offset && array_subscript_assignment)
+	{
+	  var = mkglobal ? find_global_variable_noref (name) : find_variable_noref (name);
+	  if (var && nameref_p (var))
+	    {
+	      internal_warning (_("%s: removing nameref attribute"), name);
+	      FREE (value_cell (var));		/* XXX - bash-4.3 compat */
+	      var_setvalue (var, (char *)NULL);
+	      VUNSETATTR (var, att_nameref);
+	    }
+	}
+#endif
+
+      /* See if we are trying to set flags or value (or create) for an
+	 existing nameref that points to a non-existent variable: e.g.,
+		declare -n foo=bar
+		unset foo	# unsets bar
+		declare -i foo
+		foo=4+4
+		declare -p foo
+      */
+      if (var == 0 && (mkglobal || flags_on || flags_off || offset))
+	{
+	  refvar = mkglobal ? find_global_variable_last_nameref (name, 0) : find_variable_last_nameref (name, 0);
+	  if (refvar && nameref_p (refvar) == 0)
+	    refvar = 0;
+	  if (refvar)
+	    var = declare_find_variable (nameref_cell (refvar), mkglobal, 0);
+	  if (refvar && var == 0)
+	    {
+	      oldname = name;	/* need to free this */
+
+	      /* I'm not sure subscript_start is ever non-null here. In any
+		 event, build a new name from the nameref value, including any
+		 subscript, and add the [[+]=value] if offset != 0 */
+	      name = declare_build_newname (nameref_cell (refvar), subscript_start, offset, value, aflags);
+
+	      if (offset)
+	        {
+		  offset = assignment (name, 0);
+		  /* If offset was valid previously, but substituting the
+		     the nameref value results in an invalid assignment,
+		     throw an invalid identifier error */
+		  if (offset == 0)
+		    {
+		      free (oldname);
+		      sh_invalidid (name);
+		      assign_error++;
+		      NEXT_VARIABLE ();
+		    }
+		  name[(aflags & ASS_APPEND) ? offset - 1 : offset] = '\0';
+		  value = name + offset + 1;
+		}
+	      free (oldname);
+
+	      /* OK, let's turn off the nameref attribute.
+		 Now everything else applies to VAR. */
+	      if (flags_off & att_nameref)
+		VUNSETATTR (refvar, att_nameref);
+
+	      goto restart_new_var_name;
+	      /* NOTREACHED */
+	    }
+	}
+      if (var == 0)
+	var = declare_find_variable (name, mkglobal, chklocal);
+
+      /* At this point, VAR is the variable we are dealing with; REFVAR is the
+	 nameref variable we dereferenced to get VAR, if any. */
+#if defined (ARRAY_VARS)
+      var_exists = var != 0;
+      array_exists = var && (array_p (var) || assoc_p (var));
+      creating_array = flags_on & (att_array|att_assoc);
+#endif
+
+      /* Make a new variable if we need to. */
+      if (var == 0)
+	{
+#if defined (ARRAY_VARS)
+	  if (flags_on & att_assoc)
+	    {
+	      var = make_new_assoc_variable (name);
+	      if (var && offset == 0)
+		VSETATTR (var, att_invisible);
+	    }
+	  else if ((flags_on & att_array) || making_array_special)
+	    {
+	      var = make_new_array_variable (name);
+	      if (var && offset == 0)
+	        VSETATTR (var, att_invisible);
+	    }
+	  else
+#endif
+	    {
+	      var = mkglobal ? bind_global_variable (name, (char *)NULL, ASS_FORCE) : bind_variable (name, (char *)NULL, ASS_FORCE);
+	      if (var && offset == 0)
+	        VSETATTR (var, att_invisible);
+	    }
+	  if (var == 0)
+	    {
+	      /* Has to appear in brackets */
+	      NEXT_VARIABLE ();
+	    }
+	  created_var = 1;
+	}
+      /* Nameref variable error checking. */
+
+      /* Can't take an existing array variable and make it a nameref */
+      else if ((array_p (var) || assoc_p (var)) && (flags_on & att_nameref))
+	{
+	  builtin_error (_("%s: reference variable cannot be an array"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't have an invalid identifier as nameref value */
+      else if (nameref_p (var) && (flags_on & att_nameref) == 0 && (flags_off & att_nameref) == 0 && offset && valid_nameref_value (value, 1) == 0)
+	{
+	  builtin_error (_("`%s': invalid variable name for name reference"), value);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't make an existing variable a nameref if its current value is not
+	 a valid identifier. Check of offset is to allow an assignment to a
+	 nameref var as part of the declare word to override existing value. */
+      else if ((flags_on & att_nameref) && nameref_p (var) == 0 && var_isset (var) && offset == 0 && valid_nameref_value (value_cell (var), 0) == 0)
+	{
+	  builtin_error (_("`%s': invalid variable name for name reference"), value_cell (var));
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't make an existing readonly variable a nameref. */
+      else if ((flags_on & att_nameref) && readonly_p (var))
+	{
+	  sh_readonly (name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* Readonly variable error checking. */
+
+      /* Cannot use declare +r to turn off readonly attribute. */ 
+      if (readonly_p (var) && (flags_off & att_readonly))
+	{
+	  sh_readonly (name_cell (var));
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Cannot use declare to assign value to readonly or noassign variable. */
+      else if ((readonly_p (var) || noassign_p (var)) && offset)
+	{
+	  if (readonly_p (var))
+	    sh_readonly (name);
+	  assign_error++;
+	  NEXT_VARIABLE ();
+	}
+
+#if defined (ARRAY_VARS)
+      /* make declare a[2]=foo as similar to a[2]=foo as possible if a is
+	 already an array or assoc variable. */
+      if (array_subscript_assignment && array_exists && creating_array == 0)
+	simple_array_assign = 1;
+      else if ((making_array_special || creating_array || array_exists) && offset)
+	{
+	  int vlen;
+	  vlen = STRLEN (value);
+/*itrace("declare_builtin: name = %s value = %s flags = %d", name, value, wflags);*/
+
+	  /* Print a warning for a construct like
+		declare -a array='(quoted compound value)'
+	     if the array variable doesn't already exist. */
+	  if (shell_compatibility_level > 43 && (wflags & W_COMPASSIGN) == 0 &&
+		value[0] == '(' && value[vlen-1] == ')')
+	    {
+	      /* The warning is only printed when using compound assignment
+		 to an array variable that doesn't already exist.  We use
+		 creating_array to allow things like
+		     declare -a foo$bar='(abc)' to work. */		     
+	      if (array_exists == 0 && creating_array == 0)
+		internal_warning (_("%s: quoted compound array assignment deprecated"), list->word->word);
+	      compound_array_assign = array_exists || creating_array;
+	      simple_array_assign = making_array_special;
+	    }
+	  else if (value[0] == '(' && value[vlen-1] == ')' && (shell_compatibility_level < 44 || (wflags & W_COMPASSIGN)))
+	    compound_array_assign = 1;
+	  else
+	    simple_array_assign = 1;
+	}
+
+      /* Array variable error checking. */
+
+      /* Cannot use declare +a name or declare +A name to remove an array variable. */
+      if (((flags_off & att_array) && array_p (var)) || ((flags_off & att_assoc) && assoc_p (var)))
+	{
+	  builtin_error (_("%s: cannot destroy array variables in this way"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      else if ((flags_on & att_array) && assoc_p (var))
+	{
+	  builtin_error (_("%s: cannot convert associative to indexed array"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      else if ((flags_on & att_assoc) && array_p (var))
+	{
+	  builtin_error (_("%s: cannot convert indexed to associative array"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* ksh93 compat: turning on nameref attribute turns off -ilu */
+      if (flags_on & att_nameref)
+	VUNSETATTR (var, att_integer|att_uppercase|att_lowercase|att_capcase);
+
+      /* declare -A name[[n]] makes name an associative array variable. */
+      if (flags_on & att_assoc)
+	{
+	  if (assoc_p (var) == 0)
+	    var = convert_var_to_assoc (var);
+	}
+      /* declare -a name[[n]] or declare name[n] makes NAME an indexed
+	 array variable. */
+      else if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0 && assoc_p (var) == 0)
+	var = convert_var_to_array (var);
+#endif /* ARRAY_VARS */
+
+      /* XXX - we note that we are turning on nameref attribute and defer
+	 setting it until the assignment has been made so we don't do an
+	 inadvertent nameref lookup.  Might have to do the same thing for
+	 flags_off&att_nameref. */
+      /* XXX - ksh93 makes it an error to set a readonly nameref variable
+	 using a single typeset command. */
+      onref = (flags_on & att_nameref);
+      flags_on &= ~att_nameref;
+#if defined (ARRAY_VARS)
+      /* I don't believe this condition ever tests true, but array variables
+	 may not be namerefs */
+      if (array_p (var) || assoc_p (var) || (offset && compound_array_assign)
+	    || simple_array_assign)
+	onref = 0;
+#endif
+
+      /* ksh93 seems to do this */
+      offref = (flags_off & att_nameref);
+      flags_off &= ~att_nameref;
+
+      VSETATTR (var, flags_on);
+      VUNSETATTR (var, flags_off);
+
+#if defined (ARRAY_VARS)
+      if (offset && compound_array_assign)
+	assign_array_var_from_string (var, value, aflags|ASS_FORCE);
+      else if (simple_array_assign && subscript_start)
+	{
+	  int local_aflags;
+	  /* declare [-aA] name[N]=value */
+	  *subscript_start = '[';	/* ] */
+	  /* XXX - problem here with appending */
+	  local_aflags = aflags&ASS_APPEND;
+	  local_aflags |= assoc_noexpand ? ASS_NOEXPAND : 0;
+	  var = assign_array_element (name, value, local_aflags);	/* XXX - not aflags */
+	  *subscript_start = '\0';
+	  if (var == 0)	/* some kind of assignment error */
+	    {
+	      assign_error++;
+	      flags_on |= onref;
+	      flags_off |= offref;
+	      NEXT_VARIABLE ();
+	    }
+	}
+      else if (simple_array_assign)
+	{
+	  /* let bind_{array,assoc}_variable take care of this. */
+	  if (assoc_p (var))
+	    bind_assoc_variable (var, name, savestring ("0"), value, aflags|ASS_FORCE);
+	  else
+	    bind_array_variable (name, 0, value, aflags|ASS_FORCE);
+	}
+      else
+#endif
+      /* XXX - no ASS_FORCE here */
+      /* bind_variable_value duplicates the essential internals of bind_variable() */
+      if (offset)
+	{
+	  if (onref || nameref_p (var))
+	    aflags |= ASS_NAMEREF;
+	  v = bind_variable_value (var, value, aflags);
+	  if (v == 0 && (onref || nameref_p (var)))
+	    {
+	      if (valid_nameref_value (value, 1) == 0)
+		sh_invalidid (value);
+	      assign_error++;
+	      /* XXX - unset this variable? or leave it as normal var? */
+	      if (created_var)
+		delete_var (var->name, mkglobal ? global_variables : shell_variables);
+	      flags_on |= onref;		/* undo change from above */
+	      flags_off |= offref;
+	      NEXT_VARIABLE ();
+	    }
+	}
+
+      /* If we found this variable in the temporary environment, as with
+	 `var=value declare -x var', make sure it is treated identically
+	 to `var=value export var'.  Do the same for `declare -r' and
+	 `readonly'.  Preserve the attributes, except for att_tempvar. */
+      /* XXX -- should this create a variable in the global scope, or
+	 modify the local variable flags?  ksh93 has it modify the
+	 global scope.
+	 Need to handle case like in set_var_attribute where a temporary
+	 variable is in the same table as the function local vars. */
+      if ((flags_on & (att_exported|att_readonly)) && tempvar_p (var))
+	{
+	  SHELL_VAR *tv;
+	  char *tvalue;
+
+	  tv = find_tempenv_variable (var->name);
+	  if (tv)
+	    {
+	      tvalue = var_isset (var) ? savestring (value_cell (var)) : savestring ("");
+	      tv = bind_variable (var->name, tvalue, 0);
+	      if (tv)
+		{
+		  tv->attributes |= var->attributes & ~att_tempvar;
+		  if (tv->context > 0)
+		    VSETATTR (tv, att_propagate);
+		}
+	      free (tvalue);
+	    }
+	  VSETATTR (var, att_propagate);
+	}
+
+      /* Turn on nameref attribute we deferred above. */
+      /* XXX - should we turn on the noassign attribute for consistency with
+	 ksh93 when we turn on the nameref attribute? */
+      VSETATTR (var, onref);
+      flags_on |= onref;
+      VUNSETATTR (var, offref);
+      flags_off |= offref;
+      /* Yuck.  ksh93 compatibility.  XXX - need to investigate more but
+	 definitely happens when turning off nameref attribute on nameref
+	 (see comments above).  Under no circumstances allow this to turn
+	 off readonly attribute on readonly nameref variable. */
+      if (refvar)
+	{
+	  if (flags_off & att_readonly)
+	    flags_off &= ~att_readonly;
+ 	  VUNSETATTR (refvar, flags_off);
+	}
+
+      stupidly_hack_special_variables (name);
+
+      NEXT_VARIABLE ();
+    }
+
+  return (assign_error ? EX_BADASSIGN
+		       : ((any_failed == 0) ? EXECUTION_SUCCESS
+  					    : EXECUTION_FAILURE));
+}

builtins/declare.def.3

+This file is declare.def, from which is created declare.c.
+It implements the builtins "declare" and "local" in Bash.
+
+Copyright (C) 1987-2021 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 declare.c
+
+$BUILTIN declare
+$FUNCTION declare_builtin
+$SHORT_DOC declare [-aAfFgiIlnrtux] [-p] [name[=value] ...]
+Set variable values and attributes.
+
+Declare variables and give them attributes.  If no NAMEs are given,
+display the attributes and values of all variables.
+
+Options:
+  -f	restrict action or display to function names and definitions
+  -F	restrict display to function names only (plus line number and
+		source file when debugging)
+  -g	create global variables when used in a shell function; otherwise
+		ignored
+  -I	if creating a local variable, inherit the attributes and value
+		of a variable with the same name at a previous scope
+  -p	display the attributes and value of each NAME
+
+Options which set attributes:
+  -a	to make NAMEs indexed arrays (if supported)
+  -A	to make NAMEs associative arrays (if supported)
+  -i	to make NAMEs have the `integer' attribute
+  -l	to convert the value of each NAME to lower case on assignment
+  -n	make NAME a reference to the variable named by its value
+  -r	to make NAMEs readonly
+  -t	to make NAMEs have the `trace' attribute
+  -u	to convert the value of each NAME to upper case on assignment
+  -x	to make NAMEs export
+
+Using `+' instead of `-' turns off the given attribute.
+
+Variables with the integer attribute have arithmetic evaluation (see
+the `let' command) performed when the variable is assigned a value.
+
+When used in a function, `declare' makes NAMEs local, as with the `local'
+command.  The `-g' option suppresses this behavior.
+
+Exit Status:
+Returns success unless an invalid option is supplied or a variable
+assignment error occurs.
+$END
+
+$BUILTIN typeset
+$FUNCTION declare_builtin
+$SHORT_DOC typeset [-aAfFgiIlnrtux] [-p] name[=value] ...
+Set variable values and attributes.
+
+A synonym for `declare'.  See `help declare'.
+$END
+
+#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 "../flags.h"
+#include "common.h"
+#include "builtext.h"
+#include "bashgetopt.h"
+
+static SHELL_VAR *declare_find_variable PARAMS((const char *, int, int));
+static char *declare_build_newname PARAMS((char *, char *, int, char *, int));
+static char *declare_transform_name PARAMS((char *, int, int));
+
+static int declare_internal PARAMS((register WORD_LIST *, int));
+
+/* Declare or change variable attributes. */
+int
+declare_builtin (list)
+     register WORD_LIST *list;
+{
+  return (declare_internal (list, 0));
+}
+
+$BUILTIN local
+$FUNCTION local_builtin
+$SHORT_DOC local [option] name[=value] ...
+Define local variables.
+
+Create a local variable called NAME, and give it VALUE.  OPTION can
+be any option accepted by `declare'.
+
+Local variables can only be used within a function; they are visible
+only to the function where they are defined and its children.
+
+Exit Status:
+Returns success unless an invalid option is supplied, a variable
+assignment error occurs, or the shell is not executing a function.
+$END
+int
+local_builtin (list)
+     register WORD_LIST *list;
+{
+  /* Catch a straight `local --help' before checking function context */
+  if (list && list->word && STREQ (list->word->word, "--help"))
+    {
+      builtin_help ();
+      return (EX_USAGE);
+    }
+    
+  if (variable_context)
+    return (declare_internal (list, 1));
+  else
+    {
+      builtin_error (_("can only be used in a function"));
+      return (EXECUTION_FAILURE);
+    }
+}
+
+#if defined (ARRAY_VARS)
+#  define DECLARE_OPTS	"+acfgilnprtuxAFGI"
+#else
+#  define DECLARE_OPTS	"+cfgilnprtuxFGI"
+#endif
+
+static SHELL_VAR *
+declare_find_variable (name, mkglobal, chklocal)
+     const char *name;
+     int mkglobal, chklocal;
+{
+  SHELL_VAR *var;
+
+  if (mkglobal == 0)
+    return (find_variable (name));
+  else if (chklocal)
+    {
+      var = find_variable (name);
+      if (var && local_p (var) && var->context == variable_context)
+	return var;
+      return (find_global_variable (name));
+    }
+  else
+    return (find_global_variable (name));
+}
+
+/* Build a new string
+	NAME[SUBSCRIPT][[+]=VALUE]
+   from expanding a nameref into NAME */
+static char *
+declare_build_newname (name, subscript_start, offset, value, aflags)
+     char *name, *subscript_start;
+     int offset;
+     char *value;
+     int aflags;
+{
+  size_t namelen, savelen;
+  char *ret;
+
+  savelen = namelen = strlen (name);
+  if (subscript_start)
+    {
+      *subscript_start = '[';		/* ] */
+      namelen += strlen (subscript_start);
+    }
+  ret = xmalloc (namelen + 2 + strlen (value) + 1);
+  strcpy (ret, name);
+  if (subscript_start)
+    strcpy (ret + savelen, subscript_start);
+  if (offset)
+    {
+      if (aflags & ASS_APPEND)
+	ret[namelen++] = '+';
+      ret[namelen++] = '=';
+      if (value && *value)
+	strcpy (ret + namelen, value);
+      else
+	ret[namelen] = '\0';
+    }
+
+  return (ret);
+}
+
+static char *
+declare_transform_name (name, flags_on, flags_off)
+     char *name;
+     int flags_on, flags_off;
+{
+  SHELL_VAR *var, *refvar;
+  char *newname;
+  
+  var = find_variable (name);
+  if (var == 0)
+    newname = nameref_transform_name (name, ASS_MKLOCAL);
+  else if ((flags_on & att_nameref) == 0 && (flags_off & att_nameref) == 0)
+    {
+      /* Ok, we're following namerefs here, so let's make sure that if
+	 we followed one, it was at the same context (see below for
+	 more details). */
+      refvar = find_variable_last_nameref (name, 1);
+      newname = (refvar && refvar->context != variable_context) ? name : name_cell (var);
+      refvar = (SHELL_VAR *)NULL;
+    }
+  else
+    newname = name;	/* dealing with nameref attribute */
+
+  return (newname);
+}
+
+/* The workhorse function. */
+static int
+declare_internal (list, local_var)
+     register WORD_LIST *list;
+     int local_var;
+{
+  int flags_on, flags_off, *flags;
+  int any_failed, assign_error, pflag, nodefs, opt, onref, offref;
+  int mkglobal, chklocal, inherit_flag;
+  char *t, *subscript_start;
+  SHELL_VAR *var, *refvar, *v;
+  FUNCTION_DEF *shell_fn;
+
+  flags_on = flags_off = any_failed = assign_error = pflag = nodefs = 0;
+  mkglobal = chklocal = inherit_flag = 0;
+  refvar = (SHELL_VAR *)NULL;
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, DECLARE_OPTS)) != -1)
+    {
+      flags = list_opttype == '+' ? &flags_off : &flags_on;
+
+      /* If you add options here, see whether or not they need to be added to
+	 the loop in subst.c:shell_expand_word_list() */
+      switch (opt)
+	{
+	case 'a':
+#if defined (ARRAY_VARS)
+	  *flags |= att_array;
+	  break;
+#else
+	  builtin_usage ();
+	  return (EX_USAGE);
+#endif
+	case 'A':
+#if defined (ARRAY_VARS)
+	  *flags |= att_assoc;
+	  break;
+#else
+	  builtin_usage ();
+	  return (EX_USAGE);
+#endif
+	case 'p':
+	  pflag++;
+	  break;
+        case 'F':
+	  nodefs++;
+	  *flags |= att_function;
+	  break;
+	case 'f':
+	  *flags |= att_function;
+	  break;
+	case 'G':
+	  if (flags == &flags_on)
+	    chklocal = 1;
+	  /*FALLTHROUGH*/
+	case 'g':
+	  if (flags == &flags_on)
+	    mkglobal = 1;
+	  break;
+	case 'i':
+	  *flags |= att_integer;
+	  break;
+	case 'n':
+	  *flags |= att_nameref;
+	  break;
+	case 'r':
+	  *flags |= att_readonly;
+	  break;
+	case 't':
+	  *flags |= att_trace;
+	  break;
+	case 'x':
+	  *flags |= att_exported;
+	  array_needs_making = 1;
+	  break;
+#if defined (CASEMOD_ATTRS)
+#  if defined (CASEMOD_CAPCASE)
+	 case 'c':
+	  *flags |= att_capcase;
+	  if (flags == &flags_on)
+	    flags_off |= att_uppercase|att_lowercase;
+	  break;
+#  endif
+	case 'l':
+	  *flags |= att_lowercase;
+	  if (flags == &flags_on)
+	    flags_off |= att_capcase|att_uppercase;
+	  break;
+	case 'u':
+	  *flags |= att_uppercase;
+	  if (flags == &flags_on)
+	    flags_off |= att_capcase|att_lowercase;
+	  break;
+#endif /* CASEMOD_ATTRS */
+	case 'I':
+	  inherit_flag = MKLOC_INHERIT;
+	  break;
+	CASE_HELPOPT;
+	default:
+	  builtin_usage ();
+	  return (EX_USAGE);
+	}
+    }
+
+  list = loptend;
+
+  /* If there are no more arguments left, then we just want to show
+     some variables. */
+  if (list == 0)	/* declare -[aAfFirtx] */
+    {
+      /* Show local variables defined at this context level if this is
+	 the `local' builtin. */
+      if (local_var)
+	show_local_var_attributes (0, nodefs);	/* XXX - fix up args later */
+      else if (pflag && (flags_on == 0 || flags_on == att_function))
+	show_all_var_attributes (flags_on == 0, nodefs);
+      else if (flags_on == 0)
+	return (set_builtin ((WORD_LIST *)NULL));
+      else
+	set_or_show_attributes ((WORD_LIST *)NULL, flags_on, nodefs);
+
+      return (sh_chkwrite (EXECUTION_SUCCESS));
+    }
+
+  if (pflag)	/* declare -p [-aAfFirtx] name [name...] */
+    {
+      for (any_failed = 0; list; list = list->next)
+	{
+	  if (flags_on & att_function)
+	    pflag = show_func_attributes (list->word->word, nodefs);
+	  else if (local_var)
+	    pflag = show_localname_attributes (list->word->word, nodefs);
+	  else
+	    pflag = show_name_attributes (list->word->word, nodefs);
+	  if (pflag)
+	    {
+	      sh_notfound (list->word->word);
+	      any_failed++;
+	    }
+	}
+      return (sh_chkwrite (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS));
+    }
+
+  /* Some option combinations that don't make any sense */
+  if ((flags_on & att_function) && (flags_on & (att_array|att_assoc|att_integer|att_nameref)))
+    {
+      char *optchar;
+
+      if (flags_on & att_nameref)
+	optchar = "-n";
+      else if (flags_on & att_integer)
+	optchar = "-i";
+      else if (flags_on & att_assoc)
+	optchar = "-A";
+      else if (flags_on & att_array)
+	optchar = "-a";
+
+      sh_invalidopt (optchar);	
+      return (EXECUTION_FAILURE);
+    }
+
+#define NEXT_VARIABLE() free (name); list = list->next; continue
+
+  /* There are arguments left, so we are making variables. */
+  while (list)		/* declare [-aAfFirx] name [name ...] */
+    {
+      char *value, *name, *oldname;
+      int offset, aflags, wflags, created_var;
+      int assoc_noexpand;
+#if defined (ARRAY_VARS)
+      int making_array_special, compound_array_assign, simple_array_assign;
+      int var_exists, array_exists, creating_array, array_subscript_assignment;
+#endif
+
+      name = savestring (list->word->word);
+      wflags = list->word->flags;
+#if defined (ARRAY_VARS)
+      assoc_noexpand = assoc_expand_once && (wflags & W_ASSIGNMENT);
+#else
+      assoc_noexpand = 0;
+#endif
+      offset = assignment (name, assoc_noexpand ? 2 : 0);
+      aflags = 0;
+      created_var = 0;
+
+      if (local_var && variable_context && STREQ (name, "-"))
+	{
+	  var = make_local_variable ("-", 0);
+	  FREE (value_cell (var));		/* just in case */
+	  value = get_current_options ();
+	  var_setvalue (var, value);
+	  VSETATTR (var, att_invisible);
+	  NEXT_VARIABLE ();
+	}
+
+      /* If we are declaring a function, then complain about it in some way.
+	 We don't let people make functions by saying `typeset -f foo=bar'. */
+
+      /* Can't define functions using assignment statements */
+      if (offset && (flags_on & att_function))	/* declare -f [-rix] foo=bar */
+	{
+	  builtin_error (_("cannot use `-f' to make functions"));
+	  free (name);
+	  return (EXECUTION_FAILURE);
+	}
+
+      /* There should be a way, however, to let people look at a particular
+	 function definition by saying `typeset -f foo'.  This is the only
+	 place in this builtin where we deal with functions. */
+
+      if (flags_on & att_function)
+	{
+	  /* Should we restrict this when the shell is in posix mode even if
+	     the function was created before the shell entered posix mode?
+	     Previous versions of the shell enforced the restriction. */
+	  if (posixly_correct && legal_identifier (name) == 0)
+	    {
+	      sh_invalidid (name);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+
+	  var = find_function (name);
+
+	  if (var)
+	    {
+	      if (readonly_p (var) && (flags_off & att_readonly))
+		{
+		  builtin_error (_("%s: readonly function"), name);
+		  any_failed++;
+		  NEXT_VARIABLE ();
+		}
+	      /* declare -[Ff] name [name...] */
+	      if (flags_on == att_function && flags_off == 0)
+		{
+#if defined (DEBUGGER)
+		  if (nodefs && debugging_mode)
+		    {
+		      shell_fn = find_function_def (name_cell (var));
+		      if (shell_fn)
+			printf ("%s %d %s\n", name_cell (var), shell_fn->line, shell_fn->source_file);
+		      else
+			printf ("%s\n", name_cell (var));
+		    }
+		  else
+#endif /* DEBUGGER */
+		    {	
+		      t = nodefs ? name_cell (var) : named_function_string (name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL);
+		      printf ("%s\n", t);
+		      any_failed = sh_chkwrite (any_failed);
+		    }
+		}
+	      else		/* declare -[fF] -[rx] name [name...] */
+		{
+		  VSETATTR (var, flags_on);
+		  flags_off &= ~att_function;	/* makes no sense */
+		  VUNSETATTR (var, flags_off);
+		}
+	    }
+	  else
+	    any_failed++;
+
+	  NEXT_VARIABLE ();
+	}
+
+      if (offset)	/* declare [-aAfFirx] name=value */
+	{
+	  name[offset] = '\0';
+	  value = name + offset + 1;
+	  if (name[offset - 1] == '+')
+	    {
+	      aflags |= ASS_APPEND;
+	      name[offset - 1] = '\0';
+	    }
+	}
+      else
+	value = "";
+
+      /* Do some lexical error checking on the LHS and RHS of the assignment
+	 that is specific to nameref variables. */
+      if (flags_on & att_nameref)
+	{
+#if defined (ARRAY_VARS)
+	  if (valid_array_reference (name, 0))
+	    {
+	      builtin_error (_("%s: reference variable cannot be an array"), name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+	  else
+#endif
+	  /* disallow self references at global scope, warn at function scope */
+	  if (check_selfref (name, value, 0))
+	    {
+	      if (variable_context == 0)
+		{
+		  builtin_error (_("%s: nameref variable self references not allowed"), name);
+		  assign_error++;	/* XXX any_failed++ instead? */
+		  NEXT_VARIABLE ();
+		}
+	      else
+		builtin_warning (_("%s: circular name reference"), name);
+	    }
+	  if (value && *value && (aflags & ASS_APPEND) == 0 && valid_nameref_value (value, 1) == 0)
+	    {
+	      builtin_error (_("`%s': invalid variable name for name reference"), value);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+	}
+
+restart_new_var_name:
+
+      /* The rest of the loop body deals with declare -[aAinrx] name [name...]
+	 where each NAME can be an assignment statement. */
+
+      subscript_start = (char *)NULL;	/* used below */
+#if defined (ARRAY_VARS)
+      /* Determine whether we are creating or assigning an array variable */
+      var_exists = array_exists = creating_array = 0;
+      compound_array_assign = simple_array_assign = 0;
+      array_subscript_assignment = 0;
+      if (t = strchr (name, '['))	/* ] */
+	{
+	  /* If offset != 0 we have already validated any array reference
+	     because assignment() calls skipsubscript() */
+	  if (offset == 0 && valid_array_reference (name, 0) == 0)
+	    {
+	      sh_invalidid (name);
+	      assign_error++;
+	      NEXT_VARIABLE ();
+	    }
+	  subscript_start = t;
+	  *t = '\0';
+	  making_array_special = 1;	/* XXX - should this check offset? */
+	  array_subscript_assignment = offset != 0;
+	}
+      else
+	making_array_special = 0;
+#endif
+
+      /* Ensure the argument is a valid, well-formed shell identifier. */
+      if (legal_identifier (name) == 0)
+	{
+	  sh_invalidid (name);
+	  assign_error++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* If VARIABLE_CONTEXT has a non-zero value, then we are executing
+	 inside of a function.  This means we should make local variables,
+	 not global ones. */
+
+      /* XXX - this has consequences when we're making a local copy of a
+	       variable that was in the temporary environment.  Watch out
+	       for this. */
+      refvar = (SHELL_VAR *)NULL;
+      if (variable_context && mkglobal == 0)
+	{
+	  char *newname;
+
+	  /* We don't check newname for validity here. We should not have an
+	     invalid name assigned as the value of a nameref, but this could
+	     cause problems. */
+	  newname = declare_transform_name (name, flags_on, flags_off);
+
+#if defined (ARRAY_VARS)
+	  /* Pass 1 as second argument to make_local_{assoc,array}_variable
+	     return an existing {array,assoc} variable to be flagged as an
+	     error below. */
+	  if (flags_on & att_assoc)
+	    var = make_local_assoc_variable (newname, MKLOC_ARRAYOK|inherit_flag);
+	  else if ((flags_on & att_array) || making_array_special)
+	    var = make_local_array_variable (newname, MKLOC_ASSOCOK|inherit_flag);
+	  else
+#endif
+	  if (offset == 0 && (flags_on & att_nameref))
+	    {
+	      /* First look for refvar at current scope */
+	      refvar = find_variable_last_nameref (name, 1);
+	      /* VARIABLE_CONTEXT != 0, so we are attempting to create or modify
+		 the attributes for a local variable at the same scope.  If we've
+		 used a reference from a previous context to resolve VAR, we
+		 want to throw REFVAR and VAR away and create a new local var. */
+	      if (refvar && refvar->context != variable_context)
+		{
+		  refvar = 0;
+		  var = make_local_variable (name, inherit_flag);
+		}
+	      else if (refvar && refvar->context == variable_context)
+		var = refvar;
+	      /* Maybe we just want to create a new local variable */
+	      else if (var == 0 || var->context != variable_context)
+		var = make_local_variable (name, inherit_flag);
+	      /* otherwise we have a var at the right context */
+	    }
+	  else
+	    /* XXX - check name for validity here with valid_nameref_value? */
+	    var = make_local_variable ((flags_on & att_nameref) ? name : newname, inherit_flag);	/* sets att_invisible for new vars */
+
+	  if (var == 0)
+	    {
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+	  if (var && nameref_p (var) && readonly_p (var) && nameref_cell (var) && (flags_off & att_nameref))
+	    {
+	      sh_readonly (name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+	}
+      else
+	var = (SHELL_VAR *)NULL;
+
+      /* VAR is non-null if we just created or fetched a local variable. */
+
+      /* Here's what ksh93 seems to do as of the 2012 version: if we are
+	 using declare -n to modify the value of an existing nameref
+	 variable, don't follow the nameref chain at all and just search
+	 for a nameref at the current context.  If we have a nameref,
+	 modify its value (changing which variable it references). */
+      if (var == 0 && (flags_on & att_nameref))
+	{
+	  /* See if we are trying to modify an existing nameref variable,
+	     but don't follow the nameref chain. */
+	  var = mkglobal ? find_global_variable_noref (name) : find_variable_noref (name);
+	  if (var && nameref_p (var) == 0)
+	    var = 0;
+	}
+
+      /* However, if we're turning off the nameref attribute on an existing
+	 nameref variable, we first follow the nameref chain to the end,
+	 modify the value of the variable this nameref variable references
+	 if there is an assignment statement argument,
+	 *CHANGING ITS VALUE AS A SIDE EFFECT*, then turn off the nameref
+	 flag *LEAVING THE NAMEREF VARIABLE'S VALUE UNCHANGED* */
+      else if (var == 0 && (flags_off & att_nameref))
+	{
+	  /* See if we are trying to modify an existing nameref variable */
+	     refvar = mkglobal ? find_global_variable_last_nameref (name, 0) : find_variable_last_nameref (name, 0);
+	  if (refvar && nameref_p (refvar) == 0)
+	    refvar = 0;
+	  /* If the nameref is readonly but doesn't have a value, ksh93
+	     allows the nameref attribute to be removed.  If it's readonly
+	     and has a value, even if the value doesn't reference an
+	     existing variable, we disallow the modification */
+	  if (refvar && nameref_cell (refvar) && readonly_p (refvar))
+	    {
+	      sh_readonly (name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+
+	  /* If all we're doing is turning off the nameref attribute, don't
+	     bother with VAR at all, whether it exists or not. Just turn it
+	     off and go on. */
+	  if (refvar && flags_on == 0 && offset == 0 && flags_off == att_nameref)
+	    {
+	      VUNSETATTR (refvar, att_nameref);
+	      NEXT_VARIABLE ();
+	    }
+
+	  if (refvar)
+	    var = declare_find_variable (nameref_cell (refvar), mkglobal, 0);
+	}
+#if defined (ARRAY_VARS)
+      /* If we have an array assignment to a nameref, remove the nameref
+	 attribute and go on.  This handles
+	 declare -n xref[=value]; declare [-a] xref[1]=one */
+      else if (var == 0 && offset && array_subscript_assignment)
+	{
+	  var = mkglobal ? find_global_variable_noref (name) : find_variable_noref (name);
+	  if (var && nameref_p (var))
+	    {
+	      internal_warning (_("%s: removing nameref attribute"), name);
+	      FREE (value_cell (var));		/* XXX - bash-4.3 compat */
+	      var_setvalue (var, (char *)NULL);
+	      VUNSETATTR (var, att_nameref);
+	    }
+	}
+#endif
+
+      /* See if we are trying to set flags or value (or create) for an
+	 existing nameref that points to a non-existent variable: e.g.,
+		declare -n foo=bar
+		unset foo	# unsets bar
+		declare -i foo
+		foo=4+4
+		declare -p foo
+      */
+      if (var == 0 && (mkglobal || flags_on || flags_off || offset))
+	{
+	  refvar = mkglobal ? find_global_variable_last_nameref (name, 0) : find_variable_last_nameref (name, 0);
+	  if (refvar && nameref_p (refvar) == 0)
+	    refvar = 0;
+	  if (refvar)
+	    var = declare_find_variable (nameref_cell (refvar), mkglobal, 0);
+	  if (refvar && var == 0)
+	    {
+	      oldname = name;	/* need to free this */
+
+	      /* I'm not sure subscript_start is ever non-null here. In any
+		 event, build a new name from the nameref value, including any
+		 subscript, and add the [[+]=value] if offset != 0 */
+	      name = declare_build_newname (nameref_cell (refvar), subscript_start, offset, value, aflags);
+
+	      if (offset)
+	        {
+		  offset = assignment (name, 0);
+		  /* If offset was valid previously, but substituting the
+		     the nameref value results in an invalid assignment,
+		     throw an invalid identifier error */
+		  if (offset == 0)
+		    {
+		      free (oldname);
+		      sh_invalidid (name);
+		      assign_error++;
+		      NEXT_VARIABLE ();
+		    }
+		  name[(aflags & ASS_APPEND) ? offset - 1 : offset] = '\0';
+		  value = name + offset + 1;
+		}
+	      free (oldname);
+
+	      /* OK, let's turn off the nameref attribute.
+		 Now everything else applies to VAR. */
+	      if (flags_off & att_nameref)
+		VUNSETATTR (refvar, att_nameref);
+
+	      goto restart_new_var_name;
+	      /* NOTREACHED */
+	    }
+	}
+      if (var == 0)
+	var = declare_find_variable (name, mkglobal, chklocal);
+
+      /* At this point, VAR is the variable we are dealing with; REFVAR is the
+	 nameref variable we dereferenced to get VAR, if any. */
+#if defined (ARRAY_VARS)
+      var_exists = var != 0;
+      array_exists = var && (array_p (var) || assoc_p (var));
+      creating_array = flags_on & (att_array|att_assoc);
+#endif
+
+      /* Make a new variable if we need to. */
+      if (var == 0)
+	{
+#if defined (ARRAY_VARS)
+	  if (flags_on & att_assoc)
+	    {
+	      var = make_new_assoc_variable (name);
+	      if (var && offset == 0)
+		VSETATTR (var, att_invisible);
+	    }
+	  else if ((flags_on & att_array) || making_array_special)
+	    {
+	      var = make_new_array_variable (name);
+	      if (var && offset == 0)
+	        VSETATTR (var, att_invisible);
+	    }
+	  else
+#endif
+	    {
+	      var = mkglobal ? bind_global_variable (name, (char *)NULL, ASS_FORCE) : bind_variable (name, (char *)NULL, ASS_FORCE);
+	      if (var && offset == 0)
+	        VSETATTR (var, att_invisible);
+	    }
+	  if (var == 0)
+	    {
+	      /* Has to appear in brackets */
+	      NEXT_VARIABLE ();
+	    }
+	  created_var = 1;
+	}
+
+      /* Nameref variable error checking. */
+
+      /* Can't take an existing array variable and make it a nameref */
+      else if ((array_p (var) || assoc_p (var)) && (flags_on & att_nameref))
+	{
+	  builtin_error (_("%s: reference variable cannot be an array"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't have an invalid identifier as nameref value */
+      else if (nameref_p (var) && (flags_on & att_nameref) == 0 && (flags_off & att_nameref) == 0 && offset && valid_nameref_value (value, 1) == 0)
+	{
+	  builtin_error (_("`%s': invalid variable name for name reference"), value);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't make an existing variable a nameref if its current value is not
+	 a valid identifier. Check of offset is to allow an assignment to a
+	 nameref var as part of the declare word to override existing value. */
+      else if ((flags_on & att_nameref) && nameref_p (var) == 0 && var_isset (var) && offset == 0 && valid_nameref_value (value_cell (var), 0) == 0)
+	{
+	  builtin_error (_("`%s': invalid variable name for name reference"), value_cell (var));
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Can't make an existing readonly variable a nameref. */
+      else if ((flags_on & att_nameref) && readonly_p (var))
+	{
+	  sh_readonly (name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* Readonly variable error checking. */
+
+      /* Cannot use declare +r to turn off readonly attribute. */ 
+      if (readonly_p (var) && (flags_off & att_readonly))
+	{
+	  sh_readonly (name_cell (var));
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      /* Cannot use declare to assign value to readonly or noassign variable. */
+      else if ((readonly_p (var) || noassign_p (var)) && offset)
+	{
+	  if (readonly_p (var))
+	    sh_readonly (name);
+	  assign_error++;
+	  NEXT_VARIABLE ();
+	}
+
+#if defined (ARRAY_VARS)
+      /* Array variable error checking. */
+
+      /* Cannot use declare +a name or declare +A name to remove an array variable. */
+      if (((flags_off & att_array) && array_p (var)) || ((flags_off & att_assoc) && assoc_p (var)))
+	{
+	  builtin_error (_("%s: cannot destroy array variables in this way"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      else if ((flags_on & att_array) && assoc_p (var))
+	{
+	  builtin_error (_("%s: cannot convert associative to indexed array"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+      else if ((flags_on & att_assoc) && array_p (var))
+	{
+	  builtin_error (_("%s: cannot convert indexed to associative array"), name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* make declare a[2]=foo as similar to a[2]=foo as possible if a is
+	 already an array or assoc variable. */
+      if (array_subscript_assignment && array_exists && creating_array == 0)
+	simple_array_assign = 1;
+      else if ((making_array_special || creating_array || array_exists) && offset)
+	{
+	  int vlen;
+	  vlen = STRLEN (value);
+/*itrace("declare_builtin: name = %s value = %s flags = %d", name, value, wflags);*/
+
+	  /* Print a warning for a construct like
+		declare -a array='(quoted compound value)'
+	     if the array variable doesn't already exist. */
+	  if (shell_compatibility_level > 43 && (wflags & W_COMPASSIGN) == 0 &&
+		value[0] == '(' && value[vlen-1] == ')')
+	    {
+	      /* The warning is only printed when using compound assignment
+		 to an array variable that doesn't already exist.  We use
+		 creating_array to allow things like
+		     declare -a foo$bar='(abc)' to work. */		     
+	      if (array_exists == 0 && creating_array == 0)
+		internal_warning (_("%s: quoted compound array assignment deprecated"), list->word->word);
+	      compound_array_assign = array_exists || creating_array;
+	      simple_array_assign = making_array_special;
+	    }
+	  else if (value[0] == '(' && value[vlen-1] == ')' && (shell_compatibility_level < 44 || (wflags & W_COMPASSIGN)))
+	    compound_array_assign = 1;
+	  else
+	    simple_array_assign = 1;
+	}
+
+      /* declare -A name[[n]] makes name an associative array variable. */
+      if (flags_on & att_assoc)
+	{
+	  if (assoc_p (var) == 0)
+	    var = convert_var_to_assoc (var);
+	}
+      /* declare -a name[[n]] or declare name[n] makes NAME an indexed
+	 array variable. */
+      else if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0 && assoc_p (var) == 0)
+	var = convert_var_to_array (var);
+#endif /* ARRAY_VARS */
+
+      /* ksh93 compat: turning on nameref attribute turns off -ilu */
+      if (flags_on & att_nameref)
+	VUNSETATTR (var, att_integer|att_uppercase|att_lowercase|att_capcase);
+
+      /* XXX - we note that we are turning on nameref attribute and defer
+	 setting it until the assignment has been made so we don't do an
+	 inadvertent nameref lookup.  Might have to do the same thing for
+	 flags_off&att_nameref. */
+      /* XXX - ksh93 makes it an error to set a readonly nameref variable
+	 using a single typeset command. */
+      onref = (flags_on & att_nameref);
+      flags_on &= ~att_nameref;
+#if defined (ARRAY_VARS)
+      /* I don't believe this condition ever tests true, but array variables
+	 may not be namerefs */
+      if (array_p (var) || assoc_p (var) || (offset && compound_array_assign)
+	    || simple_array_assign)
+	onref = 0;
+#endif
+
+      /* ksh93 seems to do this */
+      offref = (flags_off & att_nameref);
+      flags_off &= ~att_nameref;
+
+      VSETATTR (var, flags_on);
+      VUNSETATTR (var, flags_off);
+
+#if defined (ARRAY_VARS)
+      if (offset && compound_array_assign)
+	assign_array_var_from_string (var, value, aflags|ASS_FORCE);
+      else if (simple_array_assign && subscript_start)
+	{
+	  int local_aflags;
+	  /* declare [-aA] name[N]=value */
+	  *subscript_start = '[';	/* ] */
+	  /* XXX - problem here with appending */
+	  local_aflags = aflags&ASS_APPEND;
+	  local_aflags |= assoc_noexpand ? ASS_NOEXPAND : 0;
+	  var = assign_array_element (name, value, local_aflags);	/* XXX - not aflags */
+	  *subscript_start = '\0';
+	  if (var == 0)	/* some kind of assignment error */
+	    {
+	      assign_error++;
+	      flags_on |= onref;
+	      flags_off |= offref;
+	      NEXT_VARIABLE ();
+	    }
+	}
+      else if (simple_array_assign)
+	{
+	  /* let bind_{array,assoc}_variable take care of this. */
+	  if (assoc_p (var))
+	    bind_assoc_variable (var, name, savestring ("0"), value, aflags|ASS_FORCE);
+	  else
+	    bind_array_variable (name, 0, value, aflags|ASS_FORCE);
+	}
+      else
+#endif
+      /* XXX - no ASS_FORCE here */
+      /* bind_variable_value duplicates the essential internals of bind_variable() */
+      if (offset)
+	{
+	  if (onref || nameref_p (var))
+	    aflags |= ASS_NAMEREF;
+	  v = bind_variable_value (var, value, aflags);
+	  if (v == 0 && (onref || nameref_p (var)))
+	    {
+	      if (valid_nameref_value (value, 1) == 0)
+		sh_invalidid (value);
+	      assign_error++;
+	      /* XXX - unset this variable? or leave it as normal var? */
+	      if (created_var)
+		delete_var (name_cell (var), mkglobal ? global_variables : shell_variables);
+	      flags_on |= onref;		/* undo change from above */
+	      flags_off |= offref;
+	      NEXT_VARIABLE ();
+	    }
+	}
+
+      /* If we found this variable in the temporary environment, as with
+	 `var=value declare -x var', make sure it is treated identically
+	 to `var=value export var'.  Do the same for `declare -r' and
+	 `readonly'.  Preserve the attributes, except for att_tempvar. */
+      /* XXX -- should this create a variable in the global scope, or
+	 modify the local variable flags?  ksh93 has it modify the
+	 global scope.
+	 Need to handle case like in set_var_attribute where a temporary
+	 variable is in the same table as the function local vars. */
+      if ((flags_on & (att_exported|att_readonly)) && tempvar_p (var))
+	{
+	  SHELL_VAR *tv;
+	  char *tvalue;
+
+	  tv = find_tempenv_variable (name_cell (var));
+	  if (tv)
+	    {
+	      tvalue = var_isset (var) ? savestring (value_cell (var)) : savestring ("");
+	      tv = bind_variable (name_cell (var), tvalue, 0);
+	      if (tv)
+		{
+		  tv->attributes |= var->attributes & ~att_tempvar;
+		  if (tv->context > 0)
+		    VSETATTR (tv, att_propagate);
+		}
+	      free (tvalue);
+	    }
+	  VSETATTR (var, att_propagate);
+	}
+
+      /* Turn on nameref attribute we deferred above. */
+      /* XXX - should we turn on the noassign attribute for consistency with
+	 ksh93 when we turn on the nameref attribute? */
+      VSETATTR (var, onref);
+      flags_on |= onref;
+      VUNSETATTR (var, offref);
+      flags_off |= offref;
+      /* Yuck.  ksh93 compatibility.  XXX - need to investigate more but
+	 definitely happens when turning off nameref attribute on nameref
+	 (see comments above).  Under no circumstances allow this to turn
+	 off readonly attribute on readonly nameref variable. */
+      if (refvar)
+	{
+	  if (flags_off & att_readonly)
+	    flags_off &= ~att_readonly;
+ 	  VUNSETATTR (refvar, flags_off);
+	}
+
+      stupidly_hack_special_variables (name);
+
+      NEXT_VARIABLE ();
+    }
+
+  return (assign_error ? EX_BADASSIGN
+		       : ((any_failed == 0) ? EXECUTION_SUCCESS
+  					    : EXECUTION_FAILURE));
+}

command.h

@@ -124,6 +124,7 @@ enum command_type { cm_for, cm_case, cm_while, cm_if, cm_simple, cm_select,
 #define SUBSHELL_PROCSUB 0x20	/* subshell caused by <(command) or >(command) */
 #define SUBSHELL_COPROC	0x40	/* subshell from a coproc pipeline */
 #define SUBSHELL_RESETTRAP 0x80	/* subshell needs to reset trap strings on first call to trap */
+#define SUBSHELL_IGNTRAP 0x100  /* subshell should reset trapped signals from trap_handler */
 
 /* A structure which represents a word. */
 typedef struct word_desc {

execute_cmd.c

@@ -1547,6 +1547,9 @@ execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close)
   clear_pending_traps ();
   reset_signal_handlers ();
   subshell_environment |= SUBSHELL_RESETTRAP;
+  /* Note that signal handlers have been reset, so we should no longer
+    reset the handler and resend trapped signals to ourselves. */
+  subshell_environment &= ~SUBSHELL_IGNTRAP;
 
   /* We are in a subshell, so forget that we are running a trap handler or
      that the signal handler has changed (we haven't changed it!) */
@@ -4332,7 +4335,8 @@ execute_simple_command (simple_command, pipe_in, pipe_out, async, fds_to_close)
 	  already_forked = 1;
 	  cmdflags |= CMD_NO_FORK;
 
-	  subshell_environment = SUBSHELL_FORK;		/* XXX */
+	  /* We redo some of what make_child() does with SUBSHELL_IGNTRAP */
+	  subshell_environment = SUBSHELL_FORK|SUBSHELL_IGNTRAP;	/* XXX */
 	  if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
 	    subshell_environment |= SUBSHELL_PIPE;
 	  if (async)
@@ -4586,6 +4590,7 @@ run_builtin:
 	     trap strings if we run trap to change a signal disposition. */
 	  reset_signal_handlers ();
 	  subshell_environment |= SUBSHELL_RESETTRAP;
+	  subshell_environment &= ~SUBSHELL_IGNTRAP;
 
 	  if (async)
 	    {
@@ -5526,6 +5531,7 @@ execute_disk_command (words, redirects, command_line, pipe_in, pipe_out,
       reset_terminating_signals ();	/* XXX */
       /* Cancel traps, in trap.c. */
       restore_original_signals ();
+      subshell_environment &= ~SUBSHELL_IGNTRAP;
 
 #if defined (JOB_CONTROL)
       FREE (p);

jobs.c

@@ -2220,6 +2220,8 @@ make_child (command, flags)
 	 signals to the default state for a new process. */
       pid_t mypid;
 
+      subshell_environment |= SUBSHELL_IGNTRAP;
+
       /* If this ends up being changed to modify or use `command' in the
 	 child process, go back and change callers who free `command' in
 	 the child process when this returns. */

nojobs.c

@@ -575,6 +575,8 @@ make_child (command, flags)
 	last_asynchronous_pid = getpid ();
 #endif
 
+      subshell_environment |= SUBSHELL_IGNTRAP;
+
       default_tty_job_signals ();
     }
   else

po/hr.po

@@ -3,13 +3,13 @@
 # This file is distributed under the same license as the bash package.
 #
 # Tomislav Krznar <tomislav.krznar@gmail.com>, 2012, 2013.
-# Božidar Putanec <bozidarp@yahoo.com>, 2018, 2019, 2020.
+# Božidar Putanec <bozidarp@yahoo.com>, 2018, 2019, 2020, 2021.
 msgid ""
 msgstr ""
 "Project-Id-Version: bash 5.1\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2020-11-28 12:51-0500\n"
-"PO-Revision-Date: 2020-12-29 11:38-0800\n"
+"PO-Revision-Date: 2021-01-02 13:56-0800\n"
 "Last-Translator: Božidar Putanec <bozidarp@yahoo.com>\n"
 "Language-Team: Croatian <lokalizacija@linux.hr>\n"
 "Language: hr\n"
@@ -774,7 +774,7 @@ msgid ""
 msgstr ""
 "Doda direktorij na vrh stȏga direktorija ili zarotira stȏg tako da\n"
 "    učini novi vrh stȏga trenutnim radnim direktorijem. Bez argumenata\n"
-"    razmijeni pozicije dva direktorija na vrhu stȏga.\n"
+"    razmijeni pozicije dvama direktorijima na vrhu stȏga.\n"
 "\n"
 "    Opcije:\n"
 "      -n   spriječi uobičajenu promjenu direktorija kad dodaje\n"
@@ -810,8 +810,9 @@ msgid ""
 "    \n"
 "    The `dirs' builtin displays the directory stack."
 msgstr ""
-"Ukloni direktorije iz stȏga direktorija. Bez argumenata, ukloni\n"
-"    direktorij na vrhu stȏga i premjesti se u novi najviši direktorij.\n"
+"Ukloni zapise iz stȏga direktorija. Bez argumenata, ukloni direktorij na\n"
+"    vrhu stȏga i učini da je trenutni radni direktorij jednak novom direktoriju\n"
+"    na vrhu stȏga.\n"
 "\n"
 "    Opcije:\n"
 "      -n   spriječi uobičajenu promjenu direktorija kad uklanja\n"
@@ -2334,7 +2335,7 @@ msgstr ""
 msgid "jobs [-lnprs] [jobspec ...] or jobs -x command [args]"
 msgstr ""
 "jobs [-lnprs] [SPECIFIKACIJA_POSLA...]\n"
-" ili: jobs -x NAREDBA [ARGUMENTI]"
+" ili: jobs -x NAREDBA [ARGUMENT...]"
 
 #: builtins.c:131
 msgid "disown [-h] [-ar] [jobspec ... | pid ...]"
@@ -2431,7 +2432,7 @@ msgstr "wait [PID...]"
 
 #: builtins.c:184
 msgid "for NAME [in WORDS ... ] ; do COMMANDS; done"
-msgstr "for IME [in RIJEČIMA .... do NAREDBE; done"
+msgstr "for IME [in RIJEČIMA...].; do NAREDBE; done"
 
 #: builtins.c:186
 msgid "for (( exp1; exp2; exp3 )); do COMMANDS; done"
@@ -2439,7 +2440,7 @@ msgstr "for (( IZRAZ1; IZRAZ2; IZRAZ3 )); do NAREDBE; done"
 
 #: builtins.c:188
 msgid "select NAME [in WORDS ... ;] do COMMANDS; done"
-msgstr "select IME [in RIJEČI ....; do NAREDBE; done"
+msgstr "select IME [in RIJEČI... ;] do NAREDBE; done"
 
 #: builtins.c:190
 msgid "time [-p] pipeline"
@@ -2489,7 +2490,7 @@ msgstr "[[ IZRAZ ]]"
 
 #: builtins.c:212
 msgid "variables - Names and meanings of some shell variables"
-msgstr "varijable — imena i značenje nekih varijabla ljuske"
+msgstr "var — imena i značenje nekih varijabla ljuske"
 
 #: builtins.c:215
 msgid "pushd [-n] [+N | -N | dir]"
@@ -2532,13 +2533,13 @@ msgstr "compopt [-o|+o OPCIJA] [-DEI] [IME...]"
 #: builtins.c:242
 msgid "mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]"
 msgstr ""
-"mapfile [-d MEĐA] [-n BROJ] [-O POČETAK] [-s BROJ] [-t] [-u FD]\n"
+"mapfile [-d MEĐA] [-n KOLIČINA [-O POČETAK] [-s BROJ] [-t] [-u FD]\n"
 "                 [-C FUNKCIJA] [-c TOLIKO] [POLJE]"
 
 #: builtins.c:244
 msgid "readarray [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]"
 msgstr ""
-"readarray [-d MEĐA] [-n BROJ] [-O POČETAK] [-s BROJ] [-t] [-u FD]\n"
+"readarray [-d MEĐA] [-n KOLIČINA] [-O POČETAK] [-s BROJ] [-t] [-u FD]\n"
 "                     [-C FUNKCIJA] [-c TOLIKO] [POLJE]"
 
 #: builtins.c:256
@@ -2561,11 +2562,11 @@ msgid ""
 msgstr ""
 "Definira ili prikaže aliase.\n"
 "\n"
-"    Bez argumenata, „alias“ ispiše popis aliasa na standardni izlaz u\n"
-"    upotrebljivom formatu: 'alias IME=ZAMJENA'. S argumentima, alias je\n"
-"    definiran za svako IME za koje je navedena ZAMJENA. Ako ZAMJENA završi\n"
-"    s razmakom (bjelinom), onda alias pri ekspanziji provjeri da li je i\n"
-"    sljedeća riječ alias.\n"
+"    Bez argumenata (ili s opcijom -p), „alias“ ispiše popis aliasa na\n"
+"    standardni izlaz u upotrebljivom formatu: alias IME='ZAMJENA'.\n"
+"    S argumentima, alias je definiran za svako IME za koje je navedena ZAMJENA.\n"
+"    Zaostali razmak (bjelina) u ZAMJENI čini da „alias“ prilikom ekspanzije\n"
+"    provjerava je li i sljedeća riječ zamjenska.\n"
 "\n"
 "    Options:\n"
 "      -p       ispiše sve definirane aliase u upotrebljivom formatu\n"
@@ -2632,7 +2633,7 @@ msgstr ""
 "\n"
 "    Opcije:\n"
 "      -f DATOTEKA        pročita prečace (bindings, key sequences) iz DATOTEKE\n"
-"      -l                 ispiše sve poznate funkcije\n"
+"      -l                 izlista imena svih poznatih funkcija\n"
 "      -m MAPA_TIPAKA     koristi MAPU_TIPAKA (keymap) dok traje ova naredba;\n"
 "                         moguće MAPE_TIPAKA su jedna od emacs, emacs-standard,\n"
 "                         emacs-meta, emacs-ctlx, vi, vi-move, vi-command,\n"
@@ -2641,13 +2642,13 @@ msgstr ""
 "      -p                 ispiše imena funkcija i prečaca u obliku\n"
 "                           koji se može iskoristiti kao ulaz\n"
 "      -r PREČAC          razveže PREČAC (ukloni sekvenciju tipki za prečac)\n"
-"      -q FUNKCIJA        ispita i ispiše tipke koje pozivaju navedenu FUNKCIJU\n"
+"      -q FUNKCIJA        ispita i ispiše tipke koje pozivaju tu FUNKCIJU\n"
 "      -S                 izlista prečace (sekvencije tipki) koje pozivaju makroe\n"
 "                           s njihovim vrijednostima\n"
 "      -s                 ispiše sekvencije tipki poje pozivaju makroe s\n"
 "                           njihovim vrijednostima u obliku koji se može\n"
 "                           iskoristiti kao ulaz\n"
-"      -u FUNKCIJA        razveže sve prečace vezane na navedenu FUNKCIJU\n"
+"      -u FUNKCIJA        razveže sve prečace vezane na tu FUNKCIJU\n"
 "      -V                 izlista imena varijabli s njihovim vrijednostima\n"
 "      -v                 ispiše imena varijabli s njihovim vrijednostima\n"
 "                           u formatu koji se može iskoristiti kao ulaz\n"
@@ -2705,14 +2706,14 @@ msgid ""
 msgstr ""
 "Izvrši ugrađenu funkciju ljuske (shell builtins).\n"
 "\n"
-"    Izvrši danu UGRAĐENU_SHELL_FUNKCIJU (SHELL-BUILTIN) funkciju s navedenim\n"
-"    ARGUMENTIMA. To je korisno ako želite redefinirati implementaciju\n"
-"    ugrađene shell funkcije kao vlastitu shell funkciju (skriptu s istim\n"
-"    imenom kao ugrađena shell funkcija), a potrebna vam je funkcionalnost\n"
-"    te ugrađene shell funkcije unutar vaše vlastite skripte (shell funkcije).\n"
+"    Izvrši danu UGRAĐENU_SHELL_FUNKCIJU s navedenim ARGUMENTIMA.\n"
+"    To je korisno ako želite redefinirati implementaciju ugrađene shell\n"
+"    funkcije kao vlastitu shell funkciju (skriptu s istim imenom kao ugrađena\n"
+"    shell funkcija), a potrebna vam je funkcionalnost te ugrađene shell\n"
+"    funkcije unutar vaše vlastite skripte.\n"
 "\n"
 "    Završi s kȏdom UGRAĐENE_SHELL_FUNKCIJE ili s kȏdom 1 ako\n"
-"    UGRAĐENA_SHELL_FUNKCIJA nije ugrađene funkcija ljuske (shell builtin)."
+"    UGRAĐENA_SHELL_FUNKCIJA nije ugrađene funkcija ljuske."
 
 #: builtins.c:369
 msgid ""
@@ -2729,14 +2730,14 @@ msgid ""
 "    Returns 0 unless the shell is not executing a shell function or EXPR\n"
 "    is invalid."
 msgstr ""
-"Pokaže kontekst trenutnog poziva funkciji.\n"
+"Vrati kontekst trenutnog poziva funkciji.\n"
 "\n"
-"    Bez IZRAZA, vrati „$line $filename“. Ako je dan IZRAZ, vrati\n"
-"    „$line $subroutine $filename“; ova dodatna obavijest može poslužiti\n"
-"    za „stack trace“.\n"
+"    Bez IZRAZA, vrati „$line $filename“. Ako je dan IZRAZ, onda vrati\n"
+"    „$line $subroutine $filename“; ova dodatna informacija može poslužiti za\n"
+"    stvaranje „stack trace“.\n"
 "\n"
-"    Vrijednost IZRAZA pokazuje koliko se treba vratiti unatrag od\n"
-"    trenutne pozicije, s time da je pozicija 0 trenutna pozicija.\n"
+"    Vrijednost IZRAZA naznačuje koliko ciklusa se treba vratiti\n"
+"    unatrag od trenutne pozicije; trenutni ciklus ima vrijednost 0.\n"
 "\n"
 "    Završi s uspjehom osim ako ljuska ne izvršava ljuskinu funkciju\n"
 "    ili je IZRAZ nevaljan."
@@ -2780,7 +2781,7 @@ msgstr ""
 "Promjeni trenutni direktorij.\n"
 "\n"
 "    Promijeni trenutni direktorij u navedeni DIREKTORIJ. Ako DIREKTORIJ nije\n"
-"    naveden, onda se za DIREKTORIJ koristi vrijednost varijable HOME.\n"
+"    naveden, za DIREKTORIJ se koristi vrijednost varijable HOME.\n"
 "\n"
 "    Varijabla CDPATH definira staze (direktorije) po kojima se\n"
 "    traži DIREKTORIJ.\n"
@@ -2794,12 +2795,11 @@ msgstr ""
 "    naziv, „cd“ prijeđe u direktorij s tim nazivom.\n"
 "\n"
 "    Opcije:\n"
-"      -L    slijedi simboličke veze; simboličke veze u DIREKTORIJU\n"
-"              razriješi nakon procesiranja „..“ instancije DIREKTORIJA;\n"
-"              opcija „-L“ je aktivna u zadanom (početnom) stanju\n"
-"      -P    rabi fizičku strukturu direktorija umjesto da slijedi\n"
-"              simboličke veze; simboličke veze DIREKTORIJA\n"
-"              razriješi prije procesiranja „..“ instancije DIREKTORIJA\n"
+"      -L    slijedi simboličke veze; simboličke veze u DIREKTORIJU razriješi\n"
+"              nakon obrade zapisa „..“\n"
+"      -P    rabi fizičku strukturu direktorija umjesto da slijedi simboličke\n"
+"              veze; simboličke veze u DIREKTORIJU razriješi prije obrade\n"
+"              zapisa „..“\n"
 "      -e    ako je dana s opcijom „-P“, i trenutni radni direktorij nije\n"
 "              moguće uspješno odrediti nakon uspješne promjene direktorija,\n"
 "              „cd“ završi s kȏdom različitim od 0.\n"
@@ -2893,8 +2893,8 @@ msgstr ""
 "    Opcije:\n"
 "      -p   rabi zadanu vrijednost za PATH kao garanciju\n"
 "             pronalaženja svih standardnih programa\n"
-"      -v   ispiše opis NAREDBE, slično kao „type“ builtin\n"
-"      -V   ispiše opširniji opis svake navedene NAREDBE\n"
+"      -v   pokaže ime naredbe koja bi se izvršila\n"
+"      -V   == „-v” ali opširnije\n"
 "\n"
 "    Završi s izlaznim kȏdom NAREDBE\n"
 "    ili s 1 ako NAREDBA nije pronađena."
@@ -2947,9 +2947,9 @@ msgstr ""
 "    Opcije:\n"
 "      -f   prikaže samo definirane funkcije (ne prikaže varijable)\n"
 "      -F   prikaže samo imena funkcija bez definicija\n"
-"      -g   kreira globalne varijable samo za upotrebu u funkciji ljuske;\n"
+"      -g   stvori globalne varijable samo za upotrebu u funkciji ljuske;\n"
 "             inače se ignoriraju\n"
-"      -I   ako kreira lokalnu varijablu, neka naslijedi atribute i vrijednost\n"
+"      -I   ako stvori lokalnu varijablu, neka naslijedi atribute i vrijednost\n"
 "             varijable s istim imenom u prethodnom opsegu\n"
 "      -p   prikaže atribute i vrijednost za svako dano IME\n"
 "\n"
@@ -2984,7 +2984,7 @@ msgid ""
 msgstr ""
 "Postavi vrijednosti i svojstva varijabli.\n"
 "\n"
-"    Sinonim za „declare“.  Za detalje, bez navodnika, utipkajte „help declare“."
+"    Sinonim za „declare“.  Za detalje utipkajte (bez navodnika) „help declare“."
 
 #: builtins.c:540
 msgid ""
@@ -3002,14 +3002,14 @@ msgid ""
 msgstr ""
 "Definira lokalne varijable.\n"
 "\n"
-"    Stvori lokalnu varijablu IME i dodijeli joj vrijednost. OPCIJA\n"
-"    može biti bilo koja od opcija koju prihvaća naredba „declare“.\n"
+"    Stvori lokalnu varijablu IME i dodijeli joj vrijednost. OPCIJA može biti\n"
+"    bilo koja od opcija koju prihvaća naredba „declare“.\n"
 "\n"
-"    Lokalne varijable mogu se koristiti samo unutar funkcije i\n"
-"    vidljive su samo toj funkciji i njezinim potomcima.\n"
+"    Lokalne varijable mogu se koristiti samo unutar funkcije i vidljive su\n"
+"    samo toj funkciji i njezinim potomcima.\n"
 "\n"
-"    Završi s uspjehom osim ako su navedene nevaljane opcije,ili\n"
-"    se dogodila greška pri dodijeli ili ljuska ne izvrši funkciju."
+"    Završi s uspjehom osim ako su navedene nevaljane opcije, ili se dogodila\n"
+"    greška pri dodijeli ili ljuska ne izvrši funkciju."
 
 #: builtins.c:557
 msgid ""
@@ -3144,7 +3144,7 @@ msgstr ""
 "\n"
 "    Primjer: da koristite binarnu datoteku „test“ koja se nalazi na stazi\n"
 "    pretraživanja PATH, umjesto ugrađene (test) naredbe, utipkajte\n"
-"    bez navodnika „enable -n test“.\n"
+"    (bez navodnika) „enable -n test“.\n"
 "\n"
 "    Završi s uspjehom osim ako IME nije ugrađena naredba ili se nije\n"
 "    dogodila greška."
@@ -3210,7 +3210,7 @@ msgstr ""
 "\n"
 "    „getopts” se može koristiti u skriptama za raščlanjivanje\n"
 "    pozicijskih parametara kao opcija.\n"
-"    \n"
+"\n"
 "    STRING_OPCIJA sadrži slova opcije koje treba prepoznati; ako iza\n"
 "    slova slijedi dvotočka, očekuje se da opcija ima argument koji treba\n"
 "    biti bjelinom odvojen od opcije.\n"
@@ -3223,11 +3223,11 @@ msgstr ""
 "    ljuskinu varijablu OPTARG.\n"
 "\n"
 "    getopts javlja greške na jedan od dva načina. Ako je dvotočka prvi znaku\n"
-"    u STRINGU_OPCIJA, getopts tiho prijavi grešku (ne ispisuje poruke o greškama).\n"
-"    Ako naiđe na nevaljanu opciju, getopts smjesti nađeni znak opcije u OPTARG.\n"
-"    Ako zahtijevani argument nije pronađen, getopts smjesti „:“ u IME i postavi\n"
-"    OPTARG na pronađeni znak opcije. Ako getopts ne radi tiho i naiđe na\n"
-"    nevaljanu opciju, getopts smjesti „?“ u IME i poništi OPTARG.\n"
+"    u STRINGU_OPCIJA, getopts tiho prijavi grešku, tj. ne ispisuje poruke o\n"
+"    greškama. Ako naiđe na nevaljanu opciju, getopts smjesti nađeni znak opcije\n"
+"    u OPTARG. Ako zahtijevani argument nije pronađen, getopts smjesti „:“ u IME\n"
+"    i postavi OPTARG na pronađeni znak opcije. Ako getopts ne radi tiho i naiđe\n"
+"    na nevaljanu opciju, getopts smjesti „?“ u IME i poništi OPTARG.\n"
 "    Ako zahtijevani argument nije pronađen, getopts smjesti „?“ u IME, poništi\n"
 "    OPTARG i ispiše poruku o greškama.\n"
 "\n"
@@ -3262,14 +3262,14 @@ msgid ""
 msgstr ""
 "Zamjeni ljusku s danom naredbom.\n"
 "\n"
-"    Izvrši danu NAREDBU, zamijenivši ovu ljusku s ovim programom.\n"
+"    Izvrši danu NAREDBU, zamjenjujući ovu ljusku s ovim programom.\n"
 "    Eventualni ARGUMENTI postanu argumenti NAREDBE. Ako NAREDBA nije\n"
 "    specificirana, sva preusmjeravanja se dogode u trenutnoj ljusci.\n"
 "\n"
 "    Opcije:\n"
 "      -a IME   dȁde IME kao nulti argument NAREDBI\n"
 "      -c       izvrši NAREDBU u praznoj okolini\n"
-"      -l       uvrsti spojnicu („-“) na početak nultog argumenta NAREDBE\n"
+"      -l       proslijedi crticu („-“) kao nulti argument NAREDBE\n"
 "\n"
 "    Ako se naredba ne može izvršiti, ne-interaktivna ljuska završi,\n"
 "    osim ako je aktivna opcija ljuske „execfail“.\n"
@@ -3365,8 +3365,8 @@ msgstr ""
 "    Bez navedene specifikacije posla, premjesti u prednji plan posao koji\n"
 "    ljuska smatra trenutnim.\n"
 "\n"
-"    Završi s kȏdom trenutne naredbe u prednjem planu\n"
-"    ili s neuspjehom ako se dogodi greška."
+"    Završi s kȏdom trenutne naredbe u prednjem planu ili s neuspjehom ako se\n"
+"    dogodi greška."
 
 #: builtins.c:779
 msgid ""
@@ -3448,7 +3448,7 @@ msgid ""
 "    Exit Status:\n"
 "    Returns success unless PATTERN is not found or an invalid option is given."
 msgstr ""
-"Prikaže podatke o ugrađenim (builtin) naredbama.\n"
+"Prikaže podatke o ugrađenim (builtins) naredbama.\n"
 "\n"
 "    Prikaže kratke sažetke o ugrađenim naredbama. Ako je specificiran\n"
 "    UZORAK, prikaže detaljnu pomoć za sve naredbe koje podudaraju UZORAK;\n"
@@ -3457,10 +3457,10 @@ msgstr ""
 "    Opcije:\n"
 "      -d   ukratko opisano djelovanje naredbe\n"
 "      -m   prikaže uporabu u pseudo manpage formatu\n"
-"      -s   prikaže samo sinopsis uporabe za svaku naredbu koja podudara UZORAK\n"
+"      -s   prikaže samo sažetak uporabe za svaku naredbu koja podudara UZORAK\n"
 "\n"
-"    Završi s uspjehom osim ako UZORAK nije pronađen, ili je dana\n"
-"    nevaljana opcija."
+"    Završi s uspjehom osim ako UZORAK nije pronađen, ili je dana nevaljana\n"
+"    opcija."
 
 #: builtins.c:842
 msgid ""
@@ -3502,30 +3502,31 @@ msgstr ""
 "    ispiše samo N posljednjih redaka povijesti.\n"
 "\n"
 "    Opcije:\n"
-"      -c   počisti povijest iz memorije; zaboravi sve izvršene naredbe\n"
-"      -d   POZICIJA  izbriše redak povijesti na POZICIJI\n"
+"      -c   izbriše povijest iz memorije; zaboravi sve izvršene naredbe\n"
+"      -d   POZICIJA  izbriše redak povijesti na toj POZICIJI. Negativna\n"
+"           POZICIJA odbrojava od kraja popisa.\n"
 "\n"
-"      -a   pripoji trenutnu povijest „povijesnoj“ datoteci\n"
-"      -n   pripoji sve nepročitane retke povijesne datoteke\n"
+"      -a   doda trenutnu povijest „povijesnoj“ datoteci\n"
+"      -n   doda sve nepročitane retke povijesne datoteke\n"
 "             trenutnom popisu povijesti\n"
-"      -r   pročita i pripoji povijesnu datoteku\n"
+"      -r   pročita i doda povijesnu datoteku\n"
 "             trenutnom popisu povijesti\n"
 "      -w   trenutnu povijest zapiše u povijesnu datoteku\n"
 "\n"
 "      -p   proširi povijest na svakom ARGUMENTU i prikaže rezultat\n"
 "             bez spremanja u povijesni popis\n"
-"      -s   Pripoji ARGUMENTE popisu povijesti kao pojedinačne stavke \n"
+"      -s   doda ARGUMENTE kao jednu stavku popisu povijesti\n"
 "\n"
-"    Kao povijesna datoteka koristi se DATOTEKA ako je dana; ako nije dana,\n"
-"    koristi se varijabla HISTFILE (ako ima vrijednost), inače se koristi\n"
+"    Ako je dana, DATOTEKA se koristi se kao povijesna datoteka; ako nije dana,\n"
+"    koristi se varijabla HISTFILE (ako ima vrijednost). Inače se koristi\n"
 "    ~/.bash_history.\n"
 "\n"
 "    Ako HISTTIMEFORMAT varijabla postoji i nije nula, njezinu vrijednost\n"
 "    koristi strftime(3) kao format string za ispis vremenskih oznaka\n"
 "    povijesnih stavki; inače, vremenske oznake se ne ispisuju.\n"
 "\n"
-"    Završi s uspjehom osim ako nije dana nevaljana opcija\n"
-"    ili se dogodila greška."
+"    Završi s uspjehom osim ako nije dana nevaljana opcija ili se dogodila\n"
+"    greška."
 
 #: builtins.c:879
 msgid ""
@@ -3563,8 +3564,8 @@ msgstr ""
 "      -s   ograniči izlaz samo na zaustavljene poslove\n"
 "\n"
 "    Ako je navedena opcija '-x', dana NAREDBA će se izvršiti tek nakon\n"
-"    zatvaranja svih poslova navedenih u ARGUMENTIMA (tj. njihov ID procesa\n"
-"    zamijenjen je s ID-om njima nadređenog procesa).\n"
+"    zatvaranja svih navedenih poslova u ARGUMENTIMA (tj. njihov ID procesa je\n"
+"    zamijenjen s ID-om njima nadređenoga procesa).\n"
 "\n"
 "    Završi s uspjehom osim ako je dana nevaljana opcija ili se dogodila greška.\n"
 "    Ako je dana opcija -x, završi sa izlaznim kȏdom NAREDBE."
@@ -3624,9 +3625,9 @@ msgid ""
 msgstr ""
 "Pošalje signal poslu.\n"
 "\n"
-"    Pošalje procesu, identificiranim PID-om ili SPECIFIKACIJOM_POSLA,\n"
-"    signal naveden brojem ili imenom. Ako nije navedeno ni ime ni broj,\n"
-"   „kill” pošalje SIGTERM.\n"
+"    Procesima označenim s PID-om ili sa SPECIFIKACIJOM_POSLA pošalje signal\n"
+"    naveden brojem ili imenom. Ako nije naveden ni broj ni ime, „kill” pošalje\n"
+"    SIGTERM.\n"
 "\n"
 "    Opcije:\n"
 "      -s IME          IME je ime signala koji se šalje\n"
@@ -3634,15 +3635,14 @@ msgstr ""
 "      -l              izlista imena dostupnih signala; ako su dani argumenti\n"
 "                        iza „-l“, to su brojevi signala čija odgovarajuća\n"
 "                        imena treba ispisati\n"
-"      -L              isto kao -l\n"
+"      -L              == -l\n"
 "\n"
 "    „kill“ je ugrađena ljuskina naredba iz dva razloga: dopušta korištenje\n"
 "    ID posla umjesto ID procesa i također dopušta ubiti procese iako\n"
 "    ste dostigli vaše ograničenje za broj procesa koje možete stvoriti;\n"
 "    tj. ne morate pokrenuti novi proces da ubijete prekobrojne procese.\n"
 "\n"
-"    Završi s uspjehom osim ako je dana nevaljana opcija\n"
-"    ili se dogodila greška."
+"    Završi s uspjehom osim ako je dana nevaljana opcija ili se dogodila greška."
 
 #: builtins.c:949
 msgid ""
@@ -3693,22 +3693,22 @@ msgstr ""
 "    obavlja za cijele brojeve fiksne širine bez provjere prelijevanja.\n"
 "    Ipak, dijeljenje s nulom se detektira i prijavi kao greška.\n"
 "\n"
-"    Popis koji slijedi opisuje operatore s jednakom prednošću u\n"
-"    istom retku, a redci su poredani po opadajućoj prednosti.\n"
+"    Popis koji slijedi opisuje operatore s jednakom prednošću u istom retku,\n"
+"    a redci su poredani po opadajućoj prednosti.\n"
 "\n"
 "        var++, var--    post-inkrement, post-dekrement varijable\n"
 "        ++var, --var    pre-inkrement, pre-dekrement varijable\n"
 "        -, +            unarni minus, unarni plus\n"
-"        !, ~            logička i bitna negacija\n"
+"        !, ~            logička i bitwise negacija\n"
 "        **              potenciranje\n"
 "        *, /, %         množenje, dijeljenje, ostatak dijeljenja\n"
 "        +, -            zbrajanje, oduzimanje\n"
-"        <<, >>          pomak za bit ulijevo i udesno\n"
+"        <<, >>          bitwise pomak ulijevo, udesno\n"
 "        <=, >=, <, >    usporedba\n"
 "        ==, !=          jednako, nejednako\n"
-"        &               vrednuje aritmetičke izraze AND\n"
-"        ^               bitni XOR\n"
-"        |               bitni OR\n"
+"        &               bitwise AND\n"
+"        ^               bitwise XOR\n"
+"        |               bitwise OR\n"
 "        &&              logički AND\n"
 "        ||              logički OR\n"
 "\n"
@@ -3794,7 +3794,7 @@ msgstr ""
 "      -p PROMPT  ispiše taj string kao prompt (bez LF) prije početka čitanja\n"
 "      -r         backslash je doslovno kosa crta (nema posebno značenje)\n"
 "      -s         ne odjekuje (echo) ulaz koji dolazi iz terminala\n"
-"      -t BROJ    nakon isteka BROJ SEKUNDI prestane čekati na ulaz i završi\n"
+"      -t BROJ    nakon isteka BROJA sekundi  prestane čekati na ulaz i završi\n"
 "                   s kȏdom većim od 128; zadano, broj sekundi čekanja je\n"
 "                   vrijednost varijable TMOUT; BROJ može biti i realni broj;\n"
 "                   Ako je BROJ = 0, „read“ završi odmah bez da išta čita, a\n"
@@ -3805,8 +3805,7 @@ msgstr ""
 "\n"
 "      Završi s uspjehom osim ako ne naiđe na konac datoteke (EOF) ili je\n"
 "      isteklo vrijeme čekanja ili se dogodila greška pri dodjeli ili je\n"
-"      naveden nevaljani deskriptor datoteke\n"
-"      kao argument opciji „-u“."
+"      naveden nevaljani deskriptor datoteke kao argument opciji „-u“."
 
 #: builtins.c:1041
 msgid ""
@@ -3819,7 +3818,7 @@ msgid ""
 "    Exit Status:\n"
 "    Returns N, or failure if the shell is not executing a function or script."
 msgstr ""
-"Povrat iz funkcije ljuske.\n"
+"Vračanje iz funkcije ljuske.\n"
 "\n"
 "    Učini da funkcija ili pokrenuta skripta završi sa izlaznom vrijednošću\n"
 "    specificiranom s N. Ako N nije dan, završi s kȏdom zadnje naredbe\n"
@@ -3930,7 +3929,7 @@ msgstr ""
 "            (a ne samo one argumente koji prethode imenu naredbe)\n"
 "      -m  upravljanje poslovima je omogućeno (zadano)\n"
 "      -n  pročita, ali ne izvrši naredbe\n"
-"      -o  IME_OPCIJE  omogući tu opciju (v. niže dugačke nazive IMENA_OPCIJA)\n"
+"      -o  IME_OPCIJE  omogući tu opciju (v. niže dugačke nazive za IME_OPCIJE)\n"
 "      -P  ne razriješi simboličke veze pri izvršavanju naredbi poput „cd“\n"
 "            koje promjene trenutni direktorij\n"
 "      -p  uključi privilegirani način: datoteke BASH_ENV i ENV se zanemare,\n"
@@ -3954,34 +3953,34 @@ msgstr ""
 "    pozicijski i dodijeljeni su u $1, $2, .. $N.\n"
 "\n"
 "    Dugački nazivi za IME_OPCIJE koji se koriste s opcijom -o (ili +o)\n"
-"      allexport    isto kao -a\n"
-"      braceexpand  isto kao -B (zamjena vitičastih zagrada)\n"
+"      allexport    == -a\n"
+"      braceexpand  == -B (zamjena vitičastih zagrada)\n"
 "      emacs        za uređivanje redaka koristi sučelje u „emacs“ stilu\n"
-"      errexit      isto kao -e\n"
-"      errtrace     isto kao -E\n"
-"      functrace    isto kao -T\n"
-"      hashall      isto kao -h\n"
-"      histexpand   isto kao -H\n"
+"      errexit      == -e\n"
+"      errtrace     == -E\n"
+"      functrace    == -T\n"
+"      hashall      == -h\n"
+"      histexpand   == -H\n"
 "      history      omogući naredbu „history“\n"
 "      ignoreeof    ignorira Ctrl-D; ne završi (ne iziđe iz) ljusku na EOF\n"
 "      interactive-comments  dopusti komentiranje u interaktivnim naredbama\n"
-"      keyword      isto kao -k\n"
-"      monitor      isto kao -m\n"
-"      noclobber    isto kao -C\n"
-"      noexec       isto kao -n\n"
-"      noglob       isto kao -f\n"
-"      nolog        (prepoznata, ali se ignorira)\n"
-"      notify       isto kao -b\n"
-"      nounset      isto kao -u\n"
-"      onecmd       isto kao -t\n"
-"      physical     isto kao -P\n"
+"      keyword      == -k\n"
+"      monitor      == -m\n"
+"      noclobber    == -C\n"
+"      noexec       == -n\n"
+"      noglob       == -f\n"
+"      nolog        (prepoznata, ali je zanemarena)\n"
+"      notify       == -b\n"
+"      nounset      == -u\n"
+"      onecmd       == -t\n"
+"      physical     == -P\n"
 "      pipefail     cjevovod vrati vrijednost izlaznog koda zadnje neuspješne\n"
 "                     naredbe ili 0 ako su svi poslovi uspješno završeni\n"
 "      posix        striktno poštuje POSIX standard\n"
-"      privileged   isto kao -p\n"
-"      verbose      isto kao -v\n"
+"      privileged   == -p\n"
+"      verbose      == -v\n"
 "      vi           za uređivanje redaka koristi sučelje u „vi“ stilu\n"
-"      xtrace       isto kao -x\n"
+"      xtrace       == -x\n"
 "\n"
 "    Završi s uspjehom osim ako je dana nevaljana opcija."
 
@@ -4019,8 +4018,8 @@ msgstr ""
 "    ne uspije, onda pokuša ukloniti funkciju. Neke varijable nije moguće\n"
 "    ukloniti; pogledajte „readonly.\n"
 "\n"
-"    Završi s uspjehom osim ako je dana nevaljana opcija\n"
-"    ili IME je „samo-za-čitanje“."
+"    Završi s uspjehom osim ako je dana nevaljana opcija ili IME je\n"
+"    „samo-za-čitanje“. (bez navodnika)"
 
 #: builtins.c:1161
 msgid ""
@@ -4088,7 +4087,7 @@ msgstr ""
 "      -p  prikaže popis svih nepromjenjivih varijabli ili funkcija\n"
 "            ovisno o opciji „-f“ (je li ili nije dana).\n"
 "\n"
-"    Argument „--“ onemogući daljnje procesiranje opcija.\n"
+"    Argument „--“ onemogući daljnje obrađivanje opcija.\n"
 "\n"
 "    Završi s uspjehom osim ako je dana nevaljana opcija ili je IME nevaljano."
 
@@ -4557,9 +4556,9 @@ msgid ""
 "    Exit Status:\n"
 "    Returns success unless MODE is invalid or an invalid option is given."
 msgstr ""
-"Prikaže ili postavi masku prilikom kreiranje datoteke.\n"
+"Prikaže ili postavi masku prilikom stvaranja datoteke.\n"
 "\n"
-"    Postavi masku datoteke koju kreira korisnik na MODE.\n"
+"    Postavi masku datoteke koju stvori korisnik na MODE.\n"
 "    Ako MODE nije naveden, ispiše trenutnu vrijednost maske.\n"
 "\n"
 "    Ako MODE počinje sa znamenkom, interpretira se kao oktalni broj;\n"
@@ -4652,9 +4651,9 @@ msgstr ""
 "Izvrši naredbe za svakoga člana u popisu.\n"
 "\n"
 "    Petlja „for“ izvrši sekvenciju naredbi za svakoga člana u popisu stavki.\n"
-"    Ako nema operanda „in RIJEČI ...., podrazumijeva se operand\n"
+"    Ako nema operanda „in RIJEČIMA...; podrazumijeva se operand\n"
 "    „in \"$@\"“. Svakom elementu u RIJEČIMA, IME se postavi na taj element\n"
-"    i izvrše se NAREDBE.\n"
+"    i NAREDBE se izvrše.\n"
 "\n"
 "    Završi s kȏdom zadnje izvršene naredbe."
 
@@ -4712,9 +4711,9 @@ msgstr ""
 "    Nakon izbornika prikaže se PS3 prompt i redak se čita iz standardnoga\n"
 "    ulaza; ako se redak sastoji od broja koji odgovara jednoj od prikazanih\n"
 "    riječi, onda varijabla IME dobije vrijednost te riječi; ako je redak\n"
-"    prazan, RIJEČI i prompt se ponovno prikažu; ako se pročita EOF „select“\n"
-"    naredba završi s poslom. Bilo koja druga vrijednost koja se pročita učini\n"
-"    da se IME isprazni (nulira). Pročitani redak spremi se u varijablu REPLY.\n"
+"    prazan, RIJEČI i prompt se ponovno prikažu; ako se pročita EOF (Ctrl-D)\n"
+"    „select“ naredba završi. Bilo koja druga pročitana vrijednost učini da se\n"
+"    IME isprazni (nulira). Pročitani redak se spremi u varijablu REPLY.\n"
 "    NAREDBE se izvršavaju nakon svakog izbora, tako dugo dok „break“ naredba\n"
 "    ne prekine posao.\n"
 "\n"
@@ -4784,10 +4783,10 @@ msgstr ""
 "    Izvrši naredbe iza „if“; ako to završi s kȏdom 0, izvrši naredbe\n"
 "    iza prvog „then“; inače, izvrši naredbe iza sljedećeg „elif“\n"
 "    (ako postoji) ili „else“ (ako postoji). Ako „elif“ završi s kȏdom\n"
-"    nula, izvrši naredbe iza odgovarajućeg „then“. Ako više nema „elif“,\n"
+"    nula, izvrši naredbe iza odgovarajućeg „then“. Ako nema više „elif“,\n"
 "    ili „else“ ili nakon izvršenih naredbi iza „then“, „if“ naredba završi.\n"
 "\n"
-"    „if“ završi s kȏdom zadnjeg izvršenoga zadatka."
+"    „if“ završi s kȏdom zadnje izvršene naredbe."
 
 #: builtins.c:1647
 msgid ""
@@ -4801,8 +4800,8 @@ msgid ""
 msgstr ""
 "Izvršava naredbe tako dugo dok je test uspješan.\n"
 "\n"
-"    Izvršava sukcesivne NAREDBE tako dugo dok zadnja naredba u\n"
-"    „while“ NAREDBAMA završava s kȏdom 0.\n"
+"    Izvršava sukcesivne NAREDBE tako dugo dok zadnja naredba u „while“\n"
+"    NAREDBAMA završava s kȏdom 0.\n"
 "\n"
 "    Završi s kȏdom zadnje izvršene naredbe."
 
@@ -4835,7 +4834,7 @@ msgid ""
 "    Exit Status:\n"
 "    The coproc command returns an exit status of 0."
 msgstr ""
-"Kreira coprocess (suproces) s imenom IME.\n"
+"Stvori koproces nazvan IME.\n"
 "\n"
 "    Izvrši NAREDBU asinkrono, sa standardnim izlazom i standardnim ulazom\n"
 "    naredbe spojene preko cijevi na deskriptore datoteke dodijeljene\n"
@@ -4858,7 +4857,7 @@ msgid ""
 msgstr ""
 "Definira funkciju ljuske.\n"
 "\n"
-"    Kreira funkciju ljuske nazvanu IME. Kad se pokrene kao jednostavna\n"
+"    Stvori funkciju ljuske nazvanu IME. Kad se pokrene kao jednostavna\n"
 "    naredba, IME izvrši NAREDBE unutar konteksta pozivne ljuske.\n"
 "    Kad se IME pozove, argumenti se proslijede funkciji kao $1...$N,\n"
 "    a ime funkcije je $FUNCNAME.\n"
@@ -5102,7 +5101,7 @@ msgstr ""
 "\n"
 "    Doda direktorij na vrh stȏga direktorija ili zarotira stȏg tako da\n"
 "    učini novi vrh stȏga trenutnim radnim direktorijem. Bez argumenata\n"
-"    razmijeni pozicije dvaju direktorija na vrhu stȏga.\n"
+"    razmijeni pozicije dvama direktorijima na vrhu stȏga.\n"
 "\n"
 "    Opcije:\n"
 "      -n   izostavi uobičajenu promjenu direktorija kad dodaje\n"
@@ -5118,8 +5117,8 @@ msgstr ""
 "\n"
 "      Naredba „dirs“ prikaže trenutni sadržaj stȏga direktorija.\n"
 "\n"
-"    Završi s uspjehom osim ako je dana nevaljana opcija\n"
-"    ili nije uspjela promjena direktorija."
+"    Završi s uspjehom osim ako je dana nevaljana opcija ili promjena\n"
+"    direktorija nije uspjela"
 
 #: builtins.c:1855
 msgid ""
@@ -5149,8 +5148,9 @@ msgid ""
 msgstr ""
 "Ukloni direktorije iz stȏga.\n"
 "\n"
-"    Ukloni direktorije iz stȏga direktorija. Bez argumenata, ukloni\n"
-"    direktorij na vrhu stȏga i premjesti se u novi najviši direktorij.\n"
+"    Ukloni zapise iz stȏga direktorija. Bez argumenata, ukloni direktorij na\n"
+"    vrhu stȏga i učini da je trenutni radni direktorij jednak novom direktoriju\n"
+"    na vrhu stȏga.\n"
 "\n"
 "    Opcije:\n"
 "      -n   izostavi uobičajenu promjenu direktorija kad uklanja\n"
@@ -5166,8 +5166,8 @@ msgstr ""
 "\n"
 "    Naredba „dirs“ prikaže trenutni sadržaj stȏga direktorija.\n"
 "\n"
-"    Završi s uspjehom osim ako je dana nevaljana opcija\n"
-"    ili nije uspjela promjena direktorija."
+"    Završi s uspjehom osim ako je dana nevaljana opcija ili promjena\n"
+"    direktorija nije uspjela."
 
 #: builtins.c:1885
 msgid ""
@@ -5299,7 +5299,7 @@ msgstr ""
 "    koji se pretvore i kopiraju na izlaz; specifikacije formata od kojih\n"
 "    svaka uzrokuje ispisivanje sljedećeg sukcesivnog argumenta.\n"
 "\n"
-"    Pored standardnih simbola \"diouxXfeEgGcs\"za format opisanih u printf(1),\n"
+"    Pored standardnih simbola „diouxXfeEgGcs” za format opisanih u printf(1),\n"
 "    „printf” dodatno interpretira:\n"
 "      %b       proširi backslash (\\) kontrolne znakove u odgovarajuće\n"
 "               argumente\n"
@@ -5379,8 +5379,8 @@ msgstr ""
 "Prikaže moguća kompletiranja ovisno o opcijama.\n"
 "\n"
 "    „compgen“ je namijenjen za upotrebu unutar funkcije koja generira\n"
-"    moguća kompletiranja. Ako je dana neobvezna opcija RIJEČ, generira\n"
-"    samo moguća kompletiranja podudarna s opcijom RIJEČ.\n"
+"    moguća kompletiranja. Ako je dana neobvezna opcija RIJEČ (word)\n"
+"    generira odgovarajuća kompletiranja podudarna s RIJEČI.\n"
 "\n"
 "    Završi s uspjehom osim ako je dana nevaljana opcija ili se dogodila greška."
 
@@ -5412,18 +5412,18 @@ msgid ""
 "    Returns success unless an invalid option is supplied or NAME does not\n"
 "    have a completion specification defined."
 msgstr ""
-"Izmjeni ili pokaže opcije za kompletiranje.\n"
+"Promijeni ili pokaže opcije za kompletiranje.\n"
 "\n"
-"    Izmijeni opcije kompletiranja za svako IME u skladu s opcijama,\n"
+"    Promijeni opcije kompletiranja za svako IME u skladu s opcijama,\n"
 "    ili za kompletiranje koje se trenutno vrši ako nisu navedena IMENA.\n"
-"    Ako nema opcija, ispišu se opcije kompletiranja za svako IME ili\n"
-"    za trenutno kompletiranje.\n"
+"    Ako nema opcija, ispiše opcije kompletiranja za svako IME ili za\n"
+"    trenutno kompletiranje.\n"
 "\n"
 "    Opcije:\n"
-"      -o OPCIJA   ovu OPCIJU kompletiranja postavi za svako IME\n"
-"      -D          promijeni opcije za kompletiranje „zadanih“ naredba\n"
-"      -E          promijeni opcije za kompletiranje „praznih“ naredba\n"
-"      -I          promijeni opcije za kompletiranje za početnu riječ\n"
+"      -o OPCIJA   omogući ovu OPCIJU kompletiranja za svako IME\n"
+"      -D          promijeni opcije za „zadano” kompletiranje\n"
+"      -E          promijeni opcije za kompletiranje „prazne“ naredbe\n"
+"      -I          promijeni opcije za kompletiranje na početnu riječ\n"
 "\n"
 "    „+“ umjesto „-“ isključi odgovarajuću opciju.\n"
 "\n"
@@ -5433,8 +5433,8 @@ msgstr ""
 "    pozvati „compopt“; time se onda promjene opcije za taj generator koji\n"
 "    trenutno izvršava kompletiranja.\n"
 "\n"
-"    Završi s uspjehom osim ako nije dana nevaljana opcija\n"
-"    ili nije definirana specifikacija za kompletiranje IMENA."
+"    Završi s uspjehom osim ako nije dana nevaljana opcija ili nije definirana\n"
+"    specifikacija za kompletiranje IMENA."
 
 #: builtins.c:2047
 msgid ""
@@ -5472,13 +5472,13 @@ msgid ""
 msgstr ""
 "Pročitane retke iz standardnoga ulaza upiše u varijablu indeksirano polje.\n"
 "\n"
-"    Pročitane retke iz standardnog ulaza (ili, ako je navedena -u opcija iz\n"
+"    Pročitane retke iz standardnog ulaza (ili ako je navedena opcija -u, iz\n"
 "    deskriptora datoteke FD) upiše u indeksiranu varijablu POLJE. Ako argument\n"
 "    POLJE nije dan, za POLJE se (zadano) koristi varijabla MAPFILE\n"
 "\n"
 "    Opcije:\n"
 "      -d MEĐA      prvi znak u MEĐI (umjesto LF) je znak za kraj retka\n"
-"      -n BROJ      kopira ne više od BROJ redaka (0 znači sve retke)\n"
+"      -n KOLIČINA  kopira ne više od KOLIČINE redaka (0 kopira sve retke)\n"
 "      -O POČETAK   upisivanje u POLJE započinje od indeksa POČETAK (zadano 0)\n"
 "      -s BROJ      preskoči (izostavi) prvih BROJ redaka\n"
 "      -t           ukloni zaostalu MEĐU (zadano LF) iz svakog učitanog retka\n"
@@ -5506,7 +5506,7 @@ msgid ""
 "    \n"
 "    A synonym for `mapfile'."
 msgstr ""
-"Učita retke iz datoteke u varijablu vrste indeksirano polje.\n"
+"Učita retke iz datoteke u varijablu indeksirano polje.\n"
 "\n"
 "    Sinonim za „mapfile“."
 

po/pt_BR.po

 # Brazilian Portuguese translation for bash
-# Copyright (C) 2019 Free Software Foundation, Inc.
+# Copyright (C) 2021 Free Software Foundation, Inc.
 # This file is distributed under the same license as the bash package.
 # Halley Pacheco de Oliveira <halleypo@ig.com.br>, 2002.
-# Rafael Fontenelle <rafaelff@gnome.org>, 2015, 2016, 2018, 2019.
+# Rafael Fontenelle <rafaelff@gnome.org>, 2015-2021.
+#
 msgid ""
 msgstr ""
-"Project-Id-Version: bash 5.0\n"
+"Project-Id-Version: bash 5.1\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2020-11-28 12:51-0500\n"
-"PO-Revision-Date: 2019-01-09 15:13-0200\n"
+"PO-Revision-Date: 2021-01-07 10:37-0300\n"
 "Last-Translator: Rafael Fontenelle <rafaelff@gnome.org>\n"
-"Language-Team: Brazilian Portuguese <ldpbr-translation@lists.sourceforge."
-"net>\n"
+"Language-Team: Brazilian Portuguese <ldpbr-translation@lists.sourceforge.net>\n"
 "Language: pt_BR\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=2; plural=(n > 1);\n"
-"X-Generator: Virtaal 1.0.0-beta1\n"
+"Plural-Forms: nplurals=2; plural=(n > 1)\n"
+"X-Generator: Gtranslator 3.38.0\n"
 "X-Bugs: Report translation errors to the Language-Team address.\n"
 
 #: arrayfunc.c:66
@@ -57,8 +57,7 @@ msgstr "%s: impossível criar: %s"
 
 #: bashline.c:4310
 msgid "bash_execute_unix_command: cannot find keymap for command"
-msgstr ""
-"bash_execute_unix_command: impossível localizar mapa de teclas para comando"
+msgstr "bash_execute_unix_command: impossível localizar mapa de teclas para comando"
 
 #: bashline.c:4459
 #, c-format
@@ -76,9 +75,9 @@ msgid "%s: missing colon separator"
 msgstr "%s faltando separador dois-pontos"
 
 #: bashline.c:4555
-#, fuzzy, c-format
+#, c-format
 msgid "`%s': cannot unbind in command keymap"
-msgstr "`%s': impossível desassociar (unbind)"
+msgstr "`%s': não foi desassociar no comando keymap"
 
 #: braces.c:327
 #, c-format
@@ -144,7 +143,6 @@ msgstr "significativo apenas em um loop de `for', `while' ou `until'"
 
 # help caller
 #: builtins/caller.def:136
-#, fuzzy
 msgid ""
 "Returns the context of the current subroutine call.\n"
 "    \n"
@@ -158,16 +156,11 @@ msgstr ""
 "Retorna o contexto da chamada de sub-rotina atual.\n"
 "    \n"
 "    Sem EXPR, retorna \"$linha $arquivo\".  Com EXPR, retorna\n"
-"    \"$linha $sub-rotina $arquivo\"; essa informação extra pode ser usada "
-"para\n"
+"    \"$linha $sub-rotina $arquivo\"; essa informação extra pode ser usada para\n"
 "    fornecer um rastro da pilha.\n"
 "    \n"
 "    O valor de EXPR indica quantos quadros de chamada deve voltar antes do\n"
-"    atual; o quadro do topo é o quadro 0.\n"
-"    \n"
-"    Status de saída:\n"
-"    Retorna 0, a menos que o shell não esteja executando uma função de\n"
-"    shell ou EXPR seja inválida."
+"    atual; o quadro do topo é o quadro 0."
 
 #: builtins/cd.def:327
 msgid "HOME not set"
@@ -250,9 +243,7 @@ msgstr "%s: especificação de sinal inválida"
 #: builtins/common.c:259
 #, c-format
 msgid "`%s': not a pid or valid job spec"
-msgstr ""
-"`%s': não é um identificador de processo (pid) nem é uma especificação de "
-"trabalho válida"
+msgstr "`%s': não é um identificador de processo (pid) nem é uma especificação de trabalho válida"
 
 #: builtins/common.c:266 error.c:510
 #, c-format
@@ -427,9 +418,9 @@ msgid "cannot find %s in shared object %s: %s"
 msgstr "impossível localizar %s no objeto compartilhado %s: %s"
 
 #: builtins/enable.def:388
-#, fuzzy, c-format
+#, c-format
 msgid "%s: dynamic builtin already loaded"
-msgstr "%s: não foi carregado dinamicamente"
+msgstr "%s: comando dinâmico já foi carregado"
 
 #: builtins/enable.def:392
 #, c-format
@@ -548,14 +539,13 @@ msgid ""
 "'\n"
 "\n"
 msgstr ""
+"'\n"
+"\n"
 
 #: builtins/help.def:185
 #, c-format
-msgid ""
-"no help topics match `%s'.  Try `help help' or `man -k %s' or `info %s'."
-msgstr ""
-"nenhum tópico de ajuda corresponde a `%s'.  Tente `help help' ou `man -k %s' "
-"ou `info %s'."
+msgid "no help topics match `%s'.  Try `help help' or `man -k %s' or `info %s'."
+msgstr "nenhum tópico de ajuda corresponde a `%s'.  Tente `help help' ou `man -k %s' ou `info %s'."
 
 #: builtins/help.def:224
 #, c-format
@@ -573,12 +563,10 @@ msgid ""
 "A star (*) next to a name means that the command is disabled.\n"
 "\n"
 msgstr ""
-"Esses comandos shell são definidos internamente. Digite `help' para ver "
-"essa\n"
+"Esses comandos shell são definidos internamente. Digite `help' para ver essa\n"
 "lista. Digite `help NOME' para descobrir mais sobre a função `NOME'.\n"
 "Use `info bash' para descobrir mais sobre o shell em geral.\n"
-"Use `man -k' ou `info' para descobrir mais sobre comandos que não estão "
-"nesta\n"
+"Use `man -k' ou `info' para descobrir mais sobre comandos que não estão nesta\n"
 "lista.\n"
 "\n"
 "Um asterisco (*) próximo ao nome significa que o comando está desabilitado.\n"
@@ -733,12 +721,10 @@ msgid ""
 "    \twith its position in the stack\n"
 "    \n"
 "    Arguments:\n"
-"      +N\tDisplays the Nth entry counting from the left of the list shown "
-"by\n"
+"      +N\tDisplays the Nth entry counting from the left of the list shown by\n"
 "    \tdirs when invoked without options, starting with zero.\n"
 "    \n"
-"      -N\tDisplays the Nth entry counting from the right of the list shown "
-"by\n"
+"      -N\tDisplays the Nth entry counting from the right of the list shown by\n"
 "\tdirs when invoked without options, starting with zero."
 msgstr ""
 "Exibe a lista de diretórios atualmente memorizados. Diretórios são\n"
@@ -857,14 +843,11 @@ msgstr "erro de leitura: %d: %s"
 
 #: builtins/return.def:68
 msgid "can only `return' from a function or sourced script"
-msgstr ""
-"possível retornar (`return') apenas de uma função ou script carregado (com "
-"`source')"
+msgstr "possível retornar (`return') apenas de uma função ou script carregado (com `source')"
 
 #: builtins/set.def:869
 msgid "cannot simultaneously unset a function and a variable"
-msgstr ""
-"impossível simultaneamente remover definição de uma função e uma variável"
+msgstr "impossível simultaneamente remover definição de uma função e uma variável"
 
 #: builtins/set.def:966
 #, c-format
@@ -887,8 +870,7 @@ msgstr "número de shift"
 
 #: builtins/shopt.def:310
 msgid "cannot set and unset shell options simultaneously"
-msgstr ""
-"impossível simultaneamente definir e remover definição de opções do shell"
+msgstr "impossível simultaneamente definir e remover definição de opções do shell"
 
 #: builtins/shopt.def:428
 #, c-format
@@ -1028,9 +1010,7 @@ msgstr "%s: variável não associada"
 
 #: eval.c:242
 msgid "\atimed out waiting for input: auto-logout\n"
-msgstr ""
-"\atempo limite de espera excedido aguardando entrada: fim automático da "
-"sessão\n"
+msgstr "\atempo limite de espera excedido aguardando entrada: fim automático da sessão\n"
 
 #: execute_cmd.c:537
 #, c-format
@@ -1163,9 +1143,8 @@ msgid "invalid arithmetic base"
 msgstr "base aritmética inválida"
 
 #: expr.c:1582
-#, fuzzy
 msgid "invalid integer constant"
-msgstr "%s: número de linhas inválido"
+msgstr "contante inteira inválida"
 
 #: expr.c:1598
 msgid "value too great for base"
@@ -1183,21 +1162,17 @@ msgstr "getcwd: impossível acessar os diretórios pais (anteriores)"
 #: input.c:99 subst.c:6069
 #, c-format
 msgid "cannot reset nodelay mode for fd %d"
-msgstr ""
-"impossível redefinir modo `nodelay' para o descritor de arquivo (fd) %d"
+msgstr "impossível redefinir modo `nodelay' para o descritor de arquivo (fd) %d"
 
 #: input.c:266
 #, c-format
 msgid "cannot allocate new file descriptor for bash input from fd %d"
-msgstr ""
-"impossível alocar novo descritor de arquivo (fd) para a entrada do `bash' a "
-"partir do fd %d"
+msgstr "impossível alocar novo descritor de arquivo (fd) para a entrada do `bash' a partir do fd %d"
 
 #: input.c:274
 #, c-format
 msgid "save_bash_input: buffer already exists for new fd %d"
-msgstr ""
-"save_bash_input: buffer já existe para o novo descritor de arquivo (fd) %d"
+msgstr "save_bash_input: buffer já existe para o novo descritor de arquivo (fd) %d"
 
 #: jobs.c:543
 msgid "start_pipeline: pgrp pipe"
@@ -1206,19 +1181,17 @@ msgstr "start_pipeline: `pipe' de pgrp"
 #: jobs.c:906
 #, c-format
 msgid "bgp_delete: LOOP: psi (%d) == storage[psi].bucket_next"
-msgstr ""
+msgstr "bgp_delete: LOOP: psi (%d) == storage[psi].bucket_next"
 
 #: jobs.c:959
 #, c-format
 msgid "bgp_search: LOOP: psi (%d) == storage[psi].bucket_next"
-msgstr ""
+msgstr "bgp_search: LOOP: psi (%d) == storage[psi].bucket_next"
 
 #: jobs.c:1283
 #, c-format
 msgid "forked pid %d appears in running job %d"
-msgstr ""
-"identificador de processo (pid) %d bifurcado (fork) aparece no trabalho em "
-"execução %d"
+msgstr "identificador de processo (pid) %d bifurcado (fork) aparece no trabalho em execução %d"
 
 #: jobs.c:1402
 #, c-format
@@ -1302,9 +1275,9 @@ msgid "wait_for_job: job %d is stopped"
 msgstr "wait_for_job: trabalho %d está parado"
 
 #: jobs.c:3564
-#, fuzzy, c-format
+#, c-format
 msgid "%s: no current jobs"
-msgstr "%s: trabalho não existe"
+msgstr "%s: nenhum trabalho atual"
 
 #: jobs.c:3571
 #, c-format
@@ -1395,9 +1368,8 @@ msgid "free: underflow detected; mh_nbytes out of range"
 msgstr "free: esvaziamento de pilha detectado; mh_nbytes fora do limite"
 
 #: lib/malloc/malloc.c:1001
-#, fuzzy
 msgid "free: underflow detected; magic8 corrupted"
-msgstr "free: esvaziamento de pilha detectado; mh_nbytes fora do limite"
+msgstr "free: esvaziamento de pilha detectado; magic8 corrompido"
 
 #: lib/malloc/malloc.c:1009
 msgid "free: start and end chunk sizes differ"
@@ -1412,9 +1384,8 @@ msgid "realloc: underflow detected; mh_nbytes out of range"
 msgstr "realloc: esvaziamento de pilha detectado; mh_nbytes fora do limite"
 
 #: lib/malloc/malloc.c:1141
-#, fuzzy
 msgid "realloc: underflow detected; magic8 corrupted"
-msgstr "realloc: esvaziamento de pilha detectado; mh_nbytes fora do limite"
+msgstr "realloc: esvaziamento de pilha detectado; magic8 corrompido"
 
 #: lib/malloc/malloc.c:1150
 msgid "realloc: start and end chunk sizes differ"
@@ -1512,8 +1483,7 @@ msgstr "make_here_document: tipo da instrução incorreto %d"
 #: make_cmd.c:657
 #, c-format
 msgid "here-document at line %d delimited by end-of-file (wanted `%s')"
-msgstr ""
-"here-document na linha %d delimitado pelo fim do arquivo (desejava `%s')"
+msgstr "here-document na linha %d delimitado pelo fim do arquivo (desejava `%s')"
 
 #: make_cmd.c:756
 #, c-format
@@ -1522,11 +1492,8 @@ msgstr "make_redirection: instrução de redirecionamento `%d' fora do limite"
 
 #: parse.y:2393
 #, c-format
-msgid ""
-"shell_getc: shell_input_line_size (%zu) exceeds SIZE_MAX (%lu): line "
-"truncated"
-msgstr ""
-"shell_getc: shell_input_line_size (%zu) excede SIZE_MAX (%lu): linha truncada"
+msgid "shell_getc: shell_input_line_size (%zu) exceeds SIZE_MAX (%lu): line truncated"
+msgstr "shell_getc: shell_input_line_size (%zu) excede SIZE_MAX (%lu): linha truncada"
 
 #: parse.y:2826
 msgid "maximum here-document count exceeded"
@@ -1779,15 +1746,12 @@ msgstr "\t-%s ou -o opção\n"
 #: shell.c:2068
 #, c-format
 msgid "Type `%s -c \"help set\"' for more information about shell options.\n"
-msgstr ""
-"Digite `%s -c \"help set\"' para mais informações sobre as opções do shell.\n"
+msgstr "Digite `%s -c \"help set\"' para mais informações sobre as opções do shell.\n"
 
 #: shell.c:2069
 #, c-format
 msgid "Type `%s -c help' for more information about shell builtin commands.\n"
-msgstr ""
-"Digite `%s -c help' para mais informações sobre os comandos internos do "
-"shell.\n"
+msgstr "Digite `%s -c help' para mais informações sobre os comandos internos do shell.\n"
 
 #: shell.c:2070
 #, c-format
@@ -1963,7 +1927,7 @@ msgstr "modo monitor HFT rescindido"
 
 #: siglist.c:210
 msgid "HFT sound sequence has completed"
-msgstr "a seqüência de som HFT foi completada"
+msgstr "a sequência de som HFT foi completada"
 
 #: siglist.c:214
 msgid "Information request"
@@ -2021,9 +1985,7 @@ msgstr "impossível criar um processo filho para substituição do comando"
 
 #: subst.c:6423
 msgid "command_substitute: cannot duplicate pipe as fd 1"
-msgstr ""
-"command_substitute: impossível duplicar o `pipe' como descritor de arquivo "
-"(fd) 1"
+msgstr "command_substitute: impossível duplicar o `pipe' como descritor de arquivo (fd) 1"
 
 #: subst.c:6883 subst.c:9952
 #, c-format
@@ -2066,11 +2028,8 @@ msgid "$%s: cannot assign in this way"
 msgstr "$%s: impossível atribuir desta maneira"
 
 #: subst.c:9814
-msgid ""
-"future versions of the shell will force evaluation as an arithmetic "
-"substitution"
-msgstr ""
-"versões futuras do shell vão forçar avaliação como um substituto aritmético"
+msgid "future versions of the shell will force evaluation as an arithmetic substitution"
+msgstr "versões futuras do shell vão forçar avaliação como um substituto aritmético"
 
 #: subst.c:10367
 #, c-format
@@ -2115,9 +2074,9 @@ msgid "missing `]'"
 msgstr "faltando `]'"
 
 #: test.c:899
-#, fuzzy, c-format
+#, c-format
 msgid "syntax error: `%s' unexpected"
-msgstr "erro de sintaxe: `;' inesperado"
+msgstr "erro de sintaxe: `%s' inesperado"
 
 #: trap.c:220
 msgid "invalid signal number"
@@ -2126,8 +2085,7 @@ msgstr "número de sinal inválido"
 #: trap.c:325
 #, c-format
 msgid "trap handler: maximum trap handler level exceeded (%d)"
-msgstr ""
-"manipulador de trap: excedido o nível máximo de manipulador de captura (%d)"
+msgstr "manipulador de trap: excedido o nível máximo de manipulador de captura (%d)"
 
 #: trap.c:414
 #, c-format
@@ -2136,11 +2094,8 @@ msgstr "run_pending_traps: valor incorreto em trap_list[%d]: %p"
 
 #: trap.c:418
 #, c-format
-msgid ""
-"run_pending_traps: signal handler is SIG_DFL, resending %d (%s) to myself"
-msgstr ""
-"run_pending_traps: manipulador de sinal é SIG_DFL, enviando novamente %d "
-"(%s) para mim mesmo"
+msgid "run_pending_traps: signal handler is SIG_DFL, resending %d (%s) to myself"
+msgstr "run_pending_traps: manipulador de sinal é SIG_DFL, enviando novamente %d (%s) para mim mesmo"
 
 #: trap.c:487
 #, c-format
@@ -2202,8 +2157,7 @@ msgstr "pop_var_context: nenhum contexto em no global_variables"
 
 #: variables.c:5424
 msgid "pop_scope: head of shell_variables not a temporary environment scope"
-msgstr ""
-"pop_scope: cabeça de shell_variables não é um escopo de ambiente temporário"
+msgstr "pop_scope: cabeça de shell_variables não é um escopo de ambiente temporário"
 
 #: variables.c:6387
 #, c-format
@@ -2221,17 +2175,12 @@ msgid "%s: %s: compatibility value out of range"
 msgstr "%s: %s: valor de compatibilidade fora dos limites"
 
 #: version.c:46 version2.c:46
-#, fuzzy
 msgid "Copyright (C) 2020 Free Software Foundation, Inc."
-msgstr "Copyright (C) 2018 Free Software Foundation, Inc."
+msgstr "Copyright (C) 2020 Free Software Foundation, Inc."
 
 #: version.c:47 version2.c:47
-msgid ""
-"License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl."
-"html>\n"
-msgstr ""
-"Licença GPLv3+: GNU GPL versão 3 ou posterior <http://gnu.org/licenses/gpl."
-"html>.\n"
+msgid "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n"
+msgstr "Licença GPLv3+: GNU GPL versão 3 ou posterior <http://gnu.org/licenses/gpl.html>.\n"
 
 #: version.c:86 version2.c:86
 #, c-format
@@ -2268,20 +2217,15 @@ msgstr "%s: %s:%d: impossível alocar %lu bytes"
 
 #: builtins.c:45
 msgid "alias [-p] [name[=value] ... ]"
-msgstr "alias [-p] [NOME[=VALOR] ... ]"
+msgstr "alias [-p] [nome[=valor] ... ]"
 
 #: builtins.c:49
 msgid "unalias [-a] name [name ...]"
-msgstr "unalias [-a] NOME [NOME ...]"
+msgstr "unalias [-a] nome [nome ...]"
 
 #: builtins.c:53
-msgid ""
-"bind [-lpsvPSVX] [-m keymap] [-f filename] [-q name] [-u name] [-r keyseq] [-"
-"x keyseq:shell-command] [keyseq:readline-function or readline-command]"
-msgstr ""
-"bind [-lpsvPSVX] [-m MAPA-TECLAS] [-f ARQUIVO] [-q NOME] [-u NOME] [-r SEQ-"
-"TECLAS]  [-x SEQ-TECLAS:COMANDO-SHELL] [SEQ-TECLAS:FUNÇÃO-DE-LINHA ou "
-"COMANDO-DE-LINHA]"
+msgid "bind [-lpsvPSVX] [-m keymap] [-f filename] [-q name] [-u name] [-r keyseq] [-x keyseq:shell-command] [keyseq:readline-function or readline-command]"
+msgstr "bind [-lpsvPSVX] [-m mapa-teclas] [-f arquivo] [-q nome] [-u nome] [-r seq-teclas]  [-x seq-teclas:comando-shell] [seq-teclas:função-de-readline ou comando-readline]"
 
 #: builtins.c:56
 msgid "break [n]"
@@ -2312,14 +2256,12 @@ msgid "command [-pVv] command [arg ...]"
 msgstr "command [-pVv] COMANDO [ARG ...]"
 
 #: builtins.c:78
-#, fuzzy
 msgid "declare [-aAfFgiIlnrtux] [-p] [name[=value] ...]"
-msgstr "declare [-aAfFgilnrtux] [-p] [NOME[=VALOR] ...]"
+msgstr "declare [-aAfFgiIlnrtux] [-p] [nome[=valor] ...]"
 
 #: builtins.c:80
-#, fuzzy
 msgid "typeset [-aAfFgiIlnrtux] [-p] name[=value] ..."
-msgstr "typeset [-aAfFgilnrtux] [-p] NOME[=VALOR] ..."
+msgstr "typeset [-aAfFgiIlnrtux] [-p] nome[=valor] ..."
 
 #: builtins.c:82
 msgid "local [option] name[=value] ..."
@@ -2342,14 +2284,12 @@ msgid "eval [arg ...]"
 msgstr "eval [ARG ...]"
 
 #: builtins.c:96
-#, fuzzy
 msgid "getopts optstring name [arg ...]"
-msgstr "getopts OPTSTRING NOME [ARG]"
+msgstr "getopts optstring nome [arg ...]"
 
 #: builtins.c:98
-#, fuzzy
 msgid "exec [-cl] [-a name] [command [argument ...]] [redirection ...]"
-msgstr "exec [-cl] [-a NOME] [COMANDO [ARGUMENTOS ...]] [REDIRECIONAMENTO ...]"
+msgstr "exec [-cl] [-a nome] [comando [argumento ...]] [redirecionamento ...]"
 
 #: builtins.c:100
 msgid "exit [n]"
@@ -2361,8 +2301,7 @@ msgstr "logout [n]"
 
 #: builtins.c:105
 msgid "fc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [command]"
-msgstr ""
-"fc [-e EDITOR] [-lnr] [PRIMEIRO] [ÚLTIMO] ou fc -s [ANTIGO=NOVO] [COMANDO]"
+msgstr "fc [-e EDITOR] [-lnr] [PRIMEIRO] [ÚLTIMO] ou fc -s [ANTIGO=NOVO] [COMANDO]"
 
 #: builtins.c:109
 msgid "fg [job_spec]"
@@ -2381,12 +2320,8 @@ msgid "help [-dms] [pattern ...]"
 msgstr "help [-dms] [PADRÃO ...]"
 
 #: builtins.c:123
-msgid ""
-"history [-c] [-d offset] [n] or history -anrw [filename] or history -ps arg "
-"[arg...]"
-msgstr ""
-"history [-c] [-d POSIÇÃO] [n] ou history -anrw [ARQUIVO] ou history -ps ARG "
-"[ARG...]"
+msgid "history [-c] [-d offset] [n] or history -anrw [filename] or history -ps arg [arg...]"
+msgstr "history [-c] [-d POSIÇÃO] [n] ou history -anrw [ARQUIVO] ou history -ps ARG [ARG...]"
 
 #: builtins.c:127
 msgid "jobs [-lnprs] [jobspec ...] or jobs -x command [args]"
@@ -2397,24 +2332,16 @@ msgid "disown [-h] [-ar] [jobspec ... | pid ...]"
 msgstr "disown [-h] [-ar] [ESPEC-JOB ... | pid ...]"
 
 #: builtins.c:134
-msgid ""
-"kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l "
-"[sigspec]"
-msgstr ""
-"kill [-s SIGSPEC | -n SIGNUM | -SIGSPEC] PID | ESPEC-JOB ... ou kill -l "
-"[SIGSPEC]"
+msgid "kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]"
+msgstr "kill [-s SIGSPEC | -n SIGNUM | -SIGSPEC] PID | ESPEC-JOB ... ou kill -l [SIGSPEC]"
 
 #: builtins.c:136
 msgid "let arg [arg ...]"
 msgstr "let ARG [ARG ...]"
 
 #: builtins.c:138
-msgid ""
-"read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p "
-"prompt] [-t timeout] [-u fd] [name ...]"
-msgstr ""
-"read [-ers] [-a ARRAY] [-d DELIM] [-i TEXTO] [-n NCHARS] [-N NCHARS] [-p "
-"CONFIRMAR ] [-t TEMPO] [-u FD] [NOME ...]"
+msgid "read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]"
+msgstr "read [-ers] [-a ARRAY] [-d DELIM] [-i TEXTO] [-n NCHARS] [-N NCHARS] [-p CONFIRMAR ] [-t TEMPO] [-u FD] [NOME ...]"
 
 #: builtins.c:140
 msgid "return [n]"
@@ -2442,11 +2369,11 @@ msgstr "shift [n]"
 
 #: builtins.c:152
 msgid "source filename [arguments]"
-msgstr "source ARQUIVO [ARGUMENTOS]"
+msgstr "source arquivo [argumentos]"
 
 #: builtins.c:154
 msgid ". filename [arguments]"
-msgstr ". ARQUIVO [ARGUMENTOS]"
+msgstr ". arquivo [argumentos]"
 
 #: builtins.c:157
 msgid "suspend [-f]"
@@ -2454,32 +2381,31 @@ msgstr "suspend [-f]"
 
 #: builtins.c:160
 msgid "test [expr]"
-msgstr "test [EXPR]"
+msgstr "test [expr]"
 
 #: builtins.c:162
 msgid "[ arg... ]"
-msgstr "[ ARG... ]"
+msgstr "[ arg... ]"
 
 #: builtins.c:166
 msgid "trap [-lp] [[arg] signal_spec ...]"
-msgstr "trap [-lp] [[ARG] ESPEC-SINAL ...]"
+msgstr "trap [-lp] [[arg] espec-sinal ...]"
 
 #: builtins.c:168
 msgid "type [-afptP] name [name ...]"
-msgstr "type [-apt] NOME [NOME ...]"
+msgstr "type [-apt] nome [nome ...]"
 
 #: builtins.c:171
 msgid "ulimit [-SHabcdefiklmnpqrstuvxPT] [limit]"
-msgstr "ulimit [-SHabcdefiklmnpqrstuvxPT] [LIMITE]"
+msgstr "ulimit [-SHabcdefiklmnpqrstuvxPT] [limite]"
 
 #: builtins.c:174
 msgid "umask [-p] [-S] [mode]"
-msgstr "umask [-p] [-S] [MODO]"
+msgstr "umask [-p] [-S] [modo]"
 
 #: builtins.c:177
-#, fuzzy
 msgid "wait [-fn] [-p var] [id ...]"
-msgstr "wait [-fn] [ID ...]"
+msgstr "wait [-fn] [-p var] [id ...]"
 
 #: builtins.c:181
 msgid "wait [pid ...]"
@@ -2487,11 +2413,11 @@ msgstr "wait [PID ...]"
 
 #: builtins.c:184
 msgid "for NAME [in WORDS ... ] ; do COMMANDS; done"
-msgstr "for NOME [in PALAVRAS ...] ; do COMANDOS; done"
+msgstr "for NOME [in PALAVRAs ...] ; do COMANDOS; done"
 
 #: builtins.c:186
 msgid "for (( exp1; exp2; exp3 )); do COMMANDS; done"
-msgstr "for (( EXP1; EXP2; EXP3 )); do COMANDOS; done"
+msgstr "for (( exp1; exp2; exp3 )); do COMANDOS; done"
 
 #: builtins.c:188
 msgid "select NAME [in WORDS ... ;] do COMMANDS; done"
@@ -2499,19 +2425,15 @@ msgstr "select NOME [in PALAVRAS ... ;] do COMANDOS; done"
 
 #: builtins.c:190
 msgid "time [-p] pipeline"
-msgstr "time [-p] LINHA-COMANDOS"
+msgstr "time [-p] linha-comandos"
 
 #: builtins.c:192
 msgid "case WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esac"
 msgstr "case PALAVRA in [PADRÃO [| PADRÃO]...) COMANDOS ;;]... esac"
 
 #: builtins.c:194
-msgid ""
-"if COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS; ]... [ else "
-"COMMANDS; ] fi"
-msgstr ""
-"if COMANDOS; then COMANDOS; [ elif COMANDOS; then COMANDOS; ]... [ else "
-"COMANDOS; ] fi"
+msgid "if COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS; ]... [ else COMMANDS; ] fi"
+msgstr "if COMANDOS; then COMANDOS; [ elif COMANDOS; then COMANDOS; ]... [ else COMANDOS; ] fi"
 
 #: builtins.c:196
 msgid "while COMMANDS; do COMMANDS; done"
@@ -2523,7 +2445,7 @@ msgstr "until COMANDOS; do COMANDOS; done"
 
 #: builtins.c:200
 msgid "coproc [NAME] command [redirections]"
-msgstr "coproc [NOME] COMANDO [REDIRECIONAMENTOS]"
+msgstr "coproc [NOME] comando [redirecionamentos]"
 
 #: builtins.c:202
 msgid "function name { COMMANDS ; } or name () { COMMANDS ; }"
@@ -2535,15 +2457,15 @@ msgstr "{ COMANDOS ; }"
 
 #: builtins.c:206
 msgid "job_spec [&]"
-msgstr "ESPEC-JOB [&]"
+msgstr "escpec-job [&]"
 
 #: builtins.c:208
 msgid "(( expression ))"
-msgstr "(( EXPRESSÃO ))"
+msgstr "(( expressão ))"
 
 #: builtins.c:210
 msgid "[[ expression ]]"
-msgstr "[[ EXPRESSÃO ]]"
+msgstr "[[ expressão ]]"
 
 # Não traduzir "variables", esta é uma opção "builtin" do "bash" que é exibida ao executar "help" e acessível com "help variables".
 #: builtins.c:212
@@ -2552,7 +2474,7 @@ msgstr "variables - Nomes e significados de algumas variáveis do shell"
 
 #: builtins.c:215
 msgid "pushd [-n] [+N | -N | dir]"
-msgstr "pushd [-n] [+N | -N | DIR]"
+msgstr "pushd [-n] [+N | -N | dir]"
 
 #: builtins.c:219
 msgid "popd [-n] [+N | -N]"
@@ -2564,52 +2486,31 @@ msgstr "dirs [-clpv] [+N] [-N]"
 
 #: builtins.c:226
 msgid "shopt [-pqsu] [-o] [optname ...]"
-msgstr "shopt [-pqsu] [-o] [NOME-OPÇÃO ...]"
+msgstr "shopt [-pqsu] [-o] [nome-opção ...]"
 
 #: builtins.c:228
 msgid "printf [-v var] format [arguments]"
-msgstr "printf [-v VAR] FORMATO [ARGUMENTOS]"
+msgstr "printf [-v var] formato [argumentos]"
 
 #: builtins.c:231
-#, fuzzy
-msgid ""
-"complete [-abcdefgjksuv] [-pr] [-DEI] [-o option] [-A action] [-G globpat] [-"
-"W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S "
-"suffix] [name ...]"
-msgstr ""
-"complete [-abcdefgjksuv] [-pr] [-DEI] [-o OPÇÃO] [-A AÇÃO] [-G GLOBAL] [-W "
-"LISTA-PALAVRAS]  [-F FUNÇÃO] [-C COMANDO] [-X FILTRO] [-P PREFIXO] [-S "
-"SUFIXO] [NOME ...]"
+msgid "complete [-abcdefgjksuv] [-pr] [-DEI] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [name ...]"
+msgstr "complete [-abcdefgjksuv] [-pr] [-DEI] [-o opção] [-A ação] [-G global] [-W lista-palavras]  [-F função] [-C comando] [-X filtro] [-P prefixo] [-S sufixo] [nome ...]"
 
 #: builtins.c:235
-#, fuzzy
-msgid ""
-"compgen [-abcdefgjksuv] [-o option] [-A action] [-G globpat] [-W wordlist] [-"
-"F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [word]"
-msgstr ""
-"compgen [-abcdefgjksuv] [-o OPÇÃO] [-A AÇÃO] [-G GLOBAL] [-W LISTA-"
-"PALAVRAS]  [-F FUNÇÃO] [-C COMANDO] [-X FILTRO] [-P PREFIXO] [-S SUFIXO] "
-"[PALAVRA]"
+msgid "compgen [-abcdefgjksuv] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [word]"
+msgstr "compgen [-abcdefgjksuv] [-o opção] [-A ação] [-G global] [-W lista-palavras]  [-F função] [-C comando] [-X filtro] [-P prefixo] [-S sufixo] [palavra]"
 
 #: builtins.c:239
 msgid "compopt [-o|+o option] [-DEI] [name ...]"
-msgstr "compopt [-o|+o OPÇÃO] [-DEI] [NOME ...]"
+msgstr "compopt [-o|+o opção] [-DEI] [nome ...]"
 
 #: builtins.c:242
-msgid ""
-"mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C "
-"callback] [-c quantum] [array]"
-msgstr ""
-"mapfile [-d DELIM] [-n NÚMERO] [-O ORIGEM] [-s NÚMERO] [-t] [-u FD] [-C "
-"CHAMADA] [-c QUANTIDADE] [ARRAY]"
+msgid "mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]"
+msgstr "mapfile [-d delim] [-n número] [-O origem] [-s número] [-t] [-u fd] [-C chamada] [-c quantidade] [array]"
 
 #: builtins.c:244
-msgid ""
-"readarray [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C "
-"callback] [-c quantum] [array]"
-msgstr ""
-"readarray [-d DELIM] [-n NÚMERO] [-O ORIGEM] [-s NÚMERO] [-t] [-u FD] [-C "
-"CHAMADA] [-c QUANTIDADE] [ARRAY]"
+msgid "readarray [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]"
+msgstr "readarray [-d delim] [-n número] [-O origem] [-s número] [-t] [-u fd] [-C chamada] [-c quantidade] [array]"
 
 # help alias
 #: builtins.c:256
@@ -2627,8 +2528,7 @@ msgid ""
 "      -p\tprint all defined aliases in a reusable format\n"
 "    \n"
 "    Exit Status:\n"
-"    alias returns true unless a NAME is supplied for which no alias has "
-"been\n"
+"    alias returns true unless a NAME is supplied for which no alias has been\n"
 "    defined."
 msgstr ""
 "Define ou exibe apelidos (aliases).\n"
@@ -2677,30 +2577,25 @@ msgid ""
 "    Options:\n"
 "      -m  keymap         Use KEYMAP as the keymap for the duration of this\n"
 "                         command.  Acceptable keymap names are emacs,\n"
-"                         emacs-standard, emacs-meta, emacs-ctlx, vi, vi-"
-"move,\n"
+"                         emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,\n"
 "                         vi-command, and vi-insert.\n"
 "      -l                 List names of functions.\n"
 "      -P                 List function names and bindings.\n"
 "      -p                 List functions and bindings in a form that can be\n"
 "                         reused as input.\n"
-"      -S                 List key sequences that invoke macros and their "
-"values\n"
-"      -s                 List key sequences that invoke macros and their "
-"values\n"
+"      -S                 List key sequences that invoke macros and their values\n"
+"      -s                 List key sequences that invoke macros and their values\n"
 "                         in a form that can be reused as input.\n"
 "      -V                 List variable names and values\n"
 "      -v                 List variable names and values in a form that can\n"
 "                         be reused as input.\n"
 "      -q  function-name  Query about which keys invoke the named function.\n"
-"      -u  function-name  Unbind all keys which are bound to the named "
-"function.\n"
+"      -u  function-name  Unbind all keys which are bound to the named function.\n"
 "      -r  keyseq         Remove the binding for KEYSEQ.\n"
 "      -f  filename       Read key bindings from FILENAME.\n"
 "      -x  keyseq:shell-command\tCause SHELL-COMMAND to be executed when\n"
 "    \t\t\t\tKEYSEQ is entered.\n"
-"      -X                 List key sequences bound with -x and associated "
-"commands\n"
+"      -X                 List key sequences bound with -x and associated commands\n"
 "                         in a form that can be reused as input.\n"
 "    \n"
 "    Exit Status:\n"
@@ -2714,39 +2609,30 @@ msgstr ""
 "    um argumento singular.\n"
 "    \n"
 "    Opções:\n"
-"      -m  MAPA-TECLAS    Usa MAPA-TECLAS como mapa de teclas para a duração\n"
+"      -m  mapa-teclas    Usa MAPA-TECLAS como mapa de teclas para a duração\n"
 "                         deste comando. Nomes de mapa de teclas aceitáveis\n"
 "                         são emacs, emacs-standard, emacs-meta, emacs-ctlx,\n"
 "                         vi, vi-move, vi-command e vi-insert.\n"
 "      -l                 Lista nomes de funções.\n"
 "      -P                 Lista nomes e associações de função.\n"
-"      -p                 Lista funções e associações em uma forma que pode "
-"ser\n"
+"      -p                 Lista funções e associações em uma forma que pode ser\n"
 "                         usada como entrada.\n"
-"      -S                 Lista sequências de teclas que chamam macros e "
-"seus\n"
+"      -S                 Lista sequências de teclas que chamam macros e seus\n"
 "                         valores\n"
-"      -s                 Lista sequências de teclas que chamam macros e "
-"seus\n"
-"                         valores em uma forma que pode ser usada como "
-"entrada.\n"
+"      -s                 Lista sequências de teclas que chamam macros e seus\n"
+"                         valores em uma forma que pode ser usada como entrada.\n"
 "      -V                 Lista nomes e valores de variáveis\n"
-"      -v                 Lista nomes e valores de variáveis em uma forma "
-"que\n"
+"      -v                 Lista nomes e valores de variáveis em uma forma que\n"
 "                         pode ser usada como entrada.\n"
-"      -q  NOME           Consulta sobre quais teclas chamam a função "
-"informada.\n"
-"      -u  NOME           Desassocia todas teclas que estão associadas à "
-"função\n"
+"      -q  nome-função    Consulta sobre quais teclas chamam a função informada.\n"
+"      -u  nome-função    Desassocia todas teclas que estão associadas à função\n"
 "                         informada.\n"
-"      -r  SEQ-TECLAS     Remove a associação para SEQ-TECLAS.\n"
-"      -f  ARQUIVO        Lê associações de tecla de ARQUIVO.\n"
-"      -x  SEQ-TECLAS:COMANDO-SHELL\n"
-"                         Faz com que COMANDO-SHELL seja executado ao "
-"inserir\n"
+"      -r  seq-teclas     Remove a associação para SEQ-TECLAS.\n"
+"      -f  arquivo        Lê associações de tecla de ARQUIVO.\n"
+"      -x  seq-teclas:comando-shell\n"
+"                         Faz com que COMANDO-SHELL seja executado ao inserir\n"
 "                         SEQ-TECLAS.\n"
-"      -X                 Lista sequência de teclas associadas com -x e "
-"comandos\n"
+"      -X                 Lista sequência de teclas associadas com -x e comandos\n"
 "                         associados em uma forma que pode ser usada como\n"
 "                         entrada.\n"
 "    \n"
@@ -2800,8 +2686,7 @@ msgid ""
 "    \n"
 "    Execute SHELL-BUILTIN with arguments ARGs without performing command\n"
 "    lookup.  This is useful when you wish to reimplement a shell builtin\n"
-"    as a shell function, but need to execute the builtin within the "
-"function.\n"
+"    as a shell function, but need to execute the builtin within the function.\n"
 "    \n"
 "    Exit Status:\n"
 "    Returns the exit status of SHELL-BUILTIN, or false if SHELL-BUILTIN is\n"
@@ -2837,8 +2722,7 @@ msgstr ""
 "Retorna o contexto da chamada de sub-rotina atual.\n"
 "    \n"
 "    Sem EXPR, retorna \"$linha $arquivo\".  Com EXPR, retorna\n"
-"    \"$linha $sub-rotina $arquivo\"; essa informação extra pode ser usada "
-"para\n"
+"    \"$linha $sub-rotina $arquivo\"; essa informação extra pode ser usada para\n"
 "    fornecer um rastro da pilha.\n"
 "    \n"
 "    O valor de EXPR indica quantos quadros de chamada deve voltar antes do\n"
@@ -2853,22 +2737,16 @@ msgstr ""
 msgid ""
 "Change the shell working directory.\n"
 "    \n"
-"    Change the current directory to DIR.  The default DIR is the value of "
-"the\n"
+"    Change the current directory to DIR.  The default DIR is the value of the\n"
 "    HOME shell variable.\n"
 "    \n"
-"    The variable CDPATH defines the search path for the directory "
-"containing\n"
-"    DIR.  Alternative directory names in CDPATH are separated by a colon "
-"(:).\n"
-"    A null directory name is the same as the current directory.  If DIR "
-"begins\n"
+"    The variable CDPATH defines the search path for the directory containing\n"
+"    DIR.  Alternative directory names in CDPATH are separated by a colon (:).\n"
+"    A null directory name is the same as the current directory.  If DIR begins\n"
 "    with a slash (/), then CDPATH is not used.\n"
 "    \n"
-"    If the directory is not found, and the shell option `cdable_vars' is "
-"set,\n"
-"    the word is assumed to be  a variable name.  If that variable has a "
-"value,\n"
+"    If the directory is not found, and the shell option `cdable_vars' is set,\n"
+"    the word is assumed to be  a variable name.  If that variable has a value,\n"
 "    its value is used for DIR.\n"
 "    \n"
 "    Options:\n"
@@ -2884,13 +2762,11 @@ msgid ""
 "    \t\tattributes as a directory containing the file attributes\n"
 "    \n"
 "    The default is to follow symbolic links, as if `-L' were specified.\n"
-"    `..' is processed by removing the immediately previous pathname "
-"component\n"
+"    `..' is processed by removing the immediately previous pathname component\n"
 "    back to a slash or the beginning of DIR.\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns 0 if the directory is changed, and if $PWD is set successfully "
-"when\n"
+"    Returns 0 if the directory is changed, and if $PWD is set successfully when\n"
 "    -P is used; non-zero otherwise."
 msgstr ""
 "Altera o diretório de trabalho do shell.\n"
@@ -2898,20 +2774,17 @@ msgstr ""
 "    Altera o diretório atual para DIR, sendo o padrão de DIR o mesmo valor\n"
 "    da variável HOME.\n"
 "    \n"
-"    A variável CDPATH define o caminho de pesquisa para o diretório "
-"contendo\n"
+"    A variável CDPATH define o caminho de pesquisa para o diretório contendo\n"
 "    DIR. Nomes de diretórios alternativos em CDPATH são separados por\n"
 "    dois-pontos (:). Um nome de diretório nulo é o mesmo que o diretório\n"
 "    atual. Se DIR inicia com uma barra (/), então CDPATH não é usada.\n"
 "    \n"
-"    Se o diretório não for encontrado e a opção `cdable_vars` estiver "
-"definida\n"
+"    Se o diretório não for encontrado e a opção `cdable_vars` estiver definida\n"
 "    no shell, a palavra é presumida como sendo o nome de uma variável. Se\n"
 "    tal variável possuir um valor, este valor é usado para DIR.\n"
 "    \n"
 "    Opções:\n"
-"      -L\tforça links simbólicos a serem seguidos: resolver links "
-"simbólicos\n"
+"      -L\tforça links simbólicos a serem seguidos: resolver links simbólicos\n"
 "      \t\tem DIR após processar instâncias de `..'\n"
 "      -P\tusa a estrutura do diretório físico sem seguir links\n"
 "    \t\tsimbólicos: resolve links simbólicos em DIR antes de processar\n"
@@ -2922,15 +2795,12 @@ msgstr ""
 "    \t\tatributos estendidos como um diretório contendo os atributos de\n"
 "    \t\tarquivo\n"
 "    \n"
-"    O padrão é seguir links simbólicos, como se `-L' tivesse sido "
-"especificada.\n"
-"    `..' é processada removendo o componente de caminho imediatamente "
-"anterior\n"
+"    O padrão é seguir links simbólicos, como se `-L' tivesse sido especificada.\n"
+"    `..' é processada removendo o componente de caminho imediatamente anterior\n"
 "    de volta para uma barra ou para o início de DIR.\n"
 "    \n"
 "    Status de saída:\n"
-"    Retorna 0, se o diretório tiver sido alterado e se $PWD está definida "
-"com\n"
+"    Retorna 0, se o diretório tiver sido alterado e se $PWD está definida com\n"
 "    sucesso quando a opção -P for usada; do contrário, retorna não-zero."
 
 # help pwd
@@ -3011,8 +2881,7 @@ msgid ""
 "Execute a simple command or display information about commands.\n"
 "    \n"
 "    Runs COMMAND with ARGS suppressing  shell function lookup, or display\n"
-"    information about the specified COMMANDs.  Can be used to invoke "
-"commands\n"
+"    information about the specified COMMANDs.  Can be used to invoke commands\n"
 "    on disk when a function with the same name exists.\n"
 "    \n"
 "    Options:\n"
@@ -3042,7 +2911,6 @@ msgstr ""
 
 # help declare
 #: builtins.c:490
-#, fuzzy
 msgid ""
 "Set variable values and attributes.\n"
 "    \n"
@@ -3075,8 +2943,7 @@ msgid ""
 "    Variables with the integer attribute have arithmetic evaluation (see\n"
 "    the `let' command) performed when the variable is assigned a value.\n"
 "    \n"
-"    When used in a function, `declare' makes NAMEs local, as with the "
-"`local'\n"
+"    When used in a function, `declare' makes NAMEs local, as with the `local'\n"
 "    command.  The `-g' option suppresses this behavior.\n"
 "    \n"
 "    Exit Status:\n"
@@ -3085,8 +2952,7 @@ msgid ""
 msgstr ""
 "Define valores e atributos de variável.\n"
 "    \n"
-"    Declara variáveis e a elas fornece atributos. Se nenhum NOME for "
-"fornecido,\n"
+"    Declara variáveis e a elas fornece atributos. Se nenhum NOME for fornecido,\n"
 "    exibe os atributos e valores de todas as variáveis.\n"
 "    \n"
 "    Opções:\n"
@@ -3101,13 +2967,11 @@ msgstr ""
 "      -a\tpara fazer NOMEs serem arrrays indexados (se houver suporte)\n"
 "      -A\tpara fazer NOMEs serem arrrays associativos (se houver suporte)\n"
 "      -i\tpara fazer NOMEs terem o atributo `integer'\n"
-"      -l\tpara converter o valor de cada NOME para minúsculo em sua "
-"atribuição\n"
+"      -l\tpara converter o valor de cada NOME para minúsculo em sua atribuição\n"
 "      -n\tfazer de NOME uma referência à variável chamada por seu valor\n"
-"      -r\tpara fazer de NOMEs somente-leitura\n"
+"      -r\tpara fazer de NOMEs somente leitura\n"
 "      -t\tpara fazer NOMEs terem o atributo `trace'\n"
-"      -u\tpara converter o valor de cada NOME para maiúsculo em sua "
-"atribuição\n"
+"      -u\tpara converter o valor de cada NOME para maiúsculo em sua atribuição\n"
 "      -x\tpra fazer NOMEs exportar\n"
 "    \n"
 "    Usar `+' ao invés de `-' desliga o atributo dado.\n"
@@ -3152,8 +3016,7 @@ msgstr ""
 "    Cria uma variável local chamada NOME e lhe dá VALOR. OPÇÃO pode ser\n"
 "    qualquer opção aceita pelo `declare'.\n"
 "    \n"
-"    Variáveis locais podem ser usadas apenas em uma função; elas são "
-"visíveis\n"
+"    Variáveis locais podem ser usadas apenas em uma função; elas são visíveis\n"
 "    apenas para a função na qual elas foram definidas, bem como para seus\n"
 "    filhos.\n"
 "    \n"
@@ -3167,8 +3030,7 @@ msgstr ""
 msgid ""
 "Write arguments to the standard output.\n"
 "    \n"
-"    Display the ARGs, separated by a single space character and followed by "
-"a\n"
+"    Display the ARGs, separated by a single space character and followed by a\n"
 "    newline, on the standard output.\n"
 "    \n"
 "    Options:\n"
@@ -3192,11 +3054,9 @@ msgid ""
 "    \t\t0 to 3 octal digits\n"
 "      \\xHH\tthe eight-bit character whose value is HH (hexadecimal).  HH\n"
 "    \t\tcan be one or two hex digits\n"
-"      \\uHHHH\tthe Unicode character whose value is the hexadecimal value "
-"HHHH.\n"
+"      \\uHHHH\tthe Unicode character whose value is the hexadecimal value HHHH.\n"
 "    \t\tHHHH can be one to four hex digits.\n"
-"      \\UHHHHHHHH the Unicode character whose value is the hexadecimal "
-"value\n"
+"      \\UHHHHHHHH the Unicode character whose value is the hexadecimal value\n"
 "    \t\tHHHHHHHH. HHHHHHHH can be one to eight hex digits.\n"
 "    \n"
 "    Exit Status:\n"
@@ -3318,8 +3178,7 @@ msgstr ""
 msgid ""
 "Execute arguments as a shell command.\n"
 "    \n"
-"    Combine ARGs into a single string, use the result as input to the "
-"shell,\n"
+"    Combine ARGs into a single string, use the result as input to the shell,\n"
 "    and execute the resulting commands.\n"
 "    \n"
 "    Exit Status:\n"
@@ -3335,7 +3194,6 @@ msgstr ""
 
 # help getopts
 #: builtins.c:652
-#, fuzzy
 msgid ""
 "Parse option arguments.\n"
 "    \n"
@@ -3400,17 +3258,16 @@ msgstr ""
 "    encontrado, getopts coloca um ':' em NOME e define OPTARG para o\n"
 "    caractere de opção encontrada. Se getopts não estiver no modo\n"
 "    silencioso, uma opção inválida é vista, getopts coloca um '?' em\n"
-"    NOME e remove definição de OPTARG. Se um argumento obrigatório não for\n"
-"    encontrado, um '?' é colocado em NOME, OPTARG tem sua definição "
-"removida\n"
-"    e uma mensagem de diagnóstico é mostrada.\n"
+"    NOME e remove definição de OPTARG. Se um argumento obrigatório não\n"
+"    for encontrado, um '?' é colocado em NOME, OPTARG tem sua definição\n"
+"    removida e uma mensagem de diagnóstico é mostrada.\n"
 "    \n"
 "    Se a variável shell OPTERR possuir o valor 0, getopts desabilita a\n"
 "    exibição de mensagens de erro, mesmo se o primeiro caractere de\n"
 "    OPÇÕES não for dois-pontos.  OPTERR tem o valor por padrão.\n"
 "    \n"
-"    Getopts normalmente analisa os parâmetros posicionais ($0 - $9), mas se\n"
-"    mais argumentos forem fornecidos, eles serão analisados.\n"
+"    Getopts normalmente analisa os parâmetros posicionais, mas se mais\n"
+"    argumentos forem fornecidos, eles serão analisados.\n"
 "    \n"
 "    Status de saída:\n"
 "    Retorna sucesso, se uma opção for encontrada; falha se o fim das opções\n"
@@ -3422,8 +3279,7 @@ msgid ""
 "Replace the shell with the given command.\n"
 "    \n"
 "    Execute COMMAND, replacing this shell with the specified program.\n"
-"    ARGUMENTS become the arguments to COMMAND.  If COMMAND is not "
-"specified,\n"
+"    ARGUMENTS become the arguments to COMMAND.  If COMMAND is not specified,\n"
 "    any redirections take effect in the current shell.\n"
 "    \n"
 "    Options:\n"
@@ -3431,13 +3287,11 @@ msgid ""
 "      -c\texecute COMMAND with an empty environment\n"
 "      -l\tplace a dash in the zeroth argument to COMMAND\n"
 "    \n"
-"    If the command cannot be executed, a non-interactive shell exits, "
-"unless\n"
+"    If the command cannot be executed, a non-interactive shell exits, unless\n"
 "    the shell option `execfail' is set.\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns success unless COMMAND is not found or a redirection error "
-"occurs."
+"    Returns success unless COMMAND is not found or a redirection error occurs."
 msgstr ""
 "Substitui o shell com o comando fornecido.\n"
 "    \n"
@@ -3447,7 +3301,7 @@ msgstr ""
 "    atual.\n"
 "    \n"
 "    Opções:\n"
-"      -a NOME\tpassa NOME como argumento zero para COMANDO\n"
+"      -a nome\tpassa NOME como argumento zero para COMANDO\n"
 "      -c\texecuta COMANDO com um ambiente vazio\n"
 "      -l\tcoloca um traço no argumento zero para COMANDO\n"
 "    \n"
@@ -3476,8 +3330,7 @@ msgstr ""
 msgid ""
 "Exit a login shell.\n"
 "    \n"
-"    Exits a login shell with exit status N.  Returns an error if not "
-"executed\n"
+"    Exits a login shell with exit status N.  Returns an error if not executed\n"
 "    in a login shell."
 msgstr ""
 "Sai de um shell de login.\n"
@@ -3490,15 +3343,13 @@ msgstr ""
 msgid ""
 "Display or execute commands from the history list.\n"
 "    \n"
-"    fc is used to list or edit and re-execute commands from the history "
-"list.\n"
+"    fc is used to list or edit and re-execute commands from the history list.\n"
 "    FIRST and LAST can be numbers specifying the range, or FIRST can be a\n"
 "    string, which means the most recent command beginning with that\n"
 "    string.\n"
 "    \n"
 "    Options:\n"
-"      -e ENAME\tselect which editor to use.  Default is FCEDIT, then "
-"EDITOR,\n"
+"      -e ENAME\tselect which editor to use.  Default is FCEDIT, then EDITOR,\n"
 "    \t\tthen vi\n"
 "      -l \tlist lines instead of editing\n"
 "      -n\tomit line numbers when listing\n"
@@ -3512,14 +3363,12 @@ msgid ""
 "    the last command.\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns success or status of executed command; non-zero if an error "
-"occurs."
+"    Returns success or status of executed command; non-zero if an error occurs."
 msgstr ""
 "Exibe ou executa comandos da lista do histórico.\n"
 "    \n"
 "    fc é usado para listar ou editar e re-executar comandos da lista de\n"
-"    histórico. PRIMEIRO e ÚLTIMO podem ser números especificando o "
-"intervalo\n"
+"    histórico. PRIMEIRO e ÚLTIMO podem ser números especificando o intervalo\n"
 "    ou PRIMEIRO pode ser uma string, o que significa o comando mais recente\n"
 "    iniciando com aquela string.\n"
 "    \n"
@@ -3560,18 +3409,15 @@ msgstr ""
 "    a noção do shell de trabalho atual é usada.\n"
 "    \n"
 "    Status de saída:\n"
-"    Status do comando colocado em primeiro plano ou falha, se ocorrer um "
-"erro."
+"    Status do comando colocado em primeiro plano ou falha, se ocorrer um erro."
 
 # help bg
 #: builtins.c:779
 msgid ""
 "Move jobs to the background.\n"
 "    \n"
-"    Place the jobs identified by each JOB_SPEC in the background, as if "
-"they\n"
-"    had been started with `&'.  If JOB_SPEC is not present, the shell's "
-"notion\n"
+"    Place the jobs identified by each JOB_SPEC in the background, as if they\n"
+"    had been started with `&'.  If JOB_SPEC is not present, the shell's notion\n"
 "    of the current job is used.\n"
 "    \n"
 "    Exit Status:\n"
@@ -3593,8 +3439,7 @@ msgid ""
 "Remember or display program locations.\n"
 "    \n"
 "    Determine and remember the full pathname of each command NAME.  If\n"
-"    no arguments are given, information about remembered commands is "
-"displayed.\n"
+"    no arguments are given, information about remembered commands is displayed.\n"
 "    \n"
 "    Options:\n"
 "      -d\tforget the remembered location of each NAME\n"
@@ -3613,14 +3458,13 @@ msgid ""
 msgstr ""
 "Memoriza ou exibe localizações de programas.\n"
 "    \n"
-"    Determina e memoriza do caminho completo de cada comando NOME. Se "
-"nenhum\n"
+"    Determina e memoriza do caminho completo de cada comando NOME. Se nenhum\n"
 "    argumento for fornecido, exibe informação sobre comandos memorizados.\n"
 "    \n"
 "    Opções:\n"
 "      -d\t\tesquece a localização memorizada de cada NOME\n"
 "      -l\t\texibe em um formato que pode ser usado como entrada\n"
-"      -p CAMINHO\tusa CAMINHO como o caminho completo de NOME\n"
+"      -p caminho\tusa CAMINHO como o caminho completo de NOME\n"
 "      -r\t\tesquece de todas as localizações memorizadas\n"
 "      -t\t\tmostra a localização memorizada de cada NOME, iniciando\n"
 "      \t\t\tcada localização com o NOME correspondente, se múltiplos\n"
@@ -3652,8 +3496,7 @@ msgid ""
 "      PATTERN\tPattern specifying a help topic\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns success unless PATTERN is not found or an invalid option is "
-"given."
+"    Returns success unless PATTERN is not found or an invalid option is given."
 msgstr ""
 "Exibe informação sobre comandos internos (builtin).\n"
 "    \n"
@@ -3663,7 +3506,7 @@ msgstr ""
 "    \n"
 "    Opções:\n"
 "      -d\texibe uma descrição breve para cada tópico\n"
-"      -m\texibe o uso em formato pseudo-manpage\n"
+"      -m\texibe o uso em formato de pseudo página man\n"
 "      -s\texibe apenas uma breve sinopse de uso para cada tópico\n"
 "      \t\tcorrespondendo a PADRÃO\n"
 "    \n"
@@ -3702,8 +3545,7 @@ msgid ""
 "    \n"
 "    If the HISTTIMEFORMAT variable is set and not null, its value is used\n"
 "    as a format string for strftime(3) to print the time stamp associated\n"
-"    with each displayed history entry.  No time stamps are printed "
-"otherwise.\n"
+"    with each displayed history entry.  No time stamps are printed otherwise.\n"
 "    \n"
 "    Exit Status:\n"
 "    Returns success unless an invalid option is given or an error occurs."
@@ -3716,9 +3558,8 @@ msgstr ""
 "    \n"
 "    Opções:\n"
 "      -c\t\tlimpa a lista de histórico ao excluir todas as entradas\n"
-"      -d POSIÇÃO\texclui a entrada de histórico na posição POSIÇÃO. "
-"Posições\n"
-"\t\t\tnegativas contam a partir do fim da lista de histórico\n"
+"      -d posição\texclui a entrada de histórico na posição POSIÇÃO. Posições\n"
+"    \t\t\tnegativas contam a partir do fim da lista de histórico\n"
 "    \n"
 "      -a\t\tanexa linhas de histórico desta sessão no arquivo de\n"
 "      \t\t\thistórico\n"
@@ -3852,12 +3693,12 @@ msgstr ""
 "    não estiverem presentes, então, SIGTERM é presumido.\n"
 "    \n"
 "    Opções:\n"
-"      -s SIGSPEC\tSIGSPEC especifica o nome do sinal\n"
-"      -n SIGNUM\t\tSIGNUM representa um número de sinal\n"
-"      -l\t\t\tlista os nomes dos sinais; se `-l' for acompanhado por\n"
-"      \t\t\t\toutros argumentos, presume-se estes sejam números de\n"
-"      \t\t\t\tsinais para os quais nomes deveriam ser listados\n"
-"      -L\t\t\tsinônimo de -l\n"
+"      -s sinal\tSINAL especifica o nome do sinal\n"
+"      -n sinal\tSINAL representa um número de sinal\n"
+"      -l\tlista os nomes dos sinais; se `-l' for acompanhado por\n"
+"    \t\toutros argumentos, presume-se estes sejam números de\n"
+"    \t\tsinais para os quais nomes deveriam ser listados\n"
+"      -L\tsinônimo de -l\n"
 "    \n"
 "    `Kill' é um comando interno do shell por duas razões: ele permite\n"
 "    IDs de trabalho serem usados ao invés de IDs de processo e permite\n"
@@ -3876,8 +3717,7 @@ msgid ""
 "    Evaluate each ARG as an arithmetic expression.  Evaluation is done in\n"
 "    fixed-width integers with no check for overflow, though division by 0\n"
 "    is trapped and flagged as an error.  The following list of operators is\n"
-"    grouped into levels of equal-precedence operators.  The levels are "
-"listed\n"
+"    grouped into levels of equal-precedence operators.  The levels are listed\n"
 "    in order of decreasing precedence.\n"
 "    \n"
 "    \tid++, id--\tvariable post-increment, post-decrement\n"
@@ -3960,16 +3800,13 @@ msgid ""
 "Read a line from the standard input and split it into fields.\n"
 "    \n"
 "    Reads a single line from the standard input, or from file descriptor FD\n"
-"    if the -u option is supplied.  The line is split into fields as with "
-"word\n"
+"    if the -u option is supplied.  The line is split into fields as with word\n"
 "    splitting, and the first word is assigned to the first NAME, the second\n"
 "    word to the second NAME, and so on, with any leftover words assigned to\n"
-"    the last NAME.  Only the characters found in $IFS are recognized as "
-"word\n"
+"    the last NAME.  Only the characters found in $IFS are recognized as word\n"
 "    delimiters.\n"
 "    \n"
-"    If no NAMEs are supplied, the line read is stored in the REPLY "
-"variable.\n"
+"    If no NAMEs are supplied, the line read is stored in the REPLY variable.\n"
 "    \n"
 "    Options:\n"
 "      -a array\tassign the words read to sequential indices of the array\n"
@@ -3981,8 +3818,7 @@ msgid ""
 "      -n nchars\treturn after reading NCHARS characters rather than waiting\n"
 "    \t\tfor a newline, but honor a delimiter if fewer than\n"
 "    \t\tNCHARS characters are read before the delimiter\n"
-"      -N nchars\treturn only after reading exactly NCHARS characters, "
-"unless\n"
+"      -N nchars\treturn only after reading exactly NCHARS characters, unless\n"
 "    \t\tEOF is encountered or read times out, ignoring any\n"
 "    \t\tdelimiter\n"
 "      -p prompt\toutput the string PROMPT without a trailing newline before\n"
@@ -4000,19 +3836,15 @@ msgid ""
 "      -u fd\tread from file descriptor FD instead of the standard input\n"
 "    \n"
 "    Exit Status:\n"
-"    The return code is zero, unless end-of-file is encountered, read times "
-"out\n"
-"    (in which case it's greater than 128), a variable assignment error "
-"occurs,\n"
+"    The return code is zero, unless end-of-file is encountered, read times out\n"
+"    (in which case it's greater than 128), a variable assignment error occurs,\n"
 "    or an invalid file descriptor is supplied as the argument to -u."
 msgstr ""
 "Lê uma linha da entrada padrão e separa em campos.\n"
 "\n"
 "    Lê uma linha da entrada padrão ou do descritor de arquivo FD, caso a\n"
-"    opção -u seja fornecida. A linha é separada em campos, na mesma forma "
-"de\n"
-"    separação de palavras, e a primeira palavra é atribuída ao primeiro "
-"NOME,\n"
+"    opção -u seja fornecida. A linha é separada em campos, na mesma forma de\n"
+"    separação de palavras, e a primeira palavra é atribuída ao primeiro NOME,\n"
 "    o segundo ao segundo NOME e por aí vai, com qualquer palavras restantes\n"
 "    atribuídas para o último NOME. Apenas os caracteres encontrados em $IFS\n"
 "    são reconhecidos como delimitadores de palavras.\n"
@@ -4021,43 +3853,36 @@ msgstr ""
 "    REPLY (resposta).\n"
 "    \n"
 "    Opções:\n"
-"      -a ARRAY      atribui as palavras lidas a índices sequenciais da\n"
+"      -a array      atribui as palavras lidas a índices sequenciais da\n"
 "                    variável array ARRAY, iniciando em zero\n"
-"      -d DELIM      continua até o primeiro caractere de DELIM ser lido, ao\n"
+"      -d delim      continua até o primeiro caractere de DELIM ser lido, ao\n"
 "                    invés de nova linha\n"
 "      -e            usa Readline para obter a linha\n"
-"      -i TEXTO      usa TEXTO como o texto inicial para Readline\n"
-"      -n NCHARS     retorna após ler NCHARS caracteres, ao invés de esperar\n"
-"                    por uma nova linha, mas respeita um delimitador se "
-"número\n"
+"      -i texto      usa TEXTO como o texto inicial para Readline\n"
+"      -n nchars     retorna após ler NCHARS caracteres, ao invés de esperar\n"
+"                    por uma nova linha, mas respeita um delimitador se número\n"
 "                    de caracteres menor que NCHARS sejam lidos antes do\n"
 "                    delimitador\n"
-"      -N NCHARS     retorna apenas após ler exatamente NCHARS caracteres, a\n"
-"                    menos que EOF (fim do arquivo) seja encontrado ou "
-"`read'\n"
+"      -N nchars     retorna apenas após ler exatamente NCHARS caracteres, a\n"
+"                    menos que EOF (fim do arquivo) seja encontrado ou `read'\n"
 "                    esgote o tempo limite, ignorando qualquer delimitador\n"
-"      -p CONFIRMAR  mostra a string PROMPT sem remover nova linha antes de\n"
+"      -p prompt     mostra a string PROMPT sem remover nova linha antes de\n"
 "                    tentar ler\n"
 "      -r            não mostra barra invertida para escapar quaisquer\n"
 "                    caracteres\n"
 "      -s            não ecoa entrada vindo de um terminal\n"
-"      -t TEMPO      esgota-se o tempo limite e retorna falha, caso uma toda\n"
+"      -t tempo      esgota-se o tempo limite e retorna falha, caso uma toda\n"
 "                    uma linha não seja lida em TEMPO segundos. O valor da\n"
-"                    variável TMOUT é o tempo limite padrão. TEMPO pode ser "
-"um\n"
-"                    número fracionado. SE TEMPO for 0, `read' retorna "
-"sucesso\n"
+"                    variável TMOUT é o tempo limite padrão. TEMPO pode ser um\n"
+"                    número fracionado. SE TEMPO for 0, `read' retorna sucesso\n"
 "                    apenas se a entrada estiver disponível no descritor de\n"
-"                    arquivo especificado. O status de saída é maior que "
-"128,\n"
+"                    arquivo especificado. O status de saída é maior que 128,\n"
 "                    se o tempo limite for excedido\n"
-"      -u FD         lê do descritor de arquivo FD, ao invés da entrada "
-"padrão\n"
+"      -u fd         lê do descritor de arquivo FD, ao invés da entrada padrão\n"
 "    \n"
 "    Status de saída:\n"
 "    O código de retorno é zero, a menos que o EOF (fim do arquivo) seja\n"
-"    encontrado, `read' esgote o tempo limite (caso em que o código de "
-"retorno\n"
+"    encontrado, `read' esgote o tempo limite (caso em que o código de retorno\n"
 "    será 128), ocorra erro de atribuição de uma variável ou um descritor de\n"
 "    arquivo inválido seja fornecido como argumento para -u."
 
@@ -4127,8 +3952,7 @@ msgid ""
 "              physical     same as -P\n"
 "              pipefail     the return value of a pipeline is the status of\n"
 "                           the last command to exit with a non-zero status,\n"
-"                           or zero if no command exited with a non-zero "
-"status\n"
+"                           or zero if no command exited with a non-zero status\n"
 "              posix        change the behavior of bash where the default\n"
 "                           operation differs from the Posix standard to\n"
 "                           match the standard\n"
@@ -4152,8 +3976,7 @@ msgid ""
 "          by default when the shell is interactive.\n"
 "      -P  If set, do not resolve symbolic links when executing commands\n"
 "          such as cd which change the current directory.\n"
-"      -T  If set, the DEBUG and RETURN traps are inherited by shell "
-"functions.\n"
+"      -T  If set, the DEBUG and RETURN traps are inherited by shell functions.\n"
 "      --  Assign any remaining arguments to the positional parameters.\n"
 "          If there are no remaining arguments, the positional parameters\n"
 "          are unset.\n"
@@ -4169,27 +3992,24 @@ msgid ""
 "    Exit Status:\n"
 "    Returns success unless an invalid option is given."
 msgstr ""
-"Define ou remove definição de valores das opções e dos parâmetros "
-"posicionais\n"
+"Define ou remove definição de valores das opções e dos parâmetros posicionais\n"
 "do shell:\n"
 "    \n"
 "    Altera o valor de opções e de parâmetros posicionais do shell ou mostra\n"
 "    os nomes ou valores de variáveis shell.\n"
 "    \n"
 "    Opções:\n"
-"      -a  Marca variáveis, que foram modificadas ou criadas, para "
-"exportação.\n"
+"      -a  Marca variáveis, que foram modificadas ou criadas, para exportação.\n"
 "      -b  Notifica sobre terminação de trabalho imediatamente.\n"
 "      -e  Sai imediatamente se um comando sai com um status não-zero.\n"
 "      -f  Desabilita a geração de nome de arquivo (\"globbing\").\n"
-"      -h  Memoriza a localização de comandos à medida em que são "
-"procurados.\n"
+"      -h  Memoriza a localização de comandos à medida em que são procurados.\n"
 "      -k  Todos argumentos de atribuição são colocados no ambiente para um\n"
 "          comando, e não apenas aqueles que precedem o nome do comando.\n"
 "      -m  Controle de trabalho está habilitado.\n"
 "      -n  Lê comandos, mas não os executa.\n"
-"      -o NOME-OPÇÃO\n"
-"          Define a variável correspondendo a NOME-OPÇÃO:\n"
+"      -o nome-opção\n"
+"          Define a variável correspondendo a nome-opção:\n"
 "              allexport    mesmo que -a\n"
 "              braceexpand  mesmo que -B\n"
 "              emacs        usa interface de edição de linha estilo Emacs\n"
@@ -4201,8 +4021,7 @@ msgstr ""
 "              history      habilita histórico de comandos\n"
 "              ignoreeof    shell não vai sair após leitura de EOF\n"
 "              interactive-comments\n"
-"                           permite mostrar comentários em comandos "
-"interativos\n"
+"                           permite mostrar comentários em comandos interativos\n"
 "              keyword      mesmo que -k\n"
 "              monitor      mesmo que -m\n"
 "              noclobber    mesmo que -C\n"
@@ -4214,10 +4033,8 @@ msgstr ""
 "              onecmd       mesmo que -t\n"
 "              physical     mesmo que -P\n"
 "              pipefail     o valor de retorno de uma linha de comandos é o\n"
-"                           status do último comando a sair com status não-"
-"zero,\n"
-"                           ou zero se nenhum comando saiu com status não "
-"zero\n"
+"                           status do último comando a sair com status não-zero,\n"
+"                           ou zero se nenhum comando saiu com status não zero\n"
 "              posix        altera o comportamento do bash, onde a operação\n"
 "                           padrão diverge dos padrões do Posix para\n"
 "                           corresponder a estes padrões\n"
@@ -4225,44 +4042,33 @@ msgstr ""
 "              verbose      mesmo que -v\n"
 "              vi           usa interface de edição de linha estilo vi\n"
 "              xtrace       mesmo que -x\n"
-"      -p  Ligado sempre que IDs de usuário real e efetivo não "
-"corresponderem.\n"
-"          Desabilita processamento do arquivo $ENV e importação de funções "
-"da\n"
+"      -p  Ligado sempre que IDs de usuário real e efetivo não corresponderem.\n"
+"          Desabilita processamento do arquivo $ENV e importação de funções da\n"
 "          shell. Ao desligar essa opção, causa o uid e o gid efetivo serem\n"
 "          os uid e gid reais.\n"
 "      -t  Sai após a leitura e execução de um comando.\n"
-"      -u  Trata limpeza (unset) de variáveis como um erro quando "
-"substituindo.\n"
+"      -u  Trata limpeza (unset) de variáveis como um erro quando substituindo.\n"
 "      -v  Mostra linhas de entrada do shell na medida em que forem lidas.\n"
-"      -x  Mostra comandos e seus argumentos na medida em que forme "
-"executados.\n"
+"      -x  Mostra comandos e seus argumentos na medida em que forme executados.\n"
 "      -B  o shell vai realizar expansão de chaves\n"
 "      -C  Se definido, não permite arquivos normais existentes serem\n"
 "          sobrescritos por redirecionamento da saída.\n"
 "      -E  Se definido, a armadilha ERR é herdada por funções do shell.\n"
-"      -H  Habilita substituição de histórico estilo \"!\". Essa sinalização "
-"está\n"
+"      -H  Habilita substituição de histórico estilo \"!\". Essa sinalização está\n"
 "          habilitada por padrão quando  shell é interativa.\n"
-"      -P  Se definida, não resolve links simbólicos ao sair de comandos, "
-"tais\n"
+"      -P  Se definida, não resolve links simbólicos ao sair de comandos, tais\n"
 "          como `cd' (que altera o diretório atual).\n"
-"      -T  Se definido, a armadilha DEBUG e RETURN são herdadas por funções "
-"do shell.\n"
-"      --  Atribui quaisquer argumentos restantes aos parâmetros "
-"posicionais.\n"
+"      -T  Se definido, a armadilha DEBUG e RETURN são herdadas por funções do shell.\n"
+"      --  Atribui quaisquer argumentos restantes aos parâmetros posicionais.\n"
 "          Se não houver argumentos restantes, os parâmetros posicionais são\n"
 "          limpos (unset).\n"
-"      -   Atribui quaisquer argumentos restantes aos parâmetros "
-"posicionais.\n"
+"      -   Atribui quaisquer argumentos restantes aos parâmetros posicionais.\n"
 "          As opções -x e -v são desligadas.\n"
 "    \n"
 "    Usar +, ao invés de -, causa essas sinalizações serem desligadas. As\n"
 "    sinalizações também podem ser usadas por meio de chamada do shell. As\n"
-"    sinalizações atualmente definidas podem ser encontradas em $-. Os n "
-"ARGs\n"
-"    restantes são parâmetros posicionais e são atribuídos, em ordem, a $1, "
-"$2,\n"
+"    sinalizações atualmente definidas podem ser encontradas em $-. Os n ARGs\n"
+"    restantes são parâmetros posicionais e são atribuídos, em ordem, a $1, $2,\n"
 "    .. $n. Se nenhuma ARG for fornecido, todas as variáveis shell são\n"
 "    mostradas.\n"
 "    \n"
@@ -4282,8 +4088,7 @@ msgid ""
 "      -n\ttreat each NAME as a name reference and unset the variable itself\n"
 "    \t\trather than the variable it references\n"
 "    \n"
-"    Without options, unset first tries to unset a variable, and if that "
-"fails,\n"
+"    Without options, unset first tries to unset a variable, and if that fails,\n"
 "    tries to unset a function.\n"
 "    \n"
 "    Some variables cannot be unset; also see `readonly'.\n"
@@ -4316,8 +4121,7 @@ msgid ""
 "Set export attribute for shell variables.\n"
 "    \n"
 "    Marks each NAME for automatic export to the environment of subsequently\n"
-"    executed commands.  If VALUE is supplied, assign VALUE before "
-"exporting.\n"
+"    executed commands.  If VALUE is supplied, assign VALUE before exporting.\n"
 "    \n"
 "    Options:\n"
 "      -f\trefer to shell functions\n"
@@ -4332,8 +4136,7 @@ msgstr ""
 "Define atributo de exportação para variáveis shell.\n"
 "    \n"
 "    Marca cada NOME para exportação automática para o ambiente dos comandos\n"
-"    executados subsequentemente. Se VALOR for fornecido, atribui VALOR "
-"antes\n"
+"    executados subsequentemente. Se VALOR for fornecido, atribui VALOR antes\n"
 "    de exportar.\n"
 "    \n"
 "    Opções:\n"
@@ -4400,8 +4203,7 @@ msgid ""
 msgstr ""
 "Desloca parâmetros posicionais.\n"
 "    \n"
-"    Renomeia os parâmetros posicionais $N+1,$N+2 ... até $1,$2 ...  Se N "
-"não\n"
+"    Renomeia os parâmetros posicionais $N+1,$N+2 ... até $1,$2 ...  Se N não\n"
 "    for fornecido, presume-se que ele seja 1.\n"
 "    \n"
 "    Status de saída:\n"
@@ -4493,8 +4295,7 @@ msgid ""
 "      -x FILE        True if the file is executable by you.\n"
 "      -O FILE        True if the file is effectively owned by you.\n"
 "      -G FILE        True if the file is effectively owned by your group.\n"
-"      -N FILE        True if the file has been modified since it was last "
-"read.\n"
+"      -N FILE        True if the file has been modified since it was last read.\n"
 "    \n"
 "      FILE1 -nt FILE2  True if file1 is newer than file2 (according to\n"
 "                       modification date).\n"
@@ -4515,8 +4316,7 @@ msgid ""
 "      STRING1 != STRING2\n"
 "                     True if the strings are not equal.\n"
 "      STRING1 < STRING2\n"
-"                     True if STRING1 sorts before STRING2 "
-"lexicographically.\n"
+"                     True if STRING1 sorts before STRING2 lexicographically.\n"
 "      STRING1 > STRING2\n"
 "                     True if STRING1 sorts after STRING2 lexicographically.\n"
 "    \n"
@@ -4543,10 +4343,8 @@ msgid ""
 msgstr ""
 "Avalia expressão condicional.\n"
 "    \n"
-"    Sai com um status de 0 (verdadeiro) ou 1 (falso) dependendo da "
-"avaliação\n"
-"    de EXPR. As expressões podem ser unárias ou binárias. Expressões "
-"unárias\n"
+"    Sai com um status de 0 (verdadeiro) ou 1 (falso) dependendo da avaliação\n"
+"    de EXPR. As expressões podem ser unárias ou binárias. Expressões unárias\n"
 "    são normalmente usadas para examinar o status de um arquivo. Há\n"
 "    operadores de strings e também há operadores de comparação numérica.\n"
 "    \n"
@@ -4560,8 +4358,7 @@ msgstr ""
 "      -c ARQUIVO     Verdadeiro, se arquivo for um caractere especial.\n"
 "      -d ARQUIVO     Verdadeiro, se arquivo for um diretório.\n"
 "      -e ARQUIVO     Verdadeiro, se arquivo existir.\n"
-"      -f ARQUIVO     Verdadeiro, se arquivo existir e for um arquivo "
-"normal.\n"
+"      -f ARQUIVO     Verdadeiro, se arquivo existir e for um arquivo normal.\n"
 "      -g ARQUIVO     Verdadeiro, se arquivo for set-group-id.\n"
 "      -h ARQUIVO     Verdadeiro, se arquivo for um link simbólico.\n"
 "      -L ARQUIVO     Verdadeiro, se arquivo for um link simbólico.\n"
@@ -4612,20 +4409,16 @@ msgstr ""
 "                     e for uma referência de nome.\n"
 "      ! EXPR         Verdadeiro, se a expressão EXPR for falsa.\n"
 "      EXPR1 -a EXPR2 Verdadeiro, se ambas EXPR1 e EXPR2 forem verdadeiras.\n"
-"      EXPR1 -o EXPR2 Verdadeiro, se ao menos uma das expressões for "
-"verdadeira.\n"
+"      EXPR1 -o EXPR2 Verdadeiro, se ao menos uma das expressões for verdadeira.\n"
 "    \n"
-"      arg1 OP arg2   Testes aritméticos.  OP é um dentre -eq, -ne, -lt, -"
-"le,\n"
+"      arg1 OP arg2   Testes aritméticos.  OP é um dentre -eq, -ne, -lt, -le,\n"
 "                     -gt, or -ge.\n"
 "    \n"
-"    Operadores binários de aritmética retornam verdadeiro se ARG1 for "
-"igual,\n"
+"    Operadores binários de aritmética retornam verdadeiro se ARG1 for igual,\n"
 "    não-igual, menor-que, menor-ou-igual-a ou maior-ou-igual-a ARG2.\n"
 "    \n"
 "    Status de saída:\n"
-"    Retorna sucesso, se EXPR for avaliada como verdadeira; falha, se EXPR "
-"for\n"
+"    Retorna sucesso, se EXPR for avaliada como verdadeira; falha, se EXPR for\n"
 "    avaliada como falsa ou um argumento inválido for informado."
 
 # help [
@@ -4646,8 +4439,7 @@ msgstr ""
 msgid ""
 "Display process times.\n"
 "    \n"
-"    Prints the accumulated user and system times for the shell and all of "
-"its\n"
+"    Prints the accumulated user and system times for the shell and all of its\n"
 "    child processes.\n"
 "    \n"
 "    Exit Status:\n"
@@ -4666,8 +4458,7 @@ msgstr ""
 msgid ""
 "Trap signals and other events.\n"
 "    \n"
-"    Defines and activates handlers to be run when the shell receives "
-"signals\n"
+"    Defines and activates handlers to be run when the shell receives signals\n"
 "    or other conditions.\n"
 "    \n"
 "    ARG is a command to be read and executed when the shell receives the\n"
@@ -4676,34 +4467,26 @@ msgid ""
 "    value.  If ARG is the null string each SIGNAL_SPEC is ignored by the\n"
 "    shell and by the commands it invokes.\n"
 "    \n"
-"    If a SIGNAL_SPEC is EXIT (0) ARG is executed on exit from the shell.  "
-"If\n"
-"    a SIGNAL_SPEC is DEBUG, ARG is executed before every simple command.  "
-"If\n"
-"    a SIGNAL_SPEC is RETURN, ARG is executed each time a shell function or "
-"a\n"
-"    script run by the . or source builtins finishes executing.  A "
-"SIGNAL_SPEC\n"
-"    of ERR means to execute ARG each time a command's failure would cause "
-"the\n"
+"    If a SIGNAL_SPEC is EXIT (0) ARG is executed on exit from the shell.  If\n"
+"    a SIGNAL_SPEC is DEBUG, ARG is executed before every simple command.  If\n"
+"    a SIGNAL_SPEC is RETURN, ARG is executed each time a shell function or a\n"
+"    script run by the . or source builtins finishes executing.  A SIGNAL_SPEC\n"
+"    of ERR means to execute ARG each time a command's failure would cause the\n"
 "    shell to exit when the -e option is enabled.\n"
 "    \n"
-"    If no arguments are supplied, trap prints the list of commands "
-"associated\n"
+"    If no arguments are supplied, trap prints the list of commands associated\n"
 "    with each signal.\n"
 "    \n"
 "    Options:\n"
 "      -l\tprint a list of signal names and their corresponding numbers\n"
 "      -p\tdisplay the trap commands associated with each SIGNAL_SPEC\n"
 "    \n"
-"    Each SIGNAL_SPEC is either a signal name in <signal.h> or a signal "
-"number.\n"
+"    Each SIGNAL_SPEC is either a signal name in <signal.h> or a signal number.\n"
 "    Signal names are case insensitive and the SIG prefix is optional.  A\n"
 "    signal may be sent to the shell with \"kill -signal $$\".\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns success unless a SIGSPEC is invalid or an invalid option is "
-"given."
+"    Returns success unless a SIGSPEC is invalid or an invalid option is given."
 msgstr ""
 "Tratamento de sinais e outros eventos.\n"
 "    \n"
@@ -4769,8 +4552,7 @@ msgid ""
 "      NAME\tCommand name to be interpreted.\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns success if all of the NAMEs are found; fails if any are not "
-"found."
+"    Returns success if all of the NAMEs are found; fails if any are not found."
 msgstr ""
 "Exibe informação sobre o tipo de comando.\n"
 "    \n"
@@ -4801,12 +4583,10 @@ msgstr ""
 
 # help ulimit
 #: builtins.c:1431
-#, fuzzy
 msgid ""
 "Modify shell resource limits.\n"
 "    \n"
-"    Provides control over the resources available to the shell and "
-"processes\n"
+"    Provides control over the resources available to the shell and processes\n"
 "    it creates, on systems that allow such control.\n"
 "    \n"
 "    Options:\n"
@@ -4853,7 +4633,7 @@ msgstr ""
 "Modifica limites de recursos do shell.\n"
 "    \n"
 "    Fornece controle sobre os recursos disponíveis para o shell e\n"
-"    seus processos, em sistemas que permitem tal controle.\n"
+"    os processos que ele cria, em sistemas que permitem tal controle.\n"
 "    \n"
 "    Opções:\n"
 "      -S\tusa um limite `soft' de recursos\n"
@@ -4877,7 +4657,9 @@ msgstr ""
 "      -u\to número máximo de processos de usuário\n"
 "      -v\to tamanho de memória virtual\n"
 "      -x\to número máximo de travas de arquivos\n"
-"      -P\to número máximo de pseudo-terminais\n"
+"      -P\to número máximo de pseudoterminais\n"
+"      -R\to tempo máximo que um processo de tempo real pode executar\n"
+"              antes de ser bloqueado\n"
 "      -T\to número máximo de fluxos (threads)\n"
 "    \n"
 "    Nem todas as opções estão disponíveis em todas as plataformas.\n"
@@ -4934,27 +4716,22 @@ msgstr ""
 
 # help wait
 #: builtins.c:1502
-#, fuzzy
 msgid ""
 "Wait for job completion and return exit status.\n"
 "    \n"
-"    Waits for each process identified by an ID, which may be a process ID or "
-"a\n"
+"    Waits for each process identified by an ID, which may be a process ID or a\n"
 "    job specification, and reports its termination status.  If ID is not\n"
 "    given, waits for all currently active child processes, and the return\n"
 "    status is zero.  If ID is a job specification, waits for all processes\n"
 "    in that job's pipeline.\n"
 "    \n"
-"    If the -n option is supplied, waits for a single job from the list of "
-"IDs,\n"
-"    or, if no IDs are supplied, for the next job to complete and returns "
-"its\n"
+"    If the -n option is supplied, waits for a single job from the list of IDs,\n"
+"    or, if no IDs are supplied, for the next job to complete and returns its\n"
 "    exit status.\n"
 "    \n"
 "    If the -p option is supplied, the process or job identifier of the job\n"
 "    for which the exit status is returned is assigned to the variable VAR\n"
-"    named by the option argument. The variable will be unset initially, "
-"before\n"
+"    named by the option argument. The variable will be unset initially, before\n"
 "    any assignment. This is useful only when the -n option is supplied.\n"
 "    \n"
 "    If the -f option is supplied, and job control is enabled, waits for the\n"
@@ -4977,27 +4754,27 @@ msgstr ""
 "    Se a opção -n for fornecida, espera pelo próximo trabalho terminar e\n"
 "    retorna seu status de trabalho.\n"
 "    \n"
-"    Se a opção -f for fornecida, e o controle de trabalho estiver ativado,\n"
-"    espera o ID especificado terminar, em vez de esperar ele alterar o\n"
-"    status.\n"
+"    Se a opção -p for fornecida, o identificador de processo ou trabalho do\n"
+"    trabalho, ao qual o status de saída é retornado, é atribuído à variável\n"
+"    VAR nomeada pelo argumento da opção.A variável terá sua definição\n"
+"    removida inicialmente, antes de qualquer atribuição.Isso é útil quando.\n"
 "    \n"
 "    Status de saída:\n"
 "    Retorna o status do último ID; falha, se ID for inválido ou uma opção\n"
-"    inválida for fornecida."
+"    inválida for fornecida, ou se -n é fornecida e o shell possui nenhum\n"
+"    filho inesperado."
 
 # help wait
 #: builtins.c:1533
 msgid ""
 "Wait for process completion and return exit status.\n"
 "    \n"
-"    Waits for each process specified by a PID and reports its termination "
-"status.\n"
+"    Waits for each process specified by a PID and reports its termination status.\n"
 "    If PID is not given, waits for all currently active child processes,\n"
 "    and the return status is zero.  PID must be a process ID.\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns the status of the last PID; fails if PID is invalid or an "
-"invalid\n"
+"    Returns the status of the last PID; fails if PID is invalid or an invalid\n"
 "    option is given."
 msgstr ""
 "Espera por conclusão de processo e retorna o status de saída.\n"
@@ -5028,8 +4805,7 @@ msgstr ""
 "    \n"
 "    O loop `for' executa uma sequência de comandos para cada membro em\n"
 "    uma lista de itens. Se `in PALAVRAS ...;' não estiver presente, então\n"
-"    `in \"$@\"' é presumido. Para cada elemento em PALAVRAS, NOME é "
-"definido\n"
+"    `in \"$@\"' é presumido. Para cada elemento em PALAVRAS, NOME é definido\n"
 "    com aquele elemento e os COMANDOS são executados.\n"
 "    \n"
 "    Status de saída:\n"
@@ -5158,17 +4934,12 @@ msgstr ""
 msgid ""
 "Execute commands based on conditional.\n"
 "    \n"
-"    The `if COMMANDS' list is executed.  If its exit status is zero, then "
-"the\n"
-"    `then COMMANDS' list is executed.  Otherwise, each `elif COMMANDS' list "
-"is\n"
+"    The `if COMMANDS' list is executed.  If its exit status is zero, then the\n"
+"    `then COMMANDS' list is executed.  Otherwise, each `elif COMMANDS' list is\n"
 "    executed in turn, and if its exit status is zero, the corresponding\n"
-"    `then COMMANDS' list is executed and the if command completes.  "
-"Otherwise,\n"
-"    the `else COMMANDS' list is executed, if present.  The exit status of "
-"the\n"
-"    entire construct is the exit status of the last command executed, or "
-"zero\n"
+"    `then COMMANDS' list is executed and the if command completes.  Otherwise,\n"
+"    the `else COMMANDS' list is executed, if present.  The exit status of the\n"
+"    entire construct is the exit status of the last command executed, or zero\n"
 "    if no condition tested true.\n"
 "    \n"
 "    Exit Status:\n"
@@ -5255,8 +5026,7 @@ msgid ""
 "Define shell function.\n"
 "    \n"
 "    Create a shell function named NAME.  When invoked as a simple command,\n"
-"    NAME runs COMMANDs in the calling shell's context.  When NAME is "
-"invoked,\n"
+"    NAME runs COMMANDs in the calling shell's context.  When NAME is invoked,\n"
 "    the arguments are passed to the function as $1...$n, and the function's\n"
 "    name is in $FUNCNAME.\n"
 "    \n"
@@ -5319,7 +5089,6 @@ msgstr ""
 
 # help '(('
 #: builtins.c:1726
-#, fuzzy
 msgid ""
 "Evaluate arithmetic expression.\n"
 "    \n"
@@ -5332,7 +5101,7 @@ msgstr ""
 "Avalia expressões aritméticas.\n"
 "    \n"
 "    A EXPRESSÃO é avaliada de acordo com as regras de avaliação aritmética.\n"
-"    Equivalente a \"let EXPRESSÃO\".\n"
+"    Equivalente a `let \"EXPRESSÃO\"'.\n"
 "    \n"
 "    Status de saída:\n"
 "    Retorna 1, se EXPRESSÃO for avaliada como 0; do contrário, retorna 0."
@@ -5342,12 +5111,9 @@ msgstr ""
 msgid ""
 "Execute conditional command.\n"
 "    \n"
-"    Returns a status of 0 or 1 depending on the evaluation of the "
-"conditional\n"
-"    expression EXPRESSION.  Expressions are composed of the same primaries "
-"used\n"
-"    by the `test' builtin, and may be combined using the following "
-"operators:\n"
+"    Returns a status of 0 or 1 depending on the evaluation of the conditional\n"
+"    expression EXPRESSION.  Expressions are composed of the same primaries used\n"
+"    by the `test' builtin, and may be combined using the following operators:\n"
 "    \n"
 "      ( EXPRESSION )\tReturns the value of EXPRESSION\n"
 "      ! EXPRESSION\t\tTrue if EXPRESSION is false; else false\n"
@@ -5475,8 +5241,7 @@ msgstr ""
 "    OSTYPE\t\t\tA versão do Unix no qual Bash está sendo executado.\n"
 "    PATH\t\t\tUma lista separada por dois-pontos de diretórios para\n"
 "    \t\t\tpesquisar ao se procurar por comandos.\n"
-"    PROMPT_COMMAND\tUm comando a ser executado antes de imprimir cada "
-"prompt\n"
+"    PROMPT_COMMAND\tUm comando a ser executado antes de imprimir cada prompt\n"
 "    \t\t\tprimário.\n"
 "    PS1\t\t\t\tA string de prompt primário.\n"
 "    PS2\t\t\t\tA string de prompt secundária.\n"
@@ -5717,34 +5482,27 @@ msgid ""
 "      -v var\tassign the output to shell variable VAR rather than\n"
 "    \t\tdisplay it on the standard output\n"
 "    \n"
-"    FORMAT is a character string which contains three types of objects: "
-"plain\n"
-"    characters, which are simply copied to standard output; character "
-"escape\n"
+"    FORMAT is a character string which contains three types of objects: plain\n"
+"    characters, which are simply copied to standard output; character escape\n"
 "    sequences, which are converted and copied to the standard output; and\n"
-"    format specifications, each of which causes printing of the next "
-"successive\n"
+"    format specifications, each of which causes printing of the next successive\n"
 "    argument.\n"
 "    \n"
-"    In addition to the standard format specifications described in "
-"printf(1),\n"
+"    In addition to the standard format specifications described in printf(1),\n"
 "    printf interprets:\n"
 "    \n"
 "      %b\texpand backslash escape sequences in the corresponding argument\n"
 "      %q\tquote the argument in a way that can be reused as shell input\n"
-"      %(fmt)T\toutput the date-time string resulting from using FMT as a "
-"format\n"
+"      %(fmt)T\toutput the date-time string resulting from using FMT as a format\n"
 "    \t        string for strftime(3)\n"
 "    \n"
 "    The format is re-used as necessary to consume all of the arguments.  If\n"
 "    there are fewer arguments than the format requires,  extra format\n"
-"    specifications behave as if a zero value or null string, as "
-"appropriate,\n"
+"    specifications behave as if a zero value or null string, as appropriate,\n"
 "    had been supplied.\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns success unless an invalid option is given or a write or "
-"assignment\n"
+"    Returns success unless an invalid option is given or a write or assignment\n"
 "    error occurs."
 msgstr ""
 "Formata e imprime ARGUMENTOS sob controle de FORMATO.\n"
@@ -5780,14 +5538,11 @@ msgstr ""
 
 # help complete
 #: builtins.c:1971
-#, fuzzy
 msgid ""
 "Specify how arguments are to be completed by Readline.\n"
 "    \n"
-"    For each NAME, specify how arguments are to be completed.  If no "
-"options\n"
-"    are supplied, existing completion specifications are printed in a way "
-"that\n"
+"    For each NAME, specify how arguments are to be completed.  If no options\n"
+"    are supplied, existing completion specifications are printed in a way that\n"
 "    allows them to be reused as input.\n"
 "    \n"
 "    Options:\n"
@@ -5802,10 +5557,8 @@ msgid ""
 "    \t\tcommand) word\n"
 "    \n"
 "    When completion is attempted, the actions are applied in the order the\n"
-"    uppercase-letter options are listed above. If multiple options are "
-"supplied,\n"
-"    the -D option takes precedence over -E, and both take precedence over -"
-"I.\n"
+"    uppercase-letter options are listed above. If multiple options are supplied,\n"
+"    the -D option takes precedence over -E, and both take precedence over -I.\n"
 "    \n"
 "    Exit Status:\n"
 "    Returns success unless an invalid option is supplied or an error occurs."
@@ -5817,21 +5570,18 @@ msgstr ""
 "    impressas em uma forma que permite-as serem usadas como entrada.\n"
 "    \n"
 "    Opções:\n"
-"      -p\timprime especificações existentes de completar em um formato "
-"usável\n"
-"      -r\tremove uma especificação de completar para cada NOME ou, se "
-"nenhum\n"
-"      \t\tNOME for fornecido, todas as especificações de completar\n"
+"      -p\timprime especificações existentes de completar em um formato usável\n"
+"      -r\tremove uma especificação de completar para cada NOME ou, se nenhum\n"
+"    \t\tNOME for fornecido, todas as especificações de completar\n"
 "      -D\taplica as completações e ações como sendo o padrão para comandos\n"
-"      \t\tsem qualquer especificação definida\n"
+"    \t\tsem qualquer especificação definida\n"
 "      -E\taplica as completações e ações para tentativa de completar\n"
-"      \t\tcomandos -- \"vazios\" em uma linha vazia\n"
+"    \t\tcomandos -- \"vazios\" em uma linha vazia\n"
 "      -I\taplica completações e ações para a palavra inicial (geralmente o\n"
 "    \t\tcomando)\n"
 "    \n"
 "    Ao tentar completar, as ações são fornecidas na ordem em que as opções\n"
-"    de letras de caixa alta são listadas acima. Se várias opções forem "
-"fornecidas,\n"
+"    de letras de caixa alta são listadas acima. Se várias opções forem fornecidas,\n"
 "    a opção -D tem precedência sobre -E, e ambos têm precedência sobre -I.\n"
 "    sobre -E.\n"
 "    \n"
@@ -5845,8 +5595,7 @@ msgid ""
 "Display possible completions depending on the options.\n"
 "    \n"
 "    Intended to be used from within a shell function generating possible\n"
-"    completions.  If the optional WORD argument is supplied, matches "
-"against\n"
+"    completions.  If the optional WORD argument is supplied, matches against\n"
 "    WORD are generated.\n"
 "    \n"
 "    Exit Status:\n"
@@ -5867,12 +5616,9 @@ msgstr ""
 msgid ""
 "Modify or display completion options.\n"
 "    \n"
-"    Modify the completion options for each NAME, or, if no NAMEs are "
-"supplied,\n"
-"    the completion currently being executed.  If no OPTIONs are given, "
-"print\n"
-"    the completion options for each NAME or the current completion "
-"specification.\n"
+"    Modify the completion options for each NAME, or, if no NAMEs are supplied,\n"
+"    the completion currently being executed.  If no OPTIONs are given, print\n"
+"    the completion options for each NAME or the current completion specification.\n"
 "    \n"
 "    Options:\n"
 "    \t-o option\tSet completion option OPTION for each NAME\n"
@@ -5902,7 +5648,7 @@ msgstr ""
 "    especificação de completação atual.\n"
 "    \n"
 "    Opções:\n"
-"    \t-o OPÇÃO\tDefine a opção de completação OPÇÃO para cada NOME\n"
+"    \t-o opção\tDefine a opção de completação OPÇÃO para cada NOME\n"
 "    \t-D\t\tAltera opções para a completação de comando \"padrão\"\n"
 "    \t-E\t\tAltera opções para a completação de comando \"vazio\"\n"
 "    \t-I\t\tAltera as opções para completação na palavra inicial\n"
@@ -5927,22 +5673,17 @@ msgstr ""
 msgid ""
 "Read lines from the standard input into an indexed array variable.\n"
 "    \n"
-"    Read lines from the standard input into the indexed array variable "
-"ARRAY, or\n"
-"    from file descriptor FD if the -u option is supplied.  The variable "
-"MAPFILE\n"
+"    Read lines from the standard input into the indexed array variable ARRAY, or\n"
+"    from file descriptor FD if the -u option is supplied.  The variable MAPFILE\n"
 "    is the default ARRAY.\n"
 "    \n"
 "    Options:\n"
 "      -d delim\tUse DELIM to terminate lines, instead of newline\n"
-"      -n count\tCopy at most COUNT lines.  If COUNT is 0, all lines are "
-"copied\n"
-"      -O origin\tBegin assigning to ARRAY at index ORIGIN.  The default "
-"index is 0\n"
+"      -n count\tCopy at most COUNT lines.  If COUNT is 0, all lines are copied\n"
+"      -O origin\tBegin assigning to ARRAY at index ORIGIN.  The default index is 0\n"
 "      -s count\tDiscard the first COUNT lines read\n"
 "      -t\tRemove a trailing DELIM from each line read (default newline)\n"
-"      -u fd\tRead lines from file descriptor FD instead of the standard "
-"input\n"
+"      -u fd\tRead lines from file descriptor FD instead of the standard input\n"
 "      -C callback\tEvaluate CALLBACK each time QUANTUM lines are read\n"
 "      -c quantum\tSpecify the number of lines read between each call to\n"
 "    \t\t\tCALLBACK\n"
@@ -5955,13 +5696,11 @@ msgid ""
 "    element to be assigned and the line to be assigned to that element\n"
 "    as additional arguments.\n"
 "    \n"
-"    If not supplied with an explicit origin, mapfile will clear ARRAY "
-"before\n"
+"    If not supplied with an explicit origin, mapfile will clear ARRAY before\n"
 "    assigning to it.\n"
 "    \n"
 "    Exit Status:\n"
-"    Returns success unless an invalid option is given or ARRAY is readonly "
-"or\n"
+"    Returns success unless an invalid option is given or ARRAY is readonly or\n"
 "    not an indexed array."
 msgstr ""
 "Lê linhas da entrada padrão para uma variável array indexado.\n"
@@ -5971,29 +5710,24 @@ msgstr ""
 "    MAPFILE é o ARRAY padrão.\n"
 "    \n"
 "    Opções:\n"
-"      -d DELIM      Usa DELIM para terminar linhas, ao invés de nova linha\n"
-"      -n NÚMERO     Copia no máximo NÚMERO linhas. Se NÚMERO for 0, todas "
-"as\n"
+"      -d dlim      Usa DELIM para terminar linhas, ao invés de nova linha\n"
+"      -n número     Copia no máximo NÚMERO linhas. Se NÚMERO for 0, todas as\n"
 "                    linhas são copiadas\n"
-"      -O ORIGEM     Inicia atribuição de ARRAY no índice ORIGEM. O índice\n"
+"      -O origem     Inicia atribuição de ARRAY no índice ORIGEM. O índice\n"
 "                    padrão é 0\n"
-"      -s NÚMERO     Descarta as primeiras NÚMERO linhas lidas\n"
+"      -s número     Descarta as primeiras NÚMERO linhas lidas\n"
 "      -t            Remove uma DELIM ao final para cada linha lida\n"
 "                    (padrão: nova linha)\n"
-"      -u FD         Lê linhas do descritor de arquivos FD, ao invés da "
-"entrada\n"
+"      -u fd         Lê linhas do descritor de arquivos FD, ao invés da entrada\n"
 "                    padrão\n"
-"      -C CHAMADA    Avalia CHAMADA a cada vez que QUANTIDADE linhas foram "
-"lidas\n"
-"      -c QUANTIDADE Especifica o número de linhas lidas entre cada chamada "
-"para\n"
+"      -C chamada    Avalia CHAMADA a cada vez que QUANTIDADE linhas foram lidas\n"
+"      -c quantidade Especifica o número de linhas lidas entre cada chamada para\n"
 "                    CHAMADA\n"
 "    \n"
 "    Argumentos:\n"
 "      ARRAY         Nome da variável array para usar para arquivos de dados\n"
 "    \n"
-"    Se -C for fornecido sem -c, a quantidade padrão é 5000. Quando CHAMADA "
-"é\n"
+"    Se -C for fornecido sem -c, a quantidade padrão é 5000. Quando CHAMADA é\n"
 "    avaliada, é fornecido o índice para o próximo elemento da array ser\n"
 "    atribuído e a linha para ser atribuída àquele elemento como argumentos\n"
 "    adicionais\n"
@@ -6090,12 +5824,9 @@ msgstr ""
 #~ "    If FILENAME is given, it is used as the history file.  Otherwise,\n"
 #~ "    if HISTFILE has a value, that is used, else ~/.bash_history.\n"
 #~ "    \n"
-#~ "    If the HISTTIMEFORMAT variable is set and not null, its value is "
-#~ "used\n"
-#~ "    as a format string for strftime(3) to print the time stamp "
-#~ "associated\n"
-#~ "    with each displayed history entry.  No time stamps are printed "
-#~ "otherwise.\n"
+#~ "    If the HISTTIMEFORMAT variable is set and not null, its value is used\n"
+#~ "    as a format string for strftime(3) to print the time stamp associated\n"
+#~ "    with each displayed history entry.  No time stamps are printed otherwise.\n"
 #~ "    \n"
 #~ "    Exit Status:\n"
 #~ "    Returns success unless an invalid option is given or an error occurs."
@@ -6121,16 +5852,12 @@ msgstr ""
 #~ "      -s\t\t\tanexa os ARGs à lista de histórico como uma única entrada\n"
 #~ "    \n"
 #~ "    Se ARQUIVO for fornecido, ele é usado como o arquivo de histórico.\n"
-#~ "    Do contrário, se a variável HISTFILE tiver um valor, este será "
-#~ "usado;\n"
+#~ "    Do contrário, se a variável HISTFILE tiver um valor, este será usado;\n"
 #~ "    senão, usa de ~/.bash_history.\n"
 #~ "    \n"
-#~ "    Se a variável HISTTIMEFORMAT for definida e não for nula, seu valor "
-#~ "é\n"
-#~ "    usado como uma string de formato para strftime(3) para mostrar a "
-#~ "marca\n"
-#~ "    de tempo associada com cada entrada de histórico exibida. Do "
-#~ "contrário,\n"
+#~ "    Se a variável HISTTIMEFORMAT for definida e não for nula, seu valor é\n"
+#~ "    usado como uma string de formato para strftime(3) para mostrar a marca\n"
+#~ "    de tempo associada com cada entrada de histórico exibida. Do contrário,\n"
 #~ "    nenhuma marca de tempo é mostrada.\n"
 #~ "    \n"
 #~ "    Status de saída:\n"
@@ -6151,10 +5878,8 @@ msgstr ""
 #~ "      -l\tlist the signal names; if arguments follow `-l' they are\n"
 #~ "    \t\tassumed to be signal numbers for which names should be listed\n"
 #~ "    \n"
-#~ "    Kill is a shell builtin for two reasons: it allows job IDs to be "
-#~ "used\n"
-#~ "    instead of process IDs, and allows processes to be killed if the "
-#~ "limit\n"
+#~ "    Kill is a shell builtin for two reasons: it allows job IDs to be used\n"
+#~ "    instead of process IDs, and allows processes to be killed if the limit\n"
 #~ "    on processes that you can create is reached.\n"
 #~ "    \n"
 #~ "    Exit Status:\n"
@@ -6212,8 +5937,7 @@ msgstr ""
 #~ "              history      enable command history\n"
 #~ "              ignoreeof    the shell will not exit upon reading EOF\n"
 #~ "              interactive-comments\n"
-#~ "                           allow comments to appear in interactive "
-#~ "commands\n"
+#~ "                           allow comments to appear in interactive commands\n"
 #~ "              keyword      same as -k\n"
 #~ "              monitor      same as -m\n"
 #~ "              noclobber    same as -C\n"
@@ -6224,12 +5948,9 @@ msgstr ""
 #~ "              nounset      same as -u\n"
 #~ "              onecmd       same as -t\n"
 #~ "              physical     same as -P\n"
-#~ "              pipefail     the return value of a pipeline is the status "
-#~ "of\n"
-#~ "                           the last command to exit with a non-zero "
-#~ "status,\n"
-#~ "                           or zero if no command exited with a non-zero "
-#~ "status\n"
+#~ "              pipefail     the return value of a pipeline is the status of\n"
+#~ "                           the last command to exit with a non-zero status,\n"
+#~ "                           or zero if no command exited with a non-zero status\n"
 #~ "              posix        change the behavior of bash where the default\n"
 #~ "                           operation differs from the Posix standard to\n"
 #~ "                           match the standard\n"
@@ -6237,11 +5958,9 @@ msgstr ""
 #~ "              verbose      same as -v\n"
 #~ "              vi           use a vi-style line editing interface\n"
 #~ "              xtrace       same as -x\n"
-#~ "      -p  Turned on whenever the real and effective user ids do not "
-#~ "match.\n"
+#~ "      -p  Turned on whenever the real and effective user ids do not match.\n"
 #~ "          Disables processing of the $ENV file and importing of shell\n"
-#~ "          functions.  Turning this option off causes the effective uid "
-#~ "and\n"
+#~ "          functions.  Turning this option off causes the effective uid and\n"
 #~ "          gid to be set to the real uid and gid.\n"
 #~ "      -t  Exit after reading and executing one command.\n"
 #~ "      -u  Treat unset variables as an error when substituting.\n"
@@ -6264,32 +5983,26 @@ msgstr ""
 #~ "    \n"
 #~ "    Using + rather than - causes these flags to be turned off.  The\n"
 #~ "    flags can also be used upon invocation of the shell.  The current\n"
-#~ "    set of flags may be found in $-.  The remaining n ARGs are "
-#~ "positional\n"
+#~ "    set of flags may be found in $-.  The remaining n ARGs are positional\n"
 #~ "    parameters and are assigned, in order, to $1, $2, .. $n.  If no\n"
 #~ "    ARGs are given, all shell variables are printed.\n"
 #~ "    \n"
 #~ "    Exit Status:\n"
 #~ "    Returns success unless an invalid option is given."
 #~ msgstr ""
-#~ "Define ou remove definição de valores das opções e dos parâmetros "
-#~ "posicionais\n"
+#~ "Define ou remove definição de valores das opções e dos parâmetros posicionais\n"
 #~ "do shell:\n"
 #~ "    \n"
-#~ "    Altera o valor de opções e de parâmetros posicionais do shell ou "
-#~ "mostra\n"
+#~ "    Altera o valor de opções e de parâmetros posicionais do shell ou mostra\n"
 #~ "    os nomes ou valores de variáveis shell.\n"
 #~ "    \n"
 #~ "    Opções:\n"
-#~ "      -a  Marca variáveis, que foram modificadas ou criadas, para "
-#~ "exportação.\n"
+#~ "      -a  Marca variáveis, que foram modificadas ou criadas, para exportação.\n"
 #~ "      -b  Notifica sobre terminação de trabalho imediatamente.\n"
 #~ "      -e  Sai imediatamente se um comando sai com um status não-zero.\n"
 #~ "      -f  Desabilita a geração de nome de arquivo (\"globbing\").\n"
-#~ "      -h  Memoriza a localização de comandos à medida em que são "
-#~ "procurados.\n"
-#~ "      -k  Todos argumentos de atribuição são colocados no ambiente para "
-#~ "um\n"
+#~ "      -h  Memoriza a localização de comandos à medida em que são procurados.\n"
+#~ "      -k  Todos argumentos de atribuição são colocados no ambiente para um\n"
 #~ "          comando, e não apenas aqueles que precedem o nome do comando.\n"
 #~ "      -m  Controle de trabalho está habilitado.\n"
 #~ "      -n  Lê comandos, mas não os executa.\n"
@@ -6306,8 +6019,7 @@ msgstr ""
 #~ "              history      habilita histórico de comandos\n"
 #~ "              ignoreeof    shell não vai sair após leitura de EOF\n"
 #~ "              interactive-comments\n"
-#~ "                           permite mostrar comentários em comandos "
-#~ "interativos\n"
+#~ "                           permite mostrar comentários em comandos interativos\n"
 #~ "              keyword      mesmo que -k\n"
 #~ "              monitor      mesmo que -m\n"
 #~ "              noclobber    mesmo que -C\n"
@@ -6318,61 +6030,43 @@ msgstr ""
 #~ "              nounset      mesmo que -u\n"
 #~ "              onecmd       mesmo que -t\n"
 #~ "              physical     mesmo que -P\n"
-#~ "              pipefail     o valor de retorno de uma linha de comandos é "
-#~ "o\n"
-#~ "                           status do último comando a sair com status não-"
-#~ "zero,\n"
-#~ "                           ou zero se nenhum comando saiu com status não "
-#~ "zero\n"
-#~ "              posix        altera o comportamento do bash, onde a "
-#~ "operação\n"
+#~ "              pipefail     o valor de retorno de uma linha de comandos é o\n"
+#~ "                           status do último comando a sair com status não-zero,\n"
+#~ "                           ou zero se nenhum comando saiu com status não zero\n"
+#~ "              posix        altera o comportamento do bash, onde a operação\n"
 #~ "                           padrão diverge dos padrões do Posix para\n"
 #~ "                           corresponder a estes padrões\n"
 #~ "              privileged   mesmo que -p\n"
 #~ "              verbose      mesmo que -v\n"
 #~ "              vi           usa interface de edição de linha estilo vi\n"
 #~ "              xtrace       mesmo que -x\n"
-#~ "      -p  Ligado sempre que IDs de usuário real e efetivo não "
-#~ "corresponderem.\n"
-#~ "          Desabilita processamento do arquivo $ENV e importação de "
-#~ "funções da\n"
-#~ "          shell. Ao desligar essa opção, causa o uid e o gid efetivo "
-#~ "serem\n"
+#~ "      -p  Ligado sempre que IDs de usuário real e efetivo não corresponderem.\n"
+#~ "          Desabilita processamento do arquivo $ENV e importação de funções da\n"
+#~ "          shell. Ao desligar essa opção, causa o uid e o gid efetivo serem\n"
 #~ "          os uid e gid reais.\n"
 #~ "      -t  Sai após a leitura e execução de um comando.\n"
-#~ "      -u  Trata limpeza (unset) de variáveis como um erro quando "
-#~ "substituindo.\n"
-#~ "      -v  Mostra linhas de entrada do shell na medida em que forem "
-#~ "lidas.\n"
-#~ "      -x  Mostra comandos e seus argumentos na medida em que forme "
-#~ "executados.\n"
+#~ "      -u  Trata limpeza (unset) de variáveis como um erro quando substituindo.\n"
+#~ "      -v  Mostra linhas de entrada do shell na medida em que forem lidas.\n"
+#~ "      -x  Mostra comandos e seus argumentos na medida em que forme executados.\n"
 #~ "      -B  o shell vai realizar expansão de chaves\n"
 #~ "      -C  Se definido, não permite arquivos normais existentes serem\n"
 #~ "          sobrescritos por redirecionamento da saída.\n"
 #~ "      -E  Se definido, a armadilha ERR é herdada por funções do shell.\n"
-#~ "      -H  Habilita substituição de histórico estilo \"!\". Essa "
-#~ "sinalização está\n"
+#~ "      -H  Habilita substituição de histórico estilo \"!\". Essa sinalização está\n"
 #~ "          habilitada por padrão quando  shell é interativa.\n"
-#~ "      -P  Se definida, não resolve links simbólicos ao sair de comandos, "
-#~ "tais\n"
+#~ "      -P  Se definida, não resolve links simbólicos ao sair de comandos, tais\n"
 #~ "          como `cd' (que altera o diretório atual).\n"
 #~ "      -T  Se definido, a armadilha DEBUG é herdada por funções do shell.\n"
-#~ "      --  Atribui quaisquer argumentos restantes aos parâmetros "
-#~ "posicionais.\n"
-#~ "          Se não houver argumentos restantes, os parâmetros posicionais "
-#~ "são\n"
+#~ "      --  Atribui quaisquer argumentos restantes aos parâmetros posicionais.\n"
+#~ "          Se não houver argumentos restantes, os parâmetros posicionais são\n"
 #~ "          limpos (unset).\n"
-#~ "      -   Atribui quaisquer argumentos restantes aos parâmetros "
-#~ "posicionais.\n"
+#~ "      -   Atribui quaisquer argumentos restantes aos parâmetros posicionais.\n"
 #~ "          As opções -x e -v são desligadas.\n"
 #~ "    \n"
 #~ "    Usar +, ao invés de -, causa essas sinalizações serem desligadas. As\n"
-#~ "    sinalizações também podem ser usadas por meio de chamada do shell. "
-#~ "As\n"
-#~ "    sinalizações atualmente definidas podem ser encontradas em $-. Os n "
-#~ "ARGs\n"
-#~ "    restantes são parâmetros posicionais e são atribuídos, em ordem, a "
-#~ "$1, $2,\n"
+#~ "    sinalizações também podem ser usadas por meio de chamada do shell. As\n"
+#~ "    sinalizações atualmente definidas podem ser encontradas em $-. Os n ARGs\n"
+#~ "    restantes são parâmetros posicionais e são atribuídos, em ordem, a $1, $2,\n"
 #~ "    .. $n. Se nenhuma ARG for fornecido, todas as variáveis shell são\n"
 #~ "    mostradas.\n"
 #~ "    \n"
@@ -6383,10 +6077,8 @@ msgstr ""
 #~ msgid ""
 #~ "Create a coprocess named NAME.\n"
 #~ "    \n"
-#~ "    Execute COMMAND asynchronously, with the standard output and "
-#~ "standard\n"
-#~ "    input of the command connected via a pipe to file descriptors "
-#~ "assigned\n"
+#~ "    Execute COMMAND asynchronously, with the standard output and standard\n"
+#~ "    input of the command connected via a pipe to file descriptors assigned\n"
 #~ "    to indices 0 and 1 of an array variable NAME in the executing shell.\n"
 #~ "    The default NAME is \"COPROC\".\n"
 #~ "    \n"
@@ -6396,8 +6088,7 @@ msgstr ""
 #~ "Cria um coprocesso chamado NOME.\n"
 #~ "    \n"
 #~ "    Executa COMANDO assincronamente, com a saída padrão e entrada padrão\n"
-#~ "    do comando conectados via um `pipe' (redirecionamento) para "
-#~ "descritores\n"
+#~ "    do comando conectados via um `pipe' (redirecionamento) para descritores\n"
 #~ "    de arquivo atribuídos para índices 0 e 1 de uma variável array NOME\n"
 #~ "    no shell em execução. O NOME padrão é \"COPROC\".\n"
 #~ "    \n"
@@ -6520,8 +6211,7 @@ msgstr ""
 #~ msgstr "substituição de comando"
 
 #~ msgid "Can't reopen pipe to command substitution (fd %d): %s"
-#~ msgstr ""
-#~ "Impossível reabrir o `pipe' para substituição de comando (fd %d): %s"
+#~ msgstr "Impossível reabrir o `pipe' para substituição de comando (fd %d): %s"
 
 #~ msgid "$%c: unbound variable"
 #~ msgstr "$%c: variável não associada"
@@ -6605,8 +6295,7 @@ msgstr ""
 #~ msgstr "de aliases na forma `alias NOME=VALOR' na saída padrão."
 
 #~ msgid "Otherwise, an alias is defined for each NAME whose VALUE is given."
-#~ msgstr ""
-#~ "Ou então, um alias é definido para cada NOME cujo VALOR for fornecido."
+#~ msgstr "Ou então, um alias é definido para cada NOME cujo VALOR for fornecido."
 
 #~ msgid "A trailing space in VALUE causes the next word to be checked for"
 #~ msgstr "Um espaço após VALOR faz a próxima palavra ser verificada para"
@@ -6615,45 +6304,34 @@ msgstr ""
 #~ msgstr "substituição do alias quando o alias é expandido. Alias retorna"
 
 #~ msgid "true unless a NAME is given for which no alias has been defined."
-#~ msgstr ""
-#~ "verdadeiro, a não ser que seja fornecido um NOME sem alias definido."
+#~ msgstr "verdadeiro, a não ser que seja fornecido um NOME sem alias definido."
 
-#~ msgid ""
-#~ "Remove NAMEs from the list of defined aliases.  If the -a option is given,"
-#~ msgstr ""
-#~ "Remove NOMEs da lista de aliases definidos. Se a opção -a for fornecida,"
+#~ msgid "Remove NAMEs from the list of defined aliases.  If the -a option is given,"
+#~ msgstr "Remove NOMEs da lista de aliases definidos. Se a opção -a for fornecida,"
 
 #~ msgid "then remove all alias definitions."
 #~ msgstr "então todas as definições de alias são removidas."
 
 #~ msgid "Bind a key sequence to a Readline function, or to a macro.  The"
-#~ msgstr ""
-#~ "Víncula uma seqüência de teclas a uma função de leitura de linha, ou a uma"
+#~ msgstr "Víncula uma sequência de teclas a uma função de leitura de linha, ou a uma"
 
 #~ msgid "syntax is equivalent to that found in ~/.inputrc, but must be"
-#~ msgstr ""
-#~ "macro.  A sintaxe é equivalente à encontrada em ~/.inputrc, mas deve ser"
+#~ msgstr "macro.  A sintaxe é equivalente à encontrada em ~/.inputrc, mas deve ser"
 
-#~ msgid ""
-#~ "passed as a single argument: bind '\"\\C-x\\C-r\": re-read-init-file'."
-#~ msgstr ""
-#~ "passada como um único argumento: bind '\"\\C-x\\C-r\": re-read-init-file'."
+#~ msgid "passed as a single argument: bind '\"\\C-x\\C-r\": re-read-init-file'."
+#~ msgstr "passada como um único argumento: bind '\"\\C-x\\C-r\": re-read-init-file'."
 
 #~ msgid "Arguments we accept:"
 #~ msgstr "Argumentos permitidos:"
 
-#~ msgid ""
-#~ "  -m  keymap         Use `keymap' as the keymap for the duration of this"
-#~ msgstr ""
-#~ "  -m  MAPA-TECLAS    Usar `MAPA-TECLAS' como mapa das teclas pela duração"
+#~ msgid "  -m  keymap         Use `keymap' as the keymap for the duration of this"
+#~ msgstr "  -m  MAPA-TECLAS    Usar `MAPA-TECLAS' como mapa das teclas pela duração"
 
 #~ msgid "                     command.  Acceptable keymap names are emacs,"
 #~ msgstr "                     deste comando.  Os nomes aceitos são emacs,"
 
-#~ msgid ""
-#~ "                     emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,"
-#~ msgstr ""
-#~ "                     emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,"
+#~ msgid "                     emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,"
+#~ msgstr "                     emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,"
 
 #~ msgid "                     vi-command, and vi-insert."
 #~ msgstr "                     vi-command, and vi-insert."
@@ -6664,10 +6342,8 @@ msgstr ""
 #~ msgid "  -P                 List function names and bindings."
 #~ msgstr "  -P                 Listar nomes e associações das funções."
 
-#~ msgid ""
-#~ "  -p                 List functions and bindings in a form that can be"
-#~ msgstr ""
-#~ "  -p                 Listar nomes e associações das funções de uma forma"
+#~ msgid "  -p                 List functions and bindings in a form that can be"
+#~ msgstr "  -p                 Listar nomes e associações das funções de uma forma"
 
 #~ msgid "                     reused as input."
 #~ msgstr "                     que pode ser reutilizada como entrada."
@@ -6678,32 +6354,25 @@ msgstr ""
 #~ msgid "  -f  filename       Read key bindings from FILENAME."
 #~ msgstr "  -f  ARQUIVO        Ler os vínculos das teclas em ARQUIVO."
 
-#~ msgid ""
-#~ "  -q  function-name  Query about which keys invoke the named function."
+#~ msgid "  -q  function-name  Query about which keys invoke the named function."
 #~ msgstr "  -q  NOME-FUNÇÃO    Consultar quais teclas chamam esta função."
 
 #~ msgid "  -V                 List variable names and values"
 #~ msgstr "  -V                 Listar os nomes e os valores das variáveis."
 
-#~ msgid ""
-#~ "  -v                 List variable names and values in a form that can"
-#~ msgstr ""
-#~ "  -v                 Listar os nomes e os valores das variáveis de uma"
+#~ msgid "  -v                 List variable names and values in a form that can"
+#~ msgstr "  -v                 Listar os nomes e os valores das variáveis de uma"
 
 #~ msgid "                     be reused as input."
 #~ msgstr "                     forma que pode ser reutilizada como entrada."
 
-#~ msgid ""
-#~ "  -S                 List key sequences that invoke macros and their "
-#~ "values"
+#~ msgid "  -S                 List key sequences that invoke macros and their values"
 #~ msgstr ""
-#~ "  -S                 Listar as seqüências de teclas que chamam macros\n"
+#~ "  -S                 Listar as sequências de teclas que chamam macros\n"
 #~ "                         e seus valores."
 
-#~ msgid ""
-#~ "  -s                 List key sequences that invoke macros and their "
-#~ "values in"
-#~ msgstr "  -s                 Listar seqüências de teclas que chamam macros"
+#~ msgid "  -s                 List key sequences that invoke macros and their values in"
+#~ msgstr "  -s                 Listar sequências de teclas que chamam macros"
 
 #~ msgid "                     a form that can be reused as input."
 #~ msgstr ""
@@ -6723,8 +6392,7 @@ msgstr ""
 #~ msgstr "Se N for especificado, prossegue no N-ésimo laço envolvente."
 
 #~ msgid "Run a shell builtin.  This is useful when you wish to rename a"
-#~ msgstr ""
-#~ "Executa um comando interno do shell.  Útil quando desejamos substituir"
+#~ msgstr "Executa um comando interno do shell.  Útil quando desejamos substituir"
 
 #~ msgid "shell builtin to be a function, but need the functionality of the"
 #~ msgstr "um comando interno do shell por uma função, mas necessitamos da"
@@ -6739,12 +6407,10 @@ msgstr ""
 #~ msgstr "para DIR.  A variável $CDPATH define o caminho de procura para"
 
 #~ msgid "the directory containing DIR.  Alternative directory names in CDPATH"
-#~ msgstr ""
-#~ "o diretório que contém DIR.  Nomes de diretórios alternativos em CDPATH"
+#~ msgstr "o diretório que contém DIR.  Nomes de diretórios alternativos em CDPATH"
 
 #~ msgid "are separated by a colon (:).  A null directory name is the same as"
-#~ msgstr ""
-#~ "são separados por dois pontos (:).  Um nome de diretório nulo é o mesmo"
+#~ msgstr "são separados por dois pontos (:).  Um nome de diretório nulo é o mesmo"
 
 #~ msgid "the current directory, i.e. `.'.  If DIR begins with a slash (/),"
 #~ msgstr "que o diretório atual, i.e. `.'.  Se DIR inicia com uma barra (/),"
@@ -6753,20 +6419,15 @@ msgstr ""
 #~ msgstr "então $CDPATH não é usado.  Se o diretório não for encontrado, e a"
 
 #~ msgid "shell option `cdable_vars' is set, then try the word as a variable"
-#~ msgstr ""
-#~ "opção `cdable_vars' estiver definida, tentar usar DIR como um nome de"
+#~ msgstr "opção `cdable_vars' estiver definida, tentar usar DIR como um nome de"
 
 #~ msgid "name.  If that variable has a value, then cd to the value of that"
-#~ msgstr ""
-#~ "variável.  Se esta variável tiver valor, então `cd' para o valor desta"
+#~ msgstr "variável.  Se esta variável tiver valor, então `cd' para o valor desta"
 
-#~ msgid ""
-#~ "variable.  The -P option says to use the physical directory structure"
-#~ msgstr ""
-#~ "variável.  A opção -P indica para usar a estrutura física do diretório"
+#~ msgid "variable.  The -P option says to use the physical directory structure"
+#~ msgstr "variável.  A opção -P indica para usar a estrutura física do diretório"
 
-#~ msgid ""
-#~ "instead of following symbolic links; the -L option forces symbolic links"
+#~ msgid "instead of following symbolic links; the -L option forces symbolic links"
 #~ msgstr "em vez de seguir os vínculos simbólicos; a opção -L força seguir os"
 
 #~ msgid "to be followed."
@@ -6781,27 +6442,19 @@ msgstr ""
 #~ msgid "makes pwd follow symbolic links."
 #~ msgstr "com que `pwd' siga os vínculos simbólicos."
 
-#~ msgid ""
-#~ "Runs COMMAND with ARGS ignoring shell functions.  If you have a shell"
-#~ msgstr ""
-#~ "Executa COMANDO com ARGs ignorando as funções da shell.  Ex: Havendo"
+#~ msgid "Runs COMMAND with ARGS ignoring shell functions.  If you have a shell"
+#~ msgstr "Executa COMANDO com ARGs ignorando as funções da shell.  Ex: Havendo"
 
 #~ msgid "function called `ls', and you wish to call the command `ls', you can"
-#~ msgstr ""
-#~ "uma função `ls', e se for necessário executar o comando `ls', executa-se"
+#~ msgstr "uma função `ls', e se for necessário executar o comando `ls', executa-se"
 
-#~ msgid ""
-#~ "say \"command ls\".  If the -p option is given, a default value is used"
-#~ msgstr ""
-#~ "\"command ls\".  Se a opção -p for fornecida, o valor padrão é utilizado"
+#~ msgid "say \"command ls\".  If the -p option is given, a default value is used"
+#~ msgstr "\"command ls\".  Se a opção -p for fornecida, o valor padrão é utilizado"
 
-#~ msgid ""
-#~ "for PATH that is guaranteed to find all of the standard utilities.  If"
-#~ msgstr ""
-#~ "para PATH, garantindo-se o encontro de todos os utilitários padrão. Se"
+#~ msgid "for PATH that is guaranteed to find all of the standard utilities.  If"
+#~ msgstr "para PATH, garantindo-se o encontro de todos os utilitários padrão. Se"
 
-#~ msgid ""
-#~ "the -V or -v option is given, a string is printed describing COMMAND."
+#~ msgid "the -V or -v option is given, a string is printed describing COMMAND."
 #~ msgstr "a opção -V ou -v for fornecida, é exibida a descrição do COMANDO."
 
 #~ msgid "The -V option produces a more verbose description."
@@ -6852,8 +6505,7 @@ msgstr ""
 #~ msgid "name only."
 #~ msgstr "somente."
 
-#~ msgid ""
-#~ "Using `+' instead of `-' turns off the given attribute instead.  When"
+#~ msgid "Using `+' instead of `-' turns off the given attribute instead.  When"
 #~ msgstr "Usando `+' em vez de `-' faz o atributo ser desabilitado.  Quando"
 
 #~ msgid "used in a function, makes NAMEs local, as with the `local' command."
@@ -6872,8 +6524,7 @@ msgstr ""
 #~ msgstr "Exibe ARGs.  Se -n for fornecido, o caracter final de nova linha é"
 
 #~ msgid "suppressed.  If the -e option is given, interpretation of the"
-#~ msgstr ""
-#~ "suprimido.  Se a opção -e for fornecida, a interpretação dos seguintes"
+#~ msgstr "suprimido.  Se a opção -e for fornecida, a interpretação dos seguintes"
 
 #~ msgid "following backslash-escaped characters is turned on:"
 #~ msgstr "caracteres após a contrabarra é ativada:"
@@ -6911,74 +6562,56 @@ msgstr ""
 #~ msgid "\t\\num\tthe character whose ASCII code is NUM (octal)."
 #~ msgstr "\t\\num\to caracter com código ASCII igual a NUM (octal)."
 
-#~ msgid ""
-#~ "You can explicitly turn off the interpretation of the above characters"
-#~ msgstr ""
-#~ "Pode-se explicitamente desabilitar a interpretação dos caracteres acima"
+#~ msgid "You can explicitly turn off the interpretation of the above characters"
+#~ msgstr "Pode-se explicitamente desabilitar a interpretação dos caracteres acima"
 
 #~ msgid "with the -E option."
 #~ msgstr "através da opção -E."
 
-#~ msgid ""
-#~ "Output the ARGs.  If -n is specified, the trailing newline is suppressed."
-#~ msgstr ""
-#~ "Exibe ARGS.  Se -n for fornecido, o caracter final de nova linha é "
-#~ "suprimido."
+#~ msgid "Output the ARGs.  If -n is specified, the trailing newline is suppressed."
+#~ msgstr "Exibe ARGS.  Se -n for fornecido, o caracter final de nova linha é suprimido."
 
 #~ msgid "Enable and disable builtin shell commands.  This allows"
-#~ msgstr ""
-#~ "Habilita e desabilita os comandos internos do shell, permitindo usar"
+#~ msgstr "Habilita e desabilita os comandos internos do shell, permitindo usar"
 
 #~ msgid "you to use a disk command which has the same name as a shell"
-#~ msgstr ""
-#~ "um comando de disco que tenha o mesmo nome do comando interno do shell."
+#~ msgstr "um comando de disco que tenha o mesmo nome do comando interno do shell."
 
 #~ msgid "builtin.  If -n is used, the NAMEs become disabled; otherwise"
-#~ msgstr ""
-#~ "Se -n for especificado, os NOMEs são desabilitados, senão os nomes são"
+#~ msgstr "Se -n for especificado, os NOMEs são desabilitados, senão os nomes são"
 
 #~ msgid "NAMEs are enabled.  For example, to use the `test' found on your"
-#~ msgstr ""
-#~ "habilitados. Por exemplo, para usar `test' encontrado pelo PATH em vez"
+#~ msgstr "habilitados. Por exemplo, para usar `test' encontrado pelo PATH em vez"
 
 #~ msgid "path instead of the shell builtin version, type `enable -n test'."
-#~ msgstr ""
-#~ "da versão interna do comando, digite `enable -n test'. Em sistemas que"
+#~ msgstr "da versão interna do comando, digite `enable -n test'. Em sistemas que"
 
 #~ msgid "On systems supporting dynamic loading, the -f option may be used"
-#~ msgstr ""
-#~ "suportam carregamento dinâmico, pode-se usar a opção -f para carregar"
+#~ msgstr "suportam carregamento dinâmico, pode-se usar a opção -f para carregar"
 
 #~ msgid "to load new builtins from the shared object FILENAME.  The -d"
-#~ msgstr ""
-#~ "novos comandos internos do objeto compartilhado ARQUIVO.  A opção -d"
+#~ msgstr "novos comandos internos do objeto compartilhado ARQUIVO.  A opção -d"
 
 #~ msgid "option will delete a builtin previously loaded with -f.  If no"
-#~ msgstr ""
-#~ "elimina os comandos internos previamente carregados com -f.  Se nenhum"
+#~ msgstr "elimina os comandos internos previamente carregados com -f.  Se nenhum"
 
 #~ msgid "non-option names are given, or the -p option is supplied, a list"
-#~ msgstr ""
-#~ "nome for fornecido, ou se a opção -p for fornecida, uma lista de comandos"
+#~ msgstr "nome for fornecido, ou se a opção -p for fornecida, uma lista de comandos"
 
 #~ msgid "of builtins is printed.  The -a option means to print every builtin"
-#~ msgstr ""
-#~ "internos é exibida.  A opção -a faz com que todos os comandos internos"
+#~ msgstr "internos é exibida.  A opção -a faz com que todos os comandos internos"
 
 #~ msgid "with an indication of whether or not it is enabled.  The -s option"
 #~ msgstr "sejam exibidos indicando se estão habilitados ou não.  A opção -s"
 
 #~ msgid "restricts the output to the Posix.2 `special' builtins.  The -n"
-#~ msgstr ""
-#~ "restringe a saída aos comandos internos `especiais' Posix.2.  A opção"
+#~ msgstr "restringe a saída aos comandos internos `especiais' Posix.2.  A opção"
 
 #~ msgid "option displays a list of all disabled builtins."
 #~ msgstr "-n exibe a lista de todos os comandos internos desabilitados."
 
-#~ msgid ""
-#~ "Read ARGs as input to the shell and execute the resulting command(s)."
-#~ msgstr ""
-#~ "Ler ARGs como entrada do shell e executar o(s) comando(s) resultante(s)."
+#~ msgid "Read ARGs as input to the shell and execute the resulting command(s)."
+#~ msgstr "Ler ARGs como entrada do shell e executar o(s) comando(s) resultante(s)."
 
 #~ msgid "Getopts is used by shell procedures to parse positional parameters."
 #~ msgstr ""
@@ -7007,15 +6640,13 @@ msgstr ""
 #~ msgstr "shell OPTIND.  OPTIND é inicializado com 1 cada vez que o script"
 
 #~ msgid "a shell script is invoked.  When an option requires an argument,"
-#~ msgstr ""
-#~ "do shell é chamado.  Quando uma opção requer um argumento, `getopts'"
+#~ msgstr "do shell é chamado.  Quando uma opção requer um argumento, `getopts'"
 
 #~ msgid "getopts places that argument into the shell variable OPTARG."
 #~ msgstr "coloca este argumento dentro da variável do shell OPTARG."
 
 #~ msgid "getopts reports errors in one of two ways.  If the first character"
-#~ msgstr ""
-#~ "`getopts' informa os erros de duas maneiras.  Se o primeiro caracter de"
+#~ msgstr "`getopts' informa os erros de duas maneiras.  Se o primeiro caracter de"
 
 #~ msgid "of OPTSTRING is a colon, getopts uses silent error reporting.  In"
 #~ msgstr "OPÇÕES for dois pontos, `getopts' usa o modo silencioso.  Neste"
@@ -7027,24 +6658,19 @@ msgstr ""
 #~ msgstr "encontrada, `getopts' coloca o caracter da opção em OPTARG.  Se um"
 
 #~ msgid "required argument is not found, getopts places a ':' into NAME and"
-#~ msgstr ""
-#~ "argumento requerido não for encontrado, `getopts' coloca ':' em  NOME e"
+#~ msgstr "argumento requerido não for encontrado, `getopts' coloca ':' em  NOME e"
 
 #~ msgid "sets OPTARG to the option character found.  If getopts is not in"
-#~ msgstr ""
-#~ "atribui a OPTARG o caracter de opção encontrado. Se `getopts' não está em"
+#~ msgstr "atribui a OPTARG o caracter de opção encontrado. Se `getopts' não está em"
 
 #~ msgid "silent mode, and an illegal option is seen, getopts places '?' into"
-#~ msgstr ""
-#~ "modo silencioso, e uma opção ilegal é encontrada, `getopts' coloca '?' em"
+#~ msgstr "modo silencioso, e uma opção ilegal é encontrada, `getopts' coloca '?' em"
 
 #~ msgid "NAME and unsets OPTARG.  If a required option is not found, a '?'"
-#~ msgstr ""
-#~ "NOME e desativa OPTARG.  Se uma opção requerida não é encontrada, uma '?'"
+#~ msgstr "NOME e desativa OPTARG.  Se uma opção requerida não é encontrada, uma '?'"
 
 #~ msgid "is placed in NAME, OPTARG is unset, and a diagnostic message is"
-#~ msgstr ""
-#~ "é colocada em NOME, OPTARG é desativado, e uma mensagem de diagnóstico é"
+#~ msgstr "é colocada em NOME, OPTARG é desativado, e uma mensagem de diagnóstico é"
 
 #~ msgid "printed."
 #~ msgstr "exibida."
@@ -7059,19 +6685,16 @@ msgstr ""
 #~ msgstr "OPTSTRING não seja dois pontos.  OPTERR tem o valor 1 por padrão."
 
 #~ msgid "Getopts normally parses the positional parameters ($0 - $9), but if"
-#~ msgstr ""
-#~ "`getopts' normalmente faz a leitura dos parãmetros posicionais ($0 - $9),"
+#~ msgstr "`getopts' normalmente faz a leitura dos parãmetros posicionais ($0 - $9),"
 
 #~ msgid "more arguments are given, they are parsed instead."
 #~ msgstr "mas, se mais argumentos forem fornecidos, então estes são lidos."
 
 #~ msgid "Exec FILE, replacing this shell with the specified program."
-#~ msgstr ""
-#~ "Executa ARQUIVO, substituindo esta shell pelo programa especificado."
+#~ msgstr "Executa ARQUIVO, substituindo esta shell pelo programa especificado."
 
 #~ msgid "If FILE is not specified, the redirections take effect in this"
-#~ msgstr ""
-#~ "Se ARQUIVO não for especificado, os redirecionamentos são efetivados"
+#~ msgstr "Se ARQUIVO não for especificado, os redirecionamentos são efetivados"
 
 #~ msgid "shell.  If the first argument is `-l', then place a dash in the"
 #~ msgstr "neste shell.  Se o primeiro argumento for `-l', coloca um hífen no"
@@ -7089,8 +6712,7 @@ msgstr ""
 #~ msgstr "Se o arquivo não puder ser executado e o shell não for interativa,"
 
 #~ msgid "then the shell exits, unless the variable \"no_exit_on_failed_exec\""
-#~ msgstr ""
-#~ "então o shell termina, a menos que a variável \"no_exit_on_failed_exec\""
+#~ msgstr "então o shell termina, a menos que a variável \"no_exit_on_failed_exec\""
 
 #~ msgid "is set."
 #~ msgstr "esteja inicializada."
@@ -7098,8 +6720,7 @@ msgstr ""
 #~ msgid "is that of the last command executed."
 #~ msgstr "de saída é igual ao do último comando executado."
 
-#~ msgid ""
-#~ "FIRST and LAST can be numbers specifying the range, or FIRST can be a"
+#~ msgid "FIRST and LAST can be numbers specifying the range, or FIRST can be a"
 #~ msgstr "PRIMEIRO e ÚLTIMO podem ser números especificando o intervalo, ou"
 
 #~ msgid "string, which means the most recent command beginning with that"
@@ -7108,16 +6729,11 @@ msgstr ""
 #~ msgid "string."
 #~ msgstr "mais recente começado por estes caracteres."
 
-#~ msgid ""
-#~ "   -e ENAME selects which editor to use.  Default is FCEDIT, then EDITOR,"
-#~ msgstr ""
-#~ "   -e EDITOR seleciona qual editor usar.  O padrão é FCEDIT, depois "
-#~ "EDITOR,"
+#~ msgid "   -e ENAME selects which editor to use.  Default is FCEDIT, then EDITOR,"
+#~ msgstr "   -e EDITOR seleciona qual editor usar.  O padrão é FCEDIT, depois EDITOR,"
 
-#~ msgid ""
-#~ "      then the editor which corresponds to the current readline editing"
-#~ msgstr ""
-#~ "      depois o editor correspondente ao modo de edição atual da leitura"
+#~ msgid "      then the editor which corresponds to the current readline editing"
+#~ msgstr "      depois o editor correspondente ao modo de edição atual da leitura"
 
 #~ msgid "      mode, then vi."
 #~ msgstr "      de linha, e depois o vi."
@@ -7128,40 +6744,32 @@ msgstr ""
 #~ msgid "   -n means no line numbers listed."
 #~ msgstr "   -n indica para não listar os números das linhas."
 
-#~ msgid ""
-#~ "   -r means reverse the order of the lines (making it newest listed "
-#~ "first)."
-#~ msgstr ""
-#~ "   -r faz reverter a ordem das linhas (a última torna-se a primeira)."
+#~ msgid "   -r means reverse the order of the lines (making it newest listed first)."
+#~ msgstr "   -r faz reverter a ordem das linhas (a última torna-se a primeira)."
 
 #~ msgid "With the `fc -s [pat=rep ...] [command]' format, the command is"
-#~ msgstr ""
-#~ "No formato `fc -s [ANTIGO=NOVO ...] [COMANDO]', o comando é executado"
+#~ msgstr "No formato `fc -s [ANTIGO=NOVO ...] [COMANDO]', o comando é executado"
 
 #~ msgid "re-executed after the substitution OLD=NEW is performed."
 #~ msgstr "novamente após a substituição de ANTIGO por NOVO ser realizada."
 
 #~ msgid "A useful alias to use with this is r='fc -s', so that typing `r cc'"
-#~ msgstr ""
-#~ "Um alias útil a ser usado é r='fc -s' para que, ao se digitar `r cc',"
+#~ msgstr "Um alias útil a ser usado é r='fc -s' para que, ao se digitar `r cc',"
 
 #~ msgid "runs the last command beginning with `cc' and typing `r' re-executes"
 #~ msgstr "seja executado o último comando começado por `cc' e, ao se digitar"
 
 #~ msgid "Place JOB_SPEC in the foreground, and make it the current job.  If"
-#~ msgstr ""
-#~ "Colocar JOB-ESPECIFICADO no primeiro plano, e torná-lo o trabalho atual."
+#~ msgstr "Colocar JOB-ESPECIFICADO no primeiro plano, e torná-lo o trabalho atual."
 
 #~ msgid "JOB_SPEC is not present, the shell's notion of the current job is"
-#~ msgstr ""
-#~ "Se JOB-ESPECIFICADO não estiver presente, a noção do shell do trabalho"
+#~ msgstr "Se JOB-ESPECIFICADO não estiver presente, a noção do shell do trabalho"
 
 #~ msgid "used."
 #~ msgstr "atual é utilizada."
 
 #~ msgid "Place JOB_SPEC in the background, as if it had been started with"
-#~ msgstr ""
-#~ "Colocar JOB-ESPECIFICADO no segundo plano, como se tivesse sido ativado"
+#~ msgstr "Colocar JOB-ESPECIFICADO no segundo plano, como se tivesse sido ativado"
 
 #~ msgid "`&'.  If JOB_SPEC is not present, the shell's notion of the current"
 #~ msgstr "com `&'. Se JOB-ESPECIFICADO não estiver presente, a noção do shell"
@@ -7170,22 +6778,18 @@ msgstr ""
 #~ msgstr "do trabalho atual é utilizada."
 
 #~ msgid "For each NAME, the full pathname of the command is determined and"
-#~ msgstr ""
-#~ "Para cada NOME, o caminho completo do comando é determinado e lembrado."
+#~ msgstr "Para cada NOME, o caminho completo do comando é determinado e lembrado."
 
 #~ msgid "remembered.  If the -p option is supplied, PATHNAME is used as the"
-#~ msgstr ""
-#~ "Se a opção -p for fornecida, CAMINHO é utilizado como o caminho completo"
+#~ msgstr "Se a opção -p for fornecida, CAMINHO é utilizado como o caminho completo"
 
 #~ msgid "full pathname of NAME, and no path search is performed.  The -r"
 #~ msgstr "para NOME, e nenhuma procura de caminho é realizada.  A opção -r"
 
 #~ msgid "option causes the shell to forget all remembered locations.  If no"
-#~ msgstr ""
-#~ "faz com que a shell esqueça todas as localizações lembradas.  Sem nenhum"
+#~ msgstr "faz com que a shell esqueça todas as localizações lembradas.  Sem nenhum"
 
-#~ msgid ""
-#~ "arguments are given, information about remembered commands is displayed."
+#~ msgid "arguments are given, information about remembered commands is displayed."
 #~ msgstr "argumento, as informações sobre os comandos lembrados são exibidas."
 
 #~ msgid "Display helpful information about builtin commands.  If PATTERN is"
@@ -7195,12 +6799,10 @@ msgstr ""
 #~ msgstr "especificado, fornece ajuda detalhada para todos os comandos que"
 
 #~ msgid "otherwise a list of the builtins is printed."
-#~ msgstr ""
-#~ "correspondem ao PADRÃO, senão a lista dos comandos internos é exibida."
+#~ msgstr "correspondem ao PADRÃO, senão a lista dos comandos internos é exibida."
 
 #~ msgid "Display the history list with line numbers.  Lines listed with"
-#~ msgstr ""
-#~ "Exibe a lista histórica com os números das linhas. Linhas contendo um"
+#~ msgstr "Exibe a lista histórica com os números das linhas. Linhas contendo um"
 
 #~ msgid "with a `*' have been modified.  Argument of N says to list only"
 #~ msgstr "`*' foram modificadas.  O argumento N faz listar somente as últimas"
@@ -7208,19 +6810,14 @@ msgstr ""
 #~ msgid "the last N lines.  The -c option causes the history list to be"
 #~ msgstr "N linhas.  A opção -c faz com que a lista histórica seja apagada"
 
-#~ msgid ""
-#~ "cleared by deleting all of the entries.  The `-w' option writes out the"
-#~ msgstr ""
-#~ "removendo todas as entradas.  A opção `-w' escreve o histórico atual no"
+#~ msgid "cleared by deleting all of the entries.  The `-w' option writes out the"
+#~ msgstr "removendo todas as entradas.  A opção `-w' escreve o histórico atual no"
 
-#~ msgid ""
-#~ "current history to the history file;  `-r' means to read the file and"
-#~ msgstr ""
-#~ "arquivo de histórico;  A opção `-r' significa ler o arquivo e apensar seu"
+#~ msgid "current history to the history file;  `-r' means to read the file and"
+#~ msgstr "arquivo de histórico;  A opção `-r' significa ler o arquivo e apensar seu"
 
 #~ msgid "append the contents to the history list instead.  `-a' means"
-#~ msgstr ""
-#~ "conteúdo à lista histórica.  A opção `-a' significa apensar as linhas de"
+#~ msgstr "conteúdo à lista histórica.  A opção `-a' significa apensar as linhas de"
 
 #~ msgid "to append history lines from this session to the history file."
 #~ msgstr "histórico desta sessão ao arquivo de histórico."
@@ -7229,113 +6826,82 @@ msgstr ""
 #~ msgstr "A opção `-n' faz ler todas as linhas de histórico ainda não lidas"
 
 #~ msgid "from the history file and append them to the history list.  If"
-#~ msgstr ""
-#~ "do arquivo histórico, e apensá-las à lista de histórico.  Se ARQUIVO"
+#~ msgstr "do arquivo histórico, e apensá-las à lista de histórico.  Se ARQUIVO"
 
 #~ msgid "FILENAME is given, then that is used as the history file else"
 #~ msgstr "for fornecido, então este é usado como arquivo de histórico, senão"
 
 #~ msgid "if $HISTFILE has a value, that is used, else ~/.bash_history."
-#~ msgstr ""
-#~ "se $HISTFILE possui valor, este é usado, senão ~/.bash_history.  Se a"
+#~ msgstr "se $HISTFILE possui valor, este é usado, senão ~/.bash_history.  Se a"
 
 #~ msgid "If the -s option is supplied, the non-option ARGs are appended to"
-#~ msgstr ""
-#~ "opção -s for fornecida, os ARGs, que não forem opções, são apensados à"
+#~ msgstr "opção -s for fornecida, os ARGs, que não forem opções, são apensados à"
 
 #~ msgid "the history list as a single entry.  The -p option means to perform"
-#~ msgstr ""
-#~ "lista histórica como uma única entrada. A opção -p significa realizar a"
+#~ msgstr "lista histórica como uma única entrada. A opção -p significa realizar a"
 
-#~ msgid ""
-#~ "history expansion on each ARG and display the result, without storing"
-#~ msgstr ""
-#~ "expansão da história em cada ARG e exibir o resultado, sem armazenar"
+#~ msgid "history expansion on each ARG and display the result, without storing"
+#~ msgstr "expansão da história em cada ARG e exibir o resultado, sem armazenar"
 
 #~ msgid "anything in the history list."
 #~ msgstr "nada na lista de histórico."
 
 #~ msgid "Lists the active jobs.  The -l option lists process id's in addition"
-#~ msgstr ""
-#~ "Lista os trabalhos ativos.  A opção -l lista os ID's dos processos além"
+#~ msgstr "Lista os trabalhos ativos.  A opção -l lista os ID's dos processos além"
 
 #~ msgid "to the normal information; the -p option lists process id's only."
-#~ msgstr ""
-#~ "das informações usuais;  a opção -p lista somente os ID's dos processos."
+#~ msgstr "das informações usuais;  a opção -p lista somente os ID's dos processos."
 
-#~ msgid ""
-#~ "If -n is given, only processes that have changed status since the last"
-#~ msgstr ""
-#~ "Se -n for fornecido, somente os processos que mudaram de status desde a"
+#~ msgid "If -n is given, only processes that have changed status since the last"
+#~ msgstr "Se -n for fornecido, somente os processos que mudaram de status desde a"
 
-#~ msgid ""
-#~ "notification are printed.  JOBSPEC restricts output to that job.  The"
-#~ msgstr ""
-#~ "última notificação são exibidos.  JOB-ESPECIFICADO restringe a saída a "
-#~ "este"
+#~ msgid "notification are printed.  JOBSPEC restricts output to that job.  The"
+#~ msgstr "última notificação são exibidos.  JOB-ESPECIFICADO restringe a saída a este"
 
 #~ msgid "-r and -s options restrict output to running and stopped jobs only,"
-#~ msgstr ""
-#~ "trabalho.  As opções -r e -s restringem a saída apenas aos trabalhos"
+#~ msgstr "trabalho.  As opções -r e -s restringem a saída apenas aos trabalhos"
 
 #~ msgid "respectively.  Without options, the status of all active jobs is"
-#~ msgstr ""
-#~ "executando e parados, respectivamente.  Sem opções, o status de todos os"
+#~ msgstr "executando e parados, respectivamente.  Sem opções, o status de todos os"
 
-#~ msgid ""
-#~ "printed.  If -x is given, COMMAND is run after all job specifications"
-#~ msgstr ""
-#~ "trabalhos ativos são exibidos.  Se -x for fornecido, COMANDO é executado"
+#~ msgid "printed.  If -x is given, COMMAND is run after all job specifications"
+#~ msgstr "trabalhos ativos são exibidos.  Se -x for fornecido, COMANDO é executado"
 
-#~ msgid ""
-#~ "that appear in ARGS have been replaced with the process ID of that job's"
-#~ msgstr ""
-#~ "após todas as especificações de trabalho que aparecem em ARGS terem sido"
+#~ msgid "that appear in ARGS have been replaced with the process ID of that job's"
+#~ msgstr "após todas as especificações de trabalho que aparecem em ARGS terem sido"
 
 #~ msgid "process group leader."
 #~ msgstr "substituídas pelo ID do processo líder deste grupo de processos."
 
 #~ msgid "Removes each JOBSPEC argument from the table of active jobs."
-#~ msgstr ""
-#~ "Remove cada argumento JOB-ESPECIFICADO da tabela de trabalhos ativos."
+#~ msgstr "Remove cada argumento JOB-ESPECIFICADO da tabela de trabalhos ativos."
 
 #~ msgid "Send the processes named by PID (or JOB) the signal SIGSPEC.  If"
-#~ msgstr ""
-#~ "Envia ao processo identificado pelo PID (ou JOB) o sinal SIGSPEC.  Se"
+#~ msgstr "Envia ao processo identificado pelo PID (ou JOB) o sinal SIGSPEC.  Se"
 
-#~ msgid ""
-#~ "SIGSPEC is not present, then SIGTERM is assumed.  An argument of `-l'"
-#~ msgstr ""
-#~ "SIGSPEC não estiver presente, então SIGTERM é assumido.  A opção `-l'"
+#~ msgid "SIGSPEC is not present, then SIGTERM is assumed.  An argument of `-l'"
+#~ msgstr "SIGSPEC não estiver presente, então SIGTERM é assumido.  A opção `-l'"
 
 #~ msgid "lists the signal names; if arguments follow `-l' they are assumed to"
-#~ msgstr ""
-#~ "lista os nomes dos sinais;  havendo argumentos após `-l', são assumidos"
+#~ msgstr "lista os nomes dos sinais;  havendo argumentos após `-l', são assumidos"
 
 #~ msgid "be signal numbers for which names should be listed.  Kill is a shell"
-#~ msgstr ""
-#~ "como sendo os números dos sinais cujos nomes devem ser exibidos.  Kill"
+#~ msgstr "como sendo os números dos sinais cujos nomes devem ser exibidos.  Kill"
 
 #~ msgid "builtin for two reasons: it allows job IDs to be used instead of"
-#~ msgstr ""
-#~ "é um comando interno por duas razões: permite o uso do ID do trabalho em"
+#~ msgstr "é um comando interno por duas razões: permite o uso do ID do trabalho em"
 
 #~ msgid "process IDs, and, if you have reached the limit on processes that"
-#~ msgstr ""
-#~ "vez do ID do processo e, caso tenha sido atingido o limite de processos "
-#~ "que"
+#~ msgstr "vez do ID do processo e, caso tenha sido atingido o limite de processos que"
 
-#~ msgid ""
-#~ "you can create, you don't have to start a process to kill another one."
-#~ msgstr ""
-#~ "podem ser criados, não é necessário um novo processo para remover outro."
+#~ msgid "you can create, you don't have to start a process to kill another one."
+#~ msgstr "podem ser criados, não é necessário um novo processo para remover outro."
 
 #~ msgid "Each ARG is an arithmetic expression to be evaluated.  Evaluation"
 #~ msgstr "Cada ARG é uma expressão aritmética a ser avaliada.  A avaliação é"
 
 #~ msgid "is done in long integers with no check for overflow, though division"
-#~ msgstr ""
-#~ "feita usando inteiros longos sem verificar estouro, embora a divisão"
+#~ msgstr "feita usando inteiros longos sem verificar estouro, embora a divisão"
 
 #~ msgid "by 0 is trapped and flagged as an error.  The following list of"
 #~ msgstr "por 0 seja capturada e indicada como erro.  A lista abaixo está"
@@ -7407,8 +6973,7 @@ msgstr ""
 #~ msgstr "ativo para ser usada em uma expressão."
 
 #~ msgid "Operators are evaluated in order of precedence.  Sub-expressions in"
-#~ msgstr ""
-#~ "Os operadores são avaliados em ordem de precedência.  Sub-expressões"
+#~ msgstr "Os operadores são avaliados em ordem de precedência.  Sub-expressões"
 
 #~ msgid "parentheses are evaluated first and may override the precedence"
 #~ msgstr "entre parênteses são avaliadas primeiro e podem prevalecer sobre as"
@@ -7425,76 +6990,53 @@ msgstr ""
 #~ msgid "One line is read from the standard input, and the first word is"
 #~ msgstr "Uma linha é lida a partir da entrada padrão, e a primeira palavra é"
 
-#~ msgid ""
-#~ "assigned to the first NAME, the second word to the second NAME, and so"
-#~ msgstr ""
-#~ "atribuída ao primeiro NOME, a segunda ao segundo NOME, e assim por diante,"
+#~ msgid "assigned to the first NAME, the second word to the second NAME, and so"
+#~ msgstr "atribuída ao primeiro NOME, a segunda ao segundo NOME, e assim por diante,"
 
-#~ msgid ""
-#~ "on, with leftover words assigned to the last NAME.  Only the characters"
-#~ msgstr ""
-#~ "com as palavras restantes atribuídas ao último NOME.  Somente os "
-#~ "caracteres"
+#~ msgid "on, with leftover words assigned to the last NAME.  Only the characters"
+#~ msgstr "com as palavras restantes atribuídas ao último NOME.  Somente os caracteres"
 
 #~ msgid "found in $IFS are recognized as word delimiters.  The return code is"
-#~ msgstr ""
-#~ "encontrados em $IFS são reconhecidos como delimitadores. O código de "
-#~ "retorno"
+#~ msgstr "encontrados em $IFS são reconhecidos como delimitadores. O código de retorno"
 
-#~ msgid ""
-#~ "zero, unless end-of-file is encountered.  If no NAMEs are supplied, the"
-#~ msgstr ""
-#~ "é zero, a menos que EOF seja encontrado.  Se nenhum NOME for fornecido,"
+#~ msgid "zero, unless end-of-file is encountered.  If no NAMEs are supplied, the"
+#~ msgstr "é zero, a menos que EOF seja encontrado.  Se nenhum NOME for fornecido,"
 
-#~ msgid ""
-#~ "line read is stored in the REPLY variable.  If the -r option is given,"
-#~ msgstr ""
-#~ "a linha lida é armazenada na variável REPLY.  Se a opção -r for fornecida,"
+#~ msgid "line read is stored in the REPLY variable.  If the -r option is given,"
+#~ msgstr "a linha lida é armazenada na variável REPLY.  Se a opção -r for fornecida,"
 
 #~ msgid "this signifies `raw' input, and backslash escaping is disabled.  If"
-#~ msgstr ""
-#~ "significa entrada `textual', desabilitando a interpretação da contrabarra."
+#~ msgstr "significa entrada `textual', desabilitando a interpretação da contrabarra."
 
 #~ msgid "the `-p' option is supplied, the string supplied as an argument is"
-#~ msgstr ""
-#~ "Se a opção `-p' for fornecida a MENSAGEM fornecida como argumento é "
-#~ "exibida,"
+#~ msgstr "Se a opção `-p' for fornecida a MENSAGEM fornecida como argumento é exibida,"
 
-#~ msgid ""
-#~ "output without a trailing newline before attempting to read.  If -a is"
-#~ msgstr ""
-#~ "sem o caracter de nova linha, antes de efetuar a leitura.  Se a opção -a"
+#~ msgid "output without a trailing newline before attempting to read.  If -a is"
+#~ msgstr "sem o caracter de nova linha, antes de efetuar a leitura.  Se a opção -a"
 
-#~ msgid ""
-#~ "supplied, the words read are assigned to sequential indices of ARRAY,"
-#~ msgstr ""
-#~ "for fornecida, as palavras lidas são atribuídas aos índices seqüenciais"
+#~ msgid "supplied, the words read are assigned to sequential indices of ARRAY,"
+#~ msgstr "for fornecida, as palavras lidas são atribuídas aos índices sequenciais"
 
 #~ msgid "starting at zero.  If -e is supplied and the shell is interactive,"
-#~ msgstr ""
-#~ "do ARRAY, começando por zero.  Se a opção -e for fornecida, e a shell for"
+#~ msgstr "do ARRAY, começando por zero.  Se a opção -e for fornecida, e a shell for"
 
 #~ msgid "readline is used to obtain the line."
 #~ msgstr "interativa, `readline' é utilizado para ler a linha."
 
-#~ msgid ""
-#~ "Causes a function to exit with the return value specified by N.  If N"
+#~ msgid "Causes a function to exit with the return value specified by N.  If N"
 #~ msgstr "Faz a função terminar com o valor de retorno especificado por N."
 
 #~ msgid "is omitted, the return status is that of the last command."
 #~ msgstr "Se N for omitido, retorna o status do último comando executado."
 
 #~ msgid "    -a  Mark variables which are modified or created for export."
-#~ msgstr ""
-#~ "    -a  Marcar para exportação as variáveis que são criadas ou "
-#~ "modificadas."
+#~ msgstr "    -a  Marcar para exportação as variáveis que são criadas ou modificadas."
 
 #~ msgid "    -b  Notify of job termination immediately."
 #~ msgstr "    -b  Notificar imediatamente o término do trabalho."
 
 #~ msgid "    -e  Exit immediately if a command exits with a non-zero status."
-#~ msgstr ""
-#~ "    -e  Terminar imediatamente se um comando terminar com status != 0."
+#~ msgstr "    -e  Terminar imediatamente se um comando terminar com status != 0."
 
 #~ msgid "    -f  Disable file name generation (globbing)."
 #~ msgstr "    -f  Desabilitar a geração de nome de arquivo (metacaracteres)."
@@ -7502,16 +7044,14 @@ msgstr ""
 #~ msgid "    -h  Remember the location of commands as they are looked up."
 #~ msgstr "    -h  Lembrar da localização dos comandos ao procurá-los."
 
-#~ msgid ""
-#~ "    -i  Force the shell to be an \"interactive\" one.  Interactive shells"
+#~ msgid "    -i  Force the shell to be an \"interactive\" one.  Interactive shells"
 #~ msgstr "    -i  Forçar a shell ser do tipo \"interativa\".  `Shells'"
 
 #~ msgid "        always read `~/.bashrc' on startup."
 #~ msgstr "        interativas sempre lêem `~/.bashrc' ao iniciar."
 
 #~ msgid "    -k  All assignment arguments are placed in the environment for a"
-#~ msgstr ""
-#~ "    -k  Todos os argumentos de atribuição são colocados no ambiente,"
+#~ msgstr "    -k  Todos os argumentos de atribuição são colocados no ambiente,"
 
 #~ msgid "        command, not just those that precede the command name."
 #~ msgstr "        e não somente os que precedem o nome do comando."
@@ -7535,8 +7075,7 @@ msgstr ""
 #~ msgstr "            braceexpand  o mesmo que -B"
 
 #~ msgid "            emacs        use an emacs-style line editing interface"
-#~ msgstr ""
-#~ "            emacs        usar interface de edição de linha estilo emacs"
+#~ msgstr "            emacs        usar interface de edição de linha estilo emacs"
 
 #~ msgid "            errexit      same as -e"
 #~ msgstr "            errexit      o mesmo que -e"
@@ -7553,10 +7092,8 @@ msgstr ""
 #~ msgid "            interactive-comments"
 #~ msgstr "            interactive-comments"
 
-#~ msgid ""
-#~ "                         allow comments to appear in interactive commands"
-#~ msgstr ""
-#~ "                         permite comentários em comandos interativos"
+#~ msgid "                         allow comments to appear in interactive commands"
+#~ msgstr "                         permite comentários em comandos interativos"
 
 #~ msgid "            keyword      same as -k"
 #~ msgstr "            keyword      o mesmo que -k"
@@ -7585,15 +7122,11 @@ msgstr ""
 #~ msgid "            physical     same as -P"
 #~ msgstr "            physical     o mesmo que -P"
 
-#~ msgid ""
-#~ "            posix        change the behavior of bash where the default"
-#~ msgstr ""
-#~ "            posix        mudar o comportamento do `bash' onde o padrão"
+#~ msgid "            posix        change the behavior of bash where the default"
+#~ msgstr "            posix        mudar o comportamento do `bash' onde o padrão"
 
-#~ msgid ""
-#~ "                         operation differs from the 1003.2 standard to"
-#~ msgstr ""
-#~ "                         for diferente do padrão 1003.2, para tornar"
+#~ msgid "                         operation differs from the 1003.2 standard to"
+#~ msgstr "                         for diferente do padrão 1003.2, para tornar"
 
 #~ msgid "                         match the standard"
 #~ msgstr "                         igual ao padrão"
@@ -7605,26 +7138,19 @@ msgstr ""
 #~ msgstr "            verbose      o mesmo que -v"
 
 #~ msgid "            vi           use a vi-style line editing interface"
-#~ msgstr ""
-#~ "            vi           usar interface de edição de linha estilo vi"
+#~ msgstr "            vi           usar interface de edição de linha estilo vi"
 
 #~ msgid "            xtrace       same as -x"
 #~ msgstr "            xtrace       o mesmo que -x"
 
-#~ msgid ""
-#~ "    -p  Turned on whenever the real and effective user ids do not match."
-#~ msgstr ""
-#~ "    -p  Habilitado sempre que o usuário real e efetivo forem diferentes."
+#~ msgid "    -p  Turned on whenever the real and effective user ids do not match."
+#~ msgstr "    -p  Habilitado sempre que o usuário real e efetivo forem diferentes."
 
 #~ msgid "        Disables processing of the $ENV file and importing of shell"
-#~ msgstr ""
-#~ "        Desabilita o processamento do arquivo $ENV e importação das "
-#~ "funções"
+#~ msgstr "        Desabilita o processamento do arquivo $ENV e importação das funções"
 
-#~ msgid ""
-#~ "        functions.  Turning this option off causes the effective uid and"
-#~ msgstr ""
-#~ "        da shell.  Desabilitando esta opção faz com que o `uid' e `gid'"
+#~ msgid "        functions.  Turning this option off causes the effective uid and"
+#~ msgstr "        da shell.  Desabilitando esta opção faz com que o `uid' e `gid'"
 
 #~ msgid "        gid to be set to the real uid and gid."
 #~ msgstr "        efetivos sejam feitos o mesmo que o `uid' e `gid' reais."
@@ -7633,8 +7159,7 @@ msgstr ""
 #~ msgstr "    -t  Sair após ler e executar um comando."
 
 #~ msgid "    -u  Treat unset variables as an error when substituting."
-#~ msgstr ""
-#~ "    -u  Tratar como erro as variáveis não inicializadas na substituição."
+#~ msgstr "    -u  Tratar como erro as variáveis não inicializadas na substituição."
 
 #~ msgid "    -v  Print shell input lines as they are read."
 #~ msgstr "    -v  Exibir as linhas de entrada da shell ao lê-las."
@@ -7667,13 +7192,10 @@ msgstr ""
 #~ msgstr "Usando + em vez de - faz com que as opções sejam desabilitadas. As"
 
 #~ msgid "flags can also be used upon invocation of the shell.  The current"
-#~ msgstr ""
-#~ "opções também podem ser usadas na chamada da shell.  O conjunto atual"
+#~ msgstr "opções também podem ser usadas na chamada da shell.  O conjunto atual"
 
-#~ msgid ""
-#~ "set of flags may be found in $-.  The remaining n ARGs are positional"
-#~ msgstr ""
-#~ "de opções pode ser encontrado em $-. Os n ARGs restantes são parâmetros"
+#~ msgid "set of flags may be found in $-.  The remaining n ARGs are positional"
+#~ msgstr "de opções pode ser encontrado em $-. Os n ARGs restantes são parâmetros"
 
 #~ msgid "parameters and are assigned, in order, to $1, $2, .. $n.  If no"
 #~ msgstr "posicionais e são atribuídos, em ordem, a $1, $2, .. $n.  Se nenhum"
@@ -7682,12 +7204,10 @@ msgstr ""
 #~ msgstr "ARG for fornecido, todas as variáveis da shell são exibidas."
 
 #~ msgid "For each NAME, remove the corresponding variable or function.  Given"
-#~ msgstr ""
-#~ "Para cada NOME, remove a variável ou a função correspondente.  Usando-se a"
+#~ msgstr "Para cada NOME, remove a variável ou a função correspondente.  Usando-se a"
 
 #~ msgid "the `-v', unset will only act on variables.  Given the `-f' flag,"
-#~ msgstr ""
-#~ "opção `-v', `unset' atua somente nas variáveis.  Usando-se a opção `-f'"
+#~ msgstr "opção `-v', `unset' atua somente nas variáveis.  Usando-se a opção `-f'"
 
 #~ msgid "unset will only act on functions.  With neither flag, unset first"
 #~ msgstr "`unset' atua somente nas funções.  Sem nenhuma opção, inicialmente"
@@ -7695,73 +7215,56 @@ msgstr ""
 #~ msgid "tries to unset a variable, and if that fails, then tries to unset a"
 #~ msgstr "`unset' tenta remover uma variável e, se falhar, tenta remover uma"
 
-#~ msgid ""
-#~ "function.  Some variables (such as PATH and IFS) cannot be unset; also"
-#~ msgstr ""
-#~ "função.  Algumas variáveis (como PATH e IFS) não podem ser removidas."
+#~ msgid "function.  Some variables (such as PATH and IFS) cannot be unset; also"
+#~ msgstr "função.  Algumas variáveis (como PATH e IFS) não podem ser removidas."
 
 #~ msgid "see readonly."
 #~ msgstr "Veja também o comando `readonly'."
 
 #~ msgid "NAMEs are marked for automatic export to the environment of"
-#~ msgstr ""
-#~ "NOMEs são marcados para serem automaticamente exportados para o ambiente"
+#~ msgstr "NOMEs são marcados para serem automaticamente exportados para o ambiente"
 
 #~ msgid "subsequently executed commands.  If the -f option is given,"
 #~ msgstr "dos comando executados a seguir.  Se a opção -f for fornecida,"
 
 #~ msgid "the NAMEs refer to functions.  If no NAMEs are given, or if `-p'"
-#~ msgstr ""
-#~ "os NOMEs se referem a funções.  Se nenhum nome for fornecido, ou se `-p'"
+#~ msgstr "os NOMEs se referem a funções.  Se nenhum nome for fornecido, ou se `-p'"
 
 #~ msgid "is given, a list of all names that are exported in this shell is"
-#~ msgstr ""
-#~ "for usado, uma lista com todos os nomes que são exportados nesta shell é"
+#~ msgstr "for usado, uma lista com todos os nomes que são exportados nesta shell é"
 
 #~ msgid "printed.  An argument of `-n' says to remove the export property"
-#~ msgstr ""
-#~ "exibida.  O argumento `-n' faz remover a propriedade de exportação dos"
+#~ msgstr "exibida.  O argumento `-n' faz remover a propriedade de exportação dos"
 
 #~ msgid "from subsequent NAMEs.  An argument of `--' disables further option"
-#~ msgstr "NOMEs subseqüentes.  O argumento `--' desabilita o processamento de"
+#~ msgstr "NOMEs subsequentes.  O argumento `--' desabilita o processamento de"
 
 #~ msgid "processing."
 #~ msgstr "opções posteriores."
 
-#~ msgid ""
-#~ "The given NAMEs are marked readonly and the values of these NAMEs may"
-#~ msgstr ""
-#~ "Os NOMEs são marcados como somente para leitura, e os valores destes"
+#~ msgid "The given NAMEs are marked readonly and the values of these NAMEs may"
+#~ msgstr "Os NOMEs são marcados como somente para leitura, e os valores destes"
 
 #~ msgid "not be changed by subsequent assignment.  If the -f option is given,"
-#~ msgstr ""
-#~ "NOMEs não poderão ser alterados por novas atribuições.  Se a opção -f for"
+#~ msgstr "NOMEs não poderão ser alterados por novas atribuições.  Se a opção -f for"
 
 #~ msgid "then functions corresponding to the NAMEs are so marked.  If no"
-#~ msgstr ""
-#~ "fornecida, as funções correspondentes a NOMEs também são marcadas.  Sem"
+#~ msgstr "fornecida, as funções correspondentes a NOMEs também são marcadas.  Sem"
 
-#~ msgid ""
-#~ "arguments are given, or if `-p' is given, a list of all readonly names"
-#~ msgstr ""
-#~ "nenhum argumento, ou se `-p' for usado, uma lista com todos os nomes"
+#~ msgid "arguments are given, or if `-p' is given, a list of all readonly names"
+#~ msgstr "nenhum argumento, ou se `-p' for usado, uma lista com todos os nomes"
 
-#~ msgid ""
-#~ "is printed.  An argument of `-n' says to remove the readonly property"
-#~ msgstr ""
-#~ "somente para leitura é exibida.  O argumento `-n' remove a propriedade"
+#~ msgid "is printed.  An argument of `-n' says to remove the readonly property"
+#~ msgstr "somente para leitura é exibida.  O argumento `-n' remove a propriedade"
 
 #~ msgid "from subsequent NAMEs.  The `-a' option means to treat each NAME as"
 #~ msgstr "somente para leitura.  A opção `-a' faz tratar cada NOME como uma"
 
 #~ msgid "an array variable.  An argument of `--' disables further option"
-#~ msgstr ""
-#~ "variável tipo array.  Um argumento `--' desabilita o processamento de"
+#~ msgstr "variável tipo array.  Um argumento `--' desabilita o processamento de"
 
-#~ msgid ""
-#~ "The positional parameters from $N+1 ... are renamed to $1 ...  If N is"
-#~ msgstr ""
-#~ "Os parâmetros posicionais a partir de $N+1 ... são deslocados para $1 ..."
+#~ msgid "The positional parameters from $N+1 ... are renamed to $1 ...  If N is"
+#~ msgstr "Os parâmetros posicionais a partir de $N+1 ... são deslocados para $1 ..."
 
 #~ msgid "not given, it is assumed to be 1."
 #~ msgstr "Se N não for especificado, o valor 1 é assumido ($2 vira $1 ...)."
@@ -7773,31 +7276,25 @@ msgstr ""
 #~ msgstr "$PATH são usados para encontrar o diretório contendo o ARQUIVO."
 
 #~ msgid "Suspend the execution of this shell until it receives a SIGCONT"
-#~ msgstr ""
-#~ "Suspender a execução desta shell até que o sinal SIGCONT seja recebido."
+#~ msgstr "Suspender a execução desta shell até que o sinal SIGCONT seja recebido."
 
 #~ msgid "signal.  The `-f' if specified says not to complain about this"
 #~ msgstr "Se a opção `-f' for especificada indica para não reclamar sobre ser"
 
 #~ msgid "being a login shell if it is; just suspend anyway."
-#~ msgstr ""
-#~ "uma `shell de login', caso seja; simplesmente suspender de qualquer forma."
+#~ msgstr "uma `shell de login', caso seja; simplesmente suspender de qualquer forma."
 
 #~ msgid "Exits with a status of 0 (trueness) or 1 (falseness) depending on"
-#~ msgstr ""
-#~ "Termina com status 0 (verdadeiro) ou 1 (falso) conforme EXPR for avaliada."
+#~ msgstr "Termina com status 0 (verdadeiro) ou 1 (falso) conforme EXPR for avaliada."
 
 #~ msgid "the evaluation of EXPR.  Expressions may be unary or binary.  Unary"
-#~ msgstr ""
-#~ "As expressões podem ser unárias ou binárias. As expressões unárias são"
+#~ msgstr "As expressões podem ser unárias ou binárias. As expressões unárias são"
 
 #~ msgid "expressions are often used to examine the status of a file.  There"
-#~ msgstr ""
-#~ "muito usadas para examinar o status de um arquivo.  Existem, também,"
+#~ msgstr "muito usadas para examinar o status de um arquivo.  Existem, também,"
 
 #~ msgid "are string operators as well, and numeric comparison operators."
-#~ msgstr ""
-#~ "operadores para cadeias de caracteres (strings) e comparações numéricas."
+#~ msgstr "operadores para cadeias de caracteres (strings) e comparações numéricas."
 
 #~ msgid "File operators:"
 #~ msgstr "Operadores para arquivos:"
@@ -7806,8 +7303,7 @@ msgstr ""
 #~ msgstr "    -b ARQUIVO  Verdade se o arquivo for do tipo especial de bloco."
 
 #~ msgid "    -c FILE        True if file is character special."
-#~ msgstr ""
-#~ "    -c ARQUIVO  Verdade se o arquivo for do tipo especial de caracter."
+#~ msgstr "    -c ARQUIVO  Verdade se o arquivo for do tipo especial de caracter."
 
 #~ msgid "    -d FILE        True if file is a directory."
 #~ msgstr "    -d ARQUIVO  Verdade se o arquivo for um diretório."
@@ -7819,12 +7315,10 @@ msgstr ""
 #~ msgstr "    -f ARQUIVO  Verdade se o arquivo existir e for do tipo regular."
 
 #~ msgid "    -g FILE        True if file is set-group-id."
-#~ msgstr ""
-#~ "    -g ARQUIVO  Verdade se o arquivo tiver o bit \"set-group-id\" ativo."
+#~ msgstr "    -g ARQUIVO  Verdade se o arquivo tiver o bit \"set-group-id\" ativo."
 
 #~ msgid "    -h FILE        True if file is a symbolic link.  Use \"-L\"."
-#~ msgstr ""
-#~ "    -h ARQUIVO  Verdade se arquivo for um vínculo simbólico.  Usar \"-L\"."
+#~ msgstr "    -h ARQUIVO  Verdade se arquivo for um vínculo simbólico.  Usar \"-L\"."
 
 #~ msgid "    -L FILE        True if file is a symbolic link."
 #~ msgstr "    -L ARQUIVO  Verdade se o arquivo for um vínculo simbólico."
@@ -7836,8 +7330,7 @@ msgstr ""
 #~ msgstr "    -p ARQUIVO  Verdade se o arquivo for um `named pipe'."
 
 #~ msgid "    -r FILE        True if file is readable by you."
-#~ msgstr ""
-#~ "    -r ARQUIVO  Verdade se você tiver autorização para ler o arquivo."
+#~ msgstr "    -r ARQUIVO  Verdade se você tiver autorização para ler o arquivo."
 
 #~ msgid "    -s FILE        True if file exists and is not empty."
 #~ msgstr "    -s ARQUIVO  Verdade se o arquivo existir e não estiver vazio."
@@ -7851,26 +7344,19 @@ msgstr ""
 #~ "                    em um terminal."
 
 #~ msgid "    -u FILE        True if the file is set-user-id."
-#~ msgstr ""
-#~ "    -u ARQUIVO  Verdade se o arquivo tiver o bit \"set-user-id\" ativo."
+#~ msgstr "    -u ARQUIVO  Verdade se o arquivo tiver o bit \"set-user-id\" ativo."
 
 #~ msgid "    -w FILE        True if the file is writable by you."
-#~ msgstr ""
-#~ "    -w ARQUIVO  Verdade se você tiver autorização para escrever no "
-#~ "arquivo."
+#~ msgstr "    -w ARQUIVO  Verdade se você tiver autorização para escrever no arquivo."
 
 #~ msgid "    -x FILE        True if the file is executable by you."
-#~ msgstr ""
-#~ "    -x ARQUIVO  Verdade se você tiver autorização para executar o arquivo."
+#~ msgstr "    -x ARQUIVO  Verdade se você tiver autorização para executar o arquivo."
 
 #~ msgid "    -O FILE        True if the file is effectively owned by you."
-#~ msgstr ""
-#~ "    -O ARQUIVO  Verdade se o arquivo pertencer ao seu usuário efetivo."
+#~ msgstr "    -O ARQUIVO  Verdade se o arquivo pertencer ao seu usuário efetivo."
 
-#~ msgid ""
-#~ "    -G FILE        True if the file is effectively owned by your group."
-#~ msgstr ""
-#~ "    -G ARQUIVO  Verdade se o arquivo pertencer ao seu grupo efetivo."
+#~ msgid "    -G FILE        True if the file is effectively owned by your group."
+#~ msgstr "    -G ARQUIVO  Verdade se o arquivo pertencer ao seu grupo efetivo."
 
 #~ msgid "  FILE1 -nt FILE2  True if file1 is newer than (according to"
 #~ msgstr "  ARQ1 -nt ARQ2 Verdade se ARQ1 for mais novo (conforme a data"
@@ -7913,18 +7399,14 @@ msgstr ""
 #~ msgid "    STRING1 < STRING2"
 #~ msgstr "    STRING1 < STRING2"
 
-#~ msgid ""
-#~ "                   True if STRING1 sorts before STRING2 lexicographically"
-#~ msgstr ""
-#~ "                Verdade se STRING1 tiver ordenação anterior à STRING2."
+#~ msgid "                   True if STRING1 sorts before STRING2 lexicographically"
+#~ msgstr "                Verdade se STRING1 tiver ordenação anterior à STRING2."
 
 #~ msgid "    STRING1 > STRING2"
 #~ msgstr "    STRING1 > STRING2"
 
-#~ msgid ""
-#~ "                   True if STRING1 sorts after STRING2 lexicographically"
-#~ msgstr ""
-#~ "                Verdade se STRING1 tiver ordenação posterior à STRING2."
+#~ msgid "                   True if STRING1 sorts after STRING2 lexicographically"
+#~ msgstr "                Verdade se STRING1 tiver ordenação posterior à STRING2."
 
 #~ msgid "Other operators:"
 #~ msgstr "Outros operadores:"
@@ -7945,11 +7427,9 @@ msgstr ""
 #~ msgstr "                   -lt, -le, -gt, ou -ge."
 
 #~ msgid "Arithmetic binary operators return true if ARG1 is equal, not-equal,"
-#~ msgstr ""
-#~ "Operadores aritméticos binários retornam verdadeiro se ARG1 for igual,"
+#~ msgstr "Operadores aritméticos binários retornam verdadeiro se ARG1 for igual,"
 
-#~ msgid ""
-#~ "less-than, less-than-or-equal, greater-than, or greater-than-or-equal"
+#~ msgid "less-than, less-than-or-equal, greater-than, or greater-than-or-equal"
 #~ msgstr "diferente, menor, menor ou igual, maior, ou maior ou igual do que"
 
 #~ msgid "than ARG2."
@@ -7962,60 +7442,46 @@ msgstr ""
 #~ msgstr "argumento deve ser o literal `]', para fechar o `[' de abertura."
 
 #~ msgid "Print the accumulated user and system times for processes run from"
-#~ msgstr ""
-#~ "Exibe os tempos acumulados do usuário e do sistema para os processos"
+#~ msgstr "Exibe os tempos acumulados do usuário e do sistema para os processos"
 
 #~ msgid "the shell."
 #~ msgstr "executados por esta shell."
 
 #~ msgid "The command ARG is to be read and executed when the shell receives"
-#~ msgstr ""
-#~ "O comando em ARG é para ser lido e executado quando a shell receber o(s)"
+#~ msgstr "O comando em ARG é para ser lido e executado quando a shell receber o(s)"
 
 #~ msgid "signal(s) SIGNAL_SPEC.  If ARG is absent all specified signals are"
-#~ msgstr ""
-#~ "sinal(is) SINAL-ESPEC.  Se ARG for omitido, todos os sinais especificados"
+#~ msgstr "sinal(is) SINAL-ESPEC.  Se ARG for omitido, todos os sinais especificados"
 
 #~ msgid "reset to their original values.  If ARG is the null string each"
-#~ msgstr ""
-#~ "retornam aos seus valores originais.  Se ARG for uma string nula, cada"
+#~ msgstr "retornam aos seus valores originais.  Se ARG for uma string nula, cada"
 
 #~ msgid "SIGNAL_SPEC is ignored by the shell and by the commands it invokes."
-#~ msgstr ""
-#~ "SINAL-ESPEC é ignorado pela shell e pelos comandos chamados por ela."
+#~ msgstr "SINAL-ESPEC é ignorado pela shell e pelos comandos chamados por ela."
 
 #~ msgid "If SIGNAL_SPEC is EXIT (0) the command ARG is executed on exit from"
-#~ msgstr ""
-#~ "Se SINAL-ESPEC for EXIT (0) o comando em ARG é executado na saída da"
+#~ msgstr "Se SINAL-ESPEC for EXIT (0) o comando em ARG é executado na saída da"
 
 #~ msgid "the shell.  If SIGNAL_SPEC is DEBUG, ARG is executed after every"
-#~ msgstr ""
-#~ "shell.  Se SINAL-ESPEC for DEBUG, o comando em ARG é executado após cada"
+#~ msgstr "shell.  Se SINAL-ESPEC for DEBUG, o comando em ARG é executado após cada"
 
 #~ msgid "command.  If ARG is `-p' then the trap commands associated with"
-#~ msgstr ""
-#~ "comando.  Se ARG for `-p' então os comandos de captura associados com cada"
+#~ msgstr "comando.  Se ARG for `-p' então os comandos de captura associados com cada"
 
 #~ msgid "each SIGNAL_SPEC are displayed.  If no arguments are supplied or if"
 #~ msgstr "SINAL-ESPEC são exibidos.  Se nenhum argumento for fornecido, ou se"
 
 #~ msgid "only `-p' is given, trap prints the list of commands associated with"
-#~ msgstr ""
-#~ "somente `-p' for fornecido, é exibida a lista dos comandos associados"
+#~ msgstr "somente `-p' for fornecido, é exibida a lista dos comandos associados"
 
-#~ msgid ""
-#~ "each signal number.  SIGNAL_SPEC is either a signal name in <signal.h>"
-#~ msgstr ""
-#~ "com cada número de sinal.  SINAL-ESPEC é um nome de sinal em <signal.h> ou"
+#~ msgid "each signal number.  SIGNAL_SPEC is either a signal name in <signal.h>"
+#~ msgstr "com cada número de sinal.  SINAL-ESPEC é um nome de sinal em <signal.h> ou"
 
-#~ msgid ""
-#~ "or a signal number.  `trap -l' prints a list of signal names and their"
-#~ msgstr ""
-#~ "um número de sinal.  `trap -l' exibe a lista de nomes de sinais com seus"
+#~ msgid "or a signal number.  `trap -l' prints a list of signal names and their"
+#~ msgstr "um número de sinal.  `trap -l' exibe a lista de nomes de sinais com seus"
 
 #~ msgid "corresponding numbers.  Note that a signal can be sent to the shell"
-#~ msgstr ""
-#~ "números correspondentes.  Note que o sinal pode ser enviado para a shell"
+#~ msgstr "números correspondentes.  Note que o sinal pode ser enviado para a shell"
 
 #~ msgid "with \"kill -signal $$\"."
 #~ msgstr "através do comando \"kill -SINAL $$\"."
@@ -8024,19 +7490,13 @@ msgstr ""
 #~ msgstr "Para cada NOME, indica como este deve ser interpretado caso seja"
 
 #~ msgid "If the -t option is used, returns a single word which is one of"
-#~ msgstr ""
-#~ "Se a opção -t for fornecida, `type' retorna uma única palavra dentre"
+#~ msgstr "Se a opção -t for fornecida, `type' retorna uma única palavra dentre"
 
-#~ msgid ""
-#~ "`alias', `keyword', `function', `builtin', `file' or `', if NAME is an"
-#~ msgstr ""
-#~ "`alias', `keyword', `function', `builtin', `file' ou `', se NOME for um"
+#~ msgid "`alias', `keyword', `function', `builtin', `file' or `', if NAME is an"
+#~ msgstr "`alias', `keyword', `function', `builtin', `file' ou `', se NOME for um"
 
-#~ msgid ""
-#~ "alias, shell reserved word, shell function, shell builtin, disk file,"
-#~ msgstr ""
-#~ "alias, uma palavra reservada, função ou comando interno da shell, um "
-#~ "arquivo"
+#~ msgid "alias, shell reserved word, shell function, shell builtin, disk file,"
+#~ msgstr "alias, uma palavra reservada, função ou comando interno da shell, um arquivo"
 
 #~ msgid "or unfound, respectively."
 #~ msgstr "em disco, ou não for encontrado, respectivamente."
@@ -8050,10 +7510,8 @@ msgstr ""
 #~ msgid "If the -a flag is used, displays all of the places that contain an"
 #~ msgstr "Se a opção -a for fornecida, exibe todos os locais que contém um"
 
-#~ msgid ""
-#~ "executable named `file'.  This includes aliases and functions, if and"
-#~ msgstr ""
-#~ "arquivo executável chamado `ARQUIVO', incluindo os aliases e funções,"
+#~ msgid "executable named `file'.  This includes aliases and functions, if and"
+#~ msgstr "arquivo executável chamado `ARQUIVO', incluindo os aliases e funções,"
 
 #~ msgid "only if the -p flag is not also used."
 #~ msgstr "mas somente se a opção -p não for fornecida conjuntamente."
@@ -8065,12 +7523,10 @@ msgstr ""
 #~ msgstr "-a, -p, and -t, respectivamente."
 
 #~ msgid "Ulimit provides control over the resources available to processes"
-#~ msgstr ""
-#~ "Ulimit estabelece controle sobre os recursos disponíveis para os processos"
+#~ msgstr "Ulimit estabelece controle sobre os recursos disponíveis para os processos"
 
 #~ msgid "started by the shell, on systems that allow such control.  If an"
-#~ msgstr ""
-#~ "iniciados por esta shell, em sistemas que permitem estes controles. Se uma"
+#~ msgstr "iniciados por esta shell, em sistemas que permitem estes controles. Se uma"
 
 #~ msgid "option is given, it is interpreted as follows:"
 #~ msgstr "opção for fornecida, é interpretada como mostrado a seguir:"
@@ -8085,15 +7541,13 @@ msgstr ""
 #~ msgstr "    -a\ttodos os limites correntes são informados"
 
 #~ msgid "    -c\tthe maximum size of core files created"
-#~ msgstr ""
-#~ "    -c\to tamanho máximo para os arquivos de imagem do núcleo criados"
+#~ msgstr "    -c\to tamanho máximo para os arquivos de imagem do núcleo criados"
 
 #~ msgid "    -d\tthe maximum size of a process's data segment"
 #~ msgstr "    -d\to tamanho máximo do segmento de dados de um processo"
 
 #~ msgid "    -m\tthe maximum resident set size"
-#~ msgstr ""
-#~ "    -m\to tamanho máximo do conjunto de processos residentes em memória"
+#~ msgstr "    -m\to tamanho máximo do conjunto de processos residentes em memória"
 
 #~ msgid "    -s\tthe maximum stack size"
 #~ msgstr "    -s\to tamanho máximo da pilha"
@@ -8117,15 +7571,13 @@ msgstr ""
 #~ msgstr "    -v\to tamanho da memória virtual"
 
 #~ msgid "If LIMIT is given, it is the new value of the specified resource."
-#~ msgstr ""
-#~ "Se LIMITE for fornecido, torna-se o novo valor do recurso especificado."
+#~ msgstr "Se LIMITE for fornecido, torna-se o novo valor do recurso especificado."
 
 #~ msgid "Otherwise, the current value of the specified resource is printed."
 #~ msgstr "Senão, o valor atual do recurso especificado é exibido."
 
 #~ msgid "If no option is given, then -f is assumed.  Values are in 1k"
-#~ msgstr ""
-#~ "Se nenhuma opção for fornecida, então -f é assumido. Os valores são em"
+#~ msgstr "Se nenhuma opção for fornecida, então -f é assumido. Os valores são em"
 
 #~ msgid "increments, except for -t, which is in seconds, -p, which is in"
 #~ msgstr "incrementos de 1k, exceto para -t, que é em segundos, -p, que é em"
@@ -8136,101 +7588,77 @@ msgstr ""
 #~ msgid "processes."
 #~ msgstr "processos."
 
-#~ msgid ""
-#~ "The user file-creation mask is set to MODE.  If MODE is omitted, or if"
-#~ msgstr ""
-#~ "MODO é atribuído à máscara de criação de arquivos do usuário.  Se omitido,"
+#~ msgid "The user file-creation mask is set to MODE.  If MODE is omitted, or if"
+#~ msgstr "MODO é atribuído à máscara de criação de arquivos do usuário.  Se omitido,"
 
-#~ msgid ""
-#~ "`-S' is supplied, the current value of the mask is printed.  The `-S'"
-#~ msgstr ""
-#~ "ou se `-S' for especificado, a máscara em uso é exibida.  A opção `-S'"
+#~ msgid "`-S' is supplied, the current value of the mask is printed.  The `-S'"
+#~ msgstr "ou se `-S' for especificado, a máscara em uso é exibida.  A opção `-S'"
 
-#~ msgid ""
-#~ "option makes the output symbolic; otherwise an octal number is output."
+#~ msgid "option makes the output symbolic; otherwise an octal number is output."
 #~ msgstr "exibe símbolos na saída; sem esta opção um número octal é exibido."
 
 #~ msgid "If MODE begins with a digit, it is interpreted as an octal number,"
-#~ msgstr ""
-#~ "Se MODO começar por um dígito, é interpretado como sendo um número octal,"
+#~ msgstr "Se MODO começar por um dígito, é interpretado como sendo um número octal,"
 
-#~ msgid ""
-#~ "otherwise it is a symbolic mode string like that accepted by chmod(1)."
-#~ msgstr ""
-#~ "senão devem ser caracteres simbólicos, como os aceitos por chmod(1)."
+#~ msgid "otherwise it is a symbolic mode string like that accepted by chmod(1)."
+#~ msgstr "senão devem ser caracteres simbólicos, como os aceitos por chmod(1)."
 
-#~ msgid ""
-#~ "Wait for the specified process and report its termination status.  If"
-#~ msgstr ""
-#~ "Aguardar pelo processo especificado e informar seu status de término. Se N"
+#~ msgid "Wait for the specified process and report its termination status.  If"
+#~ msgstr "Aguardar pelo processo especificado e informar seu status de término. Se N"
 
 #~ msgid "N is not given, all currently active child processes are waited for,"
-#~ msgstr ""
-#~ "não for especificado, todos os processos filhos ativos são aguardados,"
+#~ msgstr "não for especificado, todos os processos filhos ativos são aguardados,"
 
 #~ msgid "and the return code is zero.  N may be a process ID or a job"
 #~ msgstr "e o código de retorno é zero.  N pode ser o ID de um processo ou a"
 
 #~ msgid "specification; if a job spec is given, all processes in the job's"
-#~ msgstr ""
-#~ "especificação de um trabalho; Se for a especificação de um trabalho, todos"
+#~ msgstr "especificação de um trabalho; Se for a especificação de um trabalho, todos"
 
 #~ msgid "pipeline are waited for."
 #~ msgstr "os processos presentes no `pipeline' do trabalho são aguardados."
 
 #~ msgid "and the return code is zero.  N is a process ID; if it is not given,"
-#~ msgstr ""
-#~ "e o código de retorno é zero.  N é o ID de um processo; se N não for"
+#~ msgstr "e o código de retorno é zero.  N é o ID de um processo; se N não for"
 
 #~ msgid "all child processes of the shell are waited for."
 #~ msgstr "especificado, todos os processos filhos da shell são aguardados."
 
 #~ msgid "The `for' loop executes a sequence of commands for each member in a"
-#~ msgstr ""
-#~ "O laço `for' executa a seqüência de comandos para cada membro na lista de"
+#~ msgstr "O laço `for' executa a sequência de comandos para cada membro na lista de"
 
-#~ msgid ""
-#~ "list of items.  If `in WORDS ...;' is not present, then `in \"$@\"' is"
-#~ msgstr ""
-#~ "items.  Se `in PALAVRAS ...;' não estiver presente, então `in \"$@\"'"
+#~ msgid "list of items.  If `in WORDS ...;' is not present, then `in \"$@\"' is"
+#~ msgstr "items.  Se `in PALAVRAS ...;' não estiver presente, então `in \"$@\"'"
 
-#~ msgid ""
-#~ "assumed.  For each element in WORDS, NAME is set to that element, and"
-#~ msgstr ""
-#~ "(parâmetros posicionais) é assumido. Para cada elemento em PALAVRAS, NOME"
+#~ msgid "assumed.  For each element in WORDS, NAME is set to that element, and"
+#~ msgstr "(parâmetros posicionais) é assumido. Para cada elemento em PALAVRAS, NOME"
 
 #~ msgid "the COMMANDS are executed."
 #~ msgstr "assume seu valor, e os COMANDOS são executados."
 
 #~ msgid "The WORDS are expanded, generating a list of words.  The"
-#~ msgstr ""
-#~ "As palavras são expandidas, gerando uma lista de palavras. O conjunto"
+#~ msgstr "As palavras são expandidas, gerando uma lista de palavras. O conjunto"
 
 #~ msgid "set of expanded words is printed on the standard error, each"
-#~ msgstr ""
-#~ "de palavras expandidas é enviado para a saída de erro padrão, cada uma"
+#~ msgstr "de palavras expandidas é enviado para a saída de erro padrão, cada uma"
 
 #~ msgid "preceded by a number.  If `in WORDS' is not present, `in \"$@\"'"
-#~ msgstr ""
-#~ "precedida por um número.  Se `in PALAVRAS' for omitido, `in \"$@\"' é"
+#~ msgstr "precedida por um número.  Se `in PALAVRAS' for omitido, `in \"$@\"' é"
 
 #~ msgid "is assumed.  The PS3 prompt is then displayed and a line read"
 #~ msgstr "assumido.  Em seguida o prompt PS3 é exibido, e uma linha é lida da"
 
 #~ msgid "from the standard input.  If the line consists of the number"
-#~ msgstr ""
-#~ "entrada padrão.  Se a linha consistir do número correspondente ao número"
+#~ msgstr "entrada padrão.  Se a linha consistir do número correspondente ao número"
 
 #~ msgid "corresponding to one of the displayed words, then NAME is set"
 #~ msgstr "de uma das palavras exibidas, então NOME é atribuído para esta"
 
 #~ msgid "to that word.  If the line is empty, WORDS and the prompt are"
-#~ msgstr ""
-#~ "PALAVRA.  Se a linha estiver vazia, PALAVRAS e o prompt são exibidos"
+#~ msgstr "PALAVRA.  Se a linha estiver vazia, PALAVRAS e o prompt são exibidos"
 
 #~ msgid "redisplayed.  If EOF is read, the command completes.  Any other"
-#~ msgstr ""
-#~ "novamente.  Se EOF for lido, o comando termina.  Qualquer outro valor"
+#~ msgstr "novamente.  Se EOF for lido, o comando termina.  Qualquer outro valor"
 
 #~ msgid "value read causes NAME to be set to null.  The line read is saved"
 #~ msgstr "lido faz com que NOME seja tornado nulo.  A linha lida é salva"
@@ -8242,42 +7670,28 @@ msgstr ""
 #~ msgstr "até que o comando `break' ou `return' seja executado."
 
 #~ msgid "Selectively execute COMMANDS based upon WORD matching PATTERN.  The"
-#~ msgstr ""
-#~ "Executar seletivamente COMANDOS tomando por base a correspondência entre"
+#~ msgstr "Executar seletivamente COMANDOS tomando por base a correspondência entre"
 
 #~ msgid "`|' is used to separate multiple patterns."
-#~ msgstr ""
-#~ "PALAVRA e PADRÃO. O caracter `|' é usado para separar múltiplos padrões."
+#~ msgstr "PALAVRA e PADRÃO. O caracter `|' é usado para separar múltiplos padrões."
 
-#~ msgid ""
-#~ "The if COMMANDS are executed.  If the exit status is zero, then the then"
-#~ msgstr ""
-#~ "Os COMANDOS `if' são executados. Se os status de saída for zero, então os"
+#~ msgid "The if COMMANDS are executed.  If the exit status is zero, then the then"
+#~ msgstr "Os COMANDOS `if' são executados. Se os status de saída for zero, então os"
 
-#~ msgid ""
-#~ "COMMANDS are executed.  Otherwise, each of the elif COMMANDS are executed"
-#~ msgstr ""
-#~ "COMANDOS `then' são executados, senão, os COMANDOS `elif' são executados "
-#~ "em"
+#~ msgid "COMMANDS are executed.  Otherwise, each of the elif COMMANDS are executed"
+#~ msgstr "COMANDOS `then' são executados, senão, os COMANDOS `elif' são executados em"
 
-#~ msgid ""
-#~ "in turn, and if the exit status is zero, the corresponding then COMMANDS"
-#~ msgstr ""
-#~ "seqüência e, se o status de saída for zero, os COMANDOS `then' associados"
+#~ msgid "in turn, and if the exit status is zero, the corresponding then COMMANDS"
+#~ msgstr "sequência e, se o status de saída for zero, os COMANDOS `then' associados"
 
-#~ msgid ""
-#~ "are executed and the if command completes.  Otherwise, the else COMMANDS"
-#~ msgstr ""
-#~ "são executados e o `if' termina.  Senão, os COMANDOS da cláusula `else'"
+#~ msgid "are executed and the if command completes.  Otherwise, the else COMMANDS"
+#~ msgstr "são executados e o `if' termina.  Senão, os COMANDOS da cláusula `else'"
 
-#~ msgid ""
-#~ "are executed, if present.  The exit status is the exit status of the last"
-#~ msgstr ""
-#~ "são executados, se houver.  O status de saída é o status de saída do"
+#~ msgid "are executed, if present.  The exit status is the exit status of the last"
+#~ msgstr "são executados, se houver.  O status de saída é o status de saída do"
 
 #~ msgid "command executed, or zero if no condition tested true."
-#~ msgstr ""
-#~ "último comando executado, ou zero, se nenhuma condição for verdadeira."
+#~ msgstr "último comando executado, ou zero, se nenhuma condição for verdadeira."
 
 #~ msgid "Expand and execute COMMANDS as long as the final command in the"
 #~ msgstr "Expande e executa COMANDOS enquanto o comando final nos"
@@ -8304,22 +7718,16 @@ msgstr ""
 #~ msgstr "redirecionar todo um conjunto de comandos."
 
 #~ msgid "This is similar to the `fg' command.  Resume a stopped or background"
-#~ msgstr ""
-#~ "Semelhante ao comando `fg'. Prossegue a execução de um trabalho parado ou"
+#~ msgstr "Semelhante ao comando `fg'. Prossegue a execução de um trabalho parado ou"
 
 #~ msgid "job.  If you specifiy DIGITS, then that job is used.  If you specify"
-#~ msgstr ""
-#~ "em segundo plano. Se DÍGITOS for especificado, então este trabalho é "
-#~ "usado."
+#~ msgstr "em segundo plano. Se DÍGITOS for especificado, então este trabalho é usado."
 
-#~ msgid ""
-#~ "WORD, then the job whose name begins with WORD is used.  Following the"
-#~ msgstr ""
-#~ "Se for especificado PALAVRA, o trabalho começado por PALAVRA é usado."
+#~ msgid "WORD, then the job whose name begins with WORD is used.  Following the"
+#~ msgstr "Se for especificado PALAVRA, o trabalho começado por PALAVRA é usado."
 
 #~ msgid "job specification with a `&' places the job in the background."
-#~ msgstr ""
-#~ "Seguindo-se a especificação por um `&' põe o trabalho em segundo plano."
+#~ msgstr "Seguindo-se a especificação por um `&' põe o trabalho em segundo plano."
 
 #~ msgid "BASH_VERSION    The version numbers of this Bash."
 #~ msgstr "BASH_VERSION    Os números da versão desta `bash'."
@@ -8333,15 +7741,11 @@ msgstr ""
 #~ msgid "\t\tdirectory."
 #~ msgstr "\t\tencontrado no diretório atual."
 
-#~ msgid ""
-#~ "HISTFILE        The name of the file where your command history is stored."
-#~ msgstr ""
-#~ "HISTFILE        O nome do arquivo onde o histórico de comandos é "
-#~ "armazenado."
+#~ msgid "HISTFILE        The name of the file where your command history is stored."
+#~ msgstr "HISTFILE        O nome do arquivo onde o histórico de comandos é armazenado."
 
 #~ msgid "HISTFILESIZE    The maximum number of lines this file can contain."
-#~ msgstr ""
-#~ "HISTFILESIZE    O número máximo de linhas que este arquivo pode conter."
+#~ msgstr "HISTFILESIZE    O número máximo de linhas que este arquivo pode conter."
 
 #~ msgid "HISTSIZE        The maximum number of history lines that a running"
 #~ msgstr "HISTSIZE        O número máximo de linhas do histórico que uma"
@@ -8350,16 +7754,12 @@ msgstr ""
 #~ msgstr "\t\tshell em execução pode acessar."
 
 #~ msgid "HOME            The complete pathname to your login directory."
-#~ msgstr ""
-#~ "HOME            O nome completo do caminho do seu diretório de login."
+#~ msgstr "HOME            O nome completo do caminho do seu diretório de login."
 
-#~ msgid ""
-#~ "HOSTTYPE        The type of CPU this version of Bash is running under."
-#~ msgstr ""
-#~ "HOSTTYPE        O tipo de CPU sob a qual esta `bash' está executando."
+#~ msgid "HOSTTYPE        The type of CPU this version of Bash is running under."
+#~ msgstr "HOSTTYPE        O tipo de CPU sob a qual esta `bash' está executando."
 
-#~ msgid ""
-#~ "IGNOREEOF       Controls the action of the shell on receipt of an EOF"
+#~ msgid "IGNOREEOF       Controls the action of the shell on receipt of an EOF"
 #~ msgstr "IGNOREEOF       Controla a ação da shell ao receber um caracter"
 
 #~ msgid "\t\tcharacter as the sole input.  If set, then the value"
@@ -8372,16 +7772,13 @@ msgstr ""
 #~ msgstr "\t\tde forma seguida em uma linha vazia, antes da shell terminar"
 
 #~ msgid "\t\t(default 10).  When unset, EOF signifies the end of input."
-#~ msgstr ""
-#~ "\t\t(padrão 10).  Caso contrário, EOF significa o fim da entrada de dados."
+#~ msgstr "\t\t(padrão 10).  Caso contrário, EOF significa o fim da entrada de dados."
 
 #~ msgid "MAILCHECK\tHow often, in seconds, Bash checks for new mail."
-#~ msgstr ""
-#~ "MAILCHECK\tFreqüência, em segundos, para a `bash' verificar novo e-mail."
+#~ msgstr "MAILCHECK\tFreqüência, em segundos, para a `bash' verificar novo e-mail."
 
 #~ msgid "MAILPATH\tA colon-separated list of filenames which Bash checks"
-#~ msgstr ""
-#~ "MAILPATH\tUma lista, separada por dois pontos, de nomes de arquivos,"
+#~ msgstr "MAILPATH\tUma lista, separada por dois pontos, de nomes de arquivos,"
 
 #~ msgid "\t\tfor new mail."
 #~ msgstr "\t\tnos quais a `bash' vai verificar se existe novo e-mail."
@@ -8390,8 +7787,7 @@ msgstr ""
 #~ msgstr "OSTYPE\t\tA versão do Unix sob a qual a `bash' está executando."
 
 #~ msgid "PATH            A colon-separated list of directories to search when"
-#~ msgstr ""
-#~ "PATH            Uma lista, separada por dois pontos, de diretórios a"
+#~ msgstr "PATH            Uma lista, separada por dois pontos, de diretórios a"
 
 #~ msgid "\t\tlooking for commands."
 #~ msgstr "\t\tserem pesquisados quando os comandos forem procurados."
@@ -8412,20 +7808,16 @@ msgstr ""
 #~ msgstr "TERM            O nome do tipo de terminal em uso no momento."
 
 #~ msgid "auto_resume     Non-null means a command word appearing on a line by"
-#~ msgstr ""
-#~ "auto_resume     Não nulo significa que um comando aparecendo sozinho em"
+#~ msgstr "auto_resume     Não nulo significa que um comando aparecendo sozinho em"
 
 #~ msgid "\t\titself is first looked for in the list of currently"
-#~ msgstr ""
-#~ "\t\tlinha deve ser procurado primeiro na lista de trabalhos parados."
+#~ msgstr "\t\tlinha deve ser procurado primeiro na lista de trabalhos parados."
 
 #~ msgid "\t\tstopped jobs.  If found there, that job is foregrounded."
-#~ msgstr ""
-#~ "\t\tSe for encontrado na lista, o trabalho vai para o primeiro plano."
+#~ msgstr "\t\tSe for encontrado na lista, o trabalho vai para o primeiro plano."
 
 #~ msgid "\t\tA value of `exact' means that the command word must"
-#~ msgstr ""
-#~ "\t\tO valor `exact' significa que a palavra do comando deve corresponder"
+#~ msgstr "\t\tO valor `exact' significa que a palavra do comando deve corresponder"
 
 #~ msgid "\t\texactly match a command in the list of stopped jobs.  A"
 #~ msgstr "\t\texatamente a um comando da lista de trabalhos parados."
@@ -8437,23 +7829,19 @@ msgstr ""
 #~ msgstr "\t\tcorresponder a uma parte do trabalho.  Qualquer outro valor"
 
 #~ msgid "\t\tthe command must be a prefix of a stopped job."
-#~ msgstr ""
-#~ "\t\tsignifica que o comando deve ser um prefixo de um trabalho parado."
+#~ msgstr "\t\tsignifica que o comando deve ser um prefixo de um trabalho parado."
 
 #~ msgid "command_oriented_history"
 #~ msgstr "command_oriented_history"
 
-#~ msgid ""
-#~ "                Non-null means to save multiple-line commands together on"
-#~ msgstr ""
-#~ "                Se não for nulo significa salvar comandos com múltiplas"
+#~ msgid "                Non-null means to save multiple-line commands together on"
+#~ msgstr "                Se não for nulo significa salvar comandos com múltiplas"
 
 #~ msgid "                a single history line."
 #~ msgstr "                linhas, juntas em uma única linha do histórico."
 
 #~ msgid "histchars       Characters controlling history expansion and quick"
-#~ msgstr ""
-#~ "histchars       Caracteres que controlam a expansão do histórico e a"
+#~ msgstr "histchars       Caracteres que controlam a expansão do histórico e a"
 
 #~ msgid "\t\tsubstitution.  The first character is the history"
 #~ msgstr "\t\tsubstituição rápida.  O primeiro caracter é o de substituição"
@@ -8468,12 +7856,10 @@ msgstr ""
 #~ msgstr "\t\té o de comentário do histórico, geralmente o `#'."
 
 #~ msgid "HISTCONTROL\tSet to a value of `ignorespace', it means don't enter"
-#~ msgstr ""
-#~ "HISTCONTROL\tCom valor igual a `ignorespace', significa não introduzir"
+#~ msgstr "HISTCONTROL\tCom valor igual a `ignorespace', significa não introduzir"
 
 #~ msgid "\t\tlines which begin with a space or tab on the history"
-#~ msgstr ""
-#~ "\t\tlinhas que iniciam por espaço ou tabulação na lista de histórico."
+#~ msgstr "\t\tlinhas que iniciam por espaço ou tabulação na lista de histórico."
 
 #~ msgid "\t\tlist.  Set to a value of `ignoredups', it means don't"
 #~ msgstr "\t\tCom valor igual a `ignoredups', significa não introduzir linhas"
@@ -8485,8 +7871,7 @@ msgstr ""
 #~ msgstr "\t\t`ignoreboth' significa combinar as duas opções.  Remover,"
 
 #~ msgid "\t\tor set to any other value than those above means to save"
-#~ msgstr ""
-#~ "\t\tou atribuir algum outro valor que não os acima, significa salvar"
+#~ msgstr "\t\tou atribuir algum outro valor que não os acima, significa salvar"
 
 #~ msgid "\t\tall lines on the history list."
 #~ msgstr "\t\ttodas as linhas na lista de histórico."
@@ -8495,22 +7880,19 @@ msgstr ""
 #~ msgstr "Adiciona o diretório no topo da pilha de diretórios, ou rotaciona a"
 
 #~ msgid "the stack, making the new top of the stack the current working"
-#~ msgstr ""
-#~ "pilha, fazendo o diretório atual de trabalho ficar no topo da pilha."
+#~ msgstr "pilha, fazendo o diretório atual de trabalho ficar no topo da pilha."
 
 #~ msgid "directory.  With no arguments, exchanges the top two directories."
 #~ msgstr "Sem nenhum argumento, troca os dois diretórios do topo."
 
 #~ msgid "+N\tRotates the stack so that the Nth directory (counting"
-#~ msgstr ""
-#~ "+N\tRotaciona a pilha de tal forma que o n-ésimo diretório (contado a"
+#~ msgstr "+N\tRotaciona a pilha de tal forma que o n-ésimo diretório (contado a"
 
 #~ msgid "\tfrom the left of the list shown by `dirs') is at the top."
 #~ msgstr "\tpartir da esquerda da lista exibida por `dirs') fique no topo."
 
 #~ msgid "-N\tRotates the stack so that the Nth directory (counting"
-#~ msgstr ""
-#~ "-N\tRotaciona a pilha de tal forma que o n-ésimo diretório (contado a"
+#~ msgstr "-N\tRotaciona a pilha de tal forma que o n-ésimo diretório (contado a"
 
 #~ msgid "\tfrom the right) is at the top."
 #~ msgstr "\tpartir da direita) fique no topo."
@@ -8551,8 +7933,7 @@ msgstr ""
 #~ msgid "\tremoves the last directory, `popd -1' the next to last."
 #~ msgstr "\tremove o último diretório, `popd -1' o penúltimo."
 
-#~ msgid ""
-#~ "-n\tsuppress the normal change of directory when removing directories"
+#~ msgid "-n\tsuppress the normal change of directory when removing directories"
 #~ msgstr "-n\tsuprime a troca normal de diretório ao remover-se diretórios"
 
 #~ msgid "\tfrom the stack, so only the stack is manipulated."
@@ -8567,57 +7948,44 @@ msgstr ""
 #~ msgid "back up through the list with the `popd' command."
 #~ msgstr "removidos da lista através do comando `popd'."
 
-#~ msgid ""
-#~ "The -l flag specifies that `dirs' should not print shorthand versions"
+#~ msgid "The -l flag specifies that `dirs' should not print shorthand versions"
 #~ msgstr "A opção -l especifica que `dirs' não deve exibir a versão resumida"
 
-#~ msgid ""
-#~ "of directories which are relative to your home directory.  This means"
-#~ msgstr ""
-#~ "dos diretórios relativos ao seu diretório `home'. Isto significa que"
+#~ msgid "of directories which are relative to your home directory.  This means"
+#~ msgstr "dos diretórios relativos ao seu diretório `home'. Isto significa que"
 
 #~ msgid "that `~/bin' might be displayed as `/homes/bfox/bin'.  The -v flag"
-#~ msgstr ""
-#~ "`~/bin' deve ser exibido como `/home/você/bin'.  A opção -v faz com que"
+#~ msgstr "`~/bin' deve ser exibido como `/home/você/bin'.  A opção -v faz com que"
 
 #~ msgid "causes `dirs' to print the directory stack with one entry per line,"
 #~ msgstr "`dirs' exiba a pilha de diretórios com uma entrada por linha,"
 
-#~ msgid ""
-#~ "prepending the directory name with its position in the stack.  The -p"
+#~ msgid "prepending the directory name with its position in the stack.  The -p"
 #~ msgstr "antecedendo o nome do diretório com a sua posição na pilha. A opção"
 
 #~ msgid "flag does the same thing, but the stack position is not prepended."
 #~ msgstr "-p faz a mesma coisa, mas a posição na pilha não é exibida. A opção"
 
-#~ msgid ""
-#~ "The -c flag clears the directory stack by deleting all of the elements."
+#~ msgid "The -c flag clears the directory stack by deleting all of the elements."
 #~ msgstr "-c limpa a pilha de diretórios apagando todos os seus elementos."
 
-#~ msgid ""
-#~ "+N\tdisplays the Nth entry counting from the left of the list shown by"
-#~ msgstr ""
-#~ "+N\texibe a n-ésima entrada contada a partir da esquerda da lista exibida"
+#~ msgid "+N\tdisplays the Nth entry counting from the left of the list shown by"
+#~ msgstr "+N\texibe a n-ésima entrada contada a partir da esquerda da lista exibida"
 
 #~ msgid "\tdirs when invoked without options, starting with zero."
 #~ msgstr "\tpor `dirs', quando este é chamado sem opções, começando por zero."
 
-#~ msgid ""
-#~ "-N\tdisplays the Nth entry counting from the right of the list shown by"
-#~ msgstr ""
-#~ "-N\texibe a n-ésima entrada contada a partir da direita da lista exibida"
+#~ msgid "-N\tdisplays the Nth entry counting from the right of the list shown by"
+#~ msgstr "-N\texibe a n-ésima entrada contada a partir da direita da lista exibida"
 
 #~ msgid "Toggle the values of variables controlling optional behavior."
-#~ msgstr ""
-#~ "Alterna os valores das variáveis controladoras de comportamentos "
-#~ "opcionais."
+#~ msgstr "Alterna os valores das variáveis controladoras de comportamentos opcionais."
 
 #~ msgid "The -s flag means to enable (set) each OPTNAME; the -u flag"
 #~ msgstr "A opção -s ativa (set) cada NOME-OPÇÃO; a opção -u desativa cada"
 
 #~ msgid "unsets each OPTNAME.  The -q flag suppresses output; the exit"
-#~ msgstr ""
-#~ "NOME-OPÇÃO. A opção -q suprime a saída; o status de término indica se"
+#~ msgstr "NOME-OPÇÃO. A opção -q suprime a saída; o status de término indica se"
 
 #~ msgid "status indicates whether each OPTNAME is set or unset.  The -o"
 #~ msgstr "cada NOME-OPÇÃO foi ativado ou desativado  A opção -o restringe"
@@ -8629,8 +7997,7 @@ msgstr ""
 #~ msgstr "Sem nenhuma opção, ou com a opção -p, uma lista com todas as"
 
 #~ msgid "settable options is displayed, with an indication of whether or"
-#~ msgstr ""
-#~ "opções que podem ser ativadas é exibida, com indicação sobre se cada uma"
+#~ msgstr "opções que podem ser ativadas é exibida, com indicação sobre se cada uma"
 
 #~ msgid "not each is set."
 #~ msgstr "das opções está ativa ou não."

sig.c

@@ -55,7 +55,8 @@
 #  include "bashhist.h"
 #endif
 
-extern void initialize_siglist ();
+extern void initialize_siglist PARAMS((void));
+extern void set_original_signal PARAMS((int, SigHandler *));
 
 #if !defined (JOB_CONTROL)
 extern void initialize_job_signals PARAMS((void));
@@ -255,6 +256,13 @@ initialize_terminating_signals ()
       sigaction (XSIG (i), &act, &oact);
       XHANDLER(i) = oact.sa_handler;
       XSAFLAGS(i) = oact.sa_flags;
+
+#if 0
+      set_original_signal (XSIG(i), XHANDLER(i));	/* optimization */
+#else
+      set_original_signal (XSIG(i), act.sa_handler);	/* optimization */
+#endif
+
       /* Don't do anything with signals that are ignored at shell entry
 	 if the shell is not interactive. */
       /* XXX - should we do this for interactive shells, too? */

subst.c

@@ -5951,6 +5951,7 @@ process_substitute (string, open_for_read_in_child)
       free_pushed_string_input ();
       /* Cancel traps, in trap.c. */
       restore_original_signals ();	/* XXX - what about special builtins? bash-4.2 */
+      subshell_environment &= ~SUBSHELL_IGNTRAP;
       QUIT;	/* catch any interrupts we got post-fork */
       setup_async_signals ();
 #if 0
@@ -6382,6 +6383,7 @@ command_substitute (string, quoted, flags)
 	}	
       QUIT;	/* catch any interrupts we got post-fork */
       subshell_environment |= SUBSHELL_RESETTRAP;
+      subshell_environment &= ~SUBSHELL_IGNTRAP;
     }
 
 #if defined (JOB_CONTROL)

tests/RUN-ONE-TEST

-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/errors.right

@@ -11,93 +11,95 @@ declare -fr func
 unset: usage: unset [-f] [-v] [-n] [name ...]
 ./errors.tests: line 55: unset: func: cannot unset: readonly function
 ./errors.tests: line 58: declare: func: readonly function
-./errors.tests: line 62: unset: XPATH: cannot unset: readonly variable
-./errors.tests: line 68: unset: cannot simultaneously unset a function and a variable
-./errors.tests: line 71: declare: -z: invalid option
+./errors.tests: line 62: declare: -a: invalid option
+./errors.tests: line 63: declare: -i: invalid option
+./errors.tests: line 67: unset: XPATH: cannot unset: readonly variable
+./errors.tests: line 73: unset: cannot simultaneously unset a function and a variable
+./errors.tests: line 76: declare: -z: invalid option
 declare: usage: declare [-aAfFgiIlnrtux] [-p] [name[=value] ...]
-./errors.tests: line 73: declare: `-z': not a valid identifier
-./errors.tests: line 74: declare: `/bin/sh': not a valid identifier
-./errors.tests: line 78: declare: cannot use `-f' to make functions
-./errors.tests: line 81: exec: -i: invalid option
+./errors.tests: line 78: declare: `-z': not a valid identifier
+./errors.tests: line 79: declare: `/bin/sh': not a valid identifier
+./errors.tests: line 83: declare: cannot use `-f' to make functions
+./errors.tests: line 86: exec: -i: invalid option
 exec: usage: exec [-cl] [-a name] [command [argument ...]] [redirection ...]
-./errors.tests: line 85: export: XPATH: not a function
-./errors.tests: line 88: break: only meaningful in a `for', `while', or `until' loop
-./errors.tests: line 89: continue: only meaningful in a `for', `while', or `until' loop
-./errors.tests: line 92: shift: label: numeric argument required
-./errors.tests: line 97: shift: too many arguments
-./errors.tests: line 103: let: expression expected
-./errors.tests: line 106: local: can only be used in a function
-./errors.tests: line 109: logout: not login shell: use `exit'
-./errors.tests: line 112: hash: notthere: not found
-./errors.tests: line 115: hash: -v: invalid option
+./errors.tests: line 90: export: XPATH: not a function
+./errors.tests: line 93: break: only meaningful in a `for', `while', or `until' loop
+./errors.tests: line 94: continue: only meaningful in a `for', `while', or `until' loop
+./errors.tests: line 97: shift: label: numeric argument required
+./errors.tests: line 102: shift: too many arguments
+./errors.tests: line 108: let: expression expected
+./errors.tests: line 111: local: can only be used in a function
+./errors.tests: line 114: logout: not login shell: use `exit'
+./errors.tests: line 117: hash: notthere: not found
+./errors.tests: line 120: hash: -v: invalid option
 hash: usage: hash [-lr] [-p pathname] [-dt] [name ...]
-./errors.tests: line 119: hash: hashing disabled
-./errors.tests: line 122: export: `AA[4]': not a valid identifier
-./errors.tests: line 123: readonly: `AA[4]': not a valid identifier
-./errors.tests: line 126: unset: [-2]: bad array subscript
-./errors.tests: line 130: AA: readonly variable
-./errors.tests: line 134: AA: readonly variable
-./errors.tests: line 142: shift: 5: shift count out of range
-./errors.tests: line 143: shift: -2: shift count out of range
-./errors.tests: line 146: shopt: no_such_option: invalid shell option name
-./errors.tests: line 147: shopt: no_such_option: invalid shell option name
-./errors.tests: line 150: umask: 09: octal number out of range
-./errors.tests: line 151: umask: `:': invalid symbolic mode character
-./errors.tests: line 152: umask: `:': invalid symbolic mode operator
-./errors.tests: line 155: umask: -i: invalid option
+./errors.tests: line 124: hash: hashing disabled
+./errors.tests: line 127: export: `AA[4]': not a valid identifier
+./errors.tests: line 128: readonly: `AA[4]': not a valid identifier
+./errors.tests: line 131: unset: [-2]: bad array subscript
+./errors.tests: line 135: AA: readonly variable
+./errors.tests: line 139: AA: readonly variable
+./errors.tests: line 147: shift: 5: shift count out of range
+./errors.tests: line 148: shift: -2: shift count out of range
+./errors.tests: line 151: shopt: no_such_option: invalid shell option name
+./errors.tests: line 152: shopt: no_such_option: invalid shell option name
+./errors.tests: line 155: umask: 09: octal number out of range
+./errors.tests: line 156: umask: `:': invalid symbolic mode character
+./errors.tests: line 157: umask: `:': invalid symbolic mode operator
+./errors.tests: line 160: umask: -i: invalid option
 umask: usage: umask [-p] [-S] [mode]
-./errors.tests: line 159: umask: `u': invalid symbolic mode character
-./errors.tests: line 168: VAR: readonly variable
-./errors.tests: line 171: declare: VAR: readonly variable
-./errors.tests: line 172: declare: VAR: readonly variable
-./errors.tests: line 174: declare: unset: not found
-./errors.tests: line 177: VAR: readonly variable
-./errors.tests: command substitution: line 181: syntax error near unexpected token `)'
-./errors.tests: command substitution: line 181: ` for z in 1 2 3; do )'
-./errors.tests: command substitution: line 182: syntax error near unexpected token `done'
-./errors.tests: command substitution: line 182: ` for z in 1 2 3; done )'
-./errors.tests: line 184: cd: HOME not set
-./errors.tests: line 185: cd: /tmp/xyz.bash: No such file or directory
-./errors.tests: line 187: cd: OLDPWD not set
-./errors.tests: line 188: cd: /bin/sh: Not a directory
-./errors.tests: line 190: cd: /tmp/cd-notthere: No such file or directory
-./errors.tests: line 193: .: filename argument required
+./errors.tests: line 164: umask: `u': invalid symbolic mode character
+./errors.tests: line 173: VAR: readonly variable
+./errors.tests: line 176: declare: VAR: readonly variable
+./errors.tests: line 177: declare: VAR: readonly variable
+./errors.tests: line 179: declare: unset: not found
+./errors.tests: line 182: VAR: readonly variable
+./errors.tests: command substitution: line 186: syntax error near unexpected token `)'
+./errors.tests: command substitution: line 186: ` for z in 1 2 3; do )'
+./errors.tests: command substitution: line 187: syntax error near unexpected token `done'
+./errors.tests: command substitution: line 187: ` for z in 1 2 3; done )'
+./errors.tests: line 189: cd: HOME not set
+./errors.tests: line 190: cd: /tmp/xyz.bash: No such file or directory
+./errors.tests: line 192: cd: OLDPWD not set
+./errors.tests: line 193: cd: /bin/sh: Not a directory
+./errors.tests: line 195: cd: /tmp/cd-notthere: No such file or directory
+./errors.tests: line 198: .: filename argument required
 .: usage: . filename [arguments]
-./errors.tests: line 194: source: filename argument required
+./errors.tests: line 199: source: filename argument required
 source: usage: source filename [arguments]
-./errors.tests: line 197: .: -i: invalid option
+./errors.tests: line 202: .: -i: invalid option
 .: usage: . filename [arguments]
-./errors.tests: line 200: set: -q: invalid option
+./errors.tests: line 205: set: -q: invalid option
 set: usage: set [-abefhkmnptuvxBCHP] [-o option-name] [--] [arg ...]
-./errors.tests: line 203: enable: sh: not a shell builtin
-./errors.tests: line 203: enable: bash: not a shell builtin
-./errors.tests: line 206: shopt: cannot set and unset shell options simultaneously
-./errors.tests: line 209: read: var: invalid timeout specification
-./errors.tests: line 212: read: `/bin/sh': not a valid identifier
-./errors.tests: line 215: VAR: readonly variable
-./errors.tests: line 218: readonly: -x: invalid option
+./errors.tests: line 208: enable: sh: not a shell builtin
+./errors.tests: line 208: enable: bash: not a shell builtin
+./errors.tests: line 211: shopt: cannot set and unset shell options simultaneously
+./errors.tests: line 214: read: var: invalid timeout specification
+./errors.tests: line 217: read: `/bin/sh': not a valid identifier
+./errors.tests: line 220: VAR: readonly variable
+./errors.tests: line 223: readonly: -x: invalid option
 readonly: usage: readonly [-aAf] [name[=value] ...] or readonly -p
-./errors.tests: line 221: eval: -i: invalid option
+./errors.tests: line 226: eval: -i: invalid option
 eval: usage: eval [arg ...]
-./errors.tests: line 222: command: -i: invalid option
+./errors.tests: line 227: command: -i: invalid option
 command: usage: command [-pVv] command [arg ...]
-./errors.tests: line 225: /bin/sh + 0: syntax error: operand expected (error token is "/bin/sh + 0")
-./errors.tests: line 226: /bin/sh + 0: syntax error: operand expected (error token is "/bin/sh + 0")
-./errors.tests: line 229: trap: NOSIG: invalid signal specification
-./errors.tests: line 232: trap: -s: invalid option
+./errors.tests: line 230: /bin/sh + 0: syntax error: operand expected (error token is "/bin/sh + 0")
+./errors.tests: line 231: /bin/sh + 0: syntax error: operand expected (error token is "/bin/sh + 0")
+./errors.tests: line 234: trap: NOSIG: invalid signal specification
+./errors.tests: line 237: trap: -s: invalid option
 trap: usage: trap [-lp] [[arg] signal_spec ...]
-./errors.tests: line 238: return: can only `return' from a function or sourced script
-./errors.tests: line 242: break: 0: loop count out of range
-./errors.tests: line 246: continue: 0: loop count out of range
-./errors.tests: line 251: builtin: bash: not a shell builtin
-./errors.tests: line 255: bg: no job control
-./errors.tests: line 256: fg: no job control
-./errors.tests: line 259: kill: -s: option requires an argument
-./errors.tests: line 261: kill: S: invalid signal specification
-./errors.tests: line 263: kill: `': not a pid or valid job spec
+./errors.tests: line 243: return: can only `return' from a function or sourced script
+./errors.tests: line 247: break: 0: loop count out of range
+./errors.tests: line 251: continue: 0: loop count out of range
+./errors.tests: line 256: builtin: bash: not a shell builtin
+./errors.tests: line 260: bg: no job control
+./errors.tests: line 261: fg: no job control
+./errors.tests: line 264: kill: -s: option requires an argument
+./errors.tests: line 266: kill: S: invalid signal specification
+./errors.tests: line 268: kill: `': not a pid or valid job spec
 kill: usage: kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]
-./errors.tests: line 268: set: trackall: invalid option name
-./errors.tests: line 272: xx: readonly variable
+./errors.tests: line 273: set: trackall: invalid option name
+./errors.tests: line 277: xx: readonly variable
 1
 ./errors1.sub: line 14: .: -i: invalid option
 .: usage: . filename [arguments]
@@ -197,4 +199,4 @@ ok 6
 bash: line 1: return: can only `return' from a function or sourced script
 after return
 bash: line 1: return: can only `return' from a function or sourced script
-./errors.tests: line 299: `!!': not a valid identifier
+./errors.tests: line 304: `!!': not a valid identifier

tests/errors.tests

@@ -57,6 +57,11 @@ unset -f func
 declare -fr func
 declare -f +r func
 
+# cannot use declare -f in combination with other attributes
+a() { echo a; }
+declare -f -a a
+declare -f -i b c
+
 XPATH=$PATH
 declare -r XPATH
 unset -v XPATH

tests/nameref.right

@@ -348,6 +348,10 @@ declare -a v=([1]="1")
 declare -a v=([0]="0" [1]="1")
 declare -n n="v[1]"
 declare -a v=([0]="0")
+./nameref15.sub: line 120: warning: xref: removing nameref attribute
+declare -a xref=([1]="one")
+./nameref15.sub: line 126: warning: xref: removing nameref attribute
+declare -a xref=([1]="one")
 declare -n r1="y"
 declare -n r2="x"
 ./nameref16.sub: line 25: typeset: x: not found
@@ -440,6 +444,8 @@ declare -n foo="bar"
 declare -- bar
 declare -- foo="bar"
 declare -- bar
+8
+declare -n ivar="foo"
 declare -a v=([0]="Y")
 r: <Y>
 v: <Y>
@@ -483,3 +489,24 @@ declare -n ref="var"
 declare -ai var=([1]="0")
 declare -n ref="var"
 declare -- var="1"
+a string with spaces
+many spaces
+declare -n foo="bar[0]"
+declare -a bar=([0]=" still more spaces")
+declare -n foo="bar[0]"
+declare -a bar=([0]="spaces still more spaces")
+./nameref22.sub: line 50: declare: array: reference variable cannot be an array
+./nameref22.sub: line 53: declare: array[128]: reference variable cannot be an array
+declare -a array=([0]="one" [1]="two" [2]="three")
+declare -- array="(one two three)"
+declare -a array=([0]="one" [1]="two" [2]="three")
+./nameref22.sub: line 69: declare: `(one two three)': invalid variable name for name reference
+./nameref22.sub: line 70: declare: array: reference variable cannot be an array
+declare -a array=([0]="zero")
+./nameref22.sub: line 74: declare: array: reference variable cannot be an array
+declare -a array=([0]="one" [1]="two" [2]="three")
+./nameref22.sub: line 79: declare: array: reference variable cannot be an array
+declare -a array
+declare -ai array=([0]="one")
+declare -a array=([0]="zero")
+declare -a array=([0]="one" [1]="two" [2]="three")

tests/nameref15.sub

@@ -115,3 +115,13 @@ v=(0 1)
 declare -n n=v[1]
 unset n
 declare -p n v
+
+declare -n xref
+declare -a xref[1]=one
+declare -p xref
+
+unset xref
+declare -n xref
+xref=array
+declare -a xref[1]=one
+declare -p xref

tests/nameref19.sub

@@ -62,3 +62,12 @@ declare bar
 declare -p foo bar
 declare +n foo
 declare -p foo bar
+
+# but when we add the nameref attribute, we remove other attributes
+
+declare -i ivar
+ivar=4+4
+echo $ivar
+
+declare -n ivar=foo
+declare -p ivar

tests/nameref22.sub

+#   This program 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.
+#
+#   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+declare -n foo=bar
+
+declare foo='a string with spaces'
+echo $foo
+
+unset foo
+declare foo+='many spaces'
+echo $foo
+
+unset foo	# unsets bar
+unset -n foo
+
+declare -a bar
+declare -n foo='bar[0]'
+declare foo+=' still more spaces'
+
+declare -p foo bar
+unset -n foo
+unset bar
+
+declare -a bar
+declare -n foo='bar[0]'
+declare foo=spaces
+declare foo+=' still more spaces'
+
+declare -p foo bar
+
+unset -n foo
+unset bar
+
+ray=ray
+
+declare -a array
+array[0]=zero
+
+declare -n array
+unset array
+
+declare -n array[128]
+unset array
+
+declare -a array='(one two three)'
+declare -p array
+unset array
+
+declare array='(one two three)'
+declare -p array
+unset array
+
+declare -a ar$ray='(one two three)'
+declare -p ar$ray
+unset array
+
+declare -a array=(zero)
+declare -n array='(one two three)'
+declare -n array=three
+declare -p array
+unset array
+
+declare -n array=(one two three)
+declare -p array
+unset array
+
+declare -a array
+declare -n array=one
+declare -p array
+unset array
+
+array=one
+declare -i array[64];
+declare -p array
+unset array
+
+declare -a array=zero
+declare -p array
+unset array
+
+declare -a array
+declare array='(one two three)'
+declare -p array
+unset array
+
+

trap.c

@@ -481,6 +481,32 @@ trap_handler (sig)
       SIGRETURN (0);
     }
 
+  /* This means we're in a subshell, but have not yet reset the handler for
+     trapped signals. We're not supposed to execute the trap in this situation;
+     we should restore the original signal and resend the signal to ourselves
+     to preserve the Posix "signal traps that are not being ignored shall be
+     set to the default action" semantics. */
+  if ((subshell_environment & SUBSHELL_IGNTRAP) && trap_list[sig] != (char *)IGNORE_SIG)
+    {
+      sigset_t mask;
+
+      /* Paranoia */
+      if (original_signals[sig] == IMPOSSIBLE_TRAP_HANDLER)
+	original_signals[sig] = SIG_DFL;
+
+      restore_signal (sig);
+
+      /* Make sure we let the signal we just caught through */
+      sigemptyset (&mask);
+      sigprocmask (SIG_SETMASK, (sigset_t *)NULL, &mask);
+      sigdelset (&mask, sig);
+      sigprocmask (SIG_SETMASK, &mask, (sigset_t *)NULL);
+
+      kill (getpid (), sig);
+
+      SIGRETURN (0);
+    }
+
   if ((sig >= NSIG) ||
       (trap_list[sig] == (char *)DEFAULT_SIG) ||
       (trap_list[sig] == (char *)IGNORE_SIG))