RET_T TouchFile( const char *name )
/****************************************/
{
tiny_date_t dt;
tiny_time_t tm;
tiny_ftime_t p_hms;
tiny_fdate_t p_ymd;
tiny_ret_t ret;
ret = TinyOpen( name, TIO_WRITE );
if( TINY_OK( ret ) ) {
dt = TinyGetDate();
p_ymd.year = dt.year + (1900 - 1980);
p_ymd.month = dt.month;
p_ymd.day = dt.day_of_month;
tm = TinyGetTime();
p_hms.hours = tm.hour;
p_hms.minutes = tm.minutes;
p_hms.twosecs = tm.seconds / 2;
TinySetFileStamp( TINY_INFO( ret ), p_hms, p_ymd );
TinyClose( TINY_INFO( ret ) );
} else {
ret = TinyCreate( name, TIO_NORMAL );
if( TINY_OK( ret ) ) {
TinyClose( TINY_INFO( ret ) );
} else {
return( RET_ERROR );
}
}
return( RET_SUCCESS );
}
sys_handle LocalOpen( const char *name, open_access access )
{
tiny_ret_t ret;
unsigned mode;
if( (access & OP_WRITE) == 0 ) {
mode = TIO_READ;
access &= ~(OP_CREATE|OP_TRUNC);
} else if( access & OP_READ ) {
mode = TIO_READ_WRITE;
} else {
mode = TIO_WRITE;
}
if( access & (OP_CREATE|OP_TRUNC) ) {
ret = TinyCreate( name, TIO_NORMAL );
} else {
if( _osmajor >= 3 ) mode |= 0x80; /* set no inheritance */
ret = TinyOpen( name, mode );
}
if( TINY_ERROR( ret ) ) {
StashErrCode( TINY_INFO( ret ), OP_LOCAL );
return( NIL_SYS_HANDLE );
}
return( TINY_INFO( ret ) );
}
static tiny_ret_t DoOpen( char *name, bool create, unsigned mode )
/****************************************************************/
{
tiny_ret_t h;
CheckBreak();
for( ;; ) {
if( OpenFiles >= MAX_OPEN_FILES ) CleanCachedHandles();
if( create ) {
h = TinyCreate( name, mode );
} else {
h = TinyOpen( name, mode );
}
if( TINY_OK( h ) ) {
OpenFiles++;
break;
}
if( TINY_INFO( h ) != TOOMANY ) break;
if( !CleanCachedHandles() ) break;
}
return( h );
}
bool XchkOpen( where_parm where, char *f_buff )
{
tiny_ret_t rc;
fileHandle = TINY_HANDLE_NULL;
if( f_buff != NULL ) {
fullName = f_buff;
*f_buff++ = TinyGetCurrDrive() + 'A';
*f_buff++ = ':';
*f_buff++ = '\\';
rc = TinyFarGetCWDir( f_buff, 0 );
if( TINY_OK( rc ) ) {
while( *f_buff != 0 )
++f_buff;
if( f_buff[-1] == '\\' ) {
--f_buff;
} else {
*f_buff++ = '\\';
}
memcpy( f_buff, CHECK_FILE, sizeof( CHECK_FILE ) );
rc = TinyCreate( fullName, TIO_NORMAL );
if( TINY_OK( rc ) ) {
fileHandle = TINY_INFO( rc );
}
}
if( fileHandle == TINY_HANDLE_NULL ) {
fullName = NULL;
}
} else {
if( fullName != NULL ) {
rc = TinyOpen( fullName, TIO_READ );
if( TINY_OK( rc ) ) {
fileHandle = TINY_INFO( rc );
}
}
}
return( fileHandle != TINY_HANDLE_NULL );
}
trap_retval ReqFile_open( void )
{
tiny_ret_t rc;
int mode;
char *filename;
file_open_req *acc;
file_open_ret *ret;
static int MapAcc[] = { TIO_READ, TIO_WRITE, TIO_READ_WRITE };
acc = GetInPtr( 0 );
filename = GetInPtr( sizeof( *acc ) );
ret = GetOutPtr( 0 );
if( acc->mode & TF_CREATE ) {
rc = TinyCreate( filename, TIO_NORMAL );
} else {
mode = MapAcc[ acc->mode - 1 ];
if( IsDOS3 ) mode |= 0x80; /* set no inheritance */
rc = TinyOpen( filename, mode );
}
ret->handle = TINY_INFO( rc );
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
return( sizeof( *ret ) );
}
long MySpawn( const char *cmd )
{
bool cp;
long rc;
exec_block exeparm;
_fcb fcb1, fcb2;
cmd_struct cmds;
char path[_MAX_PATH], file[_MAX_PATH];
tiny_ret_t ret;
int i;
char chkfname[L_tmpnam];
minMemoryLeft = MaxMemFree & ~((long)MAX_IO_BUFFER - 1);
chkSwapSize = 1 + (unsigned short)
(((minMemoryLeft + ((long)MAX_IO_BUFFER - 1)) & ~((long)MAX_IO_BUFFER - 1)) /
(long)MAX_IO_BUFFER);
/*
* set up checkpoint file stuff:
*/
#ifndef NOEMS
if( !EMSBlockTest( chkSwapSize ) ) {
xHandle = alloca( chkSwapSize * sizeof( long ) );
xSize = alloca( chkSwapSize * sizeof( short ) );
for( i = 0; i < chkSwapSize; i++ ) {
EMSGetBlock( &xHandle[i] );
}
isWhere = IN_EMS;
currMem = 0;
goto evil_goto;
}
#endif
#ifndef NOXMS
if( !XMSBlockTest( chkSwapSize ) ) {
xHandle = alloca( chkSwapSize * sizeof( long ) );
xSize = alloca( chkSwapSize * sizeof( short ) );
for( i = 0; i < chkSwapSize; i++ ) {
XMSGetBlock( &xHandle[i] );
}
isWhere = IN_XMS;
currMem = 0;
goto evil_goto;
}
#endif
file[0] = 0;
tmpnam( chkfname );
StrMerge( 3, file, TmpDir, FILE_SEP_STR, chkfname );
fullName = file;
ret = TinyCreate( fullName, TIO_NORMAL );
if( ret < 0 ) {
return( 0 );
}
fileHandle = ret;
isWhere = ON_DISK;
/*
* build command line
*/
evil_goto:
GetSpawnCommandLine( path, cmd, &cmds );
/*
* set up parm block
*/
exeparm.envp = 0;
exeparm.cmdline = &cmds;
exeparm.fcb1 = fcb1;
exeparm.fcb2 = fcb2;
GetFcb( &cmds.cmd, &fcb1 );
GetFcb( &cmds.cmd, &fcb2 );
/*
* spawn the command
*/
cp = checkPointMem( minMemoryLeft / 16 );
rc = DoSpawn( path, &exeparm );
if( cp ) {
CheckPointRestore();
}
return( rc );
}
bool CheckPointMem( unsigned max, char *f_buff )
{
dos_mem_block *mem;
dos_mem_block *start;
dos_mem_block *end;
dos_mem_block *next;
dos_mem_block *chk;
tiny_ret_t rc;
tiny_handle_t hdl;
unsigned size;
unsigned bytes;
unsigned psp;
char *p;
if( max == 0 ) return( FALSE );
ChkFile = f_buff;
psp = TinyGetPSP();
start = MK_FP( psp - 1, 0 );
while( start->owner == psp ) {
if( start->chain == END_OF_CHAIN ) return( FALSE );
// start = NEXT_BLOCK( start );
start = MK_FP( (FP_SEG( start ) + (start)->size + 1), 0 );
}
mem = start;
for( ;; ) {
if( mem->owner == 0 && mem->size >= max ) return( FALSE );
if( mem->chain == END_OF_CHAIN ) break;
// mem = NEXT_BLOCK( mem );
mem = MK_FP( (FP_SEG( mem ) + (mem)->size + 1), 0 );
}
// end = NEXT_BLOCK( mem );
end = MK_FP( (FP_SEG( mem ) + (mem)->size + 1), 0 );
size = FP_SEG( end ) - FP_SEG( start );
if( size < 0x1000 ) return( FALSE );
*f_buff++ = TinyGetCurrDrive() + 'A';
*f_buff++ = ':';
*f_buff++ = '\\';
rc = TinyFarGetCWDir( (char __far *)f_buff, 0 );
if( TINY_ERROR( rc ) )
return( FALSE );
while( *f_buff != 0 ) ++f_buff;
if( f_buff[-1] == '\\' ) {
--f_buff;
} else {
*f_buff++ = '\\';
}
for( p = CHECK_FILE; *f_buff = *p; ++p, ++f_buff ) {}
rc = TinyCreate( ChkFile, TIO_NORMAL );
if( TINY_ERROR( rc ) )
return( FALSE );
hdl = TINY_INFO( rc );
if( size > max ) size = max;
chk = MK_FP( FP_SEG( end ) - size - 1, 0 );
mem = start;
for( ;; ) {
// next = NEXT_BLOCK( mem );
next = MK_FP( (FP_SEG( mem ) + (mem)->size + 1), 0 );
if( FP_SEG( next ) > FP_SEG( chk ) ) break;
mem = next;
}
if( !PUT_ITEM( mem ) || !PUT_ITEM( *mem ) || !PUT_ITEM( chk ) ) {
TinyClose( hdl );
Cleanup();
return( FALSE );
}
next = chk;
while( FP_SEG( next ) < FP_SEG( end ) ) {
size = FP_SEG( end ) - FP_SEG( next );
if( size >= 0x1000 ) size = 0x0800;
bytes = size << 4;
if( TinyWrite( hdl, next, bytes ) != bytes ) {
TinyClose( hdl );
Cleanup();
return( FALSE );
}
next = MK_FP( FP_SEG( next ) + size, 0 );
}
TinyClose( hdl );
mem->chain = MEMORY_BLOCK;
mem->size = FP_SEG( chk ) - FP_SEG( mem ) - 1;
chk->size = FP_SEG( end ) - FP_SEG( chk ) - 1;
chk->chain = END_OF_CHAIN;
chk->owner = 0;
return( TRUE );
}
