braces.c

   1 /* braces.c -- code for doing word expansion in curly braces. */
   2
   3 /* Copyright (C) 1987,1991 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 it
   8    under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 1, or (at your option)
  10    any later version.
  11
  12    Bash is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with Bash; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20
  21 /* Stuff in curly braces gets expanded before all other shell expansions. */
  22
  23 #include "config.h"
  24
  25 #if defined (BRACE_EXPANSION)
  26
  27 #if defined (HAVE_UNISTD_H)
  28 #  ifdef _MINIX
  29 #    include <sys/types.h>
  30 #  endif
  31 #  include <unistd.h>
  32 #endif
  33
  34 #include "bashansi.h"
  35
  36 #if defined (SHELL)
  37 #  include "shell.h"
  38 #endif /* SHELL */
  39
  40 #include "general.h"
  41 #define brace_whitespace(c) (!(c) || (c) == ' ' || (c) == '\t' || (c) == '\n')
  42
  43 #if defined (SHELL)
  44 extern char *extract_command_subst ();
  45 #endif
  46
  47 /* Basic idea:
  48
  49    Segregate the text into 3 sections: preamble (stuff before an open brace),
  50    postamble (stuff after the matching close brace) and amble (stuff after
  51    preamble, and before postamble).  Expand amble, and then tack on the
  52    expansions to preamble.  Expand postamble, and tack on the expansions to
  53    the result so far.
  54  */
  55
  56 /* The character which is used to separate arguments. */
  57 int brace_arg_separator = ',';
  58
  59 static int brace_gobbler ();
  60 static char **expand_amble (), **array_concat ();
  61
  62 /* Return an array of strings; the brace expansion of TEXT. */
  63 char **
  64 brace_expand (text)
  65      char *text;
  66 {
  67   register int start;
  68   char *preamble, *postamble, *amble;
  69   char **tack, **result;
  70   int i, j, c;
  71
  72   /* Find the text of the preamble. */
  73   i = 0;
  74   c = brace_gobbler (text, &i, '{');
  75
  76   preamble = (char *)xmalloc (i + 1);
  77   strncpy (preamble, text, i);
  78   preamble[i] = '\0';
  79
  80   result = (char **)xmalloc (2 * sizeof (char *));
  81   result[0] = preamble;
  82   result[1] = (char *)NULL;
  83
  84   /* Special case.  If we never found an exciting character, then
  85      the preamble is all of the text, so just return that. */
  86   if (c != '{')
  87     return (result);
  88
  89   /* Find the amble.  This is the stuff inside this set of braces. */
  90   start = ++i;
  91   c = brace_gobbler (text, &i, '}');
  92
  93   /* What if there isn't a matching close brace? */
  94   if (c == 0)
  95     {
  96 #if defined (NOTDEF)
  97       /* Well, if we found an unquoted BRACE_ARG_SEPARATOR between START
  98          and I, then this should be an error.  Otherwise, it isn't. */
  99       for (j = start; j < i; j++)
 100         {
 101           if (text[j] == '\\')
 102             {
 103               j++;
 104               continue;
 105             }
 106
 107           if (text[j] == brace_arg_separator)
 108             {
 109               free_array (result);
 110               report_error ("missing `}'");
 111               throw_to_top_level ();
 112             }
 113         }
 114 #endif
 115       free (preamble);          /* Same as result[0]; see initialization. */
 116       result[0] = savestring (text);
 117       return (result);
 118     }
 119
 120   amble = (char *)xmalloc (1 + (i - start));
 121   strncpy (amble, &text[start], (i - start));
 122   amble[i - start] = '\0';
 123
 124 #if defined (SHELL)
 125   /* If the amble does not contain an unquoted BRACE_ARG_SEPARATOR, then
 126      just return without doing any expansion.  */
 127   for (j = 0; amble[j]; j++)
 128     {
 129       if (amble[j] == '\\')
 130         {
 131           j++;
 132           continue;
 133         }
 134       if (amble[j] == brace_arg_separator)
 135         break;
 136     }
 137
 138   if (!amble[j])
 139     {
 140       free (amble);
 141       free (preamble);
 142       result[0] = savestring (text);
 143       return (result);
 144     }
 145 #endif /* SHELL */
 146
 147   postamble = &text[i + 1];
 148
 149   tack = expand_amble (amble);
 150   result = array_concat (result, tack);
 151   free (amble);
 152   free_array (tack);
 153
 154   tack = brace_expand (postamble);
 155   result = array_concat (result, tack);
 156   free_array (tack);
 157
 158   return (result);
 159 }
 160
 161 /* Expand the text found inside of braces.  We simply try to split the
 162    text at BRACE_ARG_SEPARATORs into separate strings.  We then brace
 163    expand each slot which needs it, until there are no more slots which
 164    need it. */
 165 static char **
 166 expand_amble (text)
 167      char *text;
 168 {
 169   char **result, **partial;
 170   char *tem;
 171   int start, i, c;
 172
 173   result = (char **)NULL;
 174
 175   for (start = 0, i = 0, c = 1; c; start = ++i)
 176     {
 177       c = brace_gobbler (text, &i, brace_arg_separator);
 178       tem = (char *)xmalloc (1 + (i - start));
 179       strncpy (tem, &text[start], (i - start));
 180       tem[i- start] = '\0';
 181
 182       partial = brace_expand (tem);
 183
 184       if (!result)
 185         result = partial;
 186       else
 187         {
 188           register int lr = array_len (result);
 189           register int lp = array_len (partial);
 190           register int j;
 191
 192           result = (char **)xrealloc (result, (1 + lp + lr) * sizeof (char *));
 193
 194           for (j = 0; j < lp; j++)
 195             result[lr + j] = partial[j];
 196
 197           result[lr + j] = (char *)NULL;
 198           free (partial);
 199         }
 200       free (tem);
 201     }
 202   return (result);
 203 }
 204
 205 /* Start at INDEX, and skip characters in TEXT. Set INDEX to the
 206    index of the character matching SATISFY.  This understands about
 207    quoting.  Return the character that caused us to stop searching;
 208    this is either the same as SATISFY, or 0. */
 209 static int
 210 brace_gobbler (text, indx, satisfy)
 211      char *text;
 212      int *indx;
 213      int satisfy;
 214 {
 215   register int i, c, quoted, level, pass_next;
 216 #if defined (SHELL)
 217   int si;
 218   char *t;
 219 #endif
 220
 221   level = quoted = pass_next = 0;
 222
 223   for (i = *indx; c = text[i]; i++)
 224     {
 225       if (pass_next)
 226         {
 227           pass_next = 0;
 228           continue;
 229         }
 230
 231       /* A backslash escapes the next character.  This allows backslash to
 232          escape the quote character in a double-quoted string. */
 233       if (c == '\\' && (quoted == 0 || quoted == '"' || quoted == '`'))
 234         {
 235           pass_next = 1;
 236           continue;
 237         }
 238
 239       if (quoted)
 240         {
 241           if (c == quoted)
 242             quoted = 0;
 243           continue;
 244         }
 245
 246       if (c == '"' || c == '\'' || c == '`')
 247         {
 248           quoted = c;
 249           continue;
 250         }
 251
 252 #if defined (SHELL)
 253       /* Pass new-style command substitutions through unchanged. */
 254       if (c == '$' && text[i+1] == '(')                 /* ) */
 255         {
 256           si = i + 2;
 257           t = extract_command_subst (text, &si);
 258           i = si;
 259           free (t);
 260           continue;
 261         }
 262 #endif
 263
 264       if (c == satisfy && level == 0 && quoted == 0)
 265         {
 266           /* We ignore an open brace surrounded by whitespace, and also
 267              an open brace followed immediately by a close brace preceded
 268              by whitespace.  */
 269           if (c == '{' &&
 270               ((!i || brace_whitespace (text[i - 1])) &&
 271                (brace_whitespace (text[i + 1]) || text[i + 1] == '}')))
 272             continue;
 273 #if defined (SHELL)
 274           /* If this is being compiled as part of bash, ignore the `{'
 275              in a `${}' construct */
 276           if ((c != '{') || i == 0 || (text[i - 1] != '$'))
 277 #endif /* SHELL */
 278             break;
 279         }
 280
 281       if (c == '{')
 282         level++;
 283       else if (c == '}' && level)
 284         level--;
 285     }
 286
 287   *indx = i;
 288   return (c);
 289 }
 290
 291 /* Return a new array of strings which is the result of appending each
 292    string in ARR2 to each string in ARR1.  The resultant array is
 293    len (arr1) * len (arr2) long.  For convenience, ARR1 (and its contents)
 294    are free ()'ed.  ARR1 can be NULL, in that case, a new version of ARR2
 295    is returned. */
 296 static char **
 297 array_concat (arr1, arr2)
 298      char **arr1, **arr2;
 299 {
 300   register int i, j, len, len1, len2;
 301   register char **result;
 302
 303   if (arr1 == 0)
 304     return (copy_array (arr2));
 305
 306   if (arr2 == 0)
 307     return (copy_array (arr1));
 308
 309   len1 = array_len (arr1);
 310   len2 = array_len (arr2);
 311
 312   result = (char **)xmalloc ((1 + (len1 * len2)) * sizeof (char *));
 313
 314   len = 0;
 315   for (i = 0; i < len1; i++)
 316     {
 317       int strlen_1 = strlen (arr1[i]);
 318
 319       for (j = 0; j < len2; j++)
 320         {
 321           result[len] =
 322             (char *)xmalloc (1 + strlen_1 + strlen (arr2[j]));
 323           strcpy (result[len], arr1[i]);
 324           strcpy (result[len] + strlen_1, arr2[j]);
 325           len++;
 326         }
 327       free (arr1[i]);
 328     }
 329   free (arr1);
 330
 331   result[len] = (char *)NULL;
 332   return (result);
 333 }
 334
 335 #if defined (TEST)
 336 #include <stdio.h>
 337
 338 fatal_error (format, arg1, arg2)
 339      char *format, *arg1, *arg2;
 340 {
 341   report_error (format, arg1, arg2);
 342   exit (1);
 343 }
 344
 345 report_error (format, arg1, arg2)
 346      char *format, *arg1, *arg2;
 347 {
 348   fprintf (stderr, format, arg1, arg2);
 349   fprintf (stderr, "\n");
 350 }
 351
 352 main ()
 353 {
 354   char example[256];
 355
 356   for (;;)
 357     {
 358       char **result;
 359       int i;
 360
 361       fprintf (stderr, "brace_expand> ");
 362
 363       if ((!fgets (example, 256, stdin)) ||
 364           (strncmp (example, "quit", 4) == 0))
 365         break;
 366
 367       if (strlen (example))
 368         example[strlen (example) - 1] = '\0';
 369
 370       result = brace_expand (example);
 371
 372       for (i = 0; result[i]; i++)
 373         printf ("%s\n", result[i]);
 374
 375       free_array (result);
 376     }
 377 }
 378 \f
 379 /*
 380  * Local variables:
 381  * compile-command: "gcc -g -Bstatic -DTEST -o brace_expand braces.c general.o"
 382  * end:
 383  */
 384
 385 #endif /* TEST */
 386 #endif /* BRACE_EXPANSION */