mirror of
https://git.savannah.gnu.org/git/make.git
synced 2024-11-25 12:37:04 +00:00
342 lines
8.5 KiB
C
342 lines
8.5 KiB
C
/* Variable expansion functions for GNU Make.
|
||
Copyright (C) 1988, 1989, 1991 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 2, 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 GNU Make; see the file COPYING. If not, write to
|
||
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||
|
||
#include "make.h"
|
||
#include "commands.h"
|
||
#include "file.h"
|
||
#include "variable.h"
|
||
|
||
|
||
/* Recursively expand V. The returned string is malloc'd. */
|
||
|
||
static char *
|
||
recursively_expand (v)
|
||
register struct variable *v;
|
||
{
|
||
char *value;
|
||
|
||
if (v->expanding)
|
||
{
|
||
/* Expanding V causes infinite recursion. Lose. */
|
||
if (reading_filename == 0)
|
||
fatal ("Recursive variable `%s' references itself (eventually)",
|
||
v->name);
|
||
else
|
||
makefile_fatal
|
||
(reading_filename, *reading_lineno_ptr,
|
||
"Recursive variable `%s' references itself (eventually)",
|
||
v->name);
|
||
}
|
||
|
||
v->expanding = 1;
|
||
value = allocated_variable_expand (v->value);
|
||
v->expanding = 0;
|
||
|
||
return value;
|
||
}
|
||
|
||
/* 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 (line)
|
||
register char *line;
|
||
{
|
||
register struct variable *v;
|
||
register char *p, *o, *p1;
|
||
|
||
p = line;
|
||
o = initialize_variable_output ();
|
||
|
||
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 = index (p, '$');
|
||
|
||
o = variable_buffer_output (o, p, p1 != 0 ? p1 - p : strlen (p) + 1);
|
||
|
||
if (p1 == 0)
|
||
break;
|
||
p = p1 + 1;
|
||
|
||
/* Dispatch on the char that follows the $. */
|
||
|
||
switch (*p)
|
||
{
|
||
case '$':
|
||
/* $$ seen means output one $ to the variable output buffer. */
|
||
o = variable_buffer_output (o, p, 1);
|
||
break;
|
||
|
||
case '(':
|
||
case '{':
|
||
/* $(...) or ${...} is the general case of substitution. */
|
||
{
|
||
char openparen = *p;
|
||
char closeparen = (openparen == '(') ? ')' : '}';
|
||
register char *beg = p + 1;
|
||
char *op, *begp;
|
||
char *end;
|
||
|
||
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. */
|
||
|
||
p1 = index (beg, closeparen);
|
||
if (p1 != 0)
|
||
p1 = lindex (beg, p1, '$');
|
||
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)
|
||
{
|
||
char *name = expand_argument (beg, p);
|
||
static char start[3] = { '$', }, end[2];
|
||
start[1] = openparen;
|
||
end[0] = closeparen;
|
||
p1 = concat (start, name, end);
|
||
free (name);
|
||
name = allocated_variable_expand (p1);
|
||
o = variable_buffer_output (o, name, strlen (name));
|
||
free (name);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* This is not a reference to a built-in function and
|
||
it does not contain any variable references inside.
|
||
There are several things it could be. */
|
||
|
||
p = index (beg, ':');
|
||
if (p != 0 && lindex (beg, p, closeparen) == 0)
|
||
{
|
||
/* This is a substitution reference: $(FOO:A=B). */
|
||
int count;
|
||
char *subst_beg, *replace_beg;
|
||
unsigned int subst_len, replace_len;
|
||
|
||
v = lookup_variable (beg, p - beg);
|
||
|
||
subst_beg = p + 1;
|
||
count = 0;
|
||
for (p = subst_beg; *p != '\0'; ++p)
|
||
{
|
||
if (*p == openparen)
|
||
++count;
|
||
else if (*p == closeparen)
|
||
--count;
|
||
else if (*p == '=' && count <= 0)
|
||
break;
|
||
}
|
||
if (count > 0)
|
||
/* There were unmatched opening parens. */
|
||
return initialize_variable_output ();
|
||
subst_len = p - subst_beg;
|
||
|
||
replace_beg = p + 1;
|
||
count = 0;
|
||
for (p = replace_beg; *p != '\0'; ++p)
|
||
{
|
||
if (*p == openparen)
|
||
++count;
|
||
else if (*p == closeparen && --count < 0)
|
||
break;
|
||
}
|
||
if (count > 0)
|
||
/* There were unmatched opening parens. */
|
||
return initialize_variable_output ();
|
||
end = p;
|
||
replace_len = p - replace_beg;
|
||
|
||
if (v != 0 && *v->value != '\0')
|
||
{
|
||
char *value = (v->recursive ? recursively_expand (v)
|
||
: v->value);
|
||
if (lindex (subst_beg, subst_beg + subst_len, '%') != 0)
|
||
{
|
||
p = savestring (subst_beg, subst_len);
|
||
p1 = savestring (replace_beg, replace_len);
|
||
o = patsubst_expand (o, value, p, p1,
|
||
index (p, '%'), index (p1, '%'));
|
||
free (p);
|
||
free (p1);
|
||
}
|
||
else
|
||
o = subst_expand (o, value, subst_beg, replace_beg,
|
||
subst_len, replace_len, 0, 1);
|
||
if (v->recursive)
|
||
free (value);
|
||
}
|
||
}
|
||
|
||
/* No, this must be an ordinary variable reference. */
|
||
else
|
||
{
|
||
/* Look up the value of the variable. */
|
||
end = index (beg, closeparen);
|
||
if (end == 0)
|
||
return initialize_variable_output ();
|
||
v = lookup_variable (beg, end - beg);
|
||
|
||
if (v != 0 && *v->value != '\0')
|
||
{
|
||
char *value = (v->recursive ? recursively_expand (v)
|
||
: v->value);
|
||
o = variable_buffer_output (o, value, strlen (value));
|
||
if (v->recursive)
|
||
free (value);
|
||
}
|
||
}
|
||
|
||
/* Advance p past the variable reference to resume scan. */
|
||
p = end;
|
||
}
|
||
break;
|
||
|
||
case '\0':
|
||
break;
|
||
|
||
default:
|
||
if (isblank (p[-1]))
|
||
break;
|
||
|
||
/* A $ followed by a random char is a variable reference:
|
||
$a is equivalent to $(a). */
|
||
{
|
||
/* We could do the expanding here, but this way
|
||
avoids code repetition at a small performance cost. */
|
||
char name[5];
|
||
name[0] = '$';
|
||
name[1] = '(';
|
||
name[2] = *p;
|
||
name[3] = ')';
|
||
name[4] = '\0';
|
||
p1 = allocated_variable_expand (name);
|
||
o = variable_buffer_output (o, p1, strlen (p1));
|
||
free (p1);
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
if (*p == '\0')
|
||
break;
|
||
else
|
||
++p;
|
||
}
|
||
|
||
(void) variable_buffer_output (o, "", 1);
|
||
return initialize_variable_output ();
|
||
}
|
||
|
||
/* 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 (str, end)
|
||
char *str, *end;
|
||
{
|
||
char *tmp = savestring (str, end - str);
|
||
char *value = allocated_variable_expand (tmp);
|
||
|
||
free (tmp);
|
||
|
||
return value;
|
||
}
|
||
|
||
/* 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 (line, file)
|
||
char *line;
|
||
register struct file *file;
|
||
{
|
||
char *result;
|
||
struct variable_set_list *save;
|
||
|
||
if (file == 0)
|
||
return variable_expand (line);
|
||
|
||
save = current_variable_set_list;
|
||
current_variable_set_list = file->variables;
|
||
reading_filename = file->cmds->filename;
|
||
reading_lineno_ptr = &file->cmds->lineno;
|
||
result = variable_expand (line);
|
||
current_variable_set_list = save;
|
||
reading_filename = 0;
|
||
reading_lineno_ptr = 0;
|
||
|
||
return result;
|
||
}
|
||
|
||
/* Like variable_expand, but the returned string is malloc'd. */
|
||
char *
|
||
allocated_variable_expand (line)
|
||
char *line;
|
||
{
|
||
return allocated_variable_expand_for_file (line, (struct file *) 0);
|
||
}
|
||
|
||
/* Like variable_expand_for_file, but the returned string is malloc'd. */
|
||
|
||
char *
|
||
allocated_variable_expand_for_file (line, file)
|
||
char *line;
|
||
struct file *file;
|
||
{
|
||
char *save;
|
||
char *value;
|
||
|
||
save = save_variable_output ();
|
||
|
||
value = variable_expand_for_file (line, file);
|
||
value = savestring (value, strlen (value));
|
||
|
||
restore_variable_output (save);
|
||
|
||
return value;
|
||
}
|