oodate = TRUE;
oodate = true;
Make_OODate(gn)    GNode	    *gn;	      /* the node to check */{    Boolean	    oodate;    /*     * Certain types of targets needn't even be sought as their datedness     * doesn't depend on their modification time...     */    if ((gn->type & (OP_JOIN|OP_USE|OP_EXEC)) == 0) {	(void)Dir_MTime(gn);	if (DEBUG(MAKE)) {	    if (!is_out_of_date(gn->mtime)) {		printf("modified %s...", Targ_FmtTime(gn->mtime));	    } else {		printf("non-existent...");	    }	}    }    /*     * A target is remade in one of the following circumstances:     *	its modification time is smaller than that of its youngest child     *	    and it would actually be run (has commands or type OP_NOP)     *	it's the object of a force operator     *	it has no children, was on the lhs of an operator and doesn't exist     *	    already.     *     * Libraries are only considered out-of-date if the archive module says     * they are.     *     * These weird rules are brought to you by Backward-Compatability and     * the strange people who wrote 'Make'.     */    if (gn->type & OP_USE) {	/*	 * If the node is a USE node it is *never* out of date	 * no matter *what*.	 */	if (DEBUG(MAKE)) {	    printf(".USE node...");	}	oodate = FALSE;    } else if ((gn->type & OP_LIB) && Arch_IsLib(gn)) {	if (DEBUG(MAKE)) {	    printf("library...");	}	/*	 * always out of date if no children and :: target	 */	oodate = Arch_LibOODate(gn) ||	    (is_out_of_date(gn->cmtime) && (gn->type & OP_DOUBLEDEP));    } else if (gn->type & OP_JOIN) {	/*	 * A target with the .JOIN attribute is only considered	 * out-of-date if any of its children was out-of-date.	 */	if (DEBUG(MAKE)) {	    printf(".JOIN node...");	}	oodate = gn->childMade;    } else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) {	/*	 * A node which is the object of the force (!) operator or which has	 * the .EXEC attribute is always considered out-of-date.	 */	if (DEBUG(MAKE)) {	    if (gn->type & OP_FORCE) {		printf("! operator...");	    } else if (gn->type & OP_PHONY) {		printf(".PHONY node...");	    } else {		printf(".EXEC node...");	    }	}	oodate = TRUE;    } else if (is_before(gn->mtime, gn->cmtime) ||	       (is_out_of_date(gn->cmtime) &&		(is_out_of_date(gn->mtime) || (gn->type & OP_DOUBLEDEP))))    {	/*	 * A node whose modification time is less than that of its	 * youngest child or that has no children (cmtime == OUT_OF_DATE) and	 * either doesn't exist (mtime == OUT_OF_DATE) or was the object of a	 * :: operator is out-of-date. Why? Because that's the way Make does	 * it.	 */	if (DEBUG(MAKE)) {	    if (is_before(gn->mtime, gn->cmtime)) {		printf("modified before source...");	    } else if (is_out_of_date(gn->mtime)) {		printf("non-existent and no sources...");	    } else {		printf(":: operator and no sources...");	    }	}	oodate = TRUE;    } else {#if 0	/* WHY? */	if (DEBUG(MAKE)) {	    printf("source %smade...", gn->childMade ? "" : "not ");	}	oodate = gn->childMade;#else	oodate = FALSE;#endif /* 0 */    }    /*     * If the target isn't out-of-date, the parents need to know its     * modification time. Note that targets that appear to be out-of-date     * but aren't, because they have no commands and aren't of type OP_NOP,     * have their mtime stay below their children's mtime to keep parents from     * thinking they're out-of-date.     */    if (!oodate)	Lst_ForEach(&gn->parents, MakeTimeStamp, gn);    return oodate;}