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