Imported from ../bash-2.05b.tar.gz.devel-base-dist

1 files changed, 451 insertions, 243 deletions

diff --git a/array.c b/array.c
index c1d862ed..a73be55a 100644
--- a/array.c
+++ b/array.c
@@ -9,7 +9,7 @@
  * chet@ins.cwru.edu
  */
 
-/* Copyright (C) 1997 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2002 Free Software Foundation, Inc.
 
    This file is part of GNU Bash, the Bourne Again SHell.
 
@@ -53,50 +53,26 @@
 		new->next = ae; \
 	} while(0)
 
-/*
- * Allocate and return a new array element with index INDEX and value
- * VALUE.
- */
-ARRAY_ELEMENT *
-new_array_element(indx, value)
-arrayind_t	indx;
-char	*value;
-{
-	ARRAY_ELEMENT *r;
-
-	r = (ARRAY_ELEMENT *)xmalloc(sizeof(ARRAY_ELEMENT));
-	r->ind = indx;
-	r->value = value ? savestring(value) : (char *)NULL;
-	r->next = r->prev = (ARRAY_ELEMENT *) NULL;
-	return(r);
-}
-
-void
-destroy_array_element(ae)
-ARRAY_ELEMENT	*ae;
-{
-	FREE(ae->value);
-	free(ae);
-}
+static char *array_to_string_internal __P((ARRAY_ELEMENT *, ARRAY_ELEMENT *, char *, int));
 
 ARRAY *
-new_array()
+array_create()
 {
 	ARRAY	*r;
 	ARRAY_ELEMENT	*head;
 
 	r =(ARRAY *)xmalloc(sizeof(ARRAY));
 	r->type = array_indexed;
-	r->max_index = r->max_size = -1;
+	r->max_index = -1;
 	r->num_elements = 0;
-	head = new_array_element(-1, (char *)NULL);	/* dummy head */
+	head = array_create_element(-1, (char *)NULL);	/* dummy head */
 	head->prev = head->next = head;
 	r->head = head;
 	return(r);
 }
 
 void
-empty_array (a)
+array_flush (a)
 ARRAY	*a;
 {
 	register ARRAY_ELEMENT *r, *r1;
@@ -105,27 +81,27 @@ ARRAY	*a;
 		return;
 	for (r = element_forw(a->head); r != a->head; ) {
 		r1 = element_forw(r);
-		destroy_array_element(r);
+		array_dispose_element(r);
 		r = r1;
 	}
 	a->head->next = a->head->prev = a->head;
-	a->max_index = a->max_size = -1;
-	a->num_elements = a->max_size = 0;
+	a->max_index = -1;
+	a->num_elements = 0;
 }
 
 void
-dispose_array(a)
+array_dispose(a)
 ARRAY	*a;
 {
 	if (a == 0)
 		return;
-	empty_array (a);
-	destroy_array_element(a->head);
+	array_flush (a);
+	array_dispose_element(a->head);
 	free(a);
 }
 
 ARRAY *
-dup_array(a)
+array_copy(a)
 ARRAY	*a;
 {
 	ARRAY	*a1;
@@ -133,13 +109,12 @@ ARRAY	*a;
 
 	if (!a)
 		return((ARRAY *) NULL);
-	a1 = new_array();
+	a1 = array_create();
 	a1->type = a->type;
 	a1->max_index = a->max_index;
 	a1->num_elements = a->num_elements;
-	a1->max_size = a->max_size;
 	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		new = new_array_element(element_index(ae), element_value(ae));
+		new = array_create_element(element_index(ae), element_value(ae));
 		ADD_BEFORE(a1->head, new);
 	}
 	return(a1);
@@ -151,41 +126,254 @@ ARRAY	*a;
  * S to E, inclusive.
  */
 ARRAY *
-dup_array_subrange(array, s, e)
+array_slice(array, s, e)
 ARRAY		*array;
 ARRAY_ELEMENT	*s, *e;
 {
 	ARRAY	*a;
 	ARRAY_ELEMENT *p, *n;
-	arrayind_t i;
+	int	i;
+	arrayind_t mi;
 
-	a = new_array ();
+	a = array_create ();
 	a->type = array->type;
 
 	for (p = s, i = 0; p != e; p = element_forw(p), i++) {
-		n = new_array_element (i, element_value(p));
+		n = array_create_element (element_index(p), element_value(p));
 		ADD_BEFORE(a->head, n);
+		mi = element_index(ae);
 	}
-	a->num_elements = a->max_index = i;
+	a->num_elements = i;
+	a->max_index = mi;
 	return a;
 }
 #endif
 
+/*
+ * Walk the array, calling FUNC once for each element, with the array
+ * element as the argument.
+ */
+void
+array_walk(a, func)
+ARRAY	*a;
+sh_ae_map_func_t *func;
+{
+	register ARRAY_ELEMENT *ae;
+
+	if (a == 0 || array_empty(a))
+		return;
+	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae))
+		if ((*func)(ae) < 0)
+			return;
+}
+
+/*
+ * Shift the array A N elements to the left.  Delete the first N elements
+ * and subtract N from the indices of the remaining elements.  If FLAGS
+ * does not include AS_DISPOSE, this returns a singly-linked null-terminated
+ * list of elements so the caller can dispose of the chain.  If FLAGS
+ * includes AS_DISPOSE, this function disposes of the shifted-out elements
+ * and returns NULL.
+ */
+ARRAY_ELEMENT *
+array_shift(a, n, flags)
+ARRAY	*a;
+int	n, flags;
+{
+	register ARRAY_ELEMENT *ae, *ret;
+	register int i;
+
+	if (a == 0 || array_empty(a) || n <= 0)
+		return ((ARRAY_ELEMENT *)NULL);
+
+	for (i = 0, ret = ae = element_forw(a->head); ae != a->head && i < n; ae = element_forw(ae), i++)
+		;
+	if (ae == a->head) {
+		/* Easy case; shifting out all of the elements */
+		if (flags & AS_DISPOSE) {
+			array_flush (a);
+			return ((ARRAY_ELEMENT *)NULL);
+		}
+		for (ae = ret; element_forw(ae) != a->head; ae = element_forw(ae))
+			;
+		element_forw(ae) = (ARRAY_ELEMENT *)NULL;
+		a->head->next = a->head->prev = a->head;
+		a->max_index = -1;
+		a->num_elements = 0;
+		return ret;
+	}
+	/*
+	 * ae now points to the list of elements we want to retain.
+	 * ret points to the list we want to either destroy or return.
+	 */
+	ae->prev->next = (ARRAY_ELEMENT *)NULL;		/* null-terminate RET */
+
+	a->head->next = ae;		/* slice RET out of the array */
+	ae->prev = a->head;
+
+	for ( ; ae != a->head; ae = element_forw(ae))
+		element_index(ae) -= n;	/* renumber retained indices */
+
+	a->num_elements -= n;		/* modify bookkeeping information */
+	a->max_index -= n;
+
+	if (flags & AS_DISPOSE) {
+		for (ae = ret; ae; ) {
+			ret = element_forw(ae);
+			array_dispose_element(ae);
+			ae = ret;
+		}
+		return ((ARRAY_ELEMENT *)NULL);
+	}
+
+	return ret;
+}
+
+/*
+ * Shift array A right N indices.  If S is non-null, it becomes the value of
+ * the new element 0.  Returns the number of elements in the array after the
+ * shift.
+ */
+int
+array_rshift (a, n, s)
+ARRAY	*a;
+int	n;
+char	*s;
+{
+	register ARRAY_ELEMENT	*ae, *new;
+
+	if (a == 0)
+		return 0;
+	if (n <= 0)
+		return (a->num_elements);
+
+	ae = element_forw(a->head);
+	if (s) {
+		new = array_create_element(0, s);
+		ADD_BEFORE(ae, new);
+		a->num_elements++;
+	}
+
+	a->max_index += n;
+
+	/*
+	 * Renumber all elements in the array except the one we just added.
+	 */
+	for ( ; ae != a->head; ae = element_forw(ae))
+		element_index(ae) += n;
+
+	return (a->num_elements);
+}
+
+ARRAY	*
+array_quote(array)
+ARRAY	*array;
+{
+	ARRAY_ELEMENT	*a;
+	char	*t;
+
+	if (array == 0 || array->head == 0 || array_empty (array))
+		return (ARRAY *)NULL;
+	for (a = element_forw(array->head); a != array->head; a = element_forw(a)) {
+		t = quote_string (a->value);
+		FREE(a->value);
+		a->value = t;
+	}
+	return array;
+}
+
+char *
+array_subrange (a, start, end, quoted)
+ARRAY	*a;
+arrayind_t	start, end;
+int	quoted;
+{
+	ARRAY_ELEMENT	*h, *p;
+	arrayind_t	i;
+
+	p = array_head (a);
+	if (p == 0 || array_empty (a) || start > array_num_elements (a))
+		return ((char *)NULL);
+
+	for (i = 0, p = element_forw(p); p != a->head && i < start; i++, p = element_forw(p))
+		;
+	if (p == a->head)
+		return ((char *)NULL);
+	for (h = p; p != a->head && i < end; i++, p = element_forw(p))
+		;
+
+	return (array_to_string_internal (h, p, " ", quoted));
+}
+
+char *
+array_patsub (a, pat, rep, mflags)
+ARRAY	*a;
+char	*pat, *rep;
+int	mflags;
+{
+	ARRAY		*a2;
+	ARRAY_ELEMENT	*e;
+	char	*t;
+
+	if (array_head (a) == 0 || array_empty (a))
+		return ((char *)NULL);
+
+	a2 = array_copy (a);
+	for (e = element_forw(a2->head); e != a2->head; e = element_forw(e)) {
+		t = pat_subst(element_value(e), pat, rep, mflags);
+		FREE(element_value(e));
+		e->value = t;
+	}
+
+	if (mflags & MATCH_QUOTED)
+		array_quote (a2);
+	t = array_to_string (a2, " ", 0);
+	array_dispose (a2);
+
+	return t;
+}
+
+/*
+ * Allocate and return a new array element with index INDEX and value
+ * VALUE.
+ */
+ARRAY_ELEMENT *
+array_create_element(indx, value)
+arrayind_t	indx;
+char	*value;
+{
+	ARRAY_ELEMENT *r;
+
+	r = (ARRAY_ELEMENT *)xmalloc(sizeof(ARRAY_ELEMENT));
+	r->ind = indx;
+	r->value = value ? savestring(value) : (char *)NULL;
+	r->next = r->prev = (ARRAY_ELEMENT *) NULL;
+	return(r);
+}
+
 #ifdef INCLUDE_UNUSED
 ARRAY_ELEMENT *
-copy_array_element(ae)
+array_copy_element(ae)
 ARRAY_ELEMENT	*ae;
 {
-	return(ae ? new_array_element(element_index(ae), element_value(ae))
+	return(ae ? array_create_element(element_index(ae), element_value(ae))
 		  : (ARRAY_ELEMENT *) NULL);
 }
 #endif
 
+void
+array_dispose_element(ae)
+ARRAY_ELEMENT	*ae;
+{
+	FREE(ae->value);
+	free(ae);
+}
+
 /*
  * Add a new element with index I and value V to array A (a[i] = v).
  */
 int
-array_add_element(a, i, v)
+array_insert(a, i, v)
 ARRAY	*a;
 arrayind_t	i;
 char	*v;
@@ -194,7 +382,7 @@ char	*v;
 
 	if (!a)
 		return(-1);
-	new = new_array_element(i, v);
+	new = array_create_element(i, v);
 	if (i > array_max_index(a)) {
 		/*
 		 * Hook onto the end.  This also works for an empty array.
@@ -214,7 +402,7 @@ char	*v;
 			/*
 			 * Replacing an existing element.
 			 */
-			destroy_array_element(new);
+			array_dispose_element(new);
 			free(element_value(ae));
 			ae->value = savestring(v);
 			return(0);
@@ -232,7 +420,7 @@ char	*v;
  * caller can dispose of it.
  */
 ARRAY_ELEMENT *
-array_delete_element(a, i)
+array_remove(a, i)
 ARRAY	*a;
 arrayind_t	i;
 {
@@ -270,25 +458,68 @@ arrayind_t	i;
 	return((char *) NULL);
 }
 
-#ifdef TEST_ARRAY
-/*
- * Walk the array, calling FUNC once for each element, with the array
- * element as the argument.
- */
-void
-array_walk(a, func)
+/* Convenience routines for the shell to translate to and from the form used
+   by the rest of the code. */
+WORD_LIST *
+array_to_word_list(a)
 ARRAY	*a;
-sh_ae_map_func_t *func;
 {
-	register ARRAY_ELEMENT *ae;
+	WORD_LIST	*list;
+	ARRAY_ELEMENT	*ae;
 
 	if (a == 0 || array_empty(a))
-		return;
+		return((WORD_LIST *)NULL);
+	list = (WORD_LIST *)NULL;
 	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae))
-		(*func)(ae);
+		list = make_word_list (make_bare_word(element_value(ae)), list);
+	return (REVERSE_LIST(list, WORD_LIST *));
 }
-#endif
 
+ARRAY *
+array_from_word_list (list)
+WORD_LIST	*list;
+{
+	ARRAY	*a;
+
+	if (list == 0)
+		return((ARRAY *)NULL);
+	a = array_create();
+	return (array_assign_list (a, list));
+}
+
+ARRAY *
+array_assign_list (array, list)
+ARRAY	*array;
+WORD_LIST	*list;
+{
+	register WORD_LIST *l;
+	register arrayind_t i;
+
+	for (l = list, i = 0; l; l = l->next, i++)
+		array_insert(array, i, l->word->word);
+	return array;
+}
+
+char **
+array_to_argv (a)
+ARRAY	*a;
+{
+	char		**ret, *t;
+	int		i;
+	ARRAY_ELEMENT	*ae;
+
+	if (a == 0 || array_empty(a))
+		return ((char **)NULL);
+	ret = strvec_create (array_num_elements (a) + 1);
+	i = 0;
+	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
+		t = element_value (ae);
+		ret[i++] = t ? savestring (t) : (char *)NULL;
+	}
+	ret[i] = (char *)NULL;
+	return (ret);
+}
+	
 /*
  * Return a string that is the concatenation of all the elements in A,
  * separated by SEP.
@@ -335,23 +566,12 @@ int	quoted;
 }
 
 char *
-array_to_string (a, sep, quoted)
+array_to_assign (a, quoted)
 ARRAY	*a;
-char	*sep;
 int	quoted;
 {
-	if (a == 0)
-		return((char *)NULL);
-	if (array_empty(a))
-		return(savestring(""));
-	return (array_to_string_internal (element_forw(a->head), a->head, sep, quoted));
-}
-
-char *
-array_to_assignment_string (a)
-ARRAY	*a;
-{
-	char	*result, *indstr, *valstr;
+	char	*result, *valstr, *is;
+	char	indstr[INT_STRLEN_BOUND(intmax_t) + 1];
 	ARRAY_ELEMENT *ae;
 	int	rsize, rlen, elen;
 
@@ -363,15 +583,15 @@ ARRAY	*a;
 	rlen = 1;
 
 	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		indstr = itos (element_index(ae));
+		is = inttostr (element_index(ae), indstr, sizeof(indstr));
 		valstr = element_value (ae) ? sh_double_quote (element_value(ae))
 					    : (char *)NULL;
 		elen = STRLEN (indstr) + 8 + STRLEN (valstr);
 		RESIZE_MALLOCED_BUFFER (result, rlen, (elen + 1), rsize, rsize);
 
 		result[rlen++] = '[';
-		strcpy (result + rlen, indstr);
-		rlen += STRLEN (indstr);
+		strcpy (result + rlen, is);
+		rlen += STRLEN (is);
 		result[rlen++] = ']';
 		result[rlen++] = '=';
 		if (valstr) {
@@ -382,52 +602,39 @@ ARRAY	*a;
 		if (element_forw(ae) != a->head)
 		  result[rlen++] = ' ';
 
-		FREE (indstr);
 		FREE (valstr);
 	}
 	RESIZE_MALLOCED_BUFFER (result, rlen, 1, rsize, 8);
 	result[rlen++] = ')';
 	result[rlen] = '\0';
+	if (quoted) {
+		/* This is not as efficient as it could be... */
+		valstr = sh_single_quote (result);
+		free (result);
+		result = valstr;
+	}
 	return(result);
 }
 
 char *
-quoted_array_assignment_string (a)
+array_to_string (a, sep, quoted)
 ARRAY	*a;
+char	*sep;
+int	quoted;
 {
-	char *vstr, *sv;
-
-	sv = array_to_assignment_string (a);
-	if (sv == 0)
-		return ((char *)NULL);
-
-	vstr = sh_single_quote (sv);
-	free (sv);
-	return (vstr);
-}
-
-#if 0
-/* Determine if s2 occurs in s1.  If so, return a pointer to the
-   match in s1.  The compare is case sensitive. */
-static char *
-sindex (s1, s2)
-register char *s1, *s2;
-{
-	register int i, l, len;
-
-	for (i = 0, l = strlen(s2), len = strlen(s1); (len - i) >= l; i++)
-		if (strncmp (s1 + i, s2, l) == 0)
-			return (s1 + i);
-	return ((char *)NULL);
+	if (a == 0)
+		return((char *)NULL);
+	if (array_empty(a))
+		return(savestring(""));
+	return (array_to_string_internal (element_forw(a->head), a->head, sep, quoted));
 }
-#endif
 
 #if defined (INCLUDE_UNUSED) || defined (TEST_ARRAY)
 /*
  * Return an array consisting of elements in S, separated by SEP
  */
 ARRAY *
-string_to_array(s, sep)
+array_from_string(s, sep)
 char	*s, *sep;
 {
 	ARRAY	*a;
@@ -438,147 +645,122 @@ char	*s, *sep;
 	w = list_string (s, sep, 0);
 	if (w == 0)
 		return((ARRAY *)NULL);
-	a = word_list_to_array (w);
+	a = array_from_word_list (w);
 	return (a);
 }
 #endif
 
-/* Convenience routines for the shell to translate to and from the form used
-   by the rest of the code. */
-WORD_LIST *
-array_to_word_list(a)
-ARRAY	*a;
-{
-	WORD_LIST	*list;
-	ARRAY_ELEMENT	*ae;
+#if defined (TEST_ARRAY)
+/*
+ * To make a running version, compile -DTEST_ARRAY and link with:
+ * 	xmalloc.o syntax.o lib/malloc/libmalloc.a lib/sh/libsh.a
+ */
+int interrupt_immediately = 0;
 
-	if (a == 0 || array_empty(a))
-		return((WORD_LIST *)NULL);
-	list = (WORD_LIST *)NULL;
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae))
-		list = make_word_list (make_bare_word(element_value(ae)), list);
-	return (REVERSE_LIST(list, WORD_LIST *));
+int
+signal_is_trapped(s)
+int	s;
+{
+	return 0;
 }
 
-char **
-array_to_argv (a)
-ARRAY	*a;
+void
+fatal_error(const char *s, ...)
 {
-	char		**ret, *t;
-	int		i;
-	ARRAY_ELEMENT	*ae;
+	fprintf(stderr, "array_test: fatal memory error\n");
+	abort();
+}
 
-	if (a == 0 || array_empty(a))
-		return ((char **)NULL);
-	ret = alloc_array (array_num_elements (a) + 1);
-	i = 0;
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		t = element_value (ae);
-		ret[i++] = t ? savestring (t) : (char *)NULL;
-	}
-	ret[i] = (char *)NULL;
-	return (ret);
+void
+programming_error(const char *s, ...)
+{
+	fprintf(stderr, "array_test: fatal programming error\n");
+	abort();
 }
-	
-ARRAY *
-assign_word_list (array, list)
-ARRAY	*array;
-WORD_LIST	*list;
+
+WORD_DESC *
+make_bare_word (s)
+const char	*s;
 {
-	register WORD_LIST *l;
-	register arrayind_t i;
+	WORD_DESC *w;
 
-	for (l = list, i = 0; l; l = l->next, i++)
-		array_add_element(array, i, l->word->word);
-	return array;
+	w = (WORD_DESC *)xmalloc(sizeof(WORD_DESC));
+	w->word = s ? savestring(s) : savestring ("");
+	w->flags = 0;
+	return w;
 }
 
-ARRAY *
-word_list_to_array (list)
-WORD_LIST	*list;
+WORD_LIST *
+make_word_list(x, l)
+WORD_DESC	*x;
+WORD_LIST	*l;
 {
-	ARRAY	*a;
+	WORD_LIST *w;
 
-	if (list == 0)
-		return((ARRAY *)NULL);
-	a = new_array();
-	return (assign_word_list (a, list));
+	w = (WORD_LIST *)xmalloc(sizeof(WORD_LIST));
+	w->word = x;
+	w->next = l;
+	return w;
 }
 
-ARRAY	*
-array_quote(array)
-ARRAY	*array;
+WORD_LIST *
+list_string(s, t, i)
+char	*s, *t;
+int	i;
 {
-	ARRAY_ELEMENT	*a;
-	char	*t;
+	char	*r, *a;
+	WORD_LIST	*wl;
 
-	if (array == 0 || array->head == 0 || array_empty (array))
-		return (ARRAY *)NULL;
-	for (a = element_forw(array->head); a != array->head; a = element_forw(a)) {
-		t = quote_string (a->value);
-		FREE(a->value);
-		a->value = t;
+	if (s == 0)
+		return (WORD_LIST *)NULL;
+	r = savestring(s);
+	wl = (WORD_LIST *)NULL;
+	a = strtok(r, t);
+	while (a) {
+		wl = make_word_list (make_bare_word(a), wl);
+		a = strtok((char *)NULL, t);
 	}
-	return array;
+	return (REVERSE_LIST (wl, WORD_LIST *));
 }
 
-char *
-array_subrange (a, start, end, quoted)
-ARRAY	*a;
-arrayind_t	start, end;
-int	quoted;
+GENERIC_LIST *
+list_reverse (list)
+GENERIC_LIST	*list;
 {
-	ARRAY_ELEMENT	*h, *p;
-	arrayind_t	i;
+	register GENERIC_LIST *next, *prev;
 
-	p = array_head (a);
-	if (p == 0 || array_empty (a) || start > array_num_elements (a))
-		return ((char *)NULL);
-
-	for (i = 0, p = element_forw(p); p != a->head && i < start; i++, p = element_forw(p))
-		;
-	if (p == a->head)
-		return ((char *)NULL);
-	for (h = p; p != a->head && i < end; i++, p = element_forw(p))
-		;
-
-	return (array_to_string_internal (h, p, " ", quoted));
+	for (prev = 0; list; ) {
+		next = list->next;
+		list->next = prev;
+		prev = list;
+		list = next;
+	}
+	return prev;
 }
 
 char *
-array_pat_subst (a, pat, rep, mflags)
-ARRAY	*a;
-char	*pat, *rep;
-int	mflags;
+pat_subst(s, t, u, i)
+char	*s, *t, *u;
+int	i;
 {
-	ARRAY		*a2;
-	ARRAY_ELEMENT	*e;
-	char	*t;
-
-	if (array_head (a) == 0 || array_empty (a))
-		return ((char *)NULL);
-
-	a2 = dup_array (a);
-	for (e = element_forw(a2->head); e != a2->head; e = element_forw(e)) {
-		t = pat_subst(element_value(e), pat, rep, mflags);
-		FREE(element_value(e));
-		e->value = t;
-	}
-
-	if (mflags & MATCH_QUOTED)
-		array_quote (a2);
-	t = array_to_string (a2, " ", 0);
-	dispose_array (a2);
-
-	return t;
+	return ((char *)NULL);
 }
 
+char *
+quote_string(s)
+char	*s;
+{
+	return savestring(s);
+}
 
-#if defined (TEST_ARRAY)
 print_element(ae)
 ARRAY_ELEMENT	*ae;
 {
-	printf("array[%ld] = %s\n", element_index(ae), element_value(ae));
+	char	lbuf[INT_STRLEN_BOUND (intmax_t) + 1];
+
+	printf("array[%s] = %s\n",
+		inttostr (element_index(ae), lbuf, sizeof (lbuf)),
+		element_value(ae));
 }
 
 print_array(a)
@@ -591,64 +773,90 @@ ARRAY	*a;
 main()
 {
 	ARRAY	*a, *new_a, *copy_of_a;
-	ARRAY_ELEMENT	*ae;
+	ARRAY_ELEMENT	*ae, *aew;
 	char	*s;
 
-	a = new_array();
-	array_add_element(a, 1, "one");
-	array_add_element(a, 7, "seven");
-	array_add_element(a, 4, "four");
-	array_add_element(a, 1029, "one thousand twenty-nine");
-	array_add_element(a, 12, "twelve");
-	array_add_element(a, 42, "forty-two");
+	a = array_create();
+	array_insert(a, 1, "one");
+	array_insert(a, 7, "seven");
+	array_insert(a, 4, "four");
+	array_insert(a, 1029, "one thousand twenty-nine");
+	array_insert(a, 12, "twelve");
+	array_insert(a, 42, "forty-two");
 	print_array(a);
 	s = array_to_string (a, " ", 0);
 	printf("s = %s\n", s);
-	copy_of_a = string_to_array(s, " ");
+	copy_of_a = array_from_string(s, " ");
 	printf("copy_of_a:");
 	print_array(copy_of_a);
-	dispose_array(copy_of_a);
+	array_dispose(copy_of_a);
 	printf("\n");
 	free(s);
-	ae = array_delete_element(a, 4);
-	destroy_array_element(ae);
-	ae = array_delete_element(a, 1029);
-	destroy_array_element(ae);
-	array_add_element(a, 16, "sixteen");
+	ae = array_remove(a, 4);
+	array_dispose_element(ae);
+	ae = array_remove(a, 1029);
+	array_dispose_element(ae);
+	array_insert(a, 16, "sixteen");
 	print_array(a);
 	s = array_to_string (a, " ", 0);
 	printf("s = %s\n", s);
-	copy_of_a = string_to_array(s, " ");
+	copy_of_a = array_from_string(s, " ");
 	printf("copy_of_a:");
 	print_array(copy_of_a);
-	dispose_array(copy_of_a);
+	array_dispose(copy_of_a);
 	printf("\n");
 	free(s);
-	array_add_element(a, 2, "two");
-	array_add_element(a, 1029, "new one thousand twenty-nine");
-	array_add_element(a, 0, "zero");
-	array_add_element(a, 134, "");
+	array_insert(a, 2, "two");
+	array_insert(a, 1029, "new one thousand twenty-nine");
+	array_insert(a, 0, "zero");
+	array_insert(a, 134, "");
 	print_array(a);
 	s = array_to_string (a, ":", 0);
 	printf("s = %s\n", s);
-	copy_of_a = string_to_array(s, ":");
+	copy_of_a = array_from_string(s, ":");
 	printf("copy_of_a:");
 	print_array(copy_of_a);
-	dispose_array(copy_of_a);
+	array_dispose(copy_of_a);
 	printf("\n");
 	free(s);
-	new_a = copy_array(a);
+	new_a = array_copy(a);
 	print_array(new_a);
 	s = array_to_string (new_a, ":", 0);
 	printf("s = %s\n", s);
-	copy_of_a = string_to_array(s, ":", 0);
+	copy_of_a = array_from_string(s, ":");
+	free(s);
 	printf("copy_of_a:");
 	print_array(copy_of_a);
-	dispose_array(copy_of_a);
-	printf("\n");
+	array_shift(copy_of_a, 2, AS_DISPOSE);
+	printf("copy_of_a shifted by two:");
+	print_array(copy_of_a);
+	ae = array_shift(copy_of_a, 2, 0);
+	printf("copy_of_a shifted by two:");
+	print_array(copy_of_a);
+	for ( ; ae; ) {
+		aew = element_forw(ae);
+		array_dispose_element(ae);
+		ae = aew;
+	}
+	array_rshift(copy_of_a, 1, (char *)0);
+	printf("copy_of_a rshift by 1:");
+	print_array(copy_of_a);
+	array_rshift(copy_of_a, 2, "new element zero");
+	printf("copy_of_a rshift again by 2 with new element zero:");
+	print_array(copy_of_a);
+	s = array_to_assign(copy_of_a, 0);
+	printf("copy_of_a=%s\n", s);
 	free(s);
-	dispose_array(a);
-	dispose_array(new_a);
+	ae = array_shift(copy_of_a, array_num_elements(copy_of_a), 0);
+	for ( ; ae; ) {
+		aew = element_forw(ae);
+		array_dispose_element(ae);
+		ae = aew;
+	}
+	array_dispose(copy_of_a);
+	printf("\n");
+	array_dispose(a);
+	array_dispose(new_a);
 }
 
 #endif /* TEST_ARRAY */