1/* Variable expansion functions for GNU Make. 2Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 31998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software 4Foundation, Inc. 5This file is part of GNU Make. 6 7GNU Make is free software; you can redistribute it and/or modify it under the 8terms of the GNU General Public License as published by the Free Software 9Foundation; either version 2, or (at your option) any later version. 10 11GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR 13A PARTICULAR PURPOSE. See the GNU General Public License for more details. 14 15You should have received a copy of the GNU General Public License along with 16GNU Make; see the file COPYING. If not, write to the Free Software 17Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */ 18 19#include "make.h" 20 21#include <assert.h> 22 23#include "filedef.h" 24#include "job.h" 25#include "commands.h" 26#include "variable.h" 27#include "rule.h" 28 29/* Initially, any errors reported when expanding strings will be reported 30 against the file where the error appears. */ 31const struct floc **expanding_var = &reading_file; 32 33/* The next two describe the variable output buffer. 34 This buffer is used to hold the variable-expansion of a line of the 35 makefile. It is made bigger with realloc whenever it is too small. 36 variable_buffer_length is the size currently allocated. 37 variable_buffer is the address of the buffer. 38 39 For efficiency, it's guaranteed that the buffer will always have 40 VARIABLE_BUFFER_ZONE extra bytes allocated. This allows you to add a few 41 extra chars without having to call a function. Note you should never use 42 these bytes unless you're _sure_ you have room (you know when the buffer 43 length was last checked. */ 44 45#define VARIABLE_BUFFER_ZONE 5 46 47static unsigned int variable_buffer_length; 48char *variable_buffer; 49 50/* Subroutine of variable_expand and friends: 51 The text to add is LENGTH chars starting at STRING to the variable_buffer. 52 The text is added to the buffer at PTR, and the updated pointer into 53 the buffer is returned as the value. Thus, the value returned by 54 each call to variable_buffer_output should be the first argument to 55 the following call. */ 56 57char * 58variable_buffer_output (char *ptr, char *string, unsigned int length) 59{ 60 register unsigned int newlen = length + (ptr - variable_buffer); 61 62 if ((newlen + VARIABLE_BUFFER_ZONE) > variable_buffer_length) 63 { 64 unsigned int offset = ptr - variable_buffer; 65 variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length 66 ? newlen + 100 67 : 2 * variable_buffer_length); 68 variable_buffer = (char *) xrealloc (variable_buffer, 69 variable_buffer_length); 70 ptr = variable_buffer + offset; 71 } 72 73 bcopy (string, ptr, length); 74 return ptr + length; 75} 76 77/* Return a pointer to the beginning of the variable buffer. */ 78 79static char * 80initialize_variable_output (void) 81{ 82 /* If we don't have a variable output buffer yet, get one. */ 83 84 if (variable_buffer == 0) 85 { 86 variable_buffer_length = 200; 87 variable_buffer = (char *) xmalloc (variable_buffer_length); 88 variable_buffer[0] = '\0'; 89 } 90 91 return variable_buffer; 92} 93 94/* Recursively expand V. The returned string is malloc'd. */ 95 96static char *allocated_variable_append PARAMS ((const struct variable *v)); 97 98char * 99recursively_expand_for_file (struct variable *v, struct file *file) 100{ 101 char *value; 102 const struct floc *this_var; 103 const struct floc **saved_varp; 104 struct variable_set_list *save = 0; 105 int set_reading = 0; 106 107 /* Don't install a new location if this location is empty. 108 This can happen for command-line variables, builtin variables, etc. */ 109 saved_varp = expanding_var; 110 if (v->fileinfo.filenm) 111 { 112 this_var = &v->fileinfo; 113 expanding_var = &this_var; 114 } 115 116 /* If we have no other file-reading context, use the variable's context. */ 117 if (!reading_file) 118 { 119 set_reading = 1; 120 reading_file = &v->fileinfo; 121 } 122 123 if (v->expanding) 124 { 125 if (!v->exp_count) 126 /* Expanding V causes infinite recursion. Lose. */ 127 fatal (*expanding_var, 128 _("Recursive variable `%s' references itself (eventually)"), 129 v->name); 130 --v->exp_count; 131 } 132 133 if (file) 134 { 135 save = current_variable_set_list; 136 current_variable_set_list = file->variables; 137 } 138 139 v->expanding = 1; 140 if (v->append) 141 value = allocated_variable_append (v); 142 else 143 value = allocated_variable_expand (v->value); 144 v->expanding = 0; 145 146 if (set_reading) 147 reading_file = 0; 148 149 if (file) 150 current_variable_set_list = save; 151 152 expanding_var = saved_varp; 153 154 return value; 155} 156 157/* Expand a simple reference to variable NAME, which is LENGTH chars long. */ 158 159#ifdef __GNUC__ 160__inline 161#endif 162static char * 163reference_variable (char *o, char *name, unsigned int length) 164{ 165 register struct variable *v; 166 char *value; 167 168 v = lookup_variable (name, length); 169 170 if (v == 0) 171 warn_undefined (name, length); 172 173 /* If there's no variable by that name or it has no value, stop now. */ 174 if (v == 0 || (*v->value == '\0' && !v->append)) 175 return o; 176 177 value = (v->recursive ? recursively_expand (v) : v->value); 178 179 o = variable_buffer_output (o, value, strlen (value)); 180 181 if (v->recursive) 182 free (value); 183 184 return o; 185} 186 187/* Scan STRING for variable references and expansion-function calls. Only 188 LENGTH bytes of STRING are actually scanned. If LENGTH is -1, scan until 189 a null byte is found. 190 191 Write the results to LINE, which must point into `variable_buffer'. If 192 LINE is NULL, start at the beginning of the buffer. 193 Return a pointer to LINE, or to the beginning of the buffer if LINE is 194 NULL. */ 195 196char * 197variable_expand_string (char *line, char *string, long length) 198{ 199 register struct variable *v; 200 register char *p, *o, *p1; 201 char save_char = '\0'; 202 unsigned int line_offset; 203 204 if (!line) 205 line = initialize_variable_output(); 206 207 p = string; 208 o = line; 209 line_offset = line - variable_buffer; 210 211 if (length >= 0) 212 { 213 save_char = string[length]; 214 string[length] = '\0'; 215 } 216 217 while (1) 218 { 219 /* Copy all following uninteresting chars all at once to the 220 variable output buffer, and skip them. Uninteresting chars end 221 at the next $ or the end of the input. */ 222 223 p1 = strchr (p, '$'); 224 225 o = variable_buffer_output (o, p, p1 != 0 ? (unsigned int)(p1 - p) : strlen (p) + 1); 226 227 if (p1 == 0) 228 break; 229 p = p1 + 1; 230 231 /* Dispatch on the char that follows the $. */ 232 233 switch (*p) 234 { 235 case '$': 236 /* $$ seen means output one $ to the variable output buffer. */ 237 o = variable_buffer_output (o, p, 1); 238 break; 239 240 case '(': 241 case '{': 242 /* $(...) or ${...} is the general case of substitution. */ 243 { 244 char openparen = *p; 245 char closeparen = (openparen == '(') ? ')' : '}'; 246 register char *beg = p + 1; 247 int free_beg = 0; 248 char *op, *begp; 249 char *end, *colon; 250 251 op = o; 252 begp = p; 253 if (handle_function (&op, &begp)) 254 { 255 o = op; 256 p = begp; 257 break; 258 } 259 260 /* Is there a variable reference inside the parens or braces? 261 If so, expand it before expanding the entire reference. */ 262 263 end = strchr (beg, closeparen); 264 if (end == 0) 265 /* Unterminated variable reference. */ 266 fatal (*expanding_var, _("unterminated variable reference")); 267 p1 = lindex (beg, end, '$'); 268 if (p1 != 0) 269 { 270 /* BEG now points past the opening paren or brace. 271 Count parens or braces until it is matched. */ 272 int count = 0; 273 for (p = beg; *p != '\0'; ++p) 274 { 275 if (*p == openparen) 276 ++count; 277 else if (*p == closeparen && --count < 0) 278 break; 279 } 280 /* If COUNT is >= 0, there were unmatched opening parens 281 or braces, so we go to the simple case of a variable name 282 such as `$($(a)'. */ 283 if (count < 0) 284 { 285 beg = expand_argument (beg, p); /* Expand the name. */ 286 free_beg = 1; /* Remember to free BEG when finished. */ 287 end = strchr (beg, '\0'); 288 } 289 } 290 else 291 /* Advance P to the end of this reference. After we are 292 finished expanding this one, P will be incremented to 293 continue the scan. */ 294 p = end; 295 296 /* This is not a reference to a built-in function and 297 any variable references inside are now expanded. 298 Is the resultant text a substitution reference? */ 299 300 colon = lindex (beg, end, ':'); 301 if (colon) 302 { 303 /* This looks like a substitution reference: $(FOO:A=B). */ 304 char *subst_beg, *subst_end, *replace_beg, *replace_end; 305 306 subst_beg = colon + 1; 307 subst_end = lindex (subst_beg, end, '='); 308 if (subst_end == 0) 309 /* There is no = in sight. Punt on the substitution 310 reference and treat this as a variable name containing 311 a colon, in the code below. */ 312 colon = 0; 313 else 314 { 315 replace_beg = subst_end + 1; 316 replace_end = end; 317 318 /* Extract the variable name before the colon 319 and look up that variable. */ 320 v = lookup_variable (beg, colon - beg); 321 if (v == 0) 322 warn_undefined (beg, colon - beg); 323 324 /* If the variable is not empty, perform the 325 substitution. */ 326 if (v != 0 && *v->value != '\0') 327 { 328 char *pattern, *replace, *ppercent, *rpercent; 329 char *value = (v->recursive 330 ? recursively_expand (v) 331 : v->value); 332 333 /* Copy the pattern and the replacement. Add in an 334 extra % at the beginning to use in case there 335 isn't one in the pattern. */ 336 pattern = (char *) alloca (subst_end - subst_beg + 2); 337 *(pattern++) = '%'; 338 bcopy (subst_beg, pattern, subst_end - subst_beg); 339 pattern[subst_end - subst_beg] = '\0'; 340 341 replace = (char *) alloca (replace_end 342 - replace_beg + 2); 343 *(replace++) = '%'; 344 bcopy (replace_beg, replace, 345 replace_end - replace_beg); 346 replace[replace_end - replace_beg] = '\0'; 347 348 /* Look for %. Set the percent pointers properly 349 based on whether we find one or not. */ 350 ppercent = find_percent (pattern); 351 if (ppercent) 352 { 353 ++ppercent; 354 rpercent = 0; 355 } 356 else 357 { 358 ppercent = pattern; 359 rpercent = replace; 360 --pattern; 361 --replace; 362 } 363 364 o = patsubst_expand (o, value, pattern, replace, 365 ppercent, rpercent); 366 367 if (v->recursive) 368 free (value); 369 } 370 } 371 } 372 373 if (colon == 0) 374 /* This is an ordinary variable reference. 375 Look up the value of the variable. */ 376 o = reference_variable (o, beg, end - beg); 377 378 if (free_beg) 379 free (beg); 380 } 381 break; 382 383 case '\0': 384 break; 385 386 default: 387 if (isblank ((unsigned char)p[-1])) 388 break; 389 390 /* A $ followed by a random char is a variable reference: 391 $a is equivalent to $(a). */ 392 o = reference_variable (o, p, 1); 393 394 break; 395 } 396 397 if (*p == '\0') 398 break; 399 else 400 ++p; 401 } 402 403 if (save_char) 404 string[length] = save_char; 405 406 (void)variable_buffer_output (o, "", 1); 407 return (variable_buffer + line_offset); 408} 409 410/* Scan LINE for variable references and expansion-function calls. 411 Build in `variable_buffer' the result of expanding the references and calls. 412 Return the address of the resulting string, which is null-terminated 413 and is valid only until the next time this function is called. */ 414 415char * 416variable_expand (char *line) 417{ 418 return variable_expand_string(NULL, line, (long)-1); 419} 420 421/* Expand an argument for an expansion function. 422 The text starting at STR and ending at END is variable-expanded 423 into a null-terminated string that is returned as the value. 424 This is done without clobbering `variable_buffer' or the current 425 variable-expansion that is in progress. */ 426 427char * 428expand_argument (const char *str, const char *end) 429{ 430 char *tmp; 431 432 if (str == end) 433 return xstrdup(""); 434 435 if (!end || *end == '\0') 436 return allocated_variable_expand ((char *)str); 437 438 tmp = (char *) alloca (end - str + 1); 439 bcopy (str, tmp, end - str); 440 tmp[end - str] = '\0'; 441 442 return allocated_variable_expand (tmp); 443} 444 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 448char * 449variable_expand_for_file (char *line, struct file *file) 450{ 451 char *result; 452 struct variable_set_list *save; 453 454 if (file == 0) 455 return variable_expand (line); 456 457 save = current_variable_set_list; 458 current_variable_set_list = file->variables; 459 if (file->cmds && file->cmds->fileinfo.filenm) 460 reading_file = &file->cmds->fileinfo; 461 else 462 reading_file = 0; 463 result = variable_expand (line); 464 current_variable_set_list = save; 465 reading_file = 0; 466 467 return result; 468} 469 470/* Like allocated_variable_expand, but for += target-specific variables. 471 First recursively construct the variable value from its appended parts in 472 any upper variable sets. Then expand the resulting value. */ 473 474static char * 475variable_append (const char *name, unsigned int length, 476 const struct variable_set_list *set) 477{ 478 const struct variable *v; 479 char *buf = 0; 480 481 /* If there's nothing left to check, return the empty buffer. */ 482 if (!set) 483 return initialize_variable_output (); 484 485 /* Try to find the variable in this variable set. */ 486 v = lookup_variable_in_set (name, length, set->set); 487 488 /* If there isn't one, look to see if there's one in a set above us. */ 489 if (!v) 490 return variable_append (name, length, set->next); 491 492 /* If this variable type is append, first get any upper values. 493 If not, initialize the buffer. */ 494 if (v->append) 495 buf = variable_append (name, length, set->next); 496 else 497 buf = initialize_variable_output (); 498 499 /* Append this value to the buffer, and return it. 500 If we already have a value, first add a space. */ 501 if (buf > variable_buffer) 502 buf = variable_buffer_output (buf, " ", 1); 503 504 /* Either expand it or copy it, depending. */ 505 if (! v->recursive) 506 return variable_buffer_output (buf, v->value, strlen (v->value)); 507 508 buf = variable_expand_string (buf, v->value, strlen (v->value)); 509 return (buf + strlen (buf)); 510} 511 512 513static char * 514allocated_variable_append (const struct variable *v) 515{ 516 char *val; 517 518 /* Construct the appended variable value. */ 519 520 char *obuf = variable_buffer; 521 unsigned int olen = variable_buffer_length; 522 523 variable_buffer = 0; 524 525 val = variable_append (v->name, strlen (v->name), current_variable_set_list); 526 variable_buffer_output (val, "", 1); 527 val = variable_buffer; 528 529 variable_buffer = obuf; 530 variable_buffer_length = olen; 531 532 return val; 533} 534 535/* Like variable_expand_for_file, but the returned string is malloc'd. 536 This function is called a lot. It wants to be efficient. */ 537 538char * 539allocated_variable_expand_for_file (char *line, struct file *file) 540{ 541 char *value; 542 543 char *obuf = variable_buffer; 544 unsigned int olen = variable_buffer_length; 545 546 variable_buffer = 0; 547 548 value = variable_expand_for_file (line, file); 549 550#if 0 551 /* Waste a little memory and save time. */ 552 value = xrealloc (value, strlen (value)) 553#endif 554 555 variable_buffer = obuf; 556 variable_buffer_length = olen; 557 558 return value; 559} 560 561/* Install a new variable_buffer context, returning the current one for 562 safe-keeping. */ 563 564void 565install_variable_buffer (char **bufp, unsigned int *lenp) 566{ 567 *bufp = variable_buffer; 568 *lenp = variable_buffer_length; 569 570 variable_buffer = 0; 571 initialize_variable_output (); 572} 573 574/* Restore a previously-saved variable_buffer setting (free the current one). 575 */ 576 577void 578restore_variable_buffer (char *buf, unsigned int len) 579{ 580 free (variable_buffer); 581 582 variable_buffer = buf; 583 variable_buffer_length = len; 584} 585