headers(t);
headers(target_to_rescan);
make1c( state *pState ){	CMD	*cmd = (CMD *)pState->t->cmds;	/* If there are (more) commands to run to build this target */	/* (and we haven't hit an error running earlier comands) we */	/* launch the command with execcmd(). */		/* If there are no more commands to run, we collect the status */	/* from all the actions then report our completion to all the */	/* parents. */	if( cmd && pState->t->status == EXEC_CMD_OK )	{		if( DEBUG_MAKEQ ||             ! ( cmd->rule->actions->flags & RULE_QUIETLY ) && DEBUG_MAKE)	    {		printf( "%s ", cmd->rule->name );		list_print( lol_get( &cmd->args, 0 ) );		printf( "\n" );	    }	    if( DEBUG_EXEC )		printf( "%s\n", cmd->buf );	    if( globs.cmdout )		fprintf( globs.cmdout, "%s", cmd->buf );	    if( globs.noexec )	    {			pState->curstate = T_STATE_MAKE1D;			pState->status = EXEC_CMD_OK;	    } 	    else	    {			TARGET *t = pState->t;			fflush( stdout );			pop_state(&state_stack); /* pop state first because execcmd could push state */			execcmd( cmd->buf, make_closure, t, cmd->shell );	    }	}	else	{	    TARGETS	*c;	    ACTIONS	*actions;	    /* Collect status from actions, and distribute it as well */	    for( actions = pState->t->actions; actions; actions = actions->next )		if( actions->action->status > pState->t->status )		    pState->t->status = actions->action->status;	    for( actions = pState->t->actions; actions; actions = actions->next )		if( pState->t->status > actions->action->status )		    actions->action->status = pState->t->status;	    /* Tally success/failure for those we tried to update. */	    if( pState->t->progress == T_MAKE_RUNNING )		switch( pState->t->status )	    {	    case EXEC_CMD_OK:		++counts->made;		break;	    case EXEC_CMD_FAIL:		++counts->failed;		break;	    }	    /* Tell parents dependent has been built */		{			stack temp_stack = { NULL };			TARGET *t = pState->t;                        TARGET* additional_includes = NULL;			t->progress = T_MAKE_DONE;            /* Target was updated. Rescan dependencies. */            if (t->fate >= T_FATE_MISSING &&                t->status == EXEC_CMD_OK &&                !t->rescanned) {                SETTINGS *s;                               t->rescanned = 1;                if (t->flags & T_FLAG_INTERNAL) {                    t = t->original_target;                                    }                /* Clean current includes */                if (t->includes) {                    t->includes = 0;                }                s = copysettings( t->settings );                pushsettings( s );                headers(t);                popsettings( s );                freesettings( s );                if (t->includes) {                    t->includes->rescanned = 1;                    /* Tricky. The parents were already processed, but they                       did not seen the internal node, because it was just                        created. We need to make the calls to make1a that would                       have been done by parents here, and also make sure all                       unprocessed parents will pick up the includes. We must                       make sure processing of the additional make1a invocations                       is done before make1b which means this target is built,                       otherwise the parent will be considered built before this                       make1a processing is even started.                    */                    make0(t->includes, t->parents->target, 0, 0, 0);                    for( c = t->parents; c; c = c->next) {                        c->target->depends = targetentry( c->target->depends,                                                           t->includes );                    }                    /* Will be processed below. */                    additional_includes = t->includes;                }                            }            if (additional_includes)                for ( c = t->parents; c; c = c->next ) {                                                push_state(&temp_stack, additional_includes, c->target, T_STATE_MAKE1A);                                    }			for( c = t->parents; c; c = c->next ) {				push_state(&temp_stack, c->target, NULL, T_STATE_MAKE1B);            }             #ifdef OPT_SEMAPHORE	    /* If there is a semaphore, its now free */	    if( t->semaphore )	    {		assert( t->semaphore->asynccnt == 1 );		--(t->semaphore->asynccnt);		if( DEBUG_EXECCMD )		    printf( "SEM: %s is now free\n", t->semaphore->name);		/* If anything is waiting, notify the next target. There's no            point in notifying all waiting targets, since they'll be            serialized again. */		if( t->semaphore->parents )		{		    TARGETS *first = t->semaphore->parents;		    if( first->next )			first->next->tail = first->tail;		    t->semaphore->parents = first->next;		    if( DEBUG_EXECCMD )			printf( "SEM: placing %s on stack\n", first->target->name);            push_state(&temp_stack, first->target, NULL, T_STATE_MAKE1B);		    free( first );		}	    }#endif					/* must pop state before pushing any more */			pop_state(&state_stack);					/* using stacks reverses the order of execution. Reverse it back */			push_stack_on_stack(&state_stack, &temp_stack);		}	}}