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 ) );
}
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 );
}
/*
* chkOpen - re-open a checkpoint file
*/
static bool chkOpen( void )
{
tiny_ret_t ret;
switch( isWhere ) {
case ON_DISK:
ret = TinyOpen( fullName, TIO_READ );
if( ret < 0 ) {
return( false );
}
fileHandle = ret;
break;
#ifndef NOEMS
case IN_EMS:
currMem = 0;
break;
#endif
#ifndef NOXMS
case IN_XMS:
currMem = 0;
break;
#endif
}
return( true );
} /* chkOpen */
dig_fhandle DIGPathOpen( const char *name, unsigned name_len, const char *exts, char *result, unsigned max_result )
{
bool has_ext;
bool has_path;
const char *src;
char *dst;
char trpfile[256];
tiny_ret_t rc;
char c;
result = result; max_result = max_result;
has_ext = FALSE;
has_path = FALSE;
src = name;
dst = trpfile;
while( name_len-- > 0 ) {
c = *src++;
*dst++ = c;
switch( c ) {
case '.':
has_ext = TRUE;
break;
case '/':
case '\\':
has_ext = FALSE;
/* fall through */
case ':':
has_path = TRUE;
break;
}
}
if( !has_ext ) {
*dst++ = '.';
name_len = strlen( exts );
memcpy( dst, exts, name_len );
dst += name_len;
}
*dst = '\0';
if( has_path ) {
rc = TinyOpen( trpfile, TIO_READ );
} else {
_searchenv( trpfile, "PATH", RWBuff );
rc = TinyOpen( RWBuff, TIO_READ );
}
return( TINY_ERROR( rc ) ? DIG_NIL_HANDLE : TINY_INFO( rc ) );
}
static const char *GetHelpName( const char *exe_name )
{
/*
if executable is:
PE format, subsystem PE_SS_PL_DOSSTYLE (0x42) then PEDHELP.EXP
or:
PE format, other subsystems then PENHELP.EXP
otherwise:
PLSHELP.EXP
*/
tiny_ret_t rc;
tiny_handle_t handle;
unsigned_32 off;
union {
dos_exe_header dos;
pe_header pe;
} head;
handle = -1;
rc = TinyOpen( exe_name, 0 );
if( TINY_ERROR( rc ) )
goto exp;
handle = TINY_INFO( rc );
TinyRead( handle, &head.dos, sizeof( head.dos ) );
if( head.dos.signature != DOS_SIGNATURE )
goto exp;
TinySeek( handle, OS2_NE_OFFSET, SEEK_SET );
TinyRead( handle, &off, sizeof( off ) );
TinySeek( handle, off, SEEK_SET );
TinyRead( handle, &head.pe, sizeof( head.pe ) );
TinyClose( handle );
handle = -1;
switch( head.pe.signature ) {
case PE_SIGNATURE:
case PL_SIGNATURE:
if( head.pe.subsystem == PE_SS_PL_DOSSTYLE ) {
_DBG_Writeln( "Want PEDHELP" );
return( HELPNAME_DS );
}
_DBG_Writeln( "Want PENHELP" );
return( HELPNAME_NS );
}
exp:
if( handle != -1 )
TinyClose( handle );
_DBG_Writeln( "Want PLSHELP" );
return( HELPNAME );
}
void CheckPointRestore( void )
{
dos_mem_block *chk;
tiny_ret_t rc;
tiny_handle_t hdl;
rc = TinyOpen( ChkFile, TIO_READ );
if( TINY_ERROR( rc ) )
return;
hdl = TINY_INFO( rc );
TinyRead( hdl, &chk, sizeof( chk ) );
TinyRead( hdl, chk, sizeof( *chk ) );
TinyRead( hdl, &chk, sizeof( chk ) );
while( TinyRead( hdl, chk, 0x8000 ) == 0x8000 ) {
chk = MK_FP( FP_SEG( chk ) + 0x800, 0 );
}
TinyClose( hdl );
Cleanup();
}
static tiny_ret_t TryPath( char *name, char *end, char *ext_list )
{
tiny_ret_t rc;
char *p;
int done;
int mode;
done = 0;
mode = 0 ; //IsDOS3 ? 0x40 : 0;
do {
if( *ext_list == '\0' ) done = 1;
for( p = end; *p = *ext_list; ++p, ++ext_list )
{}
rc = TinyOpen( name, mode );
if( TINY_OK( rc ) ) {
TinyClose( TINY_INFO( rc ) );
return( rc );
}
++ext_list;
} while( !done );
return( rc );
}
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 ) );
}
static char *SearchPath( const char __far *env, const char *file, char *buff, char **pendname )
{
char *endname;
char *name;
tiny_ret_t rc;
char save[20];
unsigned len;
char *ptr;
if( env == NULL ) {
CopyStr( ";", buff );
} else {
CopyStr( ";", CopyStr( env, CopyStr( ".;", buff ) ) );
}
name = buff;
len = strlen( file );
while( *name ) {
endname = name;
while( *endname != ';' )
++endname;
memcpy( save, endname, len + 2 );
ptr = endname;
if( name != ptr && ptr[-1]!=':' && ptr[-1]!='/' && ptr[-1]!='\\' ) {
*ptr++ = '\\';
}
memcpy( ptr, file, len + 1 );
rc = TinyOpen( name, 0 );
if( TINY_OK( rc ) ) {
TinyClose( TINY_INFO( rc ) );
break;
}
memcpy( endname, save, len + 2 );
name = endname + 1;
}
*pendname = endname;
return( name );
}
static void AddModHandle( char *name, epsp_t *epsp )
/**************************************************/
{
mod_t *mod;
tiny_ret_t rc;
int handle;
object_record obj;
unsigned_32 off;
os2_flat_header os2_hdr;
addr_off new_base;
unsigned i;
if( ModHandles == NULL ) {
ModHandles = malloc( sizeof( mod_t ) );
} else {
ModHandles = realloc( ModHandles, ( NumModHandles + 1 ) * sizeof( mod_t ) );
}
mod = &ModHandles[NumModHandles];
++NumModHandles;
mod->epsp = epsp;
mod->loaded = TRUE;
mod->SegCount = 0;
mod->ObjInfo = NULL;
if( XVersion >= 0x404 ) {
name = epsp->FileName;
}
rc = TinyOpen( name, TIO_READ );
if( TINY_ERROR( rc ) ) {
return;
}
handle = TINY_INFO( rc );
TinySeek( handle, OS2_NE_OFFSET, SEEK_SET );
TinyRead( handle, &off, sizeof( off ) );
TinySeek( handle, off, SEEK_SET );
TinyRead( handle, &os2_hdr, sizeof( os2_hdr ) );
TinySeek( handle, os2_hdr.objtab_off + off, SEEK_SET );
mod->SegCount = os2_hdr.num_objects;
mod->ObjInfo = malloc( os2_hdr.num_objects * sizeof( seg_t ) );
new_base = 0;
for( i = 0; i < os2_hdr.num_objects; ++i ) {
TinyRead( handle, &obj, sizeof( obj ) );
mod->ObjInfo[i].flags = obj.flags;
mod->ObjInfo[i].base = obj.addr;
mod->ObjInfo[i].size = obj.size;
mod->ObjInfo[i].new_base = new_base;
new_base += ALIGN4K( obj.size );
if( NumModHandles == 1 ) { // main executable
if( obj.flags & OBJ_BIG ) {
if( obj.flags & OBJ_EXECUTABLE ) {
if( flatCode == FLAT_SEL ) {
flatCode = ( mod->epsp->SegBase + i * 8 ) | 3;
}
} else {
if( flatData == FLAT_SEL ) {
flatData = ( mod->epsp->SegBase + i * 8 ) | 3;
}
}
}
}
}
TinyClose( handle );
}
trap_retval ReqProg_load( void )
{
addr_seg psp;
pblock parmblock;
tiny_ret_t rc;
char *parm;
char *name;
char __far *dst;
char exe_name[128];
char ch;
EXE_TYPE exe;
prog_load_ret *ret;
unsigned len;
ExceptNum = -1;
ret = GetOutPtr( 0 );
memset( &TaskRegs, 0, sizeof( TaskRegs ) );
TaskRegs.EFL = MyFlags() & ~USR_FLAGS;
/* build a DOS command line parameter in our PSP command area */
Flags.BoundApp = FALSE;
psp = DbgPSP();
parm = name = GetInPtr( sizeof( prog_load_req ) );
if( TINY_ERROR( FindFilePath( name, exe_name, DosExtList ) ) ) {
exe_name[0] = '\0';
}
while( *parm++ != '\0' ) {} // skip program name
len = GetTotalSize() - ( parm - name ) - sizeof( prog_load_req );
if( len > 126 )
len = 126;
dst = MK_FP( psp, CMD_OFFSET + 1 );
for( ; len > 0; --len ) {
ch = *parm++;
if( ch == '\0' ) {
if( len == 1 )
break;
ch = ' ';
}
*dst++ = ch;
}
*dst = '\r';
*(byte __far *)MK_FP( psp, CMD_OFFSET ) = FP_OFF( dst ) - ( CMD_OFFSET + 1 );
parmblock.envstring = 0;
parmblock.commandln.segment = psp;
parmblock.commandln.offset = CMD_OFFSET;
parmblock.fcb01.segment = psp;
parmblock.fcb02.segment = psp;
parmblock.fcb01.offset = 0x5C;
parmblock.fcb02.offset = 0x6C;
exe = CheckEXEType( exe_name );
if( EXEhandle != 0 ) {
TinyClose( EXEhandle );
EXEhandle = 0;
}
switch( exe ) {
case EXE_RATIONAL_386:
ret->err = ERR_RATIONAL_EXE;
return( sizeof( *ret ) );
case EXE_PHARLAP_SIMPLE:
ret->err = ERR_PHARLAP_EXE;
return( sizeof( *ret ) );
}
SegmentChain = 0;
BoundAppLoading = FALSE;
rc = DOSLoadProg( exe_name, &parmblock );
if( TINY_OK( rc ) ) {
TaskRegs.SS = parmblock.startsssp.segment;
/* for some insane reason DOS returns a starting SP two less then
normal */
TaskRegs.ESP = parmblock.startsssp.offset + 2;
TaskRegs.CS = parmblock.startcsip.segment;
TaskRegs.EIP = parmblock.startcsip.offset;
psp = DOSTaskPSP();
} else {
psp = TinyAllocBlock( TinyAllocBlock( 0xffff ) );
TinyFreeBlock( psp );
TaskRegs.SS = psp + 0x10;
TaskRegs.ESP = 0xfffe;
TaskRegs.CS = psp + 0x10;
TaskRegs.EIP = 0x100;
}
TaskRegs.DS = psp;
TaskRegs.ES = psp;
if( TINY_OK( rc ) ) {
if( Flags.NoOvlMgr || !CheckOvl( parmblock.startcsip ) ) {
if( exe == EXE_OS2 ) {
opcode_type __far *loc_brk_opcode;
BoundAppLoading = TRUE;
RunProg( &TaskRegs, &TaskRegs );
loc_brk_opcode = MK_FP(TaskRegs.CS, TaskRegs.EIP);
if( *loc_brk_opcode == BRKPOINT ) {
*loc_brk_opcode = saved_opcode;
}
BoundAppLoading = FALSE;
rc = TinyOpen( exe_name, TIO_READ_WRITE );
if( TINY_OK( rc ) ) {
EXEhandle = TINY_INFO( rc );
SeekEXEset( StartByte );
WriteEXE( saved_opcode );
TinySetFileStamp( EXEhandle, EXETime, EXEDate );
TinyClose( EXEhandle );
EXEhandle = 0;
Flags.BoundApp = TRUE;
}
}
}
}
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
ret->task_id = psp;
ret->flags = 0;
ret->mod_handle = 0;
return( sizeof( *ret ) );
}
static EXE_TYPE CheckEXEType( char *name )
{
tiny_ret_t rc;
union {
tiny_ret_t rc;
tiny_file_stamp_t stamp;
} exe_time;
word value;
opcode_type brk_opcode;
static dos_exe_header head;
static os2_exe_header os2_head;
Flags.com_file = FALSE;
EXEhandle = 0;
rc = TinyOpen( name, TIO_READ_WRITE );
if( TINY_ERROR( rc ) )
return( EXE_UNKNOWN );
EXEhandle = TINY_INFO( rc );
exe_time.rc = TinyGetFileStamp( EXEhandle );
EXETime = exe_time.stamp.time;
EXEDate = exe_time.stamp.date;
if( TINY_ERROR( ReadEXE( head ) ) )
return( EXE_UNKNOWN ); /* MZ Signature */
switch( head.signature ) {
case SIMPLE_SIGNATURE: // mp
case REX_SIGNATURE: // mq
case EXTENDED_SIGNATURE: // 'P3'
return( EXE_PHARLAP_SIMPLE );
case DOS_SIGNATURE:
if( head.reloc_offset != OS2_EXE_HEADER_FOLLOWS )
return( EXE_DOS );
if( TINY_ERROR( SeekEXEset( OS2_NE_OFFSET ) ) )
return( EXE_UNKNOWN );/* offset of new exe */
if( TINY_ERROR( ReadEXE( NEOffset ) ) )
return( EXE_UNKNOWN );
if( TINY_ERROR( SeekEXEset( NEOffset ) ) )
return( EXE_UNKNOWN );
if( TINY_ERROR( ReadEXE( os2_head ) ) )
return( EXE_UNKNOWN );/* NE Signature */
if( os2_head.signature == RAT_SIGNATURE_WORD )
return( EXE_RATIONAL_386 );
if( os2_head.signature != OS2_SIGNATURE_WORD )
return( EXE_UNKNOWN );
NumSegments = os2_head.segments;
SegTable = NEOffset + os2_head.segment_off;
if( os2_head.align == 0 )
os2_head.align = 9;
SeekEXEset( SegTable + ( os2_head.entrynum - 1 ) * 8 );
ReadEXE( value );
StartByte = ( (long)value << os2_head.align ) + os2_head.IP;
SeekEXEset( StartByte );
ReadEXE( saved_opcode );
SeekEXEset( StartByte );
brk_opcode = BRKPOINT;
rc = WriteEXE( brk_opcode );
return( EXE_OS2 );
default:
Flags.com_file = TRUE;
return( EXE_UNKNOWN );
}
}
