| /* Variable expansion functions for GNU Make. |
| Copyright (C) 1988-2016 Free Software Foundation, Inc. |
| This file is part of GNU Make. |
| |
| GNU Make is free software; you can redistribute it and/or modify it under the |
| terms of the GNU General Public License as published by the Free Software |
| Foundation; either version 3 of the License, or (at your option) any later |
| version. |
| |
| GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR |
| A PARTICULAR PURPOSE. See the GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License along with |
| this program. If not, see <http://www.gnu.org/licenses/>. */ |
| |
| #include "makeint.h" |
| |
| #include <assert.h> |
| |
| #include "filedef.h" |
| #include "job.h" |
| #include "commands.h" |
| #include "variable.h" |
| #include "rule.h" |
| |
| /* Initially, any errors reported when expanding strings will be reported |
| against the file where the error appears. */ |
| const gmk_floc **expanding_var = &reading_file; |
| |
| /* The next two describe the variable output buffer. |
| This buffer is used to hold the variable-expansion of a line of the |
| makefile. It is made bigger with realloc whenever it is too small. |
| variable_buffer_length is the size currently allocated. |
| variable_buffer is the address of the buffer. |
| |
| For efficiency, it's guaranteed that the buffer will always have |
| VARIABLE_BUFFER_ZONE extra bytes allocated. This allows you to add a few |
| extra chars without having to call a function. Note you should never use |
| these bytes unless you're _sure_ you have room (you know when the buffer |
| length was last checked. */ |
| |
| #define VARIABLE_BUFFER_ZONE 5 |
| |
| static unsigned int variable_buffer_length; |
| char *variable_buffer; |
| |
| /* Subroutine of variable_expand and friends: |
| The text to add is LENGTH chars starting at STRING to the variable_buffer. |
| The text is added to the buffer at PTR, and the updated pointer into |
| the buffer is returned as the value. Thus, the value returned by |
| each call to variable_buffer_output should be the first argument to |
| the following call. */ |
| |
| char * |
| variable_buffer_output (char *ptr, const char *string, unsigned int length) |
| { |
| register unsigned int newlen = length + (ptr - variable_buffer); |
| |
| if ((newlen + VARIABLE_BUFFER_ZONE) > variable_buffer_length) |
| { |
| unsigned int offset = ptr - variable_buffer; |
| variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length |
| ? newlen + 100 |
| : 2 * variable_buffer_length); |
| variable_buffer = xrealloc (variable_buffer, variable_buffer_length); |
| ptr = variable_buffer + offset; |
| } |
| |
| memcpy (ptr, string, length); |
| return ptr + length; |
| } |
| |
| /* Return a pointer to the beginning of the variable buffer. */ |
| |
| static char * |
| initialize_variable_output (void) |
| { |
| /* If we don't have a variable output buffer yet, get one. */ |
| |
| if (variable_buffer == 0) |
| { |
| variable_buffer_length = 200; |
| variable_buffer = xmalloc (variable_buffer_length); |
| variable_buffer[0] = '\0'; |
| } |
| |
| return variable_buffer; |
| } |
| |
| /* Recursively expand V. The returned string is malloc'd. */ |
| |
| static char *allocated_variable_append (const struct variable *v); |
| |
| char * |
| recursively_expand_for_file (struct variable *v, struct file *file) |
| { |
| char *value; |
| const gmk_floc *this_var; |
| const gmk_floc **saved_varp; |
| struct variable_set_list *save = 0; |
| int set_reading = 0; |
| |
| /* Don't install a new location if this location is empty. |
| This can happen for command-line variables, builtin variables, etc. */ |
| saved_varp = expanding_var; |
| if (v->fileinfo.filenm) |
| { |
| this_var = &v->fileinfo; |
| expanding_var = &this_var; |
| } |
| |
| /* If we have no other file-reading context, use the variable's context. */ |
| if (!reading_file) |
| { |
| set_reading = 1; |
| reading_file = &v->fileinfo; |
| } |
| |
| if (v->expanding) |
| { |
| if (!v->exp_count) |
| /* Expanding V causes infinite recursion. Lose. */ |
| OS (fatal, *expanding_var, |
| _("Recursive variable '%s' references itself (eventually)"), |
| v->name); |
| --v->exp_count; |
| } |
| |
| if (file) |
| { |
| save = current_variable_set_list; |
| current_variable_set_list = file->variables; |
| } |
| |
| v->expanding = 1; |
| if (v->append) |
| value = allocated_variable_append (v); |
| else |
| value = allocated_variable_expand (v->value); |
| v->expanding = 0; |
| |
| if (set_reading) |
| reading_file = 0; |
| |
| if (file) |
| current_variable_set_list = save; |
| |
| expanding_var = saved_varp; |
| |
| return value; |
| } |
| |
| /* Expand a simple reference to variable NAME, which is LENGTH chars long. */ |
| |
| #ifdef __GNUC__ |
| __inline |
| #endif |
| static char * |
| reference_variable (char *o, const char *name, unsigned int length) |
| { |
| struct variable *v; |
| char *value; |
| |
| v = lookup_variable (name, length); |
| |
| if (v == 0) |
| warn_undefined (name, length); |
| |
| /* If there's no variable by that name or it has no value, stop now. */ |
| if (v == 0 || (*v->value == '\0' && !v->append)) |
| return o; |
| |
| value = (v->recursive ? recursively_expand (v) : v->value); |
| |
| o = variable_buffer_output (o, value, strlen (value)); |
| |
| if (v->recursive) |
| free (value); |
| |
| return o; |
| } |
| |
| /* Scan STRING for variable references and expansion-function calls. Only |
| LENGTH bytes of STRING are actually scanned. If LENGTH is -1, scan until |
| a null byte is found. |
| |
| Write the results to LINE, which must point into 'variable_buffer'. If |
| LINE is NULL, start at the beginning of the buffer. |
| Return a pointer to LINE, or to the beginning of the buffer if LINE is |
| NULL. |
| */ |
| char * |
| variable_expand_string (char *line, const char *string, long length) |
| { |
| struct variable *v; |
| const char *p, *p1; |
| char *save; |
| char *o; |
| unsigned int line_offset; |
| |
| if (!line) |
| line = initialize_variable_output (); |
| o = line; |
| line_offset = line - variable_buffer; |
| |
| if (length == 0) |
| { |
| variable_buffer_output (o, "", 1); |
| return (variable_buffer); |
| } |
| |
| /* We need a copy of STRING: due to eval, it's possible that it will get |
| freed as we process it (it might be the value of a variable that's reset |
| for example). Also having a nil-terminated string is handy. */ |
| save = length < 0 ? xstrdup (string) : xstrndup (string, length); |
| p = save; |
| |
| while (1) |
| { |
| /* Copy all following uninteresting chars all at once to the |
| variable output buffer, and skip them. Uninteresting chars end |
| at the next $ or the end of the input. */ |
| |
| p1 = strchr (p, '$'); |
| |
| o = variable_buffer_output (o, p, p1 != 0 ? (unsigned int)(p1 - p) : strlen (p) + 1); |
| |
| if (p1 == 0) |
| break; |
| p = p1 + 1; |
| |
| /* Dispatch on the char that follows the $. */ |
| |
| switch (*p) |
| { |
| case '$': |
| case '\0': |
| /* $$ or $ at the end of the string means output one $ to the |
| variable output buffer. */ |
| o = variable_buffer_output (o, p1, 1); |
| break; |
| |
| case '(': |
| case '{': |
| /* $(...) or ${...} is the general case of substitution. */ |
| { |
| char openparen = *p; |
| char closeparen = (openparen == '(') ? ')' : '}'; |
| const char *begp; |
| const char *beg = p + 1; |
| char *op; |
| char *abeg = NULL; |
| const char *end, *colon; |
| |
| op = o; |
| begp = p; |
| if (handle_function (&op, &begp)) |
| { |
| o = op; |
| p = begp; |
| break; |
| } |
| |
| /* Is there a variable reference inside the parens or braces? |
| If so, expand it before expanding the entire reference. */ |
| |
| end = strchr (beg, closeparen); |
| if (end == 0) |
| /* Unterminated variable reference. */ |
| O (fatal, *expanding_var, _("unterminated variable reference")); |
| p1 = lindex (beg, end, '$'); |
| if (p1 != 0) |
| { |
| /* BEG now points past the opening paren or brace. |
| Count parens or braces until it is matched. */ |
| int count = 0; |
| for (p = beg; *p != '\0'; ++p) |
| { |
| if (*p == openparen) |
| ++count; |
| else if (*p == closeparen && --count < 0) |
| break; |
| } |
| /* If COUNT is >= 0, there were unmatched opening parens |
| or braces, so we go to the simple case of a variable name |
| such as '$($(a)'. */ |
| if (count < 0) |
| { |
| abeg = expand_argument (beg, p); /* Expand the name. */ |
| beg = abeg; |
| end = strchr (beg, '\0'); |
| } |
| } |
| else |
| /* Advance P to the end of this reference. After we are |
| finished expanding this one, P will be incremented to |
| continue the scan. */ |
| p = end; |
| |
| /* This is not a reference to a built-in function and |
| any variable references inside are now expanded. |
| Is the resultant text a substitution reference? */ |
| |
| colon = lindex (beg, end, ':'); |
| if (colon) |
| { |
| /* This looks like a substitution reference: $(FOO:A=B). */ |
| const char *subst_beg = colon + 1; |
| const char *subst_end = lindex (subst_beg, end, '='); |
| if (subst_end == 0) |
| /* There is no = in sight. Punt on the substitution |
| reference and treat this as a variable name containing |
| a colon, in the code below. */ |
| colon = 0; |
| else |
| { |
| const char *replace_beg = subst_end + 1; |
| const char *replace_end = end; |
| |
| /* Extract the variable name before the colon |
| and look up that variable. */ |
| v = lookup_variable (beg, colon - beg); |
| if (v == 0) |
| warn_undefined (beg, colon - beg); |
| |
| /* If the variable is not empty, perform the |
| substitution. */ |
| if (v != 0 && *v->value != '\0') |
| { |
| char *pattern, *replace, *ppercent, *rpercent; |
| char *value = (v->recursive |
| ? recursively_expand (v) |
| : v->value); |
| |
| /* Copy the pattern and the replacement. Add in an |
| extra % at the beginning to use in case there |
| isn't one in the pattern. */ |
| pattern = alloca (subst_end - subst_beg + 2); |
| *(pattern++) = '%'; |
| memcpy (pattern, subst_beg, subst_end - subst_beg); |
| pattern[subst_end - subst_beg] = '\0'; |
| |
| replace = alloca (replace_end - replace_beg + 2); |
| *(replace++) = '%'; |
| memcpy (replace, replace_beg, |
| replace_end - replace_beg); |
| replace[replace_end - replace_beg] = '\0'; |
| |
| /* Look for %. Set the percent pointers properly |
| based on whether we find one or not. */ |
| ppercent = find_percent (pattern); |
| if (ppercent) |
| { |
| ++ppercent; |
| rpercent = find_percent (replace); |
| if (rpercent) |
| ++rpercent; |
| } |
| else |
| { |
| ppercent = pattern; |
| rpercent = replace; |
| --pattern; |
| --replace; |
| } |
| |
| o = patsubst_expand_pat (o, value, pattern, replace, |
| ppercent, rpercent); |
| |
| if (v->recursive) |
| free (value); |
| } |
| } |
| } |
| |
| if (colon == 0) |
| /* This is an ordinary variable reference. |
| Look up the value of the variable. */ |
| o = reference_variable (o, beg, end - beg); |
| |
| free (abeg); |
| } |
| break; |
| |
| default: |
| if (ISSPACE (p[-1])) |
| break; |
| |
| /* A $ followed by a random char is a variable reference: |
| $a is equivalent to $(a). */ |
| o = reference_variable (o, p, 1); |
| |
| break; |
| } |
| |
| if (*p == '\0') |
| break; |
| |
| ++p; |
| } |
| |
| free (save); |
| |
| variable_buffer_output (o, "", 1); |
| return (variable_buffer + line_offset); |
| } |
| |
| /* Scan LINE for variable references and expansion-function calls. |
| Build in 'variable_buffer' the result of expanding the references and calls. |
| Return the address of the resulting string, which is null-terminated |
| and is valid only until the next time this function is called. */ |
| |
| char * |
| variable_expand (const char *line) |
| { |
| return variable_expand_string (NULL, line, (long)-1); |
| } |
| |
| /* Expand an argument for an expansion function. |
| The text starting at STR and ending at END is variable-expanded |
| into a null-terminated string that is returned as the value. |
| This is done without clobbering 'variable_buffer' or the current |
| variable-expansion that is in progress. */ |
| |
| char * |
| expand_argument (const char *str, const char *end) |
| { |
| char *tmp, *alloc = NULL; |
| char *r; |
| |
| if (str == end) |
| return xstrdup (""); |
| |
| if (!end || *end == '\0') |
| return allocated_variable_expand (str); |
| |
| if (end - str + 1 > 1000) |
| tmp = alloc = xmalloc (end - str + 1); |
| else |
| tmp = alloca (end - str + 1); |
| |
| memcpy (tmp, str, end - str); |
| tmp[end - str] = '\0'; |
| |
| r = allocated_variable_expand (tmp); |
| |
| free (alloc); |
| |
| return r; |
| } |
| |
| /* Expand LINE for FILE. Error messages refer to the file and line where |
| FILE's commands were found. Expansion uses FILE's variable set list. */ |
| |
| char * |
| variable_expand_for_file (const char *line, struct file *file) |
| { |
| char *result; |
| struct variable_set_list *savev; |
| const gmk_floc *savef; |
| |
| if (file == 0) |
| return variable_expand (line); |
| |
| savev = current_variable_set_list; |
| current_variable_set_list = file->variables; |
| |
| savef = reading_file; |
| if (file->cmds && file->cmds->fileinfo.filenm) |
| reading_file = &file->cmds->fileinfo; |
| else |
| reading_file = 0; |
| |
| result = variable_expand (line); |
| |
| current_variable_set_list = savev; |
| reading_file = savef; |
| |
| return result; |
| } |
| |
| /* Like allocated_variable_expand, but for += target-specific variables. |
| First recursively construct the variable value from its appended parts in |
| any upper variable sets. Then expand the resulting value. */ |
| |
| static char * |
| variable_append (const char *name, unsigned int length, |
| const struct variable_set_list *set, int local) |
| { |
| const struct variable *v; |
| char *buf = 0; |
| /* If this set is local and the next is not a parent, then next is local. */ |
| int nextlocal = local && set->next_is_parent == 0; |
| |
| /* If there's nothing left to check, return the empty buffer. */ |
| if (!set) |
| return initialize_variable_output (); |
| |
| /* Try to find the variable in this variable set. */ |
| v = lookup_variable_in_set (name, length, set->set); |
| |
| /* If there isn't one, or this one is private, try the set above us. */ |
| if (!v || (!local && v->private_var)) |
| return variable_append (name, length, set->next, nextlocal); |
| |
| /* If this variable type is append, first get any upper values. |
| If not, initialize the buffer. */ |
| if (v->append) |
| buf = variable_append (name, length, set->next, nextlocal); |
| else |
| buf = initialize_variable_output (); |
| |
| /* Append this value to the buffer, and return it. |
| If we already have a value, first add a space. */ |
| if (buf > variable_buffer) |
| buf = variable_buffer_output (buf, " ", 1); |
| |
| /* Either expand it or copy it, depending. */ |
| if (! v->recursive) |
| return variable_buffer_output (buf, v->value, strlen (v->value)); |
| |
| buf = variable_expand_string (buf, v->value, strlen (v->value)); |
| return (buf + strlen (buf)); |
| } |
| |
| |
| static char * |
| allocated_variable_append (const struct variable *v) |
| { |
| char *val; |
| |
| /* Construct the appended variable value. */ |
| |
| char *obuf = variable_buffer; |
| unsigned int olen = variable_buffer_length; |
| |
| variable_buffer = 0; |
| |
| val = variable_append (v->name, strlen (v->name), |
| current_variable_set_list, 1); |
| variable_buffer_output (val, "", 1); |
| val = variable_buffer; |
| |
| variable_buffer = obuf; |
| variable_buffer_length = olen; |
| |
| return val; |
| } |
| |
| /* Like variable_expand_for_file, but the returned string is malloc'd. |
| This function is called a lot. It wants to be efficient. */ |
| |
| char * |
| allocated_variable_expand_for_file (const char *line, struct file *file) |
| { |
| char *value; |
| |
| char *obuf = variable_buffer; |
| unsigned int olen = variable_buffer_length; |
| |
| variable_buffer = 0; |
| |
| value = variable_expand_for_file (line, file); |
| |
| variable_buffer = obuf; |
| variable_buffer_length = olen; |
| |
| return value; |
| } |
| |
| /* Install a new variable_buffer context, returning the current one for |
| safe-keeping. */ |
| |
| void |
| install_variable_buffer (char **bufp, unsigned int *lenp) |
| { |
| *bufp = variable_buffer; |
| *lenp = variable_buffer_length; |
| |
| variable_buffer = 0; |
| initialize_variable_output (); |
| } |
| |
| /* Restore a previously-saved variable_buffer setting (free the current one). |
| */ |
| |
| void |
| restore_variable_buffer (char *buf, unsigned int len) |
| { |
| free (variable_buffer); |
| |
| variable_buffer = buf; |
| variable_buffer_length = len; |
| } |
