1 /* $NetBSD: dir.c,v 1.43 2004/07/01 20:38:09 jmc Exp $ */ 2 3 /* 4 * Copyright (c) 1988, 1989, 1990 The Regents of the University of California. 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 /* 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 72 #ifndef MAKE_NATIVE 73 static char rcsid[] = "$NetBSD: dir.c,v 1.43 2004/07/01 20:38:09 jmc Exp $"; 74 #else 75 #include <sys/cdefs.h> 76 #ifndef lint 77 #if 0 78 static char sccsid[] = "@(#)dir.c 8.2 (Berkeley) 1/2/94"; 79 #else 80 __RCSID("$NetBSD: dir.c,v 1.43 2004/07/01 20:38:09 jmc Exp $"); 81 #endif 82 #endif /* not lint */ 83 #endif 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 * 94 * Dir_InitCur Set the cur Path. 95 * 96 * Dir_InitDot Set the dot Path. 97 * 98 * Dir_End Cleanup the module. 99 * 100 * Dir_SetPATH Set ${.PATH} to reflect state of dirSearchPath. 101 * 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 * 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 * 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> 139 #include <sys/stat.h> 140 141 #include <dirent.h> 142 #include <errno.h> 143 #include <stdio.h> 144 145 #include "make.h" 146 #include "hash.h" 147 #include "dir.h" 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 */ 233 static Path *cur; /* contents of current directory, if not dot */ 234 static Path *dotLast; /* a fake path entry indicating we need to 235 * look for . last */ 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 247 static int DirFindName(ClientData, ClientData); 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); 251 static int DirPrintWord(ClientData, ClientData); 252 static int DirPrintDir(ClientData, ClientData); 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 *); 257 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 271 Dir_Init (const char *cdname) 272 { 273 dirSearchPath = Lst_Init (FALSE); 274 openDirectories = Lst_Init (FALSE); 275 Hash_InitTable(&mtimes, 0); 276 277 Dir_InitCur(cdname); 278 279 dotLast = (Path *) emalloc (sizeof (Path)); 280 dotLast->refCount = 1; 281 dotLast->hits = 0; 282 dotLast->name = estrdup(".DOTLAST"); 283 Hash_InitTable (&dotLast->files, -1); 284 } 285 286 /* 287 * Called by Dir_Init() and whenever .CURDIR is assigned to. 288 */ 289 void 290 Dir_InitCur (const char *cdname) 291 { 292 Path *p; 293 294 if (cdname != NULL) { 295 /* 296 * Our build directory is not the same as our source directory. 297 * Keep this one around too. 298 */ 299 if ((p = Dir_AddDir(NULL, cdname))) { 300 p->refCount += 1; 301 if (cur && cur != p) { 302 /* 303 * We've been here before, cleanup. 304 */ 305 cur->refCount -= 1; 306 Dir_Destroy((ClientData) cur); 307 } 308 cur = p; 309 } 310 } 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 326 Dir_InitDot(void) 327 { 328 if (dot != NULL) { 329 LstNode ln; 330 331 /* Remove old entry from openDirectories, but do not destroy. */ 332 ln = Lst_Member (openDirectories, (ClientData)dot); 333 (void) Lst_Remove (openDirectories, ln); 334 } 335 336 dot = Dir_AddDir (NULL, "."); 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; 348 Dir_SetPATH(); /* initialize */ 349 } 350 351 /*- 352 *----------------------------------------------------------------------- 353 * Dir_End -- 354 * cleanup things for this module 355 * 356 * Results: 357 * none 358 * 359 * Side Effects: 360 * none 361 *----------------------------------------------------------------------- 362 */ 363 void 364 Dir_End(void) 365 { 366 #ifdef CLEANUP 367 if (cur) { 368 cur->refCount -= 1; 369 Dir_Destroy((ClientData) cur); 370 } 371 dot->refCount -= 1; 372 dotLast->refCount -= 1; 373 Dir_Destroy((ClientData) dotLast); 374 Dir_Destroy((ClientData) dot); 375 Dir_ClearPath(dirSearchPath); 376 Lst_Destroy(dirSearchPath, NOFREE); 377 Dir_ClearPath(openDirectories); 378 Lst_Destroy(openDirectories, NOFREE); 379 Hash_DeleteTable(&mtimes); 380 #endif 381 } 382 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 389 Dir_SetPATH (void) 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 397 if (Lst_Open (dirSearchPath) == SUCCESS) { 398 if ((ln = Lst_First (dirSearchPath)) != NILLNODE) { 399 p = (Path *) Lst_Datum (ln); 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 413 while ((ln = Lst_Next (dirSearchPath)) != NILLNODE) { 414 p = (Path *) Lst_Datum (ln); 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 432 /*- 433 *----------------------------------------------------------------------- 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 * 439 * Input: 440 * p Current name 441 * dname Desired name 442 * 443 * Results: 444 * 0 if it is the same. Non-zero otherwise 445 * 446 * Side Effects: 447 * None 448 *----------------------------------------------------------------------- 449 */ 450 static int 451 DirFindName(ClientData p, ClientData dname) 452 { 453 return (strcmp (((Path *)p)->name, (char *) dname)); 454 } 455 456 /*- 457 *----------------------------------------------------------------------- 458 * Dir_HasWildcards -- 459 * see if the given name has any wildcard characters in it 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 464 * escaping the expansion! 465 * 466 * Input: 467 * name name to check 468 * 469 * Results: 470 * returns TRUE if the word should be expanded, FALSE otherwise 471 * 472 * Side Effects: 473 * none 474 *----------------------------------------------------------------------- 475 */ 476 Boolean 477 Dir_HasWildcards(char *name) 478 { 479 char *cp; 480 int wild = 0, brace = 0, bracket = 0; 481 482 for (cp = name; *cp; cp++) { 483 switch(*cp) { 484 case '{': 485 brace++; 486 wild = 1; 487 break; 488 case '}': 489 brace--; 490 break; 491 case '[': 492 bracket++; 493 wild = 1; 494 break; 495 case ']': 496 bracket--; 497 break; 498 case '?': 499 case '*': 500 wild = 1; 501 break; 502 default: 503 break; 504 } 505 } 506 return wild && bracket == 0 && brace == 0; 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 515 * src / *src / *.c properly (just *.c on any of the directories), but it 516 * will do for now. 517 * 518 * Input: 519 * pattern Pattern to look for 520 * p Directory to search 521 * expansion Place to store the results 522 * 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 532 DirMatchFiles(const char *pattern, Path *p, Lst expansions) 533 { 534 Hash_Search search; /* Index into the directory's table */ 535 Hash_Entry *entry; /* Current entry in the table */ 536 Boolean isDot; /* TRUE if the directory being searched is . */ 537 538 isDot = (*p->name == '.' && p->name[1] == '\0'); 539 540 for (entry = Hash_EnumFirst(&p->files, &search); 541 entry != (Hash_Entry *)NULL; 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, 555 (isDot ? estrdup(entry->name) : 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 * 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 * 577 * Results: 578 * None. 579 * 580 * Side Effects: 581 * The given list is filled with the expansions... 582 * 583 *----------------------------------------------------------------------- 584 */ 585 static void 586 DirExpandCurly(const char *word, const char *brace, Lst path, Lst expansions) 587 { 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 */ 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. */ 594 char *file; /* Current expansion */ 595 int otherLen; /* The length of the other pieces of the 596 * expansion (chars before and after the 597 * clause in 'word') */ 598 char *cp2; /* Pointer for checking for wildcards in 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 */ 638 file = emalloc(otherLen + cp - start + 1); 639 if (brace != word) { 640 strncpy(file, word, brace-word); 641 } 642 if (cp != start) { 643 strncpy(&file[brace-word], start, cp-start); 644 } 645 strcpy(&file[(brace-word)+(cp-start)], end); 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 * 684 * Input: 685 * word Word to expand 686 * path Path on which to look 687 * expansions Place to store the result 688 * 689 * Results: 690 * None. 691 * 692 * Side Effects: 693 * Things are added to the expansions list. 694 * 695 *----------------------------------------------------------------------- 696 */ 697 static void 698 DirExpandInt(const char *word, Lst path, Lst expansions) 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 727 DirPrintWord(ClientData word, ClientData dummy) 728 { 729 printf("%s ", (char *) word); 730 731 return(dummy ? 0 : 0); 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 * 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 * 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 755 Dir_Expand(const char *word, Lst path, Lst expansions) 756 { 757 const char *cp; 758 759 if (DEBUG(DIR)) { 760 printf("Expanding \"%s\"... ", word); 761 } 762 763 cp = strchr(word, '{'); 764 if (cp) { 765 DirExpandCurly(word, cp, path, expansions); 766 } else { 767 cp = strchr(word, '/'); 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) { 794 char sc; 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 */ 799 sc = cp[1]; 800 ((char *)UNCONST(cp))[1] = '\0'; 801 dirpath = Dir_FindFile(word, path); 802 ((char *)UNCONST(cp))[1] = sc; 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 */ 810 if (dirpath != (char *)NULL) { 811 char *dp = &dirpath[strlen(dirpath) - 1]; 812 if (*dp == '/') 813 *dp = '\0'; 814 path = Lst_Init(FALSE); 815 (void) Dir_AddDir(path, dirpath); 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); 836 837 /* 838 * Then the files in every other directory on the path. 839 */ 840 DirExpandInt(word, path, expansions); 841 } 842 } 843 if (DEBUG(DIR)) { 844 Lst_ForEach(expansions, DirPrintWord, (ClientData) 0); 845 fputc('\n', stdout); 846 } 847 } 848 849 /*- 850 *----------------------------------------------------------------------- 851 * DirLookup -- 852 * Find if the file with the given name exists in the given path. 853 * 854 * Results: 855 * The path to the file or NULL. This path is guaranteed to be in a 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 * 863 DirLookup(Path *p, const char *name __unused, const char *cp, 864 Boolean hasSlash __unused) 865 { 866 char *file; /* the current filename to check */ 867 868 if (DEBUG(DIR)) { 869 printf(" %s ...\n", p->name); 870 } 871 872 if (Hash_FindEntry (&p->files, cp) == (Hash_Entry *)NULL) 873 return NULL; 874 875 file = str_concat (p->name, cp, STR_ADDSLASH); 876 if (DEBUG(DIR)) { 877 printf(" returning %s\n", file); 878 } 879 p->hits += 1; 880 hits += 1; 881 return file; 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 * 900 DirLookupSubdir(Path *p, const char *name) 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) { 907 file = str_concat (p->name, name, STR_ADDSLASH); 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)) { 916 printf("checking %s ...\n", file); 917 } 918 919 if (stat (file, &stb) == 0) { 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)) { 925 printf(" Caching %s for %s\n", Targ_FmtTime(stb.st_mtime), 926 file); 927 } 928 entry = Hash_CreateEntry(&mtimes, (char *) file, 929 (Boolean *)NULL); 930 Hash_SetValue(entry, (long)stb.st_mtime); 931 nearmisses += 1; 932 return (file); 933 } 934 free (file); 935 return NULL; 936 } 937 938 /*- 939 *----------------------------------------------------------------------- 940 * DirLookupAbs -- 941 * Find if the file with the given name exists in the given path. 942 * 943 * Results: 944 * The path to the file, the empty string or NULL. If the file is 945 * the empty string, the search should be terminated. 946 * This path is guaranteed to be in a different part of memory 947 * than name and so may be safely free'd. 948 * 949 * Side Effects: 950 * None. 951 *----------------------------------------------------------------------- 952 */ 953 static char * 954 DirLookupAbs(Path *p, const char *name, const char *cp) 955 { 956 char *p1; /* pointer into p->name */ 957 const char *p2; /* pointer into name */ 958 959 if (DEBUG(DIR)) { 960 printf(" %s ...\n", p->name); 961 } 962 963 /* 964 * If the file has a leading path component and that component 965 * exactly matches the entire name of the current search 966 * directory, we can attempt another cache lookup. And if we don't 967 * have a hit, we can safely assume the file does not exist at all. 968 */ 969 for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) { 970 continue; 971 } 972 if (*p1 != '\0' || p2 != cp - 1) { 973 return NULL; 974 } 975 976 if (Hash_FindEntry (&p->files, cp) == (Hash_Entry *)NULL) { 977 if (DEBUG(DIR)) { 978 printf(" must be here but isn't -- returning\n"); 979 } 980 /* Return empty string: terminates search */ 981 return estrdup(""); 982 } 983 984 p->hits += 1; 985 hits += 1; 986 if (DEBUG(DIR)) { 987 printf(" returning %s\n", name); 988 } 989 return (estrdup (name)); 990 } 991 992 /*- 993 *----------------------------------------------------------------------- 994 * DirFindDot -- 995 * Find the file given on "." or curdir 996 * 997 * Results: 998 * The path to the file or NULL. This path is guaranteed to be in a 999 * different part of memory than name and so may be safely free'd. 1000 * 1001 * Side Effects: 1002 * Hit counts change 1003 *----------------------------------------------------------------------- 1004 */ 1005 static char * 1006 DirFindDot(Boolean hasSlash __unused, const char *name, const char *cp) 1007 { 1008 1009 if (Hash_FindEntry (&dot->files, cp) != (Hash_Entry *)NULL) { 1010 if (DEBUG(DIR)) { 1011 printf(" in '.'\n"); 1012 } 1013 hits += 1; 1014 dot->hits += 1; 1015 return (estrdup (name)); 1016 } 1017 if (cur && 1018 Hash_FindEntry (&cur->files, cp) != (Hash_Entry *)NULL) { 1019 if (DEBUG(DIR)) { 1020 printf(" in ${.CURDIR} = %s\n", cur->name); 1021 } 1022 hits += 1; 1023 cur->hits += 1; 1024 return str_concat (cur->name, cp, STR_ADDSLASH); 1025 } 1026 1027 return NULL; 1028 } 1029 1030 /*- 1031 *----------------------------------------------------------------------- 1032 * Dir_FindFile -- 1033 * Find the file with the given name along the given search path. 1034 * 1035 * Input: 1036 * name the file to find 1037 * path the Lst of directories to search 1038 * 1039 * Results: 1040 * The path to the file or NULL. This path is guaranteed to be in a 1041 * different part of memory than name and so may be safely free'd. 1042 * 1043 * Side Effects: 1044 * If the file is found in a directory which is not on the path 1045 * already (either 'name' is absolute or it is a relative path 1046 * [ dir1/.../dirn/file ] which exists below one of the directories 1047 * already on the search path), its directory is added to the end 1048 * of the path on the assumption that there will be more files in 1049 * that directory later on. Sometimes this is true. Sometimes not. 1050 *----------------------------------------------------------------------- 1051 */ 1052 char * 1053 Dir_FindFile(const char *name, Lst path) 1054 { 1055 LstNode ln; /* a list element */ 1056 char *file; /* the current filename to check */ 1057 Path *p; /* current path member */ 1058 const char *cp; /* index of first slash, if any */ 1059 Boolean hasLastDot = FALSE; /* true we should search dot last */ 1060 Boolean hasSlash; /* true if 'name' contains a / */ 1061 struct stat stb; /* Buffer for stat, if necessary */ 1062 Hash_Entry *entry; /* Entry for mtimes table */ 1063 1064 /* 1065 * Find the final component of the name and note whether it has a 1066 * slash in it (the name, I mean) 1067 */ 1068 cp = strrchr (name, '/'); 1069 if (cp) { 1070 hasSlash = TRUE; 1071 cp += 1; 1072 } else { 1073 hasSlash = FALSE; 1074 cp = name; 1075 } 1076 1077 if (DEBUG(DIR)) { 1078 printf("Searching for %s ...", name); 1079 } 1080 1081 if (Lst_Open (path) == FAILURE) { 1082 if (DEBUG(DIR)) { 1083 printf("couldn't open path, file not found\n"); 1084 } 1085 misses += 1; 1086 return ((char *) NULL); 1087 } 1088 1089 if ((ln = Lst_First (path)) != NILLNODE) { 1090 p = (Path *) Lst_Datum (ln); 1091 if (p == dotLast) { 1092 hasLastDot = TRUE; 1093 if (DEBUG(DIR)) 1094 printf("[dot last]..."); 1095 } 1096 } 1097 if (DEBUG(DIR)) { 1098 printf("\n"); 1099 } 1100 1101 /* 1102 * If there's no leading directory components or if the leading 1103 * directory component is exactly `./', consult the cached contents 1104 * of each of the directories on the search path. 1105 */ 1106 if ((!hasSlash || (cp - name == 2 && *name == '.'))) { 1107 /* 1108 * We look through all the directories on the path seeking one which 1109 * contains the final component of the given name. If such a beast 1110 * is found, we concatenate the directory name and the final 1111 * component and return the resulting string. If we don't find any 1112 * such thing, we go on to phase two... 1113 * 1114 * No matter what, we always look for the file in the current 1115 * directory before anywhere else (unless we found the magic 1116 * DOTLAST path, in which case we search it last) and we *do not* 1117 * add the ./ to it if it exists. 1118 * This is so there are no conflicts between what the user 1119 * specifies (fish.c) and what pmake finds (./fish.c). 1120 */ 1121 if (!hasLastDot && 1122 (file = DirFindDot(hasSlash, name, cp)) != NULL) { 1123 Lst_Close (path); 1124 return file; 1125 } 1126 1127 while ((ln = Lst_Next (path)) != NILLNODE) { 1128 p = (Path *) Lst_Datum (ln); 1129 if (p == dotLast) 1130 continue; 1131 if ((file = DirLookup(p, name, cp, hasSlash)) != NULL) { 1132 Lst_Close (path); 1133 return file; 1134 } 1135 } 1136 1137 if (hasLastDot && 1138 (file = DirFindDot(hasSlash, name, cp)) != NULL) { 1139 Lst_Close (path); 1140 return file; 1141 } 1142 } 1143 Lst_Close (path); 1144 1145 /* 1146 * We didn't find the file on any directory in the search path. 1147 * If the name doesn't contain a slash, that means it doesn't exist. 1148 * If it *does* contain a slash, however, there is still hope: it 1149 * could be in a subdirectory of one of the members of the search 1150 * path. (eg. /usr/include and sys/types.h. The above search would 1151 * fail to turn up types.h in /usr/include, but it *is* in 1152 * /usr/include/sys/types.h). 1153 * [ This no longer applies: If we find such a beast, we assume there 1154 * will be more (what else can we assume?) and add all but the last 1155 * component of the resulting name onto the search path (at the 1156 * end).] 1157 * This phase is only performed if the file is *not* absolute. 1158 */ 1159 if (!hasSlash) { 1160 if (DEBUG(DIR)) { 1161 printf(" failed.\n"); 1162 } 1163 misses += 1; 1164 return ((char *) NULL); 1165 } 1166 1167 if (name[0] != '/') { 1168 Boolean checkedDot = FALSE; 1169 1170 if (DEBUG(DIR)) { 1171 printf(" Trying subdirectories...\n"); 1172 } 1173 1174 if (!hasLastDot) { 1175 if (dot) { 1176 checkedDot = TRUE; 1177 if ((file = DirLookupSubdir(dot, name)) != NULL) 1178 return file; 1179 } 1180 if (cur && (file = DirLookupSubdir(cur, name)) != NULL) 1181 return file; 1182 } 1183 1184 (void) Lst_Open (path); 1185 while ((ln = Lst_Next (path)) != NILLNODE) { 1186 p = (Path *) Lst_Datum (ln); 1187 if (p == dotLast) 1188 continue; 1189 if (p == dot) { 1190 if (checkedDot) 1191 continue; 1192 checkedDot = TRUE; 1193 } 1194 if ((file = DirLookupSubdir(p, name)) != NULL) { 1195 Lst_Close (path); 1196 return file; 1197 } 1198 } 1199 Lst_Close (path); 1200 1201 if (hasLastDot) { 1202 if (dot && !checkedDot) { 1203 checkedDot = TRUE; 1204 if ((file = DirLookupSubdir(dot, name)) != NULL) 1205 return file; 1206 } 1207 if (cur && (file = DirLookupSubdir(cur, name)) != NULL) 1208 return file; 1209 } 1210 1211 if (checkedDot) { 1212 /* 1213 * Already checked by the given name, since . was in the path, 1214 * so no point in proceeding... 1215 */ 1216 if (DEBUG(DIR)) { 1217 printf(" Checked . already, returning NULL\n"); 1218 } 1219 return(NULL); 1220 } 1221 1222 } else { /* name[0] == '/' */ 1223 1224 /* 1225 * For absolute names, compare directory path prefix against the 1226 * the directory path of each member on the search path for an exact 1227 * match. If we have an exact match on any member of the search path, 1228 * use the cached contents of that member to lookup the final file 1229 * component. If that lookup fails we can safely assume that the 1230 * file does not exist at all. This is signified by DirLookupAbs() 1231 * returning an empty string. 1232 */ 1233 if (DEBUG(DIR)) { 1234 printf(" Trying exact path matches...\n"); 1235 } 1236 1237 if (!hasLastDot && cur && (file = DirLookupAbs(cur, name, cp)) != NULL) 1238 return *file?file:NULL; 1239 1240 (void) Lst_Open (path); 1241 while ((ln = Lst_Next (path)) != NILLNODE) { 1242 p = (Path *) Lst_Datum (ln); 1243 if (p == dotLast) 1244 continue; 1245 if ((file = DirLookupAbs(p, name, cp)) != NULL) { 1246 Lst_Close (path); 1247 return *file?file:NULL; 1248 } 1249 } 1250 Lst_Close (path); 1251 1252 if (hasLastDot && cur && (file = DirLookupAbs(cur, name, cp)) != NULL) 1253 return *file?file:NULL; 1254 } 1255 1256 /* 1257 * Didn't find it that way, either. Sigh. Phase 3. Add its directory 1258 * onto the search path in any case, just in case, then look for the 1259 * thing in the hash table. If we find it, grand. We return a new 1260 * copy of the name. Otherwise we sadly return a NULL pointer. Sigh. 1261 * Note that if the directory holding the file doesn't exist, this will 1262 * do an extra search of the final directory on the path. Unless something 1263 * weird happens, this search won't succeed and life will be groovy. 1264 * 1265 * Sigh. We cannot add the directory onto the search path because 1266 * of this amusing case: 1267 * $(INSTALLDIR)/$(FILE): $(FILE) 1268 * 1269 * $(FILE) exists in $(INSTALLDIR) but not in the current one. 1270 * When searching for $(FILE), we will find it in $(INSTALLDIR) 1271 * b/c we added it here. This is not good... 1272 */ 1273 #ifdef notdef 1274 cp[-1] = '\0'; 1275 (void) Dir_AddDir (path, name); 1276 cp[-1] = '/'; 1277 1278 bigmisses += 1; 1279 ln = Lst_Last (path); 1280 if (ln == NILLNODE) { 1281 return ((char *) NULL); 1282 } else { 1283 p = (Path *) Lst_Datum (ln); 1284 } 1285 1286 if (Hash_FindEntry (&p->files, cp) != (Hash_Entry *)NULL) { 1287 return (estrdup (name)); 1288 } else { 1289 return ((char *) NULL); 1290 } 1291 #else /* !notdef */ 1292 if (DEBUG(DIR)) { 1293 printf(" Looking for \"%s\" ...\n", name); 1294 } 1295 1296 bigmisses += 1; 1297 entry = Hash_FindEntry(&mtimes, name); 1298 if (entry != (Hash_Entry *)NULL) { 1299 if (DEBUG(DIR)) { 1300 printf(" got it (in mtime cache)\n"); 1301 } 1302 return(estrdup(name)); 1303 } else if (stat (name, &stb) == 0) { 1304 entry = Hash_CreateEntry(&mtimes, name, (Boolean *)NULL); 1305 if (DEBUG(DIR)) { 1306 printf(" Caching %s for %s\n", Targ_FmtTime(stb.st_mtime), 1307 name); 1308 } 1309 Hash_SetValue(entry, (long)stb.st_mtime); 1310 return (estrdup (name)); 1311 } else { 1312 if (DEBUG(DIR)) { 1313 printf(" failed. Returning NULL\n"); 1314 } 1315 return ((char *)NULL); 1316 } 1317 #endif /* notdef */ 1318 } 1319 1320 1321 /*- 1322 *----------------------------------------------------------------------- 1323 * Dir_FindHereOrAbove -- 1324 * search for a path starting at a given directory and then working 1325 * our way up towards the root. 1326 * 1327 * Input: 1328 * here starting directory 1329 * search_path the path we are looking for 1330 * result the result of a successful search is placed here 1331 * rlen the length of the result buffer 1332 * (typically MAXPATHLEN + 1) 1333 * 1334 * Results: 1335 * 0 on failure, 1 on success [in which case the found path is put 1336 * in the result buffer]. 1337 * 1338 * Side Effects: 1339 *----------------------------------------------------------------------- 1340 */ 1341 int 1342 Dir_FindHereOrAbove(char *here, char *search_path, char *result, int rlen) { 1343 1344 struct stat st; 1345 char dirbase[MAXPATHLEN + 1], *db_end; 1346 char try[MAXPATHLEN + 1], *try_end; 1347 1348 /* copy out our starting point */ 1349 snprintf(dirbase, sizeof(dirbase), "%s", here); 1350 db_end = dirbase + strlen(dirbase); 1351 1352 /* loop until we determine a result */ 1353 while (1) { 1354 1355 /* try and stat(2) it ... */ 1356 snprintf(try, sizeof(try), "%s/%s", dirbase, search_path); 1357 if (stat(try, &st) != -1) { 1358 /* 1359 * success! if we found a file, chop off 1360 * the filename so we return a directory. 1361 */ 1362 if ((st.st_mode & S_IFMT) != S_IFDIR) { 1363 try_end = try + strlen(try); 1364 while (try_end > try && *try_end != '/') 1365 try_end--; 1366 if (try_end > try) 1367 *try_end = 0; /* chop! */ 1368 } 1369 1370 /* 1371 * done! 1372 */ 1373 snprintf(result, rlen, "%s", try); 1374 return(1); 1375 } 1376 1377 /* 1378 * nope, we didn't find it. if we used up dirbase we've 1379 * reached the root and failed. 1380 */ 1381 if (db_end == dirbase) 1382 break; /* failed! */ 1383 1384 /* 1385 * truncate dirbase from the end to move up a dir 1386 */ 1387 while (db_end > dirbase && *db_end != '/') 1388 db_end--; 1389 *db_end = 0; /* chop! */ 1390 1391 } /* while (1) */ 1392 1393 /* 1394 * we failed... 1395 */ 1396 return(0); 1397 } 1398 1399 /*- 1400 *----------------------------------------------------------------------- 1401 * Dir_MTime -- 1402 * Find the modification time of the file described by gn along the 1403 * search path dirSearchPath. 1404 * 1405 * Input: 1406 * gn the file whose modification time is desired 1407 * 1408 * Results: 1409 * The modification time or 0 if it doesn't exist 1410 * 1411 * Side Effects: 1412 * The modification time is placed in the node's mtime slot. 1413 * If the node didn't have a path entry before, and Dir_FindFile 1414 * found one for it, the full name is placed in the path slot. 1415 *----------------------------------------------------------------------- 1416 */ 1417 int 1418 Dir_MTime(GNode *gn) 1419 { 1420 char *fullName; /* the full pathname of name */ 1421 struct stat stb; /* buffer for finding the mod time */ 1422 Hash_Entry *entry; 1423 1424 if (gn->type & OP_ARCHV) { 1425 return Arch_MTime (gn); 1426 } else if (gn->type & OP_PHONY) { 1427 gn->mtime = 0; 1428 return 0; 1429 } else if (gn->path == (char *)NULL) { 1430 if (gn->type & OP_NOPATH) 1431 fullName = NULL; 1432 else 1433 fullName = Dir_FindFile (gn->name, dirSearchPath); 1434 } else { 1435 fullName = gn->path; 1436 } 1437 1438 if (fullName == (char *)NULL) { 1439 fullName = estrdup(gn->name); 1440 } 1441 1442 entry = Hash_FindEntry(&mtimes, fullName); 1443 if (entry != (Hash_Entry *)NULL) { 1444 /* 1445 * Only do this once -- the second time folks are checking to 1446 * see if the file was actually updated, so we need to actually go 1447 * to the file system. 1448 */ 1449 if (DEBUG(DIR)) { 1450 printf("Using cached time %s for %s\n", 1451 Targ_FmtTime((time_t)(long)Hash_GetValue(entry)), fullName); 1452 } 1453 stb.st_mtime = (time_t)(long)Hash_GetValue(entry); 1454 Hash_DeleteEntry(&mtimes, entry); 1455 } else if (stat (fullName, &stb) < 0) { 1456 if (gn->type & OP_MEMBER) { 1457 if (fullName != gn->path) 1458 free(fullName); 1459 return Arch_MemMTime (gn); 1460 } else { 1461 stb.st_mtime = 0; 1462 } 1463 } 1464 if (fullName && gn->path == (char *)NULL) { 1465 gn->path = fullName; 1466 } 1467 1468 gn->mtime = stb.st_mtime; 1469 return (gn->mtime); 1470 } 1471 1472 /*- 1473 *----------------------------------------------------------------------- 1474 * Dir_AddDir -- 1475 * Add the given name to the end of the given path. The order of 1476 * the arguments is backwards so ParseDoDependency can do a 1477 * Lst_ForEach of its list of paths... 1478 * 1479 * Input: 1480 * path the path to which the directory should be 1481 * added 1482 * name the name of the directory to add 1483 * 1484 * Results: 1485 * none 1486 * 1487 * Side Effects: 1488 * A structure is added to the list and the directory is 1489 * read and hashed. 1490 *----------------------------------------------------------------------- 1491 */ 1492 Path * 1493 Dir_AddDir(Lst path, const char *name) 1494 { 1495 LstNode ln = NILLNODE; /* node in case Path structure is found */ 1496 Path *p = NULL; /* pointer to new Path structure */ 1497 DIR *d; /* for reading directory */ 1498 struct dirent *dp; /* entry in directory */ 1499 1500 if (strcmp(name, ".DOTLAST") == 0) { 1501 ln = Lst_Find (path, (ClientData)UNCONST(name), DirFindName); 1502 if (ln != NILLNODE) 1503 return (Path *) Lst_Datum(ln); 1504 else { 1505 dotLast->refCount += 1; 1506 (void)Lst_AtFront(path, (ClientData)dotLast); 1507 } 1508 } 1509 1510 if (path) 1511 ln = Lst_Find (openDirectories, (ClientData)UNCONST(name), DirFindName); 1512 if (ln != NILLNODE) { 1513 p = (Path *)Lst_Datum (ln); 1514 if (Lst_Member(path, (ClientData)p) == NILLNODE) { 1515 p->refCount += 1; 1516 (void)Lst_AtEnd (path, (ClientData)p); 1517 } 1518 } else { 1519 if (DEBUG(DIR)) { 1520 printf("Caching %s ...", name); 1521 fflush(stdout); 1522 } 1523 1524 if ((d = opendir (name)) != (DIR *) NULL) { 1525 p = (Path *) emalloc (sizeof (Path)); 1526 p->name = estrdup (name); 1527 p->hits = 0; 1528 p->refCount = 1; 1529 Hash_InitTable (&p->files, -1); 1530 1531 while ((dp = readdir (d)) != (struct dirent *) NULL) { 1532 #if defined(sun) && defined(d_ino) /* d_ino is a sunos4 #define for d_fileno */ 1533 /* 1534 * The sun directory library doesn't check for a 0 inode 1535 * (0-inode slots just take up space), so we have to do 1536 * it ourselves. 1537 */ 1538 if (dp->d_fileno == 0) { 1539 continue; 1540 } 1541 #endif /* sun && d_ino */ 1542 (void)Hash_CreateEntry(&p->files, dp->d_name, (Boolean *)NULL); 1543 } 1544 (void) closedir (d); 1545 (void)Lst_AtEnd (openDirectories, (ClientData)p); 1546 if (path != NULL) 1547 (void)Lst_AtEnd (path, (ClientData)p); 1548 } 1549 if (DEBUG(DIR)) { 1550 printf("done\n"); 1551 } 1552 } 1553 return p; 1554 } 1555 1556 /*- 1557 *----------------------------------------------------------------------- 1558 * Dir_CopyDir -- 1559 * Callback function for duplicating a search path via Lst_Duplicate. 1560 * Ups the reference count for the directory. 1561 * 1562 * Results: 1563 * Returns the Path it was given. 1564 * 1565 * Side Effects: 1566 * The refCount of the path is incremented. 1567 * 1568 *----------------------------------------------------------------------- 1569 */ 1570 ClientData 1571 Dir_CopyDir(ClientData p) 1572 { 1573 ((Path *) p)->refCount += 1; 1574 1575 return ((ClientData)p); 1576 } 1577 1578 /*- 1579 *----------------------------------------------------------------------- 1580 * Dir_MakeFlags -- 1581 * Make a string by taking all the directories in the given search 1582 * path and preceding them by the given flag. Used by the suffix 1583 * module to create variables for compilers based on suffix search 1584 * paths. 1585 * 1586 * Input: 1587 * flag flag which should precede each directory 1588 * path list of directories 1589 * 1590 * Results: 1591 * The string mentioned above. Note that there is no space between 1592 * the given flag and each directory. The empty string is returned if 1593 * Things don't go well. 1594 * 1595 * Side Effects: 1596 * None 1597 *----------------------------------------------------------------------- 1598 */ 1599 char * 1600 Dir_MakeFlags(const char *flag, Lst path) 1601 { 1602 char *str; /* the string which will be returned */ 1603 char *s1, *s2;/* the current directory preceded by 'flag' */ 1604 LstNode ln; /* the node of the current directory */ 1605 Path *p; /* the structure describing the current directory */ 1606 1607 str = estrdup (""); 1608 1609 if (Lst_Open (path) == SUCCESS) { 1610 while ((ln = Lst_Next (path)) != NILLNODE) { 1611 p = (Path *) Lst_Datum (ln); 1612 s2 = str_concat (flag, p->name, 0); 1613 str = str_concat (s1 = str, s2, STR_ADDSPACE); 1614 free(s1); 1615 free(s2); 1616 } 1617 Lst_Close (path); 1618 } 1619 1620 return (str); 1621 } 1622 1623 /*- 1624 *----------------------------------------------------------------------- 1625 * Dir_Destroy -- 1626 * Nuke a directory descriptor, if possible. Callback procedure 1627 * for the suffixes module when destroying a search path. 1628 * 1629 * Input: 1630 * pp The directory descriptor to nuke 1631 * 1632 * Results: 1633 * None. 1634 * 1635 * Side Effects: 1636 * If no other path references this directory (refCount == 0), 1637 * the Path and all its data are freed. 1638 * 1639 *----------------------------------------------------------------------- 1640 */ 1641 void 1642 Dir_Destroy(ClientData pp) 1643 { 1644 Path *p = (Path *) pp; 1645 p->refCount -= 1; 1646 1647 if (p->refCount == 0) { 1648 LstNode ln; 1649 1650 ln = Lst_Member (openDirectories, (ClientData)p); 1651 (void) Lst_Remove (openDirectories, ln); 1652 1653 Hash_DeleteTable (&p->files); 1654 free((Address)p->name); 1655 free((Address)p); 1656 } 1657 } 1658 1659 /*- 1660 *----------------------------------------------------------------------- 1661 * Dir_ClearPath -- 1662 * Clear out all elements of the given search path. This is different 1663 * from destroying the list, notice. 1664 * 1665 * Input: 1666 * path Path to clear 1667 * 1668 * Results: 1669 * None. 1670 * 1671 * Side Effects: 1672 * The path is set to the empty list. 1673 * 1674 *----------------------------------------------------------------------- 1675 */ 1676 void 1677 Dir_ClearPath(Lst path) 1678 { 1679 Path *p; 1680 while (!Lst_IsEmpty(path)) { 1681 p = (Path *)Lst_DeQueue(path); 1682 Dir_Destroy((ClientData) p); 1683 } 1684 } 1685 1686 1687 /*- 1688 *----------------------------------------------------------------------- 1689 * Dir_Concat -- 1690 * Concatenate two paths, adding the second to the end of the first. 1691 * Makes sure to avoid duplicates. 1692 * 1693 * Input: 1694 * path1 Dest 1695 * path2 Source 1696 * 1697 * Results: 1698 * None 1699 * 1700 * Side Effects: 1701 * Reference counts for added dirs are upped. 1702 * 1703 *----------------------------------------------------------------------- 1704 */ 1705 void 1706 Dir_Concat(Lst path1, Lst path2) 1707 { 1708 LstNode ln; 1709 Path *p; 1710 1711 for (ln = Lst_First(path2); ln != NILLNODE; ln = Lst_Succ(ln)) { 1712 p = (Path *)Lst_Datum(ln); 1713 if (Lst_Member(path1, (ClientData)p) == NILLNODE) { 1714 p->refCount += 1; 1715 (void)Lst_AtEnd(path1, (ClientData)p); 1716 } 1717 } 1718 } 1719 1720 /********** DEBUG INFO **********/ 1721 void 1722 Dir_PrintDirectories(void) 1723 { 1724 LstNode ln; 1725 Path *p; 1726 1727 printf ("#*** Directory Cache:\n"); 1728 printf ("# Stats: %d hits %d misses %d near misses %d losers (%d%%)\n", 1729 hits, misses, nearmisses, bigmisses, 1730 (hits+bigmisses+nearmisses ? 1731 hits * 100 / (hits + bigmisses + nearmisses) : 0)); 1732 printf ("# %-20s referenced\thits\n", "directory"); 1733 if (Lst_Open (openDirectories) == SUCCESS) { 1734 while ((ln = Lst_Next (openDirectories)) != NILLNODE) { 1735 p = (Path *) Lst_Datum (ln); 1736 printf ("# %-20s %10d\t%4d\n", p->name, p->refCount, p->hits); 1737 } 1738 Lst_Close (openDirectories); 1739 } 1740 } 1741 1742 static int 1743 DirPrintDir(ClientData p, ClientData dummy) 1744 { 1745 printf ("%s ", ((Path *) p)->name); 1746 return (dummy ? 0 : 0); 1747 } 1748 1749 void 1750 Dir_PrintPath(Lst path) 1751 { 1752 Lst_ForEach (path, DirPrintDir, (ClientData)0); 1753 } 1754