]>
git.ipfire.org Git - thirdparty/bash.git/blob - array.c
2 * array.c - functions to create, destroy, access, and manipulate arrays
5 * Arrays are sparse doubly-linked lists. An element's index is stored
12 /* Copyright (C) 1997-2020 Free Software Foundation, Inc.
14 This file is part of GNU Bash, the Bourne Again SHell.
16 Bash is free software: you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation, either version 3 of the License, or
19 (at your option) any later version.
21 Bash is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with Bash. If not, see <http://www.gnu.org/licenses/>.
32 #if defined (ARRAY_VARS)
34 #if defined (HAVE_UNISTD_H)
36 # include <sys/types.h>
46 #include "builtins/common.h"
48 #define ADD_BEFORE(ae, new) \
50 ae->prev->next = new; \
51 new->prev = ae->prev; \
56 #define ADD_AFTER(ae, new) \
58 ae->next->prev = new; \
59 new->next = ae->next; \
64 static char *array_to_string_internal
PARAMS((ARRAY_ELEMENT
*, ARRAY_ELEMENT
*, char *, int));
66 static char *spacesep
= " ";
68 #define IS_LASTREF(a) (a->lastref)
70 #define LASTREF_START(a, i) \
71 (IS_LASTREF(a) && i >= element_index(a->lastref)) ? a->lastref \
72 : element_forw(a->head)
74 #define LASTREF(a) (a->lastref ? a->lastref : element_forw(a->head))
76 #define INVALIDATE_LASTREF(a) a->lastref = 0
77 #define SET_LASTREF(a, e) a->lastref = (e)
78 #define UNSET_LASTREF(a) a->lastref = 0;
86 r
= (ARRAY
*)xmalloc(sizeof(ARRAY
));
87 r
->type
= array_indexed
;
90 r
->lastref
= (ARRAY_ELEMENT
*)0;
91 head
= array_create_element(-1, (char *)NULL
); /* dummy head */
92 head
->prev
= head
->next
= head
;
101 register ARRAY_ELEMENT
*r
, *r1
;
105 for (r
= element_forw(a
->head
); r
!= a
->head
; ) {
106 r1
= element_forw(r
);
107 array_dispose_element(r
);
110 a
->head
->next
= a
->head
->prev
= a
->head
;
113 INVALIDATE_LASTREF(a
);
123 array_dispose_element(a
->head
);
132 ARRAY_ELEMENT
*ae
, *new;
135 return((ARRAY
*) NULL
);
138 a1
->max_index
= a
->max_index
;
139 a1
->num_elements
= a
->num_elements
;
140 for (ae
= element_forw(a
->head
); ae
!= a
->head
; ae
= element_forw(ae
)) {
141 new = array_create_element(element_index(ae
), element_value(ae
));
142 ADD_BEFORE(a1
->head
, new);
143 if (ae
== LASTREF(a
))
144 SET_LASTREF(a1
, new);
150 * Make and return a new array composed of the elements in array A from
154 array_slice(array
, s
, e
)
156 ARRAY_ELEMENT
*s
, *e
;
159 ARRAY_ELEMENT
*p
, *n
;
164 a
->type
= array
->type
;
166 for (mi
= 0, p
= s
, i
= 0; p
!= e
; p
= element_forw(p
), i
++) {
167 n
= array_create_element (element_index(p
), element_value(p
));
168 ADD_BEFORE(a
->head
, n
);
169 mi
= element_index(n
);
177 * Walk the array, calling FUNC once for each element, with the array
178 * element as the argument.
181 array_walk(a
, func
, udata
)
183 sh_ae_map_func_t
*func
;
186 register ARRAY_ELEMENT
*ae
;
188 if (a
== 0 || array_empty(a
))
190 for (ae
= element_forw(a
->head
); ae
!= a
->head
; ae
= element_forw(ae
))
191 if ((*func
)(ae
, udata
) < 0)
196 * Shift the array A N elements to the left. Delete the first N elements
197 * and subtract N from the indices of the remaining elements. If FLAGS
198 * does not include AS_DISPOSE, this returns a singly-linked null-terminated
199 * list of elements so the caller can dispose of the chain. If FLAGS
200 * includes AS_DISPOSE, this function disposes of the shifted-out elements
204 array_shift(a
, n
, flags
)
208 register ARRAY_ELEMENT
*ae
, *ret
;
211 if (a
== 0 || array_empty(a
) || n
<= 0)
212 return ((ARRAY_ELEMENT
*)NULL
);
214 INVALIDATE_LASTREF(a
);
215 for (i
= 0, ret
= ae
= element_forw(a
->head
); ae
!= a
->head
&& i
< n
; ae
= element_forw(ae
), i
++)
218 /* Easy case; shifting out all of the elements */
219 if (flags
& AS_DISPOSE
) {
221 return ((ARRAY_ELEMENT
*)NULL
);
223 for (ae
= ret
; element_forw(ae
) != a
->head
; ae
= element_forw(ae
))
225 element_forw(ae
) = (ARRAY_ELEMENT
*)NULL
;
226 a
->head
->next
= a
->head
->prev
= a
->head
;
232 * ae now points to the list of elements we want to retain.
233 * ret points to the list we want to either destroy or return.
235 ae
->prev
->next
= (ARRAY_ELEMENT
*)NULL
; /* null-terminate RET */
237 a
->head
->next
= ae
; /* slice RET out of the array */
240 for ( ; ae
!= a
->head
; ae
= element_forw(ae
))
241 element_index(ae
) -= n
; /* renumber retained indices */
243 a
->num_elements
-= n
; /* modify bookkeeping information */
244 a
->max_index
= element_index(a
->head
->prev
);
246 if (flags
& AS_DISPOSE
) {
247 for (ae
= ret
; ae
; ) {
248 ret
= element_forw(ae
);
249 array_dispose_element(ae
);
252 return ((ARRAY_ELEMENT
*)NULL
);
259 * Shift array A right N indices. If S is non-null, it becomes the value of
260 * the new element 0. Returns the number of elements in the array after the
264 array_rshift (a
, n
, s
)
269 register ARRAY_ELEMENT
*ae
, *new;
271 if (a
== 0 || (array_empty(a
) && s
== 0))
274 return (a
->num_elements
);
276 ae
= element_forw(a
->head
);
278 new = array_create_element(0, s
);
281 if (array_num_elements(a
) == 1) { /* array was empty */
288 * Renumber all elements in the array except the one we just added.
290 for ( ; ae
!= a
->head
; ae
= element_forw(ae
))
291 element_index(ae
) += n
;
293 a
->max_index
= element_index(a
->head
->prev
);
295 INVALIDATE_LASTREF(a
);
296 return (a
->num_elements
);
300 array_unshift_element(a
)
303 return (array_shift (a
, 1, 0));
307 array_shift_element(a
, v
)
311 return (array_rshift (a
, 1, v
));
321 if (array
== 0 || array_head(array
) == 0 || array_empty(array
))
322 return (ARRAY
*)NULL
;
323 for (a
= element_forw(array
->head
); a
!= array
->head
; a
= element_forw(a
)) {
324 t
= quote_string (a
->value
);
332 array_quote_escapes(array
)
338 if (array
== 0 || array_head(array
) == 0 || array_empty(array
))
339 return (ARRAY
*)NULL
;
340 for (a
= element_forw(array
->head
); a
!= array
->head
; a
= element_forw(a
)) {
341 t
= quote_escapes (a
->value
);
355 if (array
== 0 || array_head(array
) == 0 || array_empty(array
))
356 return (ARRAY
*)NULL
;
357 for (a
= element_forw(array
->head
); a
!= array
->head
; a
= element_forw(a
)) {
358 t
= dequote_string (a
->value
);
366 array_dequote_escapes(array
)
372 if (array
== 0 || array_head(array
) == 0 || array_empty(array
))
373 return (ARRAY
*)NULL
;
374 for (a
= element_forw(array
->head
); a
!= array
->head
; a
= element_forw(a
)) {
375 t
= dequote_escapes (a
->value
);
383 array_remove_quoted_nulls(array
)
388 if (array
== 0 || array_head(array
) == 0 || array_empty(array
))
389 return (ARRAY
*)NULL
;
390 for (a
= element_forw(array
->head
); a
!= array
->head
; a
= element_forw(a
))
391 a
->value
= remove_quoted_nulls (a
->value
);
396 * Return a string whose elements are the members of array A beginning at
397 * index START and spanning NELEM members. Null elements are counted.
398 * Since arrays are sparse, unset array elements are not counted.
401 array_subrange (a
, start
, nelem
, starsub
, quoted
, pflags
)
403 arrayind_t start
, nelem
;
404 int starsub
, quoted
, pflags
;
407 ARRAY_ELEMENT
*h
, *p
;
412 p
= a
? array_head (a
) : 0;
413 if (p
== 0 || array_empty (a
) || start
> array_max_index(a
))
414 return ((char *)NULL
);
417 * Find element with index START. If START corresponds to an unset
418 * element (arrays can be sparse), use the first element whose index
419 * is >= START. If START is < 0, we count START indices back from
420 * the end of A (not elements, even with sparse arrays -- START is an
423 for (p
= element_forw(p
); p
!= array_head(a
) && start
> element_index(p
); p
= element_forw(p
))
427 return ((char *)NULL
);
429 /* Starting at P, take NELEM elements, inclusive. */
430 for (i
= 0, h
= p
; p
!= a
->head
&& i
< nelem
; i
++, p
= element_forw(p
))
433 a2
= array_slice(a
, h
, p
);
435 wl
= array_to_word_list(a2
);
439 t
= string_list_pos_params(starsub
? '*' : '@', wl
, quoted
, pflags
); /* XXX */
446 array_patsub (a
, pat
, rep
, mflags
)
452 int pchar
, qflags
, pflags
;
453 WORD_LIST
*wl
, *save
;
455 if (a
== 0 || array_head(a
) == 0 || array_empty(a
))
456 return ((char *)NULL
);
458 wl
= array_to_word_list(a
);
462 for (save
= wl
; wl
; wl
= wl
->next
) {
463 t
= pat_subst (wl
->word
->word
, pat
, rep
, mflags
);
464 FREE (wl
->word
->word
);
468 pchar
= (mflags
& MATCH_STARSUB
) == MATCH_STARSUB
? '*' : '@';
469 qflags
= (mflags
& MATCH_QUOTED
) == MATCH_QUOTED
? Q_DOUBLE_QUOTES
: 0;
470 pflags
= (mflags
& MATCH_ASSIGNRHS
) ? PF_ASSIGNRHS
: 0;
472 t
= string_list_pos_params (pchar
, save
, qflags
, pflags
);
479 array_modcase (a
, pat
, modop
, mflags
)
486 int pchar
, qflags
, pflags
;
487 WORD_LIST
*wl
, *save
;
489 if (a
== 0 || array_head(a
) == 0 || array_empty(a
))
490 return ((char *)NULL
);
492 wl
= array_to_word_list(a
);
494 return ((char *)NULL
);
496 for (save
= wl
; wl
; wl
= wl
->next
) {
497 t
= sh_modcase(wl
->word
->word
, pat
, modop
);
498 FREE(wl
->word
->word
);
502 pchar
= (mflags
& MATCH_STARSUB
) == MATCH_STARSUB
? '*' : '@';
503 qflags
= (mflags
& MATCH_QUOTED
) == MATCH_QUOTED
? Q_DOUBLE_QUOTES
: 0;
504 pflags
= (mflags
& MATCH_ASSIGNRHS
) ? PF_ASSIGNRHS
: 0;
506 t
= string_list_pos_params (pchar
, save
, qflags
, pflags
);
513 * Allocate and return a new array element with index INDEX and value
517 array_create_element(indx
, value
)
523 r
= (ARRAY_ELEMENT
*)xmalloc(sizeof(ARRAY_ELEMENT
));
525 r
->value
= value
? savestring(value
) : (char *)NULL
;
526 r
->next
= r
->prev
= (ARRAY_ELEMENT
*) NULL
;
530 #ifdef INCLUDE_UNUSED
532 array_copy_element(ae
)
535 return(ae
? array_create_element(element_index(ae
), element_value(ae
))
536 : (ARRAY_ELEMENT
*) NULL
);
541 array_dispose_element(ae
)
551 * Add a new element with index I and value V to array A (a[i] = v).
554 array_insert(a
, i
, v
)
559 register ARRAY_ELEMENT
*new, *ae
, *start
;
565 new = array_create_element(i
, v
);
566 if (i
> array_max_index(a
)) {
568 * Hook onto the end. This also works for an empty array.
569 * Fast path for the common case of allocating arrays
572 ADD_BEFORE(a
->head
, new);
577 } else if (i
< array_first_index(a
)) {
578 /* Hook at the beginning */
579 ADD_AFTER(a
->head
, new);
584 #if OPTIMIZE_SEQUENTIAL_ARRAY_ASSIGNMENT
586 * Otherwise we search for the spot to insert it. The lastref
587 * handle optimizes the case of sequential or almost-sequential
588 * assignments that are not at the end of the array.
591 /* Use same strategy as array_reference to avoid paying large penalty
592 for semi-random assignment pattern. */
593 startind
= element_index(start
);
594 if (i
< startind
/2) {
595 start
= element_forw(a
->head
);
596 startind
= element_index(start
);
598 } else if (i
>= startind
) {
604 start
= element_forw(ae
->head
);
605 startind
= element_index(start
);
608 for (ae
= start
; ae
!= a
->head
; ) {
609 if (element_index(ae
) == i
) {
611 * Replacing an existing element.
613 free(element_value(ae
));
614 /* Just swap in the new value */
615 ae
->value
= new->value
;
617 array_dispose_element(new);
620 } else if (direction
== 1 && element_index(ae
) > i
) {
625 } else if (direction
== -1 && element_index(ae
) < i
) {
631 ae
= direction
== 1 ? element_forw(ae
) : element_back(ae
);
633 array_dispose_element(new);
634 INVALIDATE_LASTREF(a
);
635 return (-1); /* problem */
639 * Delete the element with index I from array A and return it so the
640 * caller can dispose of it.
647 register ARRAY_ELEMENT
*ae
, *start
;
651 if (a
== 0 || array_empty(a
))
652 return((ARRAY_ELEMENT
*) NULL
);
653 if (i
> array_max_index(a
) || i
< array_first_index(a
))
654 return((ARRAY_ELEMENT
*)NULL
); /* Keep roving pointer into array to optimize sequential access */
656 /* Use same strategy as array_reference to avoid paying large penalty
657 for semi-random assignment pattern. */
658 startind
= element_index(start
);
659 if (i
< startind
/2) {
660 start
= element_forw(a
->head
);
661 startind
= element_index(start
);
663 } else if (i
>= startind
) {
668 for (ae
= start
; ae
!= a
->head
; ) {
669 if (element_index(ae
) == i
) {
670 ae
->next
->prev
= ae
->prev
;
671 ae
->prev
->next
= ae
->next
;
673 if (i
== array_max_index(a
))
674 a
->max_index
= element_index(ae
->prev
);
676 INVALIDATE_LASTREF(a
);
678 if (ae
->next
!= a
->head
)
679 SET_LASTREF(a
, ae
->next
);
680 else if (ae
->prev
!= a
->head
)
681 SET_LASTREF(a
, ae
->prev
);
683 INVALIDATE_LASTREF(a
);
687 ae
= (direction
== 1) ? element_forw(ae
) : element_back(ae
);
688 if (direction
== 1 && element_index(ae
) > i
)
690 else if (direction
== -1 && element_index(ae
) < i
)
693 return((ARRAY_ELEMENT
*) NULL
);
697 * Return the value of a[i].
700 array_reference(a
, i
)
704 register ARRAY_ELEMENT
*ae
, *start
;
708 if (a
== 0 || array_empty(a
))
709 return((char *) NULL
);
710 if (i
> array_max_index(a
) || i
< array_first_index(a
))
711 return((char *)NULL
); /* Keep roving pointer into array to optimize sequential access */
712 start
= LASTREF(a
); /* lastref pointer */
713 startind
= element_index(start
);
714 if (i
< startind
/2) { /* XXX - guess */
715 start
= element_forw(a
->head
);
716 startind
= element_index(start
);
718 } else if (i
>= startind
) {
723 for (ae
= start
; ae
!= a
->head
; ) {
724 if (element_index(ae
) == i
) {
726 return(element_value(ae
));
728 ae
= (direction
== 1) ? element_forw(ae
) : element_back(ae
);
729 /* Take advantage of index ordering to short-circuit */
730 /* If we don't find it, set the lastref pointer to the element
731 that's `closest', assuming that the unsuccessful reference
732 will quickly be followed by an assignment. No worse than
733 not changing it from the previous value or resetting it. */
734 if (direction
== 1 && element_index(ae
) > i
) {
735 start
= ae
; /* use for SET_LASTREF below */
737 } else if (direction
== -1 && element_index(ae
) < i
) {
738 start
= ae
; /* use for SET_LASTREF below */
745 SET_LASTREF(a
, start
);
747 return((char *) NULL
);
750 /* Convenience routines for the shell to translate to and from the form used
751 by the rest of the code. */
754 array_to_word_list(a
)
760 if (a
== 0 || array_empty(a
))
761 return((WORD_LIST
*)NULL
);
762 list
= (WORD_LIST
*)NULL
;
763 for (ae
= element_forw(a
->head
); ae
!= a
->head
; ae
= element_forw(ae
))
764 list
= make_word_list (make_bare_word(element_value(ae
)), list
);
765 return (REVERSE_LIST(list
, WORD_LIST
*));
769 array_from_word_list (list
)
775 return((ARRAY
*)NULL
);
777 return (array_assign_list (a
, list
));
781 array_keys_to_word_list(a
)
788 if (a
== 0 || array_empty(a
))
789 return((WORD_LIST
*)NULL
);
790 list
= (WORD_LIST
*)NULL
;
791 for (ae
= element_forw(a
->head
); ae
!= a
->head
; ae
= element_forw(ae
)) {
792 t
= itos(element_index(ae
));
793 list
= make_word_list (make_bare_word(t
), list
);
796 return (REVERSE_LIST(list
, WORD_LIST
*));
800 array_assign_list (array
, list
)
804 register WORD_LIST
*l
;
805 register arrayind_t i
;
807 for (l
= list
, i
= 0; l
; l
= l
->next
, i
++)
808 array_insert(array
, i
, l
->word
->word
);
813 array_to_argv (a
, countp
)
821 if (a
== 0 || array_empty(a
)) {
824 return ((char **)NULL
);
826 ret
= strvec_create (array_num_elements (a
) + 1);
828 for (ae
= element_forw(a
->head
); ae
!= a
->head
; ae
= element_forw(ae
)) {
829 t
= element_value (ae
);
831 ret
[i
++] = savestring (t
);
833 ret
[i
] = (char *)NULL
;
840 * Return a string that is the concatenation of the elements in A from START
841 * to END, separated by SEP.
844 array_to_string_internal (start
, end
, sep
, quoted
)
845 ARRAY_ELEMENT
*start
, *end
;
851 int slen
, rsize
, rlen
, reg
;
853 if (start
== end
) /* XXX - should not happen */
854 return ((char *)NULL
);
858 for (rsize
= rlen
= 0, ae
= start
; ae
!= end
; ae
= element_forw(ae
)) {
860 result
= (char *)xmalloc (rsize
= 64);
861 if (element_value(ae
)) {
862 t
= quoted
? quote_string(element_value(ae
)) : element_value(ae
);
864 RESIZE_MALLOCED_BUFFER (result
, rlen
, (reg
+ slen
+ 2),
866 strcpy(result
+ rlen
, t
);
871 * Add a separator only after non-null elements.
873 if (element_forw(ae
) != end
) {
874 strcpy(result
+ rlen
, sep
);
880 result
[rlen
] = '\0'; /* XXX */
885 array_to_kvpair (a
, quoted
)
889 char *result
, *valstr
, *is
;
890 char indstr
[INT_STRLEN_BOUND(intmax_t) + 1];
892 int rsize
, rlen
, elen
;
894 if (a
== 0 || array_empty (a
))
895 return((char *)NULL
);
897 result
= (char *)xmalloc (rsize
= 128);
898 result
[rlen
= 0] = '\0';
900 for (ae
= element_forw(a
->head
); ae
!= a
->head
; ae
= element_forw(ae
)) {
901 is
= inttostr (element_index(ae
), indstr
, sizeof(indstr
));
902 valstr
= element_value (ae
) ?
903 (ansic_shouldquote (element_value (ae
)) ?
904 ansic_quote (element_value(ae
), 0, (int *)0) :
905 sh_double_quote (element_value (ae
)))
907 elen
= STRLEN (is
) + 8 + STRLEN (valstr
);
908 RESIZE_MALLOCED_BUFFER (result
, rlen
, (elen
+ 1), rsize
, rsize
);
910 strcpy (result
+ rlen
, is
);
912 result
[rlen
++] = ' ';
914 strcpy (result
+ rlen
, valstr
);
915 rlen
+= STRLEN (valstr
);
917 strcpy (result
+ rlen
, "\"\"");
921 if (element_forw(ae
) != a
->head
)
922 result
[rlen
++] = ' ';
926 RESIZE_MALLOCED_BUFFER (result
, rlen
, 1, rsize
, 8);
930 /* This is not as efficient as it could be... */
931 valstr
= sh_single_quote (result
);
939 array_to_assign (a
, quoted
)
943 char *result
, *valstr
, *is
;
944 char indstr
[INT_STRLEN_BOUND(intmax_t) + 1];
946 int rsize
, rlen
, elen
;
948 if (a
== 0 || array_empty (a
))
949 return((char *)NULL
);
951 result
= (char *)xmalloc (rsize
= 128);
955 for (ae
= element_forw(a
->head
); ae
!= a
->head
; ae
= element_forw(ae
)) {
956 is
= inttostr (element_index(ae
), indstr
, sizeof(indstr
));
957 valstr
= element_value (ae
) ?
958 (ansic_shouldquote (element_value (ae
)) ?
959 ansic_quote (element_value(ae
), 0, (int *)0) :
960 sh_double_quote (element_value (ae
)))
962 elen
= STRLEN (is
) + 8 + STRLEN (valstr
);
963 RESIZE_MALLOCED_BUFFER (result
, rlen
, (elen
+ 1), rsize
, rsize
);
965 result
[rlen
++] = '[';
966 strcpy (result
+ rlen
, is
);
968 result
[rlen
++] = ']';
969 result
[rlen
++] = '=';
971 strcpy (result
+ rlen
, valstr
);
972 rlen
+= STRLEN (valstr
);
975 if (element_forw(ae
) != a
->head
)
976 result
[rlen
++] = ' ';
980 RESIZE_MALLOCED_BUFFER (result
, rlen
, 1, rsize
, 8);
981 result
[rlen
++] = ')';
984 /* This is not as efficient as it could be... */
985 valstr
= sh_single_quote (result
);
993 array_to_string (a
, sep
, quoted
)
999 return((char *)NULL
);
1001 return(savestring(""));
1002 return (array_to_string_internal (element_forw(a
->head
), a
->head
, sep
, quoted
));
1005 #if defined (INCLUDE_UNUSED) || defined (TEST_ARRAY)
1007 * Return an array consisting of elements in S, separated by SEP
1010 array_from_string(s
, sep
)
1017 return((ARRAY
*)NULL
);
1018 w
= list_string (s
, sep
, 0);
1020 return((ARRAY
*)NULL
);
1021 a
= array_from_word_list (w
);
1026 #if defined (TEST_ARRAY)
1028 * To make a running version, compile -DTEST_ARRAY and link with:
1029 * xmalloc.o syntax.o lib/malloc/libmalloc.a lib/sh/libsh.a
1031 int interrupt_immediately
= 0;
1034 signal_is_trapped(s
)
1041 fatal_error(const char *s
, ...)
1043 fprintf(stderr
, "array_test: fatal memory error\n");
1048 programming_error(const char *s
, ...)
1050 fprintf(stderr
, "array_test: fatal programming error\n");
1060 w
= (WORD_DESC
*)xmalloc(sizeof(WORD_DESC
));
1061 w
->word
= s
? savestring(s
) : savestring ("");
1067 make_word_list(x
, l
)
1073 w
= (WORD_LIST
*)xmalloc(sizeof(WORD_LIST
));
1080 list_string(s
, t
, i
)
1088 return (WORD_LIST
*)NULL
;
1090 wl
= (WORD_LIST
*)NULL
;
1093 wl
= make_word_list (make_bare_word(a
), wl
);
1094 a
= strtok((char *)NULL
, t
);
1096 return (REVERSE_LIST (wl
, WORD_LIST
*));
1103 register GENERIC_LIST
*next
, *prev
;
1105 for (prev
= 0; list
; ) {
1115 pat_subst(s
, t
, u
, i
)
1119 return ((char *)NULL
);
1126 return savestring(s
);
1132 char lbuf
[INT_STRLEN_BOUND (intmax_t) + 1];
1134 printf("array[%s] = %s\n",
1135 inttostr (element_index(ae
), lbuf
, sizeof (lbuf
)),
1143 array_walk(a
, print_element
, (void *)NULL
);
1148 ARRAY
*a
, *new_a
, *copy_of_a
;
1149 ARRAY_ELEMENT
*ae
, *aew
;
1153 array_insert(a
, 1, "one");
1154 array_insert(a
, 7, "seven");
1155 array_insert(a
, 4, "four");
1156 array_insert(a
, 1029, "one thousand twenty-nine");
1157 array_insert(a
, 12, "twelve");
1158 array_insert(a
, 42, "forty-two");
1160 s
= array_to_string (a
, " ", 0);
1161 printf("s = %s\n", s
);
1162 copy_of_a
= array_from_string(s
, " ");
1163 printf("copy_of_a:");
1164 print_array(copy_of_a
);
1165 array_dispose(copy_of_a
);
1168 ae
= array_remove(a
, 4);
1169 array_dispose_element(ae
);
1170 ae
= array_remove(a
, 1029);
1171 array_dispose_element(ae
);
1172 array_insert(a
, 16, "sixteen");
1174 s
= array_to_string (a
, " ", 0);
1175 printf("s = %s\n", s
);
1176 copy_of_a
= array_from_string(s
, " ");
1177 printf("copy_of_a:");
1178 print_array(copy_of_a
);
1179 array_dispose(copy_of_a
);
1182 array_insert(a
, 2, "two");
1183 array_insert(a
, 1029, "new one thousand twenty-nine");
1184 array_insert(a
, 0, "zero");
1185 array_insert(a
, 134, "");
1187 s
= array_to_string (a
, ":", 0);
1188 printf("s = %s\n", s
);
1189 copy_of_a
= array_from_string(s
, ":");
1190 printf("copy_of_a:");
1191 print_array(copy_of_a
);
1192 array_dispose(copy_of_a
);
1195 new_a
= array_copy(a
);
1197 s
= array_to_string (new_a
, ":", 0);
1198 printf("s = %s\n", s
);
1199 copy_of_a
= array_from_string(s
, ":");
1201 printf("copy_of_a:");
1202 print_array(copy_of_a
);
1203 array_shift(copy_of_a
, 2, AS_DISPOSE
);
1204 printf("copy_of_a shifted by two:");
1205 print_array(copy_of_a
);
1206 ae
= array_shift(copy_of_a
, 2, 0);
1207 printf("copy_of_a shifted by two:");
1208 print_array(copy_of_a
);
1210 aew
= element_forw(ae
);
1211 array_dispose_element(ae
);
1214 array_rshift(copy_of_a
, 1, (char *)0);
1215 printf("copy_of_a rshift by 1:");
1216 print_array(copy_of_a
);
1217 array_rshift(copy_of_a
, 2, "new element zero");
1218 printf("copy_of_a rshift again by 2 with new element zero:");
1219 print_array(copy_of_a
);
1220 s
= array_to_assign(copy_of_a
, 0);
1221 printf("copy_of_a=%s\n", s
);
1223 ae
= array_shift(copy_of_a
, array_num_elements(copy_of_a
), 0);
1225 aew
= element_forw(ae
);
1226 array_dispose_element(ae
);
1229 array_dispose(copy_of_a
);
1232 array_dispose(new_a
);
1235 #endif /* TEST_ARRAY */
1236 #endif /* ARRAY_VARS */