builtins/declare.def

   1 This file is declare.def, from which is created declare.c.
   2 It implements the builtins "declare" and "local" in Bash.
   3
   4 Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
   5
   6 This file is part of GNU Bash, the Bourne Again SHell.
   7
   8 Bash is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 1, or (at your option) any later
  11 version.
  12
  13 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License along
  19 with Bash; see the file COPYING.  If not, write to the Free Software
  20 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22 $PRODUCES declare.c
  23
  24 $BUILTIN declare
  25 $FUNCTION declare_builtin
  26 $SHORT_DOC declare [-afFrxi] [-p] name[=value] ...
  27 Declare variables and/or give them attributes.  If no NAMEs are
  28 given, then display the values of variables instead.  The -p option
  29 will display the attributes and values of each NAME.
  30
  31 The flags are:
  32
  33   -a    to make NAMEs arrays (if supported)
  34   -f    to select from among function names only
  35   -F    to display function names without definitions
  36   -r    to make NAMEs readonly
  37   -x    to make NAMEs export
  38   -i    to make NAMEs have the `integer' attribute set
  39
  40 Variables with the integer attribute have arithmetic evaluation (see
  41 `let') done when the variable is assigned to.
  42
  43 When displaying values of variables, -f displays a function's name
  44 and definition.  The -F option restricts the display to function
  45 name only.
  46
  47 Using `+' instead of `-' turns off the given attribute instead.  When
  48 used in a function, makes NAMEs local, as with the `local' command.
  49 $END
  50
  51 $BUILTIN typeset
  52 $FUNCTION declare_builtin
  53 $SHORT_DOC typeset [-afFrxi] [-p] name[=value] ...
  54 Obsolete.  See `declare'.
  55 $END
  56
  57 #include <config.h>
  58
  59 #if defined (HAVE_UNISTD_H)
  60 #  ifdef _MINIX
  61 #    include <sys/types.h>
  62 #  endif
  63 #  include <unistd.h>
  64 #endif
  65
  66 #include <stdio.h>
  67
  68 #include "../bashansi.h"
  69
  70 #include "../shell.h"
  71 #include "common.h"
  72 #include "builtext.h"
  73
  74 extern int variable_context, array_needs_making;
  75
  76 static int declare_internal ();
  77
  78 /* Declare or change variable attributes. */
  79 int
  80 declare_builtin (list)
  81      register WORD_LIST *list;
  82 {
  83   return (declare_internal (list, 0));
  84 }
  85
  86 $BUILTIN local
  87 $FUNCTION local_builtin
  88 $SHORT_DOC local name[=value] ...
  89 Create a local variable called NAME, and give it VALUE.  LOCAL
  90 can only be used within a function; it makes the variable NAME
  91 have a visible scope restricted to that function and its children.
  92 $END
  93 int
  94 local_builtin (list)
  95      register WORD_LIST *list;
  96 {
  97   if (variable_context)
  98     return (declare_internal (list, 1));
  99   else
 100     {
 101       builtin_error ("can only be used in a function");
 102       return (EXECUTION_FAILURE);
 103     }
 104 }
 105
 106 /* The workhorse function. */
 107 static int
 108 declare_internal (list, local_var)
 109      register WORD_LIST *list;
 110      int local_var;
 111 {
 112   int flags_on, flags_off, *flags, any_failed, assign_error, pflag, nodefs;
 113   char *t;
 114   SHELL_VAR *var;
 115
 116   flags_on = flags_off = any_failed = assign_error = pflag = nodefs = 0;
 117   while (list)
 118     {
 119       t = list->word->word;
 120       if (t[0] == '-' && t[1] == '-' && t[2] == '\0')
 121         {
 122           list = list->next;
 123           break;
 124         }
 125
 126       if (*t != '+' && *t != '-')
 127         break;
 128
 129       flags = (*t++ == '+') ? &flags_off : &flags_on;
 130
 131       while (*t)
 132         {
 133           if (*t == 'p' && local_var == 0)
 134             pflag++, t++;
 135           else if (*t == 'F')
 136             {
 137               nodefs++;
 138               *flags |= att_function; t++;
 139             }
 140           else if (*t == 'f')
 141             *flags |= att_function, t++;
 142           else if (*t == 'x')
 143             *flags |= att_exported, t++, array_needs_making = 1;
 144           else if (*t == 'r')
 145             *flags |= att_readonly, t++;
 146           else if (*t == 'i')
 147             *flags |= att_integer, t++;
 148 #if defined (ARRAY_VARS)
 149           else if (*t == 'a')
 150             *flags |= att_array, t++;
 151 #endif
 152           else
 153             {
 154               builtin_error ("unknown option: `-%c'", *t);
 155               builtin_usage ();
 156               return (EX_USAGE);
 157             }
 158         }
 159
 160       list = list->next;
 161     }
 162
 163   /* If there are no more arguments left, then we just want to show
 164      some variables. */
 165   if (list == 0)        /* declare -[afFirx] */
 166     {
 167       /* Show local variables defined at this context level if this is
 168          the `local' builtin. */
 169       if (local_var)
 170         {
 171           register SHELL_VAR **vlist;
 172           register int i;
 173
 174           vlist = map_over (variable_in_context, shell_variables);
 175
 176           if (vlist)
 177             {
 178               for (i = 0; vlist[i]; i++)
 179                 print_assignment (vlist[i]);
 180
 181               free (vlist);
 182             }
 183         }
 184       else
 185         {
 186           if (flags_on == 0)
 187             set_builtin ((WORD_LIST *)NULL);
 188           else
 189             set_or_show_attributes ((WORD_LIST *)NULL, flags_on, nodefs);
 190         }
 191
 192       fflush (stdout);
 193       return (EXECUTION_SUCCESS);
 194     }
 195
 196   if (pflag)    /* declare -p [-afFirx] name [name...] */
 197     {
 198       for (any_failed = 0; list; list = list->next)
 199         {
 200           pflag = show_name_attributes (list->word->word, nodefs);
 201           if (pflag)
 202             {
 203               builtin_error ("%s: not found", list->word->word);
 204               any_failed++;
 205             }
 206         }
 207       return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
 208     }
 209
 210 #define NEXT_VARIABLE() free (name); list = list->next; continue
 211
 212   /* There are arguments left, so we are making variables. */
 213   while (list)          /* declare [-afFirx] name [name ...] */
 214     {
 215       char *value, *name;
 216       int offset;
 217 #if defined (ARRAY_VARS)
 218       int making_array_special, assigning_array_special;
 219 #endif
 220
 221       name = savestring (list->word->word);
 222       offset = assignment (name);
 223
 224       if (offset)       /* declare [-afFirx] name=value */
 225         {
 226           name[offset] = '\0';
 227           value = name + offset + 1;
 228         }
 229       else
 230         value = "";
 231
 232 #if defined (ARRAY_VARS)
 233       assigning_array_special = 0;
 234       if (t = strchr (name, '['))
 235         {
 236           *t = '\0';
 237           making_array_special = 1;
 238         }
 239       else
 240         making_array_special = 0;
 241 #endif
 242
 243       if (legal_identifier (name) == 0)
 244         {
 245           builtin_error ("`%s': not a valid identifier", name);
 246           assign_error++;
 247           NEXT_VARIABLE ();
 248         }
 249
 250       /* If VARIABLE_CONTEXT has a non-zero value, then we are executing
 251          inside of a function.  This means we should make local variables,
 252          not global ones. */
 253
 254       if (variable_context)
 255         {
 256 #if defined (ARRAY_VARS)
 257           if ((flags_on & att_array) || making_array_special)
 258             make_local_array_variable (name);
 259           else
 260 #endif
 261           make_local_variable (name);
 262         }
 263
 264       /* If we are declaring a function, then complain about it in some way.
 265          We don't let people make functions by saying `typeset -f foo=bar'. */
 266
 267       /* There should be a way, however, to let people look at a particular
 268          function definition by saying `typeset -f foo'. */
 269
 270       if (flags_on & att_function)
 271         {
 272           if (offset)   /* declare -f [-rix] foo=bar */
 273             {
 274               builtin_error ("cannot use `-f' to make functions");
 275               free (name);
 276               return (EXECUTION_FAILURE);
 277             }
 278           else          /* declare -f [-rx] name [name...] */
 279             {
 280               var = find_function (name);
 281
 282               if (var)
 283                 {
 284                   if (readonly_p (var) && (flags_off & att_readonly))
 285                     {
 286                       builtin_error ("%s: readonly function", name);
 287                       any_failed++;
 288                       NEXT_VARIABLE ();
 289                     }
 290
 291                   /* declare -[Ff] name [name...] */
 292                   if (flags_on == att_function && flags_off == 0)
 293                     {
 294                       t = nodefs ? var->name
 295                                  : named_function_string (name, function_cell (var), 1);
 296                       printf ("%s\n", t);
 297                     }
 298                   else          /* declare -[fF] -[rx] name [name...] */
 299                     {
 300                       var->attributes |= flags_on;
 301                       var->attributes &= ~flags_off;
 302                     }
 303                 }
 304               else
 305                 any_failed++;
 306               NEXT_VARIABLE ();
 307             }
 308         }
 309       else              /* declare -[airx] name [name...] */
 310         {
 311           var = find_variable (name);
 312
 313           if (var == 0)
 314             {
 315 #if defined (ARRAY_VARS)
 316               if ((flags_on & att_array) || making_array_special)
 317                 var = make_new_array_variable (name);
 318               else
 319 #endif
 320               var = bind_variable (name, "");
 321             }
 322
 323           /* Cannot use declare +r to turn off readonly attribute. */
 324           if (readonly_p (var) && (flags_off & att_readonly))
 325             {
 326               builtin_error ("%s: readonly variable", name);
 327               any_failed++;
 328               NEXT_VARIABLE ();
 329             }
 330
 331           /* Cannot use declare to assign value to readonly variable. */
 332           if (readonly_p (var) && offset)
 333             {
 334               builtin_error ("%s: readonly variable", name);
 335               assign_error++;
 336               NEXT_VARIABLE ();
 337             }
 338
 339 #if defined (ARRAY_VARS)
 340           /* declare -a name=value does not work; declare name=value when
 341              name is already an array does not work. */
 342           if ((making_array_special || (flags_on & att_array) || array_p (var)) && offset)
 343             {
 344               if (value[0] == '(' && strchr (value, ')'))
 345                 assigning_array_special = 1;
 346               else
 347                 {
 348                   builtin_error ("%s: cannot assign to array variables in this way", name);
 349                   assign_error++;
 350                   NEXT_VARIABLE ();
 351                 }
 352             }
 353
 354           /* Cannot use declare +a name to remove an array variable. */
 355           if ((flags_off & att_array) && array_p (var))
 356             {
 357               builtin_error ("%s: cannot destroy array variables in this way", name);
 358               any_failed++;
 359               NEXT_VARIABLE ();
 360             }
 361
 362           /* declare -a name makes name an array variable. */
 363           if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0)
 364             var = convert_var_to_array (var);
 365 #endif /* ARRAY_VARS */
 366
 367           var->attributes |= flags_on;
 368           var->attributes &= ~flags_off;
 369
 370 #if defined (ARRAY_VARS)
 371           if (offset && assigning_array_special)
 372             assign_array_var_from_string (var, value);
 373           else
 374 #endif
 375           /* This essentially duplicates the internals of bind_variable() */
 376           if (offset)
 377             {
 378               var->attributes &= ~att_invisible;
 379               t = make_variable_value (var, value);
 380               FREE (var->value);
 381               var->value = t;
 382             }
 383
 384           /* If we found this variable in the temporary environment, as with
 385              `var=value declare -x var', make sure it is treated identically
 386              to `var=value export var'.  Do the same for `declare -r' and
 387              `readonly'.  Preserve the attributes, except for att_tempvar. */
 388           if ((flags_on & (att_exported|att_readonly)) && tempvar_p (var))
 389             {
 390               SHELL_VAR *tv;
 391               tv = bind_variable (var->name, var->value ? var->value : "");
 392               tv->attributes = var->attributes & ~att_tempvar;
 393               dispose_variable (var);
 394             }
 395         }
 396
 397       stupidly_hack_special_variables (name);
 398
 399       NEXT_VARIABLE ();
 400     }
 401
 402   return (assign_error ? EX_BADASSIGN
 403                        : ((any_failed == 0) ? EXECUTION_SUCCESS
 404                                             : EXECUTION_FAILURE));
 405 }