Annotation of src/usr.bin/make/dir.c, Revision 1.55
1.54 christos 1: /* $NetBSD: dir.c,v 1.53 2007/01/01 21:31:51 dsl Exp $ */
1.8 christos 2:
1.1 cgd 3: /*
4: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
1.37 agc 5: * All rights reserved.
6: *
7: * This code is derived from software contributed to Berkeley by
8: * Adam de Boor.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. Neither the name of the University nor the names of its contributors
19: * may be used to endorse or promote products derived from this software
20: * without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32: * SUCH DAMAGE.
33: */
34:
35: /*
1.1 cgd 36: * Copyright (c) 1988, 1989 by Adam de Boor
37: * Copyright (c) 1989 by Berkeley Softworks
38: * All rights reserved.
39: *
40: * This code is derived from software contributed to Berkeley by
41: * Adam de Boor.
42: *
43: * Redistribution and use in source and binary forms, with or without
44: * modification, are permitted provided that the following conditions
45: * are met:
46: * 1. Redistributions of source code must retain the above copyright
47: * notice, this list of conditions and the following disclaimer.
48: * 2. Redistributions in binary form must reproduce the above copyright
49: * notice, this list of conditions and the following disclaimer in the
50: * documentation and/or other materials provided with the distribution.
51: * 3. All advertising materials mentioning features or use of this software
52: * must display the following acknowledgement:
53: * This product includes software developed by the University of
54: * California, Berkeley and its contributors.
55: * 4. Neither the name of the University nor the names of its contributors
56: * may be used to endorse or promote products derived from this software
57: * without specific prior written permission.
58: *
59: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69: * SUCH DAMAGE.
70: */
71:
1.41 ross 72: #ifndef MAKE_NATIVE
1.54 christos 73: static char rcsid[] = "$NetBSD: dir.c,v 1.53 2007/01/01 21:31:51 dsl Exp $";
1.20 lukem 74: #else
1.19 christos 75: #include <sys/cdefs.h>
1.1 cgd 76: #ifndef lint
1.8 christos 77: #if 0
1.12 christos 78: static char sccsid[] = "@(#)dir.c 8.2 (Berkeley) 1/2/94";
1.8 christos 79: #else
1.54 christos 80: __RCSID("$NetBSD: dir.c,v 1.53 2007/01/01 21:31:51 dsl Exp $");
1.8 christos 81: #endif
1.1 cgd 82: #endif /* not lint */
1.20 lukem 83: #endif
1.1 cgd 84:
85: /*-
86: * dir.c --
87: * Directory searching using wildcards and/or normal names...
88: * Used both for source wildcarding in the Makefile and for finding
89: * implicit sources.
90: *
91: * The interface for this module is:
92: * Dir_Init Initialize the module.
93: *
1.35 sjg 94: * Dir_InitCur Set the cur Path.
95: *
96: * Dir_InitDot Set the dot Path.
97: *
1.6 jtc 98: * Dir_End Cleanup the module.
99: *
1.35 sjg 100: * Dir_SetPATH Set ${.PATH} to reflect state of dirSearchPath.
101: *
1.1 cgd 102: * Dir_HasWildcards Returns TRUE if the name given it needs to
103: * be wildcard-expanded.
104: *
105: * Dir_Expand Given a pattern and a path, return a Lst of names
106: * which match the pattern on the search path.
107: *
108: * Dir_FindFile Searches for a file on a given search path.
109: * If it exists, the entire path is returned.
110: * Otherwise NULL is returned.
111: *
1.40 chuck 112: * Dir_FindHereOrAbove Search for a path in the current directory and
113: * then all the directories above it in turn until
114: * the path is found or we reach the root ("/").
115: *
1.1 cgd 116: * Dir_MTime Return the modification time of a node. The file
117: * is searched for along the default search path.
118: * The path and mtime fields of the node are filled
119: * in.
120: *
121: * Dir_AddDir Add a directory to a search path.
122: *
123: * Dir_MakeFlags Given a search path and a command flag, create
124: * a string with each of the directories in the path
125: * preceded by the command flag and all of them
126: * separated by a space.
127: *
128: * Dir_Destroy Destroy an element of a search path. Frees up all
129: * things that can be freed for the element as long
130: * as the element is no longer referenced by any other
131: * search path.
132: * Dir_ClearPath Resets a search path to the empty list.
133: *
134: * For debugging:
135: * Dir_PrintDirectories Print stats about the directory cache.
136: */
137:
138: #include <sys/types.h>
1.34 wiz 139: #include <sys/stat.h>
140:
1.5 cgd 141: #include <dirent.h>
1.34 wiz 142: #include <errno.h>
143: #include <stdio.h>
144:
1.1 cgd 145: #include "make.h"
146: #include "hash.h"
1.5 cgd 147: #include "dir.h"
1.1 cgd 148:
149: /*
150: * A search path consists of a Lst of Path structures. A Path structure
151: * has in it the name of the directory and a hash table of all the files
152: * in the directory. This is used to cut down on the number of system
153: * calls necessary to find implicit dependents and their like. Since
154: * these searches are made before any actions are taken, we need not
155: * worry about the directory changing due to creation commands. If this
156: * hampers the style of some makefiles, they must be changed.
157: *
158: * A list of all previously-read directories is kept in the
159: * openDirectories Lst. This list is checked first before a directory
160: * is opened.
161: *
162: * The need for the caching of whole directories is brought about by
163: * the multi-level transformation code in suff.c, which tends to search
164: * for far more files than regular make does. In the initial
165: * implementation, the amount of time spent performing "stat" calls was
166: * truly astronomical. The problem with hashing at the start is,
167: * of course, that pmake doesn't then detect changes to these directories
168: * during the course of the make. Three possibilities suggest themselves:
169: *
170: * 1) just use stat to test for a file's existence. As mentioned
171: * above, this is very inefficient due to the number of checks
172: * engendered by the multi-level transformation code.
173: * 2) use readdir() and company to search the directories, keeping
174: * them open between checks. I have tried this and while it
175: * didn't slow down the process too much, it could severely
176: * affect the amount of parallelism available as each directory
177: * open would take another file descriptor out of play for
178: * handling I/O for another job. Given that it is only recently
179: * that UNIX OS's have taken to allowing more than 20 or 32
180: * file descriptors for a process, this doesn't seem acceptable
181: * to me.
182: * 3) record the mtime of the directory in the Path structure and
183: * verify the directory hasn't changed since the contents were
184: * hashed. This will catch the creation or deletion of files,
185: * but not the updating of files. However, since it is the
186: * creation and deletion that is the problem, this could be
187: * a good thing to do. Unfortunately, if the directory (say ".")
188: * were fairly large and changed fairly frequently, the constant
189: * rehashing could seriously degrade performance. It might be
190: * good in such cases to keep track of the number of rehashes
191: * and if the number goes over a (small) limit, resort to using
192: * stat in its place.
193: *
194: * An additional thing to consider is that pmake is used primarily
195: * to create C programs and until recently pcc-based compilers refused
196: * to allow you to specify where the resulting object file should be
197: * placed. This forced all objects to be created in the current
198: * directory. This isn't meant as a full excuse, just an explanation of
199: * some of the reasons for the caching used here.
200: *
201: * One more note: the location of a target's file is only performed
202: * on the downward traversal of the graph and then only for terminal
203: * nodes in the graph. This could be construed as wrong in some cases,
204: * but prevents inadvertent modification of files when the "installed"
205: * directory for a file is provided in the search path.
206: *
207: * Another data structure maintained by this module is an mtime
208: * cache used when the searching of cached directories fails to find
209: * a file. In the past, Dir_FindFile would simply perform an access()
210: * call in such a case to determine if the file could be found using
211: * just the name given. When this hit, however, all that was gained
212: * was the knowledge that the file existed. Given that an access() is
213: * essentially a stat() without the copyout() call, and that the same
214: * filesystem overhead would have to be incurred in Dir_MTime, it made
215: * sense to replace the access() with a stat() and record the mtime
216: * in a cache for when Dir_MTime was actually called.
217: */
218:
219: Lst dirSearchPath; /* main search path */
220:
221: static Lst openDirectories; /* the list of all open directories */
222:
223: /*
224: * Variables for gathering statistics on the efficiency of the hashing
225: * mechanism.
226: */
227: static int hits, /* Found in directory cache */
228: misses, /* Sad, but not evil misses */
229: nearmisses, /* Found under search path */
230: bigmisses; /* Sought by itself */
231:
232: static Path *dot; /* contents of current directory */
1.17 gwr 233: static Path *cur; /* contents of current directory, if not dot */
1.21 thorpej 234: static Path *dotLast; /* a fake path entry indicating we need to
235: * look for . last */
1.1 cgd 236: static Hash_Table mtimes; /* Results of doing a last-resort stat in
237: * Dir_FindFile -- if we have to go to the
238: * system to find the file, we might as well
239: * have its mtime on record. XXX: If this is done
240: * way early, there's a chance other rules will
241: * have already updated the file, in which case
242: * we'll update it again. Generally, there won't
243: * be two rules to update a single file, so this
244: * should be ok, but... */
245:
246:
1.34 wiz 247: static int DirFindName(ClientData, ClientData);
1.36 christos 248: static int DirMatchFiles(const char *, Path *, Lst);
249: static void DirExpandCurly(const char *, const char *, Lst, Lst);
250: static void DirExpandInt(const char *, Lst, Lst);
1.34 wiz 251: static int DirPrintWord(ClientData, ClientData);
252: static int DirPrintDir(ClientData, ClientData);
1.36 christos 253: static char *DirLookup(Path *, const char *, const char *, Boolean);
254: static char *DirLookupSubdir(Path *, const char *);
255: static char *DirFindDot(Boolean, const char *, const char *);
256: static char *DirLookupAbs(Path *, const char *, const char *);
1.5 cgd 257:
1.1 cgd 258: /*-
259: *-----------------------------------------------------------------------
260: * Dir_Init --
261: * initialize things for this module
262: *
263: * Results:
264: * none
265: *
266: * Side Effects:
267: * some directories may be opened.
268: *-----------------------------------------------------------------------
269: */
270: void
1.45 christos 271: Dir_Init(const char *cdname)
1.1 cgd 272: {
1.45 christos 273: dirSearchPath = Lst_Init(FALSE);
274: openDirectories = Lst_Init(FALSE);
1.1 cgd 275: Hash_InitTable(&mtimes, 0);
1.12 christos 276:
1.35 sjg 277: Dir_InitCur(cdname);
278:
1.45 christos 279: dotLast = emalloc(sizeof(Path));
1.35 sjg 280: dotLast->refCount = 1;
281: dotLast->hits = 0;
282: dotLast->name = estrdup(".DOTLAST");
1.45 christos 283: Hash_InitTable(&dotLast->files, -1);
1.35 sjg 284: }
285:
286: /*
287: * Called by Dir_Init() and whenever .CURDIR is assigned to.
288: */
289: void
1.45 christos 290: Dir_InitCur(const char *cdname)
1.35 sjg 291: {
292: Path *p;
293:
1.17 gwr 294: if (cdname != NULL) {
295: /*
296: * Our build directory is not the same as our source directory.
297: * Keep this one around too.
298: */
1.55 ! christos 299: if ((p = Dir_AddDir(NULL, cdname))) {
1.35 sjg 300: p->refCount += 1;
301: if (cur && cur != p) {
302: /*
303: * We've been here before, cleanup.
304: */
305: cur->refCount -= 1;
1.51 dsl 306: Dir_Destroy(cur);
1.35 sjg 307: }
308: cur = p;
309: }
1.17 gwr 310: }
1.28 tv 311: }
312:
313: /*-
314: *-----------------------------------------------------------------------
315: * Dir_InitDot --
316: * (re)initialize "dot" (current/object directory) path hash
317: *
318: * Results:
319: * none
320: *
321: * Side Effects:
322: * some directories may be opened.
323: *-----------------------------------------------------------------------
324: */
325: void
1.34 wiz 326: Dir_InitDot(void)
1.28 tv 327: {
328: if (dot != NULL) {
329: LstNode ln;
330:
331: /* Remove old entry from openDirectories, but do not destroy. */
1.51 dsl 332: ln = Lst_Member(openDirectories, dot);
1.46 christos 333: (void)Lst_Remove(openDirectories, ln);
1.28 tv 334: }
335:
1.45 christos 336: dot = Dir_AddDir(NULL, ".");
1.28 tv 337:
338: if (dot == NULL) {
339: Error("Cannot open `.' (%s)", strerror(errno));
340: exit(1);
341: }
342:
343: /*
344: * We always need to have dot around, so we increment its reference count
345: * to make sure it's not destroyed.
346: */
347: dot->refCount += 1;
1.35 sjg 348: Dir_SetPATH(); /* initialize */
1.1 cgd 349: }
350:
351: /*-
352: *-----------------------------------------------------------------------
1.6 jtc 353: * Dir_End --
354: * cleanup things for this module
355: *
356: * Results:
357: * none
358: *
359: * Side Effects:
360: * none
361: *-----------------------------------------------------------------------
362: */
363: void
1.34 wiz 364: Dir_End(void)
1.6 jtc 365: {
1.24 mycroft 366: #ifdef CLEANUP
1.17 gwr 367: if (cur) {
368: cur->refCount -= 1;
1.51 dsl 369: Dir_Destroy(cur);
1.17 gwr 370: }
1.6 jtc 371: dot->refCount -= 1;
1.21 thorpej 372: dotLast->refCount -= 1;
1.51 dsl 373: Dir_Destroy(dotLast);
374: Dir_Destroy(dot);
1.6 jtc 375: Dir_ClearPath(dirSearchPath);
376: Lst_Destroy(dirSearchPath, NOFREE);
377: Dir_ClearPath(openDirectories);
378: Lst_Destroy(openDirectories, NOFREE);
379: Hash_DeleteTable(&mtimes);
1.24 mycroft 380: #endif
1.6 jtc 381: }
382:
1.35 sjg 383: /*
384: * We want ${.PATH} to indicate the order in which we will actually
385: * search, so we rebuild it after any .PATH: target.
386: * This is the simplest way to deal with the effect of .DOTLAST.
387: */
388: void
1.45 christos 389: Dir_SetPATH(void)
1.35 sjg 390: {
391: LstNode ln; /* a list element */
392: Path *p;
393: Boolean hasLastDot = FALSE; /* true we should search dot last */
394:
395: Var_Delete(".PATH", VAR_GLOBAL);
396:
1.45 christos 397: if (Lst_Open(dirSearchPath) == SUCCESS) {
398: if ((ln = Lst_First(dirSearchPath)) != NILLNODE) {
1.46 christos 399: p = (Path *)Lst_Datum(ln);
1.35 sjg 400: if (p == dotLast) {
401: hasLastDot = TRUE;
402: Var_Append(".PATH", dotLast->name, VAR_GLOBAL);
403: }
404: }
405:
406: if (!hasLastDot) {
407: if (dot)
408: Var_Append(".PATH", dot->name, VAR_GLOBAL);
409: if (cur)
410: Var_Append(".PATH", cur->name, VAR_GLOBAL);
411: }
412:
1.45 christos 413: while ((ln = Lst_Next(dirSearchPath)) != NILLNODE) {
1.46 christos 414: p = (Path *)Lst_Datum(ln);
1.35 sjg 415: if (p == dotLast)
416: continue;
417: if (p == dot && hasLastDot)
418: continue;
419: Var_Append(".PATH", p->name, VAR_GLOBAL);
420: }
421:
422: if (hasLastDot) {
423: if (dot)
424: Var_Append(".PATH", dot->name, VAR_GLOBAL);
425: if (cur)
426: Var_Append(".PATH", cur->name, VAR_GLOBAL);
427: }
428: Lst_Close(dirSearchPath);
429: }
430: }
431:
1.6 jtc 432: /*-
433: *-----------------------------------------------------------------------
1.1 cgd 434: * DirFindName --
435: * See if the Path structure describes the same directory as the
436: * given one by comparing their names. Called from Dir_AddDir via
437: * Lst_Find when searching the list of open directories.
438: *
1.34 wiz 439: * Input:
440: * p Current name
441: * dname Desired name
442: *
1.1 cgd 443: * Results:
444: * 0 if it is the same. Non-zero otherwise
445: *
446: * Side Effects:
447: * None
448: *-----------------------------------------------------------------------
449: */
450: static int
1.34 wiz 451: DirFindName(ClientData p, ClientData dname)
1.1 cgd 452: {
1.48 christos 453: return (strcmp(((Path *)p)->name, (char *)dname));
1.1 cgd 454: }
455:
456: /*-
457: *-----------------------------------------------------------------------
458: * Dir_HasWildcards --
459: * see if the given name has any wildcard characters in it
1.13 christos 460: * be careful not to expand unmatching brackets or braces.
461: * XXX: This code is not 100% correct. ([^]] fails etc.)
462: * I really don't think that make(1) should be expanding
463: * patterns, because then you have to set a mechanism for
1.14 christos 464: * escaping the expansion!
1.1 cgd 465: *
1.34 wiz 466: * Input:
467: * name name to check
468: *
1.1 cgd 469: * Results:
470: * returns TRUE if the word should be expanded, FALSE otherwise
471: *
472: * Side Effects:
473: * none
474: *-----------------------------------------------------------------------
475: */
476: Boolean
1.34 wiz 477: Dir_HasWildcards(char *name)
1.1 cgd 478: {
1.34 wiz 479: char *cp;
1.13 christos 480: int wild = 0, brace = 0, bracket = 0;
1.12 christos 481:
1.1 cgd 482: for (cp = name; *cp; cp++) {
483: switch(*cp) {
484: case '{':
1.13 christos 485: brace++;
486: wild = 1;
487: break;
488: case '}':
489: brace--;
490: break;
1.1 cgd 491: case '[':
1.13 christos 492: bracket++;
493: wild = 1;
494: break;
495: case ']':
496: bracket--;
497: break;
1.1 cgd 498: case '?':
499: case '*':
1.13 christos 500: wild = 1;
501: break;
502: default:
503: break;
1.1 cgd 504: }
505: }
1.13 christos 506: return wild && bracket == 0 && brace == 0;
1.1 cgd 507: }
508:
509: /*-
510: *-----------------------------------------------------------------------
511: * DirMatchFiles --
512: * Given a pattern and a Path structure, see if any files
513: * match the pattern and add their names to the 'expansions' list if
514: * any do. This is incomplete -- it doesn't take care of patterns like
1.5 cgd 515: * src / *src / *.c properly (just *.c on any of the directories), but it
1.1 cgd 516: * will do for now.
517: *
1.34 wiz 518: * Input:
519: * pattern Pattern to look for
520: * p Directory to search
521: * expansion Place to store the results
522: *
1.1 cgd 523: * Results:
524: * Always returns 0
525: *
526: * Side Effects:
527: * File names are added to the expansions lst. The directory will be
528: * fully hashed when this is done.
529: *-----------------------------------------------------------------------
530: */
531: static int
1.36 christos 532: DirMatchFiles(const char *pattern, Path *p, Lst expansions)
1.1 cgd 533: {
1.12 christos 534: Hash_Search search; /* Index into the directory's table */
1.1 cgd 535: Hash_Entry *entry; /* Current entry in the table */
536: Boolean isDot; /* TRUE if the directory being searched is . */
1.12 christos 537:
1.1 cgd 538: isDot = (*p->name == '.' && p->name[1] == '\0');
1.12 christos 539:
1.1 cgd 540: for (entry = Hash_EnumFirst(&p->files, &search);
1.48 christos 541: entry != NULL;
1.1 cgd 542: entry = Hash_EnumNext(&search))
543: {
544: /*
545: * See if the file matches the given pattern. Note we follow the UNIX
546: * convention that dot files will only be found if the pattern
547: * begins with a dot (note also that as a side effect of the hashing
548: * scheme, .* won't match . or .. since they aren't hashed).
549: */
550: if (Str_Match(entry->name, pattern) &&
551: ((entry->name[0] != '.') ||
552: (pattern[0] == '.')))
553: {
554: (void)Lst_AtEnd(expansions,
1.11 christos 555: (isDot ? estrdup(entry->name) :
1.1 cgd 556: str_concat(p->name, entry->name,
557: STR_ADDSLASH)));
558: }
559: }
560: return (0);
561: }
562:
563: /*-
564: *-----------------------------------------------------------------------
565: * DirExpandCurly --
566: * Expand curly braces like the C shell. Does this recursively.
567: * Note the special case: if after the piece of the curly brace is
568: * done there are no wildcard characters in the result, the result is
569: * placed on the list WITHOUT CHECKING FOR ITS EXISTENCE.
570: *
1.34 wiz 571: * Input:
572: * word Entire word to expand
573: * brace First curly brace in it
574: * path Search path to use
575: * expansions Place to store the expansions
576: *
1.1 cgd 577: * Results:
578: * None.
579: *
580: * Side Effects:
581: * The given list is filled with the expansions...
582: *
583: *-----------------------------------------------------------------------
584: */
585: static void
1.36 christos 586: DirExpandCurly(const char *word, const char *brace, Lst path, Lst expansions)
1.1 cgd 587: {
1.36 christos 588: const char *end; /* Character after the closing brace */
589: const char *cp; /* Current position in brace clause */
590: const char *start; /* Start of current piece of brace clause */
1.1 cgd 591: int bracelevel; /* Number of braces we've seen. If we see a
592: * right brace when this is 0, we've hit the
593: * end of the clause. */
1.36 christos 594: char *file; /* Current expansion */
1.55 ! christos 595: int otherLen; /* The length of the other pieces of the
1.1 cgd 596: * expansion (chars before and after the
597: * clause in 'word') */
1.36 christos 598: char *cp2; /* Pointer for checking for wildcards in
1.1 cgd 599: * expansion before calling Dir_Expand */
600:
601: start = brace+1;
602:
603: /*
604: * Find the end of the brace clause first, being wary of nested brace
605: * clauses.
606: */
607: for (end = start, bracelevel = 0; *end != '\0'; end++) {
608: if (*end == '{') {
609: bracelevel++;
610: } else if ((*end == '}') && (bracelevel-- == 0)) {
611: break;
612: }
613: }
614: if (*end == '\0') {
615: Error("Unterminated {} clause \"%s\"", start);
616: return;
617: } else {
618: end++;
619: }
620: otherLen = brace - word + strlen(end);
621:
622: for (cp = start; cp < end; cp++) {
623: /*
624: * Find the end of this piece of the clause.
625: */
626: bracelevel = 0;
627: while (*cp != ',') {
628: if (*cp == '{') {
629: bracelevel++;
630: } else if ((*cp == '}') && (bracelevel-- <= 0)) {
631: break;
632: }
633: cp++;
634: }
635: /*
636: * Allocate room for the combination and install the three pieces.
637: */
1.55 ! christos 638: file = emalloc(otherLen + cp - start + 1);
1.1 cgd 639: if (brace != word) {
1.55 ! christos 640: strncpy(file, word, brace-word);
1.1 cgd 641: }
642: if (cp != start) {
1.55 ! christos 643: strncpy(&file[brace-word], start, cp-start);
1.1 cgd 644: }
1.55 ! christos 645: strcpy(&file[(brace-word)+(cp-start)], end);
1.1 cgd 646:
647: /*
648: * See if the result has any wildcards in it. If we find one, call
649: * Dir_Expand right away, telling it to place the result on our list
650: * of expansions.
651: */
652: for (cp2 = file; *cp2 != '\0'; cp2++) {
653: switch(*cp2) {
654: case '*':
655: case '?':
656: case '{':
657: case '[':
658: Dir_Expand(file, path, expansions);
659: goto next;
660: }
661: }
662: if (*cp2 == '\0') {
663: /*
664: * Hit the end w/o finding any wildcards, so stick the expansion
665: * on the end of the list.
666: */
667: (void)Lst_AtEnd(expansions, file);
668: } else {
669: next:
670: free(file);
671: }
672: start = cp+1;
673: }
674: }
675:
676:
677: /*-
678: *-----------------------------------------------------------------------
679: * DirExpandInt --
680: * Internal expand routine. Passes through the directories in the
681: * path one by one, calling DirMatchFiles for each. NOTE: This still
682: * doesn't handle patterns in directories...
683: *
1.34 wiz 684: * Input:
685: * word Word to expand
686: * path Path on which to look
687: * expansions Place to store the result
688: *
1.1 cgd 689: * Results:
690: * None.
691: *
692: * Side Effects:
693: * Things are added to the expansions list.
694: *
695: *-----------------------------------------------------------------------
696: */
697: static void
1.36 christos 698: DirExpandInt(const char *word, Lst path, Lst expansions)
1.1 cgd 699: {
700: LstNode ln; /* Current node */
701: Path *p; /* Directory in the node */
702:
703: if (Lst_Open(path) == SUCCESS) {
704: while ((ln = Lst_Next(path)) != NILLNODE) {
705: p = (Path *)Lst_Datum(ln);
706: DirMatchFiles(word, p, expansions);
707: }
708: Lst_Close(path);
709: }
710: }
711:
712: /*-
713: *-----------------------------------------------------------------------
714: * DirPrintWord --
715: * Print a word in the list of expansions. Callback for Dir_Expand
716: * when DEBUG(DIR), via Lst_ForEach.
717: *
718: * Results:
719: * === 0
720: *
721: * Side Effects:
722: * The passed word is printed, followed by a space.
723: *
724: *-----------------------------------------------------------------------
725: */
726: static int
1.34 wiz 727: DirPrintWord(ClientData word, ClientData dummy)
1.1 cgd 728: {
1.50 dsl 729: fprintf(debug_file, "%s ", (char *)word);
1.1 cgd 730:
1.6 jtc 731: return(dummy ? 0 : 0);
1.1 cgd 732: }
733:
734: /*-
735: *-----------------------------------------------------------------------
736: * Dir_Expand --
737: * Expand the given word into a list of words by globbing it looking
738: * in the directories on the given search path.
739: *
1.34 wiz 740: * Input:
741: * word the word to expand
742: * path the list of directories in which to find the
743: * resulting files
744: * expansions the list on which to place the results
745: *
1.1 cgd 746: * Results:
747: * A list of words consisting of the files which exist along the search
748: * path matching the given pattern.
749: *
750: * Side Effects:
751: * Directories may be opened. Who knows?
752: *-----------------------------------------------------------------------
753: */
754: void
1.36 christos 755: Dir_Expand(const char *word, Lst path, Lst expansions)
1.1 cgd 756: {
1.36 christos 757: const char *cp;
1.1 cgd 758:
759: if (DEBUG(DIR)) {
1.50 dsl 760: fprintf(debug_file, "Expanding \"%s\"... ", word);
1.1 cgd 761: }
1.12 christos 762:
1.5 cgd 763: cp = strchr(word, '{');
1.1 cgd 764: if (cp) {
765: DirExpandCurly(word, cp, path, expansions);
766: } else {
1.5 cgd 767: cp = strchr(word, '/');
1.1 cgd 768: if (cp) {
769: /*
770: * The thing has a directory component -- find the first wildcard
771: * in the string.
772: */
773: for (cp = word; *cp; cp++) {
774: if (*cp == '?' || *cp == '[' || *cp == '*' || *cp == '{') {
775: break;
776: }
777: }
778: if (*cp == '{') {
779: /*
780: * This one will be fun.
781: */
782: DirExpandCurly(word, cp, path, expansions);
783: return;
784: } else if (*cp != '\0') {
785: /*
786: * Back up to the start of the component
787: */
788: char *dirpath;
789:
790: while (cp > word && *cp != '/') {
791: cp--;
792: }
793: if (cp != word) {
1.5 cgd 794: char sc;
1.1 cgd 795: /*
796: * If the glob isn't in the first component, try and find
797: * all the components up to the one with a wildcard.
798: */
1.5 cgd 799: sc = cp[1];
1.36 christos 800: ((char *)UNCONST(cp))[1] = '\0';
1.1 cgd 801: dirpath = Dir_FindFile(word, path);
1.36 christos 802: ((char *)UNCONST(cp))[1] = sc;
1.1 cgd 803: /*
804: * dirpath is null if can't find the leading component
805: * XXX: Dir_FindFile won't find internal components.
806: * i.e. if the path contains ../Etc/Object and we're
807: * looking for Etc, it won't be found. Ah well.
808: * Probably not important.
809: */
1.48 christos 810: if (dirpath != NULL) {
1.5 cgd 811: char *dp = &dirpath[strlen(dirpath) - 1];
812: if (*dp == '/')
813: *dp = '\0';
1.1 cgd 814: path = Lst_Init(FALSE);
1.46 christos 815: (void)Dir_AddDir(path, dirpath);
1.1 cgd 816: DirExpandInt(cp+1, path, expansions);
817: Lst_Destroy(path, NOFREE);
818: }
819: } else {
820: /*
821: * Start the search from the local directory
822: */
823: DirExpandInt(word, path, expansions);
824: }
825: } else {
826: /*
827: * Return the file -- this should never happen.
828: */
829: DirExpandInt(word, path, expansions);
830: }
831: } else {
832: /*
833: * First the files in dot
834: */
835: DirMatchFiles(word, dot, expansions);
1.12 christos 836:
1.1 cgd 837: /*
838: * Then the files in every other directory on the path.
839: */
840: DirExpandInt(word, path, expansions);
841: }
842: }
843: if (DEBUG(DIR)) {
1.51 dsl 844: Lst_ForEach(expansions, DirPrintWord, NULL);
1.50 dsl 845: fprintf(debug_file, "\n");
1.1 cgd 846: }
847: }
848:
849: /*-
850: *-----------------------------------------------------------------------
1.18 christos 851: * DirLookup --
852: * Find if the file with the given name exists in the given path.
853: *
854: * Results:
1.32 pk 855: * The path to the file or NULL. This path is guaranteed to be in a
1.18 christos 856: * different part of memory than name and so may be safely free'd.
857: *
858: * Side Effects:
859: * None.
860: *-----------------------------------------------------------------------
861: */
862: static char *
1.43 jmc 863: DirLookup(Path *p, const char *name __unused, const char *cp,
864: Boolean hasSlash __unused)
1.18 christos 865: {
866: char *file; /* the current filename to check */
867:
868: if (DEBUG(DIR)) {
1.50 dsl 869: fprintf(debug_file, " %s ...\n", p->name);
1.18 christos 870: }
1.32 pk 871:
1.48 christos 872: if (Hash_FindEntry(&p->files, cp) == NULL)
1.32 pk 873: return NULL;
874:
1.45 christos 875: file = str_concat(p->name, cp, STR_ADDSLASH);
1.32 pk 876: if (DEBUG(DIR)) {
1.50 dsl 877: fprintf(debug_file, " returning %s\n", file);
1.18 christos 878: }
1.32 pk 879: p->hits += 1;
880: hits += 1;
881: return file;
1.18 christos 882: }
883:
884:
885: /*-
886: *-----------------------------------------------------------------------
887: * DirLookupSubdir --
888: * Find if the file with the given name exists in the given path.
889: *
890: * Results:
891: * The path to the file or NULL. This path is guaranteed to be in a
892: * different part of memory than name and so may be safely free'd.
893: *
894: * Side Effects:
895: * If the file is found, it is added in the modification times hash
896: * table.
897: *-----------------------------------------------------------------------
898: */
899: static char *
1.36 christos 900: DirLookupSubdir(Path *p, const char *name)
1.18 christos 901: {
902: struct stat stb; /* Buffer for stat, if necessary */
903: Hash_Entry *entry; /* Entry for mtimes table */
904: char *file; /* the current filename to check */
905:
906: if (p != dot) {
1.45 christos 907: file = str_concat(p->name, name, STR_ADDSLASH);
1.18 christos 908: } else {
909: /*
910: * Checking in dot -- DON'T put a leading ./ on the thing.
911: */
912: file = estrdup(name);
913: }
914:
915: if (DEBUG(DIR)) {
1.50 dsl 916: fprintf(debug_file, "checking %s ...\n", file);
1.18 christos 917: }
918:
1.46 christos 919: if (stat(file, &stb) == 0) {
1.18 christos 920: /*
921: * Save the modification time so if it's needed, we don't have
922: * to fetch it again.
923: */
924: if (DEBUG(DIR)) {
1.50 dsl 925: fprintf(debug_file, " Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
1.18 christos 926: file);
927: }
1.48 christos 928: entry = Hash_CreateEntry(&mtimes, (char *)file, NULL);
1.18 christos 929: Hash_SetValue(entry, (long)stb.st_mtime);
930: nearmisses += 1;
931: return (file);
932: }
1.46 christos 933: free(file);
1.18 christos 934: return NULL;
935: }
936:
937: /*-
938: *-----------------------------------------------------------------------
1.32 pk 939: * DirLookupAbs --
940: * Find if the file with the given name exists in the given path.
941: *
942: * Results:
943: * The path to the file, the empty string or NULL. If the file is
944: * the empty string, the search should be terminated.
945: * This path is guaranteed to be in a different part of memory
946: * than name and so may be safely free'd.
947: *
948: * Side Effects:
949: * None.
950: *-----------------------------------------------------------------------
951: */
952: static char *
1.36 christos 953: DirLookupAbs(Path *p, const char *name, const char *cp)
1.32 pk 954: {
955: char *p1; /* pointer into p->name */
1.36 christos 956: const char *p2; /* pointer into name */
1.32 pk 957:
958: if (DEBUG(DIR)) {
1.50 dsl 959: fprintf(debug_file, " %s ...\n", p->name);
1.32 pk 960: }
961:
962: /*
963: * If the file has a leading path component and that component
964: * exactly matches the entire name of the current search
965: * directory, we can attempt another cache lookup. And if we don't
966: * have a hit, we can safely assume the file does not exist at all.
967: */
968: for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) {
969: continue;
970: }
971: if (*p1 != '\0' || p2 != cp - 1) {
972: return NULL;
973: }
974:
1.48 christos 975: if (Hash_FindEntry(&p->files, cp) == NULL) {
1.32 pk 976: if (DEBUG(DIR)) {
1.50 dsl 977: fprintf(debug_file, " must be here but isn't -- returning\n");
1.32 pk 978: }
979: /* Return empty string: terminates search */
1.36 christos 980: return estrdup("");
1.32 pk 981: }
982:
983: p->hits += 1;
984: hits += 1;
985: if (DEBUG(DIR)) {
1.50 dsl 986: fprintf(debug_file, " returning %s\n", name);
1.32 pk 987: }
1.45 christos 988: return (estrdup(name));
1.32 pk 989: }
990:
991: /*-
992: *-----------------------------------------------------------------------
1.21 thorpej 993: * DirFindDot --
994: * Find the file given on "." or curdir
995: *
996: * Results:
997: * The path to the file or NULL. This path is guaranteed to be in a
998: * different part of memory than name and so may be safely free'd.
999: *
1000: * Side Effects:
1001: * Hit counts change
1002: *-----------------------------------------------------------------------
1003: */
1004: static char *
1.43 jmc 1005: DirFindDot(Boolean hasSlash __unused, const char *name, const char *cp)
1.21 thorpej 1006: {
1007:
1.48 christos 1008: if (Hash_FindEntry(&dot->files, cp) != NULL) {
1.21 thorpej 1009: if (DEBUG(DIR)) {
1.50 dsl 1010: fprintf(debug_file, " in '.'\n");
1.21 thorpej 1011: }
1012: hits += 1;
1013: dot->hits += 1;
1.45 christos 1014: return (estrdup(name));
1.21 thorpej 1015: }
1016: if (cur &&
1.48 christos 1017: Hash_FindEntry(&cur->files, cp) != NULL) {
1.21 thorpej 1018: if (DEBUG(DIR)) {
1.50 dsl 1019: fprintf(debug_file, " in ${.CURDIR} = %s\n", cur->name);
1.21 thorpej 1020: }
1021: hits += 1;
1022: cur->hits += 1;
1.45 christos 1023: return str_concat(cur->name, cp, STR_ADDSLASH);
1.21 thorpej 1024: }
1025:
1.32 pk 1026: return NULL;
1.21 thorpej 1027: }
1028:
1029: /*-
1030: *-----------------------------------------------------------------------
1.1 cgd 1031: * Dir_FindFile --
1032: * Find the file with the given name along the given search path.
1033: *
1.34 wiz 1034: * Input:
1035: * name the file to find
1036: * path the Lst of directories to search
1037: *
1.1 cgd 1038: * Results:
1039: * The path to the file or NULL. This path is guaranteed to be in a
1040: * different part of memory than name and so may be safely free'd.
1041: *
1042: * Side Effects:
1043: * If the file is found in a directory which is not on the path
1044: * already (either 'name' is absolute or it is a relative path
1045: * [ dir1/.../dirn/file ] which exists below one of the directories
1046: * already on the search path), its directory is added to the end
1047: * of the path on the assumption that there will be more files in
1048: * that directory later on. Sometimes this is true. Sometimes not.
1049: *-----------------------------------------------------------------------
1050: */
1051: char *
1.36 christos 1052: Dir_FindFile(const char *name, Lst path)
1.1 cgd 1053: {
1.21 thorpej 1054: LstNode ln; /* a list element */
1.34 wiz 1055: char *file; /* the current filename to check */
1056: Path *p; /* current path member */
1.52 dsl 1057: const char *cp; /* Terminal name of file */
1.31 reinoud 1058: Boolean hasLastDot = FALSE; /* true we should search dot last */
1.21 thorpej 1059: Boolean hasSlash; /* true if 'name' contains a / */
1060: struct stat stb; /* Buffer for stat, if necessary */
1061: Hash_Entry *entry; /* Entry for mtimes table */
1.12 christos 1062:
1.1 cgd 1063: /*
1064: * Find the final component of the name and note whether it has a
1065: * slash in it (the name, I mean)
1066: */
1.46 christos 1067: cp = strrchr(name, '/');
1.1 cgd 1068: if (cp) {
1069: hasSlash = TRUE;
1070: cp += 1;
1071: } else {
1072: hasSlash = FALSE;
1073: cp = name;
1074: }
1.12 christos 1075:
1.1 cgd 1076: if (DEBUG(DIR)) {
1.50 dsl 1077: fprintf(debug_file, "Searching for %s ...", name);
1.1 cgd 1078: }
1.12 christos 1079:
1.45 christos 1080: if (Lst_Open(path) == FAILURE) {
1.1 cgd 1081: if (DEBUG(DIR)) {
1.50 dsl 1082: fprintf(debug_file, "couldn't open path, file not found\n");
1.1 cgd 1083: }
1084: misses += 1;
1.48 christos 1085: return (NULL);
1.1 cgd 1086: }
1.12 christos 1087:
1.45 christos 1088: if ((ln = Lst_First(path)) != NILLNODE) {
1.46 christos 1089: p = (Path *)Lst_Datum(ln);
1.31 reinoud 1090: if (p == dotLast) {
1091: hasLastDot = TRUE;
1.32 pk 1092: if (DEBUG(DIR))
1.50 dsl 1093: fprintf(debug_file, "[dot last]...");
1.21 thorpej 1094: }
1.18 christos 1095: }
1.39 dsl 1096: if (DEBUG(DIR)) {
1.50 dsl 1097: fprintf(debug_file, "\n");
1.39 dsl 1098: }
1.18 christos 1099:
1.1 cgd 1100: /*
1.32 pk 1101: * If there's no leading directory components or if the leading
1102: * directory component is exactly `./', consult the cached contents
1103: * of each of the directories on the search path.
1.21 thorpej 1104: */
1.52 dsl 1105: if (!hasSlash || (cp - name == 2 && *name == '.')) {
1.32 pk 1106: /*
1107: * We look through all the directories on the path seeking one which
1108: * contains the final component of the given name. If such a beast
1109: * is found, we concatenate the directory name and the final
1110: * component and return the resulting string. If we don't find any
1111: * such thing, we go on to phase two...
1112: *
1113: * No matter what, we always look for the file in the current
1114: * directory before anywhere else (unless we found the magic
1115: * DOTLAST path, in which case we search it last) and we *do not*
1116: * add the ./ to it if it exists.
1117: * This is so there are no conflicts between what the user
1118: * specifies (fish.c) and what pmake finds (./fish.c).
1119: */
1120: if (!hasLastDot &&
1121: (file = DirFindDot(hasSlash, name, cp)) != NULL) {
1.45 christos 1122: Lst_Close(path);
1.32 pk 1123: return file;
1124: }
1125:
1.45 christos 1126: while ((ln = Lst_Next(path)) != NILLNODE) {
1.46 christos 1127: p = (Path *)Lst_Datum(ln);
1.32 pk 1128: if (p == dotLast)
1129: continue;
1130: if ((file = DirLookup(p, name, cp, hasSlash)) != NULL) {
1.45 christos 1131: Lst_Close(path);
1.52 dsl 1132: return file;
1.32 pk 1133: }
1134: }
1.21 thorpej 1135:
1.32 pk 1136: if (hasLastDot &&
1137: (file = DirFindDot(hasSlash, name, cp)) != NULL) {
1.45 christos 1138: Lst_Close(path);
1.32 pk 1139: return file;
1140: }
1.1 cgd 1141: }
1.45 christos 1142: Lst_Close(path);
1.12 christos 1143:
1.1 cgd 1144: /*
1.32 pk 1145: * We didn't find the file on any directory in the search path.
1.1 cgd 1146: * If the name doesn't contain a slash, that means it doesn't exist.
1147: * If it *does* contain a slash, however, there is still hope: it
1148: * could be in a subdirectory of one of the members of the search
1149: * path. (eg. /usr/include and sys/types.h. The above search would
1150: * fail to turn up types.h in /usr/include, but it *is* in
1.32 pk 1151: * /usr/include/sys/types.h).
1152: * [ This no longer applies: If we find such a beast, we assume there
1.1 cgd 1153: * will be more (what else can we assume?) and add all but the last
1154: * component of the resulting name onto the search path (at the
1.32 pk 1155: * end).]
1156: * This phase is only performed if the file is *not* absolute.
1.1 cgd 1157: */
1158: if (!hasSlash) {
1159: if (DEBUG(DIR)) {
1.50 dsl 1160: fprintf(debug_file, " failed.\n");
1.1 cgd 1161: }
1162: misses += 1;
1.48 christos 1163: return (NULL);
1.1 cgd 1164: }
1.12 christos 1165:
1.32 pk 1166: if (name[0] != '/') {
1.1 cgd 1167: Boolean checkedDot = FALSE;
1.12 christos 1168:
1.1 cgd 1169: if (DEBUG(DIR)) {
1.50 dsl 1170: fprintf(debug_file, " Trying subdirectories...\n");
1.1 cgd 1171: }
1.18 christos 1172:
1.35 sjg 1173: if (!hasLastDot) {
1174: if (dot) {
1175: checkedDot = TRUE;
1176: if ((file = DirLookupSubdir(dot, name)) != NULL)
1177: return file;
1178: }
1179: if (cur && (file = DirLookupSubdir(cur, name)) != NULL)
1180: return file;
1181: }
1.18 christos 1182:
1.46 christos 1183: (void)Lst_Open(path);
1.45 christos 1184: while ((ln = Lst_Next(path)) != NILLNODE) {
1.46 christos 1185: p = (Path *)Lst_Datum(ln);
1.21 thorpej 1186: if (p == dotLast)
1187: continue;
1.35 sjg 1188: if (p == dot) {
1189: if (checkedDot)
1190: continue;
1.1 cgd 1191: checkedDot = TRUE;
1.35 sjg 1192: }
1.18 christos 1193: if ((file = DirLookupSubdir(p, name)) != NULL) {
1.45 christos 1194: Lst_Close(path);
1.18 christos 1195: return file;
1.1 cgd 1196: }
1197: }
1.45 christos 1198: Lst_Close(path);
1.12 christos 1199:
1.35 sjg 1200: if (hasLastDot) {
1201: if (dot && !checkedDot) {
1202: checkedDot = TRUE;
1203: if ((file = DirLookupSubdir(dot, name)) != NULL)
1204: return file;
1205: }
1206: if (cur && (file = DirLookupSubdir(cur, name)) != NULL)
1207: return file;
1208: }
1.21 thorpej 1209:
1.1 cgd 1210: if (checkedDot) {
1211: /*
1212: * Already checked by the given name, since . was in the path,
1213: * so no point in proceeding...
1214: */
1215: if (DEBUG(DIR)) {
1.50 dsl 1216: fprintf(debug_file, " Checked . already, returning NULL\n");
1.1 cgd 1217: }
1218: return(NULL);
1.32 pk 1219: }
1220:
1221: } else { /* name[0] == '/' */
1222:
1223: /*
1224: * For absolute names, compare directory path prefix against the
1225: * the directory path of each member on the search path for an exact
1226: * match. If we have an exact match on any member of the search path,
1227: * use the cached contents of that member to lookup the final file
1228: * component. If that lookup fails we can safely assume that the
1229: * file does not exist at all. This is signified by DirLookupAbs()
1230: * returning an empty string.
1231: */
1232: if (DEBUG(DIR)) {
1.50 dsl 1233: fprintf(debug_file, " Trying exact path matches...\n");
1.32 pk 1234: }
1235:
1236: if (!hasLastDot && cur && (file = DirLookupAbs(cur, name, cp)) != NULL)
1237: return *file?file:NULL;
1238:
1.46 christos 1239: (void)Lst_Open(path);
1.45 christos 1240: while ((ln = Lst_Next(path)) != NILLNODE) {
1.46 christos 1241: p = (Path *)Lst_Datum(ln);
1.32 pk 1242: if (p == dotLast)
1243: continue;
1244: if ((file = DirLookupAbs(p, name, cp)) != NULL) {
1.45 christos 1245: Lst_Close(path);
1.32 pk 1246: return *file?file:NULL;
1247: }
1248: }
1.45 christos 1249: Lst_Close(path);
1.32 pk 1250:
1251: if (hasLastDot && cur && (file = DirLookupAbs(cur, name, cp)) != NULL)
1252: return *file?file:NULL;
1.1 cgd 1253: }
1.12 christos 1254:
1.1 cgd 1255: /*
1256: * Didn't find it that way, either. Sigh. Phase 3. Add its directory
1257: * onto the search path in any case, just in case, then look for the
1258: * thing in the hash table. If we find it, grand. We return a new
1259: * copy of the name. Otherwise we sadly return a NULL pointer. Sigh.
1260: * Note that if the directory holding the file doesn't exist, this will
1261: * do an extra search of the final directory on the path. Unless something
1262: * weird happens, this search won't succeed and life will be groovy.
1263: *
1264: * Sigh. We cannot add the directory onto the search path because
1265: * of this amusing case:
1266: * $(INSTALLDIR)/$(FILE): $(FILE)
1267: *
1268: * $(FILE) exists in $(INSTALLDIR) but not in the current one.
1269: * When searching for $(FILE), we will find it in $(INSTALLDIR)
1270: * b/c we added it here. This is not good...
1271: */
1272: #ifdef notdef
1273: cp[-1] = '\0';
1.46 christos 1274: (void)Dir_AddDir(path, name);
1.1 cgd 1275: cp[-1] = '/';
1.12 christos 1276:
1.1 cgd 1277: bigmisses += 1;
1.45 christos 1278: ln = Lst_Last(path);
1.1 cgd 1279: if (ln == NILLNODE) {
1.48 christos 1280: return (NULL);
1.1 cgd 1281: } else {
1.46 christos 1282: p = (Path *)Lst_Datum(ln);
1.1 cgd 1283: }
1.12 christos 1284:
1.48 christos 1285: if (Hash_FindEntry(&p->files, cp) != NULL) {
1.45 christos 1286: return (estrdup(name));
1.1 cgd 1287: } else {
1.48 christos 1288: return (NULL);
1.1 cgd 1289: }
1290: #else /* !notdef */
1291: if (DEBUG(DIR)) {
1.50 dsl 1292: fprintf(debug_file, " Looking for \"%s\" ...\n", name);
1.1 cgd 1293: }
1.12 christos 1294:
1.1 cgd 1295: bigmisses += 1;
1296: entry = Hash_FindEntry(&mtimes, name);
1.48 christos 1297: if (entry != NULL) {
1.1 cgd 1298: if (DEBUG(DIR)) {
1.50 dsl 1299: fprintf(debug_file, " got it (in mtime cache)\n");
1.1 cgd 1300: }
1.11 christos 1301: return(estrdup(name));
1.46 christos 1302: } else if (stat(name, &stb) == 0) {
1.48 christos 1303: entry = Hash_CreateEntry(&mtimes, name, NULL);
1.1 cgd 1304: if (DEBUG(DIR)) {
1.50 dsl 1305: fprintf(debug_file, " Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
1.1 cgd 1306: name);
1307: }
1.7 cgd 1308: Hash_SetValue(entry, (long)stb.st_mtime);
1.45 christos 1309: return (estrdup(name));
1.1 cgd 1310: } else {
1311: if (DEBUG(DIR)) {
1.50 dsl 1312: fprintf(debug_file, " failed. Returning NULL\n");
1.1 cgd 1313: }
1.48 christos 1314: return (NULL);
1.1 cgd 1315: }
1316: #endif /* notdef */
1317: }
1318:
1.40 chuck 1319:
1320: /*-
1321: *-----------------------------------------------------------------------
1322: * Dir_FindHereOrAbove --
1323: * search for a path starting at a given directory and then working
1324: * our way up towards the root.
1325: *
1326: * Input:
1327: * here starting directory
1328: * search_path the path we are looking for
1329: * result the result of a successful search is placed here
1330: * rlen the length of the result buffer
1331: * (typically MAXPATHLEN + 1)
1332: *
1333: * Results:
1334: * 0 on failure, 1 on success [in which case the found path is put
1335: * in the result buffer].
1336: *
1337: * Side Effects:
1338: *-----------------------------------------------------------------------
1339: */
1340: int
1.55 ! christos 1341: Dir_FindHereOrAbove(char *here, char *search_path, char *result, int rlen) {
1.40 chuck 1342:
1343: struct stat st;
1344: char dirbase[MAXPATHLEN + 1], *db_end;
1345: char try[MAXPATHLEN + 1], *try_end;
1346:
1347: /* copy out our starting point */
1348: snprintf(dirbase, sizeof(dirbase), "%s", here);
1349: db_end = dirbase + strlen(dirbase);
1350:
1351: /* loop until we determine a result */
1.55 ! christos 1352: while (1) {
1.40 chuck 1353:
1354: /* try and stat(2) it ... */
1.55 ! christos 1355: snprintf(try, sizeof(try), "%s/%s", dirbase, search_path);
1.40 chuck 1356: if (stat(try, &st) != -1) {
1357: /*
1358: * success! if we found a file, chop off
1359: * the filename so we return a directory.
1360: */
1361: if ((st.st_mode & S_IFMT) != S_IFDIR) {
1362: try_end = try + strlen(try);
1363: while (try_end > try && *try_end != '/')
1364: try_end--;
1365: if (try_end > try)
1366: *try_end = 0; /* chop! */
1367: }
1368:
1369: /*
1370: * done!
1371: */
1372: snprintf(result, rlen, "%s", try);
1373: return(1);
1374: }
1375:
1376: /*
1377: * nope, we didn't find it. if we used up dirbase we've
1378: * reached the root and failed.
1379: */
1380: if (db_end == dirbase)
1381: break; /* failed! */
1382:
1383: /*
1384: * truncate dirbase from the end to move up a dir
1385: */
1386: while (db_end > dirbase && *db_end != '/')
1387: db_end--;
1388: *db_end = 0; /* chop! */
1389:
1390: } /* while (1) */
1391:
1392: /*
1393: * we failed...
1394: */
1395: return(0);
1396: }
1397:
1.1 cgd 1398: /*-
1399: *-----------------------------------------------------------------------
1400: * Dir_MTime --
1401: * Find the modification time of the file described by gn along the
1402: * search path dirSearchPath.
1.12 christos 1403: *
1.34 wiz 1404: * Input:
1405: * gn the file whose modification time is desired
1406: *
1.1 cgd 1407: * Results:
1408: * The modification time or 0 if it doesn't exist
1409: *
1410: * Side Effects:
1411: * The modification time is placed in the node's mtime slot.
1412: * If the node didn't have a path entry before, and Dir_FindFile
1413: * found one for it, the full name is placed in the path slot.
1414: *-----------------------------------------------------------------------
1415: */
1416: int
1.34 wiz 1417: Dir_MTime(GNode *gn)
1.1 cgd 1418: {
1419: char *fullName; /* the full pathname of name */
1420: struct stat stb; /* buffer for finding the mod time */
1421: Hash_Entry *entry;
1.12 christos 1422:
1.1 cgd 1423: if (gn->type & OP_ARCHV) {
1.45 christos 1424: return Arch_MTime(gn);
1.33 pk 1425: } else if (gn->type & OP_PHONY) {
1426: gn->mtime = 0;
1427: return 0;
1.48 christos 1428: } else if (gn->path == NULL) {
1.33 pk 1429: if (gn->type & OP_NOPATH)
1.16 mycroft 1430: fullName = NULL;
1.53 dsl 1431: else {
1.45 christos 1432: fullName = Dir_FindFile(gn->name, Suff_FindPath(gn));
1.53 dsl 1433: if (DEBUG(DIR))
1434: fprintf(debug_file, "Found '%s' as '%s'\n",
1435: gn->name, fullName ? fullName : "(not found)" );
1436: }
1.1 cgd 1437: } else {
1438: fullName = gn->path;
1439: }
1.12 christos 1440:
1.48 christos 1441: if (fullName == NULL) {
1.11 christos 1442: fullName = estrdup(gn->name);
1.1 cgd 1443: }
1444:
1445: entry = Hash_FindEntry(&mtimes, fullName);
1.48 christos 1446: if (entry != NULL) {
1.1 cgd 1447: /*
1448: * Only do this once -- the second time folks are checking to
1449: * see if the file was actually updated, so we need to actually go
1450: * to the file system.
1451: */
1452: if (DEBUG(DIR)) {
1.50 dsl 1453: fprintf(debug_file, "Using cached time %s for %s\n",
1.7 cgd 1454: Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName);
1.1 cgd 1455: }
1.7 cgd 1456: stb.st_mtime = (time_t)(long)Hash_GetValue(entry);
1.1 cgd 1457: Hash_DeleteEntry(&mtimes, entry);
1.46 christos 1458: } else if (stat(fullName, &stb) < 0) {
1.1 cgd 1459: if (gn->type & OP_MEMBER) {
1.6 jtc 1460: if (fullName != gn->path)
1461: free(fullName);
1.45 christos 1462: return Arch_MemMTime(gn);
1.1 cgd 1463: } else {
1464: stb.st_mtime = 0;
1465: }
1466: }
1.48 christos 1467: if (fullName && gn->path == NULL) {
1.1 cgd 1468: gn->path = fullName;
1469: }
1.12 christos 1470:
1.1 cgd 1471: gn->mtime = stb.st_mtime;
1472: return (gn->mtime);
1473: }
1474:
1475: /*-
1476: *-----------------------------------------------------------------------
1477: * Dir_AddDir --
1478: * Add the given name to the end of the given path. The order of
1479: * the arguments is backwards so ParseDoDependency can do a
1480: * Lst_ForEach of its list of paths...
1481: *
1.34 wiz 1482: * Input:
1483: * path the path to which the directory should be
1484: * added
1485: * name the name of the directory to add
1486: *
1.1 cgd 1487: * Results:
1488: * none
1489: *
1490: * Side Effects:
1.12 christos 1491: * A structure is added to the list and the directory is
1.1 cgd 1492: * read and hashed.
1493: *-----------------------------------------------------------------------
1494: */
1.17 gwr 1495: Path *
1.34 wiz 1496: Dir_AddDir(Lst path, const char *name)
1.1 cgd 1497: {
1.35 sjg 1498: LstNode ln = NILLNODE; /* node in case Path structure is found */
1.34 wiz 1499: Path *p = NULL; /* pointer to new Path structure */
1.1 cgd 1500: DIR *d; /* for reading directory */
1.34 wiz 1501: struct dirent *dp; /* entry in directory */
1.21 thorpej 1502:
1503: if (strcmp(name, ".DOTLAST") == 0) {
1.51 dsl 1504: ln = Lst_Find(path, UNCONST(name), DirFindName);
1.21 thorpej 1505: if (ln != NILLNODE)
1.46 christos 1506: return (Path *)Lst_Datum(ln);
1.21 thorpej 1507: else {
1508: dotLast->refCount += 1;
1.51 dsl 1509: (void)Lst_AtFront(path, dotLast);
1.21 thorpej 1510: }
1511: }
1.12 christos 1512:
1.35 sjg 1513: if (path)
1.51 dsl 1514: ln = Lst_Find(openDirectories, UNCONST(name), DirFindName);
1.1 cgd 1515: if (ln != NILLNODE) {
1.46 christos 1516: p = (Path *)Lst_Datum(ln);
1.51 dsl 1517: if (path && Lst_Member(path, p) == NILLNODE) {
1.1 cgd 1518: p->refCount += 1;
1.51 dsl 1519: (void)Lst_AtEnd(path, p);
1.1 cgd 1520: }
1521: } else {
1522: if (DEBUG(DIR)) {
1.50 dsl 1523: fprintf(debug_file, "Caching %s ...", name);
1.1 cgd 1524: }
1.12 christos 1525:
1.48 christos 1526: if ((d = opendir(name)) != NULL) {
1.45 christos 1527: p = emalloc(sizeof(Path));
1528: p->name = estrdup(name);
1.1 cgd 1529: p->hits = 0;
1530: p->refCount = 1;
1.45 christos 1531: Hash_InitTable(&p->files, -1);
1.12 christos 1532:
1.48 christos 1533: while ((dp = readdir(d)) != NULL) {
1.10 christos 1534: #if defined(sun) && defined(d_ino) /* d_ino is a sunos4 #define for d_fileno */
1.1 cgd 1535: /*
1536: * The sun directory library doesn't check for a 0 inode
1537: * (0-inode slots just take up space), so we have to do
1538: * it ourselves.
1539: */
1540: if (dp->d_fileno == 0) {
1541: continue;
1542: }
1.10 christos 1543: #endif /* sun && d_ino */
1.48 christos 1544: (void)Hash_CreateEntry(&p->files, dp->d_name, NULL);
1.1 cgd 1545: }
1.46 christos 1546: (void)closedir(d);
1.51 dsl 1547: (void)Lst_AtEnd(openDirectories, p);
1.17 gwr 1548: if (path != NULL)
1.51 dsl 1549: (void)Lst_AtEnd(path, p);
1.1 cgd 1550: }
1551: if (DEBUG(DIR)) {
1.50 dsl 1552: fprintf(debug_file, "done\n");
1.1 cgd 1553: }
1554: }
1.17 gwr 1555: return p;
1.1 cgd 1556: }
1557:
1558: /*-
1559: *-----------------------------------------------------------------------
1560: * Dir_CopyDir --
1561: * Callback function for duplicating a search path via Lst_Duplicate.
1562: * Ups the reference count for the directory.
1563: *
1564: * Results:
1565: * Returns the Path it was given.
1566: *
1567: * Side Effects:
1568: * The refCount of the path is incremented.
1569: *
1570: *-----------------------------------------------------------------------
1571: */
1572: ClientData
1.34 wiz 1573: Dir_CopyDir(ClientData p)
1.1 cgd 1574: {
1.48 christos 1575: ((Path *)p)->refCount += 1;
1.1 cgd 1576:
1.51 dsl 1577: return (p);
1.1 cgd 1578: }
1579:
1580: /*-
1581: *-----------------------------------------------------------------------
1582: * Dir_MakeFlags --
1583: * Make a string by taking all the directories in the given search
1584: * path and preceding them by the given flag. Used by the suffix
1585: * module to create variables for compilers based on suffix search
1586: * paths.
1587: *
1.34 wiz 1588: * Input:
1589: * flag flag which should precede each directory
1590: * path list of directories
1591: *
1.1 cgd 1592: * Results:
1593: * The string mentioned above. Note that there is no space between
1594: * the given flag and each directory. The empty string is returned if
1595: * Things don't go well.
1596: *
1597: * Side Effects:
1598: * None
1599: *-----------------------------------------------------------------------
1600: */
1601: char *
1.36 christos 1602: Dir_MakeFlags(const char *flag, Lst path)
1.1 cgd 1603: {
1604: char *str; /* the string which will be returned */
1.36 christos 1605: char *s1, *s2;/* the current directory preceded by 'flag' */
1.1 cgd 1606: LstNode ln; /* the node of the current directory */
1607: Path *p; /* the structure describing the current directory */
1.12 christos 1608:
1.45 christos 1609: str = estrdup("");
1.12 christos 1610:
1.45 christos 1611: if (Lst_Open(path) == SUCCESS) {
1612: while ((ln = Lst_Next(path)) != NILLNODE) {
1.46 christos 1613: p = (Path *)Lst_Datum(ln);
1.45 christos 1614: s2 = str_concat(flag, p->name, 0);
1615: str = str_concat(s1 = str, s2, STR_ADDSPACE);
1.36 christos 1616: free(s1);
1617: free(s2);
1.1 cgd 1618: }
1.45 christos 1619: Lst_Close(path);
1.1 cgd 1620: }
1.12 christos 1621:
1.1 cgd 1622: return (str);
1623: }
1624:
1625: /*-
1626: *-----------------------------------------------------------------------
1627: * Dir_Destroy --
1628: * Nuke a directory descriptor, if possible. Callback procedure
1629: * for the suffixes module when destroying a search path.
1630: *
1.34 wiz 1631: * Input:
1632: * pp The directory descriptor to nuke
1633: *
1.1 cgd 1634: * Results:
1635: * None.
1636: *
1637: * Side Effects:
1638: * If no other path references this directory (refCount == 0),
1639: * the Path and all its data are freed.
1640: *
1641: *-----------------------------------------------------------------------
1642: */
1643: void
1.34 wiz 1644: Dir_Destroy(ClientData pp)
1.1 cgd 1645: {
1.48 christos 1646: Path *p = (Path *)pp;
1.1 cgd 1647: p->refCount -= 1;
1648:
1649: if (p->refCount == 0) {
1650: LstNode ln;
1651:
1.51 dsl 1652: ln = Lst_Member(openDirectories, p);
1.46 christos 1653: (void)Lst_Remove(openDirectories, ln);
1.1 cgd 1654:
1.45 christos 1655: Hash_DeleteTable(&p->files);
1.47 christos 1656: free(p->name);
1657: free(p);
1.1 cgd 1658: }
1659: }
1660:
1661: /*-
1662: *-----------------------------------------------------------------------
1663: * Dir_ClearPath --
1664: * Clear out all elements of the given search path. This is different
1665: * from destroying the list, notice.
1666: *
1.34 wiz 1667: * Input:
1668: * path Path to clear
1669: *
1.1 cgd 1670: * Results:
1671: * None.
1672: *
1673: * Side Effects:
1674: * The path is set to the empty list.
1675: *
1676: *-----------------------------------------------------------------------
1677: */
1678: void
1.34 wiz 1679: Dir_ClearPath(Lst path)
1.1 cgd 1680: {
1681: Path *p;
1682: while (!Lst_IsEmpty(path)) {
1683: p = (Path *)Lst_DeQueue(path);
1.51 dsl 1684: Dir_Destroy(p);
1.1 cgd 1685: }
1686: }
1.12 christos 1687:
1.1 cgd 1688:
1689: /*-
1690: *-----------------------------------------------------------------------
1691: * Dir_Concat --
1692: * Concatenate two paths, adding the second to the end of the first.
1693: * Makes sure to avoid duplicates.
1694: *
1.34 wiz 1695: * Input:
1696: * path1 Dest
1697: * path2 Source
1698: *
1.1 cgd 1699: * Results:
1700: * None
1701: *
1702: * Side Effects:
1703: * Reference counts for added dirs are upped.
1704: *
1705: *-----------------------------------------------------------------------
1706: */
1707: void
1.34 wiz 1708: Dir_Concat(Lst path1, Lst path2)
1.1 cgd 1709: {
1710: LstNode ln;
1711: Path *p;
1712:
1713: for (ln = Lst_First(path2); ln != NILLNODE; ln = Lst_Succ(ln)) {
1714: p = (Path *)Lst_Datum(ln);
1.51 dsl 1715: if (Lst_Member(path1, p) == NILLNODE) {
1.1 cgd 1716: p->refCount += 1;
1.51 dsl 1717: (void)Lst_AtEnd(path1, p);
1.1 cgd 1718: }
1719: }
1720: }
1721:
1722: /********** DEBUG INFO **********/
1.5 cgd 1723: void
1.34 wiz 1724: Dir_PrintDirectories(void)
1.1 cgd 1725: {
1726: LstNode ln;
1727: Path *p;
1.12 christos 1728:
1.50 dsl 1729: fprintf(debug_file, "#*** Directory Cache:\n");
1730: fprintf(debug_file, "# Stats: %d hits %d misses %d near misses %d losers (%d%%)\n",
1.1 cgd 1731: hits, misses, nearmisses, bigmisses,
1732: (hits+bigmisses+nearmisses ?
1733: hits * 100 / (hits + bigmisses + nearmisses) : 0));
1.50 dsl 1734: fprintf(debug_file, "# %-20s referenced\thits\n", "directory");
1.45 christos 1735: if (Lst_Open(openDirectories) == SUCCESS) {
1736: while ((ln = Lst_Next(openDirectories)) != NILLNODE) {
1.46 christos 1737: p = (Path *)Lst_Datum(ln);
1.50 dsl 1738: fprintf(debug_file, "# %-20s %10d\t%4d\n", p->name, p->refCount, p->hits);
1.1 cgd 1739: }
1.45 christos 1740: Lst_Close(openDirectories);
1.1 cgd 1741: }
1742: }
1743:
1.34 wiz 1744: static int
1745: DirPrintDir(ClientData p, ClientData dummy)
1.12 christos 1746: {
1.50 dsl 1747: fprintf(debug_file, "%s ", ((Path *)p)->name);
1.6 jtc 1748: return (dummy ? 0 : 0);
1749: }
1.1 cgd 1750:
1.5 cgd 1751: void
1.34 wiz 1752: Dir_PrintPath(Lst path)
1.1 cgd 1753: {
1.51 dsl 1754: Lst_ForEach(path, DirPrintDir, NULL);
1.1 cgd 1755: }
CVSweb <webmaster@jp.NetBSD.org>