LIST * compile_foreach( PARSE * parse, FRAME * frame )
{
LIST * nv = parse_evaluate( parse->left, frame );
LIST * l;
SETTINGS * s = 0;
if ( parse->num )
{
s = addsettings( s, VAR_SET, parse->string, L0 );
pushsettings( s );
}
/* Call var_set to reset $(parse->string) for each val. */
for ( l = nv; l; l = list_next( l ) )
{
LIST * val = list_new( L0, copystr( l->string ) );
var_set( parse->string, val, VAR_SET );
list_free( parse_evaluate( parse->right, frame ) );
}
if ( parse->num )
{
popsettings( s );
freesettings( s );
}
list_free( nv );
return L0;
}
static void freetarget( void *xt, void *data )
{
TARGET* t = (TARGET *)xt;
if ( t->settings )
freesettings( t->settings );
if ( t->deps[0] )
freetargets( t->deps[0] );
if ( t->deps[1] )
freetargets( t->deps[1] );
if ( t->actions )
freeactions( t->actions );
}
static void freetarget( void *xt, void *data )
{
TARGET* t = (TARGET *)xt;
if ( t->settings )
freesettings( t->settings );
if ( t->depends )
freetargets( t->depends );
if ( t->includes )
freetarget( t->includes, (void*)0);
if ( t->actions )
freeactions( t->actions );
}
static void freetarget( void * xt, void * data )
{
TARGET * t = (TARGET *)xt;
if ( t->name ) object_free ( t->name );
if ( t->boundname ) object_free ( t->boundname );
if ( t->settings ) freesettings( t->settings );
if ( t->depends ) freetargets ( t->depends );
if ( t->dependants ) freetargets ( t->dependants );
if ( t->parents ) freetargets ( t->parents );
if ( t->actions ) freeactions ( t->actions );
if ( t->includes )
{
freetarget( t->includes, (void *)0 );
BJAM_FREE( t->includes );
}
}
LIST *
compile_local(
PARSE *parse,
LOL *args,
int *jmp )
{
LISTITEM *l;
SETTINGS *s = 0;
LIST *nt = (*parse->left->func)( parse->left, args, jmp );
LIST *ns = (*parse->right->func)( parse->right, args, jmp );
LIST *result;
if( DEBUG_COMPILE )
{
debug_compile( 0, "local" );
list_print( nt );
printf( " = " );
list_print( ns );
printf( "\n" );
}
/* Initial value is ns */
for( l = list_first(nt); l; l = list_next( l ) )
s = addsettings( s, 0, list_value(l), list_copy( NULL, ns ) );
list_free( ns );
list_free( nt );
/* Note that callees of the current context get this "local" */
/* variable, making it not so much local as layered. */
pushsettings( s );
result = (*parse->third->func)( parse->third, args, jmp );
popsettings( s );
freesettings( s );
return result;
}
LIST *
compile_local(
PARSE *parse,
FRAME *frame )
{
LIST *l;
SETTINGS *s = 0;
LIST *nt = parse_evaluate( parse->left, frame );
LIST *ns = parse_evaluate( parse->right, frame );
LIST *result;
if( DEBUG_COMPILE )
{
debug_compile( 0, "local", frame);
list_print( nt );
printf( " = " );
list_print( ns );
printf( "\n" );
}
/* Initial value is ns */
for( l = nt; l; l = list_next( l ) )
s = addsettings( s, 0, l->string, list_copy( (LIST*)0, ns ) );
list_free( ns );
list_free( nt );
/* Note that callees of the current context get this "local" */
/* variable, making it not so much local as layered. */
pushsettings( s );
result = parse_evaluate( parse->third, frame );
popsettings( s );
freesettings( s );
return result;
}
LIST *
compile_on(
PARSE *parse,
LOL *args,
int *jmp )
{
LIST *nt = (*parse->left->func)( parse->left, args, jmp );
LIST *result = 0;
if( DEBUG_COMPILE )
{
debug_compile( 0, "on" );
list_print( nt );
printf( "\n" );
}
/*
* Copy settings, so that 'on target var on target = val'
* doesn't set var globally.
*/
if( nt && list_first(nt) )
{
TARGET *t = bindtarget( list_value(list_first(nt)) );
SETTINGS *s = copysettings( t->settings );
pushsettings( s );
result = (*parse->right->func)( parse->right, args, jmp );
popsettings( s );
freesettings( s );
}
list_free( nt );
return result;
}
void
make0(
TARGET *t,
TARGET *p, /* parent */
int depth, /* for display purposes */
COUNTS *counts, /* for reporting */
int anyhow ) /* forcibly touch all (real) targets */
{
TARGETS *c, *d, *incs;
TARGET *ptime = t;
time_t last, leaf, hlast;
int fate;
const char *flag = "";
SETTINGS *s;
#ifdef OPT_GRAPH_DEBUG_EXT
int savedFate, oldTimeStamp;
#endif
if( DEBUG_MAKEPROG )
printf( "make\t--\t%s%s\n", spaces( depth ), t->name );
/*
* Step 1: initialize
*/
if( DEBUG_MAKEPROG )
printf( "make\t--\t%s%s\n", spaces( depth ), t->name );
t->fate = T_FATE_MAKING;
/*
* Step 2: under the influence of "on target" variables,
* bind the target and search for headers.
*/
/* Step 2a: set "on target" variables. */
s = copysettings( t->settings );
pushsettings( s );
/* Step 2b: find and timestamp the target file (if it's a file). */
if( t->binding == T_BIND_UNBOUND && !( t->flags & T_FLAG_NOTFILE ) )
{
char* another_target;
t->boundname = search( t->name, &t->time, &another_target );
/* If it was detected that this target refers to an already
existing and bound one, we add include dependency, so that
every target which depends on us will depend on that other
target. */
if( another_target )
{
TARGET* includes;
if (!t->includes) {
t->includes = copytarget(t);
t->includes->original_target = t;
}
includes = t->includes;
includes->depends = targetlist( includes->depends,
list_new( L0, another_target ) );
}
t->binding = t->time ? T_BIND_EXISTS : T_BIND_MISSING;
}
/* INTERNAL, NOTFILE header nodes have the time of their parents */
if( p && t->flags & T_FLAG_INTERNAL )
ptime = p;
/* If temp file doesn't exist but parent does, use parent */
if( p && t->flags & T_FLAG_TEMP &&
t->binding == T_BIND_MISSING &&
p->binding != T_BIND_MISSING )
{
t->binding = T_BIND_PARENTS;
ptime = p;
}
#ifdef OPT_SEMAPHORE
{
LIST *var = var_get( "JAM_SEMAPHORE" );
if( var )
{
TARGET *semaphore = bindtarget( var->string );
semaphore->progress = T_MAKE_SEMAPHORE;
t->semaphore = semaphore;
}
}
#endif
/* Step 2c: If its a file, search for headers. */
if( t->binding == T_BIND_EXISTS )
headers( t );
/* Step 2d: reset "on target" variables */
popsettings( s );
freesettings( s );
/*
* Pause for a little progress reporting
*/
if( DEBUG_BIND )
{
if( strcmp( t->name, t->boundname ) )
{
printf( "bind\t--\t%s%s: %s\n",
spaces( depth ), t->name, t->boundname );
}
switch( t->binding )
{
case T_BIND_UNBOUND:
case T_BIND_MISSING:
case T_BIND_PARENTS:
printf( "time\t--\t%s%s: %s\n",
spaces( depth ), t->name, target_bind[ t->binding ] );
break;
case T_BIND_EXISTS:
printf( "time\t--\t%s%s: %s",
spaces( depth ), t->name, ctime( &t->time ) );
break;
}
}
/*
* Step 3: recursively make0() dependents & headers
*/
/* Step 3a: recursively make0() dependents */
for( c = t->depends; c; c = c->next )
{
int internal = t->flags & T_FLAG_INTERNAL;
/* Seems like it's not relevant for us....
if( DEBUG_DEPENDS )
printf( "%s \"%s\" : \"%s\" ;\n",
internal ? "Includes" : "Depends",
t->name, c->target->name );
*/
/* Warn about circular deps, except for includes, */
/* which include each other alot. */
if( c->target->fate == T_FATE_INIT )
make0( c->target, ptime, depth + 1, counts, anyhow );
else if( c->target->fate == T_FATE_MAKING && !internal )
printf( "warning: %s depends on itself\n", c->target->name );
}
/* Step 3b: recursively make0() internal includes node */
if( t->includes )
make0( t->includes, p, depth + 1, counts, anyhow );
/* Step 3c: add dependents' includes to our direct dependencies */
incs = 0;
for( c = t->depends; c; c = c->next )
if( c->target->includes )
incs = targetentry( incs, c->target->includes );
t->depends = targetchain( t->depends, incs );
/*
* Step 4: compute time & fate
*/
/* Step 4a: pick up dependents' time and fate */
last = 0;
leaf = 0;
fate = T_FATE_STABLE;
for( c = t->depends; c; c = c->next )
{
/* If LEAVES has been applied, we only heed the timestamps of */
/* the leaf source nodes. */
leaf = max( leaf, c->target->leaf );
if( t->flags & T_FLAG_LEAVES )
{
last = leaf;
continue;
}
last = max( last, c->target->time );
fate = max( fate, c->target->fate );
#ifdef OPT_GRAPH_DEBUG_EXT
if( DEBUG_FATE )
if( fate < c->target->fate )
printf( "fate change %s from %s to %s by dependency %s\n",
t->name,
target_fate[fate], target_fate[c->target->fate],
c->target->name);
#endif
}
/* Step 4b: pick up included headers time */
/*
* If a header is newer than a temp source that includes it,
* the temp source will need building.
*/
hlast = t->includes ? t->includes->time : 0;
/* Step 4c: handle NOUPDATE oddity */
/*
* If a NOUPDATE file exists, make dependents eternally old.
* Don't inherit our fate from our dependents. Decide fate
* based only upon other flags and our binding (done later).
*/
if( t->flags & T_FLAG_NOUPDATE )
{
#ifdef OPT_GRAPH_DEBUG_EXT
if( DEBUG_FATE )
if( fate != T_FATE_STABLE )
printf( "fate change %s back to stable, NOUPDATE.\n",
t->name);
#endif
last = 0;
t->time = 0;
/*
* Don't inherit our fate from our dependents. Decide fate
* based only upon other flags and our binding (done later).
*/
fate = T_FATE_STABLE;
}
/* Step 4d: determine fate: rebuild target or what? */
/*
In English:
If can't find or make child, can't make target.
If children changed, make target.
If target missing, make it.
If children newer, make target.
If temp's children newer than parent, make temp.
If temp's headers newer than parent, make temp.
If deliberately touched, make it.
If up-to-date temp file present, use it.
If target newer than non-notfile parent, mark target newer.
Otherwise, stable!
Note this block runs from least to most stable:
as we make it further down the list, the target's
fate is getting stabler.
*/
#ifdef OPT_GRAPH_DEBUG_EXT
savedFate = fate;
oldTimeStamp = 0;
#endif
if( fate >= T_FATE_BROKEN )
{
fate = T_FATE_CANTMAKE;
}
else if( fate >= T_FATE_SPOIL )
{
fate = T_FATE_UPDATE;
}
else if( t->binding == T_BIND_MISSING )
{
fate = T_FATE_MISSING;
}
else if( t->binding == T_BIND_EXISTS && last > t->time )
{
#ifdef OPT_GRAPH_DEBUG_EXT
oldTimeStamp = 1;
#endif
fate = T_FATE_OUTDATED;
}
else if( t->binding == T_BIND_PARENTS && last > p->time )
{
#ifdef OPT_GRAPH_DEBUG_EXT
oldTimeStamp = 1;
#endif
fate = T_FATE_NEEDTMP;
}
else if( t->binding == T_BIND_PARENTS && hlast > p->time )
{
fate = T_FATE_NEEDTMP;
}
else if( t->flags & T_FLAG_TOUCHED )
{
fate = T_FATE_TOUCHED;
}
else if( anyhow && !( t->flags & T_FLAG_NOUPDATE ) )
{
fate = T_FATE_TOUCHED;
}
else if( t->binding == T_BIND_EXISTS && t->flags & T_FLAG_TEMP )
{
fate = T_FATE_ISTMP;
}
else if( t->binding == T_BIND_EXISTS && p &&
p->binding != T_BIND_UNBOUND && t->time > p->time )
{
#ifdef OPT_GRAPH_DEBUG_EXT
oldTimeStamp = 1;
#endif
fate = T_FATE_NEWER;
}
else
{
fate = T_FATE_STABLE;
}
#ifdef OPT_GRAPH_DEBUG_EXT
if( DEBUG_FATE && fate != savedFate )
if( savedFate == T_FATE_STABLE )
printf( "fate change %s set to %s%s\n",
t->name, target_fate[fate],
oldTimeStamp ? " (by timestamp)" : "" );
else
printf( "fate change %s from %s to %s%s\n",
t->name, target_fate[savedFate], target_fate[fate],
oldTimeStamp ? " (by timestamp)" : "" );
#endif
/* Step 4e: handle missing files */
/* If it's missing and there are no actions to create it, boom. */
/* If we can't make a target we don't care about, 'sokay */
/* We could insist that there are updating actions for all missing */
/* files, but if they have dependents we just pretend it's NOTFILE. */
if( fate == T_FATE_MISSING && !t->actions && !t->depends )
{
if( t->flags & T_FLAG_NOCARE )
{
#ifdef OPT_GRAPH_DEBUG_EXT
if( DEBUG_FATE )
printf( "fate change %s to STABLE from %s, "
"no actions, no dependents and don't care\n",
t->name, target_fate[fate]);
#endif
fate = T_FATE_STABLE;
}
else
{
printf( "don't know how to make %s\n", t->name );
fate = T_FATE_CANTFIND;
}
}
/* Step 4f: propagate dependents' time & fate. */
/* Set leaf time to be our time only if this is a leaf. */
t->time = max( t->time, last );
t->leaf = leaf ? leaf : t->time ;
/* This target's fate may have been updated by virtue of following
* some target's rebuilds list, so only allow it to be increased
* to the fate we've calculated. Otherwise, grab its new fate.
*/
if (fate > t->fate)
t->fate = fate;
else
fate = t->fate;
/* Step 4g: if this target needs to be built, force rebuild
* everything in this target's rebuilds list */
if (fate >= T_FATE_BUILD && fate < T_FATE_BROKEN)
force_rebuilds(t);
/*
* Step 5: sort dependents by their update time.
*/
if( globs.newestfirst )
t->depends = make0sort( t->depends );
/*
* Step 6: a little harmless tabulating for tracing purposes
*/
/* Don't count or report interal includes nodes. */
if( t->flags & T_FLAG_INTERNAL )
return;
if (counts) {
#ifdef OPT_IMPROVED_PATIENCE_EXT
++counts->targets;
#else
if( !( ++counts->targets % 1000 ) && DEBUG_MAKE )
printf( "...patience...\n" );
#endif
if( fate == T_FATE_ISTMP )
counts->temp++;
else if( fate == T_FATE_CANTFIND )
counts->cantfind++;
else if( fate == T_FATE_CANTMAKE && t->actions )
counts->cantmake++;
else if( fate >= T_FATE_BUILD && fate < T_FATE_BROKEN && t->actions )
counts->updating++;
}
if( !( t->flags & T_FLAG_NOTFILE ) && fate >= T_FATE_SPOIL )
flag = "+";
else if( t->binding == T_BIND_EXISTS && p && t->time > p->time )
flag = "*";
if( DEBUG_MAKEPROG )
printf( "made%s\t%s\t%s%s\n",
flag, target_fate[ t->fate ],
spaces( depth ), t->name );
/* We don't have DEBUG_CAUSES.
if( DEBUG_CAUSES &&
t->fate >= T_FATE_NEWER &&
t->fate <= T_FATE_MISSING )
printf( "%s %s\n", target_fate[ t->fate ], t->name );
*/
}
LIST *
evaluate_rule(
char * rulename,
FRAME * frame )
{
LIST * result = L0;
RULE * rule;
profile_frame prof[1];
module_t * prev_module = frame->module;
LIST * l;
{
LOL arg_context_, * arg_context = &arg_context_;
if ( !frame->prev )
lol_init(arg_context);
else
arg_context = frame->prev->args;
l = var_expand( L0, rulename, rulename+strlen(rulename), arg_context, 0 );
}
if ( !l )
{
backtrace_line( frame->prev );
printf( "warning: rulename %s expands to empty string\n", rulename );
backtrace( frame->prev );
return result;
}
rulename = l->string;
rule = bindrule( l->string, frame->module );
#ifdef HAVE_PYTHON
if ( rule->python_function )
{
/* The below messing with modules is due to the way modules are
* implemented in Jam. Suppose we are in module M1 now. The global
* variable map actually holds 'M1' variables, and M1->variables hold
* global variables.
*
* If we call Python right away, Python calls back Jam and then Jam
* does 'module M1 { }' then Jam will try to swap the current global
* variables with M1->variables. The result will be that global
* variables map will hold global variables, and any variable settings
* we do will go to the global module, not M1.
*
* By restoring basic state, where the global variable map holds global
* variable, we make sure any future 'module M1' entry will work OK.
*/
LIST * result;
module_t * m = python_module();
frame->module = m;
exit_module( prev_module );
enter_module( m );
result = call_python_function( rule, frame );
exit_module( m );
enter_module ( prev_module );
return result;
}
#endif
/* Drop the rule name. */
l = list_pop_front( l );
/* Tack the rest of the expansion onto the front of the first argument. */
frame->args->list[0] = list_append( l, lol_get( frame->args, 0 ) );
if ( DEBUG_COMPILE )
{
/* Try hard to indicate in which module the rule is going to execute. */
if ( rule->module != frame->module
&& rule->procedure != 0 && strcmp( rulename, rule->procedure->rulename ) )
{
char buf[256] = "";
strncat( buf, rule->module->name, sizeof( buf ) - 1 );
strncat( buf, rule->name, sizeof( buf ) - 1 );
debug_compile( 1, buf, frame );
}
else
{
debug_compile( 1, rulename, frame );
}
lol_print( frame->args );
printf( "\n" );
}
if ( rule->procedure && rule->module != prev_module )
{
/* Propagate current module to nested rule invocations. */
frame->module = rule->module;
/* Swap variables. */
exit_module( prev_module );
enter_module( rule->module );
}
/* Record current rule name in frame. */
if ( rule->procedure )
{
frame->rulename = rulename;
/* And enter record profile info. */
if ( DEBUG_PROFILE )
profile_enter( rule->procedure->rulename, prof );
}
/* Check traditional targets $(<) and sources $(>). */
if ( !rule->actions && !rule->procedure )
{
backtrace_line( frame->prev );
printf( "rule %s unknown in module %s\n", rule->name, frame->module->name );
backtrace( frame->prev );
exit( 1 );
}
/* If this rule will be executed for updating the targets then construct the
* action for make().
*/
if ( rule->actions )
{
TARGETS * t;
ACTION * action;
/* The action is associated with this instance of this rule. */
action = (ACTION *)BJAM_MALLOC( sizeof( ACTION ) );
memset( (char *)action, '\0', sizeof( *action ) );
action->rule = rule;
action->targets = targetlist( (TARGETS *)0, lol_get( frame->args, 0 ) );
action->sources = targetlist( (TARGETS *)0, lol_get( frame->args, 1 ) );
/* If we have a group of targets all being built using the same action
* then we must not allow any of them to be used as sources unless they
* had all already been built in the first place or their joined action
* has had a chance to finish its work and build all of them anew.
*
* Without this it might be possible, in case of a multi-process build,
* for their action, triggered by buiding one of the targets, to still
* be running when another target in the group reports as done in order
* to avoid triggering the same action again and gets used prematurely.
*
* As a quick-fix to achieve this effect we make all the targets list
* each other as 'included targets'. More precisely, we mark the first
* listed target as including all the other targets in the list and vice
* versa. This makes anyone depending on any of those targets implicitly
* depend on all of them, thus making sure none of those targets can be
* used as sources until all of them have been built. Note that direct
* dependencies could not have been used due to the 'circular
* dependency' issue.
*
* TODO: Although the current implementation solves the problem of one
* of the targets getting used before its action completes its work it
* also forces the action to run whenever any of the targets in the
* group is not up to date even though some of them might not actually
* be used by the targets being built. We should see how we can
* correctly recognize such cases and use that to avoid running the
* action if possible and not rebuild targets not actually depending on
* targets that are not up to date.
*
* TODO: Using the 'include' feature might have side-effects due to
* interaction with the actual 'inclusion scanning' system. This should
* be checked.
*/
if ( action->targets )
{
TARGET * t0 = action->targets->target;
for ( t = action->targets->next; t; t = t->next )
{
target_include( t->target, t0 );
target_include( t0, t->target );
}
}
/* Append this action to the actions of each target. */
for ( t = action->targets; t; t = t->next )
t->target->actions = actionlist( t->target->actions, action );
}
/* Now recursively compile any parse tree associated with this rule.
* parse_refer()/parse_free() call pair added to ensure rule not freed
* during use.
*/
if ( rule->procedure )
{
SETTINGS * local_args = collect_arguments( rule, frame );
PARSE * parse = rule->procedure;
parse_refer( parse );
pushsettings( local_args );
result = parse_evaluate( parse, frame );
popsettings( local_args );
freesettings( local_args );
parse_free( parse );
}
if ( frame->module != prev_module )
{
exit_module( frame->module );
enter_module( prev_module );
}
if ( DEBUG_PROFILE && rule->procedure )
profile_exit( prof );
if ( DEBUG_COMPILE )
debug_compile( -1, 0, frame);
return result;
}
LIST *
evaluate_rule(
const char *rulename,
LOL *args,
LIST *result )
{
#ifdef OPT_EXPAND_RULE_NAMES_EXT
RULE *rule;
char *expanded;
char *c;
int i;
BUFFER buff;
buffer_init( &buff );
if( (i = var_string( rulename, &buff, 0, args, ' ' )) < 0 )
{
printf( "Failed to expand rule %s -- expansion too long\n", rulename );
exit( EXITBAD );
}
expanded = buffer_ptr( &buff );
while ( expanded[0] == ' ' )
expanded++;
while ( (c = strrchr(expanded, ' ')) )
*c = '\0';
if( DEBUG_COMPILE )
{
debug_compile( 1, rulename );
if ( strcmp(rulename, expanded) )
printf( "-> %s ", expanded );
lol_print( args );
printf( "\n" );
}
rule = bindrule( expanded );
#else
RULE *rule = bindrule( rulename );
if( DEBUG_COMPILE )
{
debug_compile( 1, rulename );
lol_print( args );
printf( "\n" );
}
#endif
#ifdef OPT_LOAD_MISSING_RULE_EXT
if( !rule->actions && !rule->procedure )
{
if( ruleexists( "FindMissingRule" ) )
{
LOL lol;
LIST *args = list_append( L0, expanded, 0 );
LIST *result;
lol_init( &lol );
lol_add( &lol, args );
result = evaluate_rule( "FindMissingRule", &lol, L0 );
lol_free( &lol );
if( list_first( result ) ) {
rule = bindrule( list_value( list_first( result ) ) );
}
list_free( result );
}
}
#endif /* OPT_LOAD_MISSING_RULE_EXT */
/* Check traditional targets $(<) and sources $(>) */
#ifdef OPT_IMPROVED_WARNINGS_EXT
if( !rule->actions && !rule->procedure && !globs.silence )
printf( "warning: unknown rule %s %s\n", rule->name,
file_and_line());
#else
if( !rule->actions && !rule->procedure )
printf( "warning: unknown rule %s\n", rule->name );
#endif
/* If this rule will be executed for updating the targets */
/* then construct the action for make(). */
if( rule->actions )
{
TARGETS *t;
ACTION *action;
/* The action is associated with this instance of this rule */
action = (ACTION *)malloc( sizeof( ACTION ) );
memset( (char *)action, '\0', sizeof( *action ) );
action->rule = rule;
#ifdef OPT_BUILTIN_NEEDS_EXT
action->targets = targetlist( (TARGETS *)0, lol_get( args, 0 ), 0 );
action->sources = targetlist( (TARGETS *)0, lol_get( args, 1 ), 0 );
action->autosettings = targetlist( (TARGETS *)0, lol_get( args, 2 ), 0 );
#else
action->targets = targetlist( (TARGETS *)0, lol_get( args, 0 ) );
action->sources = targetlist( (TARGETS *)0, lol_get( args, 1 ) );
#endif
#ifdef OPT_USE_CHECKSUMS_EXT
action->extratargets = targetlist( (TARGETS *)0, lol_get( args, 3 ), 0 );
#endif /* OPT_USE_CHECKSUMS_EXT */
#ifdef OPT_CLEAN_GLOBS_EXT
{
TARGETS* targets;
for ( targets = action->targets; targets; targets = targets->next ) {
if ( !( targets->target->flags & T_FLAG_NOTFILE ) )
add_used_target_to_hash( targets->target );
}
}
#endif /* OPT_CLEAN_GLOBS_EXT */
/* Append this action to the actions of each target */
#ifdef OPT_MULTIPASS_EXT
action->pass = actionpass;
for( t = action->targets; t; t = t->next ) {
t->target->progress = T_MAKE_INIT;
t->target->actions = actionlist( t->target->actions, action );
}
#else
for( t = action->targets; t; t = t->next )
t->target->actions = actionlist( t->target->actions, action );
#endif
}
/* Now recursively compile any parse tree associated with this rule */
if( rule->procedure )
{
PARSE *parse = rule->procedure;
SETTINGS *s = 0;
int jmp = JMP_NONE;
LISTITEM *l;
int i;
/* build parameters as local vars */
for( l = list_first(rule->params), i = 0; l; l = list_next(l), i++ )
s = addsettings( s, 0, list_value(l),
list_copy( L0, lol_get( args, i ) ) );
/* Run rule. */
/* Bring in local params. */
/* refer/free to ensure rule not freed during use. */
parse_refer( parse );
pushsettings( s );
result = list_appendList( result, (*parse->func)( parse, args, &jmp ) );
popsettings( s );
freesettings( s );
parse_free( parse );
}
if( DEBUG_COMPILE )
debug_compile( -1, 0 );
#ifdef OPT_EXPAND_RULE_NAMES_EXT
buffer_free( &buff );
#endif
return result;
}
static CMD *
make1cmds( TARGET *t )
{
CMD *cmds = 0;
LIST *shell = 0;
module_t *settings_module = 0;
TARGET *settings_target = 0;
/* Step through actions */
/* Actions may be shared with other targets or grouped with */
/* RULE_TOGETHER, so actions already seen are skipped. */
ACTIONS* a0;
for(a0 = t->actions ; a0; a0 = a0->next )
{
RULE *rule = a0->action->rule;
rule_actions *actions = rule->actions;
SETTINGS *boundvars;
LIST *nt, *ns;
ACTIONS *a1;
int start, chunk, length;
/* Only do rules with commands to execute. */
/* If this action has already been executed, use saved status */
if( !actions || a0->action->running )
continue;
a0->action->running = 1;
/* 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. */
nt = make1list( L0, a0->action->targets, 0 );
ns = make1list( L0, a0->action->sources, actions->flags );
if( actions->flags & RULE_TOGETHER )
for( a1 = a0->next; a1; a1 = a1->next )
if( a1->action->rule == rule && !a1->action->running )
{
ns = make1list( ns, a1->action->sources, actions->flags );
a1->action->running = 1;
}
/* If doing only updated (or existing) sources, but none have */
/* been updated (or exist), skip this action. */
if( !ns && ( actions->flags & ( RULE_NEWSRCS | RULE_EXISTING ) ) )
{
list_free( nt );
continue;
}
swap_settings( &settings_module, &settings_target, rule->module, t );
if (!shell)
shell = var_get( "JAMSHELL" ); /* shell is per-target */
/* If we had 'actions xxx bind vars' we bind the vars now */
boundvars = make1settings( actions->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.
*/
start = 0;
chunk = length = list_length( ns );
do
{
/* Build cmd: cmd_new consumes its lists. */
CMD *cmd = cmd_new( rule,
list_copy( L0, nt ),
list_sublist( ns, start, chunk ),
list_copy( L0, shell ) );
if( cmd )
{
/* It fit: chain it up. */
if( !cmds ) cmds = cmd;
else cmds->tail->next = cmd;
cmds->tail = cmd;
start += chunk;
}
else if( ( actions->flags & RULE_PIECEMEAL ) && chunk > 1 )
{
/* Reduce chunk size slowly. */
chunk = chunk * 9 / 10;
}
else
{
/* Too long and not splittable. */
printf( "%s actions too long (max %d):\n",
rule->name, MAXLINE );
/* Tell the user what didn't fit */
cmd = cmd_new(
rule, list_copy( L0, nt ),
list_sublist( ns, start, chunk ),
list_new( L0, newstr( "%" ) ) );
printf( cmd->buf );
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 );
}
swap_settings( &settings_module, &settings_target, 0, 0 );
return cmds;
}
LIST *
evaluate_rule(
const char *rulename,
LOL *args,
LIST *result,
int *jmp )
{
RULE *rule = bindrule( rulename );
if( DEBUG_COMPILE )
{
debug_compile( 1, rulename );
lol_print( args );
printf( "\n" );
}
/* Check traditional targets $(<) and sources $(>) */
if( !rule->actions && !rule->procedure )
printf( "warning: unknown rule %s\n", rule->name );
/* If this rule will be executed for updating the targets */
/* then construct the action for make(). */
if( rule->actions )
{
TARGETS *t;
ACTION *action;
/* The action is associated with this instance of this rule */
action = (ACTION *)malloc( sizeof( ACTION ) );
memset( (char *)action, '\0', sizeof( *action ) );
action->rule = rule;
action->targets = targetlist( (TARGETS *)0, lol_get( args, 0 ) );
action->sources = targetlist( (TARGETS *)0, lol_get( args, 1 ) );
/* Append this action to the actions of each target */
for( t = action->targets; t; t = t->next )
t->target->actions = actionlist( t->target->actions, action );
}
/* Now recursively compile any parse tree associated with this rule */
if( rule->procedure )
{
PARSE *parse = rule->procedure;
SETTINGS *s = 0;
LIST *l;
int i;
# ifdef OPT_RULE_PROFILING_EXT
struct timeval startTime, endTime;
if ( DEBUG_PROFILE_RULES )
gettimeofday(&startTime, 0);
# endif
/* build parameters as local vars */
for( l = rule->params, i = 0; l; l = l->next, i++ )
s = addsettings( s, 0, l->string,
list_copy( L0, lol_get( args, i ) ) );
/* Run rule. */
/* Bring in local params. */
/* refer/free to ensure rule not freed during use. */
parse_refer( parse );
pushsettings( s );
result = list_append( result, (*parse->func)( parse, args, jmp ) );
popsettings( s );
freesettings( s );
parse_free( parse );
# ifdef OPT_RULE_PROFILING_EXT
if ( DEBUG_PROFILE_RULES )
{
gettimeofday(&endTime, 0);
rule->invocations++;
rule->invocation_time
+= (endTime.tv_sec - startTime.tv_sec) * (int64_t)1000000
+ (endTime.tv_usec - startTime.tv_usec);
}
# endif
}
if( DEBUG_COMPILE )
debug_compile( -1, 0 );
return result;
}
LIST *
evaluate_rule(
char *rulename,
FRAME *frame )
{
LIST *result = L0;
RULE *rule;
profile_frame prof[1];
module_t *prev_module = frame->module;
LIST *l;
{
LOL arg_context_, *arg_context = &arg_context_;
if ( !frame->prev )
lol_init(arg_context);
else
arg_context = frame->prev->args;
l = var_expand( L0, rulename, rulename+strlen(rulename), arg_context, 0 );
}
if ( !l )
{
backtrace_line( frame->prev );
printf( "warning: rulename %s expands to empty string\n", rulename );
backtrace( frame->prev );
return result;
}
rulename = l->string;
rule = bindrule( l->string, frame->module );
#ifdef HAVE_PYTHON
if (rule->python_function)
{
return call_python_function(rule, frame);
}
#endif
/* drop the rule name */
l = list_pop_front( l );
/* tack the rest of the expansion onto the front of the first argument */
frame->args->list[0] = list_append( l, lol_get( frame->args, 0 ) );
if ( DEBUG_COMPILE )
{
/* Try hard to indicate in which module the rule is going to execute */
if ( rule->module != frame->module
&& rule->procedure != 0 && strcmp(rulename, rule->procedure->rulename) )
{
char buf[256] = "";
strncat( buf, rule->module->name, sizeof(buf) - 1 );
strncat( buf, rule->name, sizeof(buf) - 1 );
debug_compile( 1, buf, frame);
}
else
{
debug_compile( 1, rulename, frame);
}
lol_print( frame->args );
printf( "\n" );
}
if ( rule->procedure && rule->module != prev_module )
{
/* propagate current module to nested rule invocations */
frame->module = rule->module;
/* swap variables */
exit_module( prev_module );
enter_module( rule->module );
}
/* record current rule name in frame */
if ( rule->procedure )
{
frame->rulename = rulename;
/* and enter record profile info */
if ( DEBUG_PROFILE )
profile_enter( rule->procedure->rulename, prof );
}
/* Check traditional targets $(<) and sources $(>) */
if( !rule->actions && !rule->procedure )
{
backtrace_line( frame->prev );
printf( "rule %s unknown in module %s\n", rule->name, frame->module->name );
backtrace( frame->prev );
exit(1);
}
/* If this rule will be executed for updating the targets */
/* then construct the action for make(). */
if( rule->actions )
{
TARGETS *t;
ACTION *action;
/* The action is associated with this instance of this rule */
action = (ACTION *)malloc( sizeof( ACTION ) );
memset( (char *)action, '\0', sizeof( *action ) );
action->rule = rule;
action->targets = targetlist( (TARGETS *)0, lol_get( frame->args, 0 ) );
action->sources = targetlist( (TARGETS *)0, lol_get( frame->args, 1 ) );
/* Append this action to the actions of each target */
for( t = action->targets; t; t = t->next )
t->target->actions = actionlist( t->target->actions, action );
}
/* Now recursively compile any parse tree associated with this rule */
/* refer/free to ensure rule not freed during use */
if( rule->procedure )
{
SETTINGS *local_args = collect_arguments( rule, frame );
PARSE *parse = rule->procedure;
parse_refer( parse );
pushsettings( local_args );
result = parse_evaluate( parse, frame );
popsettings( local_args );
freesettings( local_args );
parse_free( parse );
}
if ( frame->module != prev_module )
{
exit_module( frame->module );
enter_module( prev_module );
}
if ( DEBUG_PROFILE && rule->procedure )
profile_exit( prof );
if( DEBUG_COMPILE )
debug_compile( -1, 0, frame);
return result;
}
static void
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) {
TARGET *target_to_rescan = t;
SETTINGS *s;
target_to_rescan->rescanned = 1;
if (target_to_rescan->flags & T_FLAG_INTERNAL) {
target_to_rescan = t->original_target;
}
/* Clean current includes */
if (target_to_rescan->includes) {
target_to_rescan->includes = 0;
}
s = copysettings( target_to_rescan->settings );
pushsettings( s );
headers(target_to_rescan);
popsettings( s );
freesettings( s );
if (target_to_rescan->includes) {
target_to_rescan->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(target_to_rescan->includes, target_to_rescan->parents->target, 0, 0, 0);
for( c = target_to_rescan->parents; c; c = c->next) {
c->target->depends = targetentry( c->target->depends,
target_to_rescan->includes );
}
/* Will be processed below. */
additional_includes = target_to_rescan->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);
}
}
}
static CMD * make1cmds( TARGET * t )
{
CMD * cmds = 0;
CMD * * cmds_next = &cmds;
LIST * shell = L0;
module_t * settings_module = 0;
TARGET * settings_target = 0;
ACTIONS * a0;
int const running_flag = globs.noexec ? A_RUNNING_NOEXEC : A_RUNNING;
/* Step through actions. Actions may be shared with other targets or grouped
* using RULE_TOGETHER, so actions already seen are skipped.
*/
for ( a0 = t->actions; a0; a0 = a0->next )
{
RULE * rule = a0->action->rule;
rule_actions * actions = rule->actions;
SETTINGS * boundvars;
LIST * nt;
LIST * ns;
ACTIONS * a1;
/* Only do rules with commands to execute. If this action has already
* been executed, use saved status.
*/
if ( !actions || a0->action->running >= running_flag )
continue;
a0->action->running = running_flag;
/* 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.
*/
nt = make1list( L0, a0->action->targets, 0 );
ns = make1list( L0, a0->action->sources, actions->flags );
if ( actions->flags & RULE_TOGETHER )
for ( a1 = a0->next; a1; a1 = a1->next )
if ( a1->action->rule == rule &&
a1->action->running < running_flag )
{
ns = make1list( ns, a1->action->sources, actions->flags );
a1->action->running = running_flag;
}
/* If doing only updated (or existing) sources, but none have been
* updated (or exist), skip this action.
*/
if ( list_empty( ns ) &&
( actions->flags & ( RULE_NEWSRCS | RULE_EXISTING ) ) )
{
list_free( nt );
continue;
}
swap_settings( &settings_module, &settings_target, rule->module, t );
if ( list_empty( shell ) )
{
/* shell is per-target */
shell = var_get( rule->module, constant_JAMSHELL );
}
/* If we had 'actions xxx bind vars' we bind the vars now. */
boundvars = make1settings( rule->module, actions->bindlist );
pushsettings( rule->module, boundvars );
/*
* Build command, starting with all source args.
*
* For actions that allow PIECEMEAL commands, if the constructed command
* string is too long, we retry constructing it with a reduced number of
* source arguments presented.
*
* While reducing slowly takes a bit of compute time to get things just
* right, it is worth it to get as close to maximum allowed command
* string length as possible, because launching the commands we are
* executing is likely to be much more compute intensive.
*
* Note that we loop through at least once, for sourceless actions.
*/
{
int const length = list_length( ns );
int start = 0;
int chunk = length;
LIST * cmd_targets = L0;
LIST * cmd_shell = L0;
do
{
CMD * cmd;
int cmd_check_result;
int cmd_error_length;
int cmd_error_max_length;
int retry = 0;
int accept_command = 0;
/* Build cmd: cmd_new() takes ownership of its lists. */
if ( list_empty( cmd_targets ) ) cmd_targets = list_copy( nt );
if ( list_empty( cmd_shell ) ) cmd_shell = list_copy( shell );
cmd = cmd_new( rule, cmd_targets, list_sublist( ns, start,
chunk ), cmd_shell );
cmd_check_result = exec_check( cmd->buf, &cmd->shell,
&cmd_error_length, &cmd_error_max_length );
if ( cmd_check_result == EXEC_CHECK_OK )
{
accept_command = 1;
}
else if ( cmd_check_result == EXEC_CHECK_NOOP )
{
accept_command = 1;
cmd->noop = 1;
}
else if ( ( actions->flags & RULE_PIECEMEAL ) && ( chunk > 1 ) )
{
/* Too long but splittable. Reduce chunk size slowly and
* retry.
*/
assert( cmd_check_result == EXEC_CHECK_TOO_LONG ||
cmd_check_result == EXEC_CHECK_LINE_TOO_LONG );
chunk = chunk * 9 / 10;
retry = 1;
}
else
{
/* Too long and not splittable. */
char const * const error_message = cmd_check_result ==
EXEC_CHECK_TOO_LONG
? "is too long"
: "contains a line that is too long";
assert( cmd_check_result == EXEC_CHECK_TOO_LONG ||
cmd_check_result == EXEC_CHECK_LINE_TOO_LONG );
printf( "%s action %s (%d, max %d):\n", object_str(
rule->name ), error_message, cmd_error_length,
cmd_error_max_length );
/* Tell the user what did not fit. */
fputs( cmd->buf->value, stdout );
exit( EXITBAD );
}
assert( !retry || !accept_command );
if ( accept_command )
{
/* Chain it up. */
*cmds_next = cmd;
cmds_next = &cmd->next;
/* Mark lists we need recreated for the next command since
* they got consumed by the cmd object.
*/
cmd_targets = L0;
cmd_shell = L0;
}
else
{
/* We can reuse targets & shell lists for the next command
* if we do not let them die with this cmd object.
*/
cmd_release_targets_and_shell( cmd );
cmd_free( cmd );
}
if ( !retry )
start += chunk;
}
while ( start < length );
}
/* These were always copied when used. */
list_free( nt );
list_free( ns );
/* Free variables with values bound by 'actions xxx bind vars'. */
popsettings( rule->module, boundvars );
freesettings( boundvars );
}
swap_settings( &settings_module, &settings_target, 0, 0 );
return cmds;
}
static void make1c( state const * const pState )
{
TARGET * const t = pState->t;
CMD * const cmd = (CMD *)t->cmds;
if ( cmd && t->status == EXEC_CMD_OK )
{
/* Pop state first in case something below (e.g. exec_cmd(), exec_wait()
* or make1c_closure()) pushes a new state. Note that we must not access
* the popped state data after this as the same stack node might have
* been reused internally for some newly pushed state.
*/
pop_state( &state_stack );
/* Increment the jobs running counter. */
++cmdsrunning;
/* Execute the actual build command or fake it if no-op. */
if ( globs.noexec || cmd->noop )
{
timing_info time_info = { 0 };
timestamp_current( &time_info.start );
timestamp_copy( &time_info.end, &time_info.start );
make1c_closure( t, EXEC_CMD_OK, &time_info, "", "", EXIT_OK );
}
else
{
exec_cmd( cmd->buf, make1c_closure, t, cmd->shell );
/* Wait until under the concurrent command count limit. */
/* FIXME: This wait could be skipped here and moved to just before
* trying to execute a command that would cross the command count
* limit. Note though that this might affect the order in which
* unrelated targets get built and would thus require that all
* affected Boost Build tests be updated.
*/
assert( 0 < globs.jobs );
assert( globs.jobs <= MAXJOBS );
while ( cmdsrunning >= globs.jobs )
exec_wait();
}
}
else
{
ACTIONS * actions;
/* Collect status from actions, and distribute it as well. */
for ( actions = t->actions; actions; actions = actions->next )
if ( actions->action->status > t->status )
t->status = actions->action->status;
for ( actions = t->actions; actions; actions = actions->next )
if ( t->status > actions->action->status )
actions->action->status = t->status;
/* Tally success/failure for those we tried to update. */
if ( t->progress == T_MAKE_RUNNING )
switch ( t->status )
{
case EXEC_CMD_OK: ++counts->made; break;
case EXEC_CMD_FAIL: ++counts->failed; break;
}
/* Tell parents their dependency has been built. */
{
TARGETS * c;
stack temp_stack = { NULL };
TARGET * additional_includes = NULL;
t->progress = globs.noexec ? T_MAKE_NOEXEC_DONE : T_MAKE_DONE;
/* Target has been updated so rescan it for dependencies. */
if ( t->fate >= T_FATE_MISSING && t->status == EXEC_CMD_OK &&
!( t->flags & T_FLAG_INTERNAL ) )
{
TARGET * saved_includes;
SETTINGS * s;
t->rescanned = 1;
/* Clean current includes. */
saved_includes = t->includes;
t->includes = 0;
s = copysettings( t->settings );
pushsettings( root_module(), s );
headers( t );
popsettings( root_module(), s );
freesettings( s );
if ( t->includes )
{
/* Tricky. The parents have already been processed, but they
* have not seen the internal node, because it was just
* created. We need to:
* - push MAKE1A states that would have been pushed by the
* parents here
* - make sure all unprocessed parents will pick up the
* new includes
* - make sure processing the additional MAKE1A states is
* done before processing the MAKE1B state for our
* current target (which would mean this target has
* already been built), otherwise the parent would be
* considered built before the additional MAKE1A state
* processing even got a chance to start.
*/
make0( t->includes, t->parents->target, 0, 0, 0, t->includes
);
/* Link the old includes on to make sure that it gets
* cleaned up correctly.
*/
t->includes->includes = saved_includes;
for ( c = t->dependants; c; c = c->next )
c->target->depends = targetentry( c->target->depends,
t->includes );
/* Will be processed below. */
additional_includes = t->includes;
}
else
{
t->includes = saved_includes;
}
}
if ( additional_includes )
for ( c = t->parents; c; c = c->next )
push_state( &temp_stack, additional_includes, c->target,
T_STATE_MAKE1A );
if ( t->scc_root )
{
TARGET * const scc_root = target_scc( t );
assert( scc_root->progress < T_MAKE_DONE );
for ( c = t->parents; c; c = c->next )
{
if ( target_scc( c->target ) == scc_root )
push_state( &temp_stack, c->target, NULL, T_STATE_MAKE1B
);
else
scc_root->parents = targetentry( scc_root->parents,
c->target );
}
}
else
{
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, it is now free. */
if ( t->semaphore )
{
assert( t->semaphore->asynccnt == 1 );
--t->semaphore->asynccnt;
if ( DEBUG_EXECCMD )
printf( "SEM: %s is now free\n", object_str(
t->semaphore->name ) );
/* If anything is waiting, notify the next target. There is no
* point in notifying all waiting targets, since they will be
* notified again.
*/
if ( t->semaphore->parents )
{
TARGETS * first = t->semaphore->parents;
t->semaphore->parents = first->next;
if ( first->next )
first->next->tail = first->tail;
if ( DEBUG_EXECCMD )
printf( "SEM: placing %s on stack\n", object_str(
first->target->name ) );
push_state( &temp_stack, first->target, NULL, T_STATE_MAKE1B
);
BJAM_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 );
}
}
}
void make0
(
TARGET * t,
TARGET * p, /* parent */
int depth, /* for display purposes */
COUNTS * counts, /* for reporting */
int anyhow,
TARGET * rescanning
) /* forcibly touch all (real) targets */
{
TARGETS * c;
TARGET * ptime = t;
TARGET * located_target = 0;
timestamp last;
timestamp leaf;
timestamp hlast;
int fate;
char const * flag = "";
SETTINGS * s;
#ifdef OPT_GRAPH_DEBUG_EXT
int savedFate;
int oldTimeStamp;
#endif
if ( DEBUG_MAKEPROG )
out_printf( "make\t--\t%s%s\n", spaces( depth ), object_str( t->name ) );
/*
* Step 1: Initialize.
*/
if ( DEBUG_MAKEPROG )
out_printf( "make\t--\t%s%s\n", spaces( depth ), object_str( t->name ) );
t->fate = T_FATE_MAKING;
t->depth = depth;
/*
* Step 2: Under the influence of "on target" variables, bind the target and
* search for headers.
*/
/* Step 2a: Set "on target" variables. */
s = copysettings( t->settings );
pushsettings( root_module(), s );
/* Step 2b: Find and timestamp the target file (if it is a file). */
if ( ( t->binding == T_BIND_UNBOUND ) && !( t->flags & T_FLAG_NOTFILE ) )
{
OBJECT * another_target;
object_free( t->boundname );
t->boundname = search( t->name, &t->time, &another_target,
t->flags & T_FLAG_ISFILE );
/* If it was detected that this target refers to an already existing and
* bound target, we add a dependency so that every target depending on
* us will depend on that other target as well.
*/
if ( another_target )
located_target = bindtarget( another_target );
t->binding = timestamp_empty( &t->time )
? T_BIND_MISSING
: T_BIND_EXISTS;
}
/* INTERNAL, NOTFILE header nodes have the time of their parents. */
if ( p && ( t->flags & T_FLAG_INTERNAL ) )
ptime = p;
/* If temp file does not exist but parent does, use parent. */
if ( p && ( t->flags & T_FLAG_TEMP ) &&
( t->binding == T_BIND_MISSING ) &&
( p->binding != T_BIND_MISSING ) )
{
t->binding = T_BIND_PARENTS;
ptime = p;
}
#ifdef OPT_SEMAPHORE
{
LIST * var = var_get( root_module(), constant_JAM_SEMAPHORE );
if ( !list_empty( var ) )
{
TARGET * const semaphore = bindtarget( list_front( var ) );
semaphore->progress = T_MAKE_SEMAPHORE;
t->semaphore = semaphore;
}
}
#endif
/* Step 2c: If its a file, search for headers. */
if ( t->binding == T_BIND_EXISTS )
headers( t );
/* Step 2d: reset "on target" variables. */
popsettings( root_module(), s );
freesettings( s );
/*
* Pause for a little progress reporting.
*/
if ( DEBUG_BIND )
{
if ( !object_equal( t->name, t->boundname ) )
out_printf( "bind\t--\t%s%s: %s\n", spaces( depth ),
object_str( t->name ), object_str( t->boundname ) );
switch ( t->binding )
{
case T_BIND_UNBOUND:
case T_BIND_MISSING:
case T_BIND_PARENTS:
out_printf( "time\t--\t%s%s: %s\n", spaces( depth ),
object_str( t->name ), target_bind[ (int)t->binding ] );
break;
case T_BIND_EXISTS:
out_printf( "time\t--\t%s%s: %s\n", spaces( depth ),
object_str( t->name ), timestamp_str( &t->time ) );
break;
}
}
/*
* Step 3: Recursively make0() dependencies & headers.
*/
/* Step 3a: Recursively make0() dependencies. */
for ( c = t->depends; c; c = c->next )
{
int const internal = t->flags & T_FLAG_INTERNAL;
/* Warn about circular deps, except for includes, which include each
* other alot.
*/
if ( c->target->fate == T_FATE_INIT )
make0( c->target, ptime, depth + 1, counts, anyhow, rescanning );
else if ( c->target->fate == T_FATE_MAKING && !internal )
out_printf( "warning: %s depends on itself\n", object_str(
c->target->name ) );
else if ( c->target->fate != T_FATE_MAKING && rescanning )
make0rescan( c->target, rescanning );
if ( rescanning && c->target->includes && c->target->includes->fate !=
T_FATE_MAKING )
make0rescan( target_scc( c->target->includes ), rescanning );
}
if ( located_target )
{
if ( located_target->fate == T_FATE_INIT )
make0( located_target, ptime, depth + 1, counts, anyhow, rescanning
);
else if ( located_target->fate != T_FATE_MAKING && rescanning )
make0rescan( located_target, rescanning );
}
/* Step 3b: Recursively make0() internal includes node. */
if ( t->includes )
make0( t->includes, p, depth + 1, counts, anyhow, rescanning );
/* Step 3c: Add dependencies' includes to our direct dependencies. */
{
TARGETS * incs = 0;
for ( c = t->depends; c; c = c->next )
if ( c->target->includes )
incs = targetentry( incs, c->target->includes );
t->depends = targetchain( t->depends, incs );
}
if ( located_target )
t->depends = targetentry( t->depends, located_target );
/* Step 3d: Detect cycles. */
{
int cycle_depth = depth;
for ( c = t->depends; c; c = c->next )
{
TARGET * scc_root = target_scc( c->target );
if ( scc_root->fate == T_FATE_MAKING &&
( !scc_root->includes ||
scc_root->includes->fate != T_FATE_MAKING ) )
{
if ( scc_root->depth < cycle_depth )
{
cycle_depth = scc_root->depth;
t->scc_root = scc_root;
}
}
}
}
/*
* Step 4: Compute time & fate.
*/
/* Step 4a: Pick up dependencies' time and fate. */
timestamp_clear( &last );
timestamp_clear( &leaf );
fate = T_FATE_STABLE;
for ( c = t->depends; c; c = c->next )
{
/* If we are in a different strongly connected component, pull
* timestamps from the root.
*/
if ( c->target->scc_root )
{
TARGET * const scc_root = target_scc( c->target );
if ( scc_root != t->scc_root )
{
timestamp_max( &c->target->leaf, &c->target->leaf,
&scc_root->leaf );
timestamp_max( &c->target->time, &c->target->time,
&scc_root->time );
c->target->fate = max( c->target->fate, scc_root->fate );
}
}
/* If LEAVES has been applied, we only heed the timestamps of the leaf
* source nodes.
*/
timestamp_max( &leaf, &leaf, &c->target->leaf );
if ( t->flags & T_FLAG_LEAVES )
{
timestamp_copy( &last, &leaf );
continue;
}
timestamp_max( &last, &last, &c->target->time );
fate = max( fate, c->target->fate );
#ifdef OPT_GRAPH_DEBUG_EXT
if ( DEBUG_FATE )
if ( fate < c->target->fate )
out_printf( "fate change %s from %s to %s by dependency %s\n",
object_str( t->name ), target_fate[ (int)fate ],
target_fate[ (int)c->target->fate ], object_str(
c->target->name ) );
#endif
}
/* Step 4b: Pick up included headers time. */
/*
* If a header is newer than a temp source that includes it, the temp source
* will need building.
*/
if ( t->includes )
timestamp_copy( &hlast, &t->includes->time );
else
timestamp_clear( &hlast );
/* Step 4c: handle NOUPDATE oddity.
*
* If a NOUPDATE file exists, mark it as having eternally old dependencies.
* Do not inherit our fate from our dependencies. Decide fate based only on
* other flags and our binding (done later).
*/
if ( t->flags & T_FLAG_NOUPDATE )
{
#ifdef OPT_GRAPH_DEBUG_EXT
if ( DEBUG_FATE )
if ( fate != T_FATE_STABLE )
out_printf( "fate change %s back to stable, NOUPDATE.\n",
object_str( t->name ) );
#endif
timestamp_clear( &last );
timestamp_clear( &t->time );
/* Do not inherit our fate from our dependencies. Decide fate based only
* upon other flags and our binding (done later).
*/
fate = T_FATE_STABLE;
}
/* Step 4d: Determine fate: rebuild target or what? */
/*
In English:
If can not find or make child, can not make target.
If children changed, make target.
If target missing, make it.
If children newer, make target.
If temp's children newer than parent, make temp.
If temp's headers newer than parent, make temp.
If deliberately touched, make it.
If up-to-date temp file present, use it.
If target newer than non-notfile parent, mark target newer.
Otherwise, stable!
Note this block runs from least to most stable: as we make it further
down the list, the target's fate gets more stable.
*/
#ifdef OPT_GRAPH_DEBUG_EXT
savedFate = fate;
oldTimeStamp = 0;
#endif
if ( fate >= T_FATE_BROKEN )
{
fate = T_FATE_CANTMAKE;
}
else if ( fate >= T_FATE_SPOIL )
{
fate = T_FATE_UPDATE;
}
else if ( t->binding == T_BIND_MISSING )
{
fate = T_FATE_MISSING;
}
else if ( t->binding == T_BIND_EXISTS && timestamp_cmp( &last, &t->time ) >
0 )
{
#ifdef OPT_GRAPH_DEBUG_EXT
oldTimeStamp = 1;
#endif
fate = T_FATE_OUTDATED;
}
else if ( t->binding == T_BIND_PARENTS && timestamp_cmp( &last, &p->time ) >
0 )
{
#ifdef OPT_GRAPH_DEBUG_EXT
oldTimeStamp = 1;
#endif
fate = T_FATE_NEEDTMP;
}
else if ( t->binding == T_BIND_PARENTS && timestamp_cmp( &hlast, &p->time )
> 0 )
{
fate = T_FATE_NEEDTMP;
}
else if ( t->flags & T_FLAG_TOUCHED )
{
fate = T_FATE_TOUCHED;
}
else if ( anyhow && !( t->flags & T_FLAG_NOUPDATE ) )
{
fate = T_FATE_TOUCHED;
}
else if ( t->binding == T_BIND_EXISTS && ( t->flags & T_FLAG_TEMP ) )
{
fate = T_FATE_ISTMP;
}
else if ( t->binding == T_BIND_EXISTS && p && p->binding != T_BIND_UNBOUND
&& timestamp_cmp( &t->time, &p->time ) > 0 )
{
#ifdef OPT_GRAPH_DEBUG_EXT
oldTimeStamp = 1;
#endif
fate = T_FATE_NEWER;
}
else
{
fate = T_FATE_STABLE;
}
#ifdef OPT_GRAPH_DEBUG_EXT
if ( DEBUG_FATE && ( fate != savedFate ) )
{
if ( savedFate == T_FATE_STABLE )
out_printf( "fate change %s set to %s%s\n", object_str( t->name ),
target_fate[ fate ], oldTimeStamp ? " (by timestamp)" : "" );
else
out_printf( "fate change %s from %s to %s%s\n", object_str( t->name ),
target_fate[ savedFate ], target_fate[ fate ], oldTimeStamp ?
" (by timestamp)" : "" );
}
#endif
/* Step 4e: Handle missing files. */
/* If it is missing and there are no actions to create it, boom. */
/* If we can not make a target we do not care about it, okay. */
/* We could insist that there are updating actions for all missing */
/* files, but if they have dependencies we just pretend it is a NOTFILE. */
if ( ( fate == T_FATE_MISSING ) && !t->actions && !t->depends )
{
if ( t->flags & T_FLAG_NOCARE )
{
#ifdef OPT_GRAPH_DEBUG_EXT
if ( DEBUG_FATE )
out_printf( "fate change %s to STABLE from %s, "
"no actions, no dependencies and do not care\n",
object_str( t->name ), target_fate[ fate ] );
#endif
fate = T_FATE_STABLE;
}
else
{
out_printf( "don't know how to make %s\n", object_str( t->name ) );
fate = T_FATE_CANTFIND;
}
}
/* Step 4f: Propagate dependencies' time & fate. */
/* Set leaf time to be our time only if this is a leaf. */
timestamp_max( &t->time, &t->time, &last );
timestamp_copy( &t->leaf, timestamp_empty( &leaf ) ? &t->time : &leaf );
/* This target's fate may have been updated by virtue of following some
* target's rebuilds list, so only allow it to be increased to the fate we
* have calculated. Otherwise, grab its new fate.
*/
if ( fate > t->fate )
t->fate = fate;
else
fate = t->fate;
/*
* Step 4g: If this target needs to be built, make0 all targets
* that are updated by the same actions used to update this target.
* These have already been marked as REBUILDS, and make1 has
* special handling for them. We just need to make sure that
* they get make0ed.
*/
if ( ( fate >= T_FATE_BUILD ) && ( fate < T_FATE_BROKEN ) )
{
ACTIONS * a;
TARGETS * c;
for ( a = t->actions; a; a = a->next )
{
for ( c = a->action->targets; c; c = c->next )
{
if ( c->target->fate == T_FATE_INIT )
{
make0( c->target, ptime, depth + 1, counts, anyhow, rescanning );
}
}
}
}
/* Step 4h: If this target needs to be built, force rebuild everything in
* its rebuilds list.
*/
if ( ( fate >= T_FATE_BUILD ) && ( fate < T_FATE_BROKEN ) )
force_rebuilds( t );
/*
* Step 5: Sort dependencies by their update time.
*/
if ( globs.newestfirst )
t->depends = make0sort( t->depends );
/*
* Step 6: A little harmless tabulating for tracing purposes.
*/
/* Do not count or report interal includes nodes. */
if ( t->flags & T_FLAG_INTERNAL )
return;
if ( counts )
{
#ifdef OPT_IMPROVED_PATIENCE_EXT
++counts->targets;
#else
if ( !( ++counts->targets % 1000 ) && DEBUG_MAKE )
{
out_printf( "...patience...\n" );
out_flush();
}
#endif
if ( fate == T_FATE_ISTMP )
++counts->temp;
else if ( fate == T_FATE_CANTFIND )
++counts->cantfind;
else if ( ( fate == T_FATE_CANTMAKE ) && t->actions )
++counts->cantmake;
else if ( ( fate >= T_FATE_BUILD ) && ( fate < T_FATE_BROKEN ) &&
t->actions )
++counts->updating;
}
if ( !( t->flags & T_FLAG_NOTFILE ) && ( fate >= T_FATE_SPOIL ) )
flag = "+";
else if ( t->binding == T_BIND_EXISTS && p && timestamp_cmp( &t->time,
&p->time ) > 0 )
flag = "*";
if ( DEBUG_MAKEPROG )
out_printf( "made%s\t%s\t%s%s\n", flag, target_fate[ (int)t->fate ],
spaces( depth ), object_str( t->name ) );
}
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 CMD * make1cmds( TARGET * t )
{
CMD * cmds = 0;
CMD * last_cmd;
LIST * shell = L0;
module_t * settings_module = 0;
TARGET * settings_target = 0;
ACTIONS * a0;
int const running_flag = globs.noexec ? A_RUNNING_NOEXEC : A_RUNNING;
/* Step through actions.
*/
for ( a0 = t->actions; a0; a0 = a0->next )
{
RULE * rule = a0->action->rule;
rule_actions * actions = rule->actions;
SETTINGS * boundvars;
LIST * nt;
LIST * ns;
ACTIONS * a1;
/* Only do rules with commands to execute.
*/
if ( !actions )
continue;
if ( a0->action->running >= running_flag )
{
CMD * first;
/* If this action was skipped either because it was
* combined with another action by RULE_TOGETHER, or
* because all of its sources were filtered out,
* then we don't have anything to do here.
*/
if ( a0->action->first_cmd == NULL )
continue;
/* This action has already been processed for another target.
* Just set up the dependency graph correctly and move on.
*/
first = a0->action->first_cmd;
if( cmds )
{
last_cmd->next = cmdlist_append_cmd( last_cmd->next, first );
}
else
{
cmds = first;
}
last_cmd = a0->action->last_cmd;
continue;
}
a0->action->running = running_flag;
/* 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.
*/
nt = make1list( L0, a0->action->targets, 0 );
ns = make1list( L0, a0->action->sources, actions->flags );
if ( actions->flags & RULE_TOGETHER )
for ( a1 = a0->next; a1; a1 = a1->next )
if ( a1->action->rule == rule &&
a1->action->running < running_flag &&
targets_equal( a0->action->targets, a1->action->targets ) )
{
ns = make1list( ns, a1->action->sources, actions->flags );
a1->action->running = running_flag;
}
/* If doing only updated (or existing) sources, but none have been
* updated (or exist), skip this action.
*/
if ( list_empty( ns ) &&
( actions->flags & ( RULE_NEWSRCS | RULE_EXISTING ) ) )
{
list_free( nt );
continue;
}
swap_settings( &settings_module, &settings_target, rule->module, t );
if ( list_empty( shell ) )
{
/* shell is per-target */
shell = var_get( rule->module, constant_JAMSHELL );
}
/* If we had 'actions xxx bind vars' we bind the vars now. */
boundvars = make1settings( rule->module, actions->bindlist );
pushsettings( rule->module, boundvars );
/*
* Build command, starting with all source args.
*
* For actions that allow PIECEMEAL commands, if the constructed command
* string is too long, we retry constructing it with a reduced number of
* source arguments presented.
*
* While reducing slowly takes a bit of compute time to get things just
* right, it is worth it to get as close to maximum allowed command
* string length as possible, because launching the commands we are
* executing is likely to be much more compute intensive.
*
* Note that we loop through at least once, for sourceless actions.
*/
{
int const length = list_length( ns );
int start = 0;
int chunk = length;
int cmd_count = 0;
LIST * cmd_targets = L0;
LIST * cmd_shell = L0;
TARGETS * semaphores = NULL;
TARGETS * targets_iter;
int unique_targets;
do
{
CMD * cmd;
int cmd_check_result;
int cmd_error_length;
int cmd_error_max_length;
int retry = 0;
int accept_command = 0;
/* Build cmd: cmd_new() takes ownership of its lists. */
if ( list_empty( cmd_targets ) ) cmd_targets = list_copy( nt );
if ( list_empty( cmd_shell ) ) cmd_shell = list_copy( shell );
cmd = cmd_new( rule, cmd_targets, list_sublist( ns, start,
chunk ), cmd_shell );
cmd_check_result = exec_check( cmd->buf, &cmd->shell,
&cmd_error_length, &cmd_error_max_length );
if ( cmd_check_result == EXEC_CHECK_OK )
{
accept_command = 1;
}
else if ( cmd_check_result == EXEC_CHECK_NOOP )
{
accept_command = 1;
cmd->noop = 1;
}
else if ( ( actions->flags & RULE_PIECEMEAL ) && ( chunk > 1 ) )
{
/* Too long but splittable. Reduce chunk size slowly and
* retry.
*/
assert( cmd_check_result == EXEC_CHECK_TOO_LONG ||
cmd_check_result == EXEC_CHECK_LINE_TOO_LONG );
chunk = chunk * 9 / 10;
retry = 1;
}
else
{
/* Too long and not splittable. */
char const * const error_message = cmd_check_result ==
EXEC_CHECK_TOO_LONG
? "is too long"
: "contains a line that is too long";
assert( cmd_check_result == EXEC_CHECK_TOO_LONG ||
cmd_check_result == EXEC_CHECK_LINE_TOO_LONG );
printf( "%s action %s (%d, max %d):\n", object_str(
rule->name ), error_message, cmd_error_length,
cmd_error_max_length );
/* Tell the user what did not fit. */
fputs( cmd->buf->value, stdout );
exit( EXITBAD );
}
assert( !retry || !accept_command );
if ( accept_command )
{
/* Chain it up. */
if ( cmds )
{
last_cmd->next = cmdlist_append_cmd( last_cmd->next, cmd );
last_cmd = cmd;
}
else
{
cmds = last_cmd = cmd;
}
if ( cmd_count++ == 0 )
{
a0->action->first_cmd = cmd;
}
/* Mark lists we need recreated for the next command since
* they got consumed by the cmd object.
*/
cmd_targets = L0;
cmd_shell = L0;
}
else
{
/* We can reuse targets & shell lists for the next command
* if we do not let them die with this cmd object.
*/
cmd_release_targets_and_shell( cmd );
cmd_free( cmd );
}
if ( !retry )
start += chunk;
}
while ( start < length );
/* Record the end of the actions cmds */
a0->action->last_cmd = last_cmd;
unique_targets = 0;
for ( targets_iter = a0->action->targets; targets_iter; targets_iter = targets_iter->next )
{
if ( targets_contains( targets_iter->next, targets_iter->target ) )
continue;
/* Add all targets produced by the action to the update list. */
push_state( &state_stack, targets_iter->target, NULL, T_STATE_MAKE1A );
++unique_targets;
}
/* We need to wait until all the targets agree that
* it's okay to run this action.
*/
( ( CMD * )a0->action->first_cmd )->asynccnt = unique_targets;
#if OPT_SEMAPHORE
/* Collect semaphores */
for ( targets_iter = a0->action->targets; targets_iter; targets_iter = targets_iter->next )
{
TARGET * sem = targets_iter->target->semaphore;
if ( sem )
{
TARGETS * semiter;
if ( ! targets_contains( semaphores, sem ) )
semaphores = targetentry( semaphores, sem );
}
}
( ( CMD * )a0->action->first_cmd )->lock = semaphores;
( ( CMD * )a0->action->last_cmd )->unlock = semaphores;
#endif
}
/* These were always copied when used. */
list_free( nt );
list_free( ns );
/* Free variables with values bound by 'actions xxx bind vars'. */
popsettings( rule->module, boundvars );
freesettings( boundvars );
}
if ( cmds )
{
last_cmd->next = cmdlist_append_target( last_cmd->next, t );
}
swap_settings( &settings_module, &settings_target, 0, 0 );
return cmds;
}
