mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-15 22:20:12 +00:00
527 lines
13 KiB
C
527 lines
13 KiB
C
/*
|
|
* Copyright 1993, 1995 Christopher Seiwald.
|
|
*
|
|
* This file is part of Jam - see jam.c for Copyright information.
|
|
*/
|
|
|
|
/*
|
|
* make.c - bring a target up to date, once rules are in place
|
|
*
|
|
* This modules controls the execution of rules to bring a target and
|
|
* its dependencies up to date. It is invoked after the targets, rules,
|
|
* et. al. described in rules.h are created by the interpreting of the
|
|
* jam files.
|
|
*
|
|
* This file contains the main make() entry point and the first pass
|
|
* make0(). The second pass, make1(), which actually does the command
|
|
* execution, is in make1.c.
|
|
*
|
|
* External routines:
|
|
* make() - make a target, given its name
|
|
*
|
|
* Internal routines:
|
|
* make0() - bind and scan everything to make a TARGET
|
|
* make0sort() - reorder TARGETS chain by their time (newest to oldest)
|
|
*
|
|
* 12/26/93 (seiwald) - allow NOTIME targets to be expanded via $(<), $(>)
|
|
* 01/04/94 (seiwald) - print all targets, bounded, when tracing commands
|
|
* 04/08/94 (seiwald) - progress report now reflects only targets with actions
|
|
* 04/11/94 (seiwald) - Combined deps & headers into deps[2] in TARGET.
|
|
* 12/20/94 (seiwald) - NOTIME renamed NOTFILE.
|
|
* 12/20/94 (seiwald) - make0() headers after determining fate of target, so
|
|
* that headers aren't seen as dependents on themselves.
|
|
* 01/19/95 (seiwald) - distinguish between CANTFIND/CANTMAKE targets.
|
|
* 02/02/95 (seiwald) - propagate leaf source time for new LEAVES rule.
|
|
* 02/14/95 (seiwald) - NOUPDATE rule means don't update existing target.
|
|
* 08/22/95 (seiwald) - NOUPDATE targets immune to anyhow (-a) flag.
|
|
* 09/06/00 (seiwald) - NOCARE affects targets with sources/actions.
|
|
* 03/02/01 (seiwald) - reverse NOCARE change.
|
|
* 03/14/02 (seiwald) - TEMPORARY targets no longer take on parents age
|
|
* 03/16/02 (seiwald) - support for -g (reorder builds by source time)
|
|
* 07/17/02 (seiwald) - TEMPORARY sources for headers now get built
|
|
* 09/19/02 (seiwald) - new -d displays
|
|
* 09/23/02 (seiwald) - suppress "...using temp..." in default output
|
|
* 09/28/02 (seiwald) - make0() takes parent pointer; new -dc display
|
|
* 11/04/02 (seiwald) - const-ing for string literals
|
|
* 12/03/02 (seiwald) - fix odd includes support by grafting them onto depends
|
|
* 12/17/02 (seiwald) - new copysettings() to protect target-specific vars
|
|
* 01/03/03 (seiwald) - T_FATE_NEWER once again gets set with missing parent
|
|
* 01/14/03 (seiwald) - fix includes fix with new internal includes TARGET
|
|
* 04/04/03 (seiwald) - fix INTERNAL node binding to avoid T_BIND_PARENTS
|
|
*/
|
|
|
|
# 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 "headers.h"
|
|
# include "command.h"
|
|
|
|
# ifndef max
|
|
# define max( a,b ) ((a)>(b)?(a):(b))
|
|
# endif
|
|
|
|
typedef struct {
|
|
int temp;
|
|
int updating;
|
|
int cantfind;
|
|
int cantmake;
|
|
int targets;
|
|
int made;
|
|
} COUNTS ;
|
|
|
|
static void make0( TARGET *t, TARGET *p, int depth,
|
|
COUNTS *counts, int anyhow );
|
|
|
|
static TARGETS *make0sort( TARGETS *c );
|
|
|
|
static const char *target_fate[] =
|
|
{
|
|
"init", /* T_FATE_INIT */
|
|
"making", /* T_FATE_MAKING */
|
|
"stable", /* T_FATE_STABLE */
|
|
"newer", /* T_FATE_NEWER */
|
|
"temp", /* T_FATE_ISTMP */
|
|
"touched", /* T_FATE_TOUCHED */
|
|
"missing", /* T_FATE_MISSING */
|
|
"needtmp", /* T_FATE_NEEDTMP */
|
|
"old", /* T_FATE_OUTDATED */
|
|
"update", /* T_FATE_UPDATE */
|
|
"nofind", /* T_FATE_CANTFIND */
|
|
"nomake" /* T_FATE_CANTMAKE */
|
|
} ;
|
|
|
|
static const char *target_bind[] =
|
|
{
|
|
"unbound",
|
|
"missing",
|
|
"parents",
|
|
"exists",
|
|
} ;
|
|
|
|
# define spaces(x) ( " " + 16 - ( x > 16 ? 16 : x ) )
|
|
|
|
/*
|
|
* make() - make a target, given its name
|
|
*/
|
|
|
|
int
|
|
make(
|
|
int n_targets,
|
|
const char **targets,
|
|
int anyhow )
|
|
{
|
|
int i;
|
|
COUNTS counts[1];
|
|
int status = 0; /* 1 if anything fails */
|
|
|
|
memset( (char *)counts, 0, sizeof( *counts ) );
|
|
|
|
for( i = 0; i < n_targets; i++ )
|
|
{
|
|
TARGET *t = bindtarget( targets[i] );
|
|
|
|
make0( t, 0, 0, counts, anyhow );
|
|
}
|
|
|
|
if( DEBUG_MAKE )
|
|
{
|
|
if( counts->targets )
|
|
printf( "...found %d target(s)...\n", counts->targets );
|
|
if( counts->temp )
|
|
printf( "...using %d temp target(s)...\n", counts->temp );
|
|
if( counts->updating )
|
|
printf( "...updating %d target(s)...\n", counts->updating );
|
|
if( counts->cantfind )
|
|
printf( "...can't find %d target(s)...\n", counts->cantfind );
|
|
if( counts->cantmake )
|
|
printf( "...can't make %d target(s)...\n", counts->cantmake );
|
|
}
|
|
|
|
status = counts->cantfind || counts->cantmake;
|
|
|
|
for( i = 0; i < n_targets; i++ )
|
|
status |= make1( bindtarget( targets[i] ) );
|
|
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* make0() - bind and scan everything to make a TARGET
|
|
*
|
|
* Make0() recursively binds a target, searches for #included headers,
|
|
* calls itself on those headers, and calls itself on any dependents.
|
|
*/
|
|
|
|
static 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;
|
|
|
|
/*
|
|
* 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 ) )
|
|
{
|
|
t->boundname = search( t->name, &t->time );
|
|
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;
|
|
}
|
|
|
|
/* 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_MAKEPROG )
|
|
{
|
|
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;
|
|
|
|
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 );
|
|
}
|
|
|
|
/* 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 )
|
|
{
|
|
last = 0;
|
|
t->time = 0;
|
|
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.
|
|
*/
|
|
|
|
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 )
|
|
{
|
|
fate = T_FATE_OUTDATED;
|
|
}
|
|
else if( t->binding == T_BIND_PARENTS && last > p->time )
|
|
{
|
|
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 )
|
|
{
|
|
fate = T_FATE_NEWER;
|
|
}
|
|
else
|
|
{
|
|
fate = T_FATE_STABLE;
|
|
}
|
|
|
|
/* 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 )
|
|
{
|
|
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 ;
|
|
t->fate = fate;
|
|
|
|
/*
|
|
* 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->targets % 1000 ) && DEBUG_MAKE )
|
|
printf( "...patience...\n" );
|
|
|
|
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 );
|
|
|
|
if( DEBUG_CAUSES &&
|
|
t->fate >= T_FATE_NEWER &&
|
|
t->fate <= T_FATE_MISSING )
|
|
printf( "%s %s\n", target_fate[ t->fate ], t->name );
|
|
}
|
|
|
|
/*
|
|
* make0sort() - reorder TARGETS chain by their time (newest to oldest)
|
|
*/
|
|
|
|
static TARGETS *
|
|
make0sort( TARGETS *chain )
|
|
{
|
|
TARGETS *result = 0;
|
|
|
|
/* We walk chain, taking each item and inserting it on the */
|
|
/* sorted result, with newest items at the front. This involves */
|
|
/* updating each TARGETS' c->next and c->tail. Note that we */
|
|
/* make c->tail a valid prev pointer for every entry. Normally, */
|
|
/* it is only valid at the head, where prev == tail. Note also */
|
|
/* that while tail is a loop, next ends at the end of the chain. */
|
|
|
|
/* Walk current target list */
|
|
|
|
while( chain )
|
|
{
|
|
TARGETS *c = chain;
|
|
TARGETS *s = result;
|
|
|
|
chain = chain->next;
|
|
|
|
/* Find point s in result for c */
|
|
|
|
while( s && s->target->time > c->target->time )
|
|
s = s->next;
|
|
|
|
/* Insert c in front of s (might be 0). */
|
|
/* Don't even think of deciphering this. */
|
|
|
|
c->next = s; /* good even if s = 0 */
|
|
if( result == s ) result = c; /* new head of chain? */
|
|
if( !s ) s = result; /* wrap to ensure a next */
|
|
if( result != c ) s->tail->next = c; /* not head? be prev's next */
|
|
c->tail = s->tail; /* take on next's prev */
|
|
s->tail = c; /* make next's prev us */
|
|
}
|
|
|
|
return result;
|
|
}
|