msjacc.c

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

        if( len == 0 ) break;
        ch = *src;
        if( ch == 0 ) {
            ch = ' ';
        }
        *dst = ch;
        ++dst;
        ++src;
        --len;
    }
    *dst = 0;
    name = buff;
    len = strlen(name);
    name = strtok( name, "@" );
    clname = strtok( NULL, "@" );
    if( clname == NULL ) return sizeof(*ret);
    clname = TrimName( clname );
    if( *clname == '\0' ) return sizeof(*ret);
    TaskLoaded = StartProc( name, clname );
    InitMappings();
    if( TaskLoaded ) {
        if( DebuggerWindow != NULL ) SetForegroundWindow( DebuggerWindow );
        ret->err = 0;
        ret->task_id = 0;
        ret->flags = LD_FLAG_IS_32 | LD_FLAG_IS_PROT | LD_FLAG_HAVE_RUNTIME_DLLS;
    }
    return sizeof( *ret );
}

unsigned ReqProg_kill( void )
/***************************/
{
    prog_kill_ret *ret;

    FiniMappings();
    EndProc();
    ret = GetOutPtr( 0 );
    ret->err = 0;
    return sizeof( *ret );
}

static void SetBreak( void )
/**************************/
{
    set_break_req *req;

    req = GetInPtr( 0 );
    SetBreakpoint( &req->break_addr );
}

static void ClearBreak( void )
/****************************/
{
    clear_break_req *req;

    req = GetInPtr( 0 );
    ClearBreakpoint( &req->break_addr );
}

unsigned ReqSet_watch()
/*********************/
{
    set_watch_ret *ret;

    SetBreak();
    ret = GetOutPtr( 0 );
    ret->err = 0;
    ret->multiplier = USING_DEBUG_REG;
    return sizeof( *ret );
}

unsigned ReqClear_watch()
/***********************/
{
    ClearBreak();
    return 0;
}

unsigned ReqSet_break()
/*********************/
{
    set_break_ret *ret;

    SetBreak();
    ret = GetOutPtr( 0 );
    ret->old = 0;
    return sizeof(*ret);
}

unsigned ReqClear_break()
/***********************/
{
    ClearBreak();
    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 ReqSet_user_screen( void )
/*********************************/
{
    return( 0 );
}

unsigned ReqSet_debug_screen( void )
/**********************************/
{
    ProcessQueuedRepaints();
    return( 0 );
}

unsigned ReqGet_lib_name( void )
/******************************/
{
    get_lib_name_req    *acc;
    get_lib_name_ret    *ret;
    char                *name;

    acc = GetInPtr(0);
    ret = GetOutPtr(0);
    name = GetOutPtr( sizeof( *ret ) );
    ret->handle = GetLibName( acc->handle, name );
    return( sizeof( *ret ) );
}

static DWORD DoFmtMsg( LPTSTR *p, DWORD err, ... )
{
    va_list     args;
    DWORD       len;
    LPSTR       q;

    va_start( args, err );
    len = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL, err, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
        (LPSTR) p, 0, &args );
    while( ( q = strchr( *p, '\r' ) ) != NULL ) *q = ' ';
    while( ( q = strchr( *p, '\n' ) ) != NULL ) *q = ' ';
    va_end( args );
    return( len );
}

static char *Errors[] = {
#undef pick
#define pick( a,b,c ) c,
#include "msjepick.h"
};

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

    get_err_text_req    *acc;
    char                *err_txt;
    LPTSTR              lpMessageBuffer;
    DWORD               len;

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

#if 0
    if( acc->err == ERR_MSJ_SAVED_ERROR ) {
        strcpy( err_txt, SavedError );
    } else
#endif
    if( IsUserErr( acc->err ) ) {
        strcpy( err_txt, Errors[ ErrIndex( acc->err ) ] );
    } else {
        len = DoFmtMsg( &lpMessageBuffer, acc->err, "%1","%2","%3","%4" );
        if( len > 0 ) {
            strcpy( err_txt, lpMessageBuffer );
            LocalFree( lpMessageBuffer );
        }
    }
    return( strlen( err_txt ) + 1 );
}

unsigned ReqGet_message_text( void )
/**********************************/
{
    return 0;
}

unsigned ReqRedirect_stdin( void )
/********************************/
{
    return 0;
}

unsigned ReqRedirect_stdout( void )
/*********************************/
{
    return 0;
}

unsigned ReqSplit_cmd( void )
/***************************/
{
    char                *cmd;
    char                *start;
    split_cmd_ret       *ret;
    unsigned            len;

    cmd = GetInPtr( sizeof( split_cmd_req ) );
    ret = GetOutPtr( 0 );
    start = cmd;
    len = GetTotalSize() - sizeof( split_cmd_req );
    for( ;; ) {
        if( len == 0 ) goto done;
        switch( *cmd ) {
        case '/':
        case '=':
        case '(':
        case ';':
        case ',':
            goto done;
        case '\0':
        case ' ':
        case '\t':
            ret->parm_start = cmd - start + 1;
            ret->cmd_end = cmd - start;
            return( sizeof( *ret ) );
        }
        ++cmd;
        --len;
    }
done:
    ret->parm_start = cmd - start;
    ret->cmd_end = cmd - start;
    return( sizeof( *ret ) );
}

unsigned ReqRead_regs( void )
/***************************/
// NYI - we can't fill out this structure
{
    mad_registers _WCUNALIGNED *mr;
    addr48_ptr pc;

    mr = GetOutPtr( 0 );
    memset( mr, 0, sizeof( mr->jvm ) );
    GetPC( &pc );
    mr->jvm.pc.offset = pc.offset;
    mr->jvm.pc.segment = pc.segment;
    return( sizeof( mr->jvm ) );
}

unsigned ReqWrite_regs( void )
/****************************/
// NYI: cannot write registers
{
    return( 0 );
}

unsigned ReqMachine_data( void )
/******************************/
// NYI: what the hell does this do?
{
    machine_data_req *  acc;
    machine_data_ret *  ret;
    unsigned_8 *        data;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    data = GetOutPtr( sizeof( *ret ) );
    return sizeof( *ret );
}

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

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->thread = GetNextThread( acc->thread, &ret->state );
    return sizeof( *ret );
}

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

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->err = 0;
    ret->old_thread = SetThread( acc->thread );
    return sizeof( *ret );
}

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

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

    // freeze the thread associated with acc->thread

    ret->err = ERR_MSJ_THREADS_NOT_SUPPORTED;
    return sizeof( *ret );
}

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

    // nyi
    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    // thaw the thread associated with acc->thread
    ret->err = ERR_MSJ_THREADS_NOT_SUPPORTED;
    return sizeof( *ret );
}

unsigned ReqThread_get_extra( void )
/**********************************/
{
    thread_get_extra_req *acc;
    char *              name;
    char *              origname;

    acc = GetInPtr( 0 );
    name = GetOutPtr( 0 );
    strcpy( name, "" );
    if( acc->thread != 0 ) {
        origname = GetThreadName( acc->thread );
        strcpy( name, origname );
    }
    return( strlen( name ) + 1 );
}