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; }
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 * * 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 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; }