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