const char *DoWildCard( const char *base )
/***********************************************/
{
PGROUP pg;
struct dirent *entry;
if( base != NULL ) {
/* clean up from previous invocation */
DoWildCardClose();
if( strpbrk( base, WILD_METAS ) == NULL ) {
return( base );
}
// create directory name and pattern
path = MallocSafe( _MAX_PATH );
pattern = MallocSafe( _MAX_PATH );
strcpy( path, base );
FixName( path );
_splitpath2( path, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
_makepath( path, pg.drive, pg.dir, ".", NULL );
// create file name pattern
_makepath( pattern, NULL, NULL, pg.fname, pg.ext );
parent = opendir( path );
if( parent == NULL ) {
DoWildCardClose();
return( base );
}
}
if( parent == NULL ) {
return( NULL );
}
assert( path != NULL && parent != NULL );
while( (entry = readdir( parent )) != NULL ) {
#ifndef __UNIX__
if( ( entry->d_attr & IGNORE_MASK ) == 0 ) {
#endif
if( __fnmatch( pattern, entry->d_name ) ) {
break;
}
#ifndef __UNIX__
}
#endif
}
if( entry == NULL ) {
DoWildCardClose();
return( base );
}
_splitpath2( path, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
_makepath( path, pg.drive, pg.dir, entry->d_name, NULL );
return( path );
}
STATIC char *getDirBuf( void )
/****************************/
{
if( dirBuf == NULL ) {
dirBuf = MallocSafe( _MAX_PATH );
}
return( dirBuf );
}
void OSLoadDLL( char *cmd_name, char *dll_name, char *ent_name )
/**************************************************************/
{
DLL_CMD *n;
// we want newer !loaddlls to take precedence
n = MallocSafe( sizeof( *n ) );
n->cmd_name = StrDupSafe( cmd_name );
n->next = dllCommandList;
dllCommandList = n;
IdeDrvInit( &n->inf, StrDupSafe( dll_name ),
(ent_name == NULL) ? NULL : StrDupSafe( ent_name ) );
}
STATIC void pushFH( SENT *sent, int fh )
/***************************************
* given an open file handle, this routine allocates a buffer, and pushes a
* SENT onto the stack
*/
{
assert( sent != NULL );
sent->data.file.fh = fh;
sent->data.file.buf = MallocSafe( FILE_BUFFER_SIZE );
sent->data.file.cur = sent->data.file.buf;
sent->data.file.max = sent->data.file.buf;
sent->data.file.line = 1;
sent->data.file.nestLevel = -1;
}
STATIC SENT *getSENT( STYPE_T type )
/***********************************
* get a free sent, and push it into stack. Determines next char of input.
*/
{
SENT *d;
if( freeSent != NULL ) { /* check if any free SENTs lying around */
d = freeSent;
freeSent = freeSent->next;
} else {
d = MallocSafe( sizeof( *d ) );
}
d->type = type;
d->next = headSent;
headSent = d;
return( d );
}
void StreamInit( void )
/****************************/
{
int count;
SENT *sent;
/* preallocate storage to speed things up, and reduce fragmentation */
freeSent = NULL;
for( count = 0; count < STREAM_ALLOC_SENT; count++ ) {
sent = MallocSafe( sizeof( *sent ) );
sent->next = freeSent;
freeSent = sent;
}
#ifdef USE_SCARCE
IfMemScarce( streamScarce );
#endif
}
STATIC RET_T imply( TARGET *targ, const char *drive, const char *dir,
const char *fname, const char *ext, bool must )
/********************************************************************
* targ is the target to be implied
* drive is the drive of the target
* dir is the path of the target
* fname is the portion of targ's name without the extension
* ext is the extension of targ's name
* must must we make this target?
*
* RET_SUCCESS - performed cmds,
* RET_WARN unable to imply,
* RET_ERROR - perform failed
*/
{
SUFFIX *srcsuf;
CREATOR *cur;
SUFFIX *cursuf;
TARGET *imptarg = NULL;
RET_T ret;
bool newtarg;
UINT32 startcount;
char *buf;
SLIST *curslist;
SLIST *slist; // Slist chosen for sufsuf
SLIST *slistDef; // Slist that has dependent path = ""
SLIST *slistEmptyTargDepPath;
bool UseDefaultSList;
int slistCount;
srcsuf = FindSuffix( ext );
if( srcsuf == NULL || srcsuf->creator == NULL ) {
PrtMsg( DBG | INF | IMP_ENV_M, targ->node.name, M_HAS_NO_IMPLICIT );
return( RET_WARN );
}
PrtMsg( DBG | INF | IMP_ENV_M, targ->node.name, M_CHECKING_IMPLICIT );
startcount = cListCount;
for( cur = srcsuf->creator; cur != NULL; cur = cur->next ) {
cursuf = cur->suffix;
/* allocate a buffer */
buf = MallocSafe( _MAX_PATH );
slist = NULL;
slistDef = NULL;
slistEmptyTargDepPath = NULL;
ret = RET_ERROR;
UseDefaultSList = true;
/* find path in SLIST */
slistCount = 0;
for( curslist = cur->slist; curslist != NULL && ret != RET_SUCCESS; curslist = curslist->next ) {
_makepath( buf, drive, dir, NULL, NULL );
FixName( buf );
/*
* note the path of the current target must match the
* path as specified in the slist
*/
if( stricmp( buf, curslist->targ_path ) == 0 ) {
/* build filename for implied target */
_makepath( buf, NULL, curslist->dep_path, fname, cursuf->node.name );
/* try to find this file on path or in targets */
ret = TrySufPath( buf, buf, &imptarg, false );
if( ret == RET_SUCCESS ) {
slist = curslist;
/* later on we need to check if implied target does not */
/* exist we need to create it on the first directory we */
/* see on the SLIST since */
/* the first on the list is the one that was defined */
/* last in the makefile */
} else if( slistDef == NULL ) {
slistDef = curslist;
}
}
if( *curslist->targ_path == NULLCHAR && *curslist->dep_path == NULLCHAR ) {
slistEmptyTargDepPath = curslist;
}
if( slistCount > 0 && slistEmptyTargDepPath != NULL ) {
UseDefaultSList = false;
}
++slistCount;
}
if( UseDefaultSList && slist == NULL && !Glob.compat_nmake ) {
_makepath( buf, NULL, NULL, fname, cursuf->node.name );
/* try to find this file on path or in targets */
ret = TrySufPath( buf, buf, &imptarg, false );
switch( ret ) {
case RET_WARN:
break;
case RET_ERROR:
if( !Glob.compat_nmake ) {
slistDef = slistEmptyTargDepPath;
}
break;
case RET_SUCCESS:
slist = slistEmptyTargDepPath;
break;
}
}
if( ret == RET_ERROR && slistDef == NULL ) {
/*
* No Default Slist found so must continue and find
* another slist
*/
FreeSafe( buf );
continue;
}
if( (ret == RET_SUCCESS && imptarg == NULL) || ret == RET_ERROR ) {
/* Either file doesn't exist, or it exists and we don't already
* have a target for it. Either way, we create a new target.
*/
if( ret == RET_ERROR ) {
slist = slistDef;
/* file doesn't exist, assume in directory */
/* pointed to by the slistDef */
_makepath( buf, NULL, slist->dep_path, fname, cursuf->node.name );
}
newtarg = true;
imptarg = NewTarget( buf );
FreeSafe( buf ); /* don't need any more */
getStats( imptarg );
imptarg->busy = true; /* protect against recursion */
if( imply( imptarg, NULL, slist->dep_path, fname, cursuf->node.name, false ) == RET_ERROR ) {
imptarg->error = true;
}
if( startcount != cListCount && (Glob.noexec || Glob.query) ) {
imptarg->touched = true;
imptarg->executed = true;
}
imptarg->updated = true;
imptarg->busy = false;
} else {
/* We already know about imptarg, so just update it */
assert( imptarg != NULL );
FreeSafe( buf ); /* don't need any more */
newtarg = false; /* this isn't a new target */
Update( imptarg );
}
/* We've tried our best to make the imptarg, check if it exists
* after our efforts.
*/
if( targExists( imptarg ) ) {
/* it exists - now we perform the implicit cmd list, and return */
ret = implyMaybePerform( targ, imptarg, slist->cretarg, must );
if( newtarg && !Glob.noexec ) {
/* destroy the implied target, because the info in the target
* structure is nicely stored on disk (unless Glob.noexec)
*/
KillTarget( imptarg->node.name );
}
implyDebugInfo( targ, startcount );
return( ret );
} else if( newtarg ) {
/* we created an unsuccessful target - so destroy it */
KillTarget( imptarg->node.name );
}
/* We couldn't imply with this suffix... try next one */
}
implyDebugInfo( targ, startcount );
return( RET_WARN );
}
