From 5a7a52eade229bc55c4883d858b36b5f6112bdb7 Mon Sep 17 00:00:00 2001
From: Chet Ramey <chet.ramey@case.edu>
Date: Thu, 7 Jan 2021 14:26:11 -0500
Subject: [PATCH] commit bash-20210104 snapshot

---
 CWRU/CWRU.chlog        |    8 +
 MANIFEST               |    1 +
 builtins/declare.def   |   24 +-
 builtins/declare.def.1 | 1040 +++++++++++++++++++++
 builtins/declare.def.2 | 1039 +++++++++++++++++++++
 builtins/declare.def.3 | 1059 ++++++++++++++++++++++
 po/pt_BR.gmo           |  Bin 162997 -> 182906 bytes
 po/pt_BR.po            | 1963 ++++++++++++++--------------------------
 tests/RUN-ONE-TEST     |    2 +-
 tests/errors.right     |  152 ++--
 tests/errors.tests     |    5 +
 tests/nameref.right    |   27 +
 tests/nameref15.sub    |   10 +
 tests/nameref19.sub    |    9 +
 tests/nameref22.sub    |   97 ++
 15 files changed, 4059 insertions(+), 1377 deletions(-)
 create mode 100644 builtins/declare.def.1
 create mode 100644 builtins/declare.def.2
 create mode 100644 builtins/declare.def.3
 create mode 100644 tests/nameref22.sub

diff --git a/CWRU/CWRU.chlog b/CWRU/CWRU.chlog
index ad5d27d9..3ae3d66b 100644
--- a/CWRU/CWRU.chlog
+++ b/CWRU/CWRU.chlog
@@ -9294,3 +9294,11 @@ sig.c
 	  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
diff --git a/MANIFEST b/MANIFEST
index 851bbda2..7a73554f 100644
--- a/MANIFEST
+++ b/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
diff --git a/builtins/declare.def b/builtins/declare.def
index 21e4516d..5a0fc615 100644
--- a/builtins/declare.def
+++ b/builtins/declare.def
@@ -1,7 +1,7 @@
 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);
 
diff --git a/builtins/declare.def.1 b/builtins/declare.def.1
new file mode 100644
index 00000000..afe37e9e
--- /dev/null
+++ b/builtins/declare.def.1
@@ -0,0 +1,1040 @@
+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));
+}
diff --git a/builtins/declare.def.2 b/builtins/declare.def.2
new file mode 100644
index 00000000..014bec9c
--- /dev/null
+++ b/builtins/declare.def.2
@@ -0,0 +1,1039 @@
+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));
+}
diff --git a/builtins/declare.def.3 b/builtins/declare.def.3
new file mode 100644
index 00000000..927e4ea2
--- /dev/null
+++ b/builtins/declare.def.3
@@ -0,0 +1,1059 @@
+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));
+}
diff --git a/po/pt_BR.gmo b/po/pt_BR.gmo
index cd1093ad72e47fb9c9a4d1b9bdce78729fcb1e9f..c61c0b5837d0b5cdbd33064f297ed53e83694100 100644
GIT binary patch
delta 30529
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

delta 13954
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

diff --git a/po/pt_BR.po b/po/pt_BR.po
index 919784c3..cddc1d90 100644
--- a/po/pt_BR.po
+++ b/po/pt_BR.po
@@ -1,23 +1,23 @@
 # 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."
diff --git a/tests/RUN-ONE-TEST b/tests/RUN-ONE-TEST
index 0b063810..c8bef8dd 100755
--- a/tests/RUN-ONE-TEST
+++ b/tests/RUN-ONE-TEST
@@ -1,4 +1,4 @@
-BUILD_DIR=/usr/local/build/chet/bash/bash-current
+BUILD_DIR=/usr/local/build/bash/bash-current
 THIS_SH=$BUILD_DIR/bash
 PATH=$PATH:$BUILD_DIR
 
diff --git a/tests/errors.right b/tests/errors.right
index be0c8959..93c73a39 100644
--- a/tests/errors.right
+++ b/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
diff --git a/tests/errors.tests b/tests/errors.tests
index 531b625b..65cf830e 100644
--- a/tests/errors.tests
+++ b/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
diff --git a/tests/nameref.right b/tests/nameref.right
index 296105c9..8fa8211a 100644
--- a/tests/nameref.right
+++ b/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")
diff --git a/tests/nameref15.sub b/tests/nameref15.sub
index cce8fbd9..e9a09eeb 100644
--- a/tests/nameref15.sub
+++ b/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
diff --git a/tests/nameref19.sub b/tests/nameref19.sub
index b00f68e5..d4b900e8 100644
--- a/tests/nameref19.sub
+++ b/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
diff --git a/tests/nameref22.sub b/tests/nameref22.sub
new file mode 100644
index 00000000..4e44fbb3
--- /dev/null
+++ b/tests/nameref22.sub
@@ -0,0 +1,97 @@
+#   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
+
+