1 This file is declare.def, from which is created declare.c.
2 It implements the builtins "declare" and "local" in Bash.
4 Copyright (C) 1987-2012 Free Software Foundation, Inc.
6 This file is part of GNU Bash, the Bourne Again SHell.
8 Bash is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 Bash is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Bash. If not, see <http://www.gnu.org/licenses/>.
24 $FUNCTION declare_builtin
25 $SHORT_DOC declare [-aAfFgilnrtux] [-p] [name[=value] ...]
26 Set variable values and attributes.
28 Declare variables and give them attributes. If no NAMEs are given,
29 display the attributes and values of all variables.
32 -f restrict action or display to function names and definitions
33 -F restrict display to function names only (plus line number and
34 source file when debugging)
35 -g create global variables when used in a shell function; otherwise
37 -p display the attributes and value of each NAME
39 Options which set attributes:
40 -a to make NAMEs indexed arrays (if supported)
41 -A to make NAMEs associative arrays (if supported)
42 -i to make NAMEs have the `integer' attribute
43 -l to convert NAMEs to lower case on assignment
44 -n make NAME a reference to the variable named by its value
45 -r to make NAMEs readonly
46 -t to make NAMEs have the `trace' attribute
47 -u to convert NAMEs to upper case on assignment
48 -x to make NAMEs export
50 Using `+' instead of `-' turns off the given attribute.
52 Variables with the integer attribute have arithmetic evaluation (see
53 the `let' command) performed when the variable is assigned a value.
55 When used in a function, `declare' makes NAMEs local, as with the `local'
56 command. The `-g' option suppresses this behavior.
59 Returns success unless an invalid option is supplied or a variable
60 assignment error occurs.
64 $FUNCTION declare_builtin
65 $SHORT_DOC typeset [-aAfFgilrtux] [-p] name[=value] ...
66 Set variable values and attributes.
68 Obsolete. See `help declare'.
73 #if defined (HAVE_UNISTD_H)
75 # include <sys/types.h>
82 #include "../bashansi.h"
83 #include "../bashintl.h"
88 #include "bashgetopt.h"
90 extern int array_needs_making;
91 extern int posixly_correct;
93 static int declare_internal __P((register WORD_LIST *, int));
95 /* Declare or change variable attributes. */
97 declare_builtin (list)
98 register WORD_LIST *list;
100 return (declare_internal (list, 0));
104 $FUNCTION local_builtin
105 $SHORT_DOC local [option] name[=value] ...
106 Define local variables.
108 Create a local variable called NAME, and give it VALUE. OPTION can
109 be any option accepted by `declare'.
111 Local variables can only be used within a function; they are visible
112 only to the function where they are defined and its children.
115 Returns success unless an invalid option is supplied, a variable
116 assignment error occurs, or the shell is not executing a function.
120 register WORD_LIST *list;
122 if (variable_context)
123 return (declare_internal (list, 1));
126 builtin_error (_("can only be used in a function"));
127 return (EXECUTION_FAILURE);
131 #if defined (ARRAY_VARS)
132 # define DECLARE_OPTS "+acfgilnprtuxAF"
134 # define DECLARE_OPTS "+cfgilnprtuxF"
137 /* The workhorse function. */
139 declare_internal (list, local_var)
140 register WORD_LIST *list;
143 int flags_on, flags_off, *flags;
144 int any_failed, assign_error, pflag, nodefs, opt, mkglobal, onref, offref;
145 char *t, *subscript_start;
146 SHELL_VAR *var, *refvar, *v;
147 FUNCTION_DEF *shell_fn;
149 flags_on = flags_off = any_failed = assign_error = pflag = nodefs = mkglobal = 0;
150 refvar = (SHELL_VAR *)NULL;
151 reset_internal_getopt ();
152 while ((opt = internal_getopt (list, DECLARE_OPTS)) != EOF)
154 flags = list_opttype == '+' ? &flags_off : &flags_on;
159 #if defined (ARRAY_VARS)
167 #if defined (ARRAY_VARS)
180 *flags |= att_function;
183 *flags |= att_function;
186 if (flags == &flags_on)
190 *flags |= att_integer;
193 *flags |= att_nameref;
196 *flags |= att_readonly;
202 *flags |= att_exported;
203 array_needs_making = 1;
205 #if defined (CASEMOD_ATTRS)
206 # if defined (CASEMOD_CAPCASE)
208 *flags |= att_capcase;
209 if (flags == &flags_on)
210 flags_off |= att_uppercase|att_lowercase;
214 *flags |= att_lowercase;
215 if (flags == &flags_on)
216 flags_off |= att_capcase|att_uppercase;
219 *flags |= att_uppercase;
220 if (flags == &flags_on)
221 flags_off |= att_capcase|att_lowercase;
223 #endif /* CASEMOD_ATTRS */
232 /* If there are no more arguments left, then we just want to show
234 if (list == 0) /* declare -[aAfFirtx] */
236 /* Show local variables defined at this context level if this is
237 the `local' builtin. */
240 register SHELL_VAR **vlist;
243 vlist = all_local_variables ();
247 for (i = 0; vlist[i]; i++)
248 print_assignment (vlist[i]);
253 else if (pflag && (flags_on == 0 || flags_on == att_function))
254 show_all_var_attributes (flags_on == 0, nodefs);
255 else if (flags_on == 0)
256 return (set_builtin ((WORD_LIST *)NULL));
258 set_or_show_attributes ((WORD_LIST *)NULL, flags_on, nodefs);
260 return (sh_chkwrite (EXECUTION_SUCCESS));
263 if (pflag) /* declare -p [-aAfFirtx] name [name...] */
265 for (any_failed = 0; list; list = list->next)
267 if (flags_on & att_function)
268 pflag = show_func_attributes (list->word->word, nodefs);
270 pflag = show_name_attributes (list->word->word, nodefs);
273 sh_notfound (list->word->word);
277 return (sh_chkwrite (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS));
280 #define NEXT_VARIABLE() free (name); list = list->next; continue
282 /* There are arguments left, so we are making variables. */
283 while (list) /* declare [-aAfFirx] name [name ...] */
287 #if defined (ARRAY_VARS)
288 int making_array_special, compound_array_assign, simple_array_assign;
291 name = savestring (list->word->word);
292 offset = assignment (name, 0);
295 if (offset) /* declare [-aAfFirx] name=value */
298 value = name + offset + 1;
299 if (name[offset - 1] == '+')
301 aflags |= ASS_APPEND;
302 name[offset - 1] = '\0';
308 /* Do some lexical error checking on the LHS and RHS of the assignment
309 that is specific to nameref variables. */
310 if (flags_on & att_nameref)
312 #if defined (ARRAY_VARIABLES)
313 if (valid_array_reference (name))
315 builtin_error (_("%s: reference variable cannot be an array"), name);
321 /* disallow self references at global scope */
322 if (STREQ (name, value) && variable_context == 0)
324 builtin_error (_("%s: nameref variable self references not allowed"), name);
330 #if defined (ARRAY_VARS)
331 compound_array_assign = simple_array_assign = 0;
332 subscript_start = (char *)NULL;
333 if (t = strchr (name, '[')) /* ] */
335 /* If offset != 0 we have already validated any array reference */
336 if (offset == 0 && valid_array_reference (name) == 0)
344 making_array_special = 1;
347 making_array_special = 0;
350 /* If we're in posix mode or not looking for a shell function (since
351 shell function names don't have to be valid identifiers when the
352 shell's not in posix mode), check whether or not the argument is a
353 valid, well-formed shell identifier. */
354 if ((posixly_correct || (flags_on & att_function) == 0) && legal_identifier (name) == 0)
361 /* If VARIABLE_CONTEXT has a non-zero value, then we are executing
362 inside of a function. This means we should make local variables,
365 /* XXX - this has consequences when we're making a local copy of a
366 variable that was in the temporary environment. Watch out
368 refvar = (SHELL_VAR *)NULL;
369 if (variable_context && mkglobal == 0 && ((flags_on & att_function) == 0))
371 #if defined (ARRAY_VARS)
372 if (flags_on & att_assoc)
373 var = make_local_assoc_variable (name);
374 else if ((flags_on & att_array) || making_array_special)
375 var = make_local_array_variable (name, making_array_special);
378 var = make_local_variable (name); /* sets att_invisible for new vars */
386 var = (SHELL_VAR *)NULL;
388 /* If we are declaring a function, then complain about it in some way.
389 We don't let people make functions by saying `typeset -f foo=bar'. */
391 /* There should be a way, however, to let people look at a particular
392 function definition by saying `typeset -f foo'. */
394 if (flags_on & att_function)
396 if (offset) /* declare -f [-rix] foo=bar */
398 builtin_error (_("cannot use `-f' to make functions"));
400 return (EXECUTION_FAILURE);
402 else /* declare -f [-rx] name [name...] */
404 var = find_function (name);
408 if (readonly_p (var) && (flags_off & att_readonly))
410 builtin_error (_("%s: readonly function"), name);
415 /* declare -[Ff] name [name...] */
416 if (flags_on == att_function && flags_off == 0)
418 #if defined (DEBUGGER)
419 if (nodefs && debugging_mode)
421 shell_fn = find_function_def (var->name);
423 printf ("%s %d %s\n", var->name, shell_fn->line, shell_fn->source_file);
425 printf ("%s\n", var->name);
428 #endif /* DEBUGGER */
430 t = nodefs ? var->name
431 : named_function_string (name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL);
433 any_failed = sh_chkwrite (any_failed);
436 else /* declare -[fF] -[rx] name [name...] */
438 VSETATTR (var, flags_on);
439 VUNSETATTR (var, flags_off);
447 else /* declare -[aAirx] name [name...] */
449 /* Non-null if we just created or fetched a local variable. */
450 /* Here's what ksh93 seems to do. If we are modifying an existing
451 nameref variable, we don't follow the nameref chain past the last
452 nameref, and we set the nameref variable's value so future
453 references to that variable will return the value of the variable
454 we're assigning right now. */
455 if (var == 0 && (flags_on & att_nameref))
457 /* See if we are trying to modify an existing nameref variable */
458 var = mkglobal ? find_global_variable_last_nameref (name) : find_variable_last_nameref (name);
459 if (var && nameref_p (var) == 0)
462 /* However, if we're turning off the nameref attribute on an existing
463 nameref variable, we first follow the nameref chain to the end,
464 modify the value of the variable this nameref variable references,
465 *CHANGING ITS VALUE AS A SIDE EFFECT* then turn off the nameref
466 flag *LEAVING THE NAMEREF VARIABLE'S VALUE UNCHANGED* */
467 else if (var == 0 && (flags_off & att_nameref))
469 /* See if we are trying to modify an existing nameref variable */
470 refvar = mkglobal ? find_global_variable_last_nameref (name) : find_variable_last_nameref (name);
471 if (refvar && nameref_p (refvar) == 0)
474 var = mkglobal ? find_global_variable (nameref_cell (refvar)) : find_variable (nameref_cell (refvar));
478 var = mkglobal ? find_global_variable (name) : find_variable (name);
482 #if defined (ARRAY_VARS)
483 if (flags_on & att_assoc)
485 var = make_new_assoc_variable (name);
487 VSETATTR (var, att_invisible);
489 else if ((flags_on & att_array) || making_array_special)
491 var = make_new_array_variable (name);
493 VSETATTR (var, att_invisible);
499 var = mkglobal ? bind_global_variable (name, "", 0) : bind_variable (name, "", 0);
502 var = mkglobal ? bind_global_variable (name, (char *)NULL, 0) : bind_variable (name, (char *)NULL, 0);
503 VSETATTR (var, att_invisible);
506 /* Can't take an existing array variable and make it a nameref */
507 else if ((array_p (var) || assoc_p (var)) && (flags_on & att_nameref))
509 builtin_error (_("%s: reference variable cannot be an array"), name);
513 else if (flags_on & att_nameref)
515 /* ksh93 compat: turning on nameref attribute turns off -ilu */
516 VUNSETATTR (var, att_integer|att_uppercase|att_lowercase|att_capcase);
519 /* Cannot use declare +r to turn off readonly attribute. */
520 if (readonly_p (var) && (flags_off & att_readonly))
527 /* Cannot use declare to assign value to readonly or noassign
529 if ((readonly_p (var) || noassign_p (var)) && offset)
531 if (readonly_p (var))
537 #if defined (ARRAY_VARS)
538 if ((making_array_special || (flags_on & (att_array|att_assoc)) || array_p (var) || assoc_p (var)) && offset)
541 vlen = STRLEN (value);
543 if (value[0] == '(' && value[vlen-1] == ')')
544 compound_array_assign = 1;
546 simple_array_assign = 1;
549 /* Cannot use declare +a name or declare +A name to remove an
551 if (((flags_off & att_array) && array_p (var)) || ((flags_off & att_assoc) && assoc_p (var)))
553 builtin_error (_("%s: cannot destroy array variables in this way"), name);
558 if ((flags_on & att_array) && assoc_p (var))
560 builtin_error (_("%s: cannot convert associative to indexed array"), name);
564 if ((flags_on & att_assoc) && array_p (var))
566 builtin_error (_("%s: cannot convert indexed to associative array"), name);
571 /* declare -A name[[n]] makes name an associative array variable. */
572 if (flags_on & att_assoc)
574 if (assoc_p (var) == 0)
575 var = convert_var_to_assoc (var);
577 /* declare -a name[[n]] or declare name[n] makes name an indexed
579 else if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0 && assoc_p (var) == 0)
580 var = convert_var_to_array (var);
581 #endif /* ARRAY_VARS */
583 /* XXX - we note that we are turning on nameref attribute and defer
584 setting it until the assignment has been made so we don't do an
585 inadvertent nameref lookup. Might have to do the same thing for
586 flags_off&att_nameref. */
587 /* XXX - ksh93 makes it an error to set a readonly nameref variable
588 using a single typeset command. */
589 onref = (flags_on & att_nameref);
590 flags_on &= ~att_nameref;
591 #if defined (ARRAY_VARS)
592 if (array_p (var) || assoc_p (var)
593 || (offset && compound_array_assign)
594 || simple_array_assign)
595 onref = 0; /* array variables may not be namerefs */
598 /* ksh93 seems to do this */
599 offref = (flags_off & att_nameref);
600 flags_off &= ~att_nameref;
602 VSETATTR (var, flags_on);
603 VUNSETATTR (var, flags_off);
605 #if defined (ARRAY_VARS)
606 if (offset && compound_array_assign)
607 assign_array_var_from_string (var, value, aflags);
608 else if (simple_array_assign && subscript_start)
610 /* declare [-aA] name[N]=value */
611 *subscript_start = '['; /* ] */
612 var = assign_array_element (name, value, 0); /* XXX - not aflags */
613 *subscript_start = '\0';
614 if (var == 0) /* some kind of assignment error */
622 else if (simple_array_assign)
624 /* let bind_{array,assoc}_variable take care of this. */
626 bind_assoc_variable (var, name, savestring ("0"), value, aflags);
628 bind_array_variable (name, 0, value, aflags);
632 /* bind_variable_value duplicates the essential internals of
637 aflags |= ASS_NAMEREF;
638 v = bind_variable_value (var, value, aflags);
641 sh_invalidid (value);
643 /* XXX - unset this variable? or leave it as normal var? */
644 delete_var (var->name, mkglobal ? global_variables : shell_variables);
649 /* If we found this variable in the temporary environment, as with
650 `var=value declare -x var', make sure it is treated identically
651 to `var=value export var'. Do the same for `declare -r' and
652 `readonly'. Preserve the attributes, except for att_tempvar. */
653 /* XXX -- should this create a variable in the global scope, or
654 modify the local variable flags? ksh93 has it modify the
656 Need to handle case like in set_var_attribute where a temporary
657 variable is in the same table as the function local vars. */
658 if ((flags_on & (att_exported|att_readonly)) && tempvar_p (var))
663 tv = find_tempenv_variable (var->name);
666 tvalue = var_isset (var) ? savestring (value_cell (var)) : savestring ("");
667 tv = bind_variable (var->name, tvalue, 0);
668 tv->attributes |= var->attributes & ~att_tempvar;
670 VSETATTR (tv, att_propagate);
673 VSETATTR (var, att_propagate);
677 /* Turn on nameref attribute we deferred above. */
678 /* XXX - should we turn on the noassign attribute for consistency with
679 ksh93 when we turn on the nameref attribute? */
680 VSETATTR (var, onref);
682 VUNSETATTR (var, offref);
684 /* Yuck. ksh93 compatibility */
686 VUNSETATTR (refvar, flags_off);
688 stupidly_hack_special_variables (name);
693 return (assign_error ? EX_BADASSIGN
694 : ((any_failed == 0) ? EXECUTION_SUCCESS
695 : EXECUTION_FAILURE));