![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dir.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / make|
Return to dir.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / make |
1.1 root 1: /*
2: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
3: * Copyright (c) 1988, 1989 by Adam de Boor
4: * Copyright (c) 1989 by Berkeley Softworks
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 are permitted
11: * provided that: (1) source distributions retain this entire copyright
12: * notice and comment, and (2) distributions including binaries display
13: * the following acknowledgement: ``This product includes software
14: * developed by the University of California, Berkeley and its contributors''
15: * in the documentation or other materials provided with the distribution
16: * and in all advertising materials mentioning features or use of this
17: * software. Neither the name of the University nor the names of its
18: * contributors may be used to endorse or promote products derived
19: * from this software without specific prior written permission.
20: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
21: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
22: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
23: */
24:
25: #ifndef lint
26: static char sccsid[] = "@(#)dir.c 5.5 (Berkeley) 6/1/90";
27: #endif /* not lint */
28:
29: /*-
30: * dir.c --
31: * Directory searching using wildcards and/or normal names...
32: * Used both for source wildcarding in the Makefile and for finding
33: * implicit sources.
34: *
35: * The interface for this module is:
36: * Dir_Init Initialize the module.
37: *
38: * Dir_HasWildcards Returns TRUE if the name given it needs to
39: * be wildcard-expanded.
40: *
41: * Dir_Expand Given a pattern and a path, return a Lst of names
42: * which match the pattern on the search path.
43: *
44: * Dir_FindFile Searches for a file on a given search path.
45: * If it exists, the entire path is returned.
46: * Otherwise NULL is returned.
47: *
48: * Dir_MTime Return the modification time of a node. The file
49: * is searched for along the default search path.
50: * The path and mtime fields of the node are filled
51: * in.
52: *
53: * Dir_AddDir Add a directory to a search path.
54: *
55: * Dir_MakeFlags Given a search path and a command flag, create
56: * a string with each of the directories in the path
57: * preceded by the command flag and all of them
58: * separated by a space.
59: *
60: * Dir_Destroy Destroy an element of a search path. Frees up all
61: * things that can be freed for the element as long
62: * as the element is no longer referenced by any other
63: * search path.
64: * Dir_ClearPath Resets a search path to the empty list.
65: *
66: * For debugging:
67: * Dir_PrintDirectories Print stats about the directory cache.
68: */
69:
70: #include <stdio.h>
71: #include <sys/types.h>
72: #include <sys/dir.h>
73: #include <sys/stat.h>
74: #include "make.h"
75: #include "hash.h"
76:
77: /*
78: * A search path consists of a Lst of Path structures. A Path structure
79: * has in it the name of the directory and a hash table of all the files
80: * in the directory. This is used to cut down on the number of system
81: * calls necessary to find implicit dependents and their like. Since
82: * these searches are made before any actions are taken, we need not
83: * worry about the directory changing due to creation commands. If this
84: * hampers the style of some makefiles, they must be changed.
85: *
86: * A list of all previously-read directories is kept in the
87: * openDirectories Lst. This list is checked first before a directory
88: * is opened.
89: *
90: * The need for the caching of whole directories is brought about by
91: * the multi-level transformation code in suff.c, which tends to search
92: * for far more files than regular make does. In the initial
93: * implementation, the amount of time spent performing "stat" calls was
94: * truly astronomical. The problem with hashing at the start is,
95: * of course, that pmake doesn't then detect changes to these directories
96: * during the course of the make. Three possibilities suggest themselves:
97: *
98: * 1) just use stat to test for a file's existence. As mentioned
99: * above, this is very inefficient due to the number of checks
100: * engendered by the multi-level transformation code.
101: * 2) use readdir() and company to search the directories, keeping
102: * them open between checks. I have tried this and while it
103: * didn't slow down the process too much, it could severely
104: * affect the amount of parallelism available as each directory
105: * open would take another file descriptor out of play for
106: * handling I/O for another job. Given that it is only recently
107: * that UNIX OS's have taken to allowing more than 20 or 32
108: * file descriptors for a process, this doesn't seem acceptable
109: * to me.
110: * 3) record the mtime of the directory in the Path structure and
111: * verify the directory hasn't changed since the contents were
112: * hashed. This will catch the creation or deletion of files,
113: * but not the updating of files. However, since it is the
114: * creation and deletion that is the problem, this could be
115: * a good thing to do. Unfortunately, if the directory (say ".")
116: * were fairly large and changed fairly frequently, the constant
117: * rehashing could seriously degrade performance. It might be
118: * good in such cases to keep track of the number of rehashes
119: * and if the number goes over a (small) limit, resort to using
120: * stat in its place.
121: *
122: * An additional thing to consider is that pmake is used primarily
123: * to create C programs and until recently pcc-based compilers refused
124: * to allow you to specify where the resulting object file should be
125: * placed. This forced all objects to be created in the current
126: * directory. This isn't meant as a full excuse, just an explanation of
127: * some of the reasons for the caching used here.
128: *
129: * One more note: the location of a target's file is only performed
130: * on the downward traversal of the graph and then only for terminal
131: * nodes in the graph. This could be construed as wrong in some cases,
132: * but prevents inadvertent modification of files when the "installed"
133: * directory for a file is provided in the search path.
134: *
135: * Another data structure maintained by this module is an mtime
136: * cache used when the searching of cached directories fails to find
137: * a file. In the past, Dir_FindFile would simply perform an access()
138: * call in such a case to determine if the file could be found using
139: * just the name given. When this hit, however, all that was gained
140: * was the knowledge that the file existed. Given that an access() is
141: * essentially a stat() without the copyout() call, and that the same
142: * filesystem overhead would have to be incurred in Dir_MTime, it made
143: * sense to replace the access() with a stat() and record the mtime
144: * in a cache for when Dir_MTime was actually called.
145: */
146:
147: Lst dirSearchPath; /* main search path */
148:
149: static Lst openDirectories; /* the list of all open directories */
150:
151: /*
152: * Variables for gathering statistics on the efficiency of the hashing
153: * mechanism.
154: */
155: static int hits, /* Found in directory cache */
156: misses, /* Sad, but not evil misses */
157: nearmisses, /* Found under search path */
158: bigmisses; /* Sought by itself */
159:
160: typedef struct Path {
161: char *name; /* Name of directory */
162: int refCount; /* Number of paths with this directory */
163: int hits; /* the number of times a file in this
164: * directory has been found */
165: Hash_Table files; /* Hash table of files in directory */
166: } Path;
167:
168: static Path *dot; /* contents of current directory */
169: static Hash_Table mtimes; /* Results of doing a last-resort stat in
170: * Dir_FindFile -- if we have to go to the
171: * system to find the file, we might as well
172: * have its mtime on record. XXX: If this is done
173: * way early, there's a chance other rules will
174: * have already updated the file, in which case
175: * we'll update it again. Generally, there won't
176: * be two rules to update a single file, so this
177: * should be ok, but... */
178:
179:
180: /*-
181: *-----------------------------------------------------------------------
182: * Dir_Init --
183: * initialize things for this module
184: *
185: * Results:
186: * none
187: *
188: * Side Effects:
189: * some directories may be opened.
190: *-----------------------------------------------------------------------
191: */
192: void
193: Dir_Init ()
194: {
195: dirSearchPath = Lst_Init (FALSE);
196: openDirectories = Lst_Init (FALSE);
197: Hash_InitTable(&mtimes, 0, HASH_STRING_KEYS);
198:
199: /*
200: * Since the Path structure is placed on both openDirectories and
201: * the path we give Dir_AddDir (which in this case is openDirectories),
202: * we need to remove "." from openDirectories and what better time to
203: * do it than when we have to fetch the thing anyway?
204: */
205: Dir_AddDir (openDirectories, ".");
206: dot = (Path *) Lst_DeQueue (openDirectories);
207:
208: /*
209: * We always need to have dot around, so we increment its reference count
210: * to make sure it's not destroyed.
211: */
212: dot->refCount += 1;
213: }
214:
215: /*-
216: *-----------------------------------------------------------------------
217: * DirFindName --
218: * See if the Path structure describes the same directory as the
219: * given one by comparing their names. Called from Dir_AddDir via
220: * Lst_Find when searching the list of open directories.
221: *
222: * Results:
223: * 0 if it is the same. Non-zero otherwise
224: *
225: * Side Effects:
226: * None
227: *-----------------------------------------------------------------------
228: */
229: static int
230: DirFindName (p, dname)
231: Path *p; /* Current name */
232: char *dname; /* Desired name */
233: {
234: return (strcmp (p->name, dname));
235: }
236:
237: /*-
238: *-----------------------------------------------------------------------
239: * Dir_HasWildcards --
240: * see if the given name has any wildcard characters in it
241: *
242: * Results:
243: * returns TRUE if the word should be expanded, FALSE otherwise
244: *
245: * Side Effects:
246: * none
247: *-----------------------------------------------------------------------
248: */
249: Boolean
250: Dir_HasWildcards (name)
251: char *name; /* name to check */
252: {
253: register char *cp;
254:
255: for (cp = name; *cp; cp++) {
256: switch(*cp) {
257: case '{':
258: case '[':
259: case '?':
260: case '*':
261: return (TRUE);
262: }
263: }
264: return (FALSE);
265: }
266:
267: /*-
268: *-----------------------------------------------------------------------
269: * DirMatchFiles --
270: * Given a pattern and a Path structure, see if any files
271: * match the pattern and add their names to the 'expansions' list if
272: * any do. This is incomplete -- it doesn't take care of patterns like
273: * src/*src/*.c properly (just *.c on any of the directories), but it
274: * will do for now.
275: *
276: * Results:
277: * Always returns 0
278: *
279: * Side Effects:
280: * File names are added to the expansions lst. The directory will be
281: * fully hashed when this is done.
282: *-----------------------------------------------------------------------
283: */
284: static int
285: DirMatchFiles (pattern, p, expansions)
286: char *pattern; /* Pattern to look for */
287: Path *p; /* Directory to search */
288: Lst expansions; /* Place to store the results */
289: {
290: Hash_Search search; /* Index into the directory's table */
291: Hash_Entry *entry; /* Current entry in the table */
292: char *f; /* Current entry in the directory */
293: Boolean isDot; /* TRUE if the directory being searched is . */
294:
295: isDot = (*p->name == '.' && p->name[1] == '\0');
296:
297: for (entry = Hash_EnumFirst(&p->files, &search);
298: entry != (Hash_Entry *)NULL;
299: entry = Hash_EnumNext(&search))
300: {
301: /*
302: * See if the file matches the given pattern. Note we follow the UNIX
303: * convention that dot files will only be found if the pattern
304: * begins with a dot (note also that as a side effect of the hashing
305: * scheme, .* won't match . or .. since they aren't hashed).
306: */
307: if (Str_Match(entry->key.name, pattern) &&
308: ((entry->key.name[0] != '.') ||
309: (pattern[0] == '.')))
310: {
311: (void)Lst_AtEnd(expansions,
312: (isDot ? strdup(entry->key.name) :
313: str_concat(p->name, entry->key.name,
314: STR_ADDSLASH)));
315: }
316: }
317: return (0);
318: }
319:
320: /*-
321: *-----------------------------------------------------------------------
322: * DirExpandCurly --
323: * Expand curly braces like the C shell. Does this recursively.
324: * Note the special case: if after the piece of the curly brace is
325: * done there are no wildcard characters in the result, the result is
326: * placed on the list WITHOUT CHECKING FOR ITS EXISTENCE.
327: *
328: * Results:
329: * None.
330: *
331: * Side Effects:
332: * The given list is filled with the expansions...
333: *
334: *-----------------------------------------------------------------------
335: */
336: static void
337: DirExpandCurly(word, brace, path, expansions)
338: char *word; /* Entire word to expand */
339: char *brace; /* First curly brace in it */
340: Lst path; /* Search path to use */
341: Lst expansions; /* Place to store the expansions */
342: {
343: char *end; /* Character after the closing brace */
344: char *cp; /* Current position in brace clause */
345: char *start; /* Start of current piece of brace clause */
346: int bracelevel; /* Number of braces we've seen. If we see a
347: * right brace when this is 0, we've hit the
348: * end of the clause. */
349: char *file; /* Current expansion */
350: int otherLen; /* The length of the other pieces of the
351: * expansion (chars before and after the
352: * clause in 'word') */
353: char *cp2; /* Pointer for checking for wildcards in
354: * expansion before calling Dir_Expand */
355:
356: start = brace+1;
357:
358: /*
359: * Find the end of the brace clause first, being wary of nested brace
360: * clauses.
361: */
362: for (end = start, bracelevel = 0; *end != '\0'; end++) {
363: if (*end == '{') {
364: bracelevel++;
365: } else if ((*end == '}') && (bracelevel-- == 0)) {
366: break;
367: }
368: }
369: if (*end == '\0') {
370: Error("Unterminated {} clause \"%s\"", start);
371: return;
372: } else {
373: end++;
374: }
375: otherLen = brace - word + strlen(end);
376:
377: for (cp = start; cp < end; cp++) {
378: /*
379: * Find the end of this piece of the clause.
380: */
381: bracelevel = 0;
382: while (*cp != ',') {
383: if (*cp == '{') {
384: bracelevel++;
385: } else if ((*cp == '}') && (bracelevel-- <= 0)) {
386: break;
387: }
388: cp++;
389: }
390: /*
391: * Allocate room for the combination and install the three pieces.
392: */
393: file = emalloc(otherLen + cp - start + 1);
394: if (brace != word) {
395: strncpy(file, word, brace-word);
396: }
397: if (cp != start) {
398: strncpy(&file[brace-word], start, cp-start);
399: }
400: strcpy(&file[(brace-word)+(cp-start)], end);
401:
402: /*
403: * See if the result has any wildcards in it. If we find one, call
404: * Dir_Expand right away, telling it to place the result on our list
405: * of expansions.
406: */
407: for (cp2 = file; *cp2 != '\0'; cp2++) {
408: switch(*cp2) {
409: case '*':
410: case '?':
411: case '{':
412: case '[':
413: Dir_Expand(file, path, expansions);
414: goto next;
415: }
416: }
417: if (*cp2 == '\0') {
418: /*
419: * Hit the end w/o finding any wildcards, so stick the expansion
420: * on the end of the list.
421: */
422: (void)Lst_AtEnd(expansions, file);
423: } else {
424: next:
425: free(file);
426: }
427: start = cp+1;
428: }
429: }
430:
431:
432: /*-
433: *-----------------------------------------------------------------------
434: * DirExpandInt --
435: * Internal expand routine. Passes through the directories in the
436: * path one by one, calling DirMatchFiles for each. NOTE: This still
437: * doesn't handle patterns in directories...
438: *
439: * Results:
440: * None.
441: *
442: * Side Effects:
443: * Things are added to the expansions list.
444: *
445: *-----------------------------------------------------------------------
446: */
447: static void
448: DirExpandInt(word, path, expansions)
449: char *word; /* Word to expand */
450: Lst path; /* Path on which to look */
451: Lst expansions; /* Place to store the result */
452: {
453: LstNode ln; /* Current node */
454: Path *p; /* Directory in the node */
455:
456: if (Lst_Open(path) == SUCCESS) {
457: while ((ln = Lst_Next(path)) != NILLNODE) {
458: p = (Path *)Lst_Datum(ln);
459: DirMatchFiles(word, p, expansions);
460: }
461: Lst_Close(path);
462: }
463: }
464:
465: /*-
466: *-----------------------------------------------------------------------
467: * DirPrintWord --
468: * Print a word in the list of expansions. Callback for Dir_Expand
469: * when DEBUG(DIR), via Lst_ForEach.
470: *
471: * Results:
472: * === 0
473: *
474: * Side Effects:
475: * The passed word is printed, followed by a space.
476: *
477: *-----------------------------------------------------------------------
478: */
479: static int
480: DirPrintWord(word)
481: char *word;
482: {
483: printf("%s ", word);
484:
485: return(0);
486: }
487:
488: /*-
489: *-----------------------------------------------------------------------
490: * Dir_Expand --
491: * Expand the given word into a list of words by globbing it looking
492: * in the directories on the given search path.
493: *
494: * Results:
495: * A list of words consisting of the files which exist along the search
496: * path matching the given pattern.
497: *
498: * Side Effects:
499: * Directories may be opened. Who knows?
500: *-----------------------------------------------------------------------
501: */
502: void
503: Dir_Expand (word, path, expansions)
504: char *word; /* the word to expand */
505: Lst path; /* the list of directories in which to find
506: * the resulting files */
507: Lst expansions; /* the list on which to place the results */
508: {
509: char *cp;
510:
511: if (DEBUG(DIR)) {
512: printf("expanding \"%s\"...", word);
513: }
514:
515: cp = index(word, '{');
516: if (cp) {
517: DirExpandCurly(word, cp, path, expansions);
518: } else {
519: cp = index(word, '/');
520: if (cp) {
521: /*
522: * The thing has a directory component -- find the first wildcard
523: * in the string.
524: */
525: for (cp = word; *cp; cp++) {
526: if (*cp == '?' || *cp == '[' || *cp == '*' || *cp == '{') {
527: break;
528: }
529: }
530: if (*cp == '{') {
531: /*
532: * This one will be fun.
533: */
534: DirExpandCurly(word, cp, path, expansions);
535: return;
536: } else if (*cp != '\0') {
537: /*
538: * Back up to the start of the component
539: */
540: char *dirpath;
541:
542: while (cp > word && *cp != '/') {
543: cp--;
544: }
545: if (cp != word) {
546: /*
547: * If the glob isn't in the first component, try and find
548: * all the components up to the one with a wildcard.
549: */
550: *cp = '\0';
551: dirpath = Dir_FindFile(word, path);
552: *cp = '/';
553: /*
554: * dirpath is null if can't find the leading component
555: * XXX: Dir_FindFile won't find internal components.
556: * i.e. if the path contains ../Etc/Object and we're
557: * looking for Etc, it won't be found. Ah well.
558: * Probably not important.
559: */
560: if (dirpath != (char *)NULL) {
561: path = Lst_Init(FALSE);
562: Dir_AddDir(path, dirpath);
563: DirExpandInt(cp+1, path, expansions);
564: Lst_Destroy(path, NOFREE);
565: }
566: } else {
567: /*
568: * Start the search from the local directory
569: */
570: DirExpandInt(word, path, expansions);
571: }
572: } else {
573: /*
574: * Return the file -- this should never happen.
575: */
576: DirExpandInt(word, path, expansions);
577: }
578: } else {
579: /*
580: * First the files in dot
581: */
582: DirMatchFiles(word, dot, expansions);
583:
584: /*
585: * Then the files in every other directory on the path.
586: */
587: DirExpandInt(word, path, expansions);
588: }
589: }
590: if (DEBUG(DIR)) {
591: Lst_ForEach(expansions, DirPrintWord, NULL);
592: putchar('\n');
593: }
594: }
595:
596: /*-
597: *-----------------------------------------------------------------------
598: * Dir_FindFile --
599: * Find the file with the given name along the given search path.
600: *
601: * Results:
602: * The path to the file or NULL. This path is guaranteed to be in a
603: * different part of memory than name and so may be safely free'd.
604: *
605: * Side Effects:
606: * If the file is found in a directory which is not on the path
607: * already (either 'name' is absolute or it is a relative path
608: * [ dir1/.../dirn/file ] which exists below one of the directories
609: * already on the search path), its directory is added to the end
610: * of the path on the assumption that there will be more files in
611: * that directory later on. Sometimes this is true. Sometimes not.
612: *-----------------------------------------------------------------------
613: */
614: char *
615: Dir_FindFile (name, path)
616: char *name; /* the file to find */
617: Lst path; /* the Lst of directories to search */
618: {
619: register char *p1; /* pointer into p->name */
620: register char *p2; /* pointer into name */
621: LstNode ln; /* a list element */
622: register char *file; /* the current filename to check */
623: register Path *p; /* current path member */
624: register char *cp; /* index of first slash, if any */
625: Boolean hasSlash; /* true if 'name' contains a / */
626: struct stat stb; /* Buffer for stat, if necessary */
627: Hash_Entry *entry; /* Entry for mtimes table */
628:
629: /*
630: * Find the final component of the name and note whether it has a
631: * slash in it (the name, I mean)
632: */
633: cp = rindex (name, '/');
634: if (cp) {
635: hasSlash = TRUE;
636: cp += 1;
637: } else {
638: hasSlash = FALSE;
639: cp = name;
640: }
641:
642: if (DEBUG(DIR)) {
643: printf("Searching for %s...", name);
644: }
645: /*
646: * No matter what, we always look for the file in the current directory
647: * before anywhere else and we *do not* add the ./ to it if it exists.
648: * This is so there are no conflicts between what the user specifies
649: * (fish.c) and what pmake finds (./fish.c).
650: */
651: if ((!hasSlash || (cp - name == 2 && *name == '.')) &&
652: (Hash_FindEntry (&dot->files, (Address)cp) != (Hash_Entry *)NULL)) {
653: if (DEBUG(DIR)) {
654: printf("in '.'\n");
655: }
656: hits += 1;
657: dot->hits += 1;
658: return (strdup (name));
659: }
660:
661: if (Lst_Open (path) == FAILURE) {
662: if (DEBUG(DIR)) {
663: printf("couldn't open path, file not found\n");
664: }
665: misses += 1;
666: return ((char *) NULL);
667: }
668:
669: /*
670: * We look through all the directories on the path seeking one which
671: * contains the final component of the given name and whose final
672: * component(s) match the name's initial component(s). If such a beast
673: * is found, we concatenate the directory name and the final component
674: * and return the resulting string. If we don't find any such thing,
675: * we go on to phase two...
676: */
677: while ((ln = Lst_Next (path)) != NILLNODE) {
678: p = (Path *) Lst_Datum (ln);
679: if (DEBUG(DIR)) {
680: printf("%s...", p->name);
681: }
682: if (Hash_FindEntry (&p->files, (Address)cp) != (Hash_Entry *)NULL) {
683: if (DEBUG(DIR)) {
684: printf("here...");
685: }
686: if (hasSlash) {
687: /*
688: * If the name had a slash, its initial components and p's
689: * final components must match. This is false if a mismatch
690: * is encountered before all of the initial components
691: * have been checked (p2 > name at the end of the loop), or
692: * we matched only part of one of the components of p
693: * along with all the rest of them (*p1 != '/').
694: */
695: p1 = p->name + strlen (p->name) - 1;
696: p2 = cp - 2;
697: while (p2 >= name && *p1 == *p2) {
698: p1 -= 1; p2 -= 1;
699: }
700: if (p2 >= name || (p1 >= p->name && *p1 != '/')) {
701: if (DEBUG(DIR)) {
702: printf("component mismatch -- continuing...");
703: }
704: continue;
705: }
706: }
707: file = str_concat (p->name, cp, STR_ADDSLASH);
708: if (DEBUG(DIR)) {
709: printf("returning %s\n", file);
710: }
711: Lst_Close (path);
712: p->hits += 1;
713: hits += 1;
714: return (file);
715: } else if (hasSlash) {
716: /*
717: * If the file has a leading path component and that component
718: * exactly matches the entire name of the current search
719: * directory, we assume the file doesn't exist and return NULL.
720: */
721: for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) {
722: continue;
723: }
724: if (*p1 == '\0' && p2 == cp - 1) {
725: if (DEBUG(DIR)) {
726: printf("must be here but isn't -- returing NULL\n");
727: }
728: Lst_Close (path);
729: return ((char *) NULL);
730: }
731: }
732: }
733:
734: /*
735: * We didn't find the file on any existing members of the directory.
736: * If the name doesn't contain a slash, that means it doesn't exist.
737: * If it *does* contain a slash, however, there is still hope: it
738: * could be in a subdirectory of one of the members of the search
739: * path. (eg. /usr/include and sys/types.h. The above search would
740: * fail to turn up types.h in /usr/include, but it *is* in
741: * /usr/include/sys/types.h) If we find such a beast, we assume there
742: * will be more (what else can we assume?) and add all but the last
743: * component of the resulting name onto the search path (at the
744: * end). This phase is only performed if the file is *not* absolute.
745: */
746: if (!hasSlash) {
747: if (DEBUG(DIR)) {
748: printf("failed.\n");
749: }
750: misses += 1;
751: return ((char *) NULL);
752: }
753:
754: if (*name != '/') {
755: Boolean checkedDot = FALSE;
756:
757: if (DEBUG(DIR)) {
758: printf("failed. Trying subdirectories...");
759: }
760: (void) Lst_Open (path);
761: while ((ln = Lst_Next (path)) != NILLNODE) {
762: p = (Path *) Lst_Datum (ln);
763: if (p != dot) {
764: file = str_concat (p->name, name, STR_ADDSLASH);
765: } else {
766: /*
767: * Checking in dot -- DON'T put a leading ./ on the thing.
768: */
769: file = strdup(name);
770: checkedDot = TRUE;
771: }
772: if (DEBUG(DIR)) {
773: printf("checking %s...", file);
774: }
775:
776:
777: if (stat (file, &stb) == 0) {
778: if (DEBUG(DIR)) {
779: printf("got it.\n");
780: }
781:
782: Lst_Close (path);
783:
784: /*
785: * We've found another directory to search. We know there's
786: * a slash in 'file' because we put one there. We nuke it after
787: * finding it and call Dir_AddDir to add this new directory
788: * onto the existing search path. Once that's done, we restore
789: * the slash and triumphantly return the file name, knowing
790: * that should a file in this directory every be referenced
791: * again in such a manner, we will find it without having to do
792: * numerous numbers of access calls. Hurrah!
793: */
794: cp = rindex (file, '/');
795: *cp = '\0';
796: Dir_AddDir (path, file);
797: *cp = '/';
798:
799: /*
800: * Save the modification time so if it's needed, we don't have
801: * to fetch it again.
802: */
803: if (DEBUG(DIR)) {
804: printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
805: file);
806: }
807: entry = Hash_CreateEntry(&mtimes, (ClientData)file,
808: (Boolean *)NULL);
809: Hash_SetValue(entry, stb.st_mtime);
810: nearmisses += 1;
811: return (file);
812: } else {
813: free (file);
814: }
815: }
816:
817: if (DEBUG(DIR)) {
818: printf("failed. ");
819: }
820: Lst_Close (path);
821:
822: if (checkedDot) {
823: /*
824: * Already checked by the given name, since . was in the path,
825: * so no point in proceeding...
826: */
827: if (DEBUG(DIR)) {
828: printf("Checked . already, returning NULL\n");
829: }
830: return(NULL);
831: }
832: }
833:
834: /*
835: * Didn't find it that way, either. Sigh. Phase 3. Add its directory
836: * onto the search path in any case, just in case, then look for the
837: * thing in the hash table. If we find it, grand. We return a new
838: * copy of the name. Otherwise we sadly return a NULL pointer. Sigh.
839: * Note that if the directory holding the file doesn't exist, this will
840: * do an extra search of the final directory on the path. Unless something
841: * weird happens, this search won't succeed and life will be groovy.
842: *
843: * Sigh. We cannot add the directory onto the search path because
844: * of this amusing case:
845: * $(INSTALLDIR)/$(FILE): $(FILE)
846: *
847: * $(FILE) exists in $(INSTALLDIR) but not in the current one.
848: * When searching for $(FILE), we will find it in $(INSTALLDIR)
849: * b/c we added it here. This is not good...
850: */
851: #ifdef notdef
852: cp[-1] = '\0';
853: Dir_AddDir (path, name);
854: cp[-1] = '/';
855:
856: bigmisses += 1;
857: ln = Lst_Last (path);
858: if (ln == NILLNODE) {
859: return ((char *) NULL);
860: } else {
861: p = (Path *) Lst_Datum (ln);
862: }
863:
864: if (Hash_FindEntry (&p->files, (Address)cp) != (Hash_Entry *)NULL) {
865: return (strdup (name));
866: } else {
867: return ((char *) NULL);
868: }
869: #else /* !notdef */
870: if (DEBUG(DIR)) {
871: printf("Looking for \"%s\"...", name);
872: }
873:
874: bigmisses += 1;
875: entry = Hash_FindEntry(&mtimes, name);
876: if (entry != (Hash_Entry *)NULL) {
877: if (DEBUG(DIR)) {
878: printf("got it (in mtime cache)\n");
879: }
880: return(strdup(name));
881: } else if (stat (name, &stb) == 0) {
882: entry = Hash_CreateEntry(&mtimes, name, (Boolean *)NULL);
883: if (DEBUG(DIR)) {
884: printf("Caching %s for %s\n", Targ_FmtTime(stb.st_mtime),
885: name);
886: }
887: Hash_SetValue(entry, stb.st_mtime);
888: return (strdup (name));
889: } else {
890: if (DEBUG(DIR)) {
891: printf("failed. Returning NULL\n");
892: }
893: return ((char *)NULL);
894: }
895: #endif /* notdef */
896: }
897:
898: /*-
899: *-----------------------------------------------------------------------
900: * Dir_MTime --
901: * Find the modification time of the file described by gn along the
902: * search path dirSearchPath.
903: *
904: * Results:
905: * The modification time or 0 if it doesn't exist
906: *
907: * Side Effects:
908: * The modification time is placed in the node's mtime slot.
909: * If the node didn't have a path entry before, and Dir_FindFile
910: * found one for it, the full name is placed in the path slot.
911: *-----------------------------------------------------------------------
912: */
913: int
914: Dir_MTime (gn)
915: GNode *gn; /* the file whose modification time is
916: * desired */
917: {
918: char *fullName; /* the full pathname of name */
919: struct stat stb; /* buffer for finding the mod time */
920: Hash_Entry *entry;
921:
922: if (gn->type & OP_ARCHV) {
923: return Arch_MTime (gn);
924: } else if (gn->path == (char *)NULL) {
925: fullName = Dir_FindFile (gn->name, dirSearchPath);
926: } else {
927: fullName = gn->path;
928: }
929:
930: if (fullName == (char *)NULL) {
931: fullName = gn->name;
932: }
933:
934: entry = Hash_FindEntry(&mtimes, fullName);
935: if (entry != (Hash_Entry *)NULL) {
936: /*
937: * Only do this once -- the second time folks are checking to
938: * see if the file was actually updated, so we need to actually go
939: * to the file system.
940: */
941: if (DEBUG(DIR)) {
942: printf("Using cached time %s for %s\n",
943: Targ_FmtTime(Hash_GetValue(entry)), fullName);
944: }
945: stb.st_mtime = (time_t)Hash_GetValue(entry);
946: Hash_DeleteEntry(&mtimes, entry);
947: } else if (stat (fullName, &stb) < 0) {
948: if (gn->type & OP_MEMBER) {
949: return Arch_MemMTime (gn);
950: } else {
951: stb.st_mtime = 0;
952: }
953: }
954: if (fullName && gn->path == (char *)NULL) {
955: gn->path = fullName;
956: }
957:
958: gn->mtime = stb.st_mtime;
959: return (gn->mtime);
960: }
961:
962: /*-
963: *-----------------------------------------------------------------------
964: * Dir_AddDir --
965: * Add the given name to the end of the given path. The order of
966: * the arguments is backwards so ParseDoDependency can do a
967: * Lst_ForEach of its list of paths...
968: *
969: * Results:
970: * none
971: *
972: * Side Effects:
973: * A structure is added to the list and the directory is
974: * read and hashed.
975: *-----------------------------------------------------------------------
976: */
977: void
978: Dir_AddDir (path, name)
979: Lst path; /* the path to which the directory should be
980: * added */
981: char *name; /* the name of the directory to add */
982: {
983: LstNode ln; /* node in case Path structure is found */
984: register Path *p; /* pointer to new Path structure */
985: DIR *d; /* for reading directory */
986: register struct direct *dp; /* entry in directory */
987: Hash_Entry *he;
988: char *fName;
989:
990: ln = Lst_Find (openDirectories, (ClientData)name, DirFindName);
991: if (ln != NILLNODE) {
992: p = (Path *)Lst_Datum (ln);
993: if (Lst_Member(path, (ClientData)p) == NILLNODE) {
994: p->refCount += 1;
995: (void)Lst_AtEnd (path, (ClientData)p);
996: }
997: } else {
998: if (DEBUG(DIR)) {
999: printf("Caching %s...", name);
1000: fflush(stdout);
1001: }
1002:
1003: if ((d = opendir (name)) != (DIR *) NULL) {
1004: p = (Path *) emalloc (sizeof (Path));
1005: p->name = strdup (name);
1006: p->hits = 0;
1007: p->refCount = 1;
1008: Hash_InitTable (&p->files, -1, HASH_STRING_KEYS);
1009:
1010: /*
1011: * Skip the first two entries -- these will *always* be . and ..
1012: */
1013: (void)readdir(d);
1014: (void)readdir(d);
1015:
1016: while ((dp = readdir (d)) != (struct direct *) NULL) {
1017: #ifdef sun
1018: /*
1019: * The sun directory library doesn't check for a 0 inode
1020: * (0-inode slots just take up space), so we have to do
1021: * it ourselves.
1022: */
1023: if (dp->d_fileno == 0) {
1024: continue;
1025: }
1026: #endif sun
1027: (void)Hash_CreateEntry(&p->files, dp->d_name, (Boolean *)NULL);
1028: }
1029: (void) closedir (d);
1030: (void)Lst_AtEnd (openDirectories, (ClientData)p);
1031: (void)Lst_AtEnd (path, (ClientData)p);
1032: }
1033: if (DEBUG(DIR)) {
1034: printf("done\n");
1035: }
1036: }
1037: }
1038:
1039: /*-
1040: *-----------------------------------------------------------------------
1041: * Dir_CopyDir --
1042: * Callback function for duplicating a search path via Lst_Duplicate.
1043: * Ups the reference count for the directory.
1044: *
1045: * Results:
1046: * Returns the Path it was given.
1047: *
1048: * Side Effects:
1049: * The refCount of the path is incremented.
1050: *
1051: *-----------------------------------------------------------------------
1052: */
1053: ClientData
1054: Dir_CopyDir(p)
1055: Path *p; /* Directory descriptor to copy */
1056: {
1057: p->refCount += 1;
1058:
1059: return ((ClientData)p);
1060: }
1061:
1062: /*-
1063: *-----------------------------------------------------------------------
1064: * Dir_MakeFlags --
1065: * Make a string by taking all the directories in the given search
1066: * path and preceding them by the given flag. Used by the suffix
1067: * module to create variables for compilers based on suffix search
1068: * paths.
1069: *
1070: * Results:
1071: * The string mentioned above. Note that there is no space between
1072: * the given flag and each directory. The empty string is returned if
1073: * Things don't go well.
1074: *
1075: * Side Effects:
1076: * None
1077: *-----------------------------------------------------------------------
1078: */
1079: char *
1080: Dir_MakeFlags (flag, path)
1081: char *flag; /* flag which should precede each directory */
1082: Lst path; /* list of directories */
1083: {
1084: char *str; /* the string which will be returned */
1085: char *tstr; /* the current directory preceded by 'flag' */
1086: LstNode ln; /* the node of the current directory */
1087: Path *p; /* the structure describing the current directory */
1088:
1089: str = strdup ("");
1090:
1091: if (Lst_Open (path) == SUCCESS) {
1092: while ((ln = Lst_Next (path)) != NILLNODE) {
1093: p = (Path *) Lst_Datum (ln);
1094: tstr = str_concat (flag, p->name, 0);
1095: str = str_concat (str, tstr, STR_ADDSPACE | STR_DOFREE);
1096: }
1097: Lst_Close (path);
1098: }
1099:
1100: return (str);
1101: }
1102:
1103: /*-
1104: *-----------------------------------------------------------------------
1105: * Dir_Destroy --
1106: * Nuke a directory descriptor, if possible. Callback procedure
1107: * for the suffixes module when destroying a search path.
1108: *
1109: * Results:
1110: * None.
1111: *
1112: * Side Effects:
1113: * If no other path references this directory (refCount == 0),
1114: * the Path and all its data are freed.
1115: *
1116: *-----------------------------------------------------------------------
1117: */
1118: void
1119: Dir_Destroy (p)
1120: Path *p; /* The directory descriptor to nuke */
1121: {
1122: Hash_Search thing1;
1123: Hash_Entry *thing2;
1124:
1125: p->refCount -= 1;
1126:
1127: if (p->refCount == 0) {
1128: LstNode ln;
1129:
1130: ln = Lst_Member (openDirectories, (ClientData)p);
1131: (void) Lst_Remove (openDirectories, ln);
1132:
1133: Hash_DeleteTable (&p->files);
1134: free((Address)p->name);
1135: free((Address)p);
1136: }
1137: }
1138:
1139: /*-
1140: *-----------------------------------------------------------------------
1141: * Dir_ClearPath --
1142: * Clear out all elements of the given search path. This is different
1143: * from destroying the list, notice.
1144: *
1145: * Results:
1146: * None.
1147: *
1148: * Side Effects:
1149: * The path is set to the empty list.
1150: *
1151: *-----------------------------------------------------------------------
1152: */
1153: void
1154: Dir_ClearPath(path)
1155: Lst path; /* Path to clear */
1156: {
1157: Path *p;
1158: while (!Lst_IsEmpty(path)) {
1159: p = (Path *)Lst_DeQueue(path);
1160: Dir_Destroy(p);
1161: }
1162: }
1163:
1164:
1165: /*-
1166: *-----------------------------------------------------------------------
1167: * Dir_Concat --
1168: * Concatenate two paths, adding the second to the end of the first.
1169: * Makes sure to avoid duplicates.
1170: *
1171: * Results:
1172: * None
1173: *
1174: * Side Effects:
1175: * Reference counts for added dirs are upped.
1176: *
1177: *-----------------------------------------------------------------------
1178: */
1179: void
1180: Dir_Concat(path1, path2)
1181: Lst path1; /* Dest */
1182: Lst path2; /* Source */
1183: {
1184: LstNode ln;
1185: Path *p;
1186:
1187: for (ln = Lst_First(path2); ln != NILLNODE; ln = Lst_Succ(ln)) {
1188: p = (Path *)Lst_Datum(ln);
1189: if (Lst_Member(path1, (ClientData)p) == NILLNODE) {
1190: p->refCount += 1;
1191: (void)Lst_AtEnd(path1, (ClientData)p);
1192: }
1193: }
1194: }
1195:
1196: /********** DEBUG INFO **********/
1197: Dir_PrintDirectories()
1198: {
1199: LstNode ln;
1200: Path *p;
1201:
1202: printf ("#*** Directory Cache:\n");
1203: printf ("# Stats: %d hits %d misses %d near misses %d losers (%d%%)\n",
1204: hits, misses, nearmisses, bigmisses,
1205: (hits+bigmisses+nearmisses ?
1206: hits * 100 / (hits + bigmisses + nearmisses) : 0));
1207: printf ("# %-20s referenced\thits\n", "directory");
1208: if (Lst_Open (openDirectories) == SUCCESS) {
1209: while ((ln = Lst_Next (openDirectories)) != NILLNODE) {
1210: p = (Path *) Lst_Datum (ln);
1211: printf ("# %-20s %10d\t%4d\n", p->name, p->refCount, p->hits);
1212: }
1213: Lst_Close (openDirectories);
1214: }
1215: }
1216:
1217: static int DirPrintDir (p) Path *p; { printf ("%s ", p->name); return (0); }
1218:
1219: Dir_PrintPath (path)
1220: Lst path;
1221: {
1222: Lst_ForEach (path, DirPrintDir, (ClientData)0);
1223: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.