lib/sh/stringvec.c

   1 /* stringvec.c - functions for managing arrays of strings. */
   2
   3 /* Copyright (C) 2000-2002 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bash, the Bourne Again SHell.
   6
   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.
  11
  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.
  16
  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/>.
  19 */
  20
  21 #include <config.h>
  22
  23 #include <bashtypes.h>
  24
  25 #if defined (HAVE_UNISTD_H)
  26 #  include <unistd.h>
  27 #endif
  28
  29 #include <bashansi.h>
  30 #include <stdio.h>
  31 #include <chartypes.h>
  32
  33 #include "shell.h"
  34
  35 /* Allocate an array of strings with room for N members. */
  36 char **
  37 strvec_create (n)
  38      int n;
  39 {
  40   return ((char **)xmalloc ((n) * sizeof (char *)));
  41 }
  42
  43 /* Allocate an array of strings with room for N members. */
  44 char **
  45 strvec_mcreate (n)
  46      int n;
  47 {
  48   return ((char **)malloc ((n) * sizeof (char *)));
  49 }
  50
  51 char **
  52 strvec_resize (array, nsize)
  53      char **array;
  54      int nsize;
  55 {
  56   return ((char **)xrealloc (array, nsize * sizeof (char *)));
  57 }
  58
  59 char **
  60 strvec_mresize (array, nsize)
  61      char **array;
  62      int nsize;
  63 {
  64   return ((char **)realloc (array, nsize * sizeof (char *)));
  65 }
  66
  67 /* Return the length of ARRAY, a NULL terminated array of char *. */
  68 int
  69 strvec_len (array)
  70      char **array;
  71 {
  72   register int i;
  73
  74   for (i = 0; array[i]; i++);
  75   return (i);
  76 }
  77
  78 /* Free the contents of ARRAY, a NULL terminated array of char *. */
  79 void
  80 strvec_flush (array)
  81      char **array;
  82 {
  83   register int i;
  84
  85   if (array == 0)
  86     return;
  87
  88   for (i = 0; array[i]; i++)
  89     free (array[i]);
  90 }
  91
  92 void
  93 strvec_dispose (array)
  94      char **array;
  95 {
  96   if (array == 0)
  97     return;
  98
  99   strvec_flush (array);
 100   free (array);
 101 }
 102
 103 int
 104 strvec_remove (array, name)
 105      char **array, *name;
 106 {
 107   register int i, j;
 108   char *x;
 109
 110   if (array == 0)
 111     return 0;
 112
 113   for (i = 0; array[i]; i++)
 114     if (STREQ (name, array[i]))
 115       {
 116         x = array[i];
 117         for (j = i; array[j]; j++)
 118           array[j] = array[j + 1];
 119         free (x);
 120         return 1;
 121       }
 122   return 0;
 123 }
 124
 125 #ifdef INCLUDE_UNUSED
 126 /* Find NAME in ARRAY.  Return the index of NAME, or -1 if not present.
 127    ARRAY should be NULL terminated. */
 128 int
 129 strvec_search (array, name)
 130      char **array, *name;
 131 {
 132   int i;
 133
 134   for (i = 0; array[i]; i++)
 135     if (STREQ (name, array[i]))
 136       return (i);
 137
 138   return (-1);
 139 }
 140 #endif
 141
 142 /* Allocate and return a new copy of ARRAY and its contents. */
 143 char **
 144 strvec_copy (array)
 145      char **array;
 146 {
 147   register int i;
 148   int len;
 149   char **ret;
 150
 151   len = strvec_len (array);
 152
 153   ret = (char **)xmalloc ((len + 1) * sizeof (char *));
 154   for (i = 0; array[i]; i++)
 155     ret[i] = savestring (array[i]);
 156   ret[i] = (char *)NULL;
 157
 158   return (ret);
 159 }
 160
 161 /* Comparison routine for use with qsort() on arrays of strings.  Uses
 162    strcoll(3) if available, otherwise it uses strcmp(3). */
 163 int
 164 strvec_strcmp (s1, s2)
 165      register char **s1, **s2;
 166 {
 167 #if defined (HAVE_STRCOLL)
 168    return (strcoll (*s1, *s2));
 169 #else /* !HAVE_STRCOLL */
 170   int result;
 171
 172   if ((result = **s1 - **s2) == 0)
 173     result = strcmp (*s1, *s2);
 174
 175   return (result);
 176 #endif /* !HAVE_STRCOLL */
 177 }
 178
 179 /* Sort ARRAY, a null terminated array of pointers to strings. */
 180 void
 181 strvec_sort (array)
 182      char **array;
 183 {
 184   qsort (array, strvec_len (array), sizeof (char *), (QSFUNC *)strvec_strcmp);
 185 }
 186
 187 /* Cons up a new array of words.  The words are taken from LIST,
 188    which is a WORD_LIST *.  If ALLOC is true, everything is malloc'ed,
 189    so you should free everything in this array when you are done.
 190    The array is NULL terminated.  If IP is non-null, it gets the
 191    number of words in the returned array.  STARTING_INDEX says where
 192    to start filling in the returned array; it can be used to reserve
 193    space at the beginning of the array. */
 194
 195 char **
 196 strvec_from_word_list (list, alloc, starting_index, ip)
 197      WORD_LIST *list;
 198      int alloc, starting_index, *ip;
 199 {
 200   int count;
 201   char **array;
 202
 203   count = list_length (list);
 204   array = (char **)xmalloc ((1 + count + starting_index) * sizeof (char *));
 205
 206   for (count = 0; count < starting_index; count++)
 207     array[count] = (char *)NULL;
 208   for (count = starting_index; list; count++, list = list->next)
 209     array[count] = alloc ? savestring (list->word->word) : list->word->word;
 210   array[count] = (char *)NULL;
 211
 212   if (ip)
 213     *ip = count;
 214   return (array);
 215 }
 216
 217 /* Convert an array of strings into the form used internally by the shell.
 218    ALLOC means to allocate new storage for each WORD_DESC in the returned
 219    list rather than copy the values in ARRAY.  STARTING_INDEX says where
 220    in ARRAY to begin. */
 221
 222 WORD_LIST *
 223 strvec_to_word_list (array, alloc, starting_index)
 224      char **array;
 225      int alloc, starting_index;
 226 {
 227   WORD_LIST *list;
 228   WORD_DESC *w;
 229   int i, count;
 230
 231   if (array == 0 || array[0] == 0)
 232     return (WORD_LIST *)NULL;
 233
 234   for (count = 0; array[count]; count++)
 235     ;
 236
 237   for (i = starting_index, list = (WORD_LIST *)NULL; i < count; i++)
 238     {
 239       w = make_bare_word (alloc ? array[i] : "");
 240       if (alloc == 0)
 241         {
 242           free (w->word);
 243           w->word = array[i];
 244         }
 245       list = make_word_list (w, list);
 246     }
 247   return (REVERSE_LIST (list, WORD_LIST *));
 248 }