1 /* arrayfunc.c -- High-level array functions used by other parts of the shell. */
3 /* Copyright (C) 2001-2006 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License along
18 with Bash; see the file COPYING. If not, write to the Free Software
19 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
23 #if defined (ARRAY_VARS)
25 #if defined (HAVE_UNISTD_H)
36 #include "builtins/common.h"
38 extern char *this_command_name;
39 extern int last_command_exit_value;
40 extern int array_needs_making;
42 static SHELL_VAR *bind_array_var_internal __P((SHELL_VAR *, arrayind_t, char *, int));
44 static void quote_array_assignment_chars __P((WORD_LIST *));
45 static char *array_value_internal __P((char *, int, int, int *));
47 /* Standard error message to use when encountering an invalid array subscript */
48 char *bash_badsub_errmsg = N_("bad array subscript");
50 /* **************************************************************** */
52 /* Functions to manipulate array variables and perform assignments */
54 /* **************************************************************** */
56 /* Convert a shell variable to an array variable. The original value is
59 convert_var_to_array (var)
65 oldval = value_cell (var);
66 array = array_create ();
68 array_insert (array, 0, oldval);
70 FREE (value_cell (var));
71 var_setarray (var, array);
73 /* these aren't valid anymore */
74 var->dynamic_value = (sh_var_value_func_t *)NULL;
75 var->assign_func = (sh_var_assign_func_t *)NULL;
77 INVALIDATE_EXPORTSTR (var);
81 VSETATTR (var, att_array);
82 VUNSETATTR (var, att_invisible);
88 bind_array_var_internal (entry, ind, value, flags)
97 /* If we're appending, we need the old value of the array reference, so
98 fake out make_variable_value with a dummy SHELL_VAR */
99 if (flags & ASS_APPEND)
101 dentry = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
102 dentry->name = savestring (entry->name);
103 newval = array_reference (array_cell (entry), ind);
105 dentry->value = savestring (newval);
108 dentry->value = (char *)xmalloc (1);
109 dentry->value[0] = '\0';
111 dentry->exportstr = 0;
112 dentry->attributes = entry->attributes & ~(att_array|att_exported);
113 /* Leave the rest of the members uninitialized; the code doesn't look
115 newval = make_variable_value (dentry, value, flags);
116 dispose_variable (dentry);
119 newval = make_variable_value (entry, value, flags);
121 if (entry->assign_func)
122 (*entry->assign_func) (entry, newval, ind);
124 array_insert (array_cell (entry), ind, newval);
130 /* Perform an array assignment name[ind]=value. If NAME already exists and
131 is not an array, and IND is 0, perform name=value instead. If NAME exists
132 and is not an array, and IND is not 0, convert it into an array with the
133 existing value as name[0].
135 If NAME does not exist, just create an array variable, no matter what
136 IND's value may be. */
138 bind_array_variable (name, ind, value, flags)
146 entry = var_lookup (name, shell_variables);
148 if (entry == (SHELL_VAR *) 0)
149 entry = make_new_array_variable (name);
150 else if (readonly_p (entry) || noassign_p (entry))
152 if (readonly_p (entry))
156 else if (array_p (entry) == 0)
157 entry = convert_var_to_array (entry);
159 /* ENTRY is an array variable, and ARRAY points to the value. */
160 return (bind_array_var_internal (entry, ind, value, flags));
163 /* Parse NAME, a lhs of an assignment statement of the form v[s], and
164 assign VALUE to that array element by calling bind_array_variable(). */
166 assign_array_element (name, value, flags)
175 vname = array_variable_name (name, &sub, &sublen);
178 return ((SHELL_VAR *)NULL);
180 if ((ALL_ELEMENT_SUB (sub[0]) && sub[1] == ']') || (sublen <= 1))
183 err_badarraysub (name);
184 return ((SHELL_VAR *)NULL);
187 ind = array_expand_index (sub, sublen);
191 err_badarraysub (name);
192 return ((SHELL_VAR *)NULL);
195 entry = bind_array_variable (vname, ind, value, flags);
201 /* Find the array variable corresponding to NAME. If there is no variable,
202 create a new array variable. If the variable exists but is not an array,
203 convert it to an indexed array. If CHECK_FLAGS is non-zero, an existing
204 variable is checked for the readonly or noassign attribute in preparation
205 for assignment (e.g., by the `read' builtin). */
207 find_or_make_array_variable (name, check_flags)
213 var = find_variable (name);
216 var = make_new_array_variable (name);
217 else if (check_flags && (readonly_p (var) || noassign_p (var)))
219 if (readonly_p (var))
221 return ((SHELL_VAR *)NULL);
223 else if (array_p (var) == 0)
224 var = convert_var_to_array (var);
229 /* Perform a compound assignment statement for array NAME, where VALUE is
230 the text between the parens: NAME=( VALUE ) */
232 assign_array_from_string (name, value, flags)
238 var = find_or_make_array_variable (name, 1);
240 return ((SHELL_VAR *)NULL);
242 return (assign_array_var_from_string (var, value, flags));
245 /* Sequentially assign the indices of indexed array variable VAR from the
248 assign_array_var_from_word_list (var, list, flags)
253 register arrayind_t i;
254 register WORD_LIST *l;
257 a = array_cell (var);
258 i = (flags & ASS_APPEND) ? array_max_index (a) + 1 : 0;
260 for (l = list; l; l = l->next, i++)
261 if (var->assign_func)
262 (*var->assign_func) (var, l->word->word, i);
264 array_insert (a, i, l->word->word);
269 expand_compound_array_assignment (value, flags)
273 WORD_LIST *list, *nlist;
277 /* I don't believe this condition is ever true any more. */
278 if (*value == '(') /*)*/
281 val = extract_array_assignment_list (value, &ni);
283 return (WORD_LIST *)NULL;
288 /* Expand the value string into a list of words, performing all the
289 shell expansions including pathname generation and word splitting. */
290 /* First we split the string on whitespace, using the shell parser
291 (ksh93 seems to do this). */
292 list = parse_string_to_word_list (val, 1, "array assign");
294 /* If we're using [subscript]=value, we need to quote each [ and ] to
295 prevent unwanted filename expansion. */
297 quote_array_assignment_chars (list);
299 /* Now that we've split it, perform the shell expansions on each
301 nlist = list ? expand_words_no_vars (list) : (WORD_LIST *)NULL;
303 dispose_words (list);
312 assign_compound_array_list (var, nlist, flags)
319 char *w, *val, *nval;
321 arrayind_t ind, last_ind;
323 a = array_cell (var);
325 /* Now that we are ready to assign values to the array, kill the existing
327 if (a && (flags & ASS_APPEND) == 0)
329 last_ind = (flags & ASS_APPEND) ? array_max_index (a) + 1 : 0;
331 for (list = nlist; list; list = list->next)
334 w = list->word->word;
336 /* We have a word of the form [ind]=value */
337 if ((list->word->flags & W_ASSIGNMENT) && w[0] == '[')
339 len = skipsubscript (w, 0);
341 /* XXX - changes for `+=' */
342 if (w[len] != ']' || (w[len+1] != '=' && (w[len+1] != '+' || w[len+2] != '=')))
344 nval = make_variable_value (var, w, flags);
345 if (var->assign_func)
346 (*var->assign_func) (var, nval, last_ind);
348 array_insert (a, last_ind, nval);
360 if (ALL_ELEMENT_SUB (w[1]) && len == 2)
362 report_error (_("%s: cannot assign to non-numeric index"), w);
366 ind = array_expand_index (w + 1, len);
373 /* XXX - changes for `+=' -- just accept the syntax. ksh93 doesn't do this */
374 if (w[len + 1] == '+' && w[len + 2] == '=')
376 iflags |= ASS_APPEND;
382 else /* No [ind]=value, just a stray `=' */
389 this_command_name = (char *)NULL; /* no command name for errors */
390 bind_array_var_internal (var, ind, val, iflags);
395 /* Perform a compound array assignment: VAR->name=( VALUE ). The
396 VALUE has already had the parentheses stripped. */
398 assign_array_var_from_string (var, value, flags)
408 nlist = expand_compound_array_assignment (value, flags);
409 assign_compound_array_list (var, nlist, flags);
412 dispose_words (nlist);
416 /* For each word in a compound array assignment, if the word looks like
417 [ind]=value, quote the `[' and `]' before the `=' to protect them from
418 unwanted filename expansion. */
420 quote_array_assignment_chars (list)
427 for (l = list; l; l = l->next)
429 if (l->word == 0 || l->word->word == 0 || l->word->word[0] == '\0')
430 continue; /* should not happen, but just in case... */
431 /* Don't bother if it doesn't look like [ind]=value */
432 if (l->word->word[0] != '[' || xstrchr (l->word->word, '=') == 0) /* ] */
434 s = nword = (char *)xmalloc (strlen (l->word->word) * 2 + 1);
436 for (t = l->word->word; *t; )
440 if (saw_eq == 0 && (*t == '[' || *t == ']'))
445 free (l->word->word);
446 l->word->word = nword;
450 /* This function assumes s[i] == '['; returns with s[ret] == ']' if
451 an array subscript is correctly parsed. */
458 #if defined (HANDLE_MULTIBYTE)
459 mbstate_t state, state_bak;
460 size_t slength, mblength;
463 #if defined (HANDLE_MULTIBYTE)
464 memset (&state, '\0', sizeof (mbstate_t));
465 slength = strlen (s + i);
471 /* Advance one (possibly multibyte) character in S starting at I. */
472 #if defined (HANDLE_MULTIBYTE)
476 mblength = mbrlen (s + i, slength, &state);
478 if (MB_INVALIDCH (mblength))
484 else if (MB_NULLWCH (mblength))
509 /* This function is called with SUB pointing to just after the beginning
510 `[' of an array subscript and removes the array element to which SUB
511 expands from array VAR. A subscript of `*' or `@' unsets the array. */
513 unbind_array_element (var, sub)
521 len = skipsubscript (sub, 0);
522 if (sub[len] != ']' || len == 0)
524 builtin_error ("%s[%s: %s", var->name, sub, _(bash_badsub_errmsg));
529 if (ALL_ELEMENT_SUB (sub[0]) && sub[1] == 0)
531 unbind_variable (var->name);
534 ind = array_expand_index (sub, len+1);
537 builtin_error ("[%s]: %s", sub, _(bash_badsub_errmsg));
540 ae = array_remove (array_cell (var), ind);
542 array_dispose_element (ae);
546 /* Format and output an array assignment in compound form VAR=(VALUES),
547 suitable for re-use as input. */
549 print_array_assignment (var, quoted)
555 vstr = array_to_assign (array_cell (var), quoted);
558 printf ("%s=%s\n", var->name, quoted ? "'()'" : "()");
561 printf ("%s=%s\n", var->name, vstr);
566 /***********************************************************************/
568 /* Utility functions to manage arrays and their contents for expansion */
570 /***********************************************************************/
572 /* Return 1 if NAME is a properly-formed array reference v[sub]. */
574 valid_array_reference (name)
580 t = xstrchr (name, '['); /* ] */
584 r = legal_identifier (name);
588 /* Check for a properly-terminated non-blank subscript. */
589 len = skipsubscript (t, 0);
590 if (t[len] != ']' || len == 1)
592 for (r = 1; r < len; r++)
593 if (whitespace (t[r]) == 0)
600 /* Expand the array index beginning at S and extending LEN characters. */
602 array_expand_index (s, len)
610 exp = (char *)xmalloc (len);
611 strncpy (exp, s, len - 1);
613 t = expand_arith_string (exp, 0);
614 this_command_name = (char *)NULL;
615 val = evalexp (t, &expok);
620 last_command_exit_value = EXECUTION_FAILURE;
622 top_level_cleanup ();
623 jump_to_top_level (DISCARD);
628 /* Return the name of the variable specified by S without any subscript.
629 If SUBP is non-null, return a pointer to the start of the subscript
630 in *SUBP. If LENP is non-null, the length of the subscript is returned
631 in *LENP. This returns newly-allocated memory. */
633 array_variable_name (s, subp, lenp)
640 t = xstrchr (s, '[');
647 return ((char *)NULL);
650 ni = skipsubscript (s, ind);
651 if (ni <= ind + 1 || s[ni] != ']')
658 return ((char *)NULL);
662 ret = savestring (s);
673 /* Return the variable specified by S without any subscript. If SUBP is
674 non-null, return a pointer to the start of the subscript in *SUBP.
675 If LENP is non-null, the length of the subscript is returned in *LENP. */
677 array_variable_part (s, subp, lenp)
684 t = array_variable_name (s, subp, lenp);
686 return ((SHELL_VAR *)NULL);
687 var = find_variable (t);
690 return (var == 0 || invisible_p (var)) ? (SHELL_VAR *)0 : var;
693 /* Return a string containing the elements in the array and subscript
694 described by S. If the subscript is * or @, obeys quoting rules akin
695 to the expansion of $* and $@ including double quoting. If RTYPE
696 is non-null it gets 1 if the array reference is name[@] or name[*]
699 array_value_internal (s, quoted, allow_all, rtype)
701 int quoted, allow_all, *rtype;
705 char *retval, *t, *temp;
709 var = array_variable_part (s, &t, &len);
711 /* Expand the index, even if the variable doesn't exist, in case side
712 effects are needed, like ${w[i++]} where w is unset. */
719 return ((char *)NULL); /* error message already printed */
722 if (ALL_ELEMENT_SUB (t[0]) && t[1] == ']')
725 *rtype = (t[0] == '*') ? 1 : 2;
729 return ((char *)NULL);
731 else if (var == 0 || value_cell (var) == 0)
732 return ((char *)NULL);
733 else if (array_p (var) == 0)
734 l = add_string_to_list (value_cell (var), (WORD_LIST *)NULL);
737 l = array_to_word_list (array_cell (var));
738 if (l == (WORD_LIST *)NULL)
739 return ((char *) NULL);
742 if (t[0] == '*' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
744 temp = string_list_dollar_star (l);
745 retval = quote_string (temp);
748 else /* ${name[@]} or unquoted ${name[*]} */
749 retval = string_list_dollar_at (l, quoted);
757 ind = array_expand_index (t, len);
761 err_badarraysub (var->name);
768 return ((char *)NULL);
771 return ((char *)NULL);
772 if (array_p (var) == 0)
773 return (ind == 0 ? value_cell (var) : (char *)NULL);
774 retval = array_reference (array_cell (var), ind);
780 /* Return a string containing the elements described by the array and
781 subscript contained in S, obeying quoting for subscripts * and @. */
783 array_value (s, quoted, rtype)
787 return (array_value_internal (s, quoted, 1, rtype));
790 /* Return the value of the array indexing expression S as a single string.
791 If ALLOW_ALL is 0, do not allow `@' and `*' subscripts. This is used
792 by other parts of the shell such as the arithmetic expression evaluator
795 get_array_value (s, allow_all, rtype)
797 int allow_all, *rtype;
799 return (array_value_internal (s, 0, allow_all, rtype));
803 array_keys (s, quoted)
808 char *retval, *t, *temp;
812 var = array_variable_part (s, &t, &len);
815 if (var == 0 || ALL_ELEMENT_SUB (t[0]) == 0 || t[1] != ']')
818 if (array_p (var) == 0)
819 l = add_string_to_list ("0", (WORD_LIST *)NULL);
822 l = array_keys_to_word_list (array_cell (var));
823 if (l == (WORD_LIST *)NULL)
824 return ((char *) NULL);
827 if (t[0] == '*' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
829 temp = string_list_dollar_star (l);
830 retval = quote_string (temp);
833 else /* ${!name[@]} or unquoted ${!name[*]} */
834 retval = string_list_dollar_at (l, quoted);
839 #endif /* ARRAY_VARS */