static SETTINGS *
make1settings( LIST *vars )
{
SETTINGS *settings = 0;
for( ; vars; vars = list_next( vars ) )
{
LIST *l = var_get( vars->string );
LIST *nl = 0;
for( ; l; l = list_next( l ) )
{
TARGET *t = bindtarget( l->string );
/* Make sure the target is bound */
if( t->binding == T_BIND_UNBOUND )
make1bind( t );
/* Build new list */
nl = list_new( nl, copystr( t->boundname ) );
}
/* Add to settings chain */
settings = addsettings( settings, 0, vars->string, nl );
}
return settings;
}
static SETTINGS *
make1settings( LIST *vars )
{
SETTINGS *settings = 0;
for( ; vars; vars = list_next( vars ) )
{
LIST *l = var_get( vars->string );
LIST *nl = 0;
for( ; l; l = list_next( l ) )
{
TARGET *t = bindtarget( l->string );
/* Make sure the target is bound, warning if it is not in the */
/* dependency graph. */
if( t->binding == T_BIND_UNBOUND )
make1bind( t, 1 );
/* Build new list */
nl = list_new( nl, t->boundname, 1 );
}
/* Add to settings chain */
settings = addsettings( settings, 0, vars->string, nl );
}
return settings;
}
static SETTINGS * make1settings( struct module_t * module, LIST * vars )
{
SETTINGS * settings = 0;
LISTITER vars_iter = list_begin( vars );
LISTITER const vars_end = list_end( vars );
for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter ) )
{
LIST * const l = var_get( module, list_item( vars_iter ) );
LIST * nl = L0;
LISTITER iter = list_begin( l );
LISTITER const end = list_end( l );
for ( ; iter != end; iter = list_next( iter ) )
{
TARGET * const t = bindtarget( list_item( iter ) );
/* Make sure the target is bound. */
if ( t->binding == T_BIND_UNBOUND )
make1bind( t );
/* Build a new list. */
nl = list_push_back( nl, object_copy( t->boundname ) );
}
/* Add to settings chain. */
settings = addsettings( settings, VAR_SET, list_item( vars_iter ), nl );
}
return settings;
}
static void
make1list_batched(
LIST**plt,
LIST**pls,
TARGETS *targets,
TARGETS *sources,
int flags )
{
/* walk sources and targets simultaneously */
for( ; targets; targets = targets->next, sources = (sources==NULL?sources:sources->next) )
{
TARGET *t = targets->target;
TARGET *s = sources!=NULL ? sources->target : NULL;
/* Sources to 'actions existing' are never in the dependency */
/* graph (if they were, they'd get built and 'existing' would */
/* be superfluous, so throttle warning message about independent */
/* targets. */
if( t->binding == T_BIND_UNBOUND )
make1bind( t, 0 );
if( s!=NULL) {
if ( s->binding == T_BIND_UNBOUND )
make1bind( s, !( flags & RULE_EXISTING ) );
if ( s->binding == T_BIND_UNBOUND )
printf("Warning using unbound source %s for batched action.\n", s->name);
}
if( ( flags & RULE_EXISTING ) && s!=NULL && s->binding != T_BIND_EXISTS )
continue;
if( t->fate < T_FATE_BUILD )
continue;
/* Build new lists */
*plt = list_new( *plt, t->boundname, 1 );
if (s!=NULL) {
*pls = list_new( *pls, s->boundname, 1 );
}
}
if (sources!=NULL) {
printf("warning: more sources than targets in a batched action!\n");
}
}
static LIST *
make1list(
LIST *l,
TARGETS *targets,
int flags )
{
for( ; targets; targets = targets->next )
{
TARGET *t = targets->target;
/* Sources to 'actions existing' are never in the dependency */
/* graph (if they were, they'd get built and 'existing' would */
/* be superfluous, so throttle warning message about independent */
/* targets. */
if( t->binding == T_BIND_UNBOUND )
make1bind( t, !( flags & RULE_EXISTING ) );
if( ( flags & RULE_EXISTING ) && t->binding != T_BIND_EXISTS )
continue;
#ifdef OPT_BUILTIN_MD5CACHE_EXT
if( ( flags & RULE_UPDATED ) && t->fate <= T_FATE_STABLE && !targets->parentcommandlineoutofdate )
#else
if( ( flags & RULE_UPDATED ) && t->fate <= T_FATE_STABLE )
#endif
continue;
/* Prohibit duplicates for RULE_TOGETHER */
if( flags & RULE_TOGETHER )
{
LIST *m;
for( m = l; m; m = m->next )
if( !strcmp( m->string, t->boundname ) )
break;
if( m )
continue;
}
/* Build new list */
l = list_new( l, t->boundname, 1 );
}
return l;
}
static LIST *
make1list(
LIST *l,
TARGETS *targets,
int flags )
{
for( ; targets; targets = targets->next )
{
TARGET *t = targets->target;
if( t->binding == T_BIND_UNBOUND )
make1bind( t );
if ( ( flags & RULE_EXISTING ) && ( flags & RULE_NEWSRCS ) )
{
if ( t->binding != T_BIND_EXISTS && t->fate <= T_FATE_STABLE)
continue;
}
else
{
if( ( flags & RULE_EXISTING ) && t->binding != T_BIND_EXISTS )
continue;
if( ( flags & RULE_NEWSRCS ) && t->fate <= T_FATE_STABLE )
continue;
}
/* Prohibit duplicates for RULE_TOGETHER */
if( flags & RULE_TOGETHER )
{
LIST *m;
for( m = l; m; m = m->next )
if( !strcmp( m->string, t->boundname ) )
break;
if( m )
continue;
}
/* Build new list */
l = list_new( l, copystr( t->boundname ) );
}
return l;
}
static LIST * make1list( LIST * l, TARGETS * targets, int flags )
{
for ( ; targets; targets = targets->next )
{
TARGET * t = targets->target;
if ( t->binding == T_BIND_UNBOUND )
make1bind( t );
if ( ( flags & RULE_EXISTING ) && ( flags & RULE_NEWSRCS ) )
{
if ( ( t->binding != T_BIND_EXISTS ) &&
( t->fate <= T_FATE_STABLE ) )
continue;
}
else if ( flags & RULE_EXISTING )
{
if ( t->binding != T_BIND_EXISTS )
continue;
}
else if ( flags & RULE_NEWSRCS )
{
if ( t->fate <= T_FATE_STABLE )
continue;
}
/* Prohibit duplicates for RULE_TOGETHER. */
if ( flags & RULE_TOGETHER )
{
LISTITER iter = list_begin( l );
LISTITER const end = list_end( l );
for ( ; iter != end; iter = list_next( iter ) )
if ( object_equal( list_item( iter ), t->boundname ) )
break;
if ( iter != end )
continue;
}
/* Build new list. */
l = list_push_back( l, object_copy( t->boundname ) );
}
return l;
}
static CMD *
make1cmds( ACTIONS *a0 )
#endif
{
CMD *cmds = 0;
LIST *shell = var_get( "JAMSHELL" ); /* shell is per-target */
/* Step through actions */
/* Actions may be shared with other targets or grouped with */
/* RULE_TOGETHER, so actions already seen are skipped. */
for( ; a0; a0 = a0->next )
{
RULE *rule = a0->action->rule;
SETTINGS *boundvars;
LIST *nt, *ns;
ACTIONS *a1;
int start, chunk, length, maxline;
TARGETS *autosettingsreverse = 0;
TARGETS *autot;
#ifdef OPT_MULTIPASS_EXT
if ( a0->action->pass != actionpass )
continue;
#endif
/* Only do rules with commands to execute. */
/* If this action has already been executed, use saved status */
#ifdef OPT_DEBUG_MAKE1_LOG_EXT
if (DEBUG_MAKE1) {
printf( "make1cmds\t--\t%s (actions %s, running %s)\n" ,
rule->name,
rule->actions ? "yes" : "no",
a0->action->running ? "yes" : "no" );
}
#endif
if( !rule->actions || a0->action->running )
continue;
#ifdef OPT_REMOVE_EMPTY_DIRS_EXT
if ( rule->flags & RULE_REMOVEEMPTYDIRS ) {
for( a1 = a0; a1; a1 = a1->next ) {
TARGETS* sources;
for ( sources = a1->action->sources; sources; sources = sources->next ) {
emptydirtargets = list_new( emptydirtargets, sources->target->name, 1 );
}
}
}
#endif
for ( autot = a0->action->autosettings; autot; autot = autot->next ) {
if ( autot->target != t )
pushsettings( autot->target->settings );
autosettingsreverse = targetentryhead( autosettingsreverse, autot->target, 0 );
}
pushsettings( t->settings );
a0->action->running = 1;
#ifdef OPT_ACTIONS_WAIT_FIX
a0->action->run_tgt = t;
#endif
/* Make LISTS of targets and sources */
/* If `execute together` has been specified for this rule, tack */
/* on sources from each instance of this rule for this target. */
#ifdef OPT_DEBUG_MAKE1_LOG_EXT
if (DEBUG_MAKE1) {
LIST *list = make1list(L0, a0->action->targets, 0);
printf("make1cmds\t--\ttargets: ");
list_print(list);
list_free(list);
printf("\n");
list = make1list(L0, a0->action->sources, 0);
printf("make1cmds\t--\tsources: ");
list_print(list);
list_free(list);
printf("\n");
}
#endif
#ifdef OPT_BUILTIN_MD5CACHE_EXT
if (t->filecache_generate || t->filecache_use)
{
LIST* targets = make1list_unbound( L0, a0->action->targets, 0 );
LIST* sources = make1list_unbound( L0, a0->action->sources, rule->flags );
nt = L0;
ns = L0;
if ( strncmp( rule->name, "batched_", 8 ) == 0 )
{
int anycacheable = 0;
for( ; targets; targets = targets->next, sources = ( sources == NULL ? sources : sources->next ) )
{
TARGET *t = bindtarget(targets->string);
TARGET *s = sources!=NULL ? bindtarget(sources->string) : NULL;
/* if this target could be cacheable */
if ( (t->flags & T_FLAG_USEFILECACHE) && (t->filecache_generate || t->filecache_use) ) {
/* find its final md5sum */
MD5_CTX context;
MD5SUM buildsumorg;
anycacheable = 1;
memcpy(&buildsumorg, &t->buildmd5sum, sizeof(t->buildmd5sum));
MD5Init( &context );
MD5Update( &context, t->buildmd5sum, sizeof( t->buildmd5sum ) );
{
TARGET *outt = bindtarget( t->boundname );
outt->flags |= T_FLAG_USEFILECACHE;
MD5Final( outt->buildmd5sum, &context );
memcpy(&t->buildmd5sum, &outt->buildmd5sum, sizeof(t->buildmd5sum));
}
if (DEBUG_MD5HASH) {
printf( "Cacheable: %s buildmd5: %s org: %s\n",
t->boundname, md5tostring(t->buildmd5sum), md5tostring(buildsumorg) );
}
/* if using cache is allowed */
if (t->filecache_use) {
const char *cachedname;
/* if the target is available in the cache */
cachedname = filecache_getfilename(t, t->buildmd5sum, ".doesntwork");
if (cachedname!=NULL) {
time_t cachedtime;
if ( file_time( cachedname, &cachedtime ) == 0 )
{
/* try to get it from the cache */
if (copyfile(t->boundname, cachedname, NULL)) {
printf( "Using cached %s\n", t->name );
continue;
} else {
printf( "Cannot retrieve %s from cache (will build normally)\n", t->name );
}
} else {
if( DEBUG_MD5HASH) {
printf( "Cannot find %s in cache as %s\n", t->name, cachedname );
}
}
}
}
/* Build new lists */
nt = list_new( nt, t->boundname, 1 );
if (s)
ns = list_new( ns, s->boundname, 1 );
}
}
if ( !anycacheable ) {
nt = make1list( L0, a0->action->targets, 0 );
ns = make1list( L0, a0->action->sources, rule->flags );
}
}
else
{
int allcached = 1;
popsettings( t->settings );
for( ; targets; targets = list_next(targets) )
{
TARGET *t = bindtarget(targets->string);
// TARGET *s = sources!=NULL ? bindtarget(sources->string) : NULL;
TARGETS *c;
TARGET *outt;
LIST *filecache = 0;
if ( t->flags & T_FLAG_USEFILECACHE )
{
pushsettings( t->settings );
filecache = filecache_fillvalues( t );
popsettings( t->settings );
}
/* if this target could be cacheable */
if ( (t->flags & T_FLAG_USEFILECACHE) && (t->filecache_generate || t->filecache_use) ) {
/* find its final md5sum */
MD5_CTX context;
if( DEBUG_MD5HASH ) {
printf( "------------------------------------------------\n" );
printf( "------------------------------------------------\n" );
printf( "------------------------------------------------\n" );
}
/* sort all dependents by name, so we can make reliable md5sums */
t->depends = make0sortbyname( t->depends );
MD5Init( &context );
/* add the path of the file to the sum - it is significant because one command can create more than one file */
MD5Update( &context, (unsigned char*)t->name, (unsigned int)strlen( t->name ) );
/* add in the COMMANDLINE */
if ( t->flags & T_FLAG_USECOMMANDLINE )
{
SETTINGS *vars;
for ( vars = t->settings; vars; vars = vars->next )
{
if ( vars->symbol[0] == 'C' && strcmp( vars->symbol, "COMMANDLINE" ) == 0 )
{
LIST *list;
for ( list = vars->value; list; list = list->next )
{
MD5Update( &context, (unsigned char*)list->string, (unsigned int)strlen( list->string ) );
if( DEBUG_MD5HASH )
printf( "\t\tCOMMANDLINE: %s\n", list->string );
}
break;
}
}
}
/* for each dependencies */
for( c = t->depends; c; c = c->next )
{
/* If this is a "Needs" dependency, don't care about its contents. */
if (c->needs)
{
continue;
}
/* add name of the dependency and its contents */
make0calcmd5sum( c->target, 1 );
if ( c->target->buildmd5sum_calculated )
{
MD5Update( &context, (unsigned char*)c->target->name, (unsigned int)strlen( c->target->name ) );
MD5Update( &context, c->target->buildmd5sum, sizeof( c->target->buildmd5sum ) );
}
}
outt = bindtarget( t->boundname );
outt->flags |= T_FLAG_USEFILECACHE;
outt->filecache_generate = t->filecache_generate;
outt->filecache_use = t->filecache_use;
outt->settings = addsettings( outt->settings, VAR_SET, "FILECACHE", list_new( L0, filecache->string, 1 ) );
MD5Final( outt->buildmd5sum, &context );
if (DEBUG_MD5HASH)
{
printf( "Cacheable: %s buildmd5: %s\n", t->boundname, md5tostring(outt->buildmd5sum) );
}
/* if using cache is allowed */
if ( t->filecache_use && allcached )
{
allcached = filecache_retrieve( t, outt->buildmd5sum );
}
else
{
allcached = 0;
}
}
else
{
allcached = 0;
}
}
pushsettings( t->settings );
if ( !allcached ) {
nt = make1list( L0, a0->action->targets, 0 );
ns = make1list( L0, a0->action->sources, rule->flags );
}
}
list_free( targets );
list_free( sources );
/* if no targets survived (all were retrieved from the cache)
or no sources survived (all are up to date) */
if (nt==NULL) { // || ns==NULL) {
/* skip this action */
list_free(ns);
popsettings( t->settings );
for ( autot = autosettingsreverse; autot; autot = autot->next ) {
if ( autot->target != t )
pushsettings( autot->target->settings );
}
continue;
}
}
else
{
#if 0
if ( strncmp( rule->name, "batched_", 8 ) == 0 )
{
TARGETS* targets = a0->action->targets;
TARGETS* sources = a0->action->sources;
int anycacheable = 0;
nt = L0;
ns = L0;
/* walk sources and targets simultaneously */
for( ; targets; targets = targets->next, sources = (sources==NULL?sources:sources->next) )
{
TARGET *t = targets->target;
TARGET *s = sources!=NULL ? sources->target : NULL;
/* Sources to 'actions existing' are never in the dependency */
/* graph (if they were, they'd get built and 'existing' would */
/* be superfluous, so throttle warning message about independent */
/* targets. */
if( t->binding == T_BIND_UNBOUND )
make1bind( t, 0 );
if( s!=NULL) {
if ( s->binding == T_BIND_UNBOUND )
make1bind( s, !( rule->flags & RULE_EXISTING ) );
if ( s->binding == T_BIND_UNBOUND )
printf("Warning using unbound source %s for batched action.\n", s->name);
}
if( ( rule->flags & RULE_EXISTING ) && s!=NULL && s->binding != T_BIND_EXISTS )
continue;
if( t->fate < T_FATE_BUILD )
continue;
/* Build new lists */
nt = list_new( nt, t->boundname, 1 );
if (s!=NULL) {
ns = list_new( ns, s->boundname, 1 );
}
}
if (sources!=NULL) {
printf("warning: more sources than targets in a batched action!\n");
}
} else {
#endif
nt = make1list( L0, a0->action->targets, 0 );
ns = make1list( L0, a0->action->sources, rule->flags );
#if 0
}
#endif
}
#else
nt = make1list( L0, a0->action->targets, 0 );
ns = make1list( L0, a0->action->sources, rule->flags );
#endif
if( rule->flags & RULE_TOGETHER )
for( a1 = a0->next; a1; a1 = a1->next )
#ifdef OPT_MULTIPASS_EXT
if( a1->action->pass == actionpass && a1->action->rule == rule && !a1->action->running )
#else
if( a1->action->rule == rule && !a1->action->running )
#endif
{
ns = make1list( ns, a1->action->sources, rule->flags );
a1->action->running = 1;
#ifdef OPT_ACTIONS_WAIT_FIX
a1->action->run_tgt = t;
#endif
}
/* If doing only updated (or existing) sources, but none have */
/* been updated (or exist), skip this action. */
if( !ns && ( rule->flags & ( RULE_UPDATED | RULE_EXISTING ) ) )
{
list_free( nt );
#ifdef OPT_DEBUG_MAKE1_LOG_EXT
if (DEBUG_MAKE1) {
const char* desc = 0;
if ((rule->flags & (RULE_UPDATED | RULE_EXISTING))
== (RULE_UPDATED | RULE_EXISTING)) {
desc = "updated/existing";
} else if (rule->flags & RULE_UPDATED) {
desc = "updated";
} else if (rule->flags & RULE_EXISTING) {
desc = "existing";
}
printf( "make1cmds\t--\t%s (skipping actions by %s)\n" ,
rule->name, desc );
}
#endif /* OPT_DEBUG_MAKE1_LOG_EXT */
popsettings( t->settings );
for ( autot = autosettingsreverse; autot; autot = autot->next ) {
if ( autot->target != t )
pushsettings( autot->target->settings );
}
continue;
}
/* If we had 'actions xxx bind vars' we bind the vars now */
boundvars = make1settings( rule->bindlist );
pushsettings( boundvars );
/*
* Build command, starting with all source args.
*
* If cmd_new returns 0, it's because the resulting command
* length is > MAXLINE. In this case, we'll slowly reduce
* the number of source arguments presented until it does
* fit. This only applies to actions that allow PIECEMEAL
* commands.
*
* While reducing slowly takes a bit of compute time to get
* things just right, it's worth it to get as close to MAXLINE
* as possible, because launching the commands we're executing
* is likely to be much more compute intensive!
*
* Note we loop through at least once, for sourceless actions.
*
* Max line length is the action specific maxline or, if not
* given or bigger than MAXLINE, MAXLINE.
*/
start = 0;
chunk = length = list_length( ns );
/* commented out so jamgram.y can compile #ifdef OPT_ACTION_MAXTARGETS_EXT */
maxline = rule->maxline;
/* commented so jamgram.y can compile #else
maxline = rule->flags / RULE_MAXLINE;
#endif */
#ifdef OPT_PIECEMEAL_PUNT_EXT
maxline = maxline && maxline < CMDBUF ? maxline : CMDBUF;
#else
maxline = maxline && maxline < MAXLINE ? maxline : MAXLINE;
#endif
do
{
/* Build cmd: cmd_new consumes its lists. */
/* commented out so jamgram.y can compile #ifdef OPT_ACTION_MAXTARGETS_EXT */
int thischunk = rule->maxtargets != 0 ? (chunk < rule->maxtargets ? chunk : rule->maxtargets) : chunk;
CMD *cmd = cmd_new( rule,
list_copy( L0, nt ),
list_sublist( ns, start, thischunk ),
list_copy( L0, shell ),
maxline );
/* commented so jamgram.y can compile #else
CMD *cmd = cmd_new( rule,
list_copy( L0, nt ),
list_sublist( ns, start, chunk ),
list_copy( L0, shell ),
maxline );
#endif */
if( cmd )
{
/* It fit: chain it up. */
if( !cmds ) cmds = cmd;
else cmds->tail->next = cmd;
cmds->tail = cmd;
/* commented out so jamgram.y can compile #ifdef OPT_ACTION_MAXTARGETS_EXT */
start += thischunk;
/* commented out so jamgram.y can compile #else
start += chunk;
#endif */
}
else if( ( rule->flags & RULE_PIECEMEAL ) && chunk > 1 )
{
/* Reduce chunk size slowly. */
chunk = chunk * 9 / 10;
}
else
{
/* Too long and not splittable. */
#ifdef OPT_PIECEMEAL_PUNT_EXT
if (maxline < CMDBUF) {
maxline = CMDBUF;
continue;
}
#endif
printf( "%s actions too long (max %d)!\n",
rule->name, maxline );
exit( EXITBAD );
}
}
while( start < length );
/* These were always copied when used. */
list_free( nt );
list_free( ns );
/* Free the variables whose values were bound by */
/* 'actions xxx bind vars' */
popsettings( boundvars );
freesettings( boundvars );
popsettings( t->settings );
for ( autot = autosettingsreverse; autot; autot = autot->next ) {
if ( autot->target != t )
pushsettings( autot->target->settings );
}
}
return cmds;
}
static void
make1list_batched(
MD5SUM *md5forcmd,
LIST**plt,
LIST**pls,
TARGETS *targets,
TARGETS *sources,
int flags )
{
/* walk sources and targets simultaneously */
for( ; targets; targets = targets->next, sources = (sources==NULL?sources:sources->next) )
{
TARGET *t = targets->target;
TARGET *s = sources!=NULL ? sources->target : NULL;
if ( t->flags & T_FLAG_USEFILECACHE )
{
LIST *filecache;
pushsettings( t->settings );
filecache = var_get( "FILECACHE" );
if ( filecache ) {
LIST *l;
char *ptr;
strcpy( filecache_buffer, "FILECACHE." );
strcat( filecache_buffer, filecache->string );
ptr = filecache_buffer + strlen( filecache_buffer );
strcat( ptr, ".USE" );
l = var_get( filecache_buffer );
if ( l && atoi( l->string ) != 0) {
t->filecache_use = 1;
}
strcat( ptr, ".GENERATE" );
l = var_get( filecache_buffer );
if ( l && atoi( l->string ) != 0) {
t->filecache_generate = 1;
}
}
popsettings( t->settings );
}
/* Sources to 'actions existing' are never in the dependency */
/* graph (if they were, they'd get built and 'existing' would */
/* be superfluous, so throttle warning message about independent */
/* targets. */
if( t->binding == T_BIND_UNBOUND )
make1bind( t, 0 );
if( s!=NULL) {
if ( s->binding == T_BIND_UNBOUND )
make1bind( s, !( flags & RULE_EXISTING ) );
if ( s->binding == T_BIND_UNBOUND )
printf("Warning using unbound source %s for batched action.\n", s->name);
}
if( ( flags & RULE_EXISTING ) && s!=NULL && s->binding != T_BIND_EXISTS )
continue;
if( t->fate < T_FATE_BUILD )
continue;
/* if this target could be cacheable */
if ( (t->flags & T_FLAG_USEFILECACHE) && (t->filecache_generate || t->filecache_use) ) {
/* find its final md5sum */
MD5_CTX context;
MD5SUM buildsumorg;
memcpy(&buildsumorg, &t->buildmd5sum, sizeof(t->buildmd5sum));
MD5Init( &context );
/* add the path of the file to the sum - it is significant because one command can create more than one file */
MD5Update( &context, t->name, strlen( t->name ) );
MD5Final( t->buildmd5sum, &context );
if (DEBUG_MD5HASH) {
printf( "Cacheable: %s buildmd5: %s org: %s\n",
t->boundname, md5tostring(t->buildmd5sum), md5tostring(buildsumorg) );
}
}
/* if this target could be cacheable */
if ( (t->flags & T_FLAG_USEFILECACHE) && (t->filecache_generate || t->filecache_use) ) {
const char *cachedname;
time_t cachedtime;
/* if using cache is allowed */
if (t->filecache_use) {
/* if the target is available in the cache */
cachedname = filecache_getfilename(t, t->buildmd5sum, "");
if (cachedname!=NULL) {
if ( file_time( cachedname, &cachedtime ) == 0 ) {
/* try to get it from the cache */
if (copyfile(t->boundname, cachedname, NULL)) {
printf( "Using cached %s\n", t->boundname );
continue;
} else {
printf( "Cannot retrieve %s from cache (will build normally)\n", t->boundname );
}
} else {
if( DEBUG_MD5HASH) {
printf( "Cannot find %s in cache as %s\n", t->boundname, cachedname );
}
}
}
}
}
/* Build new lists */
*plt = list_new( *plt, t->boundname, 1 );
if (s!=NULL) {
*pls = list_new( *pls, s->boundname, 1 );
}
}
if (sources!=NULL) {
printf("warning: more sources than targets in a batched action!\n");
}
}