jvmacc.c

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

    char                        ch;
    clear_break_req             *acc;
    brk                         *bp, *next;

    // we can assume all breaks are cleared at once

    for( bp = BPList; bp != NULL; bp = next ) {
        next = bp->next;
        LocalFree( bp );
    }
    BPList = NULL;
    acc = GetInPtr( 0 );
    ch = acc->old;
    DoWrite( acc->break_addr.offset, &ch, sizeof(ch) );
    return( 0 );
}

/*
 * runProg - run threads
 */
static unsigned runProg( bool single_step )
/*****************************************/
{
    prog_go_ret *ret;
    Classjava_lang_Thread *trd;
    unsigned_32 new_pc,old_pc;

    ret = GetOutPtr( 0 );
    if( CurrThread == NULL ) {
        ret->conditions = COND_TERMINATE;
        return( sizeof( *ret ) );
    }

    if( !single_step ) {
        EventDone(); // previous event is done
        WaitForEvent();
    } else {
        GetRegs( &old_pc, NULL, NULL, NULL );
        do {
            trd = CurrThread;
            set_single_stepping( TRUE );
            trd->single_step = TRUE;
            EventDone(); // previous event is done
            WaitForEvent();
            set_single_stepping( FALSE );
            trd->single_step = FALSE; // nyi - what if thread is dead?
            GetRegs( &new_pc, NULL, NULL, NULL );
        } while( new_pc == old_pc );
    }
    ret->conditions = Event | COND_THREAD;
    if( get_nbinclasses() > LastClassGiven ) ret->conditions |= COND_LIBRARIES;

    GetRegs( &ret->program_counter.offset, &ret->stack_pointer.offset, NULL, NULL );
    ret->program_counter.segment = 0;
    ret->stack_pointer.segment = 0;
    return( sizeof( *ret ) );
} /* runProg */

unsigned ReqProg_go()
/*******************/
{
    return( runProg( FALSE ) );
}

unsigned ReqProg_step()
/*********************/
{
    return( runProg( TRUE ) );
}

unsigned ReqRedirect_stdin()
/**************************/
{
    // never called
    return( 0 );
}

unsigned ReqRedirect_stdout()
/***************************/
{
    // never called
    return( 0 );
}

unsigned ReqGet_next_alias( void )
/********************************/
{
    get_next_alias_ret  *ret;

    ret = GetOutPtr( 0 );
    ret->seg = 0;
    ret->alias = 0;
    return( sizeof( *ret ) );
}

unsigned ReqGet_err_text( void )
/******************************/
{

    // never called
    return( 0 );
}

unsigned ReqGet_lib_name( void )
/******************************/
{
    get_lib_name_req    *acc;
    get_lib_name_ret    *ret;
    char                *name;
    int                 first;
    ClassClass          *cb;
    int                 nbinclasses = get_nbinclasses();
    ClassClass          **binclasses = get_binclasses();

    acc = GetInPtr(0);
    ret = GetOutPtr(0);

    ret->handle = 0;
    // first is 0 based, LastClassGiven is 1 based, so no increment is required
    if( acc->handle == 0 ) {
        if( nbinclasses <= LastClassGiven ) {
            return( sizeof( *ret ) );
        }
        first = LastClassGiven;
    } else {
        first = acc->handle;
    }

    if( first >= nbinclasses ) return( sizeof( *ret ) );

    cb = binclasses[ first ];
    if( cb == CbMain ) {
        ++first;
        if( first >= nbinclasses ) return( sizeof( *ret ) );
        cb = binclasses[ first ];
    }

    name = GetOutPtr( sizeof( *ret ) );
    strcpy( name, JAVAPREFIX );
    strcat( name, cb->name );

    ret->handle = LastClassGiven = first + 1;
    return( sizeof( *ret ) + strlen( name ) + 1 );
}

unsigned ReqGet_message_text( void )
/**********************************/
{
#if 0
    // we only need to implement this if we return COND_MESSAGE
    get_message_text_ret        *ret;
    char                        *err_txt;

    ret = GetOutPtr( 0 );
    ret->flags = MSG_NEWLINE | MSG_ERROR;
    err_txt = GetOutPtr( sizeof( *ret ) );
    strcpy( err_txt, "message text is NYI" );
    return( sizeof( *ret ) + strlen( err_txt ) + 1 );
#else
    return( 0 );
#endif
}

unsigned ReqThread_get_next()
/***************************/
{
    thread_get_next_req *acc;
    thread_get_next_ret *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    if( acc->thread == 0 ) {
        ret->thread = 1;
    } else {
        ret->thread = acc->thread+1;
        if( ret->thread > NumThreads ) {
            ret->thread = 0;
            return( sizeof( *ret ) );
        }
    }
    if( SysThreads[ret->thread-1] && SysThreads[ret->thread-1]->state == RUNNABLE ) {
        ret->state = THREAD_THAWED;
    } else {
        ret->state = THREAD_FROZEN;
    }
    return( sizeof( *ret ) );
}

unsigned ReqThread_set()
/**********************/
{
    thread_set_req      *acc;
    thread_set_ret      *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->old_thread = CurrThreadIdx+1;
    ret->err = 0;
    if( acc->thread != 0 ) {
        if( acc->thread <= NumThreads && SysThreads[acc->thread-1] &&
            SysThreads[acc->thread-1]->state == RUNNABLE ) {
            CurrThreadIdx = acc->thread-1;
        } else {
            ret->err = ERR_JVM_THREAD_NOT_RUNNABLE;
        }
    }
    return( sizeof( *ret ) );
}

unsigned ReqThread_freeze()
/*************************/
{
    thread_freeze_req   *acc;
    thread_freeze_ret   *ret;

    // nyi
    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->err = ERR_JVM_THREADS_NOT_SUPPORTED;
    return( sizeof( *ret ) );
}


unsigned ReqThread_thaw()
/***********************/
{
    thread_thaw_req     *acc;
    thread_thaw_ret     *ret;

    // nyi
    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->err = ERR_JVM_THREADS_NOT_SUPPORTED;
    return( sizeof( *ret ) );
}

unsigned ReqThread_get_extra()
/****************************/
{
    thread_get_extra_req        *acc;
    char                        *name;
    char                        buff[256];
    Classjava_lang_Thread*      trd;

    acc = GetInPtr( 0 );
    name = GetOutPtr( 0 );
    strcpy( name, "" );
    if( acc->thread != 0 ) {
        trd = (Classjava_lang_Thread*)unhand(Threads[acc->thread-1]);
        ThreadName( trd, buff, sizeof( buff ) );
        strcat( name, buff );

        strcat( name, " (" );
        if( SysThreads[acc->thread-1] ) {
            switch( SysThreads[acc->thread-1]->state ) {
            case RUNNABLE:
                strcat( name, "running, " );
                break;
            case SLEEPING:
                strcat( name, "sleeping, " );
                break;
            case MONITOR_WAIT:
                strcat( name, "waiting for monitor, " );
                break;
            case CONDVAR_WAIT:
                strcat( name, "waiting for conditional variable, " );
                break;
            }
        } else {
            strcat( name, "unknown state, " );
        }
        strcat( name, "priority=" );
        itoa( trd->priority, buff, 10 );
        strcat( name, buff );

        strcat( name, ")" );
    }
    return( strlen( name ) + 1 );
}

unsigned ReqFile_get_config()
/***************************/
{
    // never called
    return( 0 );
}

unsigned ReqFile_string_to_fullpath( void )
/*****************************************/
{
    // never called
    return( 0 );
}

static ClassClass *CbOpened;
unsigned ReqFile_open( void )
/***************************/
{
    file_open_req       *acc;
    file_open_ret       *ret;
    char                *buff;
    int                 i;
    int                 nbinclasses = get_nbinclasses();
    ClassClass          **binclasses = get_binclasses();

    ret = GetOutPtr( 0 );
    acc = GetInPtr( 0 );
    buff = GetInPtr( sizeof(*acc) );


    ret->err = ERR_JVM_INTERNAL_ERROR;
    if( memcmp( buff, JAVAPREFIX, sizeof( JAVAPREFIX )-1 ) == 0 ) {
        buff += sizeof( JAVAPREFIX ) - 1;
        for( i = 0; i < nbinclasses; ++i ) {
            if( strcmp( binclasses[ i ]->name, buff ) == 0 ) {
                ret->err = 0;
                CbOpened = binclasses[ i ];
                break;
            }
        }
    }
    return( sizeof( *ret ) );
}

unsigned ReqFile_seek( void )
/***************************/
{
    // never called
    return( 0 );
}

unsigned ReqFile_write( void )
/****************************/
{
    // never called
    return( 0 );
}

unsigned ReqFile_write_console( void )
/************************************/
{
    // never called
    return( 0 );
}

#define PREFIX "JAVA"
#define PREFIX_SIZE (sizeof(PREFIX)-1)
#define LENGTH (PREFIX_SIZE+sizeof(void*))

unsigned ReqFile_read( void )
/***************************/
{
    file_read_req       *acc;
    file_read_ret       *ret;
    void                *buff;
    char                tmp[LENGTH];
    unsigned            bytes;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    buff = GetOutPtr( sizeof( *ret ) );
    if( CbOpened == NULL ) return( sizeof( *ret ) );
    strcpy( tmp, PREFIX );
    *((void**)(tmp+PREFIX_SIZE)) = (void*)CbOpened;
    bytes=LENGTH;
    if( bytes > acc->len ) bytes = acc->len;
    memcpy( buff, tmp, bytes );
    ret->err = 0;
    return( sizeof( *ret ) + bytes );
}

unsigned ReqFile_close( void )
/****************************/
{
    // never called
    return( 0 );
}

unsigned ReqFile_erase( void )
/****************************/
{
    // never called
    return( 0 );

}

unsigned ReqFile_run_cmd( void )
/******************************/
{
    // never called
    return( 0 );
}

trap_version TRAPENTRY TrapInit( char *parm, char *err, bool remote )
/*******************************************************************/
{
    trap_version        ver;

    remote = remote; parm = parm;
    err[0] = '\0'; /* all ok */
    ver.major = TRAP_MAJOR_VERSION;
    ver.minor = TRAP_MINOR_VERSION;
    ver.remote = FALSE;
    sysAtexit( HandleExit );
    cbCallJava = FindClass( EE(), "sun/tools/debug/jvmhelp", TRUE );
    EventSem = CreateSemaphore( NULL, 0, 1, NULL );
    EventDoneSem = CreateSemaphore( NULL, 0, 1, NULL );
    return( ver );
}

void TRAPENTRY TrapFini()
/***********************/
{
    CloseHandle( EventSem );
    CloseHandle( EventDoneSem );
}

//OBSOLETE - use ReqRead_regs
unsigned ReqRead_cpu()
{
    return( 0 );
}

//OBSOLETE - use ReqRead_regs
unsigned ReqRead_fpu()
{
    return( 0 );
}

//OBSOLETE - use ReqWrite_regs
unsigned ReqWrite_cpu()
{
    return( 0 );
}

//OBSOLETE - use ReqWrite_regs
unsigned ReqWrite_fpu()
{
    return( 0 );
}

//OBSOLETE - use ReqMachine_data
unsigned ReqAddr_info()
{
    return( 0 );
}