Imported from ../bash-2.05b.tar.gz.

stringlib.c

@@ -1,7 +1,6 @@
 /* stringlib.c - Miscellaneous string functions. */
 
-/* Copyright (C) 1996
-   Free Software Foundation, Inc.
+/* Copyright (C) 1996-2002 Free Software Foundation, Inc.
 
    This file is part of GNU Bash, the Bourne Again SHell.
 
@@ -46,66 +45,6 @@
 /*								    */
 /* **************************************************************** */
 
-/* Cons up a new array of words.  The words are taken from LIST,
-   which is a WORD_LIST *.  If COPY is true, everything is malloc'ed,
-   so you should free everything in this array when you are done.
-   The array is NULL terminated.  If IP is non-null, it gets the
-   number of words in the returned array.  STARTING_INDEX says where
-   to start filling in the returned array; it can be used to reserve
-   space at the beginning of the array. */
-char **
-word_list_to_argv (list, copy, starting_index, ip)
-     WORD_LIST *list;
-     int copy, starting_index, *ip;
-{
-  int count;
-  char **array;
-
-  count = list_length (list);
-  array = (char **)xmalloc ((1 + count + starting_index) * sizeof (char *));
-
-  for (count = 0; count < starting_index; count++)
-    array[count] = (char *)NULL;
-  for (count = starting_index; list; count++, list = list->next)
-    array[count] = copy ? savestring (list->word->word) : list->word->word;
-  array[count] = (char *)NULL;
-
-  if (ip)
-    *ip = count;
-  return (array);
-}
-
-/* Convert an array of strings into the form used internally by the shell.
-   COPY means to copy the values in ARRAY into the returned list rather
-   than allocate new storage.  STARTING_INDEX says where in ARRAY to begin. */
-WORD_LIST *
-argv_to_word_list (array, copy, starting_index)
-     char **array;
-     int copy, starting_index;
-{
-  WORD_LIST *list;
-  WORD_DESC *w;
-  int i, count;
-
-  if (array == 0 || array[0] == 0)
-    return (WORD_LIST *)NULL;
-
-  for (count = 0; array[count]; count++)
-    ;
-
-  for (i = starting_index, list = (WORD_LIST *)NULL; i < count; i++)
-    {
-      w = make_bare_word (copy ? "" : array[i]);
-      if (copy)
-	{
-	  free (w->word);
-	  w->word = array[i];
-	}
-      list = make_word_list (w, list);
-    }
-  return (REVERSE_LIST(list, WORD_LIST *));
-}
-
 /* Find STRING in ALIST, a list of string key/int value pairs.  If FLAGS
    is 1, STRING is treated as a pattern and matched using strmatch. */
 int
@@ -132,12 +71,73 @@ find_string_in_alist (string, alist, flags)
   return -1;
 }
 
+/* Find TOKEN in ALIST, a list of string/int value pairs.  Return the
+   corresponding string.  Allocates memory for the returned
+   string.  FLAGS is currently ignored, but reserved. */
+char *
+find_token_in_alist (token, alist, flags)
+     int token;
+     STRING_INT_ALIST *alist;
+     int flags;
+{
+  register int i;
+
+  for (i = 0; alist[i].word; i++)
+    {
+      if (alist[i].token == token)
+        return (savestring (alist[i].word));
+    }
+  return ((char *)NULL);
+}
+
+int
+find_index_in_alist (string, alist, flags)
+     char *string;
+     STRING_INT_ALIST *alist;
+     int flags;
+{
+  register int i;
+  int r;
+
+  for (i = r = 0; alist[i].word; i++)
+    {
+#if defined (EXTENDED_GLOB)
+      if (flags)
+	r = strmatch (alist[i].word, string, FNM_EXTMATCH) != FNM_NOMATCH;
+      else
+#endif
+	r = STREQ (string, alist[i].word);
+
+      if (r)
+	return (i);
+    }
+
+  return -1;
+}
+
 /* **************************************************************** */
 /*								    */
 /*		    String Management Functions			    */
 /*								    */
 /* **************************************************************** */
 
+/* Cons a new string from STRING starting at START and ending at END,
+   not including END. */
+char *
+substring (string, start, end)
+     char *string;
+     int start, end;
+{
+  register int len;
+  register char *result;
+
+  len = end - start;
+  result = (char *)xmalloc (len + 1);
+  strncpy (result, string + start, len);
+  result[len] = '\0';
+  return (result);
+}
+
 /* Replace occurrences of PAT with REP in STRING.  If GLOBAL is non-zero,
    replace all occurrences, otherwise replace only the first.
    This returns a new string; the caller should free it. */