1 /* Implementation of pattern-matching file search paths for GNU Make.
2 Copyright (C) 1988-2020 Free Software Foundation, Inc.
3 This file is part of GNU Make.
4
5 GNU Make is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3 of the License, or (at your option) any later
8 version.
9
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License along with
15 this program. If not, see <http://www.gnu.org/licenses/>. */
16
17 #include "makeint.h"
18 #include "filedef.h"
19 #include "variable.h"
20 #ifdef WINDOWS32
21 #include "pathstuff.h"
22 #endif
23
24
25 /* Structure used to represent a selective VPATH searchpath. */
26
27 struct vpath
28 {
29 struct vpath *next; /* Pointer to next struct in the linked list. */
30 const char *pattern; /* The pattern to match. */
31 const char *percent; /* Pointer into 'pattern' where the '%' is. */
32 size_t patlen; /* Length of the pattern. */
33 const char **searchpath; /* Null-terminated list of directories. */
34 size_t maxlen; /* Maximum length of any entry in the list. */
35 };
36
37 /* Linked-list of all selective VPATHs. */
38
39 static struct vpath *vpaths;
40
41 /* Structure for the general VPATH given in the variable. */
42
43 static struct vpath *general_vpath;
44
45 /* Structure for GPATH given in the variable. */
46
47 static struct vpath *gpaths;
48
49
50 /* Reverse the chain of selective VPATH lists so they will be searched in the
51 order given in the makefiles and construct the list from the VPATH
52 variable. */
53
54 void
build_vpath_lists(void)55 build_vpath_lists (void)
56 {
57 struct vpath *new = 0;
58 struct vpath *old, *nexto;
59 char *p;
60
61 /* Reverse the chain. */
62 for (old = vpaths; old != 0; old = nexto)
63 {
64 nexto = old->next;
65 old->next = new;
66 new = old;
67 }
68
69 vpaths = new;
70
71 /* If there is a VPATH variable with a nonnull value, construct the
72 general VPATH list from it. We use variable_expand rather than just
73 calling lookup_variable so that it will be recursively expanded. */
74
75 {
76 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
77 int save = warn_undefined_variables_flag;
78 warn_undefined_variables_flag = 0;
79
80 p = variable_expand ("$(strip $(VPATH))");
81
82 warn_undefined_variables_flag = save;
83 }
84
85 if (*p != '\0')
86 {
87 /* Save the list of vpaths. */
88 struct vpath *save_vpaths = vpaths;
89 char gp[] = "%";
90
91 /* Empty 'vpaths' so the new one will have no next, and 'vpaths'
92 will still be nil if P contains no existing directories. */
93 vpaths = 0;
94
95 /* Parse P. */
96 construct_vpath_list (gp, p);
97
98 /* Store the created path as the general path,
99 and restore the old list of vpaths. */
100 general_vpath = vpaths;
101 vpaths = save_vpaths;
102 }
103
104 /* If there is a GPATH variable with a nonnull value, construct the
105 GPATH list from it. We use variable_expand rather than just
106 calling lookup_variable so that it will be recursively expanded. */
107
108 {
109 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
110 int save = warn_undefined_variables_flag;
111 warn_undefined_variables_flag = 0;
112
113 p = variable_expand ("$(strip $(GPATH))");
114
115 warn_undefined_variables_flag = save;
116 }
117
118 if (*p != '\0')
119 {
120 /* Save the list of vpaths. */
121 struct vpath *save_vpaths = vpaths;
122 char gp[] = "%";
123
124 /* Empty 'vpaths' so the new one will have no next, and 'vpaths'
125 will still be nil if P contains no existing directories. */
126 vpaths = 0;
127
128 /* Parse P. */
129 construct_vpath_list (gp, p);
130
131 /* Store the created path as the GPATH,
132 and restore the old list of vpaths. */
133 gpaths = vpaths;
134 vpaths = save_vpaths;
135 }
136 }
137
138 /* Construct the VPATH listing for the PATTERN and DIRPATH given.
139
140 This function is called to generate selective VPATH lists and also for
141 the general VPATH list (which is in fact just a selective VPATH that
142 is applied to everything). The returned pointer is either put in the
143 linked list of all selective VPATH lists or in the GENERAL_VPATH
144 variable.
145
146 If DIRPATH is nil, remove all previous listings with the same
147 pattern. If PATTERN is nil, remove all VPATH listings. Existing
148 and readable directories that are not "." given in the DIRPATH
149 separated by the path element separator (defined in makeint.h) are
150 loaded into the directory hash table if they are not there already
151 and put in the VPATH searchpath for the given pattern with trailing
152 slashes stripped off if present (and if the directory is not the
153 root, "/"). The length of the longest entry in the list is put in
154 the structure as well. The new entry will be at the head of the
155 VPATHS chain. */
156
157 void
construct_vpath_list(char * pattern,char * dirpath)158 construct_vpath_list (char *pattern, char *dirpath)
159 {
160 unsigned int elem;
161 char *p;
162 const char **vpath;
163 size_t maxvpath;
164 unsigned int maxelem;
165 const char *percent = NULL;
166
167 if (pattern != 0)
168 percent = find_percent (pattern);
169
170 if (dirpath == 0)
171 {
172 /* Remove matching listings. */
173 struct vpath *path, *lastpath;
174
175 lastpath = 0;
176 path = vpaths;
177 while (path != 0)
178 {
179 struct vpath *next = path->next;
180
181 if (pattern == 0
182 || (((percent == 0 && path->percent == 0)
183 || (percent - pattern == path->percent - path->pattern))
184 && streq (pattern, path->pattern)))
185 {
186 /* Remove it from the linked list. */
187 if (lastpath == 0)
188 vpaths = path->next;
189 else
190 lastpath->next = next;
191
192 /* Free its unused storage. */
193 /* MSVC erroneously warns without a cast here. */
194 free ((void *)path->searchpath);
195 free (path);
196 }
197 else
198 lastpath = path;
199
200 path = next;
201 }
202
203 return;
204 }
205
206 #ifdef WINDOWS32
207 convert_vpath_to_windows32 (dirpath, ';');
208 #endif
209
210 /* Skip over any initial separators and blanks. */
211 while (STOP_SET (*dirpath, MAP_BLANK|MAP_PATHSEP))
212 ++dirpath;
213
214 /* Figure out the maximum number of VPATH entries and put it in
215 MAXELEM. We start with 2, one before the first separator and one
216 nil (the list terminator) and increment our estimated number for
217 each separator or blank we find. */
218 maxelem = 2;
219 p = dirpath;
220 while (*p != '\0')
221 if (STOP_SET (*p++, MAP_BLANK|MAP_PATHSEP))
222 ++maxelem;
223
224 vpath = xmalloc (maxelem * sizeof (const char *));
225 maxvpath = 0;
226
227 elem = 0;
228 p = dirpath;
229 while (*p != '\0')
230 {
231 char *v;
232 size_t len;
233
234 /* Find the end of this entry. */
235 v = p;
236 while (*p != '\0'
237 #if defined(HAVE_DOS_PATHS) && (PATH_SEPARATOR_CHAR == ':')
238 /* Platforms whose PATH_SEPARATOR_CHAR is ':' and which
239 also define HAVE_DOS_PATHS would like us to recognize
240 colons after the drive letter in the likes of
241 "D:/foo/bar:C:/xyzzy". */
242 && (*p != PATH_SEPARATOR_CHAR
243 || (p == v + 1 && (p[1] == '/' || p[1] == '\\')))
244 #else
245 && *p != PATH_SEPARATOR_CHAR
246 #endif
247 && !ISBLANK (*p))
248 ++p;
249
250 len = p - v;
251 /* Make sure there's no trailing slash,
252 but still allow "/" as a directory. */
253 #if defined(__MSDOS__) || defined(__EMX__) || defined(HAVE_DOS_PATHS)
254 /* We need also to leave alone a trailing slash in "d:/". */
255 if (len > 3 || (len > 1 && v[1] != ':'))
256 #endif
257 if (len > 1 && p[-1] == '/')
258 --len;
259
260 /* Put the directory on the vpath list. */
261 if (len > 1 || *v != '.')
262 {
263 vpath[elem++] = dir_name (strcache_add_len (v, len));
264 if (len > maxvpath)
265 maxvpath = len;
266 }
267
268 /* Skip over separators and blanks between entries. */
269 while (STOP_SET (*p, MAP_BLANK|MAP_PATHSEP))
270 ++p;
271 }
272
273 if (elem > 0)
274 {
275 struct vpath *path;
276 /* ELEM is now incremented one element past the last
277 entry, to where the nil-pointer terminator goes.
278 Usually this is maxelem - 1. If not, shrink down. */
279 if (elem < (maxelem - 1))
280 vpath = xrealloc (vpath, (elem+1) * sizeof (const char *));
281
282 /* Put the nil-pointer terminator on the end of the VPATH list. */
283 vpath[elem] = NULL;
284
285 /* Construct the vpath structure and put it into the linked list. */
286 path = xmalloc (sizeof (struct vpath));
287 path->searchpath = vpath;
288 path->maxlen = maxvpath;
289 path->next = vpaths;
290 vpaths = path;
291
292 /* Set up the members. */
293 path->pattern = strcache_add (pattern);
294 path->patlen = strlen (pattern);
295 path->percent = percent ? path->pattern + (percent - pattern) : 0;
296 }
297 else
298 /* There were no entries, so free whatever space we allocated. */
299 /* MSVC erroneously warns without a cast here. */
300 free ((void *)vpath);
301 }
302
303 /* Search the GPATH list for a pathname string that matches the one passed
304 in. If it is found, return 1. Otherwise we return 0. */
305
306 int
gpath_search(const char * file,size_t len)307 gpath_search (const char *file, size_t len)
308 {
309 if (gpaths && (len <= gpaths->maxlen))
310 {
311 const char **gp;
312 for (gp = gpaths->searchpath; *gp != NULL; ++gp)
313 if (strneq (*gp, file, len) && (*gp)[len] == '\0')
314 return 1;
315 }
316
317 return 0;
318 }
319
320
321 /* Search the given VPATH list for a directory where the name pointed to by
322 FILE exists. If it is found, we return a cached name of the existing file
323 and set *MTIME_PTR (if MTIME_PTR is not NULL) to its modtime (or zero if no
324 stat call was done). Also set the matching directory index in PATH_INDEX
325 if it is not NULL. Otherwise we return NULL. */
326
327 static const char *
selective_vpath_search(struct vpath * path,const char * file,FILE_TIMESTAMP * mtime_ptr,unsigned int * path_index)328 selective_vpath_search (struct vpath *path, const char *file,
329 FILE_TIMESTAMP *mtime_ptr, unsigned int* path_index)
330 {
331 int not_target;
332 char *name;
333 const char *n;
334 const char *filename;
335 const char **vpath = path->searchpath;
336 size_t maxvpath = path->maxlen;
337 unsigned int i;
338 size_t flen, name_dplen;
339 int exists = 0;
340
341 /* Find out if *FILE is a target.
342 If and only if it is NOT a target, we will accept prospective
343 files that don't exist but are mentioned in a makefile. */
344 {
345 struct file *f = lookup_file (file);
346 not_target = f == 0 || !f->is_target;
347 }
348
349 flen = strlen (file);
350
351 /* Split *FILE into a directory prefix and a name-within-directory.
352 NAME_DPLEN gets the length of the prefix; FILENAME gets the pointer to
353 the name-within-directory and FLEN is its length. */
354
355 n = strrchr (file, '/');
356 #ifdef HAVE_DOS_PATHS
357 /* We need the rightmost slash or backslash. */
358 {
359 const char *bslash = strrchr (file, '\\');
360 if (!n || bslash > n)
361 n = bslash;
362 }
363 #endif
364 name_dplen = n != 0 ? n - file : 0;
365 filename = name_dplen > 0 ? n + 1 : file;
366 if (name_dplen > 0)
367 flen -= name_dplen + 1;
368
369 /* Get enough space for the biggest VPATH entry, a slash, the directory
370 prefix that came with FILE, another slash (although this one may not
371 always be necessary), the filename, and a null terminator. */
372 name = alloca (maxvpath + 1 + name_dplen + 1 + flen + 1);
373
374 /* Try each VPATH entry. */
375 for (i = 0; vpath[i] != 0; ++i)
376 {
377 int exists_in_cache = 0;
378 char *p = name;
379 size_t vlen = strlen (vpath[i]);
380
381 /* Put the next VPATH entry into NAME at P and increment P past it. */
382 memcpy (p, vpath[i], vlen);
383 p += vlen;
384
385 /* Add the directory prefix already in *FILE. */
386 if (name_dplen > 0)
387 {
388 #ifndef VMS
389 *p++ = '/';
390 #else
391 /* VMS: if this is not in VMS format, treat as Unix format */
392 if ((*p != ':') && (*p != ']') && (*p != '>'))
393 *p++ = '/';
394 #endif
395 memcpy (p, file, name_dplen);
396 p += name_dplen;
397 }
398
399 #ifdef HAVE_DOS_PATHS
400 /* Cause the next if to treat backslash and slash alike. */
401 if (p != name && p[-1] == '\\' )
402 p[-1] = '/';
403 #endif
404 /* Now add the name-within-directory at the end of NAME. */
405 #ifndef VMS
406 if (p != name && p[-1] != '/')
407 {
408 *p = '/';
409 memcpy (p + 1, filename, flen + 1);
410 }
411 else
412 #else
413 /* VMS use a slash if no directory terminator present */
414 if (p != name && p[-1] != '/' && p[-1] != ':' &&
415 p[-1] != '>' && p[-1] != ']')
416 {
417 *p = '/';
418 memcpy (p + 1, filename, flen + 1);
419 }
420 else
421 #endif
422 memcpy (p, filename, flen + 1);
423
424 /* Check if the file is mentioned in a makefile. If *FILE is not
425 a target, that is enough for us to decide this file exists.
426 If *FILE is a target, then the file must be mentioned in the
427 makefile also as a target to be chosen.
428
429 The restriction that *FILE must not be a target for a
430 makefile-mentioned file to be chosen was added by an
431 inadequately commented change in July 1990; I am not sure off
432 hand what problem it fixes.
433
434 In December 1993 I loosened this restriction to allow a file
435 to be chosen if it is mentioned as a target in a makefile. This
436 seem logical.
437
438 Special handling for -W / -o: make sure we preserve the special
439 values here. Actually this whole thing is a little bogus: I think
440 we should ditch the name/hname thing and look into the renamed
441 capability that already exists for files: that is, have a new struct
442 file* entry for the VPATH-found file, and set the renamed field if
443 we use it.
444 */
445 {
446 struct file *f = lookup_file (name);
447 if (f != 0)
448 {
449 exists = not_target || f->is_target;
450 if (exists && mtime_ptr
451 && (f->last_mtime == OLD_MTIME || f->last_mtime == NEW_MTIME))
452 {
453 *mtime_ptr = f->last_mtime;
454 mtime_ptr = 0;
455 }
456 }
457 }
458
459 if (!exists)
460 {
461 /* That file wasn't mentioned in the makefile.
462 See if it actually exists. */
463
464 #ifdef VMS
465 /* For VMS syntax just use the original vpath */
466 if (*p != '/')
467 exists_in_cache = exists = dir_file_exists_p (vpath[i], filename);
468 else
469 #endif
470 {
471 /* Clobber a null into the name at the last slash.
472 Now NAME is the name of the directory to look in. */
473 *p = '\0';
474 /* We know the directory is in the hash table now because either
475 construct_vpath_list or the code just above put it there.
476 Does the file we seek exist in it? */
477 exists_in_cache = exists = dir_file_exists_p (name, filename);
478 }
479 }
480
481 if (exists)
482 {
483 /* The file is in the directory cache.
484 Now check that it actually exists in the filesystem.
485 The cache may be out of date. When vpath thinks a file
486 exists, but stat fails for it, confusion results in the
487 higher levels. */
488
489 struct stat st;
490
491 #ifndef VMS
492 /* Put the slash back in NAME. */
493 *p = '/';
494 #else
495 /* If the slash was removed, put it back */
496 if (*p == 0)
497 *p = '/';
498 #endif
499
500 if (exists_in_cache) /* Makefile-mentioned file need not exist. */
501 {
502 int e;
503
504 EINTRLOOP (e, stat (name, &st)); /* Does it really exist? */
505 if (e != 0)
506 {
507 exists = 0;
508 continue;
509 }
510
511 /* Store the modtime into *MTIME_PTR for the caller. */
512 if (mtime_ptr != 0)
513 {
514 *mtime_ptr = FILE_TIMESTAMP_STAT_MODTIME (name, st);
515 mtime_ptr = 0;
516 }
517 }
518
519 /* We have found a file.
520 If we get here and mtime_ptr hasn't been set, record
521 UNKNOWN_MTIME to indicate this. */
522 if (mtime_ptr != 0)
523 *mtime_ptr = UNKNOWN_MTIME;
524
525 /* Store the name we found and return it. */
526
527 if (path_index)
528 *path_index = i;
529
530 return strcache_add_len (name, (p + 1 - name) + flen);
531 }
532 }
533
534 return 0;
535 }
536
537
538 /* Search the VPATH list whose pattern matches FILE for a directory where FILE
539 exists. If it is found, return the cached name of an existing file, and
540 set *MTIME_PTR (if MTIME_PTR is not NULL) to its modtime (or zero if no
541 stat call was done). Also set the matching directory index in VPATH_INDEX
542 and PATH_INDEX if they are not NULL. Otherwise we return 0. */
543
544 const char *
vpath_search(const char * file,FILE_TIMESTAMP * mtime_ptr,unsigned int * vpath_index,unsigned int * path_index)545 vpath_search (const char *file, FILE_TIMESTAMP *mtime_ptr,
546 unsigned int* vpath_index, unsigned int* path_index)
547 {
548 struct vpath *v;
549
550 /* If there are no VPATH entries or FILENAME starts at the root,
551 there is nothing we can do. */
552
553 if (file[0] == '/'
554 #ifdef HAVE_DOS_PATHS
555 || file[0] == '\\' || file[1] == ':'
556 #endif
557 || (vpaths == 0 && general_vpath == 0))
558 return 0;
559
560 if (vpath_index)
561 {
562 *vpath_index = 0;
563 *path_index = 0;
564 }
565
566 for (v = vpaths; v != 0; v = v->next)
567 {
568 if (pattern_matches (v->pattern, v->percent, file))
569 {
570 const char *p = selective_vpath_search (
571 v, file, mtime_ptr, path_index);
572 if (p)
573 return p;
574 }
575
576 if (vpath_index)
577 ++*vpath_index;
578 }
579
580
581 if (general_vpath != 0)
582 {
583 const char *p = selective_vpath_search (
584 general_vpath, file, mtime_ptr, path_index);
585 if (p)
586 return p;
587 }
588
589 return 0;
590 }
591
592
593
594
595 /* Print the data base of VPATH search paths. */
596
597 void
print_vpath_data_base(void)598 print_vpath_data_base (void)
599 {
600 unsigned int nvpaths;
601 struct vpath *v;
602
603 puts (_("\n# VPATH Search Paths\n"));
604
605 nvpaths = 0;
606 for (v = vpaths; v != 0; v = v->next)
607 {
608 unsigned int i;
609
610 ++nvpaths;
611
612 printf ("vpath %s ", v->pattern);
613
614 for (i = 0; v->searchpath[i] != 0; ++i)
615 printf ("%s%c", v->searchpath[i],
616 v->searchpath[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
617 }
618
619 if (vpaths == 0)
620 puts (_("# No 'vpath' search paths."));
621 else
622 printf (_("\n# %u 'vpath' search paths.\n"), nvpaths);
623
624 if (general_vpath == 0)
625 puts (_("\n# No general ('VPATH' variable) search path."));
626 else
627 {
628 const char **path = general_vpath->searchpath;
629 unsigned int i;
630
631 fputs (_("\n# General ('VPATH' variable) search path:\n# "), stdout);
632
633 for (i = 0; path[i] != 0; ++i)
634 printf ("%s%c", path[i],
635 path[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
636 }
637 }
638