1 /* Implementation of pattern-matching file search paths for GNU Make.
2 Copyright (C) 1988,89,91,92,93,94,95,96,97 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #include "pathstuff.h"
27 /* Structure used to represent a selective VPATH searchpath. */
31 struct vpath
*next
; /* Pointer to next struct in the linked list. */
32 char *pattern
; /* The pattern to match. */
33 char *percent
; /* Pointer into `pattern' where the `%' is. */
34 unsigned int patlen
;/* Length of the pattern. */
35 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
;
51 static int selective_vpath_search
PARAMS ((struct vpath
*path
, char **file
, time_t *mtime_ptr
));
53 /* Reverse the chain of selective VPATH lists so they
54 will be searched in the order given in the makefiles
55 and construct the list from the VPATH variable. */
60 register struct vpath
*new = 0;
61 register struct vpath
*old
, *nexto
;
64 /* Reverse the chain. */
65 for (old
= vpaths
; old
!= 0; old
= nexto
)
74 /* If there is a VPATH variable with a nonnull value, construct the
75 general VPATH list from it. We use variable_expand rather than just
76 calling lookup_variable so that it will be recursively expanded. */
79 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
80 int save
= warn_undefined_variables_flag
;
81 warn_undefined_variables_flag
= 0;
83 p
= variable_expand ("$(strip $(VPATH))");
85 warn_undefined_variables_flag
= save
;
90 /* Save the list of vpaths. */
91 struct vpath
*save_vpaths
= vpaths
;
93 /* Empty `vpaths' so the new one will have no next, and `vpaths'
94 will still be nil if P contains no existing directories. */
98 construct_vpath_list ("%", 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
;
122 /* Save the list of vpaths. */
123 struct vpath
*save_vpaths
= vpaths
;
125 /* Empty `vpaths' so the new one will have no next, and `vpaths'
126 will still be nil if P contains no existing directories. */
130 construct_vpath_list ("%", p
);
132 /* Store the created path as the GPATH,
133 and restore the old list of vpaths. */
135 vpaths
= save_vpaths
;
139 /* Construct the VPATH listing for the pattern and searchpath given.
141 This function is called to generate selective VPATH lists and also for
142 the general VPATH list (which is in fact just a selective VPATH that
143 is applied to everything). The returned pointer is either put in the
144 linked list of all selective VPATH lists or in the GENERAL_VPATH
147 If SEARCHPATH is nil, remove all previous listings with the same
148 pattern. If PATTERN is nil, remove all VPATH listings. Existing
149 and readable directories that are not "." given in the searchpath
150 separated by the path element separator (defined in make.h) are
151 loaded into the directory hash table if they are not there already
152 and put in the VPATH searchpath for the given pattern with trailing
153 slashes stripped off if present (and if the directory is not the
154 root, "/"). The length of the longest entry in the list is put in
155 the structure as well. The new entry will be at the head of the
159 construct_vpath_list (pattern
, dirpath
)
160 char *pattern
, *dirpath
;
162 register unsigned int elem
;
164 register char **vpath
;
165 register unsigned int maxvpath
;
166 unsigned int maxelem
;
171 pattern
= savestring (pattern
, strlen (pattern
));
172 percent
= find_percent (pattern
);
177 /* Remove matching listings. */
178 register struct vpath
*path
, *lastpath
;
184 struct vpath
*next
= path
->next
;
187 || (((percent
== 0 && path
->percent
== 0)
188 || (percent
- pattern
== path
->percent
- path
->pattern
))
189 && streq (pattern
, path
->pattern
)))
191 /* Remove it from the linked list. */
195 lastpath
->next
= next
;
197 /* Free its unused storage. */
198 free (path
->pattern
);
199 free ((char *) path
->searchpath
);
200 free ((char *) path
);
214 convert_vpath_to_windows32(dirpath
, ';');
217 /* Figure out the maximum number of VPATH entries and put it in
218 MAXELEM. We start with 2, one before the first separator and one
219 nil (the list terminator) and increment our estimated number for
220 each separator or blank we find. */
224 if (*p
++ == PATH_SEPARATOR_CHAR
|| isblank (*p
))
227 vpath
= (char **) xmalloc (maxelem
* sizeof (char *));
230 /* Skip over any initial separators and blanks. */
232 while (*p
== PATH_SEPARATOR_CHAR
|| isblank (*p
))
241 /* Find the end of this entry. */
243 while (*p
!= '\0' && *p
!= PATH_SEPARATOR_CHAR
&& !isblank (*p
))
247 /* Make sure there's no trailing slash,
248 but still allow "/" as a directory. */
250 /* We need also to leave alone a trailing slash in "d:/". */
251 if (len
> 3 || (len
> 1 && v
[1] != ':'))
253 if (len
> 1 && p
[-1] == '/')
256 if (len
> 1 || *v
!= '.')
258 v
= savestring (v
, len
);
260 /* Verify that the directory actually exists. */
262 if (dir_file_exists_p (v
, ""))
264 /* It does. Put it in the list. */
265 vpath
[elem
++] = dir_name (v
);
271 /* The directory does not exist. Omit from the list. */
275 /* Skip over separators and blanks between entries. */
276 while (*p
== PATH_SEPARATOR_CHAR
|| isblank (*p
))
283 /* ELEM is now incremented one element past the last
284 entry, to where the nil-pointer terminator goes.
285 Usually this is maxelem - 1. If not, shrink down. */
286 if (elem
< (maxelem
- 1))
287 vpath
= (char **) xrealloc ((char *) vpath
,
288 (elem
+ 1) * sizeof (char *));
290 /* Put the nil-pointer terminator on the end of the VPATH list. */
293 /* Construct the vpath structure and put it into the linked list. */
294 path
= (struct vpath
*) xmalloc (sizeof (struct vpath
));
295 path
->searchpath
= vpath
;
296 path
->maxlen
= maxvpath
;
300 /* Set up the members. */
301 path
->pattern
= pattern
;
302 path
->percent
= percent
;
303 path
->patlen
= strlen (pattern
);
307 /* There were no entries, so free whatever space we allocated. */
308 free ((char *) vpath
);
314 /* Search the GPATH list for a pathname string that matches the one passed
315 in. If it is found, return 1. Otherwise we return 0. */
318 gpath_search (file
, len
)
324 if (gpaths
&& (len
<= gpaths
->maxlen
))
325 for (gp
= gpaths
->searchpath
; *gp
!= NULL
; ++gp
)
326 if (!strncmp(*gp
, file
, len
) && (*gp
)[len
] == '\0')
332 /* Search the VPATH list whose pattern matches *FILE for a directory
333 where the name pointed to by FILE exists. If it is found, we set *FILE to
334 the newly malloc'd name of the existing file, *MTIME_PTR (if MTIME_PTR is
335 not NULL) to its modtime (or zero if no stat call was done), and return 1.
336 Otherwise we return 0. */
339 vpath_search (file
, mtime_ptr
)
343 register struct vpath
*v
;
345 /* If there are no VPATH entries or FILENAME starts at the root,
346 there is nothing we can do. */
349 #if defined (WINDOWS32) || defined (__MSDOS__)
353 || (vpaths
== 0 && general_vpath
== 0))
356 for (v
= vpaths
; v
!= 0; v
= v
->next
)
357 if (pattern_matches (v
->pattern
, v
->percent
, *file
))
358 if (selective_vpath_search (v
, file
, mtime_ptr
))
361 if (general_vpath
!= 0
362 && selective_vpath_search (general_vpath
, file
, mtime_ptr
))
369 /* Search the given VPATH list for a directory where the name pointed
370 to by FILE exists. If it is found, we set *FILE to the newly malloc'd
371 name of the existing file, *MTIME_PTR (if MTIME_PTR is not NULL) to
372 its modtime (or zero if no stat call was done), and we return 1.
373 Otherwise we return 0. */
376 selective_vpath_search (path
, file
, mtime_ptr
)
384 register char **vpath
= path
->searchpath
;
385 unsigned int maxvpath
= path
->maxlen
;
386 register unsigned int i
;
387 unsigned int flen
, vlen
, name_dplen
;
390 /* Find out if *FILE is a target.
391 If and only if it is NOT a target, we will accept prospective
392 files that don't exist but are mentioned in a makefile. */
394 struct file
*f
= lookup_file (*file
);
395 not_target
= f
== 0 || !f
->is_target
;
398 flen
= strlen (*file
);
400 /* Split *FILE into a directory prefix and a name-within-directory.
401 NAME_DPLEN gets the length of the prefix; FILENAME gets the
402 pointer to the name-within-directory and FLEN is its length. */
404 n
= rindex (*file
, '/');
405 #if defined (WINDOWS32) || defined (__MSDOS__)
406 /* We need the rightmost slash or backslash. */
408 char *bslash
= rindex(*file
, '\\');
409 if (!n
|| bslash
> n
)
413 name_dplen
= n
!= 0 ? n
- *file
: 0;
414 filename
= name_dplen
> 0 ? n
+ 1 : *file
;
416 flen
-= name_dplen
+ 1;
418 /* Allocate enough space for the biggest VPATH entry,
419 a slash, the directory prefix that came with *FILE,
420 another slash (although this one may not always be
421 necessary), the filename, and a null terminator. */
422 name
= (char *) xmalloc (maxvpath
+ 1 + name_dplen
+ 1 + flen
+ 1);
424 /* Try each VPATH entry. */
425 for (i
= 0; vpath
[i
] != 0; ++i
)
427 int exists_in_cache
= 0;
431 /* Put the next VPATH entry into NAME at N and increment N past it. */
432 vlen
= strlen (vpath
[i
]);
433 bcopy (vpath
[i
], n
, vlen
);
436 /* Add the directory prefix already in *FILE. */
442 bcopy (*file
, n
, name_dplen
);
446 #if defined (WINDOWS32) || defined (__MSDOS__)
447 /* Cause the next if to treat backslash and slash alike. */
448 if (n
!= name
&& n
[-1] == '\\' )
451 /* Now add the name-within-directory at the end of NAME. */
453 if (n
!= name
&& n
[-1] != '/')
456 bcopy (filename
, n
+ 1, flen
+ 1);
460 bcopy (filename
, n
, flen
+ 1);
462 /* Check if the file is mentioned in a makefile. If *FILE is not
463 a target, that is enough for us to decide this file exists.
464 If *FILE is a target, then the file must be mentioned in the
465 makefile also as a target to be chosen.
467 The restriction that *FILE must not be a target for a
468 makefile-mentioned file to be chosen was added by an
469 inadequately commented change in July 1990; I am not sure off
470 hand what problem it fixes.
472 In December 1993 I loosened this restriction to allow a file
473 to be chosen if it is mentioned as a target in a makefile. This
476 struct file
*f
= lookup_file (name
);
478 exists
= not_target
|| f
->is_target
;
483 /* That file wasn't mentioned in the makefile.
484 See if it actually exists. */
487 exists_in_cache
= exists
= dir_file_exists_p (vpath
[i
], filename
);
489 /* Clobber a null into the name at the last slash.
490 Now NAME is the name of the directory to look in. */
493 /* We know the directory is in the hash table now because either
494 construct_vpath_list or the code just above put it there.
495 Does the file we seek exist in it? */
496 exists_in_cache
= exists
= dir_file_exists_p (name
, filename
);
502 /* The file is in the directory cache.
503 Now check that it actually exists in the filesystem.
504 The cache may be out of date. When vpath thinks a file
505 exists, but stat fails for it, confusion results in the
511 /* Put the slash back in NAME. */
515 if (!exists_in_cache
/* Makefile-mentioned file need not exist. */
516 || stat (name
, &st
) == 0) /* Does it really exist? */
518 /* We have found a file.
519 Store the name we found into *FILE for the caller. */
521 *file
= savestring (name
, (n
+ 1 - name
) + flen
);
524 /* Store the modtime into *MTIME_PTR for the caller.
525 If we have had no need to stat the file here,
526 we record a zero modtime to indicate this. */
527 *mtime_ptr
= exists_in_cache
? st
.st_mtime
: (time_t) 0;
541 /* Print the data base of VPATH search paths. */
544 print_vpath_data_base ()
546 register unsigned int nvpaths
;
547 register struct vpath
*v
;
549 puts ("\n# VPATH Search Paths\n");
552 for (v
= vpaths
; v
!= 0; v
= v
->next
)
554 register unsigned int i
;
558 printf ("vpath %s ", v
->pattern
);
560 for (i
= 0; v
->searchpath
[i
] != 0; ++i
)
561 printf ("%s%c", v
->searchpath
[i
],
562 v
->searchpath
[i
+ 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR
);
566 puts ("# No `vpath' search paths.");
568 printf ("\n# %u `vpath' search paths.\n", nvpaths
);
570 if (general_vpath
== 0)
571 puts ("\n# No general (`VPATH' variable) search path.");
574 register char **path
= general_vpath
->searchpath
;
575 register unsigned int i
;
577 fputs ("\n# General (`VPATH' variable) search path:\n# ", stdout
);
579 for (i
= 0; path
[i
] != 0; ++i
)
580 printf ("%s%c", path
[i
],
581 path
[i
+ 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR
);