mirror of
https://git.savannah.gnu.org/git/make.git
synced 2024-12-27 06:27:51 +00:00
e97159745d
* makeint.h: Change MAP_SPACE to MAP_NEWLINE, and add MAP_PATHSEP and MAP_SPACE which is now MAP_BLANK|MAP_NEWLINE. Create NEW_TOKEN(), END_OF_TOKEN(), ISBLANK(), ISSPACE() macros. * main.c (initialize_stopchar_map): Set MAP_NEWLINE only for newline characters. * Convert all uses of isblank() and isspace() to macros. * Examine all uses of isblank() (doesn't accept newlines) and change them wherever possible to ISSPACE() (does accept newlines). * function.c (func_foreach): Strip leading/trailing space. * variable.c (parse_variable_definition): Clean up. * tests/scripts/functions/foreach: Test settings and errors. * tests/scripts/functions/call: Rewrite to new-style. * tests/scripts/misc/bs-nl: Add many more tests for newlines.
637 lines
19 KiB
C
637 lines
19 KiB
C
/* Implementation of pattern-matching file search paths 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 "filedef.h"
|
||
#include "variable.h"
|
||
#ifdef WINDOWS32
|
||
#include "pathstuff.h"
|
||
#endif
|
||
|
||
|
||
/* Structure used to represent a selective VPATH searchpath. */
|
||
|
||
struct vpath
|
||
{
|
||
struct vpath *next; /* Pointer to next struct in the linked list. */
|
||
const char *pattern;/* The pattern to match. */
|
||
const char *percent;/* Pointer into 'pattern' where the '%' is. */
|
||
unsigned int patlen;/* Length of the pattern. */
|
||
const char **searchpath; /* Null-terminated list of directories. */
|
||
unsigned int maxlen;/* Maximum length of any entry in the list. */
|
||
};
|
||
|
||
/* Linked-list of all selective VPATHs. */
|
||
|
||
static struct vpath *vpaths;
|
||
|
||
/* Structure for the general VPATH given in the variable. */
|
||
|
||
static struct vpath *general_vpath;
|
||
|
||
/* Structure for GPATH given in the variable. */
|
||
|
||
static struct vpath *gpaths;
|
||
|
||
|
||
/* Reverse the chain of selective VPATH lists so they will be searched in the
|
||
order given in the makefiles and construct the list from the VPATH
|
||
variable. */
|
||
|
||
void
|
||
build_vpath_lists ()
|
||
{
|
||
register struct vpath *new = 0;
|
||
register struct vpath *old, *nexto;
|
||
register char *p;
|
||
|
||
/* Reverse the chain. */
|
||
for (old = vpaths; old != 0; old = nexto)
|
||
{
|
||
nexto = old->next;
|
||
old->next = new;
|
||
new = old;
|
||
}
|
||
|
||
vpaths = new;
|
||
|
||
/* If there is a VPATH variable with a nonnull value, construct the
|
||
general VPATH list from it. We use variable_expand rather than just
|
||
calling lookup_variable so that it will be recursively expanded. */
|
||
|
||
{
|
||
/* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
|
||
int save = warn_undefined_variables_flag;
|
||
warn_undefined_variables_flag = 0;
|
||
|
||
p = variable_expand ("$(strip $(VPATH))");
|
||
|
||
warn_undefined_variables_flag = save;
|
||
}
|
||
|
||
if (*p != '\0')
|
||
{
|
||
/* Save the list of vpaths. */
|
||
struct vpath *save_vpaths = vpaths;
|
||
char gp[] = "%";
|
||
|
||
/* Empty 'vpaths' so the new one will have no next, and 'vpaths'
|
||
will still be nil if P contains no existing directories. */
|
||
vpaths = 0;
|
||
|
||
/* Parse P. */
|
||
construct_vpath_list (gp, p);
|
||
|
||
/* Store the created path as the general path,
|
||
and restore the old list of vpaths. */
|
||
general_vpath = vpaths;
|
||
vpaths = save_vpaths;
|
||
}
|
||
|
||
/* If there is a GPATH variable with a nonnull value, construct the
|
||
GPATH list from it. We use variable_expand rather than just
|
||
calling lookup_variable so that it will be recursively expanded. */
|
||
|
||
{
|
||
/* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
|
||
int save = warn_undefined_variables_flag;
|
||
warn_undefined_variables_flag = 0;
|
||
|
||
p = variable_expand ("$(strip $(GPATH))");
|
||
|
||
warn_undefined_variables_flag = save;
|
||
}
|
||
|
||
if (*p != '\0')
|
||
{
|
||
/* Save the list of vpaths. */
|
||
struct vpath *save_vpaths = vpaths;
|
||
char gp[] = "%";
|
||
|
||
/* Empty 'vpaths' so the new one will have no next, and 'vpaths'
|
||
will still be nil if P contains no existing directories. */
|
||
vpaths = 0;
|
||
|
||
/* Parse P. */
|
||
construct_vpath_list (gp, p);
|
||
|
||
/* Store the created path as the GPATH,
|
||
and restore the old list of vpaths. */
|
||
gpaths = vpaths;
|
||
vpaths = save_vpaths;
|
||
}
|
||
}
|
||
|
||
/* Construct the VPATH listing for the PATTERN and DIRPATH given.
|
||
|
||
This function is called to generate selective VPATH lists and also for
|
||
the general VPATH list (which is in fact just a selective VPATH that
|
||
is applied to everything). The returned pointer is either put in the
|
||
linked list of all selective VPATH lists or in the GENERAL_VPATH
|
||
variable.
|
||
|
||
If DIRPATH is nil, remove all previous listings with the same
|
||
pattern. If PATTERN is nil, remove all VPATH listings. Existing
|
||
and readable directories that are not "." given in the DIRPATH
|
||
separated by the path element separator (defined in makeint.h) are
|
||
loaded into the directory hash table if they are not there already
|
||
and put in the VPATH searchpath for the given pattern with trailing
|
||
slashes stripped off if present (and if the directory is not the
|
||
root, "/"). The length of the longest entry in the list is put in
|
||
the structure as well. The new entry will be at the head of the
|
||
VPATHS chain. */
|
||
|
||
void
|
||
construct_vpath_list (char *pattern, char *dirpath)
|
||
{
|
||
unsigned int elem;
|
||
char *p;
|
||
const char **vpath;
|
||
unsigned int maxvpath;
|
||
unsigned int maxelem;
|
||
const char *percent = NULL;
|
||
|
||
if (pattern != 0)
|
||
percent = find_percent (pattern);
|
||
|
||
if (dirpath == 0)
|
||
{
|
||
/* Remove matching listings. */
|
||
struct vpath *path, *lastpath;
|
||
|
||
lastpath = 0;
|
||
path = vpaths;
|
||
while (path != 0)
|
||
{
|
||
struct vpath *next = path->next;
|
||
|
||
if (pattern == 0
|
||
|| (((percent == 0 && path->percent == 0)
|
||
|| (percent - pattern == path->percent - path->pattern))
|
||
&& streq (pattern, path->pattern)))
|
||
{
|
||
/* Remove it from the linked list. */
|
||
if (lastpath == 0)
|
||
vpaths = path->next;
|
||
else
|
||
lastpath->next = next;
|
||
|
||
/* Free its unused storage. */
|
||
/* MSVC erroneously warns without a cast here. */
|
||
free ((void *)path->searchpath);
|
||
free (path);
|
||
}
|
||
else
|
||
lastpath = path;
|
||
|
||
path = next;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
#ifdef WINDOWS32
|
||
convert_vpath_to_windows32 (dirpath, ';');
|
||
#endif
|
||
|
||
/* Skip over any initial separators and blanks. */
|
||
while (STOP_SET (*dirpath, MAP_BLANK|MAP_PATHSEP))
|
||
++dirpath;
|
||
|
||
/* Figure out the maximum number of VPATH entries and put it in
|
||
MAXELEM. We start with 2, one before the first separator and one
|
||
nil (the list terminator) and increment our estimated number for
|
||
each separator or blank we find. */
|
||
maxelem = 2;
|
||
p = dirpath;
|
||
while (*p != '\0')
|
||
if (STOP_SET (*p++, MAP_BLANK|MAP_PATHSEP))
|
||
++maxelem;
|
||
|
||
vpath = xmalloc (maxelem * sizeof (const char *));
|
||
maxvpath = 0;
|
||
|
||
elem = 0;
|
||
p = dirpath;
|
||
while (*p != '\0')
|
||
{
|
||
char *v;
|
||
unsigned int len;
|
||
|
||
/* Find the end of this entry. */
|
||
v = p;
|
||
while (*p != '\0'
|
||
#if defined(HAVE_DOS_PATHS) && (PATH_SEPARATOR_CHAR == ':')
|
||
/* Platforms whose PATH_SEPARATOR_CHAR is ':' and which
|
||
also define HAVE_DOS_PATHS would like us to recognize
|
||
colons after the drive letter in the likes of
|
||
"D:/foo/bar:C:/xyzzy". */
|
||
&& (*p != PATH_SEPARATOR_CHAR
|
||
|| (p == v + 1 && (p[1] == '/' || p[1] == '\\')))
|
||
#else
|
||
&& *p != PATH_SEPARATOR_CHAR
|
||
#endif
|
||
&& !ISBLANK (*p))
|
||
++p;
|
||
|
||
len = p - v;
|
||
/* Make sure there's no trailing slash,
|
||
but still allow "/" as a directory. */
|
||
#if defined(__MSDOS__) || defined(__EMX__) || defined(HAVE_DOS_PATHS)
|
||
/* We need also to leave alone a trailing slash in "d:/". */
|
||
if (len > 3 || (len > 1 && v[1] != ':'))
|
||
#endif
|
||
if (len > 1 && p[-1] == '/')
|
||
--len;
|
||
|
||
/* Put the directory on the vpath list. */
|
||
if (len > 1 || *v != '.')
|
||
{
|
||
vpath[elem++] = dir_name (strcache_add_len (v, len));
|
||
if (len > maxvpath)
|
||
maxvpath = len;
|
||
}
|
||
|
||
/* Skip over separators and blanks between entries. */
|
||
while (STOP_SET (*p, MAP_BLANK|MAP_PATHSEP))
|
||
++p;
|
||
}
|
||
|
||
if (elem > 0)
|
||
{
|
||
struct vpath *path;
|
||
/* ELEM is now incremented one element past the last
|
||
entry, to where the nil-pointer terminator goes.
|
||
Usually this is maxelem - 1. If not, shrink down. */
|
||
if (elem < (maxelem - 1))
|
||
vpath = xrealloc (vpath, (elem+1) * sizeof (const char *));
|
||
|
||
/* Put the nil-pointer terminator on the end of the VPATH list. */
|
||
vpath[elem] = NULL;
|
||
|
||
/* Construct the vpath structure and put it into the linked list. */
|
||
path = xmalloc (sizeof (struct vpath));
|
||
path->searchpath = vpath;
|
||
path->maxlen = maxvpath;
|
||
path->next = vpaths;
|
||
vpaths = path;
|
||
|
||
/* Set up the members. */
|
||
path->pattern = strcache_add (pattern);
|
||
path->patlen = strlen (pattern);
|
||
path->percent = percent ? path->pattern + (percent - pattern) : 0;
|
||
}
|
||
else
|
||
/* There were no entries, so free whatever space we allocated. */
|
||
/* MSVC erroneously warns without a cast here. */
|
||
free ((void *)vpath);
|
||
}
|
||
|
||
/* Search the GPATH list for a pathname string that matches the one passed
|
||
in. If it is found, return 1. Otherwise we return 0. */
|
||
|
||
int
|
||
gpath_search (const char *file, unsigned int len)
|
||
{
|
||
if (gpaths && (len <= gpaths->maxlen))
|
||
{
|
||
const char **gp;
|
||
for (gp = gpaths->searchpath; *gp != NULL; ++gp)
|
||
if (strneq (*gp, file, len) && (*gp)[len] == '\0')
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Search the given VPATH list for a directory where the name pointed to by
|
||
FILE exists. If it is found, we return a cached name of the existing file
|
||
and set *MTIME_PTR (if MTIME_PTR is not NULL) to its modtime (or zero if no
|
||
stat call was done). Also set the matching directory index in PATH_INDEX
|
||
if it is not NULL. Otherwise we return NULL. */
|
||
|
||
static const char *
|
||
selective_vpath_search (struct vpath *path, const char *file,
|
||
FILE_TIMESTAMP *mtime_ptr, unsigned int* path_index)
|
||
{
|
||
int not_target;
|
||
char *name;
|
||
const char *n;
|
||
const char *filename;
|
||
const char **vpath = path->searchpath;
|
||
unsigned int maxvpath = path->maxlen;
|
||
unsigned int i;
|
||
unsigned int flen, name_dplen;
|
||
int exists = 0;
|
||
|
||
/* Find out if *FILE is a target.
|
||
If and only if it is NOT a target, we will accept prospective
|
||
files that don't exist but are mentioned in a makefile. */
|
||
{
|
||
struct file *f = lookup_file (file);
|
||
not_target = f == 0 || !f->is_target;
|
||
}
|
||
|
||
flen = strlen (file);
|
||
|
||
/* Split *FILE into a directory prefix and a name-within-directory.
|
||
NAME_DPLEN gets the length of the prefix; FILENAME gets the pointer to
|
||
the name-within-directory and FLEN is its length. */
|
||
|
||
n = strrchr (file, '/');
|
||
#ifdef HAVE_DOS_PATHS
|
||
/* We need the rightmost slash or backslash. */
|
||
{
|
||
const char *bslash = strrchr (file, '\\');
|
||
if (!n || bslash > n)
|
||
n = bslash;
|
||
}
|
||
#endif
|
||
name_dplen = n != 0 ? n - file : 0;
|
||
filename = name_dplen > 0 ? n + 1 : file;
|
||
if (name_dplen > 0)
|
||
flen -= name_dplen + 1;
|
||
|
||
/* Get enough space for the biggest VPATH entry, a slash, the directory
|
||
prefix that came with FILE, another slash (although this one may not
|
||
always be necessary), the filename, and a null terminator. */
|
||
name = alloca (maxvpath + 1 + name_dplen + 1 + flen + 1);
|
||
|
||
/* Try each VPATH entry. */
|
||
for (i = 0; vpath[i] != 0; ++i)
|
||
{
|
||
int exists_in_cache = 0;
|
||
char *p = name;
|
||
unsigned int vlen = strlen (vpath[i]);
|
||
|
||
/* Put the next VPATH entry into NAME at P and increment P past it. */
|
||
memcpy (p, vpath[i], vlen);
|
||
p += vlen;
|
||
|
||
/* Add the directory prefix already in *FILE. */
|
||
if (name_dplen > 0)
|
||
{
|
||
#ifndef VMS
|
||
*p++ = '/';
|
||
#else
|
||
/* VMS: if this is not in VMS format, treat as Unix format */
|
||
if ((*p != ':') && (*p != ']') && (*p != '>'))
|
||
*p++ = '/';
|
||
#endif
|
||
memcpy (p, file, name_dplen);
|
||
p += name_dplen;
|
||
}
|
||
|
||
#ifdef HAVE_DOS_PATHS
|
||
/* Cause the next if to treat backslash and slash alike. */
|
||
if (p != name && p[-1] == '\\' )
|
||
p[-1] = '/';
|
||
#endif
|
||
/* Now add the name-within-directory at the end of NAME. */
|
||
#ifndef VMS
|
||
if (p != name && p[-1] != '/')
|
||
{
|
||
*p = '/';
|
||
memcpy (p + 1, filename, flen + 1);
|
||
}
|
||
else
|
||
#else
|
||
/* VMS use a slash if no directory terminator present */
|
||
if (p != name && p[-1] != '/' && p[-1] != ':' &&
|
||
p[-1] != '>' && p[-1] != ']')
|
||
{
|
||
*p = '/';
|
||
memcpy (p + 1, filename, flen + 1);
|
||
}
|
||
else
|
||
#endif
|
||
memcpy (p, filename, flen + 1);
|
||
|
||
/* Check if the file is mentioned in a makefile. If *FILE is not
|
||
a target, that is enough for us to decide this file exists.
|
||
If *FILE is a target, then the file must be mentioned in the
|
||
makefile also as a target to be chosen.
|
||
|
||
The restriction that *FILE must not be a target for a
|
||
makefile-mentioned file to be chosen was added by an
|
||
inadequately commented change in July 1990; I am not sure off
|
||
hand what problem it fixes.
|
||
|
||
In December 1993 I loosened this restriction to allow a file
|
||
to be chosen if it is mentioned as a target in a makefile. This
|
||
seem logical.
|
||
|
||
Special handling for -W / -o: make sure we preserve the special
|
||
values here. Actually this whole thing is a little bogus: I think
|
||
we should ditch the name/hname thing and look into the renamed
|
||
capability that already exists for files: that is, have a new struct
|
||
file* entry for the VPATH-found file, and set the renamed field if
|
||
we use it.
|
||
*/
|
||
{
|
||
struct file *f = lookup_file (name);
|
||
if (f != 0)
|
||
{
|
||
exists = not_target || f->is_target;
|
||
if (exists && mtime_ptr
|
||
&& (f->last_mtime == OLD_MTIME || f->last_mtime == NEW_MTIME))
|
||
{
|
||
*mtime_ptr = f->last_mtime;
|
||
mtime_ptr = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!exists)
|
||
{
|
||
/* That file wasn't mentioned in the makefile.
|
||
See if it actually exists. */
|
||
|
||
#ifdef VMS
|
||
/* For VMS syntax just use the original vpath */
|
||
if (*p != '/')
|
||
exists_in_cache = exists = dir_file_exists_p (vpath[i], filename);
|
||
else
|
||
#endif
|
||
{
|
||
/* Clobber a null into the name at the last slash.
|
||
Now NAME is the name of the directory to look in. */
|
||
*p = '\0';
|
||
/* We know the directory is in the hash table now because either
|
||
construct_vpath_list or the code just above put it there.
|
||
Does the file we seek exist in it? */
|
||
exists_in_cache = exists = dir_file_exists_p (name, filename);
|
||
}
|
||
}
|
||
|
||
if (exists)
|
||
{
|
||
/* The file is in the directory cache.
|
||
Now check that it actually exists in the filesystem.
|
||
The cache may be out of date. When vpath thinks a file
|
||
exists, but stat fails for it, confusion results in the
|
||
higher levels. */
|
||
|
||
struct stat st;
|
||
|
||
#ifndef VMS
|
||
/* Put the slash back in NAME. */
|
||
*p = '/';
|
||
#else
|
||
/* If the slash was removed, put it back */
|
||
if (*p == 0)
|
||
*p = '/';
|
||
#endif
|
||
|
||
if (exists_in_cache) /* Makefile-mentioned file need not exist. */
|
||
{
|
||
int e;
|
||
|
||
EINTRLOOP (e, stat (name, &st)); /* Does it really exist? */
|
||
if (e != 0)
|
||
{
|
||
exists = 0;
|
||
continue;
|
||
}
|
||
|
||
/* Store the modtime into *MTIME_PTR for the caller. */
|
||
if (mtime_ptr != 0)
|
||
{
|
||
*mtime_ptr = FILE_TIMESTAMP_STAT_MODTIME (name, st);
|
||
mtime_ptr = 0;
|
||
}
|
||
}
|
||
|
||
/* We have found a file.
|
||
If we get here and mtime_ptr hasn't been set, record
|
||
UNKNOWN_MTIME to indicate this. */
|
||
if (mtime_ptr != 0)
|
||
*mtime_ptr = UNKNOWN_MTIME;
|
||
|
||
/* Store the name we found and return it. */
|
||
|
||
if (path_index)
|
||
*path_index = i;
|
||
|
||
return strcache_add_len (name, (p + 1 - name) + flen);
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Search the VPATH list whose pattern matches FILE for a directory where FILE
|
||
exists. If it is found, return the cached name of an existing file, and
|
||
set *MTIME_PTR (if MTIME_PTR is not NULL) to its modtime (or zero if no
|
||
stat call was done). Also set the matching directory index in VPATH_INDEX
|
||
and PATH_INDEX if they are not NULL. Otherwise we return 0. */
|
||
|
||
const char *
|
||
vpath_search (const char *file, FILE_TIMESTAMP *mtime_ptr,
|
||
unsigned int* vpath_index, unsigned int* path_index)
|
||
{
|
||
struct vpath *v;
|
||
|
||
/* If there are no VPATH entries or FILENAME starts at the root,
|
||
there is nothing we can do. */
|
||
|
||
if (file[0] == '/'
|
||
#ifdef HAVE_DOS_PATHS
|
||
|| file[0] == '\\' || file[1] == ':'
|
||
#endif
|
||
|| (vpaths == 0 && general_vpath == 0))
|
||
return 0;
|
||
|
||
if (vpath_index)
|
||
{
|
||
*vpath_index = 0;
|
||
*path_index = 0;
|
||
}
|
||
|
||
for (v = vpaths; v != 0; v = v->next)
|
||
{
|
||
if (pattern_matches (v->pattern, v->percent, file))
|
||
{
|
||
const char *p = selective_vpath_search (
|
||
v, file, mtime_ptr, path_index);
|
||
if (p)
|
||
return p;
|
||
}
|
||
|
||
if (vpath_index)
|
||
++*vpath_index;
|
||
}
|
||
|
||
|
||
if (general_vpath != 0)
|
||
{
|
||
const char *p = selective_vpath_search (
|
||
general_vpath, file, mtime_ptr, path_index);
|
||
if (p)
|
||
return p;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
|
||
/* Print the data base of VPATH search paths. */
|
||
|
||
void
|
||
print_vpath_data_base (void)
|
||
{
|
||
unsigned int nvpaths;
|
||
struct vpath *v;
|
||
|
||
puts (_("\n# VPATH Search Paths\n"));
|
||
|
||
nvpaths = 0;
|
||
for (v = vpaths; v != 0; v = v->next)
|
||
{
|
||
register unsigned int i;
|
||
|
||
++nvpaths;
|
||
|
||
printf ("vpath %s ", v->pattern);
|
||
|
||
for (i = 0; v->searchpath[i] != 0; ++i)
|
||
printf ("%s%c", v->searchpath[i],
|
||
v->searchpath[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
|
||
}
|
||
|
||
if (vpaths == 0)
|
||
puts (_("# No 'vpath' search paths."));
|
||
else
|
||
printf (_("\n# %u 'vpath' search paths.\n"), nvpaths);
|
||
|
||
if (general_vpath == 0)
|
||
puts (_("\n# No general ('VPATH' variable) search path."));
|
||
else
|
||
{
|
||
const char **path = general_vpath->searchpath;
|
||
unsigned int i;
|
||
|
||
fputs (_("\n# General ('VPATH' variable) search path:\n# "), stdout);
|
||
|
||
for (i = 0; path[i] != 0; ++i)
|
||
printf ("%s%c", path[i],
|
||
path[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
|
||
}
|
||
}
|