make.c revision 146581
1/*- 2 * Copyright (c) 1988, 1989, 1990, 1993 3 * The Regents of the University of California. All rights reserved. 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, 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. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)make.c 8.1 (Berkeley) 6/6/93 39 */ 40 41#include <sys/cdefs.h> 42__FBSDID("$FreeBSD: head/usr.bin/make/make.c 146581 2005-05-24 16:05:51Z harti $"); 43 44/* 45 * make.c 46 * The functions which perform the examination of targets and 47 * their suitability for creation 48 * 49 * Interface: 50 * Make_Run Initialize things for the module and recreate 51 * whatever needs recreating. Returns TRUE if 52 * work was (or would have been) done and FALSE 53 * otherwise. 54 * 55 * Make_Update Update all parents of a given child. Performs 56 * various bookkeeping chores like the updating 57 * of the cmtime field of the parent, filling 58 * of the IMPSRC context variable, etc. It will 59 * place the parent on the toBeMade queue if it should be. 60 * 61 * Make_TimeStamp Function to set the parent's cmtime field 62 * based on a child's modification time. 63 * 64 * Make_DoAllVar Set up the various local variables for a 65 * target, including the .ALLSRC variable, making 66 * sure that any variable that needs to exist 67 * at the very least has the empty value. 68 * 69 * Make_OODate Determine if a target is out-of-date. 70 * 71 * Make_HandleUse See if a child is a .USE node for a parent 72 * and perform the .USE actions if so. 73 */ 74 75#include <stdlib.h> 76 77#include "arch.h" 78#include "config.h" 79#include "dir.h" 80#include "globals.h" 81#include "GNode.h" 82#include "job.h" 83#include "make.h" 84#include "parse.h" 85#include "suff.h" 86#include "targ.h" 87#include "util.h" 88#include "var.h" 89 90/* The current fringe of the graph. These are nodes which await examination 91 * by MakeOODate. It is added to by Make_Update and subtracted from by 92 * MakeStartJobs */ 93static Lst toBeMade = Lst_Initializer(toBeMade); 94 95/* 96 * Number of nodes to be processed. If this is non-zero when Job_Empty() 97 * returns TRUE, there's a cycle in the graph. 98 */ 99static int numNodes; 100 101static Boolean MakeStartJobs(void); 102 103/** 104 * Make_TimeStamp 105 * Set the cmtime field of a parent node based on the mtime stamp in its 106 * child. Called from MakeOODate via LST_FOREACH. 107 * 108 * Results: 109 * Always returns 0. 110 * 111 * Side Effects: 112 * The cmtime of the parent node will be changed if the mtime 113 * field of the child is greater than it. 114 */ 115int 116Make_TimeStamp(GNode *pgn, GNode *cgn) 117{ 118 119 if (cgn->mtime > pgn->cmtime) { 120 pgn->cmtime = cgn->mtime; 121 } 122 return (0); 123} 124 125/** 126 * Make_OODate 127 * See if a given node is out of date with respect to its sources. 128 * Used by Make_Run when deciding which nodes to place on the 129 * toBeMade queue initially and by Make_Update to screen out USE and 130 * EXEC nodes. In the latter case, however, any other sort of node 131 * must be considered out-of-date since at least one of its children 132 * will have been recreated. 133 * 134 * Results: 135 * TRUE if the node is out of date. FALSE otherwise. 136 * 137 * Side Effects: 138 * The mtime field of the node and the cmtime field of its parents 139 * will/may be changed. 140 */ 141Boolean 142Make_OODate(GNode *gn) 143{ 144 Boolean oodate; 145 LstNode *ln; 146 147 /* 148 * Certain types of targets needn't even be sought as their datedness 149 * doesn't depend on their modification time... 150 */ 151 if ((gn->type & (OP_JOIN | OP_USE | OP_EXEC)) == 0) { 152 Dir_MTime(gn); 153 if (gn->mtime != 0) { 154 DEBUGF(MAKE, ("modified %s...", 155 Targ_FmtTime(gn->mtime))); 156 } else { 157 DEBUGF(MAKE, ("non-existent...")); 158 } 159 } 160 161 /* 162 * A target is remade in one of the following circumstances: 163 * its modification time is smaller than that of its youngest child 164 * and it would actually be run (has commands or type OP_NOP) 165 * it's the object of a force operator 166 * it has no children, was on the lhs of an operator and doesn't 167 * exist already. 168 * 169 * Libraries are only considered out-of-date if the archive module says 170 * they are. 171 * 172 * These weird rules are brought to you by Backward-Compatibility and 173 * the strange people who wrote 'Make'. 174 */ 175 if (gn->type & OP_USE) { 176 /* 177 * If the node is a USE node it is *never* out of date 178 * no matter *what*. 179 */ 180 DEBUGF(MAKE, (".USE node...")); 181 oodate = FALSE; 182 183 } else if (gn->type & OP_LIB) { 184 DEBUGF(MAKE, ("library...")); 185 186 /* 187 * always out of date if no children and :: target 188 */ 189 oodate = Arch_LibOODate(gn) || 190 ((gn->cmtime == 0) && (gn->type & OP_DOUBLEDEP)); 191 192 } else if (gn->type & OP_JOIN) { 193 /* 194 * A target with the .JOIN attribute is only considered 195 * out-of-date if any of its children was out-of-date. 196 */ 197 DEBUGF(MAKE, (".JOIN node...")); 198 oodate = gn->childMade; 199 200 } else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) { 201 /* 202 * A node which is the object of the force (!) operator or 203 * which has the .EXEC attribute is always considered 204 * out-of-date. 205 */ 206 if (gn->type & OP_FORCE) { 207 DEBUGF(MAKE, ("! operator...")); 208 } else if (gn->type & OP_PHONY) { 209 DEBUGF(MAKE, (".PHONY node...")); 210 } else { 211 DEBUGF(MAKE, (".EXEC node...")); 212 } 213 oodate = TRUE; 214 215 } else if ((gn->mtime < gn->cmtime) || 216 ((gn->cmtime == 0) && 217 ((gn->mtime==0) || (gn->type & OP_DOUBLEDEP)))) { 218 /* 219 * A node whose modification time is less than that of its 220 * youngest child or that has no children (cmtime == 0) and 221 * either doesn't exist (mtime == 0) or was the object of a 222 * :: operator is out-of-date. Why? Because that's the way 223 * Make does it. 224 */ 225 if (gn->mtime < gn->cmtime) { 226 DEBUGF(MAKE, ("modified before source...")); 227 } else if (gn->mtime == 0) { 228 DEBUGF(MAKE, ("non-existent and no sources...")); 229 } else { 230 DEBUGF(MAKE, (":: operator and no sources...")); 231 } 232 oodate = TRUE; 233 } else 234 oodate = FALSE; 235 236 /* 237 * If the target isn't out-of-date, the parents need to know its 238 * modification time. Note that targets that appear to be out-of-date 239 * but aren't, because they have no commands and aren't of type OP_NOP, 240 * have their mtime stay below their children's mtime to keep parents 241 * from thinking they're out-of-date. 242 */ 243 if (!oodate) { 244 LST_FOREACH(ln, &gn->parents) 245 if (Make_TimeStamp(Lst_Datum(ln), gn)) 246 break; 247 } 248 249 return (oodate); 250} 251 252/** 253 * Make_HandleUse 254 * Function called by Make_Run and SuffApplyTransform on the downward 255 * pass to handle .USE and transformation nodes. A callback function 256 * for LST_FOREACH, it implements the .USE and transformation 257 * functionality by copying the node's commands, type flags 258 * and children to the parent node. Should be called before the 259 * children are enqueued to be looked at. 260 * 261 * A .USE node is much like an explicit transformation rule, except 262 * its commands are always added to the target node, even if the 263 * target already has commands. 264 * 265 * Results: 266 * returns 0. 267 * 268 * Side Effects: 269 * Children and commands may be added to the parent and the parent's 270 * type may be changed. 271 * 272 *----------------------------------------------------------------------- 273 */ 274int 275Make_HandleUse(GNode *cgn, GNode *pgn) 276{ 277 GNode *gn; /* A child of the .USE node */ 278 LstNode *ln; /* An element in the children list */ 279 280 if (cgn->type & (OP_USE | OP_TRANSFORM)) { 281 if ((cgn->type & OP_USE) || Lst_IsEmpty(&pgn->commands)) { 282 /* 283 * .USE or transformation and target has no commands -- 284 * append the child's commands to the parent. 285 */ 286 Lst_Concat(&pgn->commands, &cgn->commands, LST_CONCNEW); 287 } 288 289 for (ln = Lst_First(&cgn->children); ln != NULL; 290 ln = Lst_Succ(ln)) { 291 gn = Lst_Datum(ln); 292 293 if (Lst_Member(&pgn->children, gn) == NULL) { 294 Lst_AtEnd(&pgn->children, gn); 295 Lst_AtEnd(&gn->parents, pgn); 296 pgn->unmade += 1; 297 } 298 } 299 300 pgn->type |= cgn->type & ~(OP_OPMASK | OP_USE | OP_TRANSFORM); 301 302 /* 303 * This child node is now "made", so we decrement the count of 304 * unmade children in the parent... We also remove the child 305 * from the parent's list to accurately reflect the number of 306 * decent children the parent has. This is used by Make_Run to 307 * decide whether to queue the parent or examine its children... 308 */ 309 if (cgn->type & OP_USE) { 310 pgn->unmade--; 311 } 312 } 313 return (0); 314} 315 316/** 317 * Make_Update 318 * Perform update on the parents of a node. Used by JobFinish once 319 * a node has been dealt with and by MakeStartJobs if it finds an 320 * up-to-date node. 321 * 322 * Results: 323 * Always returns 0 324 * 325 * Side Effects: 326 * The unmade field of pgn is decremented and pgn may be placed on 327 * the toBeMade queue if this field becomes 0. 328 * 329 * If the child was made, the parent's childMade field will be set true 330 * and its cmtime set to now. 331 * 332 * If the child wasn't made, the cmtime field of the parent will be 333 * altered if the child's mtime is big enough. 334 * 335 * Finally, if the child is the implied source for the parent, the 336 * parent's IMPSRC variable is set appropriately. 337 */ 338void 339Make_Update(GNode *cgn) 340{ 341 GNode *pgn; /* the parent node */ 342 const char *cname; /* the child's name */ 343 LstNode *ln; /* Element in parents and iParents lists */ 344 const char *cpref; 345 346 cname = Var_Value(TARGET, cgn); 347 348 /* 349 * If the child was actually made, see what its modification time is 350 * now -- some rules won't actually update the file. If the file still 351 * doesn't exist, make its mtime now. 352 */ 353 if (cgn->made != UPTODATE) { 354#ifndef RECHECK 355 /* 356 * We can't re-stat the thing, but we can at least take care 357 * of rules where a target depends on a source that actually 358 * creates the target, but only if it has changed, e.g. 359 * 360 * parse.h : parse.o 361 * 362 * parse.o : parse.y 363 * yacc -d parse.y 364 * cc -c y.tab.c 365 * mv y.tab.o parse.o 366 * cmp -s y.tab.h parse.h || mv y.tab.h parse.h 367 * 368 * In this case, if the definitions produced by yacc haven't 369 * changed from before, parse.h won't have been updated and 370 * cgn->mtime will reflect the current modification time for 371 * parse.h. This is something of a kludge, I admit, but it's a 372 * useful one.. 373 * XXX: People like to use a rule like 374 * 375 * FRC: 376 * 377 * To force things that depend on FRC to be made, so we have to 378 * check for gn->children being empty as well... 379 */ 380 if (!Lst_IsEmpty(&cgn->commands) || 381 Lst_IsEmpty(&cgn->children)) { 382 cgn->mtime = now; 383 } 384 #else 385 /* 386 * This is what Make does and it's actually a good thing, as it 387 * allows rules like 388 * 389 * cmp -s y.tab.h parse.h || cp y.tab.h parse.h 390 * 391 * to function as intended. Unfortunately, thanks to the 392 * stateless nature of NFS (by which I mean the loose coupling 393 * of two clients using the same file from a common server), 394 * there are times when the modification time of a file created 395 * on a remote machine will not be modified before the local 396 * stat() implied by the Dir_MTime occurs, thus leading us to 397 * believe that the file is unchanged, wreaking havoc with 398 * files that depend on this one. 399 * 400 * I have decided it is better to make too much than to make too 401 * little, so this stuff is commented out unless you're sure 402 * it's ok. 403 * -- ardeb 1/12/88 404 */ 405 /* 406 * Christos, 4/9/92: If we are saving commands pretend that 407 * the target is made now. Otherwise archives with ... rules 408 * don't work! 409 */ 410 if (noExecute || (cgn->type & OP_SAVE_CMDS) || 411 Dir_MTime(cgn) == 0) { 412 cgn->mtime = now; 413 } 414 DEBUGF(MAKE, ("update time: %s\n", Targ_FmtTime(cgn->mtime))); 415#endif 416 } 417 418 for (ln = Lst_First(&cgn->parents); ln != NULL; ln = Lst_Succ(ln)) { 419 pgn = Lst_Datum(ln); 420 if (pgn->make) { 421 pgn->unmade -= 1; 422 423 if (!(cgn->type & (OP_EXEC | OP_USE))) { 424 if (cgn->made == MADE) { 425 pgn->childMade = TRUE; 426 if (pgn->cmtime < cgn->mtime) { 427 pgn->cmtime = cgn->mtime; 428 } 429 } else { 430 Make_TimeStamp(pgn, cgn); 431 } 432 } 433 if (pgn->unmade == 0) { 434 /* 435 * Queue the node up -- any unmade predecessors 436 * will be dealt with in MakeStartJobs. 437 */ 438 Lst_EnQueue(&toBeMade, pgn); 439 } else if (pgn->unmade < 0) { 440 Error("Graph cycles through %s", pgn->name); 441 } 442 } 443 } 444 445 /* 446 * Deal with successor nodes. If any is marked for making and has an 447 * unmade count of 0, has not been made and isn't in the examination 448 * queue, it means we need to place it in the queue as it restrained 449 * itself before. 450 */ 451 for (ln = Lst_First(&cgn->successors); ln != NULL; ln = Lst_Succ(ln)) { 452 GNode *succ = Lst_Datum(ln); 453 454 if (succ->make && succ->unmade == 0 && succ->made == UNMADE && 455 Lst_Member(&toBeMade, succ) == NULL) { 456 Lst_EnQueue(&toBeMade, succ); 457 } 458 } 459 460 /* 461 * Set the .PREFIX and .IMPSRC variables for all the implied parents 462 * of this node. 463 */ 464 cpref = Var_Value(PREFIX, cgn); 465 for (ln = Lst_First(&cgn->iParents); ln != NULL; ln = Lst_Succ(ln)) { 466 pgn = Lst_Datum(ln); 467 if (pgn->make) { 468 Var_Set(IMPSRC, cname, pgn); 469 Var_Set(PREFIX, cpref, pgn); 470 } 471 } 472} 473 474/** 475 * Make_DoAllVar 476 * Set up the ALLSRC and OODATE variables. Sad to say, it must be 477 * done separately, rather than while traversing the graph. This is 478 * because Make defined OODATE to contain all sources whose modification 479 * times were later than that of the target, *not* those sources that 480 * were out-of-date. Since in both compatibility and native modes, 481 * the modification time of the parent isn't found until the child 482 * has been dealt with, we have to wait until now to fill in the 483 * variable. As for ALLSRC, the ordering is important and not 484 * guaranteed when in native mode, so it must be set here, too. 485 * 486 * Side Effects: 487 * The ALLSRC and OODATE variables of the given node is filled in. 488 * If the node is a .JOIN node, its TARGET variable will be set to 489 * match its ALLSRC variable. 490 */ 491void 492Make_DoAllVar(GNode *gn) 493{ 494 LstNode *ln; 495 GNode *cgn; 496 const char *child; 497 498 LST_FOREACH(ln, &gn->children) { 499 /* 500 * Add the child's name to the ALLSRC and OODATE variables of 501 * the given node. The child is added only if it has not been 502 * given the .EXEC, .USE or .INVISIBLE attributes. .EXEC and 503 * .USE children are very rarely going to be files, so... 504 * 505 * A child is added to the OODATE variable if its modification 506 * time is later than that of its parent, as defined by Make, 507 * except if the parent is a .JOIN node. In that case, it is 508 * only added to the OODATE variable if it was actually made 509 * (since .JOIN nodes don't have modification times, the 510 * comparison is rather unfair...). 511 */ 512 cgn = Lst_Datum(ln); 513 514 if ((cgn->type & (OP_EXEC | OP_USE | OP_INVISIBLE)) == 0) { 515 if (OP_NOP(cgn->type)) { 516 /* 517 * this node is only source; use the specific 518 * pathname for it 519 */ 520 child = cgn->path ? cgn->path : cgn->name; 521 } else 522 child = Var_Value(TARGET, cgn); 523 Var_Append(ALLSRC, child, gn); 524 if (gn->type & OP_JOIN) { 525 if (cgn->made == MADE) { 526 Var_Append(OODATE, child, gn); 527 } 528 } else if (gn->mtime < cgn->mtime || 529 (cgn->mtime >= now && cgn->made == MADE)) { 530 /* 531 * It goes in the OODATE variable if the parent 532 * is younger than the child or if the child has 533 * been modified more recently than the start of 534 * the make. This is to keep pmake from getting 535 * confused if something else updates the parent 536 * after the make starts (shouldn't happen, I 537 * know, but sometimes it does). In such a case, 538 * if we've updated the kid, the parent is 539 * likely to have a modification time later than 540 * that of the kid and anything that relies on 541 * the OODATE variable will be hosed. 542 * 543 * XXX: This will cause all made children to 544 * go in the OODATE variable, even if they're 545 * not touched, if RECHECK isn't defined, since 546 * cgn->mtime is set to now in Make_Update. 547 * According to some people, this is good... 548 */ 549 Var_Append(OODATE, child, gn); 550 } 551 } 552 } 553 554 if (!Var_Exists (OODATE, gn)) { 555 Var_Set(OODATE, "", gn); 556 } 557 if (!Var_Exists (ALLSRC, gn)) { 558 Var_Set(ALLSRC, "", gn); 559 } 560 561 if (gn->type & OP_JOIN) { 562 Var_Set(TARGET, Var_Value(ALLSRC, gn), gn); 563 } 564} 565 566/** 567 * MakeStartJobs 568 * Start as many jobs as possible. 569 * 570 * Results: 571 * If the query flag was given to pmake, no job will be started, 572 * but as soon as an out-of-date target is found, this function 573 * returns TRUE. At all other times, this function returns FALSE. 574 * 575 * Side Effects: 576 * Nodes are removed from the toBeMade queue and job table slots 577 * are filled. 578 */ 579static Boolean 580MakeStartJobs(void) 581{ 582 GNode *gn; 583 584 while (!Lst_IsEmpty(&toBeMade) && !Job_Full()) { 585 gn = Lst_DeQueue(&toBeMade); 586 DEBUGF(MAKE, ("Examining %s...", gn->name)); 587 588 /* 589 * Make sure any and all predecessors that are going to be made, 590 * have been. 591 */ 592 if (!Lst_IsEmpty(&gn->preds)) { 593 LstNode *ln; 594 595 for (ln = Lst_First(&gn->preds); ln != NULL; 596 ln = Lst_Succ(ln)){ 597 GNode *pgn = Lst_Datum(ln); 598 599 if (pgn->make && pgn->made == UNMADE) { 600 DEBUGF(MAKE, ("predecessor %s not made " 601 "yet.\n", pgn->name)); 602 break; 603 } 604 } 605 /* 606 * If ln isn't NULL, there's a predecessor as yet 607 * unmade, so we just drop this node on the floor. 608 * When the node in question has been made, it will 609 * notice this node as being ready to make but as yet 610 * unmade and will place the node on the queue. 611 */ 612 if (ln != NULL) { 613 continue; 614 } 615 } 616 617 numNodes--; 618 if (Make_OODate(gn)) { 619 DEBUGF(MAKE, ("out-of-date\n")); 620 if (queryFlag) { 621 return (TRUE); 622 } 623 Make_DoAllVar(gn); 624 Job_Make(gn); 625 } else { 626 DEBUGF(MAKE, ("up-to-date\n")); 627 gn->made = UPTODATE; 628 if (gn->type & OP_JOIN) { 629 /* 630 * Even for an up-to-date .JOIN node, we need 631 * it to have its context variables so 632 * references to it get the correct value for 633 * .TARGET when building up the context 634 * variables of its parent(s)... 635 */ 636 Make_DoAllVar(gn); 637 } 638 639 Make_Update(gn); 640 } 641 } 642 return (FALSE); 643} 644 645/** 646 * MakePrintStatus 647 * Print the status of a top-level node, viz. it being up-to-date 648 * already or not created due to an error in a lower level. 649 * Callback function for Make_Run via LST_FOREACH. If gn->unmade is 650 * nonzero and that is meant to imply a cycle in the graph, then 651 * cycle is TRUE. 652 * 653 * Side Effects: 654 * A message may be printed. 655 */ 656static void 657MakePrintStatus(GNode *gn, Boolean cycle) 658{ 659 LstNode *ln; 660 661 if (gn->made == UPTODATE) { 662 printf("`%s' is up to date.\n", gn->name); 663 664 } else if (gn->unmade != 0) { 665 if (cycle) { 666 /* 667 * If printing cycles and came to one that has unmade 668 * children, print out the cycle by recursing on its 669 * children. Note a cycle like: 670 * a : b 671 * b : c 672 * c : b 673 * will cause this to erroneously complain about a 674 * being in the cycle, but this is a good approximation. 675 */ 676 if (gn->made == CYCLE) { 677 Error("Graph cycles through `%s'", gn->name); 678 gn->made = ENDCYCLE; 679 LST_FOREACH(ln, &gn->children) 680 MakePrintStatus(Lst_Datum(ln), TRUE); 681 gn->made = UNMADE; 682 } else if (gn->made != ENDCYCLE) { 683 gn->made = CYCLE; 684 LST_FOREACH(ln, &gn->children) 685 MakePrintStatus(Lst_Datum(ln), TRUE); 686 } 687 } else { 688 printf("`%s' not remade because of errors.\n", 689 gn->name); 690 } 691 } 692} 693 694/** 695 * Make_Run 696 * Initialize the nodes to remake and the list of nodes which are 697 * ready to be made by doing a breadth-first traversal of the graph 698 * starting from the nodes in the given list. Once this traversal 699 * is finished, all the 'leaves' of the graph are in the toBeMade 700 * queue. 701 * Using this queue and the Job module, work back up the graph, 702 * calling on MakeStartJobs to keep the job table as full as 703 * possible. 704 * 705 * Results: 706 * TRUE if work was done. FALSE otherwise. 707 * 708 * Side Effects: 709 * The make field of all nodes involved in the creation of the given 710 * targets is set to 1. The toBeMade list is set to contain all the 711 * 'leaves' of these subgraphs. 712 */ 713Boolean 714Make_Run(Lst *targs) 715{ 716 GNode *gn; /* a temporary pointer */ 717 GNode *cgn; 718 Lst examine; /* List of targets to examine */ 719 int errors; /* Number of errors the Job module reports */ 720 LstNode *ln; 721 722 Lst_Init(&examine); 723 Lst_Duplicate(&examine, targs, NOCOPY); 724 numNodes = 0; 725 726 /* 727 * Make an initial downward pass over the graph, marking nodes to be 728 * made as we go down. We call Suff_FindDeps to find where a node is and 729 * to get some children for it if it has none and also has no commands. 730 * If the node is a leaf, we stick it on the toBeMade queue to 731 * be looked at in a minute, otherwise we add its children to our queue 732 * and go on about our business. 733 */ 734 while (!Lst_IsEmpty(&examine)) { 735 gn = Lst_DeQueue(&examine); 736 737 if (!gn->make) { 738 gn->make = TRUE; 739 numNodes++; 740 741 /* 742 * Apply any .USE rules before looking for implicit 743 * dependencies to make sure everything has commands 744 * that should... 745 */ 746 LST_FOREACH(ln, &gn->children) 747 if (Make_HandleUse(Lst_Datum(ln), gn)) 748 break; 749 750 Suff_FindDeps(gn); 751 752 if (gn->unmade != 0) { 753 LST_FOREACH(ln, &gn->children) { 754 cgn = Lst_Datum(ln); 755 if (!cgn->make && !(cgn->type & OP_USE)) 756 Lst_EnQueue(&examine, cgn); 757 } 758 } else { 759 Lst_EnQueue(&toBeMade, gn); 760 } 761 } 762 } 763 764 if (queryFlag) { 765 /* 766 * We wouldn't do any work unless we could start some jobs in 767 * the next loop... (we won't actually start any, of course, 768 * this is just to see if any of the targets was out of date) 769 */ 770 return (MakeStartJobs()); 771 772 } else { 773 /* 774 * Initialization. At the moment, no jobs are running and 775 * until some get started, nothing will happen since the 776 * remaining upward traversal of the graph is performed by the 777 * routines in job.c upon the finishing of a job. So we fill 778 * the Job table as much as we can before going into our loop. 779 */ 780 MakeStartJobs(); 781 } 782 783 /* 784 * Main Loop: The idea here is that the ending of jobs will take 785 * care of the maintenance of data structures and the waiting for output 786 * will cause us to be idle most of the time while our children run as 787 * much as possible. Because the job table is kept as full as possible, 788 * the only time when it will be empty is when all the jobs which need 789 * running have been run, so that is the end condition of this loop. 790 * Note that the Job module will exit if there were any errors unless 791 * the keepgoing flag was given. 792 */ 793 while (!Job_Empty()) { 794 Job_CatchOutput(!Lst_IsEmpty(&toBeMade)); 795 Job_CatchChildren(!usePipes); 796 MakeStartJobs(); 797 } 798 799 errors = Job_Finish(); 800 801 /* 802 * Print the final status of each target. E.g. if it wasn't made 803 * because some inferior reported an error. 804 */ 805 errors = ((errors == 0) && (numNodes != 0)); 806 LST_FOREACH(ln, targs) 807 MakePrintStatus(Lst_Datum(ln), errors); 808 809 return (TRUE); 810} 811