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 );
}
/*
* processFileList - process a possible file list
*/
static void processFileList( const char *ptr )
{
DIR *dirp;
struct dirent *dirent;
const char *tmp;
bool has_wild = false;
char buff1[_MAX_PATH2];
char buff2[_MAX_PATH2];
char *drive;
char *dir;
char *fname;
char *ext;
char path[_MAX_PATH];
tmp = ptr;
while( *tmp != '\0' ) {
if( *tmp == '*' || *tmp == '?' ) {
has_wild = true;
break;
}
tmp++;
}
if( !has_wild ) {
processFile( ptr );
return;
}
_splitpath2( ptr, buff1, &drive, &dir, &fname, &ext );
dirp = opendir( ptr );
if( dirp == NULL ) {
return;
}
while( (dirent = readdir( dirp )) != NULL ) {
#ifdef __UNIX__
{
struct stat buf;
stat( dirent->d_name, &buf );
if ( S_ISDIR( buf.st_mode ) )
continue;
}
#else
if( dirent->d_attr & (_A_SUBDIR | _A_VOLID) ) {
continue;
}
#endif
_splitpath2( dirent->d_name, buff2, NULL, NULL, &fname, &ext );
_makepath( path, drive, dir, fname, ext );
strlwr( path );
processFile( path );
}
closedir( dirp );
} /* processFileList */
void ActionOutfile( cmdline_t *cmd, char *buf, uint file_num ) {
/************************************************************/
char sp_buf[ _MAX_PATH2 ];
char *drive;
char *dir;
char fname[ _MAX_FNAME ];
const char *output;
/**/myassert( cmd != NULL );
/**/myassert( cmd->need_output );
/**/myassert( cmd->action != NULL );
/**/myassert( file_num < cmd->action->num_files );
output = cmd->action->output;
_splitpath2( ( output == NULL || output[0] == 0 ) ?
cmd->action->files[ file_num ] : output,
sp_buf, &drive, &dir, NULL, NULL );
fname[0] = '_';
fname[1] = 'W';
for(;;) {
StrDec( &fname[2], tempFileNum++ );
_makepath( buf, drive, dir, fname, "TMP" );
if( access( buf, 0 ) == -1 ) {
break;
}
}
}
static void BackupLog( const char *log_name, unsigned copies )
{
char buff[_MAX_PATH2];
char *drive;
char *dir;
char *fn;
char *ext;
char old_name[_MAX_PATH];
char new_name[_MAX_PATH];
char temp_ext[5];
if( copies > MAX_BACKUP )
copies = MAX_BACKUP;
if( copies == 0 ) {
remove( log_name );
return;
}
_splitpath2( log_name, buff, &drive, &dir, &fn, &ext );
while( copies != 0 ) {
PutNumber( ext, temp_ext, copies );
_makepath( new_name, drive, dir, fn, temp_ext );
remove( new_name );
if( copies == 1 ) {
strcpy( old_name, log_name );
} else {
PutNumber( ext, temp_ext, copies - 1 );
_makepath( old_name, drive, dir, fn, temp_ext );
}
rename( old_name, new_name );
--copies;
}
}
bool DlgFileBrowse( char *title, char *filter, char *path, unsigned len, fn_flags flags )
{
open_file_name ofn;
char buff[_MAX_PATH2];
char fname[_MAX_PATH];
char cd[_MAX_DRIVE+_MAX_PATH];
char *drive;
char *dir;
char *name;
char *ext;
int rc;
memset( &ofn, 0, sizeof( ofn ) );
ofn.flags = flags;
ofn.title = title;
_splitpath2( path, buff, &drive, &dir, &name, &ext );
_makepath( cd, drive, dir, ".", NULL );
_makepath( fname, NULL, NULL, name, ext );
ofn.initial_dir = cd;
ofn.file_name = fname;
ofn.max_file_name = len;
ofn.filter_list = filter;
ofn.filter_index = 0;
rc = DlgGetFileName( &ofn );
if( rc == FN_RC_FILE_SELECTED ) {
strcpy( path, fname );
return( TRUE );
}
return( FALSE );
}
static bool MsgReadErrArray( void )
#endif
{
int i;
char buffer[128];
unsigned msg_shift;
msg_shift = _WResLanguage() * MSG_LANG_SPACING;
for( i = ERR_FIRST_MESSAGE; i <= ERR_LAST_MESSAGE; i++ ) {
#if !defined(__WINDOWS__)
if( WResLoadString( &hInstance, i + msg_shift, (lpstr)buffer, sizeof( buffer ) ) <= 0 ) {
#else
if( LoadString( inst, i + msg_shift, (LPSTR)buffer, sizeof( buffer ) ) <= 0 ) {
#endif
if( i == ERR_FIRST_MESSAGE )
return( false );
buffer[0] = '\0';
}
MsgArray[i - ERR_FIRST_MESSAGE] = my_alloc( strlen( buffer ) + 1 );
if( MsgArray[i - ERR_FIRST_MESSAGE] == NULL )
return( false );
_fstrcpy( MsgArray[i - ERR_FIRST_MESSAGE], buffer );
}
return( true );
}
#if !defined(__WINDOWS__)
bool MsgInit( void )
{
char buffer[_MAX_PATH];
#if defined(_PLS)
char *fname;
char fullpath[_MAX_PATH];
#endif
bool rc;
hInstance.status = 0;
if( _cmdname( buffer ) != NULL ) {
rc = OpenResFile( &hInstance, buffer );
#if defined(_PLS)
if( !rc ) {
_splitpath2( buffer, fullpath, NULL, NULL, &fname, NULL );
_makepath( buffer, NULL, NULL, fname, ".exp" );
_searchenv( buffer, "PATH", fullpath );
if( fullpath[0] != '\0' ) {
rc = OpenResFile( &hInstance, fullpath );
}
}
#endif
if( rc ) {
MsgReadErrArray();
CloseResFile( &hInstance );
return( true );
}
}
CloseResFile( &hInstance );
posix_write( STDOUT_FILENO, NO_RES_MESSAGE, NO_RES_SIZE );
return( false );
}
const char *procPath( const char *fullpath )
/**************************************************
* process fullpath according to the form qualifier in CurAttr.num
* returns: pointer to a static buffer
*/
{
PGROUP pg;
char *p;
if( fullpath == NULL ) {
return( NULL );
}
getDirBuf();
_splitpath2( fullpath, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
switch( CurAttr.u.form ) {
case FORM_FULL:
_makepath( dirBuf, pg.drive, pg.dir, pg.fname, pg.ext );
break;
case FORM_NOEXT:
_makepath( dirBuf, pg.drive, pg.dir, pg.fname, NULL );
break;
case FORM_NOEXT_NOPATH:
_makepath( dirBuf, NULL, NULL, pg.fname, NULL );
break;
case FORM_NOPATH:
_makepath( dirBuf, NULL, NULL, pg.fname, pg.ext );
break;
case FORM_PATH:
_makepath( dirBuf, pg.drive, pg.dir, NULL, NULL );
if( Glob.compat_nmake ) {
if( dirBuf[0] == NULLCHAR ) {
dirBuf[0] = '.';
dirBuf[1] = NULLCHAR;
} else {
p = dirBuf;
while( *p != NULLCHAR ) {
++p;
}
if( *(p - 1) == '\\' ) {
*(p - 1) = NULLCHAR;
}
}
}
break;
case FORM_EXT:
_makepath( dirBuf, NULL, NULL, NULL, pg.ext );
break;
default:
dirBuf[0] = NULLCHAR;
}
massageDollarOctothorpe( dirBuf );
return( dirBuf );
}
static const char *DoWildCard( const char *base )
/***********************************************/
{
PGROUP pg;
struct dirent *entry;
if( base != NULL ) {
/* clean up from previous invocation */
DoWildCardClose();
if( strpbrk( base, "*?" ) == NULL ) {
return( base );
}
// create directory name and pattern
wildpath = MemAlloc( _MAX_PATH );
wildpattern = MemAlloc( _MAX_PATH );
strcpy( wildpath, base );
_splitpath2( wildpath, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
_makepath( wildpath, pg.drive, pg.dir, ".", NULL );
// create file name pattern
_makepath( wildpattern, NULL, NULL, pg.fname, pg.ext );
wildparent = opendir( wildpath );
if( wildparent == NULL ) {
DoWildCardClose();
return( NULL );
}
}
if( wildparent == NULL ) {
return( NULL );
}
while( (entry = readdir( wildparent )) != NULL ) {
if( ISVALIDENTRY( entry ) ) {
if( fnmatch( wildpattern, entry->d_name, FNM_OPTIONS ) == 0 ) {
break;
}
}
}
if( entry == NULL ) {
DoWildCardClose();
return( NULL );
}
_splitpath2( wildpath, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
_makepath( wildpath, pg.drive, pg.dir, entry->d_name, NULL );
return( wildpath );
}
static void AddName( char *name, FILE *link_fp ) {
//====================================================
list *curr_name;
list *last_name;
list *new_name;
char path[_MAX_PATH];
PGROUP pg1;
PGROUP pg2;
last_name = NULL;
for( curr_name = ObjList; curr_name != NULL; curr_name = curr_name->next ) {
if( stricmp( name, curr_name->filename ) == 0 )
return;
last_name = curr_name;
}
new_name = MemAlloc( sizeof( struct list ) );
if( ObjList == NULL ) {
ObjList = new_name;
} else {
last_name->next = new_name;
}
new_name->filename = strdup( name );
new_name->next = NULL;
fputs( "file '", link_fp );
if( ObjName != NULL ) {
// construct full name of object file from ObjName information
_splitpath2( ObjName, pg1.buffer, &pg1.drive, &pg1.dir, &pg1.fname, &pg1.ext );
if( pg1.ext[0] == '\0' )
pg1.ext = OBJ_EXT;
if( ( pg1.fname[0] == '\0' ) ||
( ( pg1.fname[0] == '*' ) && ( pg1.fname[1] == '\0' ) ) ) {
_splitpath2( name, pg2.buffer, NULL, NULL, &pg1.fname, &pg2.ext );
if( pg2.ext[0] != '\0' ) {
pg1.ext = pg2.ext;
}
}
_makepath( path, pg1.drive, pg1.dir, pg1.fname, pg1.ext );
name = path;
}
fputs( name, link_fp );
Fputnl( "'", link_fp );
}
static void MakeName( char *name, char *ext ) {
//=================================================
PGROUP pg;
_splitpath2( name, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
if( pg.ext[0] == '\0' )
pg.ext = ext;
_makepath( name, pg.drive, pg.dir, pg.fname, pg.ext );
}
static void splitFileName( // SPLIT APART PATH/FILENAME
const char *name, // - name to be split
struct path_descr *descr ) // - descriptor
{
_splitpath2( name
, descr->buffer
, &descr->drv
, &descr->dir
, &descr->fnm
, &descr->ext );
}
/*
* processFile - process a specified file
*/
static void processFile( const char *arg )
{
char buff[_MAX_EXT + 5];
char *ext;
file_type ftype;
unsigned tagcnt;
StartFile( arg );
_splitpath2( arg, buff, NULL, NULL, NULL, &ext );
if( fileType == TYPE_NONE ) {
ftype = TYPE_C;
if( !stricmp( ext, ".for" ) ) {
ftype = TYPE_FORTRAN;
} else if( !stricmp( ext, ".fi" ) ) {
ftype = TYPE_FORTRAN;
} else if( !stricmp( ext, ".pas" ) ) {
ftype = TYPE_PASCAL;
} else if( !stricmp( ext, ".cpp" ) ) {
ftype = TYPE_CPLUSPLUS;
} else if( !stricmp( ext, ".asm" ) ) {
ftype = TYPE_ASM;
}
} else {
ftype = fileType;
}
tagcnt = 0;
if( VerboseFlag ) {
printf( "Processing %s", arg );
tagcnt = TagCount;
fflush( stdout );
}
switch( ftype ) {
case TYPE_C:
ScanC();
break;
case TYPE_CPLUSPLUS:
ScanC();
break;
case TYPE_FORTRAN:
ScanFortran();
break;
case TYPE_PASCAL:
ScanFortran();
break;
case TYPE_ASM:
ScanAsm();
break;
}
if( VerboseFlag ) {
printf( ", %u tags.\n", TagCount - tagcnt );
}
EndFile();
} /* processFile */
static void composeFileNames( bool list_file )
{
char path[_MAX_PATH2];
char * drive;
char * dir;
char * file_name;
char * extension;
int length;
// object file name
_splitpath2( ObjFileName, path, &drive, &dir, &file_name, &extension );
#ifndef __UNIX__
// tacking on an extension is self-defeating on UNIX, and the extra
// dot at end trick doesn't work either
if( strlen( extension ) == 0 ) {
length = strlen( ObjFileName );
MemFree( ObjFileName );
ObjFileName = (char *) MemAlloc( length + strlen( OBJ_FILE_EXTENSION ) + 1 );
_makepath( ObjFileName, drive, dir, file_name, OBJ_FILE_EXTENSION );
} // else file name has an extension - leave as is
#endif
if( list_file ) {
if( ListFileName == NULL ) {
length = strlen( drive ) + strlen( dir ) + strlen( dir ) +
strlen( file_name ) + strlen( LIST_FILE_EXTENSION );
ListFileName = (char *) MemAlloc( length + 1 );
_makepath( ListFileName, drive, dir, file_name, LIST_FILE_EXTENSION );
} else {
// check extension
_splitpath2( ListFileName, path, &drive, &dir, &file_name, &extension );
if( strlen( extension ) == 0 ) {
length = strlen( ListFileName );
MemFree( ListFileName );
ListFileName = (char *) MemAlloc( length + strlen( LIST_FILE_EXTENSION ) + 1 );
_makepath( ListFileName, drive, dir, file_name, LIST_FILE_EXTENSION );
} // else has extension, leave it as is
}
}
}
static void ReplaceExt( char * name, char * new_ext, bool force )
/***************************************************************/
{
char buff[ _MAX_PATH2 ];
char * p;
char * d;
char * n;
char * e;
_splitpath2( name, buff, &d, &p, &n, &e );
if( force || e[0] == '\0' ) {
strcpy( e, new_ext );
_makepath( name, d, p, n, e );
}
}
extern bint WPSampFound( void )
/*****************************/
{
struct stat file_stat;
char buffer[_MAX_PATH2];
char *ext;
if( stat( SamplePath, &file_stat ) != -1 ) return( P_TRUE );
if( SamplePath[0] == NULLCHAR ) return( P_FALSE );
_splitpath2( SamplePath, buffer, NULL, NULL, NULL, &ext );
if( *ext != NULLCHAR ) return( P_FALSE );
ReplaceExt( SamplePath, ".smp" );
if( stat( SamplePath, &file_stat ) != -1 ) return( P_TRUE );
return( P_FALSE );
}
static void set_default_extension( const char * masterfname )
{
char buff[FILENAME_MAX];
char * ext;
_splitpath2( masterfname, buff, NULL, NULL, NULL, &ext );
if( strlen( ext ) > 0) {
if( strlen( ext ) > strlen( def_ext ) ) {
mem_free( def_ext);
def_ext = mem_alloc( 1 + strlen( ext ) );
}
strcpy( def_ext, ext );
}
return;
}
streng *os2_filespec( tsd_t *TSD, cparamboxptr parms )
{
streng *result=NULL ;
streng *inpath=NULL;
char format = '?' ;
#if defined(DJGPP)
char fdrive[MAXDRIVE], fdir[MAXDIR], fname[MAXFILE], fext[MAXEXT];
#elif defined(__EMX__)
char fdrive[_MAX_DRIVE], fdir[_MAX_DIR], fname[_MAX_FNAME], fext[_MAX_EXT];
#elif defined(HAVE__SPLITPATH2)
char fpath[_MAX_PATH2], *fdrive=NULL, *fdir=NULL, *fname=NULL, *fext=NULL;
#elif defined(HAVE__SPLITPATH)
char fdrive[_MAX_PATH], fdir[_MAX_PATH], fname[_MAX_PATH], fext[_MAX_PATH];
#else
char fpath[REXX_PATH_MAX+5],*fdrive=NULL,*fdir=NULL,*fname=NULL,*fext=NULL;
#endif
checkparam( parms, 2, 2 , "FILESPEC" ) ;
format = getoptionchar( TSD, parms->value, "FILESPEC", 1, "DNP", "?" ) ;
inpath = Str_dupstrTSD( parms->next->value ) ;
#if defined(DJGPP)
fnsplit( inpath->value, fdrive, fdir, fname, fext );
#elif defined(__EMX__)
_splitpath( inpath->value, fdrive, fdir, fname, fext );
#elif defined(HAVE__SPLITPATH2)
_splitpath2( inpath->value, fpath, &fdrive, &fdir, &fname, &fext );
#elif defined(HAVE__SPLITPATH)
_splitpath( inpath->value, fdrive, fdir, fname, fext );
#else
my_splitpath2( inpath->value, fpath, &fdrive, &fdir, &fname, &fext );
#endif
switch( format )
{
case 'D':
result = Str_creTSD( fdrive );
break;
case 'N':
result = Str_makeTSD( strlen( fname) + strlen( fext ) );
Str_catstrTSD( result, fname );
Str_catstrTSD( result, fext );
break;
case 'P':
result = Str_creTSD( fdir );
break;
}
FreeTSD( inpath );
return result;
}
STATIC enum cacheRet maybeCache( const char *fullpath, CENTRYPTR *pc )
/********************************************************************/
{
char path[_MAX_PATH];
char name[NAME_MAX + 1];
DHEADPTR dcur;
CENTRYPTR centry;
enum cacheRet ret;
PGROUP pg;
char const *ext;
assert( fullpath != NULL );
_splitpath2( fullpath, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
_makepath( path, pg.drive, pg.dir, NULL, NULL );
ext = pg.ext;
if( ext[0] == '.' && ext[1] == 0 ) {
ext = NULL;
}
_makepath( name, NULL, NULL, pg.fname, ext );
FixName( path );
FixName( name );
dcur = findDir( path );
if( dcur == NULL ) { /* must cache new directory */
ret = cacheDir( &dcur, path );
if( ret != CACHE_OK ) {
return( ret );
}
dcur->dh_next = cacheHead;
cacheHead = dcur;
}
/* now dcur points to Cached directory */
assert( dcur != NULL );
centry = findFile( dcur, name );
if( centry == NULL ) {
return( CACHE_FILE_NOT_FOUND );
}
if( pc != NULL ) {
*pc = centry;
}
return( CACHE_OK );
}
STATIC RET_T tryImply( TARGET *targ, bool must )
/**********************************************/
{
PGROUP pg;
RET_T ret;
if( Glob.block ) {
return( RET_WARN );
}
_splitpath2( targ->node.name, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
ret = imply( targ, pg.drive, pg.dir, pg.fname, pg.ext, must );
return( ret );
}
void ActionInfile( cmdline_t *cmd, char *buf, uint file_num ) {
/***********************************************************/
char buffer[ _MAX_PATH2 ];
char *drive;
char *dir;
char *fname;
char *ext;
/**/myassert( cmd != NULL );
/**/myassert( cmd->action != NULL );
/**/myassert( file_num < cmd->action->num_files );
_splitpath2( cmd->action->files[ file_num ], buffer,
&drive, &dir, &fname, &ext );
_makepath( buf, drive, dir, fname, ( ext[0]==0 ) ? OBJ_EXTENSION : ext );
}
bool ObjInit( char *fname ) {
//***************************
owl_client_funcs funcs = {
(int (*)( owl_client_file, const char *, uint ))write,
(long (*)( owl_client_file ))tell,
(long (*)( owl_client_file, long, int ))lseek,
MemAlloc,
MemFree
};
char name[ _MAX_FNAME ];
owl_format obj_format;
SectionInit();
_splitpath( fname, NULL, NULL, name, NULL );
if( !objectDefined ) {
_makepath( objName, NULL, NULL, name, OBJ_EXT );
} else {
char tmpName[ _MAX_PATH2 ];
char *tmpNode;
char *tmpDir;
char *tmpFname;
char *tmpExt;
_splitpath2( objName, tmpName, &tmpNode, &tmpDir, &tmpFname, &tmpExt );
if( *tmpExt == 0 )
tmpExt = OBJ_EXT;
if( *tmpFname == 0 )
tmpFname = name;
_makepath( objName, tmpNode, tmpDir, tmpFname, tmpExt );
}
objectDefined = FALSE; // so that the /fo applies only to the 1st obj
_makepath( errorFilename, NULL, NULL, name, ".err" );
objFile = open( objName, O_CREAT | O_TRUNC | O_BINARY | O_WRONLY, PMODE_RW );
if( objFile == -1 ) {
AsOutMessage( stderr, UNABLE_TO_CREATE, objName );
fputc( '\n', stderr );
return( FALSE );
}
ErrorFile = fopen( errorFilename, "wt" );
OwlHandle = OWLInit( &funcs, OBJ_OWL_CPU );
obj_format = ( _IsOption( OBJ_COFF ) ? OWL_FORMAT_COFF : OWL_FORMAT_ELF );
OwlFile = OWLFileInit( OwlHandle, fname, (owl_client_file)(pointer_int)objFile, obj_format, OWL_FILE_OBJECT );
ObjSwitchSection( AS_SECTION_TEXT );
CurrAlignment = 0;
return( TRUE );
}
STATIC void splitFullPath( const char *fullpath, char *pathbuf, char *filebuf )
/*****************************************************************************/
{
PGROUP pg;
char const *ext;
assert( fullpath != NULL && pathbuf != NULL && filebuf != NULL );
_splitpath2( fullpath, pg.buffer, &pg.drive, &pg.dir, &pg.fname, &pg.ext );
_makepath( pathbuf, pg.drive, pg.dir, NULL, NULL );
ext = pg.ext;
if( ext[0] == '.' && ext[1] == 0 ) {
ext = NULL;
}
_makepath( filebuf, NULL, NULL, pg.fname, ext );
}
STATIC int openIncludeFile( const char * file_name ) {
char buffer[ _MAX_PATH2 ];
char *drive;
char *dir;
char *fname;
char *ext;
char path[ _MAX_PATH ];
int fh;
_splitpath2( file_name, buffer, &drive, &dir, &fname, &ext );
_makepath( path, drive, dir, fname, ( ext[0] == 0 ) ? WMP_EXTENSION : ext );
fh = open( path, O_RDONLY | O_TEXT );
if( fh == -1 ) {
Fatal( MSG_UNABLE_TO_OPEN_FILE, path );
}
return( fh );
}
extern void ReplaceExt( char * path, char * addext )
/**************************************************/
{
char buff [ _MAX_PATH2 ];
char * drive;
char * dir;
char * fname;
char * ext;
_splitpath2( path, buff, &drive, &dir, &fname, &ext );
#if defined(__UNIX__)
if( stricmp( ext, addext ) != 0 ) {
strcat( path, addext );
}
#else
_makepath( path, drive, dir, fname, addext );
#endif
}
extern void AssertionFailed( char * file, unsigned line )
/*******************************************************/
{
char path[ _MAX_PATH2 ];
char buff[ 13+_MAX_FNAME ];
char * fname;
unsigned size;
_splitpath2( file, path, NULL, NULL, &fname, NULL ); /* _MAX_FNAME */
size = strlen( fname );
memcpy( buff, fname, size );
buff[size] = ' '; /* 1 */
utoa( line, &buff[size + 1], 10 ); /* 10 */
/* '\0' + 1 */
/* --- */
/* 12+_MAX_FNAME */
fatal( LIT( Assertion_Failed ), buff );
}
IntlData *LoadInternationalData(
const char *file_prefix )
{
IntlData *data;
int fh;
res_language_enumeration language;
unsigned len;
char *drive;
char *dir;
char cmd_name[_MAX_PATH];
char split_buff[_MAX_PATH2];
char base[16];
language = _WResLanguage();
if( language == RLE_ENGLISH ) {
return( NULL );
}
if( imageName( cmd_name ) == NULL ) {
return( NULL );
}
_splitpath2( cmd_name, split_buff, &drive, &dir, NULL, NULL );
len = strlen( file_prefix );
if( len > 6 ) {
len = 6;
}
memcpy( base, file_prefix, len );
base[len++] = '0';
base[len++] = '0' + language;
base[len] = '\0';
_makepath( cmd_name, drive, dir, base, "." LOCALE_DATA_EXT );
fh = sopen3( cmd_name, O_RDONLY | O_BINARY, SH_DENYWR );
if( fh == -1 ) {
return( NULL );
}
data = getData( fh );
if( data != NULL ) {
if( data->usage_text == NULL || data->errors_text == NULL ) {
FreeInternationalData( data );
data = NULL;
}
}
close( fh );
return( data );
}
void main()
{
char full_path[ _MAX_PATH ];
char tmp_path[ _MAX_PATH2 ];
char *drive;
char *dir;
char *fname;
char *ext;
_makepath(full_path,"c","watcomc\\h","stdio","h");
printf( "Full path is: %s\n\n", full_path );
_splitpath2( full_path, tmp_path,
&drive, &dir, &fname, &ext );
printf( "Components after _splitpath2\n" );
printf( "drive: %s\n", drive );
printf( "dir: %s\n", dir );
printf( "fname: %s\n", fname );
printf( "ext: %s\n", ext );
}
static void openFiles( void )
/*****************************/
{
/* C.L. May 22, 91 */
char sp_buf[ _MAX_PATH2 ];
char *ext;
size_t len;
_splitpath2( objName, sp_buf, NULL, NULL, &rootName, &ext );
len = strlen( rootName ) + 1;
rootName = memcpy( AllocMem( len ), rootName, len );
if( ext[ 0 ] == '\0' ) {
/* search with '.obj' or '.o' extension first */
ObjFile = OpenBinRead( MakeFileName( objName, objExt ) );
if( ObjFile == NULL ) {
/* try without extension */
ObjFile = OpenBinRead( objName );
}
} else {
/* extension specified */
ObjFile = OpenBinRead( objName );
}
/**/
if( ObjFile == NULL ) {
// ObjFile = OpenBinRead( MakeFileName( objName, objExt ) );
// if( ObjFile == NULL ) {
SysError( ERR_NOT_OPEN_OBJ, true );
// }
}
if( lstReqd ) {
if( lstName == NULL ) {
Output = OpenTxtWrite( MakeFileName( rootName, "lst" ) );
} else {
Output = OpenTxtWrite( lstName );
}
if( Output == NULL ) {
CloseBin( ObjFile );
SysError( ERR_NOT_OPEN_LIST, true );
}
}
}
static FILE *OpenPrfFile( int isInit )
{
char *drive;
char *dir;
char *name;
char fname[ _MAX_PATH2 ];
char pname[ _MAX_PATH2 ];
FILE *out;
int already;
union tsc start_tsc;
union tsc end_tsc;
struct stat exe_stat;
struct stat prf_stat;
if( PGM_NAME != NULL ) {
_splitpath2( PGM_NAME, &fname, &drive, &dir, &name, NULL );
_makepath( pname, drive, dir, name, ".prf" );
} else {
return( NULL );
}
already = access( pname, R_OK ) == 0;
if( already ) {
stat( pname, &prf_stat );
stat( PGM_NAME, &exe_stat );
if( exe_stat.st_mtime > prf_stat.st_mtime ) {
unlink( pname );
already = FALSE;
}
}
out = fopen( pname, "at+" );
if( out == NULL ) return( NULL );
if( !already ) {
fprintf( out, "Format: C/C++ 1\n" );
_RDTSC( &start_tsc );
sleep( 1 );
_RDTSC( &end_tsc );
fprintf( out, "Ticks Per Second %d\n", (long)( end_tsc.i - start_tsc.i ) );
}
return( out );
}
extern dig_fhandle FullPathOpen( char const *name, char *ext,
char *result, unsigned max_res )
/***************************************************************/
{
char realname[ _MAX_PATH2 ];
char * filename;
if( ext == NULL || *ext == '\0' ) {
strcpy( realname, name );
} else {
_splitpath2( name, result, NULL, NULL, &filename, NULL );
_makepath( realname, NULL, NULL, filename, ext );
}
filename = FindFile( result, realname, FilePathList );
if( filename == NULL ) {
filename = FindFile( result, realname, DipExePathList );
}
if( filename == NULL ) {
return( -1 );
}
return( DIGCliOpen( filename, DIG_READ ) );
}
