arrayfunc.c

   1 /* arrayfunc.c -- High-level array functions used by other parts of the shell. */
   2
   3 /* Copyright (C) 2001-2011 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bash, the Bourne Again SHell.
   6
   7    Bash is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    Bash is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with Bash.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "config.h"
  22
  23 #if defined (ARRAY_VARS)
  24
  25 #if defined (HAVE_UNISTD_H)
  26 #  include <unistd.h>
  27 #endif
  28 #include <stdio.h>
  29
  30 #include "bashintl.h"
  31
  32 #include "shell.h"
  33 #include "pathexp.h"
  34
  35 #include "shmbutil.h"
  36
  37 #include "builtins/common.h"
  38
  39 extern char *this_command_name;
  40 extern int last_command_exit_value;
  41 extern int array_needs_making;
  42
  43 static SHELL_VAR *bind_array_var_internal __P((SHELL_VAR *, arrayind_t, char *, char *, int));
  44 static SHELL_VAR *assign_array_element_internal __P((SHELL_VAR *, char *, char *, char *, int, char *, int));
  45
  46 static char *quote_assign __P((const char *));
  47 static void quote_array_assignment_chars __P((WORD_LIST *));
  48 static char *array_value_internal __P((char *, int, int, int *, arrayind_t *));
  49
  50 /* Standard error message to use when encountering an invalid array subscript */
  51 const char * const bash_badsub_errmsg = N_("bad array subscript");
  52
  53 /* **************************************************************** */
  54 /*                                                                  */
  55 /*  Functions to manipulate array variables and perform assignments */
  56 /*                                                                  */
  57 /* **************************************************************** */
  58
  59 /* Convert a shell variable to an array variable.  The original value is
  60    saved as array[0]. */
  61 SHELL_VAR *
  62 convert_var_to_array (var)
  63      SHELL_VAR *var;
  64 {
  65   char *oldval;
  66   ARRAY *array;
  67
  68   oldval = value_cell (var);
  69   array = array_create ();
  70   if (oldval)
  71     array_insert (array, 0, oldval);
  72
  73   FREE (value_cell (var));
  74   var_setarray (var, array);
  75
  76   /* these aren't valid anymore */
  77   var->dynamic_value = (sh_var_value_func_t *)NULL;
  78   var->assign_func = (sh_var_assign_func_t *)NULL;
  79
  80   INVALIDATE_EXPORTSTR (var);
  81   if (exported_p (var))
  82     array_needs_making++;
  83
  84   VSETATTR (var, att_array);
  85   VUNSETATTR (var, att_invisible);
  86
  87   return var;
  88 }
  89
  90 /* Convert a shell variable to an array variable.  The original value is
  91    saved as array[0]. */
  92 SHELL_VAR *
  93 convert_var_to_assoc (var)
  94      SHELL_VAR *var;
  95 {
  96   char *oldval;
  97   HASH_TABLE *hash;
  98
  99   oldval = value_cell (var);
 100   hash = assoc_create (0);
 101   if (oldval)
 102     assoc_insert (hash, savestring ("0"), oldval);
 103
 104   FREE (value_cell (var));
 105   var_setassoc (var, hash);
 106
 107   /* these aren't valid anymore */
 108   var->dynamic_value = (sh_var_value_func_t *)NULL;
 109   var->assign_func = (sh_var_assign_func_t *)NULL;
 110
 111   INVALIDATE_EXPORTSTR (var);
 112   if (exported_p (var))
 113     array_needs_making++;
 114
 115   VSETATTR (var, att_assoc);
 116   VUNSETATTR (var, att_invisible);
 117
 118   return var;
 119 }
 120
 121 char *
 122 make_array_variable_value (entry, ind, key, value, flags)
 123      SHELL_VAR *entry;
 124      arrayind_t ind;
 125      char *key;
 126      char *value;
 127      int flags;
 128 {
 129   SHELL_VAR *dentry;
 130   char *newval;
 131
 132   /* If we're appending, we need the old value of the array reference, so
 133      fake out make_variable_value with a dummy SHELL_VAR */
 134   if (flags & ASS_APPEND)
 135     {
 136       dentry = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
 137       dentry->name = savestring (entry->name);
 138       if (assoc_p (entry))
 139         newval = assoc_reference (assoc_cell (entry), key);
 140       else
 141         newval = array_reference (array_cell (entry), ind);
 142       if (newval)
 143         dentry->value = savestring (newval);
 144       else
 145         {
 146           dentry->value = (char *)xmalloc (1);
 147           dentry->value[0] = '\0';
 148         }
 149       dentry->exportstr = 0;
 150       dentry->attributes = entry->attributes & ~(att_array|att_assoc|att_exported);
 151       /* Leave the rest of the members uninitialized; the code doesn't look
 152          at them. */
 153       newval = make_variable_value (dentry, value, flags);
 154       dispose_variable (dentry);
 155     }
 156   else
 157     newval = make_variable_value (entry, value, flags);
 158
 159   return newval;
 160 }
 161
 162 static SHELL_VAR *
 163 bind_array_var_internal (entry, ind, key, value, flags)
 164      SHELL_VAR *entry;
 165      arrayind_t ind;
 166      char *key;
 167      char *value;
 168      int flags;
 169 {
 170   char *newval;
 171
 172   newval = make_array_variable_value (entry, ind, key, value, flags);
 173
 174   if (entry->assign_func)
 175     (*entry->assign_func) (entry, newval, ind, key);
 176   else if (assoc_p (entry))
 177     assoc_insert (assoc_cell (entry), key, newval);
 178   else
 179     array_insert (array_cell (entry), ind, newval);
 180   FREE (newval);
 181
 182   VUNSETATTR (entry, att_invisible);    /* no longer invisible */
 183   return (entry);
 184 }
 185
 186 /* Perform an array assignment name[ind]=value.  If NAME already exists and
 187    is not an array, and IND is 0, perform name=value instead.  If NAME exists
 188    and is not an array, and IND is not 0, convert it into an array with the
 189    existing value as name[0].
 190
 191    If NAME does not exist, just create an array variable, no matter what
 192    IND's value may be. */
 193 SHELL_VAR *
 194 bind_array_variable (name, ind, value, flags)
 195      char *name;
 196      arrayind_t ind;
 197      char *value;
 198      int flags;
 199 {
 200   SHELL_VAR *entry;
 201
 202   entry = find_shell_variable (name);
 203
 204   if (entry == (SHELL_VAR *) 0)
 205     entry = make_new_array_variable (name);
 206   else if (readonly_p (entry) || noassign_p (entry))
 207     {
 208       if (readonly_p (entry))
 209         err_readonly (name);
 210       return (entry);
 211     }
 212   else if (array_p (entry) == 0)
 213     entry = convert_var_to_array (entry);
 214
 215   /* ENTRY is an array variable, and ARRAY points to the value. */
 216   return (bind_array_var_internal (entry, ind, 0, value, flags));
 217 }
 218
 219 SHELL_VAR *
 220 bind_array_element (entry, ind, value, flags)
 221      SHELL_VAR *entry;
 222      arrayind_t ind;
 223      char *value;
 224      int flags;
 225 {
 226   return (bind_array_var_internal (entry, ind, 0, value, flags));
 227 }
 228
 229 SHELL_VAR *
 230 bind_assoc_variable (entry, name, key, value, flags)
 231      SHELL_VAR *entry;
 232      char *name;
 233      char *key;
 234      char *value;
 235      int flags;
 236 {
 237   SHELL_VAR *dentry;
 238   char *newval;
 239
 240   if (readonly_p (entry) || noassign_p (entry))
 241     {
 242       if (readonly_p (entry))
 243         err_readonly (name);
 244       return (entry);
 245     }
 246
 247   return (bind_array_var_internal (entry, 0, key, value, flags));
 248 }
 249
 250 /* Parse NAME, a lhs of an assignment statement of the form v[s], and
 251    assign VALUE to that array element by calling bind_array_variable(). */
 252 SHELL_VAR *
 253 assign_array_element (name, value, flags)
 254      char *name, *value;
 255      int flags;
 256 {
 257   char *sub, *vname;
 258   int sublen;
 259   SHELL_VAR *entry;
 260
 261   vname = array_variable_name (name, &sub, &sublen);
 262
 263   if (vname == 0)
 264     return ((SHELL_VAR *)NULL);
 265
 266   if ((ALL_ELEMENT_SUB (sub[0]) && sub[1] == ']') || (sublen <= 1))
 267     {
 268       free (vname);
 269       err_badarraysub (name);
 270       return ((SHELL_VAR *)NULL);
 271     }
 272
 273   entry = find_variable (vname);
 274   entry = assign_array_element_internal (entry, name, vname, sub, sublen, value, flags);
 275
 276   free (vname);
 277   return entry;
 278 }
 279
 280 static SHELL_VAR *
 281 assign_array_element_internal (entry, name, vname, sub, sublen, value, flags)
 282      SHELL_VAR *entry;
 283      char *name;                /* only used for error messages */
 284      char *vname;
 285      char *sub;
 286      int sublen;
 287      char *value;
 288      int flags;
 289 {
 290   char *akey;
 291   arrayind_t ind;
 292
 293   if (entry && assoc_p (entry))
 294     {
 295       sub[sublen-1] = '\0';
 296       akey = expand_assignment_string_to_string (sub, 0);       /* [ */
 297       sub[sublen-1] = ']';
 298       if (akey == 0 || *akey == 0)
 299         {
 300           err_badarraysub (name);
 301           FREE (akey);
 302           return ((SHELL_VAR *)NULL);
 303         }
 304       entry = bind_assoc_variable (entry, vname, akey, value, flags);
 305     }
 306   else
 307     {
 308       ind = array_expand_index (entry, sub, sublen);
 309       /* negative subscripts to indexed arrays count back from end */
 310       if (entry && ind < 0)
 311         ind = (array_p (entry) ? array_max_index (array_cell (entry)) : 0) + 1 + ind;
 312       if (ind < 0)
 313         {
 314           err_badarraysub (name);
 315           return ((SHELL_VAR *)NULL);
 316         }
 317       entry = bind_array_variable (vname, ind, value, flags);
 318     }
 319
 320   return (entry);
 321 }
 322
 323 /* Find the array variable corresponding to NAME.  If there is no variable,
 324    create a new array variable.  If the variable exists but is not an array,
 325    convert it to an indexed array.  If FLAGS&1 is non-zero, an existing
 326    variable is checked for the readonly or noassign attribute in preparation
 327    for assignment (e.g., by the `read' builtin).  If FLAGS&2 is non-zero, we
 328    create an associative array. */
 329 SHELL_VAR *
 330 find_or_make_array_variable (name, flags)
 331      char *name;
 332      int flags;
 333 {
 334   SHELL_VAR *var;
 335
 336   var = find_variable (name);
 337   if (var == 0)
 338     {
 339       /* See if we have a nameref pointing to a variable that hasn't been
 340          created yet. */
 341       var = find_variable_last_nameref (name);
 342       if (var && nameref_p (var))
 343         var = (flags & 2) ? make_new_assoc_variable (nameref_cell (var)) : make_new_array_variable (nameref_cell (var));
 344     }
 345
 346   if (var == 0)
 347     var = (flags & 2) ? make_new_assoc_variable (name) : make_new_array_variable (name);
 348   else if ((flags & 1) && (readonly_p (var) || noassign_p (var)))
 349     {
 350       if (readonly_p (var))
 351         err_readonly (name);
 352       return ((SHELL_VAR *)NULL);
 353     }
 354   else if ((flags & 2) && array_p (var))
 355     {
 356       last_command_exit_value = 1;
 357       report_error (_("%s: cannot convert indexed to associative array"), name);
 358       return ((SHELL_VAR *)NULL);
 359     }
 360   else if (array_p (var) == 0 && assoc_p (var) == 0)
 361     var = convert_var_to_array (var);
 362
 363   return (var);
 364 }
 365
 366 /* Perform a compound assignment statement for array NAME, where VALUE is
 367    the text between the parens:  NAME=( VALUE ) */
 368 SHELL_VAR *
 369 assign_array_from_string (name, value, flags)
 370      char *name, *value;
 371      int flags;
 372 {
 373   SHELL_VAR *var;
 374   int vflags;
 375
 376   vflags = 1;
 377   if (flags & ASS_MKASSOC)
 378     vflags |= 2;
 379
 380   var = find_or_make_array_variable (name, vflags);
 381   if (var == 0)
 382     return ((SHELL_VAR *)NULL);
 383
 384   return (assign_array_var_from_string (var, value, flags));
 385 }
 386
 387 /* Sequentially assign the indices of indexed array variable VAR from the
 388    words in LIST. */
 389 SHELL_VAR *
 390 assign_array_var_from_word_list (var, list, flags)
 391      SHELL_VAR *var;
 392      WORD_LIST *list;
 393      int flags;
 394 {
 395   register arrayind_t i;
 396   register WORD_LIST *l;
 397   ARRAY *a;
 398
 399   a = array_cell (var);
 400   i = (flags & ASS_APPEND) ? array_max_index (a) + 1 : 0;
 401
 402   for (l = list; l; l = l->next, i++)
 403     if (var->assign_func)
 404       (*var->assign_func) (var, l->word->word, i, 0);
 405     else
 406       array_insert (a, i, l->word->word);
 407
 408   VUNSETATTR (var, att_invisible);      /* no longer invisible */
 409
 410   return var;
 411 }
 412
 413 WORD_LIST *
 414 expand_compound_array_assignment (var, value, flags)
 415      SHELL_VAR *var;
 416      char *value;
 417      int flags;
 418 {
 419   WORD_LIST *list, *nlist;
 420   WORD_LIST *hd, *tl, *t, *n;
 421   char *val;
 422   int ni;
 423
 424   /* This condition is true when invoked from the declare builtin with a
 425      command like
 426         declare -a d='([1]="" [2]="bdef" [5]="hello world" "test")' */
 427   if (*value == '(')    /*)*/
 428     {
 429       ni = 1;
 430       val = extract_array_assignment_list (value, &ni);
 431       if (val == 0)
 432         return (WORD_LIST *)NULL;
 433     }
 434   else
 435     val = value;
 436
 437   /* Expand the value string into a list of words, performing all the
 438      shell expansions including pathname generation and word splitting. */
 439   /* First we split the string on whitespace, using the shell parser
 440      (ksh93 seems to do this). */
 441   list = parse_string_to_word_list (val, 1, "array assign");
 442
 443   if (var && assoc_p (var))
 444     {
 445       if (val != value)
 446         free (val);
 447       return list;
 448     }
 449
 450   /* If we're using [subscript]=value, we need to quote each [ and ] to
 451      prevent unwanted filename expansion.  This doesn't need to be done
 452      for associative array expansion, since that uses a different expansion
 453      function (see assign_compound_array_list below). */
 454   if (list)
 455     quote_array_assignment_chars (list);
 456
 457   /* Now that we've split it, perform the shell expansions on each
 458      word in the list. */
 459   nlist = list ? expand_words_no_vars (list) : (WORD_LIST *)NULL;
 460
 461   dispose_words (list);
 462
 463   if (val != value)
 464     free (val);
 465
 466   return nlist;
 467 }
 468
 469 /* Callers ensure that VAR is not NULL */
 470 void
 471 assign_compound_array_list (var, nlist, flags)
 472      SHELL_VAR *var;
 473      WORD_LIST *nlist;
 474      int flags;
 475 {
 476   ARRAY *a;
 477   HASH_TABLE *h;
 478   WORD_LIST *list;
 479   char *w, *val, *nval;
 480   int len, iflags, free_val;
 481   arrayind_t ind, last_ind;
 482   char *akey;
 483
 484   a = (var && array_p (var)) ? array_cell (var) : (ARRAY *)0;
 485   h = (var && assoc_p (var)) ? assoc_cell (var) : (HASH_TABLE *)0;
 486
 487   akey = (char *)0;
 488   ind = 0;
 489
 490   /* Now that we are ready to assign values to the array, kill the existing
 491      value. */
 492   if ((flags & ASS_APPEND) == 0)
 493     {
 494       if (a && array_p (var))
 495         array_flush (a);
 496       else if (h && assoc_p (var))
 497         assoc_flush (h);
 498     }
 499
 500   last_ind = (a && (flags & ASS_APPEND)) ? array_max_index (a) + 1 : 0;
 501
 502   for (list = nlist; list; list = list->next)
 503     {
 504       iflags = flags;
 505       w = list->word->word;
 506
 507       /* We have a word of the form [ind]=value */
 508       if ((list->word->flags & W_ASSIGNMENT) && w[0] == '[')
 509         {
 510           /* Don't have to handle embedded quotes specially any more, since
 511              associative array subscripts have not been expanded yet (see
 512              above). */
 513           len = skipsubscript (w, 0, 0);
 514
 515           /* XXX - changes for `+=' */
 516           if (w[len] != ']' || (w[len+1] != '=' && (w[len+1] != '+' || w[len+2] != '=')))
 517             {
 518               if (assoc_p (var))
 519                 {
 520                   err_badarraysub (w);
 521                   continue;
 522                 }
 523               nval = make_variable_value (var, w, flags);
 524               if (var->assign_func)
 525                 (*var->assign_func) (var, nval, last_ind, 0);
 526               else
 527                 array_insert (a, last_ind, nval);
 528               FREE (nval);
 529               last_ind++;
 530               continue;
 531             }
 532
 533           if (len == 1)
 534             {
 535               err_badarraysub (w);
 536               continue;
 537             }
 538
 539           if (ALL_ELEMENT_SUB (w[1]) && len == 2)
 540             {
 541               last_command_exit_value = 1;
 542               if (assoc_p (var))
 543                 report_error (_("%s: invalid associative array key"), w);
 544               else
 545                 report_error (_("%s: cannot assign to non-numeric index"), w);
 546               continue;
 547             }
 548
 549           if (array_p (var))
 550             {
 551               ind = array_expand_index (var, w + 1, len);
 552               /* negative subscripts to indexed arrays count back from end */
 553               if (ind < 0)
 554                 ind = array_max_index (array_cell (var)) + 1 + ind;
 555               if (ind < 0)
 556                 {
 557                   err_badarraysub (w);
 558                   continue;
 559                 }
 560
 561               last_ind = ind;
 562             }
 563           else if (assoc_p (var))
 564             {
 565               /* This is not performed above, see expand_compound_array_assignment */
 566               w[len] = '\0';    /*[*/
 567               akey = expand_assignment_string_to_string (w+1, 0);
 568               w[len] = ']';
 569               /* And we need to expand the value also, see below */
 570               if (akey == 0 || *akey == 0)
 571                 {
 572                   err_badarraysub (w);
 573                   FREE (akey);
 574                   continue;
 575                 }
 576             }
 577
 578           /* XXX - changes for `+=' -- just accept the syntax.  ksh93 doesn't do this */
 579           if (w[len + 1] == '+' && w[len + 2] == '=')
 580             {
 581               iflags |= ASS_APPEND;
 582               val = w + len + 3;
 583             }
 584           else
 585             val = w + len + 2;
 586         }
 587       else if (assoc_p (var))
 588         {
 589           last_command_exit_value = 1;
 590           report_error (_("%s: %s: must use subscript when assigning associative array"), var->name, w);
 591           continue;
 592         }
 593       else              /* No [ind]=value, just a stray `=' */
 594         {
 595           ind = last_ind;
 596           val = w;
 597         }
 598
 599       free_val = 0;
 600       /* See above; we need to expand the value here */
 601       if (assoc_p (var))
 602         {
 603           val = expand_assignment_string_to_string (val, 0);
 604           if (val == 0)
 605             {
 606               val = (char *)xmalloc (1);
 607               val[0] = '\0';    /* like do_assignment_internal */
 608             }
 609           free_val = 1;
 610         }
 611
 612       if (integer_p (var))
 613         this_command_name = (char *)NULL;       /* no command name for errors */
 614       bind_array_var_internal (var, ind, akey, val, iflags);
 615       last_ind++;
 616
 617       if (free_val)
 618         free (val);
 619     }
 620 }
 621
 622 /* Perform a compound array assignment:  VAR->name=( VALUE ).  The
 623    VALUE has already had the parentheses stripped. */
 624 SHELL_VAR *
 625 assign_array_var_from_string (var, value, flags)
 626      SHELL_VAR *var;
 627      char *value;
 628      int flags;
 629 {
 630   WORD_LIST *nlist;
 631
 632   if (value == 0)
 633     return var;
 634
 635   nlist = expand_compound_array_assignment (var, value, flags);
 636   assign_compound_array_list (var, nlist, flags);
 637
 638   if (nlist)
 639     dispose_words (nlist);
 640
 641   if (var)
 642     VUNSETATTR (var, att_invisible);    /* no longer invisible */
 643
 644   return (var);
 645 }
 646
 647 /* Quote globbing chars and characters in $IFS before the `=' in an assignment
 648    statement (usually a compound array assignment) to protect them from
 649    unwanted filename expansion or word splitting. */
 650 static char *
 651 quote_assign (string)
 652      const char *string;
 653 {
 654   size_t slen;
 655   int saw_eq;
 656   char *temp, *t, *subs;
 657   const char *s, *send;
 658   int ss, se;
 659   DECLARE_MBSTATE;
 660
 661   slen = strlen (string);
 662   send = string + slen;
 663
 664   t = temp = (char *)xmalloc (slen * 2 + 1);
 665   saw_eq = 0;
 666   for (s = string; *s; )
 667     {
 668       if (*s == '=')
 669         saw_eq = 1;
 670       if (saw_eq == 0 && *s == '[')             /* looks like a subscript */
 671         {
 672           ss = s - string;
 673           se = skipsubscript (string, ss, 0);
 674           subs = substring (s, ss, se);
 675           *t++ = '\\';
 676           strcpy (t, subs);
 677           t += se - ss;
 678           *t++ = '\\';
 679           *t++ = ']';
 680           s += se + 1;
 681           free (subs);
 682           continue;
 683         }
 684       if (saw_eq == 0 && (glob_char_p (s) || isifs (*s)))
 685         *t++ = '\\';
 686
 687       COPY_CHAR_P (t, s, send);
 688     }
 689   *t = '\0';
 690   return temp;
 691 }
 692
 693 /* For each word in a compound array assignment, if the word looks like
 694    [ind]=value, quote globbing chars and characters in $IFS before the `='. */
 695 static void
 696 quote_array_assignment_chars (list)
 697      WORD_LIST *list;
 698 {
 699   char *nword;
 700   WORD_LIST *l;
 701
 702   for (l = list; l; l = l->next)
 703     {
 704       if (l->word == 0 || l->word->word == 0 || l->word->word[0] == '\0')
 705         continue;       /* should not happen, but just in case... */
 706       /* Don't bother if it hasn't been recognized as an assignment or
 707          doesn't look like [ind]=value */
 708       if ((l->word->flags & W_ASSIGNMENT) == 0)
 709         continue;
 710       if (l->word->word[0] != '[' || mbschr (l->word->word, '=') == 0) /* ] */
 711         continue;
 712
 713       nword = quote_assign (l->word->word);
 714       free (l->word->word);
 715       l->word->word = nword;
 716       l->word->flags |= W_NOGLOB;       /* XXX - W_NOSPLIT also? */
 717     }
 718 }
 719
 720 /* skipsubscript moved to subst.c to use private functions. 2009/02/24. */
 721
 722 /* This function is called with SUB pointing to just after the beginning
 723    `[' of an array subscript and removes the array element to which SUB
 724    expands from array VAR.  A subscript of `*' or `@' unsets the array. */
 725 int
 726 unbind_array_element (var, sub)
 727      SHELL_VAR *var;
 728      char *sub;
 729 {
 730   int len;
 731   arrayind_t ind;
 732   char *akey;
 733   ARRAY_ELEMENT *ae;
 734
 735   len = skipsubscript (sub, 0, 0);
 736   if (sub[len] != ']' || len == 0)
 737     {
 738       builtin_error ("%s[%s: %s", var->name, sub, _(bash_badsub_errmsg));
 739       return -1;
 740     }
 741   sub[len] = '\0';
 742
 743   if (ALL_ELEMENT_SUB (sub[0]) && sub[1] == 0)
 744     {
 745       unbind_variable (var->name);
 746       return (0);
 747     }
 748
 749   if (assoc_p (var))
 750     {
 751       akey = expand_assignment_string_to_string (sub, 0);     /* [ */
 752       if (akey == 0 || *akey == 0)
 753         {
 754           builtin_error ("[%s]: %s", sub, _(bash_badsub_errmsg));
 755           FREE (akey);
 756           return -1;
 757         }
 758       assoc_remove (assoc_cell (var), akey);
 759       free (akey);
 760     }
 761   else
 762     {
 763       ind = array_expand_index (var, sub, len+1);
 764       /* negative subscripts to indexed arrays count back from end */
 765       if (ind < 0)
 766         ind = array_max_index (array_cell (var)) + 1 + ind;
 767       if (ind < 0)
 768         {
 769           builtin_error ("[%s]: %s", sub, _(bash_badsub_errmsg));
 770           return -1;
 771         }
 772       ae = array_remove (array_cell (var), ind);
 773       if (ae)
 774         array_dispose_element (ae);
 775     }
 776
 777   return 0;
 778 }
 779
 780 /* Format and output an array assignment in compound form VAR=(VALUES),
 781    suitable for re-use as input. */
 782 void
 783 print_array_assignment (var, quoted)
 784      SHELL_VAR *var;
 785      int quoted;
 786 {
 787   char *vstr;
 788
 789   vstr = array_to_assign (array_cell (var), quoted);
 790
 791   if (vstr == 0)
 792     printf ("%s=%s\n", var->name, quoted ? "'()'" : "()");
 793   else
 794     {
 795       printf ("%s=%s\n", var->name, vstr);
 796       free (vstr);
 797     }
 798 }
 799
 800 /* Format and output an associative array assignment in compound form
 801    VAR=(VALUES), suitable for re-use as input. */
 802 void
 803 print_assoc_assignment (var, quoted)
 804      SHELL_VAR *var;
 805      int quoted;
 806 {
 807   char *vstr;
 808
 809   vstr = assoc_to_assign (assoc_cell (var), quoted);
 810
 811   if (vstr == 0)
 812     printf ("%s=%s\n", var->name, quoted ? "'()'" : "()");
 813   else
 814     {
 815       printf ("%s=%s\n", var->name, vstr);
 816       free (vstr);
 817     }
 818 }
 819
 820 /***********************************************************************/
 821 /*                                                                     */
 822 /* Utility functions to manage arrays and their contents for expansion */
 823 /*                                                                     */
 824 /***********************************************************************/
 825
 826 /* Return 1 if NAME is a properly-formed array reference v[sub]. */
 827 int
 828 valid_array_reference (name)
 829      char *name;
 830 {
 831   char *t;
 832   int r, len;
 833
 834   t = mbschr (name, '[');       /* ] */
 835   if (t)
 836     {
 837       *t = '\0';
 838       r = legal_identifier (name);
 839       *t = '[';
 840       if (r == 0)
 841         return 0;
 842       /* Check for a properly-terminated non-blank subscript. */
 843       len = skipsubscript (t, 0, 0);
 844       if (t[len] != ']' || len == 1)
 845         return 0;
 846       for (r = 1; r < len; r++)
 847         if (whitespace (t[r]) == 0)
 848           return 1;
 849       return 0;
 850     }
 851   return 0;
 852 }
 853
 854 /* Expand the array index beginning at S and extending LEN characters. */
 855 arrayind_t
 856 array_expand_index (var, s, len)
 857      SHELL_VAR *var;
 858      char *s;
 859      int len;
 860 {
 861   char *exp, *t;
 862   int expok;
 863   arrayind_t val;
 864
 865   exp = (char *)xmalloc (len);
 866   strncpy (exp, s, len - 1);
 867   exp[len - 1] = '\0';
 868   t = expand_arith_string (exp, 0);
 869   this_command_name = (char *)NULL;
 870   val = evalexp (t, &expok);
 871   free (t);
 872   free (exp);
 873   if (expok == 0)
 874     {
 875       last_command_exit_value = EXECUTION_FAILURE;
 876
 877       top_level_cleanup ();
 878       jump_to_top_level (DISCARD);
 879     }
 880   return val;
 881 }
 882
 883 /* Return the name of the variable specified by S without any subscript.
 884    If SUBP is non-null, return a pointer to the start of the subscript
 885    in *SUBP. If LENP is non-null, the length of the subscript is returned
 886    in *LENP.  This returns newly-allocated memory. */
 887 char *
 888 array_variable_name (s, subp, lenp)
 889      char *s, **subp;
 890      int *lenp;
 891 {
 892   char *t, *ret;
 893   int ind, ni;
 894
 895   t = mbschr (s, '[');
 896   if (t == 0)
 897     {
 898       if (subp)
 899         *subp = t;
 900       if (lenp)
 901         *lenp = 0;
 902       return ((char *)NULL);
 903     }
 904   ind = t - s;
 905   ni = skipsubscript (s, ind, 0);
 906   if (ni <= ind + 1 || s[ni] != ']')
 907     {
 908       err_badarraysub (s);
 909       if (subp)
 910         *subp = t;
 911       if (lenp)
 912         *lenp = 0;
 913       return ((char *)NULL);
 914     }
 915
 916   *t = '\0';
 917   ret = savestring (s);
 918   *t++ = '[';           /* ] */
 919
 920   if (subp)
 921     *subp = t;
 922   if (lenp)
 923     *lenp = ni - ind;
 924
 925   return ret;
 926 }
 927
 928 /* Return the variable specified by S without any subscript.  If SUBP is
 929    non-null, return a pointer to the start of the subscript in *SUBP.
 930    If LENP is non-null, the length of the subscript is returned in *LENP. */
 931 SHELL_VAR *
 932 array_variable_part (s, subp, lenp)
 933      char *s, **subp;
 934      int *lenp;
 935 {
 936   char *t;
 937   SHELL_VAR *var;
 938
 939   t = array_variable_name (s, subp, lenp);
 940   if (t == 0)
 941     return ((SHELL_VAR *)NULL);
 942   var = find_variable (t);
 943
 944   free (t);
 945 #if 0
 946   return (var == 0 || invisible_p (var)) ? (SHELL_VAR *)0 : var;
 947 #else
 948   return var;   /* now return invisible variables; caller must handle */
 949 #endif
 950 }
 951
 952 #define INDEX_ERROR() \
 953   do \
 954     { \
 955       if (var) \
 956         err_badarraysub (var->name); \
 957       else \
 958         { \
 959           t[-1] = '\0'; \
 960           err_badarraysub (s); \
 961           t[-1] = '[';  /* ] */\
 962         } \
 963       return ((char *)NULL); \
 964     } \
 965   while (0)
 966
 967 /* Return a string containing the elements in the array and subscript
 968    described by S.  If the subscript is * or @, obeys quoting rules akin
 969    to the expansion of $* and $@ including double quoting.  If RTYPE
 970    is non-null it gets 1 if the array reference is name[*], 2 if the
 971    reference is name[@], and 0 otherwise. */
 972 static char *
 973 array_value_internal (s, quoted, flags, rtype, indp)
 974      char *s;
 975      int quoted, flags, *rtype;
 976      arrayind_t *indp;
 977 {
 978   int len;
 979   arrayind_t ind;
 980   char *akey;
 981   char *retval, *t, *temp;
 982   WORD_LIST *l;
 983   SHELL_VAR *var;
 984
 985   var = array_variable_part (s, &t, &len);
 986
 987   /* Expand the index, even if the variable doesn't exist, in case side
 988      effects are needed, like ${w[i++]} where w is unset. */
 989 #if 0
 990   if (var == 0)
 991     return (char *)NULL;
 992 #endif
 993
 994   if (len == 0)
 995     return ((char *)NULL);      /* error message already printed */
 996
 997   /* [ */
 998   akey = 0;
 999   if (ALL_ELEMENT_SUB (t[0]) && t[1] == ']')
1000     {
1001       if (rtype)
1002         *rtype = (t[0] == '*') ? 1 : 2;
1003       if ((flags & AV_ALLOWALL) == 0)
1004         {
1005           err_badarraysub (s);
1006           return ((char *)NULL);
1007         }
1008       else if (var == 0 || value_cell (var) == 0)       /* XXX - check for invisible_p(var) ? */
1009         return ((char *)NULL);
1010       else if (array_p (var) == 0 && assoc_p (var) == 0)
1011         l = add_string_to_list (value_cell (var), (WORD_LIST *)NULL);
1012       else if (assoc_p (var))
1013         {
1014           l = assoc_to_word_list (assoc_cell (var));
1015           if (l == (WORD_LIST *)NULL)
1016             return ((char *)NULL);
1017         }
1018       else
1019         {
1020           l = array_to_word_list (array_cell (var));
1021           if (l == (WORD_LIST *)NULL)
1022             return ((char *) NULL);
1023         }
1024
1025       if (t[0] == '*' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
1026         {
1027           temp = string_list_dollar_star (l);
1028           retval = quote_string (temp);         /* XXX - leak here */
1029           free (temp);
1030         }
1031       else      /* ${name[@]} or unquoted ${name[*]} */
1032         retval = string_list_dollar_at (l, quoted);     /* XXX - leak here */
1033
1034       dispose_words (l);
1035     }
1036   else
1037     {
1038       if (rtype)
1039         *rtype = 0;
1040       if (var == 0 || array_p (var) || assoc_p (var) == 0)
1041         {
1042           if ((flags & AV_USEIND) == 0 || indp == 0)
1043             {
1044               ind = array_expand_index (var, t, len);
1045               if (ind < 0)
1046                 {
1047                   /* negative subscripts to indexed arrays count back from end */
1048                   if (var && array_p (var))
1049                     ind = array_max_index (array_cell (var)) + 1 + ind;
1050                   if (ind < 0)
1051                     INDEX_ERROR();
1052                 }
1053               if (indp)
1054                 *indp = ind;
1055             }
1056           else if (indp)
1057             ind = *indp;
1058         }
1059       else if (assoc_p (var))
1060         {
1061           t[len - 1] = '\0';
1062           akey = expand_assignment_string_to_string (t, 0);     /* [ */
1063           t[len - 1] = ']';
1064           if (akey == 0 || *akey == 0)
1065             {
1066               FREE (akey);
1067               INDEX_ERROR();
1068             }
1069         }
1070
1071       if (var == 0 || value_cell (var) == 0)    /* XXX - check invisible_p(var) ? */
1072         {
1073           FREE (akey);
1074           return ((char *)NULL);
1075         }
1076       if (array_p (var) == 0 && assoc_p (var) == 0)
1077         return (ind == 0 ? value_cell (var) : (char *)NULL);
1078       else if (assoc_p (var))
1079         {
1080           retval = assoc_reference (assoc_cell (var), akey);
1081           free (akey);
1082         }
1083       else
1084         retval = array_reference (array_cell (var), ind);
1085     }
1086
1087   return retval;
1088 }
1089
1090 /* Return a string containing the elements described by the array and
1091    subscript contained in S, obeying quoting for subscripts * and @. */
1092 char *
1093 array_value (s, quoted, flags, rtype, indp)
1094      char *s;
1095      int quoted, flags, *rtype;
1096      arrayind_t *indp;
1097 {
1098   return (array_value_internal (s, quoted, flags|AV_ALLOWALL, rtype, indp));
1099 }
1100
1101 /* Return the value of the array indexing expression S as a single string.
1102    If (FLAGS & AV_ALLOWALL) is 0, do not allow `@' and `*' subscripts.  This
1103    is used by other parts of the shell such as the arithmetic expression
1104    evaluator in expr.c. */
1105 char *
1106 get_array_value (s, flags, rtype, indp)
1107      char *s;
1108      int flags, *rtype;
1109      arrayind_t *indp;
1110 {
1111   return (array_value_internal (s, 0, flags, rtype, indp));
1112 }
1113
1114 char *
1115 array_keys (s, quoted)
1116      char *s;
1117      int quoted;
1118 {
1119   int len;
1120   char *retval, *t, *temp;
1121   WORD_LIST *l;
1122   SHELL_VAR *var;
1123
1124   var = array_variable_part (s, &t, &len);
1125
1126   /* [ */
1127   if (var == 0 || ALL_ELEMENT_SUB (t[0]) == 0 || t[1] != ']')
1128     return (char *)NULL;
1129
1130   if (var_isset (var) == 0 || invisible_p (var))
1131     return (char *)NULL;
1132
1133   if (array_p (var) == 0 && assoc_p (var) == 0)
1134     l = add_string_to_list ("0", (WORD_LIST *)NULL);
1135   else if (assoc_p (var))
1136     l = assoc_keys_to_word_list (assoc_cell (var));
1137   else
1138     l = array_keys_to_word_list (array_cell (var));
1139   if (l == (WORD_LIST *)NULL)
1140     return ((char *) NULL);
1141
1142   if (t[0] == '*' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
1143     {
1144       temp = string_list_dollar_star (l);
1145       retval = quote_string (temp);
1146       free (temp);
1147     }
1148   else  /* ${!name[@]} or unquoted ${!name[*]} */
1149     retval = string_list_dollar_at (l, quoted);
1150
1151   dispose_words (l);
1152   return retval;
1153 }
1154 #endif /* ARRAY_VARS */