+2001-01-17 Paul D. Smith <psmith@gnu.org>
+
+ * variable.c (lookup_variable) [VMS]: When getting values from the
+ environment, allocate enough space for the _value_ plus escapes,
+ not enough space for the name plus escapes :-/.
+ Reported by John Fowler <jfowler@nyx.net>.
+
+ * remake.c (f_mtime): Removed the "***" prefix from the mod time
+ warnings that make generates, so it doesn't look like an error.
+ Reported by Karl Berry <karl@gnu.org>.
+
+
+ Fix for PR/2020: Rework appended target-specific variables. I'm
+ fairly confident this algorithm is finally correct.
+
+ * expand.c (allocated_variable_append): Rewrite. Instead of
+ expanding each appended variable then adding all the expanded
+ strings together, we append all the unexpanded values going up
+ through the variable set contexts, then expand the final result.
+ This behaves just like non-target-specific appended variable
+ values, while the old way didn't in various corner cases.
+ (variable_append): New function: recursively append the unexpanded
+ value of a variable, walking from the outermost variable scope to
+ the innermost.
+ * variable.c (lookup_variable): Remove the code that looked up the
+ variable set list if the found variable was "append". We don't
+ need this anymore.
+ (lookup_variable_in_set): Make this non-static so we can use it
+ elsewhere.
+ (try_variable_definition): Use lookup_variable_in_set() rather
+ than faking out current_variable_set_list by hand (cleanup).
+ * variable.h: Add a prototype for the now non-static
+ lookup_variable_in_set().
+
2000-11-17 Paul D. Smith <psmith@gnu.org>
* remake.c (f_mtime) [WINDOWS32]: On various advice, I changed the
the need for len or lastlen at all. Problem description with
sample code chages provided by Chris Faylor <cgf@redhat.com>.
+2000-10-24 Paul D. Smith <psmith@gnu.org>
+
+ * gettext.c (SWAP): Declare this with the prototype, otherwise
+ some systems don't work (non-32-bit? Reported for Cray T3E).
+ Reported by Thorstein Thorsteinsson <thor@signe.teokem.lu.se>.
+
2000-10-05 Paul D. Smith <psmith@gnu.org>
* acinclude.m4 (AM_LC_MESSAGES): Remove undefined macro
set make=gnumake\r
++if not exist config.h copy config.h.W32 config.h\r
cd w32\subproc\r
echo "Creating the subproc library"\r
%ComSpec% /c build.bat\r
\f
/* Recursively expand V. The returned string is malloc'd. */
-static char *allocated_variable_append PARAMS ((struct variable *v));
+static char *allocated_variable_append PARAMS ((const struct variable *v));
char *
recursively_expand (v)
return result;
}
\f
-/* Like allocated_variable_expand, but we first expand this variable in the
- context of the next variable set, then we append the expanded value. */
+/* 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 *
-allocated_variable_append (v)
- struct variable *v;
+variable_append (name, length, set)
+ const char *name;
+ unsigned int length;
+ const struct variable_set_list *set;
{
- struct variable_set_list *save;
- int len = strlen (v->name);
- char *var = alloca (len + 4);
- char *value;
+ const struct variable *v;
+ char *buf = 0;
- char *obuf = variable_buffer;
- unsigned int olen = variable_buffer_length;
+ /* If there's nothing left to check, return the empty buffer. */
+ if (!set)
+ return initialize_variable_output ();
- variable_buffer = 0;
+ /* Try to find the variable in this variable set. */
+ v = lookup_variable_in_set (name, length, set->set);
- assert(current_variable_set_list->next != 0);
- save = current_variable_set_list;
- current_variable_set_list = current_variable_set_list->next;
+ /* If there isn't one, look to see if there's one in a set above us. */
+ if (!v)
+ return variable_append (name, length, set->next);
- var[0] = '$';
- var[1] = '(';
- strcpy (&var[2], v->name);
- var[len+2] = ')';
- var[len+3] = '\0';
+ /* 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);
+ else
+ buf = initialize_variable_output ();
- value = variable_expand_for_file (var, 0);
+ /* 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);
- current_variable_set_list = save;
+ return variable_buffer_output (buf, v->value, strlen (v->value));
+}
+
+
+static char *
+allocated_variable_append (v)
+ const struct variable *v;
+{
+ char *val, *retval;
- value += strlen (value);
- value = variable_buffer_output (value, " ", 1);
- value = variable_expand_string (value, v->value, (long)-1);
+ /* Construct the appended variable value. */
- value = variable_buffer;
+ char *obuf = variable_buffer;
+ unsigned int olen = variable_buffer_length;
-#if 0
- /* Waste a little memory and save time. */
- value = xrealloc (value, strlen (value))
-#endif
+ variable_buffer = 0;
+
+ val = variable_append (v->name, strlen (v->name), current_variable_set_list);
+ variable_buffer_output (val, "", 1);
+ val = variable_buffer;
variable_buffer = obuf;
variable_buffer_length = olen;
- return value;
+ /* Now expand it and return that. */
+
+ retval = allocated_variable_expand (val);
+
+ free (val);
+ return retval;
}
/* Like variable_expand_for_file, but the returned string is malloc'd.
#else
static nls_uint32 SWAP PARAMS ((nls_uint32 i));
+/* Apparently on some (non-32-bit?) systems it's important to use the right
+ prototype. Reported for a CRAY T3E. */
static inline nls_uint32
-SWAP (i)
- nls_uint32 i;
+#if __STDC__
+ SWAP (nls_uint32 i)
+#else
+ SWAP (i) nls_uint32 i;
+#endif
{
return (i << 24) | ((i & 0xff00) << 8) | ((i >> 8) & 0xff00) | (i >> 24);
}
-\input texinfo @c -*- Texinfo -*-
+input texinfo @c -*- Texinfo -*-
@c %**start of header
@setfilename make.info
@settitle GNU @code{make}
date. Unfortunately, these hosts provide no way to set a high
resolution file time stamp, so commands like @samp{cp -p} that
explicitly set a file's time stamp must discard its subsecond part. If
-a file is created by such a command, you should list it as a dependency
-of @code{.LOW_RESOLUTION_TIME} so that @command{make} does not
-mistakenly conclude that the file is out of date. For example:
+a file is created by such a command, you should list it as a
+prerequisite of @code{.LOW_RESOLUTION_TIME} so that @command{make} does
+not mistakenly conclude that the file is out of date. For example:
@example
@group
Due to a limitation of the archive format, archive member time stamps
are always low resolution. You need not list archive members as
-dependencies of @code{.LOW_RESOLUTION_TIME}, as @command{make} does this
+prerequisites of @code{.LOW_RESOLUTION_TIME}, as @command{make} does this
automatically.
@findex .SILENT
Here is the syntax of a static pattern rule:
@example
-@var{targets} @dots{}: @var{target-pattern}: @var{dep-patterns} @dots{}
+@var{targets} @dots{}: @var{target-pattern}: @var{prereq-patterns} @dots{}
@var{commands}
@dots{}
@end example
@cindex target pattern, static (not implicit)
@cindex stem
-The @var{target-pattern} and @var{dep-patterns} say how to compute the
+The @var{target-pattern} and @var{prereq-patterns} say how to compute the
prerequisites of each target. Each target is matched against the
@var{target-pattern} to extract a part of the target name, called the
-@dfn{stem}. This stem is substituted into each of the @var{dep-patterns}
-to make the prerequisite names (one from each @var{dep-pattern}).
+@dfn{stem}. This stem is substituted into each of the @var{prereq-patterns}
+to make the prerequisite names (one from each @var{prereq-pattern}).
Each pattern normally contains the character @samp{%} just once. When the
@var{target-pattern} matches a target, the @samp{%} can match any part of
ordinary rules when the same target appears in more than one rule.
When a target appears in multiple rules, all the rules must be the same
-type: all ordinary, or all double-colon. If they are double-colon, each of
-them is independent of the others. Each double-colon rule's commands are
-executed if the target is older than any prerequisites of that rule. This
-can result in executing none, any, or all of the double-colon rules.
+type: all ordinary, or all double-colon. If they are double-colon, each
+of them is independent of the others. Each double-colon rule's commands
+are executed if the target is older than any prerequisites of that rule.
+If there are no prerequisites for that rule, its commands are always
+executed (even if the target already exists). This can result in
+executing none, any, or all of the double-colon rules.
Double-colon rules with the same target are in fact completely separate
from one another. Each double-colon rule is processed individually, just
@var{pattern} may contain a @samp{%} which acts as a wildcard,
matching any number of any characters within a word. If
@var{replacement} also contains a @samp{%}, the @samp{%} is replaced
-by the text that matched the @samp{%} in @var{pattern}.@refill
+by the text that matched the @samp{%} in @var{pattern}. Only the first
+@samp{%} in the @var{pattern} and @var{replacement} is treated this
+way; any subsequent @samp{%} is unchanged.@refill
@cindex @code{%}, quoting in @code{patsubst}
@cindex @code{%}, quoting with @code{\} (backslash)
semi-obsolete in GNU @code{make} since the functions @code{dir} and
@code{notdir} can be used to get a similar effect (@pxref{File Name
Functions, , Functions for File Names}). Note, however, that the
-@samp{F} variants all omit the trailing slash which always appears in
+@samp{D} variants all omit the trailing slash which always appears in
the output of the @code{dir} function. Here is a table of the variants:
@table @samp
if (adjusted_now < adjusted_mtime)
{
#ifdef NO_FLOAT
- error (NILF, _("*** Warning: File `%s' has modification time in the future"),
+ error (NILF, _("Warning: File `%s' has modification time in the future"),
file->name);
#else
double from_now =
(FILE_TIMESTAMP_S (mtime) - FILE_TIMESTAMP_S (now)
+ ((FILE_TIMESTAMP_NS (mtime) - FILE_TIMESTAMP_NS (now))
/ 1e9));
- error (NILF, _("*** Warning: File `%s' has modification time %.2g s in the future"),
+ error (NILF, _("Warning: File `%s' has modification time %.2g s in the future"),
file->name, from_now);
#endif
clock_skew_detected = 1;
$answer = "; ok\n";
&compare_output($answer, &get_logfile(1));
+# Test #12
+# PR/2020: More hassles with += target-specific vars. I _really_ think
+# I nailed it this time :-/.
+
+$makefile5 = &get_tmpfile;
+
+open(MAKEFILE, "> $makefile5");
+print MAKEFILE <<'EOF';
+.PHONY: a
+
+BLAH := foo
+COMMAND = echo $(BLAH)
+
+a: ; @$(COMMAND)
+
+a: BLAH := bar
+a: COMMAND += snafu $(BLAH)
+EOF
+close(MAKEFILE);
+
+&run_make_with_options("$makefile5", "", &get_logfile);
+$answer = "bar snafu bar\n";
+&compare_output($answer, &get_logfile(1));
+
1;
static struct variable_set_list global_setlist
= { 0, &global_variable_set };
struct variable_set_list *current_variable_set_list = &global_setlist;
-
-static struct variable *lookup_variable_in_set PARAMS ((char *name,
- unsigned int length, struct variable_set *set));
\f
/* Implement variables. */
/* Lookup a variable whose name is a string starting at NAME
and with LENGTH chars. NAME need not be null-terminated.
Returns address of the `struct variable' containing all info
- on the variable, or nil if no such variable is defined.
-
- If we find a variable which is in the process of being expanded,
- try to find one further up the set_list chain. If we don't find
- one that isn't being expanded, return a pointer to whatever we
- _did_ find. */
+ on the variable, or nil if no such variable is defined. */
struct variable *
lookup_variable (name, length)
- char *name;
+ const char *name;
unsigned int length;
{
- register struct variable_set_list *setlist;
- struct variable *firstv = 0;
+ const struct variable_set_list *setlist;
- register unsigned int i;
- register unsigned int rawhash = 0;
+ unsigned int i;
+ unsigned int rawhash = 0;
for (i = 0; i < length; ++i)
HASH (rawhash, name[i]);
for (setlist = current_variable_set_list;
setlist != 0; setlist = setlist->next)
{
- register struct variable_set *set = setlist->set;
- register unsigned int hashval = rawhash % set->buckets;
- register struct variable *v;
+ const struct variable_set *set = setlist->set;
+ unsigned int hashval = rawhash % set->buckets;
+ struct variable *v;
- /* Look through this set list. */
+ /* Look through this set list; return it if found. */
for (v = set->table[hashval]; v != 0; v = v->next)
if (*v->name == *name
&& strneq (v->name + 1, name + 1, length - 1)
&& v->name[length] == '\0')
- break;
-
- /* If we didn't find anything, go to the next set list. */
- if (!v)
- continue;
-
- /* If it's not being expanded already, we're done. */
- if (!v->expanding)
- return v;
-
- /* It is, so try to find another one. If this is the first one we've
- seen, keep a pointer in case we don't find anything else. */
- if (!firstv)
- firstv = v;
+ return v;
}
#ifdef VMS
/* since we don't read envp[] on startup, try to get the
variable via getenv() here. */
- if (!firstv)
- {
- char *vname = alloca (length + 1);
- char *value;
- strncpy (vname, name, length);
- vname[length] = 0;
- value = getenv (vname);
- if (value != 0)
- {
- char *sptr;
- int scnt;
-
- sptr = value;
- scnt = 0;
-
- while ((sptr = strchr (sptr, '$')))
- {
- scnt++;
- sptr++;
- }
-
- if (scnt > 0)
- {
- char *nvalue;
- char *nptr;
+ {
+ char *vname = alloca (length + 1);
+ char *value;
+ strncpy (vname, name, length);
+ vname[length] = 0;
+ value = getenv (vname);
+ if (value != 0)
+ {
+ char *sptr;
+ int scnt;
- nvalue = alloca (length + scnt + 1);
- sptr = value;
- nptr = nvalue;
+ sptr = value;
+ scnt = 0;
- while (*sptr)
- {
- if (*sptr == '$')
- {
- *nptr++ = '$';
- *nptr++ = '$';
- }
- else
- {
- *nptr++ = *sptr;
- }
- sptr++;
- }
+ while ((sptr = strchr (sptr, '$')))
+ {
+ scnt++;
+ sptr++;
+ }
- return define_variable (vname, length, nvalue, o_env, 1);
+ if (scnt > 0)
+ {
+ char *nvalue;
+ char *nptr;
+
+ nvalue = alloca (strlen (value) + scnt + 1);
+ sptr = value;
+ nptr = nvalue;
+
+ while (*sptr)
+ {
+ if (*sptr == '$')
+ {
+ *nptr++ = '$';
+ *nptr++ = '$';
+ }
+ else
+ {
+ *nptr++ = *sptr;
+ }
+ sptr++;
+ }
+
+ return define_variable (vname, length, nvalue, o_env, 1);
- }
+ }
- return define_variable (vname, length, value, o_env, 1);
- }
- }
+ return define_variable (vname, length, value, o_env, 1);
+ }
+ }
#endif /* VMS */
- return firstv;
+ return 0;
}
\f
/* Lookup a variable whose name is a string starting at NAME
Returns address of the `struct variable' containing all info
on the variable, or nil if no such variable is defined. */
-static struct variable *
+struct variable *
lookup_variable_in_set (name, length, set)
- char *name;
+ const char *name;
unsigned int length;
- struct variable_set *set;
+ const struct variable_set *set;
{
- register unsigned int i;
- register unsigned int hash = 0;
- register struct variable *v;
+ unsigned int i;
+ unsigned int hash = 0;
+ struct variable *v;
for (i = 0; i < length; ++i)
HASH (hash, name[i]);
register char *end;
enum { f_bogus,
f_simple, f_recursive, f_append, f_conditional } flavor = f_bogus;
- char *name, *expanded_name, *value, *alloc_value=NULL;
+ char *name, *expanded_name, *value=0, *alloc_value=NULL;
struct variable *v;
int append = 0;
break;
case f_append:
{
- struct variable_set_list *saved_next = current_variable_set_list->next;
-
/* If we have += but we're in a target variable context, we want to
append only with other variables in the context of this target. */
if (target_var)
{
append = 1;
- current_variable_set_list->next = 0;
+ v = lookup_variable_in_set (expanded_name, strlen (expanded_name),
+ current_variable_set_list->set);
}
-
- /* An appending variable definition "var += value".
- Extract the old value and append the new one. */
- v = lookup_variable (expanded_name, strlen (expanded_name));
-
- current_variable_set_list->next = saved_next;
+ else
+ v = lookup_variable (expanded_name, strlen (expanded_name));
if (v == 0)
{
extern void merge_variable_set_lists PARAMS ((struct variable_set_list **setlist0, struct variable_set_list *setlist1));
extern struct variable *try_variable_definition PARAMS ((const struct floc *flocp, char *line, enum variable_origin origin, int target_var));
-extern struct variable *lookup_variable PARAMS ((char *name, unsigned int length));
+extern struct variable *lookup_variable PARAMS ((const char *name, unsigned int length));
+extern struct variable *lookup_variable_in_set PARAMS ((const char *name,
+ unsigned int length,
+ const struct variable_set *set));
extern struct variable *define_variable_in_set
PARAMS ((char *name, unsigned int length, char *value,
projects / thirdparty / make.git / commitdiff
