Ensure variables defined in $(call ...) have global scope
[make.git] / vpath.c
blob9f41b275b5f54c7d1eb64c1c6219f9491050e921
1 /* Implementation of pattern-matching file search paths for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010 Free Software Foundation, Inc.
5 This file is part of GNU Make.
7 GNU Make is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3 of the License, or (at your option) any later
10 version.
12 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along with
17 this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "make.h"
20 #include "filedef.h"
21 #include "variable.h"
22 #ifdef WINDOWS32
23 #include "pathstuff.h"
24 #endif
27 /* Structure used to represent a selective VPATH searchpath. */
29 struct vpath
31 struct vpath *next; /* Pointer to next struct in the linked list. */
32 const char *pattern;/* The pattern to match. */
33 const char *percent;/* Pointer into `pattern' where the `%' is. */
34 unsigned int patlen;/* Length of the pattern. */
35 const char **searchpath; /* Null-terminated list of directories. */
36 unsigned int maxlen;/* Maximum length of any entry in the list. */
39 /* Linked-list of all selective VPATHs. */
41 static struct vpath *vpaths;
43 /* Structure for the general VPATH given in the variable. */
45 static struct vpath *general_vpath;
47 /* Structure for GPATH given in the variable. */
49 static struct vpath *gpaths;
52 /* Reverse the chain of selective VPATH lists so they will be searched in the
53 order given in the makefiles and construct the list from the VPATH
54 variable. */
56 void
57 build_vpath_lists ()
59 register struct vpath *new = 0;
60 register struct vpath *old, *nexto;
61 register char *p;
63 /* Reverse the chain. */
64 for (old = vpaths; old != 0; old = nexto)
66 nexto = old->next;
67 old->next = new;
68 new = old;
71 vpaths = new;
73 /* If there is a VPATH variable with a nonnull value, construct the
74 general VPATH list from it. We use variable_expand rather than just
75 calling lookup_variable so that it will be recursively expanded. */
78 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
79 int save = warn_undefined_variables_flag;
80 warn_undefined_variables_flag = 0;
82 p = variable_expand ("$(strip $(VPATH))");
84 warn_undefined_variables_flag = save;
87 if (*p != '\0')
89 /* Save the list of vpaths. */
90 struct vpath *save_vpaths = vpaths;
91 char gp[] = "%";
93 /* Empty `vpaths' so the new one will have no next, and `vpaths'
94 will still be nil if P contains no existing directories. */
95 vpaths = 0;
97 /* Parse P. */
98 construct_vpath_list (gp, p);
100 /* Store the created path as the general path,
101 and restore the old list of vpaths. */
102 general_vpath = vpaths;
103 vpaths = save_vpaths;
106 /* If there is a GPATH variable with a nonnull value, construct the
107 GPATH list from it. We use variable_expand rather than just
108 calling lookup_variable so that it will be recursively expanded. */
111 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
112 int save = warn_undefined_variables_flag;
113 warn_undefined_variables_flag = 0;
115 p = variable_expand ("$(strip $(GPATH))");
117 warn_undefined_variables_flag = save;
120 if (*p != '\0')
122 /* Save the list of vpaths. */
123 struct vpath *save_vpaths = vpaths;
124 char gp[] = "%";
126 /* Empty `vpaths' so the new one will have no next, and `vpaths'
127 will still be nil if P contains no existing directories. */
128 vpaths = 0;
130 /* Parse P. */
131 construct_vpath_list (gp, p);
133 /* Store the created path as the GPATH,
134 and restore the old list of vpaths. */
135 gpaths = vpaths;
136 vpaths = save_vpaths;
140 /* Construct the VPATH listing for the PATTERN and DIRPATH given.
142 This function is called to generate selective VPATH lists and also for
143 the general VPATH list (which is in fact just a selective VPATH that
144 is applied to everything). The returned pointer is either put in the
145 linked list of all selective VPATH lists or in the GENERAL_VPATH
146 variable.
148 If DIRPATH is nil, remove all previous listings with the same
149 pattern. If PATTERN is nil, remove all VPATH listings. Existing
150 and readable directories that are not "." given in the DIRPATH
151 separated by the path element separator (defined in make.h) are
152 loaded into the directory hash table if they are not there already
153 and put in the VPATH searchpath for the given pattern with trailing
154 slashes stripped off if present (and if the directory is not the
155 root, "/"). The length of the longest entry in the list is put in
156 the structure as well. The new entry will be at the head of the
157 VPATHS chain. */
159 void
160 construct_vpath_list (char *pattern, char *dirpath)
162 unsigned int elem;
163 char *p;
164 const char **vpath;
165 unsigned int maxvpath;
166 unsigned int maxelem;
167 const char *percent = NULL;
169 if (pattern != 0)
170 percent = find_percent (pattern);
172 if (dirpath == 0)
174 /* Remove matching listings. */
175 struct vpath *path, *lastpath;
177 lastpath = 0;
178 path = vpaths;
179 while (path != 0)
181 struct vpath *next = path->next;
183 if (pattern == 0
184 || (((percent == 0 && path->percent == 0)
185 || (percent - pattern == path->percent - path->pattern))
186 && streq (pattern, path->pattern)))
188 /* Remove it from the linked list. */
189 if (lastpath == 0)
190 vpaths = path->next;
191 else
192 lastpath->next = next;
194 /* Free its unused storage. */
195 /* MSVC erroneously warns without a cast here. */
196 free ((void *)path->searchpath);
197 free (path);
199 else
200 lastpath = path;
202 path = next;
205 return;
208 #ifdef WINDOWS32
209 convert_vpath_to_windows32(dirpath, ';');
210 #endif
212 /* Skip over any initial separators and blanks. */
213 while (*dirpath == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*dirpath))
214 ++dirpath;
216 /* Figure out the maximum number of VPATH entries and put it in
217 MAXELEM. We start with 2, one before the first separator and one
218 nil (the list terminator) and increment our estimated number for
219 each separator or blank we find. */
220 maxelem = 2;
221 p = dirpath;
222 while (*p != '\0')
223 if (*p++ == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p))
224 ++maxelem;
226 vpath = xmalloc (maxelem * sizeof (const char *));
227 maxvpath = 0;
229 elem = 0;
230 p = dirpath;
231 while (*p != '\0')
233 char *v;
234 unsigned int len;
236 /* Find the end of this entry. */
237 v = p;
238 while (*p != '\0'
239 #if defined(HAVE_DOS_PATHS) && (PATH_SEPARATOR_CHAR == ':')
240 /* Platforms whose PATH_SEPARATOR_CHAR is ':' and which
241 also define HAVE_DOS_PATHS would like us to recognize
242 colons after the drive letter in the likes of
243 "D:/foo/bar:C:/xyzzy". */
244 && (*p != PATH_SEPARATOR_CHAR
245 || (p == v + 1 && (p[1] == '/' || p[1] == '\\')))
246 #else
247 && *p != PATH_SEPARATOR_CHAR
248 #endif
249 && !isblank ((unsigned char)*p))
250 ++p;
252 len = p - v;
253 /* Make sure there's no trailing slash,
254 but still allow "/" as a directory. */
255 #if defined(__MSDOS__) || defined(__EMX__) || defined(HAVE_DOS_PATHS)
256 /* We need also to leave alone a trailing slash in "d:/". */
257 if (len > 3 || (len > 1 && v[1] != ':'))
258 #endif
259 if (len > 1 && p[-1] == '/')
260 --len;
262 /* Put the directory on the vpath list. */
263 if (len > 1 || *v != '.')
265 vpath[elem++] = dir_name (strcache_add_len (v, len));
266 if (len > maxvpath)
267 maxvpath = len;
270 /* Skip over separators and blanks between entries. */
271 while (*p == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p))
272 ++p;
275 if (elem > 0)
277 struct vpath *path;
278 /* ELEM is now incremented one element past the last
279 entry, to where the nil-pointer terminator goes.
280 Usually this is maxelem - 1. If not, shrink down. */
281 if (elem < (maxelem - 1))
282 vpath = xrealloc (vpath, (elem+1) * sizeof (const char *));
284 /* Put the nil-pointer terminator on the end of the VPATH list. */
285 vpath[elem] = NULL;
287 /* Construct the vpath structure and put it into the linked list. */
288 path = xmalloc (sizeof (struct vpath));
289 path->searchpath = vpath;
290 path->maxlen = maxvpath;
291 path->next = vpaths;
292 vpaths = path;
294 /* Set up the members. */
295 path->pattern = strcache_add (pattern);
296 path->patlen = strlen (pattern);
297 path->percent = percent ? path->pattern + (percent - pattern) : 0;
299 else
300 /* There were no entries, so free whatever space we allocated. */
301 /* MSVC erroneously warns without a cast here. */
302 free ((void *)vpath);
305 /* Search the GPATH list for a pathname string that matches the one passed
306 in. If it is found, return 1. Otherwise we return 0. */
309 gpath_search (const char *file, unsigned int len)
311 const char **gp;
313 if (gpaths && (len <= gpaths->maxlen))
314 for (gp = gpaths->searchpath; *gp != NULL; ++gp)
315 if (strneq (*gp, file, len) && (*gp)[len] == '\0')
316 return 1;
318 return 0;
322 /* Search the given VPATH list for a directory where the name pointed to by
323 FILE exists. If it is found, we return a cached name of the existing file
324 and set *MTIME_PTR (if MTIME_PTR is not NULL) to its modtime (or zero if no
325 stat call was done). Also set the matching directory index in PATH_INDEX
326 if it is not NULL. Otherwise we return NULL. */
328 static const char *
329 selective_vpath_search (struct vpath *path, const char *file,
330 FILE_TIMESTAMP *mtime_ptr, unsigned int* path_index)
332 int not_target;
333 char *name;
334 const char *n;
335 const char *filename;
336 const char **vpath = path->searchpath;
337 unsigned int maxvpath = path->maxlen;
338 unsigned int i;
339 unsigned int flen, vlen, name_dplen;
340 int exists = 0;
342 /* Find out if *FILE is a target.
343 If and only if it is NOT a target, we will accept prospective
344 files that don't exist but are mentioned in a makefile. */
346 struct file *f = lookup_file (file);
347 not_target = f == 0 || !f->is_target;
350 flen = strlen (file);
352 /* Split *FILE into a directory prefix and a name-within-directory.
353 NAME_DPLEN gets the length of the prefix; FILENAME gets the pointer to
354 the name-within-directory and FLEN is its length. */
356 n = strrchr (file, '/');
357 #ifdef HAVE_DOS_PATHS
358 /* We need the rightmost slash or backslash. */
360 const char *bslash = strrchr(file, '\\');
361 if (!n || bslash > n)
362 n = bslash;
364 #endif
365 name_dplen = n != 0 ? n - file : 0;
366 filename = name_dplen > 0 ? n + 1 : file;
367 if (name_dplen > 0)
368 flen -= name_dplen + 1;
370 /* Get enough space for the biggest VPATH entry, a slash, the directory
371 prefix that came with FILE, another slash (although this one may not
372 always be necessary), the filename, and a null terminator. */
373 name = alloca (maxvpath + 1 + name_dplen + 1 + flen + 1);
375 /* Try each VPATH entry. */
376 for (i = 0; vpath[i] != 0; ++i)
378 int exists_in_cache = 0;
379 char *p;
381 p = name;
383 /* Put the next VPATH entry into NAME at P and increment P past it. */
384 vlen = strlen (vpath[i]);
385 memcpy (p, vpath[i], vlen);
386 p += vlen;
388 /* Add the directory prefix already in *FILE. */
389 if (name_dplen > 0)
391 #ifndef VMS
392 *p++ = '/';
393 #endif
394 memcpy (p, file, name_dplen);
395 p += name_dplen;
398 #ifdef HAVE_DOS_PATHS
399 /* Cause the next if to treat backslash and slash alike. */
400 if (p != name && p[-1] == '\\' )
401 p[-1] = '/';
402 #endif
403 /* Now add the name-within-directory at the end of NAME. */
404 #ifndef VMS
405 if (p != name && p[-1] != '/')
407 *p = '/';
408 memcpy (p + 1, filename, flen + 1);
410 else
411 #endif
412 memcpy (p, filename, flen + 1);
414 /* Check if the file is mentioned in a makefile. If *FILE is not
415 a target, that is enough for us to decide this file exists.
416 If *FILE is a target, then the file must be mentioned in the
417 makefile also as a target to be chosen.
419 The restriction that *FILE must not be a target for a
420 makefile-mentioned file to be chosen was added by an
421 inadequately commented change in July 1990; I am not sure off
422 hand what problem it fixes.
424 In December 1993 I loosened this restriction to allow a file
425 to be chosen if it is mentioned as a target in a makefile. This
426 seem logical.
428 Special handling for -W / -o: make sure we preserve the special
429 values here. Actually this whole thing is a little bogus: I think
430 we should ditch the name/hname thing and look into the renamed
431 capability that already exists for files: that is, have a new struct
432 file* entry for the VPATH-found file, and set the renamed field if
433 we use it.
436 struct file *f = lookup_file (name);
437 if (f != 0)
439 exists = not_target || f->is_target;
440 if (exists && mtime_ptr
441 && (f->last_mtime == OLD_MTIME || f->last_mtime == NEW_MTIME))
443 *mtime_ptr = f->last_mtime;
444 mtime_ptr = 0;
449 if (!exists)
451 /* That file wasn't mentioned in the makefile.
452 See if it actually exists. */
454 #ifdef VMS
455 exists_in_cache = exists = dir_file_exists_p (vpath[i], filename);
456 #else
457 /* Clobber a null into the name at the last slash.
458 Now NAME is the name of the directory to look in. */
459 *p = '\0';
461 /* We know the directory is in the hash table now because either
462 construct_vpath_list or the code just above put it there.
463 Does the file we seek exist in it? */
464 exists_in_cache = exists = dir_file_exists_p (name, filename);
465 #endif
468 if (exists)
470 /* The file is in the directory cache.
471 Now check that it actually exists in the filesystem.
472 The cache may be out of date. When vpath thinks a file
473 exists, but stat fails for it, confusion results in the
474 higher levels. */
476 struct stat st;
478 #ifndef VMS
479 /* Put the slash back in NAME. */
480 *p = '/';
481 #endif
483 if (exists_in_cache) /* Makefile-mentioned file need not exist. */
485 int e;
487 EINTRLOOP (e, stat (name, &st)); /* Does it really exist? */
488 if (e != 0)
490 exists = 0;
491 continue;
494 /* Store the modtime into *MTIME_PTR for the caller. */
495 if (mtime_ptr != 0)
497 *mtime_ptr = FILE_TIMESTAMP_STAT_MODTIME (name, st);
498 mtime_ptr = 0;
502 /* We have found a file.
503 If we get here and mtime_ptr hasn't been set, record
504 UNKNOWN_MTIME to indicate this. */
505 if (mtime_ptr != 0)
506 *mtime_ptr = UNKNOWN_MTIME;
508 /* Store the name we found and return it. */
510 if (path_index)
511 *path_index = i;
513 return strcache_add_len (name, (p + 1 - name) + flen);
517 return 0;
521 /* Search the VPATH list whose pattern matches FILE for a directory where FILE
522 exists. If it is found, return the cached name of an existing file, and
523 set *MTIME_PTR (if MTIME_PTR is not NULL) to its modtime (or zero if no
524 stat call was done). Also set the matching directory index in VPATH_INDEX
525 and PATH_INDEX if they are not NULL. Otherwise we return 0. */
527 const char *
528 vpath_search (const char *file, FILE_TIMESTAMP *mtime_ptr,
529 unsigned int* vpath_index, unsigned int* path_index)
531 struct vpath *v;
533 /* If there are no VPATH entries or FILENAME starts at the root,
534 there is nothing we can do. */
536 if (file[0] == '/'
537 #ifdef HAVE_DOS_PATHS
538 || file[0] == '\\' || file[1] == ':'
539 #endif
540 || (vpaths == 0 && general_vpath == 0))
541 return 0;
543 if (vpath_index)
545 *vpath_index = 0;
546 *path_index = 0;
549 for (v = vpaths; v != 0; v = v->next)
551 if (pattern_matches (v->pattern, v->percent, file))
553 const char *p = selective_vpath_search (
554 v, file, mtime_ptr, path_index);
555 if (p)
556 return p;
559 if (vpath_index)
560 ++*vpath_index;
564 if (general_vpath != 0)
566 const char *p = selective_vpath_search (
567 general_vpath, file, mtime_ptr, path_index);
568 if (p)
569 return p;
572 return 0;
578 /* Print the data base of VPATH search paths. */
580 void
581 print_vpath_data_base (void)
583 unsigned int nvpaths;
584 struct vpath *v;
586 puts (_("\n# VPATH Search Paths\n"));
588 nvpaths = 0;
589 for (v = vpaths; v != 0; v = v->next)
591 register unsigned int i;
593 ++nvpaths;
595 printf ("vpath %s ", v->pattern);
597 for (i = 0; v->searchpath[i] != 0; ++i)
598 printf ("%s%c", v->searchpath[i],
599 v->searchpath[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
602 if (vpaths == 0)
603 puts (_("# No `vpath' search paths."));
604 else
605 printf (_("\n# %u `vpath' search paths.\n"), nvpaths);
607 if (general_vpath == 0)
608 puts (_("\n# No general (`VPATH' variable) search path."));
609 else
611 const char **path = general_vpath->searchpath;
612 unsigned int i;
614 fputs (_("\n# General (`VPATH' variable) search path:\n# "), stdout);
616 for (i = 0; path[i] != 0; ++i)
617 printf ("%s%c", path[i],
618 path[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);