_WCRTLINK int dup2( int handle1, int handle2 )
{
rdos_handle_type *obj = 0;
if( handle1 == handle2 )
return( handle2 );
if( handle2 < 0 )
return( -1 );
while( handle2 >= handle_count )
GrowHandleArr( );
RdosEnterSection( handle_section );
if( handle1 >= 0 && handle1 < handle_count )
if( handle_ptr[handle1] )
obj = handle_ptr[handle1];
if( obj )
obj->ref_count++;
RdosLeaveSection( handle_section );
if( obj ) {
if( ReplaceHandleEntry( handle2, obj ) )
return( handle2 );
else
obj->ref_count--;
}
return( -1 );
}
void AddWatch( struct TDebug *obj, int Sel, long Offset, int Size )
{
struct TDebugWatch *neww;
struct TDebugWatch *w;
int found = FALSE;
neww = (struct TDebugWatch *)malloc( sizeof( struct TDebugWatch ) );
InitDebugWatch( neww, Sel, Offset, Size );
RdosEnterSection( obj->FSection );
neww->Next = 0;
w = obj->WatchList;
if( w ) {
while( w->Next ) {
if( w->Sel == Sel && w->Offset == Offset )
found = TRUE;
w = w->Next;
}
if( !found )
w->Next = neww;
}
else
obj->WatchList = neww;
RdosLeaveSection( obj->FSection );
}
void ClearWatch( struct TDebug *obj, int Sel, long Offset, int Size )
{
struct TDebugWatch *w;
struct TDebugWatch *delw;
RdosEnterSection( obj->FSection );
w = obj->WatchList;
if( w ) {
if( w->Offset == Offset && w->Sel == Sel ) {
obj->WatchList = w->Next;
free( w );
}
else
{
while( w->Next ) {
delw = w->Next;
if( delw->Offset == Offset && delw->Sel == Sel ) {
w->Next = delw->Next;
free( delw );
}
else
w = w->Next;
}
}
}
RdosLeaveSection( obj->FSection );
}
static void HandleTerminateProcess( struct TDebug *obj, int exitcode )
{
struct TDebugThread *t;
struct TDebugModule *m;
RdosEnterSection( obj->FSection );
while( obj->ThreadList ) {
t = obj->ThreadList->Next;
FreeDebugThread( obj->ThreadList );
free( obj->ThreadList );
obj->ThreadList = t;
}
while( obj->ModuleList ) {
m = obj->ModuleList->Next;
FreeDebugModule( obj->ModuleList );
free( obj->ModuleList );
obj->ModuleList = m;
}
obj->CurrentThread = 0;
obj->NewThread = 0;
obj->FThreadChanged = TRUE;
obj->FModuleChanged = TRUE;
RdosLeaveSection( obj->FSection );
}
int GetNextModule( struct TDebug *obj, int ModuleHandle )
{
int Handle = 0xFFFF;
struct TDebugModule *m;
struct TDebugModule *rm = 0;
RdosEnterSection( obj->FSection );
m = obj->ModuleList;
while (m)
{
if (m->FNew && m->Handle > ModuleHandle && m->Handle < Handle)
{
rm = m;
Handle = m->Handle;
}
m = m->Next;
}
RdosLeaveSection( obj->FSection );
if (rm)
{
rm->FNew = FALSE;
return Handle;
}
else
return 0;
}
void AddBreak( struct TDebug *obj, int Sel, long Offset, int Hw )
{
struct TDebugBreak *newbr;
struct TDebugBreak *b;
int found = FALSE;
newbr = (struct TDebugBreak *)malloc( sizeof( struct TDebugBreak ) );
InitDebugBreak( newbr, Sel, Offset, Hw );
RdosEnterSection( obj->FSection );
newbr->Next = 0;
b = obj->BreakList;
if( b ) {
while( b->Next ) {
if( b->Sel == Sel && b->Offset == Offset )
found = TRUE;
b = b->Next;
}
if( !found )
b->Next = newbr;
}
else
obj->BreakList = newbr;
RdosLeaveSection( obj->FSection );
}
void ClearBreak( struct TDebug *obj, int Sel, long Offset )
{
struct TDebugBreak *b;
struct TDebugBreak *delbr;
RdosEnterSection( obj->FSection );
b = obj->BreakList;
if( b ) {
if( b->Offset == Offset && b->Sel == Sel ) {
obj->BreakList = b->Next;
free( b );
}
else
{
while( b->Next ) {
delbr = b->Next;
if( delbr->Offset == Offset && delbr->Sel == Sel ) {
b->Next = delbr->Next;
free( delbr );
}
else
b = b->Next;
}
}
}
RdosLeaveSection( obj->FSection );
}
static void RemoveModule( struct TDebug *obj, int module )
{
struct TDebugModule *p;
struct TDebugModule *m;
RdosEnterSection( obj->FSection );
p = 0;
m = obj->ModuleList;
while( m ) {
if( m->Handle == module ) {
if( p )
p->Next = m->Next;
else
obj->ModuleList = m->Next;
break;
}
else {
p = m;
m = m->Next;
}
}
if( m )
free( m );
RdosLeaveSection( obj->FSection );
}
void __SetIOMode_nogrow( int handle, unsigned value )
{
RdosEnterSection( handle_section );
if( handle >= 0 && handle < handle_count )
if( handle_ptr[handle] )
handle_ptr[handle]->mode = value;
RdosLeaveSection( handle_section );
}
struct TDebugModule *LockModule( struct TDebug *obj, int Handle )
{
struct TDebugModule *m;
RdosEnterSection( obj->FSection );
m = obj->ModuleList;
while (m && m->Handle != Handle)
m = m->Next;
return m;
}
struct TDebugThread *LockThread( struct TDebug *obj, int ThreadID )
{
struct TDebugThread *t;
RdosEnterSection( obj->FSection );
t = obj->ThreadList;
while( t && t->ThreadID != ThreadID )
t = t->Next;
return t;
}
static void RemoveThread( struct TDebug *obj, int thread )
{
struct TDebugThread *p;
struct TDebugThread *t;
RdosEnterSection( obj->FSection );
p = 0;
t = obj->ThreadList;
while( t ) {
if( t->ThreadID == thread ) {
if( p )
p->Next = t->Next;
else
obj->ThreadList = t->Next;
break;
}
else {
p = t;
t = t->Next;
}
}
if( t ) {
if( t == obj->CurrentThread ) {
obj->CurrentThread = 0;
RdosLeaveSection( obj->FSection );
RdosWaitMilli( 25 );
RdosEnterSection( obj->FSection );
}
free( t );
}
RdosLeaveSection( obj->FSection );
}
unsigned __GetIOMode( int handle )
{
unsigned mode = 0;
RdosEnterSection( handle_section );
if( handle >= 0 && handle < handle_count )
if( handle_ptr[handle] )
mode = handle_ptr[handle]->mode;
RdosLeaveSection( handle_section );
return( mode );
}
void SetCurrentThread( struct TDebug *obj, int ThreadID )
{
struct TDebugThread *t;
RdosEnterSection( obj->FSection );
t = obj->ThreadList;
while( t && t->ThreadID != ThreadID )
t = t->Next;
if( t )
obj->CurrentThread = t;
RdosLeaveSection( obj->FSection );
}
signed __SetIOMode( int handle, unsigned value )
{
signed ret = -1;
RdosEnterSection( handle_section );
if( handle >= 0 && handle < handle_count )
if( handle_ptr[handle] ) {
handle_ptr[handle]->mode = value;
ret = handle;
}
RdosLeaveSection( handle_section );
return( ret );
}
static void HandleException( struct TDebug *obj, struct TExceptionEvent *event, int thread )
{
struct TDebugThread *Thread;
RdosEnterSection( obj->FSection );
Thread = obj->ThreadList;
while( Thread && Thread->ThreadID != thread )
Thread = Thread->Next;
if( Thread )
SetException( Thread, event );
RdosLeaveSection( obj->FSection );
}
static rdos_handle_type *FreeHandleEntry( int handle )
{
rdos_handle_type *obj = 0;
RdosEnterSection( handle_section );
if( handle >= 0 && handle < handle_count ) {
if( handle_ptr[handle] ) {
obj = handle_ptr[handle];
handle_ptr[handle] = 0;
}
}
RdosLeaveSection( handle_section );
return( obj );
}
int HasModule( struct TDebug *obj, const char *Name )
{
struct TDebugModule *m;
int found = FALSE;
RdosEnterSection( obj->FSection );
m = obj->ModuleList;
while (m && !found)
{
if ( !strcmp( Name, m->ModuleName ) )
found = TRUE;
m = m->Next;
}
RdosLeaveSection( obj->FSection );
return found;
}
char * __CreateInheritString( void )
{
char *str;
char *ptr;
int handle;
int remain;
int count;
rdos_handle_type *obj;
count = 0;
str = lib_malloc( MAX_INHERIT_SPACE );
remain = MAX_INHERIT_SPACE - 2 - sizeof( FILE_INHERIT );
ptr = str;
strcpy( ptr, FILE_INHERIT );
ptr += strlen( FILE_INHERIT );
*ptr = 0xd;
ptr++;
RdosEnterSection( handle_section );
for( handle = 0; handle < handle_count; handle++ ) {
obj = handle_ptr[handle];
if( obj ) {
if( obj->file_name ) {
count++;
ptr = AddInherit( ptr, handle, obj, &remain );
}
}
}
RdosLeaveSection( handle_section );
if( count ) {
*ptr = 0;
ptr++;
*ptr = 0;
return( str );
} else {
lib_free( str );
return( 0 );
}
}
static int AllocHandleEntry( rdos_handle_type *obj )
{
int i;
RdosEnterSection( handle_section );
for( i = 0; i < handle_count; i++)
if( handle_ptr[i] == 0 )
break;
if( i == handle_count )
GrowHandleArr();
handle_ptr[i] = obj;
RdosLeaveSection( handle_section );
return( i );
}
static struct TDebugModule *FindModule( struct TDebug *obj, int Cs )
{
struct TDebugModule *m;
RdosEnterSection( obj->FSection );
m = obj->ModuleList;
while (m) {
if ( m->CodeSel == Cs )
break;
m = m->Next;
}
RdosLeaveSection( obj->FSection );
return m;
}
_WCRTLINK int dup( int handle )
{
rdos_handle_type *obj = 0;
RdosEnterSection( handle_section );
if( handle >= 0 && handle < handle_count )
if( handle_ptr[handle] )
obj = handle_ptr[handle];
if( obj )
obj->ref_count++;
RdosLeaveSection( handle_section );
if( obj )
return( AllocHandleEntry( obj ) );
else
return( -1 );
}
static void InsertModule( struct TDebug *obj, struct TDebugModule *mod )
{
struct TDebugModule *m;
RdosEnterSection( obj->FSection );
mod->Next = 0;
m = obj->ModuleList;
if( m ) {
while( m->Next )
m = m->Next;
m->Next = mod;
}
else
obj->ModuleList = mod;
RdosLeaveSection( obj->FSection );
}
int IsWatch( struct TDebug *obj, int Sel, long Offset )
{
struct TDebugWatch *w;
int ok = FALSE;
RdosEnterSection( obj->FSection );
w = obj->WatchList;
while (w && !ok)
{
if (w->Sel == Sel && w->Offset == Offset)
ok = TRUE;
else
w = w->Next;
}
RdosLeaveSection( obj->FSection );
return ok;
}
int IsBreak( struct TDebug *obj, int Sel, long Offset )
{
struct TDebugBreak *b;
int ok = FALSE;
RdosEnterSection( obj->FSection );
b = obj->BreakList;
while (b && !ok)
{
if (b->Sel == Sel && b->Offset == Offset)
ok = TRUE;
else
b = b->Next;
}
RdosLeaveSection( obj->FSection );
return ok;
}
static int ReplaceHandleEntry( int handle, rdos_handle_type *new_obj )
{
int ok = 0;
rdos_handle_type *obj = 0;
RdosEnterSection( handle_section );
if( handle >= 0 && handle < handle_count ) {
if( handle_ptr[handle] )
obj = handle_ptr[handle];
handle_ptr[handle] = new_obj;
ok = 1;
}
RdosLeaveSection( handle_section );
if( obj )
FreeHandleObj( obj );
return ( ok );
}
static char GetHandle( int handle, int *rdos_handle, unsigned *mode )
{
char type;
RdosEnterSection( handle_section );
type = 0;
*rdos_handle = 0;
*mode = 0;
if( handle >= 0 && handle < handle_count ) {
if( handle_ptr[handle] ) {
*rdos_handle = handle_ptr[handle]->rdos_handle;
*mode = handle_ptr[handle]->mode;
type = handle_ptr[handle]->type;
}
}
RdosLeaveSection( handle_section );
return( type );
}
int GetNextThread( struct TDebug *obj, int ThreadID )
{
int ID = 0xFFFF;
struct TDebugThread *t;
RdosEnterSection( obj->FSection );
t = obj->ThreadList;
while( t ) {
if( t->ThreadID > ThreadID && t->ThreadID < ID )
ID = t->ThreadID;
t = t->Next;
}
RdosLeaveSection( obj->FSection );
if (ID != 0xFFFF)
return ID;
else
return 0;
}
static void InsertThread( struct TDebug *obj, struct TDebugThread *thread )
{
struct TDebugThread *t;
RdosEnterSection( obj->FSection );
thread->Next = 0;
t = obj->ThreadList;
if( t ) {
while( t->Next )
t = t->Next;
t->Next = thread;
}
else
obj->ThreadList = thread;
if( !obj->CurrentThread )
obj->CurrentThread = thread;
RdosLeaveSection( obj->FSection );
}
_WCRTLINK void __AccessSemaphore( semaphore_object *obj )
{
TID tid;
tid = GetCurrentThreadId();
#if defined( _NETWARE_CLIB )
if( tid == 0 )
return;
#endif
if( obj->owner != tid ) {
#if defined( _M_I86 )
DosSemRequest( &obj->semaphore, -1L );
#else
#if !defined( __NETWARE__ )
if( obj->initialized == 0 ) {
#if defined( __RUNTIME_CHECKS__ ) && defined( _M_IX86 )
if( obj == &InitSemaphore ) {
__fatal_runtime_error( "Bad semaphore lock", 1 );
}
#endif
__AccessSemaphore( &InitSemaphore );
if( obj->initialized == 0 ) {
#if defined( __NT__ )
obj->semaphore = __NTGetCriticalSection();
#elif defined( __QNX__ )
__qsem_init( &obj->semaphore, 1, 1 );
#elif defined( __LINUX__ )
// TODO: Access semaphore under Linux!
#elif defined( __RDOS__ )
obj->semaphore = RdosCreateSection();
#elif defined( __RDOSDEV__ )
RdosInitKernelSection(&obj->semaphore);
#else
DosCreateMutexSem( NULL, &obj->semaphore, 0, FALSE );
#endif
obj->initialized = 1;
}
__ReleaseSemaphore( &InitSemaphore );
}
#endif
#if defined( __NETWARE__ )
while( obj->semaphore != 0 ) {
#if defined (_NETWARE_CLIB)
ThreadSwitch();
#else
NXThreadYield();
#endif
}
obj->semaphore = 1;
obj->initialized = 1;
#elif defined( __NT__ )
EnterCriticalSection( obj->semaphore );
#elif defined( __QNX__ )
__qsem_wait( &obj->semaphore );
#elif defined( __LINUX__ )
// TODO: Wait for semaphore under Linux!
#elif defined( __RDOS__ )
RdosEnterSection( obj->semaphore );
#elif defined( __RDOSDEV__ )
RdosEnterKernelSection( &obj->semaphore );
#else
DosRequestMutexSem( obj->semaphore, SEM_INDEFINITE_WAIT );
#endif
#endif
obj->owner = tid;
}
obj->count++;
}
