1 /* Variable expansion functions for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
4 Foundation, Inc.
5 This file is part of GNU Make.
6
7 GNU Make is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 2, or (at your option) any later version.
10
11 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License along with
16 GNU Make; see the file COPYING. If not, write to the Free Software
17 Foundation, 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. */
31 const 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
47 static unsigned int variable_buffer_length;
48 char *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
57 char *
variable_buffer_output(char * ptr,char * string,unsigned int length)58 variable_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
79 static char *
initialize_variable_output(void)80 initialize_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
96 static char *allocated_variable_append PARAMS ((const struct variable *v));
97
98 char *
recursively_expand_for_file(struct variable * v,struct file * file)99 recursively_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
162 static char *
reference_variable(char * o,char * name,unsigned int length)163 reference_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
196 char *
variable_expand_string(char * line,char * string,long length)197 variable_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
415 char *
variable_expand(char * line)416 variable_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
427 char *
expand_argument(const char * str,const char * end)428 expand_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
448 char *
variable_expand_for_file(char * line,struct file * file)449 variable_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
474 static char *
variable_append(const char * name,unsigned int length,const struct variable_set_list * set)475 variable_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
513 static char *
allocated_variable_append(const struct variable * v)514 allocated_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
538 char *
allocated_variable_expand_for_file(char * line,struct file * file)539 allocated_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
564 void
install_variable_buffer(char ** bufp,unsigned int * lenp)565 install_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
577 void
restore_variable_buffer(char * buf,unsigned int len)578 restore_variable_buffer (char *buf, unsigned int len)
579 {
580 free (variable_buffer);
581
582 variable_buffer = buf;
583 variable_buffer_length = len;
584 }
585