src/impl/stringlib.c

   1 /* stringlib.c - Miscellaneous string functions. */
   2
   3 /* Copyright (C) 1996-2009 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bush, the Bourne Again SHell.
   6
   7    Bush 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    Bush 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 Bush.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "config.h"
  22
  23 #include "bushtypes.h"
  24
  25 #if defined (HAVE_UNISTD_H)
  26 #  include <unistd.h>
  27 #endif
  28
  29 #include "bushansi.h"
  30 #include <stdio.h>
  31 #include "chartypes.h"
  32
  33 #include "shell.h"
  34 #include "impl/pathexp.h"
  35
  36 #include <glob/glob.h>
  37
  38 #if defined (EXTENDED_GLOB)
  39 #  include <glob/strmatch.h>
  40 #endif
  41
  42 /* **************************************************************** */
  43 /*                                                                  */
  44 /*              Functions to manage arrays of strings               */
  45 /*                                                                  */
  46 /* **************************************************************** */
  47
  48 /* Find STRING in ALIST, a list of string key/int value pairs.  If FLAGS
  49    is 1, STRING is treated as a pattern and matched using strmatch. */
  50 int
  51 find_string_in_alist (string, alist, flags)
  52      char *string;
  53      STRING_INT_ALIST *alist;
  54      int flags;
  55 {
  56   register int i;
  57   int r;
  58
  59   for (i = r = 0; alist[i].word; i++)
  60     {
  61 #if defined (EXTENDED_GLOB)
  62       if (flags)
  63         r = strmatch (alist[i].word, string, FNM_EXTMATCH) != FNM_NOMATCH;
  64       else
  65 #endif
  66         r = STREQ (string, alist[i].word);
  67
  68       if (r)
  69         return (alist[i].token);
  70     }
  71   return -1;
  72 }
  73
  74 /* Find TOKEN in ALIST, a list of string/int value pairs.  Return the
  75    corresponding string.  Allocates memory for the returned
  76    string.  FLAGS is currently ignored, but reserved. */
  77 char *
  78 find_token_in_alist (token, alist, flags)
  79      int token;
  80      STRING_INT_ALIST *alist;
  81      int flags;
  82 {
  83   register int i;
  84
  85   for (i = 0; alist[i].word; i++)
  86     {
  87       if (alist[i].token == token)
  88         return (savestring (alist[i].word));
  89     }
  90   return ((char *)NULL);
  91 }
  92
  93 int
  94 find_index_in_alist (string, alist, flags)
  95      char *string;
  96      STRING_INT_ALIST *alist;
  97      int flags;
  98 {
  99   register int i;
 100   int r;
 101
 102   for (i = r = 0; alist[i].word; i++)
 103     {
 104 #if defined (EXTENDED_GLOB)
 105       if (flags)
 106         r = strmatch (alist[i].word, string, FNM_EXTMATCH) != FNM_NOMATCH;
 107       else
 108 #endif
 109         r = STREQ (string, alist[i].word);
 110
 111       if (r)
 112         return (i);
 113     }
 114
 115   return -1;
 116 }
 117
 118 /* **************************************************************** */
 119 /*                                                                  */
 120 /*                  String Management Functions                     */
 121 /*                                                                  */
 122 /* **************************************************************** */
 123
 124 /* Cons a new string from STRING starting at START and ending at END,
 125    not including END. */
 126 char *
 127 substring (string, start, end)
 128      const char *string;
 129      int start, end;
 130 {
 131   register int len;
 132   register char *result;
 133
 134   len = end - start;
 135   result = (char *)xmalloc (len + 1);
 136   memcpy (result, string + start, len);
 137   result[len] = '\0';
 138   return (result);
 139 }
 140
 141 /* Replace occurrences of PAT with REP in STRING.  If GLOBAL is non-zero,
 142    replace all occurrences, otherwise replace only the first.
 143    This returns a new string; the caller should free it. */
 144 char *
 145 strsub (string, pat, rep, global)
 146      char *string, *pat, *rep;
 147      int global;
 148 {
 149   int patlen, replen, templen, tempsize, repl, i;
 150   char *temp, *r;
 151
 152   patlen = strlen (pat);
 153   replen = strlen (rep);
 154   for (temp = (char *)NULL, i = templen = tempsize = 0, repl = 1; string[i]; )
 155     {
 156       if (repl && STREQN (string + i, pat, patlen))
 157         {
 158           if (replen)
 159             RESIZE_MALLOCED_BUFFER (temp, templen, replen, tempsize, (replen * 2));
 160
 161           for (r = rep; *r; )   /* can rep == "" */
 162             temp[templen++] = *r++;
 163
 164           i += patlen ? patlen : 1;     /* avoid infinite recursion */
 165           repl = global != 0;
 166         }
 167       else
 168         {
 169           RESIZE_MALLOCED_BUFFER (temp, templen, 1, tempsize, 16);
 170           temp[templen++] = string[i++];
 171         }
 172     }
 173   if (temp)
 174     temp[templen] = 0;
 175   else
 176     temp = savestring (string);
 177   return (temp);
 178 }
 179
 180 /* Replace all instances of C in STRING with TEXT.  TEXT may be empty or
 181    NULL.  If DO_GLOB is non-zero, we quote the replacement text for
 182    globbing.  Backslash may be used to quote C. */
 183 char *
 184 strcreplace (string, c, text, do_glob)
 185      char *string;
 186      int c;
 187      const char *text;
 188      int do_glob;
 189 {
 190   char *ret, *p, *r, *t;
 191   int len, rlen, ind, tlen;
 192
 193   len = STRLEN (text);
 194   rlen = len + strlen (string) + 2;
 195   ret = (char *)xmalloc (rlen);
 196
 197   for (p = string, r = ret; p && *p; )
 198     {
 199       if (*p == c)
 200         {
 201           if (len)
 202             {
 203               ind = r - ret;
 204               if (do_glob && (glob_pattern_p (text) || strchr (text, '\\')))
 205                 {
 206                   t = quote_globbing_chars (text);
 207                   tlen = strlen (t);
 208                   RESIZE_MALLOCED_BUFFER (ret, ind, tlen, rlen, rlen);
 209                   r = ret + ind;        /* in case reallocated */
 210                   strcpy (r, t);
 211                   r += tlen;
 212                   free (t);
 213                 }
 214               else
 215                 {
 216                   RESIZE_MALLOCED_BUFFER (ret, ind, len, rlen, rlen);
 217                   r = ret + ind;        /* in case reallocated */
 218                   strcpy (r, text);
 219                   r += len;
 220                 }
 221             }
 222           p++;
 223           continue;
 224         }
 225
 226       if (*p == '\\' && p[1] == c)
 227         p++;
 228
 229       ind = r - ret;
 230       RESIZE_MALLOCED_BUFFER (ret, ind, 2, rlen, rlen);
 231       r = ret + ind;                    /* in case reallocated */
 232       *r++ = *p++;
 233     }
 234   *r = '\0';
 235
 236   return ret;
 237 }
 238
 239 #ifdef INCLUDE_UNUSED
 240 /* Remove all leading whitespace from STRING.  This includes
 241    newlines.  STRING should be terminated with a zero. */
 242 void
 243 strip_leading (string)
 244      char *string;
 245 {
 246   char *start = string;
 247
 248   while (*string && (whitespace (*string) || *string == '\n'))
 249     string++;
 250
 251   if (string != start)
 252     {
 253       int len = strlen (string);
 254       FASTCOPY (string, start, len);
 255       start[len] = '\0';
 256     }
 257 }
 258 #endif
 259
 260 /* Remove all trailing whitespace from STRING.  This includes
 261    newlines.  If NEWLINES_ONLY is non-zero, only trailing newlines
 262    are removed.  STRING should be terminated with a zero. */
 263 void
 264 strip_trailing (string, len, newlines_only)
 265      char *string;
 266      int len;
 267      int newlines_only;
 268 {
 269   while (len >= 0)
 270     {
 271       if ((newlines_only && string[len] == '\n') ||
 272           (!newlines_only && whitespace (string[len])))
 273         len--;
 274       else
 275         break;
 276     }
 277   string[len + 1] = '\0';
 278 }
 279
 280 /* A wrapper for bcopy that can be prototyped in general.h */
 281 void
 282 xbcopy (s, d, n)
 283      char *s, *d;
 284      int n;
 285 {
 286   FASTCOPY (s, d, n);
 287 }
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324