Added gitignore entries needed to ignore derived objects generated from full build...
[bash.git] / arrayfunc.c
blob21eb4cd792ab6328b8712c88e2fbf02300823eda
1 /* arrayfunc.c -- High-level array functions used by other parts of the shell. */
3 /* Copyright (C) 2001-2010 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
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.
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.
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/>.
21 #include "config.h"
23 #if defined (ARRAY_VARS)
25 #if defined (HAVE_UNISTD_H)
26 # include <unistd.h>
27 #endif
28 #include <stdio.h>
30 #include "bashintl.h"
32 #include "shell.h"
33 #include "pathexp.h"
35 #include "shmbutil.h"
37 #include "builtins/common.h"
39 extern char *this_command_name;
40 extern int last_command_exit_value;
41 extern int array_needs_making;
43 static SHELL_VAR *bind_array_var_internal __P((SHELL_VAR *, arrayind_t, char *, char *, int));
45 static char *quote_assign __P((const char *));
46 static void quote_array_assignment_chars __P((WORD_LIST *));
47 static char *array_value_internal __P((char *, int, int, int *, arrayind_t *));
49 /* Standard error message to use when encountering an invalid array subscript */
50 const char * const bash_badsub_errmsg = N_("bad array subscript");
52 /* **************************************************************** */
53 /* */
54 /* Functions to manipulate array variables and perform assignments */
55 /* */
56 /* **************************************************************** */
58 /* Convert a shell variable to an array variable. The original value is
59 saved as array[0]. */
60 SHELL_VAR *
61 convert_var_to_array (var)
62 SHELL_VAR *var;
64 char *oldval;
65 ARRAY *array;
67 oldval = value_cell (var);
68 array = array_create ();
69 if (oldval)
70 array_insert (array, 0, oldval);
72 FREE (value_cell (var));
73 var_setarray (var, array);
75 /* these aren't valid anymore */
76 var->dynamic_value = (sh_var_value_func_t *)NULL;
77 var->assign_func = (sh_var_assign_func_t *)NULL;
79 INVALIDATE_EXPORTSTR (var);
80 if (exported_p (var))
81 array_needs_making++;
83 VSETATTR (var, att_array);
84 VUNSETATTR (var, att_invisible);
86 return var;
89 /* Convert a shell variable to an array variable. The original value is
90 saved as array[0]. */
91 SHELL_VAR *
92 convert_var_to_assoc (var)
93 SHELL_VAR *var;
95 char *oldval;
96 HASH_TABLE *hash;
98 oldval = value_cell (var);
99 hash = assoc_create (0);
100 if (oldval)
101 assoc_insert (hash, savestring ("0"), oldval);
103 FREE (value_cell (var));
104 var_setassoc (var, hash);
106 /* these aren't valid anymore */
107 var->dynamic_value = (sh_var_value_func_t *)NULL;
108 var->assign_func = (sh_var_assign_func_t *)NULL;
110 INVALIDATE_EXPORTSTR (var);
111 if (exported_p (var))
112 array_needs_making++;
114 VSETATTR (var, att_assoc);
115 VUNSETATTR (var, att_invisible);
117 return var;
120 static SHELL_VAR *
121 bind_array_var_internal (entry, ind, key, value, flags)
122 SHELL_VAR *entry;
123 arrayind_t ind;
124 char *key;
125 char *value;
126 int flags;
128 SHELL_VAR *dentry;
129 char *newval;
131 /* If we're appending, we need the old value of the array reference, so
132 fake out make_variable_value with a dummy SHELL_VAR */
133 if (flags & ASS_APPEND)
135 dentry = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
136 dentry->name = savestring (entry->name);
137 if (assoc_p (entry))
138 newval = assoc_reference (assoc_cell (entry), key);
139 else
140 newval = array_reference (array_cell (entry), ind);
141 if (newval)
142 dentry->value = savestring (newval);
143 else
145 dentry->value = (char *)xmalloc (1);
146 dentry->value[0] = '\0';
148 dentry->exportstr = 0;
149 dentry->attributes = entry->attributes & ~(att_array|att_assoc|att_exported);
150 /* Leave the rest of the members uninitialized; the code doesn't look
151 at them. */
152 newval = make_variable_value (dentry, value, flags);
153 dispose_variable (dentry);
155 else
156 newval = make_variable_value (entry, value, flags);
158 if (entry->assign_func)
159 (*entry->assign_func) (entry, newval, ind, key);
160 else if (assoc_p (entry))
161 assoc_insert (assoc_cell (entry), key, newval);
162 else
163 array_insert (array_cell (entry), ind, newval);
164 FREE (newval);
166 return (entry);
169 /* Perform an array assignment name[ind]=value. If NAME already exists and
170 is not an array, and IND is 0, perform name=value instead. If NAME exists
171 and is not an array, and IND is not 0, convert it into an array with the
172 existing value as name[0].
174 If NAME does not exist, just create an array variable, no matter what
175 IND's value may be. */
176 SHELL_VAR *
177 bind_array_variable (name, ind, value, flags)
178 char *name;
179 arrayind_t ind;
180 char *value;
181 int flags;
183 SHELL_VAR *entry;
185 entry = var_lookup (name, shell_variables);
187 if (entry == (SHELL_VAR *) 0)
188 entry = make_new_array_variable (name);
189 else if (readonly_p (entry) || noassign_p (entry))
191 if (readonly_p (entry))
192 err_readonly (name);
193 return (entry);
195 else if (array_p (entry) == 0)
196 entry = convert_var_to_array (entry);
198 /* ENTRY is an array variable, and ARRAY points to the value. */
199 return (bind_array_var_internal (entry, ind, 0, value, flags));
202 SHELL_VAR *
203 bind_array_element (entry, ind, value, flags)
204 SHELL_VAR *entry;
205 arrayind_t ind;
206 char *value;
207 int flags;
209 return (bind_array_var_internal (entry, ind, 0, value, flags));
212 SHELL_VAR *
213 bind_assoc_variable (entry, name, key, value, flags)
214 SHELL_VAR *entry;
215 char *name;
216 char *key;
217 char *value;
218 int flags;
220 SHELL_VAR *dentry;
221 char *newval;
223 if (readonly_p (entry) || noassign_p (entry))
225 if (readonly_p (entry))
226 err_readonly (name);
227 return (entry);
230 return (bind_array_var_internal (entry, 0, key, value, flags));
233 /* Parse NAME, a lhs of an assignment statement of the form v[s], and
234 assign VALUE to that array element by calling bind_array_variable(). */
235 SHELL_VAR *
236 assign_array_element (name, value, flags)
237 char *name, *value;
238 int flags;
240 char *sub, *vname, *akey;
241 arrayind_t ind;
242 int sublen;
243 SHELL_VAR *entry;
245 vname = array_variable_name (name, &sub, &sublen);
247 if (vname == 0)
248 return ((SHELL_VAR *)NULL);
250 if ((ALL_ELEMENT_SUB (sub[0]) && sub[1] == ']') || (sublen <= 1))
252 free (vname);
253 err_badarraysub (name);
254 return ((SHELL_VAR *)NULL);
257 entry = find_variable (vname);
259 if (entry && assoc_p (entry))
261 sub[sublen-1] = '\0';
262 akey = expand_assignment_string_to_string (sub, 0); /* [ */
263 sub[sublen-1] = ']';
264 if (akey == 0 || *akey == 0)
266 free (vname);
267 err_badarraysub (name);
268 return ((SHELL_VAR *)NULL);
270 entry = bind_assoc_variable (entry, vname, akey, value, flags);
272 else
274 ind = array_expand_index (sub, sublen);
275 if (ind < 0)
277 free (vname);
278 err_badarraysub (name);
279 return ((SHELL_VAR *)NULL);
281 entry = bind_array_variable (vname, ind, value, flags);
284 free (vname);
285 return (entry);
288 /* Find the array variable corresponding to NAME. If there is no variable,
289 create a new array variable. If the variable exists but is not an array,
290 convert it to an indexed array. If FLAGS&1 is non-zero, an existing
291 variable is checked for the readonly or noassign attribute in preparation
292 for assignment (e.g., by the `read' builtin). If FLAGS&2 is non-zero, we
293 create an associative array. */
294 SHELL_VAR *
295 find_or_make_array_variable (name, flags)
296 char *name;
297 int flags;
299 SHELL_VAR *var;
301 var = find_variable (name);
303 if (var == 0)
304 var = (flags & 2) ? make_new_assoc_variable (name) : make_new_array_variable (name);
305 else if ((flags & 1) && (readonly_p (var) || noassign_p (var)))
307 if (readonly_p (var))
308 err_readonly (name);
309 return ((SHELL_VAR *)NULL);
311 else if ((flags & 2) && array_p (var))
313 report_error (_("%s: cannot convert indexed to associative array"), name);
314 return ((SHELL_VAR *)NULL);
316 else if (array_p (var) == 0 && assoc_p (var) == 0)
317 var = convert_var_to_array (var);
319 return (var);
322 /* Perform a compound assignment statement for array NAME, where VALUE is
323 the text between the parens: NAME=( VALUE ) */
324 SHELL_VAR *
325 assign_array_from_string (name, value, flags)
326 char *name, *value;
327 int flags;
329 SHELL_VAR *var;
330 int vflags;
332 vflags = 1;
333 if (flags & ASS_MKASSOC)
334 vflags |= 2;
336 var = find_or_make_array_variable (name, vflags);
337 if (var == 0)
338 return ((SHELL_VAR *)NULL);
340 return (assign_array_var_from_string (var, value, flags));
343 /* Sequentially assign the indices of indexed array variable VAR from the
344 words in LIST. */
345 SHELL_VAR *
346 assign_array_var_from_word_list (var, list, flags)
347 SHELL_VAR *var;
348 WORD_LIST *list;
349 int flags;
351 register arrayind_t i;
352 register WORD_LIST *l;
353 ARRAY *a;
355 a = array_cell (var);
356 i = (flags & ASS_APPEND) ? array_max_index (a) + 1 : 0;
358 for (l = list; l; l = l->next, i++)
359 if (var->assign_func)
360 (*var->assign_func) (var, l->word->word, i, 0);
361 else
362 array_insert (a, i, l->word->word);
363 return var;
366 WORD_LIST *
367 expand_compound_array_assignment (var, value, flags)
368 SHELL_VAR *var;
369 char *value;
370 int flags;
372 WORD_LIST *list, *nlist;
373 char *val;
374 int ni;
376 /* I don't believe this condition is ever true any more. */
377 if (*value == '(') /*)*/
379 ni = 1;
380 val = extract_array_assignment_list (value, &ni);
381 if (val == 0)
382 return (WORD_LIST *)NULL;
384 else
385 val = value;
387 /* Expand the value string into a list of words, performing all the
388 shell expansions including pathname generation and word splitting. */
389 /* First we split the string on whitespace, using the shell parser
390 (ksh93 seems to do this). */
391 list = parse_string_to_word_list (val, 1, "array assign");
393 /* If we're using [subscript]=value, we need to quote each [ and ] to
394 prevent unwanted filename expansion. */
395 if (list)
396 quote_array_assignment_chars (list);
398 /* Now that we've split it, perform the shell expansions on each
399 word in the list. */
400 nlist = list ? expand_words_no_vars (list) : (WORD_LIST *)NULL;
402 dispose_words (list);
404 if (val != value)
405 free (val);
407 return nlist;
410 /* Callers ensure that VAR is not NULL */
411 void
412 assign_compound_array_list (var, nlist, flags)
413 SHELL_VAR *var;
414 WORD_LIST *nlist;
415 int flags;
417 ARRAY *a;
418 HASH_TABLE *h;
419 WORD_LIST *list;
420 char *w, *val, *nval;
421 int len, iflags;
422 arrayind_t ind, last_ind;
423 char *akey;
425 a = (var && array_p (var)) ? array_cell (var) : (ARRAY *)0;
426 h = (var && assoc_p (var)) ? assoc_cell (var) : (HASH_TABLE *)0;
428 akey = (char *)0;
429 ind = 0;
431 /* Now that we are ready to assign values to the array, kill the existing
432 value. */
433 if ((flags & ASS_APPEND) == 0)
435 if (a && array_p (var))
436 array_flush (a);
437 else if (h && assoc_p (var))
438 assoc_flush (h);
441 last_ind = (a && (flags & ASS_APPEND)) ? array_max_index (a) + 1 : 0;
443 for (list = nlist; list; list = list->next)
445 iflags = flags;
446 w = list->word->word;
448 /* We have a word of the form [ind]=value */
449 if ((list->word->flags & W_ASSIGNMENT) && w[0] == '[')
451 len = skipsubscript (w, 0, (var && assoc_p (var) != 0));
453 /* XXX - changes for `+=' */
454 if (w[len] != ']' || (w[len+1] != '=' && (w[len+1] != '+' || w[len+2] != '=')))
456 if (assoc_p (var))
458 err_badarraysub (w);
459 continue;
461 nval = make_variable_value (var, w, flags);
462 if (var->assign_func)
463 (*var->assign_func) (var, nval, last_ind, 0);
464 else
465 array_insert (a, last_ind, nval);
466 FREE (nval);
467 last_ind++;
468 continue;
471 if (len == 1)
473 err_badarraysub (w);
474 continue;
477 if (ALL_ELEMENT_SUB (w[1]) && len == 2)
479 if (assoc_p (var))
480 report_error (_("%s: invalid associative array key"), w);
481 else
482 report_error (_("%s: cannot assign to non-numeric index"), w);
483 continue;
486 if (array_p (var))
488 ind = array_expand_index (w + 1, len);
489 if (ind < 0)
491 err_badarraysub (w);
492 continue;
495 last_ind = ind;
497 else if (assoc_p (var))
499 akey = substring (w, 1, len);
500 if (akey == 0 || *akey == 0)
502 err_badarraysub (w);
503 continue;
507 /* XXX - changes for `+=' -- just accept the syntax. ksh93 doesn't do this */
508 if (w[len + 1] == '+' && w[len + 2] == '=')
510 iflags |= ASS_APPEND;
511 val = w + len + 3;
513 else
514 val = w + len + 2;
516 else if (assoc_p (var))
518 report_error (_("%s: %s: must use subscript when assigning associative array"), var->name, w);
519 continue;
521 else /* No [ind]=value, just a stray `=' */
523 ind = last_ind;
524 val = w;
527 if (integer_p (var))
528 this_command_name = (char *)NULL; /* no command name for errors */
529 bind_array_var_internal (var, ind, akey, val, iflags);
530 last_ind++;
534 /* Perform a compound array assignment: VAR->name=( VALUE ). The
535 VALUE has already had the parentheses stripped. */
536 SHELL_VAR *
537 assign_array_var_from_string (var, value, flags)
538 SHELL_VAR *var;
539 char *value;
540 int flags;
542 WORD_LIST *nlist;
544 if (value == 0)
545 return var;
547 nlist = expand_compound_array_assignment (var, value, flags);
548 assign_compound_array_list (var, nlist, flags);
550 if (nlist)
551 dispose_words (nlist);
552 return (var);
555 /* Quote globbing chars and characters in $IFS before the `=' in an assignment
556 statement (usually a compound array assignment) to protect them from
557 unwanted filename expansion or word splitting. */
558 static char *
559 quote_assign (string)
560 const char *string;
562 size_t slen;
563 int saw_eq;
564 char *temp, *t, *subs;
565 const char *s, *send;
566 int ss, se;
567 DECLARE_MBSTATE;
569 slen = strlen (string);
570 send = string + slen;
572 t = temp = (char *)xmalloc (slen * 2 + 1);
573 saw_eq = 0;
574 for (s = string; *s; )
576 if (*s == '=')
577 saw_eq = 1;
578 if (saw_eq == 0 && *s == '[') /* looks like a subscript */
580 ss = s - string;
581 se = skipsubscript (string, ss, 0);
582 subs = substring (s, ss, se);
583 *t++ = '\\';
584 strcpy (t, subs);
585 t += se - ss;
586 *t++ = '\\';
587 *t++ = ']';
588 s += se + 1;
589 free (subs);
590 continue;
592 if (saw_eq == 0 && (glob_char_p (s) || isifs (*s)))
593 *t++ = '\\';
595 COPY_CHAR_P (t, s, send);
597 *t = '\0';
598 return temp;
601 /* For each word in a compound array assignment, if the word looks like
602 [ind]=value, quote globbing chars and characters in $IFS before the `='. */
603 static void
604 quote_array_assignment_chars (list)
605 WORD_LIST *list;
607 char *nword;
608 WORD_LIST *l;
610 for (l = list; l; l = l->next)
612 if (l->word == 0 || l->word->word == 0 || l->word->word[0] == '\0')
613 continue; /* should not happen, but just in case... */
614 /* Don't bother if it doesn't look like [ind]=value */
615 if (l->word->word[0] != '[' || mbschr (l->word->word, '=') == 0) /* ] */
616 continue;
617 nword = quote_assign (l->word->word);
618 free (l->word->word);
619 l->word->word = nword;
623 /* skipsubscript moved to subst.c to use private functions. 2009/02/24. */
625 /* This function is called with SUB pointing to just after the beginning
626 `[' of an array subscript and removes the array element to which SUB
627 expands from array VAR. A subscript of `*' or `@' unsets the array. */
629 unbind_array_element (var, sub)
630 SHELL_VAR *var;
631 char *sub;
633 int len;
634 arrayind_t ind;
635 char *akey;
636 ARRAY_ELEMENT *ae;
638 len = skipsubscript (sub, 0, 0);
639 if (sub[len] != ']' || len == 0)
641 builtin_error ("%s[%s: %s", var->name, sub, _(bash_badsub_errmsg));
642 return -1;
644 sub[len] = '\0';
646 if (ALL_ELEMENT_SUB (sub[0]) && sub[1] == 0)
648 unbind_variable (var->name);
649 return (0);
652 if (assoc_p (var))
654 akey = expand_assignment_string_to_string (sub, 0); /* [ */
655 if (akey == 0 || *akey == 0)
657 builtin_error ("[%s]: %s", sub, _(bash_badsub_errmsg));
658 return -1;
660 assoc_remove (assoc_cell (var), akey);
661 free (akey);
663 else
665 ind = array_expand_index (sub, len+1);
666 if (ind < 0)
668 builtin_error ("[%s]: %s", sub, _(bash_badsub_errmsg));
669 return -1;
671 ae = array_remove (array_cell (var), ind);
672 if (ae)
673 array_dispose_element (ae);
676 return 0;
679 /* Format and output an array assignment in compound form VAR=(VALUES),
680 suitable for re-use as input. */
681 void
682 print_array_assignment (var, quoted)
683 SHELL_VAR *var;
684 int quoted;
686 char *vstr;
688 vstr = array_to_assign (array_cell (var), quoted);
690 if (vstr == 0)
691 printf ("%s=%s\n", var->name, quoted ? "'()'" : "()");
692 else
694 printf ("%s=%s\n", var->name, vstr);
695 free (vstr);
699 /* Format and output an associative array assignment in compound form
700 VAR=(VALUES), suitable for re-use as input. */
701 void
702 print_assoc_assignment (var, quoted)
703 SHELL_VAR *var;
704 int quoted;
706 char *vstr;
708 vstr = assoc_to_assign (assoc_cell (var), quoted);
710 if (vstr == 0)
711 printf ("%s=%s\n", var->name, quoted ? "'()'" : "()");
712 else
714 printf ("%s=%s\n", var->name, vstr);
715 free (vstr);
719 /***********************************************************************/
720 /* */
721 /* Utility functions to manage arrays and their contents for expansion */
722 /* */
723 /***********************************************************************/
725 /* Return 1 if NAME is a properly-formed array reference v[sub]. */
727 valid_array_reference (name)
728 char *name;
730 char *t;
731 int r, len;
733 t = mbschr (name, '['); /* ] */
734 if (t)
736 *t = '\0';
737 r = legal_identifier (name);
738 *t = '[';
739 if (r == 0)
740 return 0;
741 /* Check for a properly-terminated non-blank subscript. */
742 len = skipsubscript (t, 0, 0);
743 if (t[len] != ']' || len == 1)
744 return 0;
745 for (r = 1; r < len; r++)
746 if (whitespace (t[r]) == 0)
747 return 1;
748 return 0;
750 return 0;
753 /* Expand the array index beginning at S and extending LEN characters. */
754 arrayind_t
755 array_expand_index (s, len)
756 char *s;
757 int len;
759 char *exp, *t;
760 int expok;
761 arrayind_t val;
763 exp = (char *)xmalloc (len);
764 strncpy (exp, s, len - 1);
765 exp[len - 1] = '\0';
766 t = expand_arith_string (exp, 0);
767 this_command_name = (char *)NULL;
768 val = evalexp (t, &expok);
769 free (t);
770 free (exp);
771 if (expok == 0)
773 last_command_exit_value = EXECUTION_FAILURE;
775 top_level_cleanup ();
776 jump_to_top_level (DISCARD);
778 return val;
781 /* Return the name of the variable specified by S without any subscript.
782 If SUBP is non-null, return a pointer to the start of the subscript
783 in *SUBP. If LENP is non-null, the length of the subscript is returned
784 in *LENP. This returns newly-allocated memory. */
785 char *
786 array_variable_name (s, subp, lenp)
787 char *s, **subp;
788 int *lenp;
790 char *t, *ret;
791 int ind, ni;
793 t = mbschr (s, '[');
794 if (t == 0)
796 if (subp)
797 *subp = t;
798 if (lenp)
799 *lenp = 0;
800 return ((char *)NULL);
802 ind = t - s;
803 ni = skipsubscript (s, ind, 0);
804 if (ni <= ind + 1 || s[ni] != ']')
806 err_badarraysub (s);
807 if (subp)
808 *subp = t;
809 if (lenp)
810 *lenp = 0;
811 return ((char *)NULL);
814 *t = '\0';
815 ret = savestring (s);
816 *t++ = '['; /* ] */
818 if (subp)
819 *subp = t;
820 if (lenp)
821 *lenp = ni - ind;
823 return ret;
826 /* Return the variable specified by S without any subscript. If SUBP is
827 non-null, return a pointer to the start of the subscript in *SUBP.
828 If LENP is non-null, the length of the subscript is returned in *LENP. */
829 SHELL_VAR *
830 array_variable_part (s, subp, lenp)
831 char *s, **subp;
832 int *lenp;
834 char *t;
835 SHELL_VAR *var;
837 t = array_variable_name (s, subp, lenp);
838 if (t == 0)
839 return ((SHELL_VAR *)NULL);
840 var = find_variable (t);
842 free (t);
843 return (var == 0 || invisible_p (var)) ? (SHELL_VAR *)0 : var;
846 #define INDEX_ERROR() \
847 do \
849 if (var) \
850 err_badarraysub (var->name); \
851 else \
853 t[-1] = '\0'; \
854 err_badarraysub (s); \
855 t[-1] = '['; /* ] */\
857 return ((char *)NULL); \
859 while (0)
861 /* Return a string containing the elements in the array and subscript
862 described by S. If the subscript is * or @, obeys quoting rules akin
863 to the expansion of $* and $@ including double quoting. If RTYPE
864 is non-null it gets 1 if the array reference is name[*], 2 if the
865 reference is name[@], and 0 otherwise. */
866 static char *
867 array_value_internal (s, quoted, flags, rtype, indp)
868 char *s;
869 int quoted, flags, *rtype;
870 arrayind_t *indp;
872 int len;
873 arrayind_t ind;
874 char *akey;
875 char *retval, *t, *temp;
876 WORD_LIST *l;
877 SHELL_VAR *var;
879 var = array_variable_part (s, &t, &len);
881 /* Expand the index, even if the variable doesn't exist, in case side
882 effects are needed, like ${w[i++]} where w is unset. */
883 #if 0
884 if (var == 0)
885 return (char *)NULL;
886 #endif
888 if (len == 0)
889 return ((char *)NULL); /* error message already printed */
891 /* [ */
892 if (ALL_ELEMENT_SUB (t[0]) && t[1] == ']')
894 if (rtype)
895 *rtype = (t[0] == '*') ? 1 : 2;
896 if ((flags & AV_ALLOWALL) == 0)
898 err_badarraysub (s);
899 return ((char *)NULL);
901 else if (var == 0 || value_cell (var) == 0) /* XXX - check for invisible_p(var) ? */
902 return ((char *)NULL);
903 else if (array_p (var) == 0 && assoc_p (var) == 0)
904 l = add_string_to_list (value_cell (var), (WORD_LIST *)NULL);
905 else if (assoc_p (var))
907 l = assoc_to_word_list (assoc_cell (var));
908 if (l == (WORD_LIST *)NULL)
909 return ((char *)NULL);
911 else
913 l = array_to_word_list (array_cell (var));
914 if (l == (WORD_LIST *)NULL)
915 return ((char *) NULL);
918 if (t[0] == '*' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
920 temp = string_list_dollar_star (l);
921 retval = quote_string (temp);
922 free (temp);
924 else /* ${name[@]} or unquoted ${name[*]} */
925 retval = string_list_dollar_at (l, quoted);
927 dispose_words (l);
929 else
931 if (rtype)
932 *rtype = 0;
933 if (var == 0 || array_p (var) || assoc_p (var) == 0)
935 if ((flags & AV_USEIND) == 0 || indp == 0)
937 ind = array_expand_index (t, len);
938 if (ind < 0)
940 /* negative subscripts to indexed arrays count back from end */
941 if (var && array_p (var))
942 ind = array_max_index (array_cell (var)) + 1 + ind;
943 if (ind < 0)
944 INDEX_ERROR();
946 if (indp)
947 *indp = ind;
949 else if (indp)
950 ind = *indp;
952 else if (assoc_p (var))
954 t[len - 1] = '\0';
955 akey = expand_assignment_string_to_string (t, 0); /* [ */
956 t[len - 1] = ']';
957 if (akey == 0 || *akey == 0)
958 INDEX_ERROR();
961 if (var == 0 || value_cell (var) == 0) /* XXX - check invisible_p(var) ? */
962 return ((char *)NULL);
963 if (array_p (var) == 0 && assoc_p (var) == 0)
964 return (ind == 0 ? value_cell (var) : (char *)NULL);
965 else if (assoc_p (var))
967 retval = assoc_reference (assoc_cell (var), akey);
968 free (akey);
970 else
971 retval = array_reference (array_cell (var), ind);
974 return retval;
977 /* Return a string containing the elements described by the array and
978 subscript contained in S, obeying quoting for subscripts * and @. */
979 char *
980 array_value (s, quoted, flags, rtype, indp)
981 char *s;
982 int quoted, flags, *rtype;
983 arrayind_t *indp;
985 return (array_value_internal (s, quoted, flags|AV_ALLOWALL, rtype, indp));
988 /* Return the value of the array indexing expression S as a single string.
989 If (FLAGS & AV_ALLOWALL) is 0, do not allow `@' and `*' subscripts. This
990 is used by other parts of the shell such as the arithmetic expression
991 evaluator in expr.c. */
992 char *
993 get_array_value (s, flags, rtype, indp)
994 char *s;
995 int flags, *rtype;
996 arrayind_t *indp;
998 return (array_value_internal (s, 0, flags, rtype, indp));
1001 char *
1002 array_keys (s, quoted)
1003 char *s;
1004 int quoted;
1006 int len;
1007 char *retval, *t, *temp;
1008 WORD_LIST *l;
1009 SHELL_VAR *var;
1011 var = array_variable_part (s, &t, &len);
1013 /* [ */
1014 if (var == 0 || ALL_ELEMENT_SUB (t[0]) == 0 || t[1] != ']')
1015 return (char *)NULL;
1017 if (var_isset (var) == 0 || invisible_p (var))
1018 return (char *)NULL;
1020 if (array_p (var) == 0 && assoc_p (var) == 0)
1021 l = add_string_to_list ("0", (WORD_LIST *)NULL);
1022 else if (assoc_p (var))
1023 l = assoc_keys_to_word_list (assoc_cell (var));
1024 else
1025 l = array_keys_to_word_list (array_cell (var));
1026 if (l == (WORD_LIST *)NULL)
1027 return ((char *) NULL);
1029 if (t[0] == '*' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
1031 temp = string_list_dollar_star (l);
1032 retval = quote_string (temp);
1033 free (temp);
1035 else /* ${!name[@]} or unquoted ${!name[*]} */
1036 retval = string_list_dollar_at (l, quoted);
1038 dispose_words (l);
1039 return retval;
1041 #endif /* ARRAY_VARS */