expand.c

   1 /* Variable expansion functions for GNU Make.
   2 Copyright (C) 1988, 89, 91, 92, 93, 95 Free Software Foundation, Inc.
   3 This file is part of GNU Make.
   4
   5 GNU Make is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Make is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Make; see the file COPYING.  If not, write to
  17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.  */
  19
  20 #include "make.h"
  21 #include "filedef.h"
  22 #include "job.h"
  23 #include "commands.h"
  24 #include "variable.h"
  25 #include "rule.h"
  26
  27 /* The next two describe the variable output buffer.
  28    This buffer is used to hold the variable-expansion of a line of the
  29    makefile.  It is made bigger with realloc whenever it is too small.
  30    variable_buffer_length is the size currently allocated.
  31    variable_buffer is the address of the buffer.
  32
  33    For efficiency, it's guaranteed that the buffer will always have
  34    VARIABLE_BUFFER_ZONE extra bytes allocated.  This allows you to add a few
  35    extra chars without having to call a function.  Note you should never use
  36    these bytes unless you're _sure_ you have room (you know when the buffer
  37    length was last checked.  */
  38
  39 #define VARIABLE_BUFFER_ZONE    5
  40
  41 static unsigned int variable_buffer_length;
  42 char *variable_buffer;
  43
  44 /* Subroutine of variable_expand and friends:
  45    The text to add is LENGTH chars starting at STRING to the variable_buffer.
  46    The text is added to the buffer at PTR, and the updated pointer into
  47    the buffer is returned as the value.  Thus, the value returned by
  48    each call to variable_buffer_output should be the first argument to
  49    the following call.  */
  50
  51 char *
  52 variable_buffer_output (ptr, string, length)
  53      char *ptr, *string;
  54      unsigned int length;
  55 {
  56   register unsigned int newlen = length + (ptr - variable_buffer);
  57
  58   if ((newlen + VARIABLE_BUFFER_ZONE) > variable_buffer_length)
  59     {
  60       unsigned int offset = ptr - variable_buffer;
  61       variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length
  62                                 ? newlen + 100
  63                                 : 2 * variable_buffer_length);
  64       variable_buffer = (char *) xrealloc (variable_buffer,
  65                                            variable_buffer_length);
  66       ptr = variable_buffer + offset;
  67     }
  68
  69   bcopy (string, ptr, length);
  70   return ptr + length;
  71 }
  72
  73 /* Return a pointer to the beginning of the variable buffer.  */
  74
  75 static char *
  76 initialize_variable_output ()
  77 {
  78   /* If we don't have a variable output buffer yet, get one.  */
  79
  80   if (variable_buffer == 0)
  81     {
  82       variable_buffer_length = 200;
  83       variable_buffer = (char *) xmalloc (variable_buffer_length);
  84       variable_buffer[0] = '\0';
  85     }
  86
  87   return variable_buffer;
  88 }
  89 \f
  90 /* Recursively expand V.  The returned string is malloc'd.  */
  91
  92 char *
  93 recursively_expand (v)
  94      register struct variable *v;
  95 {
  96   char *value;
  97
  98   if (v->expanding)
  99     /* Expanding V causes infinite recursion.  Lose.  */
 100     fatal (reading_file,
 101            "Recursive variable `%s' references itself (eventually)", v->name);
 102
 103   v->expanding = 1;
 104   value = allocated_variable_expand (v->value);
 105   v->expanding = 0;
 106
 107   return value;
 108 }
 109
 110 /* Warn that NAME is an undefined variable.  */
 111
 112 #ifdef __GNUC__
 113 __inline
 114 #endif
 115 static void
 116 warn_undefined (name, length)
 117      char *name;
 118      unsigned int length;
 119 {
 120   if (warn_undefined_variables_flag)
 121     error (reading_file,
 122            "warning: undefined variable `%.*s'", (int)length, name);
 123 }
 124
 125 /* Expand a simple reference to variable NAME, which is LENGTH chars long.  */
 126
 127 #ifdef __GNUC__
 128 __inline
 129 #endif
 130 static char *
 131 reference_variable (o, name, length)
 132      char *o;
 133      char *name;
 134      unsigned int length;
 135 {
 136   register struct variable *v = lookup_variable (name, length);
 137
 138   if (v == 0)
 139     warn_undefined (name, length);
 140
 141   if (v != 0 && *v->value != '\0')
 142     {
 143       char *value = (v->recursive ? recursively_expand (v) : v->value);
 144       o = variable_buffer_output (o, value, strlen (value));
 145       if (v->recursive)
 146         free (value);
 147     }
 148
 149   return o;
 150 }
 151 \f
 152 /* Scan STRING for variable references and expansion-function calls.  Only
 153    LENGTH bytes of STRING are actually scanned.  If LENGTH is -1, scan until
 154    a null byte is found.
 155
 156    Write the results to LINE, which must point into `variable_buffer'.  If
 157    LINE is NULL, start at the beginning of the buffer.
 158    Return a pointer to LINE, or to the beginning of the buffer if LINE is
 159    NULL.  */
 160
 161 char *
 162 variable_expand_string (line, string, length)
 163      register char *line;
 164      char *string;
 165      long length;
 166 {
 167   register struct variable *v;
 168   register char *p, *o, *p1;
 169   char save_char = '\0';
 170   unsigned int line_offset;
 171
 172   if (!line)
 173     line = initialize_variable_output();
 174
 175   p = string;
 176   o = line;
 177   line_offset = line - variable_buffer;
 178
 179   if (length >= 0)
 180     {
 181       save_char = string[length];
 182       string[length] = '\0';
 183     }
 184
 185   while (1)
 186     {
 187       /* Copy all following uninteresting chars all at once to the
 188          variable output buffer, and skip them.  Uninteresting chars end
 189          at the next $ or the end of the input.  */
 190
 191       p1 = index (p, '$');
 192
 193       o = variable_buffer_output (o, p, p1 != 0 ? p1 - p : strlen (p) + 1);
 194
 195       if (p1 == 0)
 196         break;
 197       p = p1 + 1;
 198
 199       /* Dispatch on the char that follows the $.  */
 200
 201       switch (*p)
 202         {
 203         case '$':
 204           /* $$ seen means output one $ to the variable output buffer.  */
 205           o = variable_buffer_output (o, p, 1);
 206           break;
 207
 208         case '(':
 209         case '{':
 210           /* $(...) or ${...} is the general case of substitution.  */
 211           {
 212             char openparen = *p;
 213             char closeparen = (openparen == '(') ? ')' : '}';
 214             register char *beg = p + 1;
 215             int free_beg = 0;
 216             char *op, *begp;
 217             char *end, *colon;
 218
 219             op = o;
 220             begp = p;
 221             if (handle_function (&op, &begp))
 222               {
 223                 o = op;
 224                 p = begp;
 225                 break;
 226               }
 227
 228             /* Is there a variable reference inside the parens or braces?
 229                If so, expand it before expanding the entire reference.  */
 230
 231             end = index (beg, closeparen);
 232             if (end == 0)
 233               /* Unterminated variable reference.  */
 234               fatal (reading_file, "unterminated variable reference");
 235             p1 = lindex (beg, end, '$');
 236             if (p1 != 0)
 237               {
 238                 /* BEG now points past the opening paren or brace.
 239                    Count parens or braces until it is matched.  */
 240                 int count = 0;
 241                 for (p = beg; *p != '\0'; ++p)
 242                   {
 243                     if (*p == openparen)
 244                       ++count;
 245                     else if (*p == closeparen && --count < 0)
 246                       break;
 247                   }
 248                 /* If COUNT is >= 0, there were unmatched opening parens
 249                    or braces, so we go to the simple case of a variable name
 250                    such as `$($(a)'.  */
 251                 if (count < 0)
 252                   {
 253                     beg = expand_argument (beg, p); /* Expand the name.  */
 254                     free_beg = 1; /* Remember to free BEG when finished.  */
 255                     end = index (beg, '\0');
 256                   }
 257               }
 258             else
 259               /* Advance P to the end of this reference.  After we are
 260                  finished expanding this one, P will be incremented to
 261                  continue the scan.  */
 262               p = end;
 263
 264             /* This is not a reference to a built-in function and
 265                any variable references inside are now expanded.
 266                Is the resultant text a substitution reference?  */
 267
 268             colon = lindex (beg, end, ':');
 269             if (colon != 0)
 270               {
 271                 /* This looks like a substitution reference: $(FOO:A=B).  */
 272                 char *subst_beg, *subst_end, *replace_beg, *replace_end;
 273
 274                 subst_beg = colon + 1;
 275                 subst_end = index (subst_beg, '=');
 276                 if (subst_end == 0)
 277                   /* There is no = in sight.  Punt on the substitution
 278                      reference and treat this as a variable name containing
 279                      a colon, in the code below.  */
 280                   colon = 0;
 281                 else
 282                   {
 283                     replace_beg = subst_end + 1;
 284                     replace_end = end;
 285
 286                     /* Extract the variable name before the colon
 287                        and look up that variable.  */
 288                     v = lookup_variable (beg, colon - beg);
 289                     if (v == 0)
 290                       warn_undefined (beg, colon - beg);
 291
 292                     if (v != 0 && *v->value != '\0')
 293                       {
 294                         char *value = (v->recursive ? recursively_expand (v)
 295                                        : v->value);
 296                         char *pattern, *percent;
 297                         if (free_beg)
 298                           {
 299                             *subst_end = '\0';
 300                             pattern = subst_beg;
 301                           }
 302                         else
 303                           {
 304                             pattern = (char *) alloca (subst_end - subst_beg
 305                                                        + 1);
 306                             bcopy (subst_beg, pattern, subst_end - subst_beg);
 307                             pattern[subst_end - subst_beg] = '\0';
 308                           }
 309                         percent = find_percent (pattern);
 310                         if (percent != 0)
 311                           {
 312                             char *replace;
 313                             if (free_beg)
 314                               {
 315                                 *replace_end = '\0';
 316                                 replace = replace_beg;
 317                               }
 318                             else
 319                               {
 320                                 replace = (char *) alloca (replace_end
 321                                                            - replace_beg
 322                                                            + 1);
 323                                 bcopy (replace_beg, replace,
 324                                        replace_end - replace_beg);
 325                                 replace[replace_end - replace_beg] = '\0';
 326                               }
 327
 328                             o = patsubst_expand (o, value, pattern, replace,
 329                                                  percent, (char *) 0);
 330                           }
 331                         else
 332                           o = subst_expand (o, value,
 333                                             pattern, replace_beg,
 334                                             strlen (pattern),
 335                                             end - replace_beg,
 336                                             0, 1);
 337                         if (v->recursive)
 338                           free (value);
 339                       }
 340                   }
 341               }
 342
 343             if (colon == 0)
 344               /* This is an ordinary variable reference.
 345                  Look up the value of the variable.  */
 346                 o = reference_variable (o, beg, end - beg);
 347
 348           if (free_beg)
 349             free (beg);
 350           }
 351           break;
 352
 353         case '\0':
 354           break;
 355
 356         default:
 357           if (isblank (p[-1]))
 358             break;
 359
 360           /* A $ followed by a random char is a variable reference:
 361              $a is equivalent to $(a).  */
 362           {
 363             /* We could do the expanding here, but this way
 364                avoids code repetition at a small performance cost.  */
 365             char name[5];
 366             name[0] = '$';
 367             name[1] = '(';
 368             name[2] = *p;
 369             name[3] = ')';
 370             name[4] = '\0';
 371             p1 = allocated_variable_expand (name);
 372             o = variable_buffer_output (o, p1, strlen (p1));
 373             free (p1);
 374           }
 375
 376           break;
 377         }
 378
 379       if (*p == '\0')
 380         break;
 381       else
 382         ++p;
 383     }
 384
 385   if (save_char)
 386     string[length] = save_char;
 387
 388   (void)variable_buffer_output (o, "", 1);
 389   return (variable_buffer + line_offset);
 390 }
 391 \f
 392 /* Scan LINE for variable references and expansion-function calls.
 393    Build in `variable_buffer' the result of expanding the references and calls.
 394    Return the address of the resulting string, which is null-terminated
 395    and is valid only until the next time this function is called.  */
 396
 397 char *
 398 variable_expand (line)
 399      char *line;
 400 {
 401   return variable_expand_string(NULL, line, -1);
 402 }
 403 \f
 404 /* Expand an argument for an expansion function.
 405    The text starting at STR and ending at END is variable-expanded
 406    into a null-terminated string that is returned as the value.
 407    This is done without clobbering `variable_buffer' or the current
 408    variable-expansion that is in progress.  */
 409
 410 char *
 411 expand_argument (str, end)
 412      char *str, *end;
 413 {
 414   char *tmp;
 415
 416   if (*end == '\0')
 417     tmp = str;
 418   else
 419     {
 420       tmp = (char *) alloca (end - str + 1);
 421       bcopy (str, tmp, end - str);
 422       tmp[end - str] = '\0';
 423     }
 424
 425   return allocated_variable_expand (tmp);
 426 }
 427 \f
 428 /* Expand LINE for FILE.  Error messages refer to the file and line where
 429    FILE's commands were found.  Expansion uses FILE's variable set list.  */
 430
 431 static char *
 432 variable_expand_for_file (line, file)
 433      char *line;
 434      register struct file *file;
 435 {
 436   char *result;
 437   struct variable_set_list *save, *fnext;
 438
 439   if (file == 0)
 440     return variable_expand (line);
 441
 442   save = current_variable_set_list;
 443   current_variable_set_list = file->variables;
 444   reading_file = &file->cmds->fileinfo;
 445   fnext = file->variables->next;
 446   /* See if there's a pattern-specific variable struct for this target.  */
 447   if (!file->pat_searched)
 448     {
 449       file->patvar = lookup_pattern_var(file->name);
 450       file->pat_searched = 1;
 451     }
 452   if (file->patvar != 0)
 453     {
 454       file->patvar->vars->next = fnext;
 455       file->variables->next = file->patvar->vars;
 456     }
 457   result = variable_expand (line);
 458   current_variable_set_list = save;
 459   reading_file = 0;
 460   file->variables->next = fnext;
 461
 462   return result;
 463 }
 464 \f
 465 /* Like variable_expand_for_file, but the returned string is malloc'd.
 466    This function is called a lot.  It wants to be efficient.  */
 467
 468 char *
 469 allocated_variable_expand_for_file (line, file)
 470      char *line;
 471      struct file *file;
 472 {
 473   char *value;
 474
 475   char *obuf = variable_buffer;
 476   unsigned int olen = variable_buffer_length;
 477
 478   variable_buffer = 0;
 479
 480   value = variable_expand_for_file (line, file);
 481
 482 #if 0
 483   /* Waste a little memory and save time.  */
 484   value = xrealloc (value, strlen (value))
 485 #endif
 486
 487   variable_buffer = obuf;
 488   variable_buffer_length = olen;
 489
 490   return value;
 491 }