Lst_ForEach (gn->children, MakeHandleUse, (ClientData)gn);
Lst_ForEach (gn->children, MakeHandleUse, gn);
Make_Run (targs)    Lst             targs;	/* the initial list of targets */{    register GNode  *gn;	/* a temporary pointer */    register Lst    examine; 	/* List of targets to examine */    int	    	    errors; 	/* Number of errors the Job module reports */    toBeMade = Lst_Init();    examine = Lst_Duplicate(targs, NOCOPY);    numNodes = 0;    /*     * Make an initial downward pass over the graph, marking nodes to be made     * as we go down. We call Suff_FindDeps to find where a node is and     * to get some children for it if it has none and also has no commands.     * If the node is a leaf, we stick it on the toBeMade queue to     * be looked at in a minute, otherwise we add its children to our queue     * and go on about our business.     */    while ((gn = (GNode *)Lst_DeQueue(examine)) != NULL) {	if (!gn->make) {	    gn->make = TRUE;	    numNodes++;	    /*	     * Apply any .USE rules before looking for implicit dependencies	     * to make sure everything has commands that should...	     */	    Lst_ForEach (gn->children, MakeHandleUse, (ClientData)gn);	    Suff_FindDeps (gn);	    if (gn->unmade != 0) {		Lst_ForEach (gn->children, MakeAddChild, (ClientData)examine);	    } else {		Lst_EnQueue(toBeMade, (ClientData)gn);	    }	}    }    Lst_Destroy (examine, NOFREE);    if (queryFlag) {	/*	 * We wouldn't do any work unless we could start some jobs in the	 * next loop... (we won't actually start any, of course, this is just	 * to see if any of the targets was out of date)	 */	return (MakeStartJobs());    } else {	/*	 * Initialization. At the moment, no jobs are running and until some	 * get started, nothing will happen since the remaining upward	 * traversal of the graph is performed by the routines in job.c upon	 * the finishing of a job. So we fill the Job table as much as we can	 * before going into our loop.	 */	(void) MakeStartJobs();    }    /*     * Main Loop: The idea here is that the ending of jobs will take     * care of the maintenance of data structures and the waiting for output     * will cause us to be idle most of the time while our children run as     * much as possible. Because the job table is kept as full as possible,     * the only time when it will be empty is when all the jobs which need     * running have been run, so that is the end condition of this loop.     * Note that the Job module will exit if there were any errors unless the     * keepgoing flag was given.     */    while (!Job_Empty ()) {	Job_CatchOutput ();	Job_CatchChildren (!usePipes);	(void)MakeStartJobs();    }    errors = Job_Finish();    /*     * Print the final status of each target. E.g. if it wasn't made     * because some inferior reported an error.     */    errors = ((errors == 0) && (numNodes != 0));    Lst_ForEach(targs, MakePrintStatus, (ClientData) &errors);    return (TRUE);}