This file is declare.def, from which is created declare.c.
It implements the builtins "declare" and "local" in Bash.
-Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
+Copyright (C) 1987-2012 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 1, or (at your option) any later
-version.
+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.
+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; see the file COPYING. If not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+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 [-afFrxi] [-p] name[=value] ...
-Declare variables and/or give them attributes. If no NAMEs are
-given, then display the values of variables instead. The -p option
-will display the attributes and values of each NAME.
-
-The flags are:
-
- -a to make NAMEs arrays (if supported)
- -f to select from among function names only
- -F to display function names without definitions
+$SHORT_DOC declare [-aAfFgilnrtux] [-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
+ -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 NAMEs 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 NAMEs to upper case on assignment
-x to make NAMEs export
- -i to make NAMEs have the `integer' attribute set
+
+Using `+' instead of `-' turns off the given attribute.
Variables with the integer attribute have arithmetic evaluation (see
-`let') done when the variable is assigned to.
+the `let' command) performed when the variable is assigned a value.
-When displaying values of variables, -f displays a function's name
-and definition. The -F option restricts the display to function
-name only.
+When used in a function, `declare' makes NAMEs local, as with the `local'
+command. The `-g' option suppresses this behavior.
-Using `+' instead of `-' turns off the given attribute instead. When
-used in a function, makes NAMEs local, as with the `local' command.
+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 [-afFrxi] [-p] name[=value] ...
-Obsolete. See `declare'.
+$SHORT_DOC typeset [-aAfFgilrtux] [-p] name[=value] ...
+Set variable values and attributes.
+
+Obsolete. 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 "common.h"
#include "builtext.h"
+#include "bashgetopt.h"
-extern int variable_context, array_needs_making;
+extern int array_needs_making;
+extern int posixly_correct;
-static int declare_internal ();
+static int declare_internal __P((register WORD_LIST *, int));
/* Declare or change variable attributes. */
int
$BUILTIN local
$FUNCTION local_builtin
-$SHORT_DOC local name[=value] ...
-Create a local variable called NAME, and give it VALUE. LOCAL
-can only be used within a function; it makes the variable NAME
-have a visible scope restricted to that function and its children.
+$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)
return (declare_internal (list, 1));
else
{
- builtin_error ("can only be used in a function");
+ builtin_error (_("can only be used in a function"));
return (EXECUTION_FAILURE);
}
}
+#if defined (ARRAY_VARS)
+# define DECLARE_OPTS "+acfgilnprtuxAF"
+#else
+# define DECLARE_OPTS "+cfgilnprtuxF"
+#endif
+
/* The workhorse function. */
static int
declare_internal (list, local_var)
register WORD_LIST *list;
int local_var;
{
- int flags_on, flags_off, *flags, any_failed, assign_error, pflag, nodefs;
- char *t;
- SHELL_VAR *var;
-
- flags_on = flags_off = any_failed = assign_error = pflag = nodefs = 0;
- while (list)
+ int flags_on, flags_off, *flags;
+ int any_failed, assign_error, pflag, nodefs, opt, mkglobal, onref, offref;
+ char *t, *subscript_start;
+ SHELL_VAR *var, *refvar, *v;
+ FUNCTION_DEF *shell_fn;
+
+ flags_on = flags_off = any_failed = assign_error = pflag = nodefs = mkglobal = 0;
+ refvar = (SHELL_VAR *)NULL;
+ reset_internal_getopt ();
+ while ((opt = internal_getopt (list, DECLARE_OPTS)) != EOF)
{
- t = list->word->word;
- if (t[0] == '-' && t[1] == '-' && t[2] == '\0')
- {
- list = list->next;
- break;
- }
-
- if (*t != '+' && *t != '-')
- break;
+ flags = list_opttype == '+' ? &flags_off : &flags_on;
- flags = (*t++ == '+') ? &flags_off : &flags_on;
-
- while (*t)
+ switch (opt)
{
- if (*t == 'p' && local_var == 0)
- pflag++, t++;
- else if (*t == 'F')
- {
- nodefs++;
- *flags |= att_function; t++;
- }
- else if (*t == 'f')
- *flags |= att_function, t++;
- else if (*t == 'x')
- *flags |= att_exported, t++, array_needs_making = 1;
- else if (*t == 'r')
- *flags |= att_readonly, t++;
- else if (*t == 'i')
- *flags |= att_integer, t++;
+ case 'a':
#if defined (ARRAY_VARS)
- else if (*t == 'a')
- *flags |= att_array, t++;
+ *flags |= att_array;
+ break;
+#else
+ builtin_usage ();
+ return (EX_USAGE);
#endif
- else
- {
- builtin_error ("unknown option: `-%c'", *t);
- builtin_usage ();
- return (EX_USAGE);
- }
+ 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)
+ 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 */
+ default:
+ builtin_usage ();
+ return (EX_USAGE);
}
-
- list = list->next;
}
+ list = loptend;
+
/* If there are no more arguments left, then we just want to show
some variables. */
- if (list == 0) /* declare -[afFirx] */
+ if (list == 0) /* declare -[aAfFirtx] */
{
/* Show local variables defined at this context level if this is
the `local' builtin. */
register SHELL_VAR **vlist;
register int i;
- vlist = map_over (variable_in_context, shell_variables);
+ vlist = all_local_variables ();
if (vlist)
{
free (vlist);
}
}
+ 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
- {
- if (flags_on == 0)
- set_builtin ((WORD_LIST *)NULL);
- else
- set_or_show_attributes ((WORD_LIST *)NULL, flags_on, nodefs);
- }
+ set_or_show_attributes ((WORD_LIST *)NULL, flags_on, nodefs);
- fflush (stdout);
- return (EXECUTION_SUCCESS);
+ return (sh_chkwrite (EXECUTION_SUCCESS));
}
- if (pflag) /* declare -p [-afFirx] name [name...] */
+ if (pflag) /* declare -p [-aAfFirtx] name [name...] */
{
for (any_failed = 0; list; list = list->next)
{
- pflag = show_name_attributes (list->word->word, nodefs);
+ if (flags_on & att_function)
+ pflag = show_func_attributes (list->word->word, nodefs);
+ else
+ pflag = show_name_attributes (list->word->word, nodefs);
if (pflag)
{
- builtin_error ("%s: not found", list->word->word);
+ sh_notfound (list->word->word);
any_failed++;
}
}
- return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
+ return (sh_chkwrite (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS));
}
#define NEXT_VARIABLE() free (name); list = list->next; continue
/* There are arguments left, so we are making variables. */
- while (list) /* declare [-afFirx] name [name ...] */
+ while (list) /* declare [-aAfFirx] name [name ...] */
{
char *value, *name;
- int offset;
+ int offset, aflags;
#if defined (ARRAY_VARS)
- int making_array_special, assigning_array_special;
+ int making_array_special, compound_array_assign, simple_array_assign;
#endif
name = savestring (list->word->word);
- offset = assignment (name);
+ offset = assignment (name, 0);
+ aflags = 0;
- if (offset) /* declare [-afFirx] name=value */
+ 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_VARIABLES)
+ if (valid_array_reference (name))
+ {
+ builtin_error (_("%s: reference variable cannot be an array"), name);
+ assign_error++;
+ NEXT_VARIABLE ();
+ }
+ else
+#endif
+ /* disallow self references at global scope */
+ if (STREQ (name, value) && variable_context == 0)
+ {
+ builtin_error (_("%s: nameref variable self references not allowed"), name);
+ assign_error++;
+ NEXT_VARIABLE ();
+ }
+ }
+
#if defined (ARRAY_VARS)
- assigning_array_special = 0;
- if (t = strchr (name, '['))
+ compound_array_assign = simple_array_assign = 0;
+ subscript_start = (char *)NULL;
+ if (t = strchr (name, '[')) /* ] */
{
+ /* If offset != 0 we have already validated any array reference */
+ if (offset == 0 && valid_array_reference (name) == 0)
+ {
+ sh_invalidid (name);
+ assign_error++;
+ NEXT_VARIABLE ();
+ }
+ subscript_start = t;
*t = '\0';
making_array_special = 1;
}
else
making_array_special = 0;
#endif
-
- if (legal_identifier (name) == 0)
+
+ /* If we're in posix mode or not looking for a shell function (since
+ shell function names don't have to be valid identifiers when the
+ shell's not in posix mode), check whether or not the argument is a
+ valid, well-formed shell identifier. */
+ if ((posixly_correct || (flags_on & att_function) == 0) && legal_identifier (name) == 0)
{
- builtin_error ("`%s': not a valid identifier", name);
+ sh_invalidid (name);
assign_error++;
NEXT_VARIABLE ();
}
inside of a function. This means we should make local variables,
not global ones. */
- if (variable_context)
+ /* 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 && ((flags_on & att_function) == 0))
{
#if defined (ARRAY_VARS)
- if ((flags_on & att_array) || making_array_special)
- make_local_array_variable (name);
+ if (flags_on & att_assoc)
+ var = make_local_assoc_variable (name);
+ else if ((flags_on & att_array) || making_array_special)
+ var = make_local_array_variable (name, making_array_special);
else
#endif
- make_local_variable (name);
+ var = make_local_variable (name); /* sets att_invisible for new vars */
+ if (var == 0)
+ {
+ any_failed++;
+ NEXT_VARIABLE ();
+ }
}
+ else
+ var = (SHELL_VAR *)NULL;
/* 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'. */
{
if (offset) /* declare -f [-rix] foo=bar */
{
- builtin_error ("cannot use `-f' to make functions");
+ builtin_error (_("cannot use `-f' to make functions"));
free (name);
return (EXECUTION_FAILURE);
}
{
if (readonly_p (var) && (flags_off & att_readonly))
{
- builtin_error ("%s: readonly function", name);
+ builtin_error (_("%s: readonly function"), name);
any_failed++;
NEXT_VARIABLE ();
}
/* declare -[Ff] name [name...] */
if (flags_on == att_function && flags_off == 0)
{
- t = nodefs ? var->name
- : named_function_string (name, function_cell (var), 1);
- printf ("%s\n", t);
+#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...] */
{
- var->attributes |= flags_on;
- var->attributes &= ~flags_off;
+ VSETATTR (var, flags_on);
+ VUNSETATTR (var, flags_off);
}
}
else
NEXT_VARIABLE ();
}
}
- else /* declare -[airx] name [name...] */
+ else /* declare -[aAirx] name [name...] */
{
- var = find_variable (name);
+ /* Non-null if we just created or fetched a local variable. */
+ /* Here's what ksh93 seems to do. If we are modifying an existing
+ nameref variable, we don't follow the nameref chain past the last
+ nameref, and we set the nameref variable's value so future
+ references to that variable will return the value of the variable
+ we're assigning right now. */
+ if (var == 0 && (flags_on & att_nameref))
+ {
+ /* See if we are trying to modify an existing nameref variable */
+ var = mkglobal ? find_global_variable_last_nameref (name) : find_variable_last_nameref (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,
+ *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) : find_variable_last_nameref (name);
+ if (refvar && nameref_p (refvar) == 0)
+ refvar = 0;
+ if (refvar)
+ var = mkglobal ? find_global_variable (nameref_cell (refvar)) : find_variable (nameref_cell (refvar));
+ }
+
+ if (var == 0)
+ var = mkglobal ? find_global_variable (name) : find_variable (name);
if (var == 0)
{
#if defined (ARRAY_VARS)
- if ((flags_on & att_array) || making_array_special)
- var = make_new_array_variable (name);
+ if (flags_on & att_assoc)
+ {
+ var = make_new_assoc_variable (name);
+ if (offset == 0)
+ VSETATTR (var, att_invisible);
+ }
+ else if ((flags_on & att_array) || making_array_special)
+ {
+ var = make_new_array_variable (name);
+ if (offset == 0)
+ VSETATTR (var, att_invisible);
+ }
else
#endif
- var = bind_variable (name, "");
+
+ if (offset)
+ var = mkglobal ? bind_global_variable (name, "", 0) : bind_variable (name, "", 0);
+ else
+ {
+ var = mkglobal ? bind_global_variable (name, (char *)NULL, 0) : bind_variable (name, (char *)NULL, 0);
+ VSETATTR (var, att_invisible);
+ }
+ }
+ /* 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 ();
+ }
+ else if (flags_on & att_nameref)
+ {
+ /* ksh93 compat: turning on nameref attribute turns off -ilu */
+ VUNSETATTR (var, att_integer|att_uppercase|att_lowercase|att_capcase);
}
/* Cannot use declare +r to turn off readonly attribute. */
if (readonly_p (var) && (flags_off & att_readonly))
{
- builtin_error ("%s: readonly variable", name);
+ sh_readonly (name);
any_failed++;
NEXT_VARIABLE ();
}
- /* Cannot use declare to assign value to readonly variable. */
- if (readonly_p (var) && offset)
+ /* Cannot use declare to assign value to readonly or noassign
+ variable. */
+ if ((readonly_p (var) || noassign_p (var)) && offset)
{
- builtin_error ("%s: readonly variable", name);
+ if (readonly_p (var))
+ sh_readonly (name);
assign_error++;
NEXT_VARIABLE ();
}
#if defined (ARRAY_VARS)
- /* declare -a name=value does not work; declare name=value when
- name is already an array does not work. */
- if ((making_array_special || (flags_on & att_array) || array_p (var)) && offset)
+ if ((making_array_special || (flags_on & (att_array|att_assoc)) || array_p (var) || assoc_p (var)) && offset)
{
- if (value[0] == '(' && strchr (value, ')'))
- assigning_array_special = 1;
+ int vlen;
+ vlen = STRLEN (value);
+
+ if (value[0] == '(' && value[vlen-1] == ')')
+ compound_array_assign = 1;
else
- {
- builtin_error ("%s: cannot assign to array variables in this way", name);
- assign_error++;
- NEXT_VARIABLE ();
- }
+ simple_array_assign = 1;
}
- /* Cannot use declare +a name to remove an array variable. */
- if ((flags_off & att_array) && array_p (var))
+ /* 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);
+ builtin_error (_("%s: cannot destroy array variables in this way"), name);
any_failed++;
NEXT_VARIABLE ();
}
- /* declare -a name makes name an array variable. */
- if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0)
+ if ((flags_on & att_array) && assoc_p (var))
+ {
+ builtin_error (_("%s: cannot convert associative to indexed array"), name);
+ any_failed++;
+ NEXT_VARIABLE ();
+ }
+ 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 */
- var->attributes |= flags_on;
- var->attributes &= ~flags_off;
+ /* 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)
+ if (array_p (var) || assoc_p (var)
+ || (offset && compound_array_assign)
+ || simple_array_assign)
+ onref = 0; /* array variables may not be namerefs */
+#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 && assigning_array_special)
- assign_array_var_from_string (var, value);
+ if (offset && compound_array_assign)
+ assign_array_var_from_string (var, value, aflags);
+ else if (simple_array_assign && subscript_start)
+ {
+ /* declare [-aA] name[N]=value */
+ *subscript_start = '['; /* ] */
+ var = assign_array_element (name, value, 0); /* XXX - not aflags */
+ *subscript_start = '\0';
+ if (var == 0) /* some kind of assignment error */
+ {
+ assign_error++;
+ 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);
+ else
+ bind_array_variable (name, 0, value, aflags);
+ }
else
#endif
+ /* bind_variable_value duplicates the essential internals of
+ bind_variable() */
if (offset)
{
- t = make_variable_value (var, value);
- FREE (var->value);
- var->value = t;
+ if (onref)
+ aflags |= ASS_NAMEREF;
+ v = bind_variable_value (var, value, aflags);
+ if (v == 0 && onref)
+ {
+ sh_invalidid (value);
+ assign_error++;
+ /* XXX - unset this variable? or leave it as normal var? */
+ delete_var (var->name, mkglobal ? global_variables : shell_variables);
+ 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);
+ 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 */
+ if (refvar)
+ VUNSETATTR (refvar, flags_off);
+
stupidly_hack_special_variables (name);
NEXT_VARIABLE ();
projects / platform / upstream / bash.git / blobdiff