gnu/make/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 (char *ptr, char *string, unsigned int length)
  56 {
  57   register unsigned int newlen = length + (ptr - variable_buffer);
  58
  59   if ((newlen + VARIABLE_BUFFER_ZONE) > variable_buffer_length)
  60     {
  61       unsigned int offset = ptr - variable_buffer;
  62       variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length
  63                                 ? newlen + 100
  64                                 : 2 * variable_buffer_length);
  65       variable_buffer = (char *) xrealloc (variable_buffer,
  66                                            variable_buffer_length);
  67       ptr = variable_buffer + offset;
  68     }
  69
  70   bcopy (string, ptr, length);
  71   return ptr + length;
  72 }
  73
  74 /* Return a pointer to the beginning of the variable buffer.  */
  75
  76 static char *
  77 initialize_variable_output (void)
  78 {
  79   /* If we don't have a variable output buffer yet, get one.  */
  80
  81   if (variable_buffer == 0)
  82     {
  83       variable_buffer_length = 200;
  84       variable_buffer = (char *) xmalloc (variable_buffer_length);
  85       variable_buffer[0] = '\0';
  86     }
  87
  88   return variable_buffer;
  89 }
  90 \f
  91 /* Recursively expand V.  The returned string is malloc'd.  */
  92
  93 static char *allocated_variable_append PARAMS ((const struct variable *v));
  94
  95 char *
  96 recursively_expand_for_file (struct variable *v, struct file *file)
  97 {
  98   char *value;
  99   struct variable_set_list *save = 0;
 100   int set_reading = 0;
 101
 102   if (v->expanding)
 103     {
 104       if (!v->exp_count)
 105         /* Expanding V causes infinite recursion.  Lose.  */
 106         fatal (reading_file,
 107                _("Recursive variable `%s' references itself (eventually)"),
 108                v->name);
 109       --v->exp_count;
 110     }
 111
 112   if (file)
 113     {
 114       save = current_variable_set_list;
 115       current_variable_set_list = file->variables;
 116     }
 117
 118   /* If we have no other file-reading context, use the variable's context. */
 119   if (!reading_file)
 120     {
 121       set_reading = 1;
 122       reading_file = &v->fileinfo;
 123     }
 124
 125   v->expanding = 1;
 126   if (v->append)
 127     value = allocated_variable_append (v);
 128   else
 129     value = allocated_variable_expand (v->value);
 130   v->expanding = 0;
 131
 132   if (set_reading)
 133     reading_file = 0;
 134   if (file)
 135     current_variable_set_list = save;
 136
 137   return value;
 138 }
 139
 140 /* Expand a simple reference to variable NAME, which is LENGTH chars long.  */
 141
 142 #ifdef __GNUC__
 143 __inline
 144 #endif
 145 static char *
 146 reference_variable (char *o, char *name, unsigned int length)
 147 {
 148   register struct variable *v;
 149   char *value;
 150
 151   v = lookup_variable (name, length);
 152
 153   if (v == 0)
 154     warn_undefined (name, length);
 155
 156   /* If there's no variable by that name or it has no value, stop now.  */
 157   if (v == 0 || (*v->value == '\0' && !v->append))
 158     return o;
 159
 160   value = (v->recursive ? recursively_expand (v) : v->value);
 161
 162   o = variable_buffer_output (o, value, strlen (value));
 163
 164   if (v->recursive)
 165     free (value);
 166
 167   return o;
 168 }
 169 \f
 170 /* Scan STRING for variable references and expansion-function calls.  Only
 171    LENGTH bytes of STRING are actually scanned.  If LENGTH is -1, scan until
 172    a null byte is found.
 173
 174    Write the results to LINE, which must point into `variable_buffer'.  If
 175    LINE is NULL, start at the beginning of the buffer.
 176    Return a pointer to LINE, or to the beginning of the buffer if LINE is
 177    NULL.  */
 178
 179 char *
 180 variable_expand_string (char *line, char *string, long length)
 181 {
 182   register struct variable *v;
 183   register char *p, *o, *p1;
 184   char save_char = '\0';
 185   unsigned int line_offset;
 186
 187   if (!line)
 188     line = initialize_variable_output();
 189
 190   p = string;
 191   o = line;
 192   line_offset = line - variable_buffer;
 193
 194   if (length >= 0)
 195     {
 196       save_char = string[length];
 197       string[length] = '\0';
 198     }
 199
 200   while (1)
 201     {
 202       /* Copy all following uninteresting chars all at once to the
 203          variable output buffer, and skip them.  Uninteresting chars end
 204          at the next $ or the end of the input.  */
 205
 206       p1 = strchr (p, '$');
 207
 208       o = variable_buffer_output (o, p, p1 != 0 ? p1 - p : strlen (p) + 1);
 209
 210       if (p1 == 0)
 211         break;
 212       p = p1 + 1;
 213
 214       /* Dispatch on the char that follows the $.  */
 215
 216       switch (*p)
 217         {
 218         case '$':
 219           /* $$ seen means output one $ to the variable output buffer.  */
 220           o = variable_buffer_output (o, p, 1);
 221           break;
 222
 223         case '(':
 224         case '{':
 225           /* $(...) or ${...} is the general case of substitution.  */
 226           {
 227             char openparen = *p;
 228             char closeparen = (openparen == '(') ? ')' : '}';
 229             register char *beg = p + 1;
 230             int free_beg = 0;
 231             char *op, *begp;
 232             char *end, *colon;
 233
 234             op = o;
 235             begp = p;
 236             if (handle_function (&op, &begp))
 237               {
 238                 o = op;
 239                 p = begp;
 240                 break;
 241               }
 242
 243             /* Is there a variable reference inside the parens or braces?
 244                If so, expand it before expanding the entire reference.  */
 245
 246             end = strchr (beg, closeparen);
 247             if (end == 0)
 248               /* Unterminated variable reference.  */
 249               fatal (reading_file, _("unterminated variable reference"));
 250             p1 = lindex (beg, end, '$');
 251             if (p1 != 0)
 252               {
 253                 /* BEG now points past the opening paren or brace.
 254                    Count parens or braces until it is matched.  */
 255                 int count = 0;
 256                 for (p = beg; *p != '\0'; ++p)
 257                   {
 258                     if (*p == openparen)
 259                       ++count;
 260                     else if (*p == closeparen && --count < 0)
 261                       break;
 262                   }
 263                 /* If COUNT is >= 0, there were unmatched opening parens
 264                    or braces, so we go to the simple case of a variable name
 265                    such as `$($(a)'.  */
 266                 if (count < 0)
 267                   {
 268                     beg = expand_argument (beg, p); /* Expand the name.  */
 269                     free_beg = 1; /* Remember to free BEG when finished.  */
 270                     end = strchr (beg, '\0');
 271                   }
 272               }
 273             else
 274               /* Advance P to the end of this reference.  After we are
 275                  finished expanding this one, P will be incremented to
 276                  continue the scan.  */
 277               p = end;
 278
 279             /* This is not a reference to a built-in function and
 280                any variable references inside are now expanded.
 281                Is the resultant text a substitution reference?  */
 282
 283             colon = lindex (beg, end, ':');
 284             if (colon)
 285               {
 286                 /* This looks like a substitution reference: $(FOO:A=B).  */
 287                 char *subst_beg, *subst_end, *replace_beg, *replace_end;
 288
 289                 subst_beg = colon + 1;
 290                 subst_end = lindex (subst_beg, end, '=');
 291                 if (subst_end == 0)
 292                   /* There is no = in sight.  Punt on the substitution
 293                      reference and treat this as a variable name containing
 294                      a colon, in the code below.  */
 295                   colon = 0;
 296                 else
 297                   {
 298                     replace_beg = subst_end + 1;
 299                     replace_end = end;
 300
 301                     /* Extract the variable name before the colon
 302                        and look up that variable.  */
 303                     v = lookup_variable (beg, colon - beg);
 304                     if (v == 0)
 305                       warn_undefined (beg, colon - beg);
 306
 307                     if (v != 0 && *v->value != '\0')
 308                       {
 309                         char *value = (v->recursive ? recursively_expand (v)
 310                                        : v->value);
 311                         char *pattern, *percent;
 312                         if (free_beg)
 313                           {
 314                             *subst_end = '\0';
 315                             pattern = subst_beg;
 316                           }
 317                         else
 318                           {
 319                             pattern = (char *) alloca (subst_end - subst_beg
 320                                                        + 1);
 321                             bcopy (subst_beg, pattern, subst_end - subst_beg);
 322                             pattern[subst_end - subst_beg] = '\0';
 323                           }
 324                         percent = find_percent (pattern);
 325                         if (percent != 0)
 326                           {
 327                             char *replace;
 328                             if (free_beg)
 329                               {
 330                                 *replace_end = '\0';
 331                                 replace = replace_beg;
 332                               }
 333                             else
 334                               {
 335                                 replace = (char *) alloca (replace_end
 336                                                            - replace_beg
 337                                                            + 1);
 338                                 bcopy (replace_beg, replace,
 339                                        replace_end - replace_beg);
 340                                 replace[replace_end - replace_beg] = '\0';
 341                               }
 342
 343                             o = patsubst_expand (o, value, pattern, replace,
 344                                                  percent, (char *) 0);
 345                           }
 346                         else
 347                           o = subst_expand (o, value,
 348                                             pattern, replace_beg,
 349                                             strlen (pattern),
 350                                             end - replace_beg,
 351                                             0, 1);
 352                         if (v->recursive)
 353                           free (value);
 354                       }
 355                   }
 356               }
 357
 358             if (colon == 0)
 359               /* This is an ordinary variable reference.
 360                  Look up the value of the variable.  */
 361                 o = reference_variable (o, beg, end - beg);
 362
 363           if (free_beg)
 364             free (beg);
 365           }
 366           break;
 367
 368         case '\0':
 369           break;
 370
 371         default:
 372           if (isblank ((unsigned char)p[-1]))
 373             break;
 374
 375           /* A $ followed by a random char is a variable reference:
 376              $a is equivalent to $(a).  */
 377           {
 378             /* We could do the expanding here, but this way
 379                avoids code repetition at a small performance cost.  */
 380             char name[5];
 381             name[0] = '$';
 382             name[1] = '(';
 383             name[2] = *p;
 384             name[3] = ')';
 385             name[4] = '\0';
 386             p1 = allocated_variable_expand (name);
 387             o = variable_buffer_output (o, p1, strlen (p1));
 388             free (p1);
 389           }
 390
 391           break;
 392         }
 393
 394       if (*p == '\0')
 395         break;
 396       else
 397         ++p;
 398     }
 399
 400   if (save_char)
 401     string[length] = save_char;
 402
 403   (void)variable_buffer_output (o, "", 1);
 404   return (variable_buffer + line_offset);
 405 }
 406 \f
 407 /* Scan LINE for variable references and expansion-function calls.
 408    Build in `variable_buffer' the result of expanding the references and calls.
 409    Return the address of the resulting string, which is null-terminated
 410    and is valid only until the next time this function is called.  */
 411
 412 char *
 413 variable_expand (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 (const char *str, const char *end)
 426 {
 427   char *tmp;
 428
 429   if (str == end)
 430     return xstrdup("");
 431
 432   if (!end || *end == '\0')
 433     return allocated_variable_expand ((char *)str);
 434
 435   tmp = (char *) alloca (end - str + 1);
 436   bcopy (str, tmp, end - str);
 437   tmp[end - str] = '\0';
 438
 439   return allocated_variable_expand (tmp);
 440 }
 441 \f
 442 /* Expand LINE for FILE.  Error messages refer to the file and line where
 443    FILE's commands were found.  Expansion uses FILE's variable set list.  */
 444
 445 static char *
 446 variable_expand_for_file (char *line, struct file *file)
 447 {
 448   char *result;
 449   struct variable_set_list *save;
 450
 451   if (file == 0)
 452     return variable_expand (line);
 453
 454   save = current_variable_set_list;
 455   current_variable_set_list = file->variables;
 456   if (file->cmds && file->cmds->fileinfo.filenm)
 457     reading_file = &file->cmds->fileinfo;
 458   else
 459     reading_file = 0;
 460   result = variable_expand (line);
 461   current_variable_set_list = save;
 462   reading_file = 0;
 463
 464   return result;
 465 }
 466 \f
 467 /* Like allocated_variable_expand, but for += target-specific variables.
 468    First recursively construct the variable value from its appended parts in
 469    any upper variable sets.  Then expand the resulting value.  */
 470
 471 static char *
 472 variable_append (const char *name, unsigned int length,
 473                  const struct variable_set_list *set)
 474 {
 475   const struct variable *v;
 476   char *buf = 0;
 477
 478   /* If there's nothing left to check, return the empty buffer.  */
 479   if (!set)
 480     return initialize_variable_output ();
 481
 482   /* Try to find the variable in this variable set.  */
 483   v = lookup_variable_in_set (name, length, set->set);
 484
 485   /* If there isn't one, look to see if there's one in a set above us.  */
 486   if (!v)
 487     return variable_append (name, length, set->next);
 488
 489   /* If this variable type is append, first get any upper values.
 490      If not, initialize the buffer.  */
 491   if (v->append)
 492     buf = variable_append (name, length, set->next);
 493   else
 494     buf = initialize_variable_output ();
 495
 496   /* Append this value to the buffer, and return it.
 497      If we already have a value, first add a space.  */
 498   if (buf > variable_buffer)
 499     buf = variable_buffer_output (buf, " ", 1);
 500
 501   return variable_buffer_output (buf, v->value, strlen (v->value));
 502 }
 503
 504
 505 static char *
 506 allocated_variable_append (const struct variable *v)
 507 {
 508   char *val, *retval;
 509
 510   /* Construct the appended variable value.  */
 511
 512   char *obuf = variable_buffer;
 513   unsigned int olen = variable_buffer_length;
 514
 515   variable_buffer = 0;
 516
 517   val = variable_append (v->name, strlen (v->name), current_variable_set_list);
 518   variable_buffer_output (val, "", 1);
 519   val = variable_buffer;
 520
 521   variable_buffer = obuf;
 522   variable_buffer_length = olen;
 523
 524   /* Now expand it and return that.  */
 525
 526   retval = allocated_variable_expand (val);
 527
 528   free (val);
 529   return retval;
 530 }
 531
 532 /* Like variable_expand_for_file, but the returned string is malloc'd.
 533    This function is called a lot.  It wants to be efficient.  */
 534
 535 char *
 536 allocated_variable_expand_for_file (char *line, struct file *file)
 537 {
 538   char *value;
 539
 540   char *obuf = variable_buffer;
 541   unsigned int olen = variable_buffer_length;
 542
 543   variable_buffer = 0;
 544
 545   value = variable_expand_for_file (line, file);
 546
 547 #if 0
 548   /* Waste a little memory and save time.  */
 549   value = xrealloc (value, strlen (value))
 550 #endif
 551
 552   variable_buffer = obuf;
 553   variable_buffer_length = olen;
 554
 555   return value;
 556 }
 557
 558 /* Install a new variable_buffer context, returning the current one for
 559    safe-keeping.  */
 560
 561 void
 562 install_variable_buffer (char **bufp, unsigned int *lenp)
 563 {
 564   *bufp = variable_buffer;
 565   *lenp = variable_buffer_length;
 566
 567   variable_buffer = 0;
 568   initialize_variable_output ();
 569 }
 570
 571 /* Restore a previously-saved variable_buffer setting (free the current one).
 572  */
 573
 574 void
 575 restore_variable_buffer (char *buf, unsigned int len)
 576 {
 577   free (variable_buffer);
 578
 579   variable_buffer = buf;
 580   variable_buffer_length = len;
 581 }