1 /* Variable expansion functions for GNU Make.
2 Copyright (C) 1988-2013 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3 of the License, or (at your option) any later
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License along with
15 this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* Initially, any errors reported when expanding strings will be reported
28 against the file where the error appears. */
29 const gmk_floc **expanding_var = &reading_file;
31 /* The next two describe the variable output buffer.
32 This buffer is used to hold the variable-expansion of a line of the
33 makefile. It is made bigger with realloc whenever it is too small.
34 variable_buffer_length is the size currently allocated.
35 variable_buffer is the address of the buffer.
37 For efficiency, it's guaranteed that the buffer will always have
38 VARIABLE_BUFFER_ZONE extra bytes allocated. This allows you to add a few
39 extra chars without having to call a function. Note you should never use
40 these bytes unless you're _sure_ you have room (you know when the buffer
41 length was last checked. */
43 #define VARIABLE_BUFFER_ZONE 5
45 static unsigned int variable_buffer_length;
46 char *variable_buffer;
48 /* Subroutine of variable_expand and friends:
49 The text to add is LENGTH chars starting at STRING to the variable_buffer.
50 The text is added to the buffer at PTR, and the updated pointer into
51 the buffer is returned as the value. Thus, the value returned by
52 each call to variable_buffer_output should be the first argument to
53 the following call. */
56 variable_buffer_output (char *ptr, const char *string, unsigned int length)
58 register unsigned int newlen = length + (ptr - variable_buffer);
60 if ((newlen + VARIABLE_BUFFER_ZONE) > variable_buffer_length)
62 unsigned int offset = ptr - variable_buffer;
63 variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length
65 : 2 * variable_buffer_length);
66 variable_buffer = xrealloc (variable_buffer, variable_buffer_length);
67 ptr = variable_buffer + offset;
70 memcpy (ptr, string, length);
74 /* Return a pointer to the beginning of the variable buffer. */
77 initialize_variable_output (void)
79 /* If we don't have a variable output buffer yet, get one. */
81 if (variable_buffer == 0)
83 variable_buffer_length = 200;
84 variable_buffer = xmalloc (variable_buffer_length);
85 variable_buffer[0] = '\0';
88 return variable_buffer;
91 /* Recursively expand V. The returned string is malloc'd. */
93 static char *allocated_variable_append (const struct variable *v);
96 recursively_expand_for_file (struct variable *v, struct file *file)
99 const gmk_floc *this_var;
100 const gmk_floc **saved_varp;
101 struct variable_set_list *save = 0;
104 /* Don't install a new location if this location is empty.
105 This can happen for command-line variables, builtin variables, etc. */
106 saved_varp = expanding_var;
107 if (v->fileinfo.filenm)
109 this_var = &v->fileinfo;
110 expanding_var = &this_var;
113 /* If we have no other file-reading context, use the variable's context. */
117 reading_file = &v->fileinfo;
123 /* Expanding V causes infinite recursion. Lose. */
124 fatal (*expanding_var,
125 _("Recursive variable '%s' references itself (eventually)"),
132 save = current_variable_set_list;
133 current_variable_set_list = file->variables;
138 value = allocated_variable_append (v);
140 value = allocated_variable_expand (v->value);
147 current_variable_set_list = save;
149 expanding_var = saved_varp;
154 /* Expand a simple reference to variable NAME, which is LENGTH chars long. */
160 reference_variable (char *o, const char *name, unsigned int length)
165 v = lookup_variable (name, length);
168 warn_undefined (name, length);
170 /* If there's no variable by that name or it has no value, stop now. */
171 if (v == 0 || (*v->value == '\0' && !v->append))
174 value = (v->recursive ? recursively_expand (v) : v->value);
176 o = variable_buffer_output (o, value, strlen (value));
184 /* Scan STRING for variable references and expansion-function calls. Only
185 LENGTH bytes of STRING are actually scanned. If LENGTH is -1, scan until
186 a null byte is found.
188 Write the results to LINE, which must point into 'variable_buffer'. If
189 LINE is NULL, start at the beginning of the buffer.
190 Return a pointer to LINE, or to the beginning of the buffer if LINE is
194 variable_expand_string (char *line, const char *string, long length)
200 unsigned int line_offset;
203 line = initialize_variable_output ();
205 line_offset = line - variable_buffer;
209 variable_buffer_output (o, "", 1);
210 return (variable_buffer);
213 /* We need a copy of STRING: due to eval, it's possible that it will get
214 freed as we process it (it might be the value of a variable that's reset
215 for example). Also having a nil-terminated string is handy. */
216 save = length < 0 ? xstrdup (string) : xstrndup (string, length);
221 /* Copy all following uninteresting chars all at once to the
222 variable output buffer, and skip them. Uninteresting chars end
223 at the next $ or the end of the input. */
225 p1 = strchr (p, '$');
227 o = variable_buffer_output (o, p, p1 != 0 ? (unsigned int)(p1 - p) : strlen (p) + 1);
233 /* Dispatch on the char that follows the $. */
238 /* $$ seen means output one $ to the variable output buffer. */
239 o = variable_buffer_output (o, p, 1);
244 /* $(...) or ${...} is the general case of substitution. */
247 char closeparen = (openparen == '(') ? ')' : '}';
249 const char *beg = p + 1;
252 const char *end, *colon;
256 if (handle_function (&op, &begp))
263 /* Is there a variable reference inside the parens or braces?
264 If so, expand it before expanding the entire reference. */
266 end = strchr (beg, closeparen);
268 /* Unterminated variable reference. */
269 fatal (*expanding_var, _("unterminated variable reference"));
270 p1 = lindex (beg, end, '$');
273 /* BEG now points past the opening paren or brace.
274 Count parens or braces until it is matched. */
276 for (p = beg; *p != '\0'; ++p)
280 else if (*p == closeparen && --count < 0)
283 /* If COUNT is >= 0, there were unmatched opening parens
284 or braces, so we go to the simple case of a variable name
288 abeg = expand_argument (beg, p); /* Expand the name. */
290 end = strchr (beg, '\0');
294 /* Advance P to the end of this reference. After we are
295 finished expanding this one, P will be incremented to
296 continue the scan. */
299 /* This is not a reference to a built-in function and
300 any variable references inside are now expanded.
301 Is the resultant text a substitution reference? */
303 colon = lindex (beg, end, ':');
306 /* This looks like a substitution reference: $(FOO:A=B). */
307 const char *subst_beg = colon + 1;
308 const char *subst_end = lindex (subst_beg, end, '=');
310 /* There is no = in sight. Punt on the substitution
311 reference and treat this as a variable name containing
312 a colon, in the code below. */
316 const char *replace_beg = subst_end + 1;
317 const char *replace_end = end;
319 /* Extract the variable name before the colon
320 and look up that variable. */
321 v = lookup_variable (beg, colon - beg);
323 warn_undefined (beg, colon - beg);
325 /* If the variable is not empty, perform the
327 if (v != 0 && *v->value != '\0')
329 char *pattern, *replace, *ppercent, *rpercent;
330 char *value = (v->recursive
331 ? recursively_expand (v)
334 /* Copy the pattern and the replacement. Add in an
335 extra % at the beginning to use in case there
336 isn't one in the pattern. */
337 pattern = alloca (subst_end - subst_beg + 2);
339 memcpy (pattern, subst_beg, subst_end - subst_beg);
340 pattern[subst_end - subst_beg] = '\0';
342 replace = alloca (replace_end - replace_beg + 2);
344 memcpy (replace, replace_beg,
345 replace_end - replace_beg);
346 replace[replace_end - replace_beg] = '\0';
348 /* Look for %. Set the percent pointers properly
349 based on whether we find one or not. */
350 ppercent = find_percent (pattern);
354 rpercent = find_percent (replace);
366 o = patsubst_expand_pat (o, value, pattern, replace,
376 /* This is an ordinary variable reference.
377 Look up the value of the variable. */
378 o = reference_variable (o, beg, end - beg);
389 if (isblank ((unsigned char)p[-1]))
392 /* A $ followed by a random char is a variable reference:
393 $a is equivalent to $(a). */
394 o = reference_variable (o, p, 1);
407 variable_buffer_output (o, "", 1);
408 return (variable_buffer + line_offset);
411 /* Scan LINE for variable references and expansion-function calls.
412 Build in 'variable_buffer' the result of expanding the references and calls.
413 Return the address of the resulting string, which is null-terminated
414 and is valid only until the next time this function is called. */
417 variable_expand (const char *line)
419 return variable_expand_string (NULL, line, (long)-1);
422 /* Expand an argument for an expansion function.
423 The text starting at STR and ending at END is variable-expanded
424 into a null-terminated string that is returned as the value.
425 This is done without clobbering 'variable_buffer' or the current
426 variable-expansion that is in progress. */
429 expand_argument (const char *str, const char *end)
431 char *tmp, *alloc = NULL;
437 if (!end || *end == '\0')
438 return allocated_variable_expand (str);
440 if (end - str + 1 > 1000)
441 tmp = alloc = xmalloc (end - str + 1);
443 tmp = alloca (end - str + 1);
445 memcpy (tmp, str, end - str);
446 tmp[end - str] = '\0';
448 r = allocated_variable_expand (tmp);
456 /* Expand LINE for FILE. Error messages refer to the file and line where
457 FILE's commands were found. Expansion uses FILE's variable set list. */
460 variable_expand_for_file (const char *line, struct file *file)
463 struct variable_set_list *savev;
464 const gmk_floc *savef;
467 return variable_expand (line);
469 savev = current_variable_set_list;
470 current_variable_set_list = file->variables;
472 savef = reading_file;
473 if (file->cmds && file->cmds->fileinfo.filenm)
474 reading_file = &file->cmds->fileinfo;
478 result = variable_expand (line);
480 current_variable_set_list = savev;
481 reading_file = savef;
486 /* Like allocated_variable_expand, but for += target-specific variables.
487 First recursively construct the variable value from its appended parts in
488 any upper variable sets. Then expand the resulting value. */
491 variable_append (const char *name, unsigned int length,
492 const struct variable_set_list *set, int local)
494 const struct variable *v;
496 /* If this set is local and the next is not a parent, then next is local. */
497 int nextlocal = local && set->next_is_parent == 0;
499 /* If there's nothing left to check, return the empty buffer. */
501 return initialize_variable_output ();
503 /* Try to find the variable in this variable set. */
504 v = lookup_variable_in_set (name, length, set->set);
506 /* If there isn't one, or this one is private, try the set above us. */
507 if (!v || (!local && v->private_var))
508 return variable_append (name, length, set->next, nextlocal);
510 /* If this variable type is append, first get any upper values.
511 If not, initialize the buffer. */
513 buf = variable_append (name, length, set->next, nextlocal);
515 buf = initialize_variable_output ();
517 /* Append this value to the buffer, and return it.
518 If we already have a value, first add a space. */
519 if (buf > variable_buffer)
520 buf = variable_buffer_output (buf, " ", 1);
522 /* Either expand it or copy it, depending. */
524 return variable_buffer_output (buf, v->value, strlen (v->value));
526 buf = variable_expand_string (buf, v->value, strlen (v->value));
527 return (buf + strlen (buf));
532 allocated_variable_append (const struct variable *v)
536 /* Construct the appended variable value. */
538 char *obuf = variable_buffer;
539 unsigned int olen = variable_buffer_length;
543 val = variable_append (v->name, strlen (v->name),
544 current_variable_set_list, 1);
545 variable_buffer_output (val, "", 1);
546 val = variable_buffer;
548 variable_buffer = obuf;
549 variable_buffer_length = olen;
554 /* Like variable_expand_for_file, but the returned string is malloc'd.
555 This function is called a lot. It wants to be efficient. */
558 allocated_variable_expand_for_file (const char *line, struct file *file)
562 char *obuf = variable_buffer;
563 unsigned int olen = variable_buffer_length;
567 value = variable_expand_for_file (line, file);
569 variable_buffer = obuf;
570 variable_buffer_length = olen;
575 /* Install a new variable_buffer context, returning the current one for
579 install_variable_buffer (char **bufp, unsigned int *lenp)
581 *bufp = variable_buffer;
582 *lenp = variable_buffer_length;
585 initialize_variable_output ();
588 /* Restore a previously-saved variable_buffer setting (free the current one).
592 restore_variable_buffer (char *buf, unsigned int len)
594 free (variable_buffer);
596 variable_buffer = buf;
597 variable_buffer_length = len;