1/* Variable expansion functions for GNU Make. 2Copyright (C) 1988, 89, 91, 92, 93, 95 Free Software Foundation, Inc. 3This file is part of GNU Make. 4 5GNU Make is free software; you can redistribute it and/or modify 6it under the terms of the GNU General Public License as published by 7the Free Software Foundation; either version 2, or (at your option) 8any later version. 9 10GNU Make is distributed in the hope that it will be useful, 11but WITHOUT ANY WARRANTY; without even the implied warranty of 12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13GNU General Public License for more details. 14 15You should have received a copy of the GNU General Public License 16along with GNU Make; see the file COPYING. If not, write to 17the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 18Boston, 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 44static unsigned int variable_buffer_length; 45char *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 54char * 55variable_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 78static char * 79initialize_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 93/* Recursively expand V. The returned string is malloc'd. */ 94 95static char *allocated_variable_append PARAMS ((const struct variable *v)); 96 97char * 98recursively_expand_for_file (v, file) 99 struct variable *v; 100 struct file *file; 101{ 102 char *value; 103 struct variable_set_list *save = 0; 104 105 if (v->expanding) 106 { 107 if (!v->exp_count) 108 /* Expanding V causes infinite recursion. Lose. */ 109 fatal (reading_file, 110 _("Recursive variable `%s' references itself (eventually)"), 111 v->name); 112 --v->exp_count; 113 } 114 115 if (file) 116 { 117 save = current_variable_set_list; 118 current_variable_set_list = file->variables; 119 } 120 121 v->expanding = 1; 122 if (v->append) 123 value = allocated_variable_append (v); 124 else 125 value = allocated_variable_expand (v->value); 126 v->expanding = 0; 127 128 if (file) 129 current_variable_set_list = save; 130 131 return value; 132} 133 134/* Expand a simple reference to variable NAME, which is LENGTH chars long. */ 135 136#ifdef __GNUC__ 137__inline 138#endif 139static char * 140reference_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 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 175char * 176variable_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) 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 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 411char * 412variable_expand (line) 413 char *line; 414{ 415 return variable_expand_string(NULL, line, (long)-1); 416} 417 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 424char * 425expand_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 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 448static char * 449variable_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 472/* Like allocated_variable_expand, but for += target-specific variables. 473 First recursively construct the variable value from its appended parts in 474 any upper variable sets. Then expand the resulting value. */ 475 476static char * 477variable_append (name, length, set) 478 const char *name; 479 unsigned int length; 480 const struct variable_set_list *set; 481{ 482 const struct variable *v; 483 char *buf = 0; 484 485 /* If there's nothing left to check, return the empty buffer. */ 486 if (!set) 487 return initialize_variable_output (); 488 489 /* Try to find the variable in this variable set. */ 490 v = lookup_variable_in_set (name, length, set->set); 491 492 /* If there isn't one, look to see if there's one in a set above us. */ 493 if (!v) 494 return variable_append (name, length, set->next); 495 496 /* If this variable type is append, first get any upper values. 497 If not, initialize the buffer. */ 498 if (v->append) 499 buf = variable_append (name, length, set->next); 500 else 501 buf = initialize_variable_output (); 502 503 /* Append this value to the buffer, and return it. 504 If we already have a value, first add a space. */ 505 if (buf > variable_buffer) 506 buf = variable_buffer_output (buf, " ", 1); 507 508 return variable_buffer_output (buf, v->value, strlen (v->value)); 509} 510 511 512static char * 513allocated_variable_append (v) 514 const struct variable *v; 515{ 516 char *val, *retval; 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 /* Now expand it and return that. */ 533 534 retval = allocated_variable_expand (val); 535 536 free (val); 537 return retval; 538} 539 540/* Like variable_expand_for_file, but the returned string is malloc'd. 541 This function is called a lot. It wants to be efficient. */ 542 543char * 544allocated_variable_expand_for_file (line, file) 545 char *line; 546 struct file *file; 547{ 548 char *value; 549 550 char *obuf = variable_buffer; 551 unsigned int olen = variable_buffer_length; 552 553 variable_buffer = 0; 554 555 value = variable_expand_for_file (line, file); 556 557#if 0 558 /* Waste a little memory and save time. */ 559 value = xrealloc (value, strlen (value)) 560#endif 561 562 variable_buffer = obuf; 563 variable_buffer_length = olen; 564 565 return value; 566} 567