/* * Copyright 1993, 1995 Christopher Seiwald. * * This file is part of Jam - see jam.c for Copyright information. */ /* * make1.c - execute command to bring targets up to date * * This module contains make1(), the entry point called by make() to * recursively decend the dependency graph executing update actions as * marked by make0(). * * External routines: * * make1() - execute commands to update a TARGET and all its dependents * * Internal routines, the recursive/asynchronous command executors: * * make1a() - recursively traverse target tree, calling make1b() * make1b() - dependents of target built, now build target with make1c() * make1c() - launch target's next command, call make1b() when done * make1d() - handle command execution completion and call back make1c() * * Internal support routines: * * make1cmds() - turn ACTIONS into CMDs, grouping, splitting, etc * make1chunk() - compute number of source that can fit on cmd line * make1list() - turn a list of targets into a LIST, for $(<) and $(>) * make1settings() - for vars that get bound values, build up replacement lists * make1bind() - bind targets that weren't bound in dependency analysis * * 04/16/94 (seiwald) - Split from make.c. * 04/21/94 (seiwald) - Handle empty "updated" actions. * 05/04/94 (seiwald) - async multiprocess (-j) support * 06/01/94 (seiwald) - new 'actions existing' does existing sources * 12/20/94 (seiwald) - NOTIME renamed NOTFILE. * 01/19/95 (seiwald) - distinguish between CANTFIND/CANTMAKE targets. * 01/22/94 (seiwald) - pass per-target JAMSHELL down to execcmd(). * 02/28/95 (seiwald) - Handle empty "existing" actions. * 03/10/95 (seiwald) - Fancy counts. */ # include "jam.h" # include "lists.h" # include "parse.h" # include "variable.h" # include "rules.h" # include "search.h" # include "newstr.h" # include "make.h" # include "command.h" # include "execcmd.h" static void make1a(); static void make1b(); static void make1c(); static void make1d(); static CMD *make1cmds(); static int make1chunk(); static LIST *make1list(); static SETTINGS *make1settings(); static void make1bind(); #ifdef OPT_SERIAL_OUTPUT_EXT static int verifyIsRealOutput (char *input, int len); #endif /* Ugly static - it's too hard to carry it through the callbacks. */ static struct { int failed; int skipped; int total; int made; } counts[1] ; /* * make1() - execute commands to update a TARGET and all its dependents */ static int intr = 0; int make1( t ) TARGET *t; { memset( (char *)counts, 0, sizeof( *counts ) ); /* CWM */ exec_init(); /* Recursively make the target and its dependents */ make1a( t, (TARGET *)0 ); /* Wait for any outstanding commands to finish running. */ while( execwait() ) ; /* CWM */ exec_done(); /* Talk about it */ if( DEBUG_MAKE && counts->failed ) printf( "...failed updating %d target(s)...\n", counts->failed ); if( DEBUG_MAKE && counts->skipped ) printf( "...skipped %d target(s)...\n", counts->skipped ); if( DEBUG_MAKE && counts->made ) printf( "...updated %d target(s)...\n", counts->made ); return counts->total != counts->made; } /* * make1a() - recursively traverse target tree, calling make1b() */ static void make1a( t, parent ) TARGET *t; TARGET *parent; { TARGETS *c; int i; /* If the parent is the first to try to build this target */ /* or this target is in the make1c() quagmire, arrange for the */ /* parent to be notified when this target is built. */ #ifdef OPT_OUTPUT_MOD_EXT if( DEBUG_EXECCMD ) printf( "Make1a (descend): %s\n", t->name ); #endif if( parent ) switch( t->progress ) { case T_MAKE_INIT: case T_MAKE_ACTIVE: case T_MAKE_RUNNING: t->parents = targetentry( t->parents, parent ); parent->asynccnt++; } if( t->progress != T_MAKE_INIT ) return; /* Asynccnt counts the dependents preventing this target from */ /* proceeding to make1b() for actual building. We start off with */ /* a count of 1 to prevent anything from happening until we can */ /* call all dependents. This 1 is accounted for when we call */ /* make1b() ourselves, below. */ t->asynccnt = 1; /* Recurse on our dependents, manipulating progress to guard */ /* against circular dependency. */ t->progress = T_MAKE_ONSTACK; for( i = T_DEPS_DEPENDS; i <= T_DEPS_INCLUDES; i++ ) for( c = t->deps[i]; c && !intr; c = c->next ) make1a( c->target, t ); t->progress = T_MAKE_ACTIVE; /* Now that all dependents have bumped asynccnt, we now allow */ /* decrement our reference to asynccnt. */ make1b( t ); } /* * make1b() - dependents of target built, now build target with make1c() */ static void make1b( t ) TARGET *t; { TARGETS *c; int i; char *failed = "dependents"; /* If any dependents are still outstanding, wait until they */ /* call make1b() to signal their completion. */ #ifdef OPT_OUTPUT_MOD_EXT if( DEBUG_EXECCMD ) printf( "Make1b ( notify): %s (count: %d)\n", t->name, t->asynccnt ); #endif if( --t->asynccnt ) return; /* Now ready to build target 't'... if dependents built ok. */ /* Collect status from dependents */ for( i = T_DEPS_DEPENDS; i <= T_DEPS_INCLUDES; i++ ) for( c = t->deps[i]; c; c = c->next ) if( c->target->status > t->status ) { failed = c->target->name; t->status = c->target->status; } #ifdef OPT_NOCARE_NODES_EXT /* If actions on deps have failed, but if this is a 'nocare' target */ /* then continue anyway. CWM */ if( t->flags & T_FLAG_NOCARE && t->status == EXEC_CMD_FAIL ) { printf( "...dependency on %s failed, but don't care...\n", t->name ); t->status = EXEC_CMD_OK ; } #endif /* If actions on deps have failed, bail. */ /* Otherwise, execute all actions to make target */ if( t->status == EXEC_CMD_FAIL && t->actions ) { ++counts->skipped; printf( "...skipped %s for lack of %s...\n", t->name, failed ); } if( t->status == EXEC_CMD_OK ) switch( t->fate ) { case T_FATE_INIT: case T_FATE_MAKING: /* shouldn't happen */ case T_FATE_STABLE: case T_FATE_NEWER: break; case T_FATE_CANTFIND: case T_FATE_CANTMAKE: t->status = EXEC_CMD_FAIL; break; case T_FATE_ISTMP: #ifndef OPT_LARGE_BUILD_EXT if( DEBUG_MAKE ) printf( "...using %s...\n", t->name ); # endif break; case T_FATE_TOUCHED: case T_FATE_MISSING: case T_FATE_OUTDATED: case T_FATE_UPDATE: /* Set "on target" vars, build actions, unset vars */ /* Set "progress" so that make1c() counts this target among */ /* the successes/failures. */ if( t->actions ) { #ifndef OPT_TIME_STAMP_OUTPUT_EXT if( DEBUG_MAKE && !( ++counts->total % 100 ) ) printf( "...on %dth target...\n", counts->total ); #else { time_t clock; if( DEBUG_MAKE && !( ++counts->total % 100 ) ) { time( &clock ); printf( "...on %dth target...%s", counts->total, ctime( &clock )); } } #endif pushsettings( t->settings ); t->cmds = (char *)make1cmds( t->actions ); popsettings( t->settings ); t->progress = T_MAKE_RUNNING; } break; } /* Call make1c() to begin the execution of the chain of commands */ /* needed to build target. If we're not going to build target */ /* (because of dependency failures or because no commands need to */ /* be run) the chain will be empty and make1c() will directly */ /* signal the completion of target. */ make1c( t ); } /* * make1c() - launch target's next command, call make1b() when done */ static void make1c( t ) TARGET *t; { CMD *cmd = (CMD *)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. */ #ifdef OPT_OUTPUT_MOD_EXT if( DEBUG_EXECCMD ) printf( "Make1c ( exec): %s\n", t->name); #endif if( cmd && t->status == EXEC_CMD_OK ) { #ifndef OPT_SERIAL_OUTPUT_EXT if( DEBUG_MAKE ) if( DEBUG_MAKEQ || ! ( cmd->rule->flags & RULE_QUIETLY ) ) { /* CWM - added '@' to front of output */ printf( "@ %s ", cmd->rule->name ); list_print( lol_get( &cmd->args, 0 ) ); printf( "\n" ); } if( DEBUG_EXEC ) printf( "%s\n", cmd->buf ); # endif if( globs.noexec ) { #ifndef OPT_SERIAL_OUTPUT_EXT make1d( t, EXEC_CMD_OK ); #else make1d( t, EXEC_CMD_OK, 0 ); #endif } else { fflush( stdout ); execcmd( cmd->buf, make1d, t, cmd->shell ); } } else { TARGETS *c; 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 dependent has been built */ t->progress = T_MAKE_DONE; for( c = t->parents; c; c = c->next ) make1b( c->target ); } } /* * make1d() - handle command execution completion and call back make1c() */ static void #ifndef OPT_SERIAL_OUTPUT_EXT make1d( t, status ) TARGET *t; int status; #else make1d( t, status, outputname ) TARGET *t; int status; char *outputname; #endif { CMD *cmd = (CMD *)t->cmds; #ifdef OPT_OUTPUT_MOD_EXT if( DEBUG_EXECCMD ) printf( "Make1d ( done): %s\n", t->name); #endif /* Execcmd() has completed. All we need to do is fiddle with the */ /* status and signal our completion so make1c() can run the next */ /* command. On interrupts, we bail heavily. */ if( status == EXEC_CMD_FAIL && ( cmd->rule->flags & RULE_IGNORE ) ) status = EXEC_CMD_OK; /* On interrupt, set intr so _everything_ fails */ if( status == EXEC_CMD_INTR ) ++intr; #ifndef OPT_SERIAL_OUTPUT_EXT if( status == EXEC_CMD_FAIL && DEBUG_MAKE ) { /* Print command text on failure */ if( !DEBUG_EXEC ) printf( "%s\n", cmd->buf ); printf( "...failed %s ", cmd->rule->name ); list_print( lol_get( &cmd->args, 0 ) ); printf( "...\n" ); } # else { int printedBuf = 0; if( DEBUG_MAKE ) if( DEBUG_MAKEQ || ! ( cmd->rule->flags & RULE_QUIETLY ) ) { /* CWM - Added '@' to front of output */ printf( "@ %s ", cmd->rule->name ); list_print( lol_get( &cmd->args, 0 ) ); printf( "\n" ); } if( DEBUG_EXEC || (status == EXEC_CMD_FAIL && DEBUG_MAKE) ) { printf( "%s\n", cmd->buf ); printedBuf = 1; } if( outputname ) { struct stat statbuf; FILE *fp; int n; char buf[4096]; /* Print output buffer contents if it contains anything */ if( stat( outputname, &statbuf ) == 0 ) { if( statbuf.st_size ) { fp = fopen( outputname, "r" ); if (fp) { n=fread (buf, sizeof(char), sizeof buf, fp); #if defined( NT ) if (verifyIsRealOutput (buf, n)) #endif { /* If there is output, print the rule */ if( !printedBuf ) printf( "%s\n", cmd->buf ); fwrite (buf, sizeof(char), n, stdout); n=fread (buf, sizeof(char), sizeof buf, fp); while (n > 0) { fwrite (buf, sizeof(char), n, stdout); n=fread (buf, sizeof(char), sizeof buf, fp); } } fclose (fp); } } } } } if( status == EXEC_CMD_FAIL && DEBUG_MAKE ) { printf( "...failed %s ", cmd->rule->name ); list_print( lol_get( &cmd->args, 0 ) ); printf( "...\n" ); } # endif /* If the command was interrupted or failed and the target */ /* is not "precious", remove the targets */ if( status != EXEC_CMD_OK && !( cmd->rule->flags & RULE_TOGETHER ) ) { LIST *targets = lol_get( &cmd->args, 0 ); for( ; targets; targets = list_next( targets ) ) if( !unlink( targets->string ) ) printf( "...removing %s\n", targets->string ); } /* Free this command and call make1c() to move onto next command. */ t->status = status; t->cmds = (char *)cmd_next( cmd ); cmd_free( cmd ); make1c( t ); } /* * make1cmds() - turn ACTIONS into CMDs, grouping, splitting, etc * * Essentially copies a chain of ACTIONs to a chain of CMDs, * grouping RULE_TOGETHER actions, splitting RULE_PIECEMEAL actions, * and handling RULE_NEWSRCS actions. The result is a chain of * CMDs which can be expanded by var_string() and executed with * execcmd(). */ static CMD * make1cmds( a0 ) ACTIONS *a0; { 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; int chunk = 0; LIST *nt, *ns; ACTIONS *a1; /* Only do rules with commands to execute. */ /* If this action has already been executed, use saved status */ if( !rule->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, rule->flags ); if( rule->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, rule->flags ); a1->action->running = 1; } /* If doing only updated (or existing) sources, but none have */ /* been updated (or exist), skip this action. */ if( !ns && ( rule->flags & ( RULE_NEWSRCS | RULE_EXISTING ) ) ) { list_free( nt ); continue; } /* If we had 'actions xxx bind vars' we bind the vars now */ boundvars = make1settings( rule->bindlist ); pushsettings( boundvars ); /* If rule is to be cut into (at most) MAXLINE pieces, estimate */ /* bytes per $(>) element and aim for using MAXLINE minus a */ /* fudgefactor. */ if( rule->flags & RULE_PIECEMEAL ) chunk = make1chunk( rule->actions, nt, ns ); /* Either cut the actions into pieces, or do it whole. */ if( chunk < 0 ) { printf( "fatal error: %s command line too long (max %d)\n", rule->name, MAXLINE ); exit( EXITBAD ); } if( chunk ) { int start; LIST *somes; if( DEBUG_EXECCMD ) printf( "%s: %d args per exec\n", rule->name, chunk ); for( start = 0; somes = list_sublist( ns, start, chunk ); start += chunk ) { cmds = cmd_new( cmds, rule, list_copy( L0, nt ), somes, list_copy( L0, shell ) ); } list_free( nt ); list_free( ns ); } else { cmds = cmd_new( cmds, rule, nt, ns, list_copy( L0, shell ) ); } /* Free the variables whose values were bound by */ /* 'actions xxx bind vars' */ popsettings( boundvars ); freesettings( boundvars ); } return cmds; } /* * make1chunk() - compute number of source that can fit on cmd line */ static int make1chunk( cmd, targets, sources ) char *cmd; LIST *targets; LIST *sources; { int onesize; int twosize; int chunk = 0; char buf[ MAXLINE ]; LOL lol; /* XXX -- egregious manipulation of lol */ /* a) we set items directly, b) we don't free it */ lol_init( &lol ); lol.count = 2; lol.list[0] = targets; lol.list[1] = list_sublist( sources, 0, 1 ); onesize = var_string( cmd, buf, MAXLINE, &lol ); list_free( lol.list[1] ); if( onesize < 0 ) return -1; lol.list[1] = list_sublist( sources, 0, 2 ); twosize = var_string( cmd, buf, MAXLINE, &lol ); list_free( lol.list[1] ); if( twosize < 0 ) return -1; if( twosize > onesize ) chunk = 3 * ( MAXLINE - onesize ) / 5 / ( twosize - onesize ) + 1; return chunk; } /* * make1list() - turn a list of targets into a LIST, for $(<) and $(>) */ static LIST * make1list( l, targets, flags ) LIST *l; TARGETS *targets; int flags; { for( ; targets; targets = targets->next ) { TARGET *t = targets->target; /* Sources to 'actions existing' are never in the dependency */ /* graph (if they were, they'd get built and 'existing' would */ /* be superfluous, so throttle warning message about independent */ /* targets. */ if( t->binding == T_BIND_UNBOUND ) make1bind( t, !( flags & RULE_EXISTING ) ); if( ( flags & RULE_EXISTING ) && t->binding != T_BIND_EXISTS ) continue; if( ( flags & RULE_NEWSRCS ) && t->fate <= T_FATE_STABLE ) continue; /* Prohibit duplicates for RULE_TOGETHER */ if( flags & RULE_TOGETHER ) { LIST *m; for( m = l; m; m = m->next ) if( !strcmp( m->string, t->boundname ) ) break; if( m ) continue; } /* Build new list */ l = list_new( l, copystr( t->boundname ) ); } return l; } /* * make1settings() - for vars that get bound values, build up replacement lists */ static SETTINGS * make1settings( vars ) LIST *vars; { SETTINGS *settings = 0; for( ; vars; vars = list_next( vars ) ) { LIST *l = var_get( vars->string ); LIST *nl = 0; for( ; l; l = list_next( l ) ) { TARGET *t = bindtarget( l->string ); /* Make sure the target is bound, warning if it is not in the */ /* dependency graph. */ if( t->binding == T_BIND_UNBOUND ) make1bind( t, 1 ); /* Build new list */ nl = list_new( nl, copystr( t->boundname ) ); } /* Add to settings chain */ settings = addsettings( settings, 0, vars->string, nl ); } return settings; } /* * make1bind() - bind targets that weren't bound in dependency analysis * * Spot the kludge! If a target is not in the dependency tree, it didn't * get bound by make0(), so we have to do it here. Ugly. */ static void make1bind( t, warn ) TARGET *t; int warn; { if( t->flags & T_FLAG_NOTFILE ) return; /* 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( warn ) printf( "warning: using independent target %s\n", t->name ); pushsettings( t->settings ); t->boundname = search( t->name, &t->time ); t->binding = t->time ? T_BIND_EXISTS : T_BIND_MISSING; popsettings( t->settings ); } #if defined( NT ) && defined ( OPT_SERIAL_OUTPUT_EXT ) /* * Detect real output from MS compilers. They *always* output a single word * which is the file name being compiled. If that's all there is, ignore * it. * * This is a pretty weak heuristic, but it seems to work well enough. */ static int verifyIsRealOutput(input, len) char *input; int len; { int n = 0, d = 0, i; for (i = 0; i < len; ++i) { switch (input[i]) { case ' ': return 1; case '\t': return 1; case '\n': if (++n > 1) return 1; break; case '.': if (++d > 1) return 1; break; } } /* There must be exactly one newline and one dot. */ if (n == 1 && d == 1) return 0; /* Assume its real. */ return 1; } #endif
# | Change | User | Description | Committed | |
---|---|---|---|---|---|
#12 | 4110 | Craig Mcpheeters | Some of my changes from work. | ||
#11 | 3183 | Craig Mcpheeters | Integration of my jam mainline branch into my work branch. | ||
#10 | 3182 | Craig Mcpheeters | Update of my work branch. | ||
#9 | 1664 | Craig Mcpheeters | A new extension - semaphores | ||
#8 | 1606 | Craig Mcpheeters |
Integration from my modified jam mainline. This is all the mainline changes into my work branch. |
||
#7 | 1477 | Craig Mcpheeters |
Integration from my main jam branch. This is 2.4-dev with my extensions. |
||
#6 | 1188 | Craig Mcpheeters |
The latest updates from my A|W work copy. Added a -d11 debug mode, which outputs information on fate changes Create jam variables to show job (-jn) information, such as the number of jobs requested, whether or not there is more than one job, and a list of the job slot numbers. These can be used in a variety of ways in supporting multi-job builds Added jobs slot expansion to the action blocks, the sequence !! is replaced by the job slot the action is running in. Modified the special shell handling to include unix. It used to be that on Unix, you could create an action block which exceeded the size that execvp() could handle (perhaps only when the DynamicCommandSize option is enabled.) On NT, all non-default shells are invoked through a intermediate file. This modification does the same for unix shells. Improved the -d+10 debug level, the dependency graph. It now shows the flags on the node as well (NOUPDATE, NOTFILE, etc.) Only issue the '...skipped' messages for nodes which would have been built |
||
#5 | 1102 | Craig Mcpheeters | A tweak | ||
#4 | 1100 | Craig Mcpheeters |
Added a percent-done extension Converted the hcache file to ansi, as the rest of Jam was updated in 2.3 |
||
#3 | 785 | Craig Mcpheeters |
Integration from //guest/craig_mcpheeters/jam/src/... This work area now contains both the Alias|Wavefront changes, and the latest integrations from the mainline. There are some changes in this area which shouldn't be merged back into the mainline. As I merge this branch back into my jam/src/... branch, I'll leave out a few of the changes. |
||
#2 | 782 | Craig Mcpheeters |
Initial return of the Alias|Wavefront mods to jam 2.2. I made a stab at a configuration system - see the file Jamfile.config. Most of the mods are now enclosed within #ifdef blocks, which kind of pollutes the code, but may make it easier to accept or reject some of these changes. Some of these #ifdefs could disappear completely if they are accepted into the mainline This return implements the following extensions: * header cache * dynamic command block size, allowing for *large* commands * slightly improved warnings and errors * serial output from jam - nice when working with multiple jobs * an extension to variable modifiers: $(>:/) and $(>:\\) * ability to ignore header dependencies for a build (jam -p) * new debug level, -d+10, which outputs the dependency graph * added no-care support to internal nodes. if they fail, dependents are built anyway * time stamps on output * a few minor output modifications * a fix for nt batch file names conflicing when more than one jam runs at a time Each of the above can be enabled/disabled on the command line. For example, to turn on the HeaderCache code: jam -sHeaderCache=1 that is, build jam first, then use that jam to build a new one with the options you want. Some of these changes may have been made in the mainline already, my next step will be to integrate the mainline changes into these ones This return isn't yet ready for prime-time |
||
#1 | 777 | Craig Mcpheeters |
Branch of my jam/src/... area. This new area establishes the integration base for the copy of Jam which has all the changes. |
||
//guest/craig_mcpheeters/jam/src/make1.c | |||||
#2 | 617 | Craig Mcpheeters | Integration from mainline as of @3 | ||
#1 | 616 | Craig Mcpheeters | Integration from Jam mainline, as of @2 |