Lst_ForEach (gn->children, CompatMake, (ClientData)gn);
Lst_ForEach(gn->children, CompatMake, gn);
CompatMake (gnp, pgnp)    ClientData	gnp;	    /* The node to make */    ClientData  pgnp;	    /* Parent to abort if necessary */{    GNode *gn = (GNode *) gnp;    GNode *pgn = (GNode *) pgnp;    if (pgn->type & OP_MADE) {	(void) Dir_MTime(gn);	gn->made = UPTODATE;    }    if (gn->type & OP_USE) {	Make_HandleUse(gn, pgn);    } else if (gn->made == UNMADE) {	/*	 * 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 'make' field will be set FALSE again.	 * This is our signal to not attempt to do anything but abort our	 * parent as well.	 */	gn->make = TRUE;	gn->made = BEINGMADE;	Suff_FindDeps (gn);	Lst_ForEach (gn->children, CompatMake, (ClientData)gn);	if (!gn->make) {	    gn->made = ABORTED;	    pgn->make = FALSE;	    return (0);	}	if (Lst_Member (gn->iParents, pgn) != NULL) {	    Var_Set(IMPSRC, Var_Value(TARGET, gn), pgn);	}	/*	 * All the children were made ok. Now cmtime contains the modification	 * time of 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->made = UPTODATE;	    if (DEBUG(MAKE)) {		printf("up-to-date.\n");	    }	    return (0);	} 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);	}	/*	 * 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(gn);	/*	 * Alter our type to tell if errors should be ignored or things	 * should not be printed so CompatRunCommand knows what to do.	 */	if (Targ_Ignore (gn)) {	    gn->type |= OP_IGNORE;	}	if (Targ_Silent (gn)) {	    gn->type |= OP_SILENT;	}	if (Job_CheckCommands (gn, Fatal)) {	    /*	     * Our commands are ok, but we still have to worry about the -t	     * flag...	     */	    if (!touchFlag) {		curTarg = gn;		Lst_ForEach (gn->commands, CompatRunCommand, (ClientData)gn);		curTarg = NULL;	    } else {		Job_Touch (gn, gn->type & OP_SILENT);	    }	} else {	    gn->made = ERROR;	}	if (gn->made != ERROR) {	    /*	     * If the node was made successfully, mark it so, update	     * its modification time and timestamp all its parents. Note	     * that for .ZEROTIME targets, the timestamping isn't done.	     * This is to keep its state from affecting that of its parent.	     */	    gn->made = MADE;#ifndef RECHECK	    /*	     * We can't re-stat the thing, but we can at least take care of	     * rules where a target depends on a source that actually creates	     * the target, but only if it has changed, e.g.	     *	     * parse.h : parse.o	     *	     * parse.o : parse.y	     *  	yacc -d parse.y	     *  	cc -c y.tab.c	     *  	mv y.tab.o parse.o	     *  	cmp -s y.tab.h parse.h || mv y.tab.h parse.h	     *	     * In this case, if the definitions produced by yacc haven't	     * changed from before, parse.h won't have been updated and	     * gn->mtime will reflect the current modification time for	     * parse.h. This is something of a kludge, I admit, but it's a	     * useful one..	     *	     * XXX: People like to use a rule like	     *	     * FRC:	     *	     * To force things that depend on FRC to be made, so we have to	     * check for gn->children being empty as well...	     */	    if (!Lst_IsEmpty(gn->commands) || Lst_IsEmpty(gn->children)) {		gn->mtime = now;	    }#else	    /*	     * 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.	     *	     * I have decided it is better to make too much than to make too	     * little, so this stuff is commented out unless you're sure it's	     * ok.	     * -- ardeb 1/12/88	     */	    if (noExecute || Dir_MTime(gn) == FALSE) {		gn->mtime = now;	    }	    if (gn->cmtime > gn->mtime)		gn->mtime = gn->cmtime;	    if (DEBUG(MAKE)) {		printf("update time: %s\n", Targ_FmtTime(gn->mtime));	    }#endif	    if (!(gn->type & OP_EXEC)) {		pgn->childMade = TRUE;		Make_TimeStamp(pgn, gn);	    }	} else if (keepgoing) {	    pgn->make = FALSE;	} else {	    printf ("\n\nStop in %s.\n", Var_Value(".CURDIR", gn));	    exit (1);	}    } else if (gn->made == ERROR) {	/*	 * Already had an error when making this beastie. Tell the parent	 * to abort.	 */	pgn->make = FALSE;    } else {	if (Lst_Member (gn->iParents, pgn) != NULL)	    Var_Set (IMPSRC, Var_Value(TARGET, gn), pgn);	switch(gn->made) {	    case BEINGMADE:		Error("Graph cycles through %s\n", gn->name);		gn->made = ERROR;		pgn->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;	}    }    return (0);}