control.cpp

开放源码的编译器open watcom 1.6.0版的源代码

        if( ImageMap[i].cls == cls ) {
            AddModuleInfo( i );
            for( j = 0; j < ImageMap[i].num_methods; ++j ) {
                if( ImageMap[i].methods[j] == meth ) {
                    return( MAKE_OFFSET( i, j, offset ) );
                }
            }
        }
    }
    return( -1 );
}

void *GetMethodPointer( addr48_off *poff )
/****************************************/
{
    addr48_off offset = *poff;
    int image,method;
    image = OFFSET_IMAGE(offset);
    method = OFFSET_METHOD(offset);
    if( image >= ImageMapTop ) return( NULL );
    if( method >= ImageMap[image].num_methods ) return( NULL );
    *poff = OFFSET_OFFSET( offset );
    return( ImageMap[ image ].methods[ method ] );
}


int GrowImageMap()
/****************/
{
    int i = ImageMapTop;
    if( ++ImageMapTop >= ImageMapSize ) {
        ImageMapSize += 10;
        ImageMap = (ImageEntry*)MSJReAlloc( ImageMap, ImageMapSize * sizeof( ImageEntry ) );
    }
    return( i );
}

extern bool StartProc( char *procname, char *clname )
/***************************************************/
// return TRUE if successful
{
    STARTUPINFO         sinfo;
    PROCESS_INFORMATION pinfo;
    wchar_t *           wclname;
    unsigned            namelen;
    DWORD               tid;

    MustBeMainThread();
    InitImageMap();
    Process.interrupting = FALSE;
    Process.task_loading = TRUE;
    Process.curr = NULL;
    Process.flags = 0;
    memset( &sinfo, 0, sizeof(sinfo) );
    sinfo.cb = sizeof(sinfo);
    if( !CreateProcess( NULL, procname, NULL, NULL, FALSE,
                        CREATE_SUSPENDED | CREATE_NEW_CONSOLE, NULL, NULL,
                        &sinfo, &pinfo) ) return FALSE;
    Process.prochdl = pinfo.hProcess;
    namelen = strlen(clname) + 1;
    wclname = (wchar_t *) alloca( namelen * sizeof(wchar_t) );
    if( wclname == NULL ) {
        EndProc();
        return FALSE;
    }
    MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, clname, namelen, wclname,
                         namelen * sizeof(wchar_t) );
    if( !SUCCEEDED( DbgManager->RequestCreateEvent( wclname, pinfo.dwProcessId ) ) ) {
        EndProc();
        return FALSE;
    }
    Process.termthread = CreateThread( NULL, 0, WaitForDeath, NULL, 0, &tid );
    if( Process.termthread == NULL ) {
        EndProc();
        return FALSE;
    }
    Process.waiting = TRUE;
    if( ResumeThread( pinfo.hThread ) == 0xFFFFFFFF ) {
        EndProc();
        return FALSE;
    }
    CloseHandle( pinfo.hThread );
    WaitForEvent();
    return TRUE;
}

extern void EndProc( void )
/*************************/
{
    MustBeMainThread();
    if( Process.curr != NULL ) {
        Process.curr->Detach();
        Process.curr->Release();
        Process.curr = NULL;
    }
    if( Process.termthread != NULL ) {
        TerminateThread( Process.termthread, 0 );
    }
    TerminateProcess( Process.prochdl, 0 );
    CloseHandle( Process.termthread );
    CloseHandle( Process.prochdl );
    InitImageMap();
}

static void GetCurrThreadPointerForThisThread()
/*********************************************/
{
#if 1
    if( CurrThreadStream != NULL ) {
        if( CurrThread_T2 != NULL ) {
            CurrThread_T2->Release();
            CurrThread_T2 = NULL;
        }
        CoGetInterfaceAndReleaseStream( CurrThreadStream, IID_IRemoteThread, (void**)&CurrThread_T2 );
        CurrThreadStream = NULL;
    }
#else
    CurrThread_T2 = CurrThread;
#endif
}

extern void ResumeProc( addr48_ptr *pc )
/**************************************/
{
    if( Process.flags != 0 ) return;    // something happened while away
    Process.waiting = TRUE;
    GetCurrThreadPointerForThisThread();
    MustSucceed( CurrThread_T2->Go() );
    WaitForEvent();
    GetPCFromThread( CurrThread_T2, pc );
}

extern void TraceProc( addr48_ptr *pc )
/*************************************/
{
    if( Process.flags != 0 ) return;    // something happened while away
    Process.waiting = TRUE;
    GetCurrThreadPointerForThisThread();
    TraceThread = CurrThread;
    MustSucceed( CurrThread_T2->StepIn() );
    WaitForEvent();
    GetPCFromThread( CurrThread_T2, pc );
    TraceThread = NULL;
}

extern void SignalDeath( void )
/*****************************/
{
    Process.flags |= COND_TERMINATE;
    if( Process.waiting ) {
        SignalEvent();
    }
}

extern void DoInterrupt( void )
/*****************************/
{
    MustBeMainThread();
    if( Process.waiting ) {
        Process.interrupting = TRUE;
        Process.curr->Break();
    }
}

extern void SetBreakpoint( addr48_ptr *addr )
/*******************************************/
{
    ObjType             objtype;
    IRemoteMethodField *obj;

    MustBeMainThread();
    obj = (IRemoteMethodField*)FindObject( addr, &objtype );
    if( obj != NULL && objtype == OBJECT_CODE ) {
        obj->SetBreakpoint( addr->offset );
    }
}

extern void ClearBreakpoint( addr48_ptr *addr )
/*********************************************/
{
    ObjType             objtype;
    IRemoteMethodField *obj;

    MustBeMainThread();
    obj = (IRemoteMethodField*)FindObject( addr, &objtype );
    if( obj != NULL && objtype == OBJECT_CODE ) {
        obj->ClearBreakpoint( addr->offset );
    }
}

extern unsigned ReadFlags( void )
/*******************************/
{
    unsigned    retval;

    retval = Process.flags;
    Process.flags = 0;
    return retval;
}

extern void ProcessQueuedRepaints( void )
/***************************************/
{
    int  i;
    RECT r;

    for( i = 0; i < NumInvalid; ++i ) {
        GetWindowRect( InvalidHWNDs[i], &r );
        InvalidateRect( InvalidHWNDs[i], &r, FALSE );
    }
    NumInvalid = 0;
}

extern unsigned_32 GetNextThread( unsigned_32 id, unsigned_8 *state )
/*******************************************************************/
{
    *state = 0;         // for now, all threads thawed
    if( id == 0 ) {
        return (unsigned_32) Process.threadtable;
    } else {
        return (unsigned_32) ((threadlist *)id)->next;
    }
}

extern unsigned_32 SetThread( unsigned_32 id )
/********************************************/
{
    threadlist *retval;

    retval = Process.threadtable;
    while( retval != NULL ) {
        if( retval->handle == CurrThread ) break;
        retval = retval->next;
    }
    if( id != 0 ) {
        CurrThread = ((threadlist *)id)->handle;
    }
    return (unsigned_32) retval;
}

extern char * GetThreadName( unsigned_32 id )
/*******************************************/
{
    return ((threadlist *)id)->name;
}


unsigned DipCue( int i, void *buff )
/***********************************/
{
    jvm_getdata_ret ret;

    AddCueInfo( i );
    ret.offset = (long)ImageMap[i].cues;
    ret.len = ImageMap[i].num_cues;
    memcpy( buff, &ret, sizeof( ret ) );
    return( sizeof( ret ) );
}

static unsigned SetCharReturn( wchar_t *uname, void *buff )
/*****************************************************/
{
    static char *ReturnValue;
    jvm_getdata_ret *ret = (jvm_getdata_ret *)buff;
    if( uname == NULL ) {
        ret->offset = (long)"";
        ret->len = 0;
    } else {
        if( ReturnValue != NULL ) MSJFree( ReturnValue );
        ReturnValue = UnicodeToASCII( uname );
        ret->offset = (long)ReturnValue;
        ret->len = strlen( ReturnValue ) + 1;
    }
    return( sizeof( *ret ) );
}

unsigned DipFileName( int i, void *buff )
/***************************************/
{
    wchar_t     *uname;

    MustBeMainThread();
    uname = NULL;
    ImageMap[i].cls->GetSourceFileName( &uname );
    return( SetCharReturn( uname, buff ) );
}

unsigned DipModName( int i, void *buff )
/************************************/
{
    wchar_t     *uname;

    MustBeMainThread();
    uname = NULL;
    ImageMap[i].cls->GetName( &uname );
    return( SetCharReturn( uname, buff ) );
}

unsigned DipModBase( int i, void *buff )
/************************************/
{
    jvm_getdata_ret *ret = (jvm_getdata_ret *)buff;

    AddAddressInfo( i );
    ret->offset = ImageMap[i].base_addr;
    ret->len = JVM_CODE_SELECTOR;
    return( sizeof( *ret ) );
}

unsigned MadUpStack( addr48_ptr *pc, addr48_ptr *newpc )
/*****************************************************/
{
    addr48_ptr  prev,curr;
    IRemoteStackFrame *frame,*junk;

    MustBeMainThread();
    newpc->segment = 0;
    newpc->offset = 0;
    if( CurrThread == NULL ) return( sizeof( *newpc ) );
    CurrThread->GetCurrentFrame( &frame );
    if( frame == NULL ) return( sizeof( *newpc ) );
    MapFrameToPC( frame, &curr );
    for( ;; ) {
        junk = frame;
        frame = NULL;
        junk->GetCallingFrame( &frame );
        junk->Release();
        if( frame == NULL ) return( sizeof( *newpc ) );
        prev = curr;
        MapFrameToPC( frame, &curr );
        if( OFFSET_IMAGE( pc->offset ) == OFFSET_IMAGE( prev.offset ) &&
            OFFSET_METHOD( pc->offset ) == OFFSET_METHOD( prev.offset ) ) {
            newpc->offset = curr.offset;
            newpc->segment = curr.segment;
            break;
        }
    }
    return( sizeof( *newpc ) );
}

unsigned DipModEnd( int i, void *buff )
/************************************/
{
    jvm_getdata_ret *ret = (jvm_getdata_ret *)buff;

    AddAddressInfo( i );
    ret->offset = ImageMap[i].end_addr;
    ret->len = JVM_CODE_SELECTOR;
    return( sizeof( *ret ) );
}

} /* end extern "C" */

static void HandleEvent( IRemoteThread *thread, unsigned cond )
/*************************************************************/
{
    if( CurrThread != thread ) {
        CurrThread = thread;
        CoMarshalInterThreadInterfaceInStream( IID_IRemoteThread, CurrThread, &CurrThreadStream );
    }
    Process.flags |= cond;
    SignalEvent();
}

static DWORD WINAPI WaitForDeath( void *parm )
/********************************************/
// in case something goes wrong, need to be able to report when the
// client process has died.
{
    parm = parm;
    WaitForSingleObject( Process.prochdl, INFINITE );
    SignalDeath();
    return 0; // thread over!
}

static bool CantDoIt( void )
/**************************/
{
    if( Process.interrupting ) {
        if( MessageBox( NULL, TRP_WIN_wanna_kill, TRP_The_WATCOM_Debugger,
                    MB_SYSTEMMODAL+MB_YESNO+MB_ICONQUESTION ) == IDYES ) {
            Process.flags |= COND_TERMINATE;
            return TRUE;
        }
    } else if( MessageBox( NULL, TRP_WIN_wanna_interrupt,
                           TRP_The_WATCOM_Debugger,
                           MB_SYSTEMMODAL+MB_YESNO+MB_ICONQUESTION ) == IDYES ){