/*- *----------------------------------------------------------------------- * MakeHandleUse -- * Callback function for Lst_ForEach, used by Make_Run on the downward * pass to handle .USE nodes. Should be called before the children * are enqueued to be looked at by MakeAddChild. * This function calls Make_HandleUse to copy the .USE node's commands, * type flags and children to the parent node. * * Input: * cgnp the child we've just examined * pgnp the current parent * * Results: * returns 0. * * Side Effects: * After expansion, .USE child nodes are removed from the parent * *----------------------------------------------------------------------- */ static int MakeHandleUse(void *cgnp, void *pgnp) { GNode *cgn = (GNode *)cgnp; GNode *pgn = (GNode *)pgnp; LstNode ln; /* An element in the children list */ int unmarked; unmarked = ((cgn->type & OP_MARK) == 0); cgn->type |= OP_MARK; if ((cgn->type & (OP_USE|OP_USEBEFORE)) == 0) return (0); if (unmarked) Make_HandleUse(cgn, pgn); /* * This child node is now "made", so we decrement the count of * unmade children in the parent... We also remove the child * from the parent's list to accurately reflect the number of decent * children the parent has. This is used by Make_Run to decide * whether to queue the parent or examine its children... */ if ((ln = Lst_Member(pgn->children, cgn)) != NULL) { Lst_Remove(pgn->children, ln); pgn->unmade--; } return (0); }
static void MakeHandleUse(void *cgnp, void *pgnp) { GNode *cgn = (GNode *)cgnp; GNode *pgn = (GNode *)pgnp; if (cgn->type & OP_USE) Make_HandleUse(cgn, pgn); }
bool Job_CheckCommands(GNode *gn) { /* Alter our type to tell if errors should be ignored or things * should not be printed so setup_and_run_command knows what to do. */ if (Targ_Ignore(gn)) gn->type |= OP_IGNORE; if (Targ_Silent(gn)) gn->type |= OP_SILENT; if (OP_NOP(gn->type) && Lst_IsEmpty(&gn->commands) && (gn->type & OP_LIB) == 0) { /* * No commands. Look for .DEFAULT rule from which we might infer * commands */ if ((gn->type & OP_NODEFAULT) == 0 && (DEFAULT->type & OP_DUMMY) == 0 && !Lst_IsEmpty(&DEFAULT->commands)) { /* * Make only looks for a .DEFAULT if the node was never * the target of an operator, so that's what we do too. * If a .DEFAULT was given, we substitute its commands * for gn's commands and set the IMPSRC variable to be * the target's name The DEFAULT node acts like a * transformation rule, in that gn also inherits any * attributes or sources attached to .DEFAULT itself. */ Make_HandleUse(DEFAULT, gn); Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn); } else if (is_out_of_date(Dir_MTime(gn))) { /* * The node wasn't the target of an operator we have no * .DEFAULT rule to go on and the target doesn't * already exist. There's nothing more we can do for * this branch. */ return false; } } return true; }
/*- *----------------------------------------------------------------------- * CompatMake -- * Make a target. * * Side Effects: * If an error is detected and not being ignored, the process exits. *----------------------------------------------------------------------- */ static void CompatMake(void *gnp, /* The node to make */ void *pgnp) /* Parent to abort if necessary */ { GNode *gn = (GNode *)gnp; GNode *pgn = (GNode *)pgnp; GNode *sib; bool cmdsOk; if (DEBUG(MAKE)) printf("CompatMake(%s, %s)\n", pgn ? pgn->name : "NULL", gn->name); /* XXX some loops are not loops, people write dependencies * between siblings to make sure they get built. * Also, we don't recognize direct loops. */ if (gn == pgn) return; /* handle .USE right away */ if (gn->type & OP_USE) { Make_HandleUse(gn, pgn); return; } look_harder_for_target(gn); if (pgn != NULL && is_sibling(gn, pgn)) return; if (pgn == NULL) pgn = gn; if (pgn->type & OP_MADE) { sib = gn; do { sib->mtime = gn->mtime; sib->built_status = UPTODATE; sib = sib->sibling; } while (sib != gn); } switch(gn->built_status) { case UNKNOWN: /* First mark ourselves to be made, then apply whatever * transformations the suffix module thinks are necessary. * Once that's done, we can descend and make all our children. * If any of them has an error but the -k flag was given, * our 'must_make' field will be set false again. This is our * signal to not attempt to do anything but abort our * parent as well. */ gn->must_make = true; gn->built_status = BEINGMADE; /* note that, in case we have siblings, we only check all * children for all siblings, but we don't try to apply * any other rule. */ sib = gn; do { Suff_FindDeps(sib); Lst_ForEach(&sib->children, CompatMake, gn); sib = sib->sibling; } while (sib != gn); if (!gn->must_make) { Error("Build for %s aborted", gn->name); gn->built_status = ABORTED; pgn->must_make = false; return; } /* All the children were made ok. Now youngest points to * the newest child, we need to find out * if we exist and when we were modified last. The criteria * for datedness are defined by the Make_OODate function. */ if (DEBUG(MAKE)) printf("Examining %s...", gn->name); if (!Make_OODate(gn)) { gn->built_status = UPTODATE; if (DEBUG(MAKE)) printf("up-to-date.\n"); return; } else if (DEBUG(MAKE)) printf("out-of-date.\n"); /* If the user is just seeing if something is out-of-date, * exit now to tell him/her "yes". */ if (queryFlag) exit(1); /* normally, we run the job, but if we can't find any * commands, we defer to siblings instead. */ sib = gn; do { /* We need to be re-made. We also have to make sure * we've got a $? variable. To be nice, we also define * the $> variable using Make_DoAllVar(). */ Make_DoAllVar(sib); cmdsOk = node_find_valid_commands(sib); if (cmdsOk || (gn->type & OP_OPTIONAL)) break; sib = sib->sibling; } while (sib != gn); if (cmdsOk) { /* Our commands are ok, but we still have to worry * about the -t flag... */ if (!touchFlag) run_gnode(sib); else { Job_Touch(sib); if (gn != sib) Job_Touch(gn); } } else { node_failure(gn); sib->built_status = ERROR; } /* copy over what we just did */ gn->built_status = sib->built_status; if (gn->built_status != ERROR) { /* If the node was made successfully, mark it so, * update its modification time and timestamp all * its parents. * This is to keep its state from affecting that of * its parent. */ gn->built_status = MADE; sib->built_status = MADE; /* This is what Make does and it's actually a good * thing, as it allows rules like * * cmp -s y.tab.h parse.h || cp y.tab.h parse.h * * to function as intended. Unfortunately, thanks to * the stateless nature of NFS (and the speed of * this program), there are times when the * modification time of a file created on a remote * machine will not be modified before the stat() * implied by the Dir_MTime occurs, thus leading us * to believe that the file is unchanged, wreaking * havoc with files that depend on this one. */ if (noExecute || is_out_of_date(Dir_MTime(gn))) clock_gettime(CLOCK_REALTIME, &gn->mtime); if (is_strictly_before(gn->mtime, gn->youngest->mtime)) gn->mtime = gn->youngest->mtime; if (sib != gn) { if (noExecute || is_out_of_date(Dir_MTime(sib))) clock_gettime(CLOCK_REALTIME, &sib->mtime); if (is_strictly_before(sib->mtime, sib->youngest->mtime)) sib->mtime = sib->youngest->mtime; } if (DEBUG(MAKE)) printf("update time: %s\n", time_to_string(&gn->mtime)); if (!(gn->type & OP_EXEC)) { pgn->childMade = true; Make_TimeStamp(pgn, gn); } } else if (keepgoing) pgn->must_make = false; else { print_errors(); exit(1); } break; case ERROR: /* Already had an error when making this beastie. Tell the * parent to abort. */ pgn->must_make = false; break; case BEINGMADE: Error("Graph cycles through %s", gn->name); gn->built_status = ERROR; pgn->must_make = false; break; case MADE: if ((gn->type & OP_EXEC) == 0) { pgn->childMade = true; Make_TimeStamp(pgn, gn); } break; case UPTODATE: if ((gn->type & OP_EXEC) == 0) Make_TimeStamp(pgn, gn); break; default: break; } }