gn->make = TRUE;
gn->make = true;
Make_Run(targs)    Lst 	    targs;	/* the initial list of targets */{    GNode	    *gn;	/* a temporary pointer */    LIST	    examine;	/* List of targets to examine */    int 	    errors;	/* Number of errors the Job module reports */    Lst_Init(&toBeMade);    Lst_Clone(&examine, 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, gn);	    Suff_FindDeps(gn);	    if (gn->unmade != 0) {		Lst_ForEach(&gn->children, MakeAddChild, &examine);	    } else {		Lst_EnQueue(&toBeMade, gn);	    }	}    }    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, &errors);    return TRUE;}