os2v2acc.c

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

                *data = resdata >> 8;
                data++;
                offv++;
                length--;
            }
        }
    }
    return( size - length );
}


void DoWritePgmScrn( char *buff, USHORT len )
{
    USHORT  written;

    DosWrite( 2, buff, len, &written );
    BreakPoint( 0 );
}

unsigned ReqGet_sys_config( void )
{
    USHORT        version;
    USHORT        shift;
    dos_debug     buff;
    char          tmp[DBG_CO_SIZE];
    get_sys_config_ret  *ret;

    ret = GetOutPtr(0);
    ret->sys.os = OS_OS2;
    DosGetVersion( &version );
    ret->sys.osminor = version & 0xff;
    ret->sys.osmajor = version >> 8;
    ret->sys.cpu = X86CPUType();
    ret->sys.fpu = ret->sys.cpu & X86_CPU_MASK;
    WriteRegs( &Buff );

    buff.Cmd = DBG_C_ReadCoRegs;
    buff.Buffer = MakeLocalPtrFlat( tmp );
    buff.Tid = 1;
    buff.Pid = Pid;
    buff.Value = DBG_CO_387;    /* for 2.0: DBG_CO_387 */
    buff.Len = DBG_CO_SIZE;     /* for 2.0: size of register state */
    buff.Index = 0;             /* for 2.0: must be 0 */
    CallDosDebug( &buff );
    if( buff.Cmd != DBG_N_Success ) {
        ret->sys.fpu = X86_NO;
    }
    DosGetHugeShift( &shift );
    ret->sys.huge_shift = shift;
    ret->sys.mad = MAD_X86;
    return( sizeof( *ret ) );
}


unsigned ReqMap_addr( void )
{
    USHORT              seg;
    ULONG               flags;
    map_addr_req        *acc;
    map_addr_ret        *ret;
    unsigned            i;
    addr_off            off;

    acc = GetInPtr(0);
    ret = GetOutPtr(0);
    ret->lo_bound = 0;
    ret->hi_bound = ~(addr48_off)0;
    if( Pid == 0 ) {
        ret->out_addr = acc->in_addr;
        return( sizeof( *ret ) );
    }

    GetObjectInfo( ModHandles[ acc->handle ] );

    seg = acc->in_addr.segment;
    off = acc->in_addr.offset;
    switch( seg ) {
    case MAP_FLAT_CODE_SELECTOR:
    case MAP_FLAT_DATA_SELECTOR:
        seg = 1;
        off += ObjInfo[0].addr;
        for( i = 0; i < NumObjects; ++i ) {
            if( ObjInfo[i].addr <= off
             && (ObjInfo[i].addr + ObjInfo[i].size) > off ) {
                seg = i + 1;
                off -= ObjInfo[i].addr;
                ret->lo_bound = ObjInfo[i].addr - ObjInfo[0].addr;
                ret->hi_bound = ret->lo_bound + ObjInfo[i].size - 1;
                break;
            }
        }
        break;
    }

    Buff.MTE = ModHandles[ acc->handle ];
    Buff.Cmd = DBG_C_NumToAddr;
    Buff.Value = seg;
    CallDosDebug( &Buff );
    Buff.MTE = ModHandles[ 0 ];
    flags = ObjInfo[seg-1].flags;
    if( flags & OBJECT_IS_BIG ) {
        ret->out_addr.segment = (flags & OBJECT_IS_CODE) ? FlatCS : FlatDS;
        ret->out_addr.offset = Buff.Addr + off;
    } else {
        Buff.Cmd = DBG_C_LinToSel;
        CallDosDebug( &Buff );
        ret->out_addr.segment = Buff.Value;
        ret->out_addr.offset = Buff.Index + off;
    }
    return( sizeof( *ret ) );
}

unsigned ReqAddr_info( void )
{
    addr_info_req       *acc;
    addr_info_ret       *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->is_32 = Is32BitSeg( acc->in_addr.segment );
    return( sizeof( *ret ) );
}

unsigned ReqMachine_data( void )
{
    machine_data_req    *acc;
    machine_data_ret    *ret;
    unsigned_8          *data;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    data = GetOutPtr( sizeof( *ret ) );
    ret->cache_start = 0;
    ret->cache_end = ~(addr_off)0;
    *data = 0;
    if( Is32BitSeg( acc->addr.segment ) ) *data |= X86AC_BIG;
    return( sizeof( *ret ) + sizeof( *data ) );
}

unsigned ReqChecksum_mem( void )
{
    ULONG         offset;
    USHORT        length;
    ULONG         sum;
    checksum_mem_req    *acc;
    checksum_mem_ret    *ret;

    acc = GetInPtr(0);
    ret = GetOutPtr(0);
    length = acc->len;
    sum = 0;
    if( Pid != 0 ) {
        offset = acc->in_addr.offset;
        while( length != 0 ) {
            Buff.Cmd = DBG_C_ReadMem_D;
            Buff.Addr = MakeItFlatNumberOne( acc->in_addr.segment, offset );
            CallDosDebug( &Buff );
            if( Buff.Cmd != DBG_N_Success ) {
                break;
            }
            sum += Buff.Value & 0xff;
            offset++;
            length--;
            if( length != 0 ) {
                sum += Buff.Value >> 8;
                offset++;
                length--;
            }
        }
    }
    ret->result = sum;
    return( sizeof( *ret ) );
}


unsigned ReqRead_mem( void )
{
    read_mem_req        *acc;
    void                *ret;
    unsigned            len;

    acc = GetInPtr(0);
    ret = GetOutPtr(0);
    len = ReadBuffer( ret, acc->mem_addr.segment, acc->mem_addr.offset, acc->len );
    return( len );
}


unsigned ReqWrite_mem( void )
{
    write_mem_req       *acc;
    write_mem_ret       *ret;
    unsigned            len;

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

    len = GetTotalSize() - sizeof(*acc);

    ret->len = WriteBuffer( GetInPtr(sizeof(*acc)),
                            acc->mem_addr.segment, acc->mem_addr.offset, len );
    return( sizeof( *ret ) );
}

static void ReadCPU( struct x86_cpu *r )
{
    r->eax = Buff.EAX;
    r->ebx = Buff.EBX;
    r->ecx = Buff.ECX;
    r->edx = Buff.EDX;
    r->esi = Buff.ESI;
    r->edi = Buff.EDI;
    r->esp = Buff.ESP;
    r->ebp = Buff.EBP;
    r->ds = Buff.DS;
    r->cs = Buff.CS;
    r->es = Buff.ES;
    r->ss = Buff.SS;
    r->fs = Buff.FS;
    r->gs = Buff.GS;
    r->eip = Buff.EIP;
    r->efl = Buff.EFlags;
    if( !Is32BitSeg( Buff.CS ) ) {
        r->eip &= 0xffff;
    }
    if( !Is32BitSeg( Buff.SS ) ) {
        r->esp &= 0xffff;
        r->ebp &= 0xffff;
    }
}

static void WriteCPU( struct x86_cpu *r )
{
    Buff.EAX = r->eax ;
    Buff.EBX = r->ebx ;
    Buff.ECX = r->ecx ;
    Buff.EDX = r->edx ;
    Buff.ESI = r->esi ;
    Buff.EDI = r->edi ;
    Buff.ESP = r->esp ;
    Buff.EBP = r->ebp ;
    Buff.DS = r->ds ;
    Buff.CS = r->cs ;
    Buff.ES = r->es ;
    Buff.SS = r->ss ;
    Buff.FS = r->fs ;
    Buff.GS = r->gs ;
    Buff.EIP = r->eip ;
    Buff.EFlags = r->efl ;
    lastSS = Buff.SS;
    lastESP = Buff.ESP;
    lastCS = Buff.CS;
    lastEIP = Buff.EIP;
}

unsigned ReqRead_cpu( void )
{
    trap_cpu_regs *regs;

    regs = GetOutPtr(0);
    memset( regs, 0, sizeof( trap_cpu_regs ) );
    if( Pid != 0 ) {
        ReadRegs( &Buff );
        ReadCPU( (struct x86_cpu *) regs );
    }
    return( sizeof( *regs ) );
}

unsigned ReqRead_fpu( void )
{
    Buff.Cmd = DBG_C_ReadCoRegs;
    Buff.Buffer = (ULONG) MakeLocalPtrFlat( GetOutPtr(0) );
    Buff.Value = DBG_CO_387;        /* for 2.0: DBG_CO_387 */
    Buff.Len = DBG_CO_SIZE;         /* for 2.0: size of register state */
    Buff.Index = 0;                 /* for 2.0: must be 0 */
    CallDosDebug( &Buff );
    if( Buff.Cmd == DBG_N_CoError ) {
        return( 0 );
    } else {
        return( DBG_CO_SIZE );
    }
}

unsigned ReqWrite_cpu( void )
{
    trap_cpu_regs       *regs;

    regs = GetInPtr(sizeof(write_cpu_req));
    if( Pid != 0 ) {
        WriteCPU( (struct x86_cpu *)regs );
        WriteRegs( &Buff );
    }
    return( 0 );
}

unsigned ReqWrite_fpu( void )
{
    Buff.Cmd = DBG_C_WriteCoRegs;
    Buff.Buffer = (ULONG) MakeLocalPtrFlat( GetInPtr( sizeof(write_fpu_req) ) );
    Buff.Value = DBG_CO_387;        /* for 2.0: DBG_CO_387 */
    Buff.Len = DBG_CO_SIZE;         /* for 2.0: buffer size */
    Buff.Index = 0;                 /* for 2.0: must be zero */
    CallDosDebug( &Buff );
    return( 0 );
}

unsigned ReqRead_regs( void )
{
    mad_registers       *mr;

    mr = GetOutPtr(0);
    memset( mr, 0, sizeof( mr->x86 ) );
    if( Pid != 0 ) {
        ReadRegs( &Buff );
        ReadCPU( &mr->x86.cpu );
        Buff.Cmd = DBG_C_ReadCoRegs;
        Buff.Buffer = (ULONG) MakeLocalPtrFlat( &mr->x86.fpu );
        Buff.Value = DBG_CO_387;        /* for 2.0: DBG_CO_387 */
        Buff.Len = DBG_CO_SIZE;         /* for 2.0: size of register state */
        Buff.Index = 0;                 /* for 2.0: must be 0 */
        CallDosDebug( &Buff );
    }
    return( sizeof( mr->x86 ) );
}

unsigned ReqWrite_regs( void )
{
    mad_registers       *mr;

    mr = GetInPtr(sizeof(write_regs_req));
    if( Pid != 0 ) {
        WriteCPU( &mr->x86.cpu );
        WriteRegs( &Buff );
        Buff.Cmd = DBG_C_WriteCoRegs;
        Buff.Buffer = (ULONG) MakeLocalPtrFlat( &mr->x86.fpu );
        Buff.Value = DBG_CO_387;        /* for 2.0: DBG_CO_387 */
        Buff.Len = DBG_CO_SIZE;         /* for 2.0: buffer size */
        Buff.Index = 0;                 /* for 2.0: must be zero */
        CallDosDebug( &Buff );
    }
    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);
    if( acc->handle != 0 ) {
        CurrModHandle = acc->handle + 1;
    }
    if( CurrModHandle >= NumModHandles ) {
        ret->handle = 0;
        return( sizeof( *ret ) );
    }
    name = GetOutPtr( sizeof(*ret) );
    Buff.Value = ModHandles[ CurrModHandle ];
    DosGetModName( ModHandles[ CurrModHandle ], 128, name );
    ret->handle = CurrModHandle;
    return( sizeof( *ret ) + strlen( name ) + 1 );
}

static USHORT GetEXEFlags( char *name )
{
    HFILE       hdl;
    USHORT      type;
    ULONG       new_head;
    USHORT      exeflags;

    if( !FindNewHeader( name, &hdl, &new_head, &type ) ) {
        return( 0 );
    }
    if( type == EXE_NE ) {
        SeekRead( hdl, new_head+0x0c, &exeflags, sizeof( exeflags ) );
    } else if( type == EXE_LE || type == EXE_LX ) {
        SeekRead( hdl, new_head+0x10, &exeflags, sizeof( exeflags ) );
    } else {
        exeflags = 0;
    }
    DosClose( hdl );
    exeflags &= 0x0700;
    return( exeflags );

} /* GetEXEFlags */

static bool FindLinearStartAddress( ULONG *pLin, char *name )
{
    bool        rc;
    HFILE       hdl;
    USHORT      type;
    ULONG       new_head;
    ULONG       objnum;
    USHORT      sobjn;
    ULONG       eip;
    USHORT      ip;

    if( !FindNewHeader( name, &hdl, &new_head, &type ) ) {
        return( FALSE );
    }
    for( ;; ) {
        rc = FALSE;
        if( type == EXE_NE ) {

            if( !SeekRead( hdl, new_head+0x14, &ip, sizeof( ip ) ) ) {
                break;
            }
            eip = ip;
            if( !SeekRead( hdl, new_head+0x16, &sobjn, sizeof( sobjn ) ) ) {
                break;
            }
            objnum = sobjn;

            Is32Bit = FALSE;

        } else if( type == EXE_LE || type == EXE_LX ) {

            if( !SeekRead( hdl, new_head+0x1c, &eip, sizeof( eip ) ) ) {
                break;
            }
            if( !SeekRead( hdl, new_head+0x18, &objnum, sizeof( objnum ) ) ) {
                break;
            }

            Is32Bit = TRUE;

        } else {
            break;
        }

        Buff.Cmd = DBG_C_NumToAddr;
        Buff.Value = objnum;
        Buff.MTE = ModHandles[ 0 ];
        CallDosDebug( &Buff );
        if( Buff.Cmd != DBG_N_Success ) {
            break;
        }
        *pLin = eip + Buff.Addr;

        Buff.MTE = ModHandles[ 0 ];

        rc = TRUE;
        break;
    }
    DosClose( hdl );
    return( rc );

} /* FindLinearStartAddress */

static BOOL ExecuteUntilLinearAddressHit( ULONG lin )
{
    byte        saved;
    byte        breakpnt = 0xCC;
    BOOL        rc=TRUE;

    ReadLinear( &saved, lin, sizeof( byte ) );
    WriteLinear( &breakpnt, lin, sizeof( byte ) );
    do {
        ExceptNum = 0;
        DebugExecute( &Buff, DBG_C_Go, TRUE );
        if( ExceptNum == 0 ) {
            rc = TRUE; // dll loaded
            break;
        }
        if( ExceptNum != XCPT_BREAKPOINT ) {
            rc = FALSE;
            break;
        }
    } while( ExceptLinear != lin );
    WriteLinear( &saved, lin, sizeof( byte ) );
    return( rc );
}

void AppSession( void )
{
    if( !IsPMDebugger() )
        DosSelectSession( SID, 0 );
}

void DebugSession( void )
{
    if( !IsPMDebugger() )
        DosSelectSession( 0, 0 );
}

unsigned ReqProg_load( void )
{
    NEWSTARTDATA        start;
    char                *parms;
    char                *end;
    char                *prog;
    char                exe_name[255];
    char                appname[200];
    ULONG               startLinear;
    prog_load_ret       *ret;

    LastMTE = 0;
    ExceptNum = -1;
    ret = GetOutPtr( 0 );
    AtEnd = FALSE;
    TaskFS = 0;
    prog = GetInPtr( sizeof( prog_load_req ) );
    if( FindFilePath( prog, exe_name, OS2ExtList ) != 0 ) {
        exe_name[0] = '\0';
    }
    parms = AddDriveAndPath( exe_name, UtilBuff );
    while( *prog != '\0' ) ++prog;
    ++prog;
    end = (char *)GetInPtr( GetTotalSize()-1 ) + 1;
    MergeArgvArray( prog, parms, end - prog );

    start.Length = offsetof( NEWSTARTDATA, IconFile ); /* default for the rest */
    start.Related = 1;
    start.FgBg = !Remote;
    start.TraceOpt = 1;
    strcpy( appname, TRP_The_WATCOM_Debugger );
    strcat( appname, ": " );
    strcat( appname, exe_name );
    start.PgmTitle = (PSZ) appname;
    start.PgmName = UtilBuff;
    start.PgmInputs = parms;
    start.TermQ = 0;
    start.Environment = NULL;
    start.InheritOpt = 1;
    ret->err = 0;
    if( GetEXEFlags( UtilBuff ) == EXE_IS_PM ) {
        if( TypeProcess == SSF_TYPE_WINDOWABLEVIO ) {
            ret->err = ERROR_NOT_IN_WINDOW;
        } else {
            start.SessionType = SSF_TYPE_PM;
            if( !IsPMDebugger() ) StartPMHelp();
        }
    } else if( TypeProcess == _PT_WINDOWABLEVIO || TypeProcess == _PT_PM ) {
        start.SessionType = SSF_TYPE_WINDOWABLEVIO;
    } else if( TypeProcess == _PT_FULLSCREEN ) {
        start.SessionType = SSF_TYPE_FULLSCREEN;
    }
    if( ret->err == 0 ) {
        ret->err = DosStartSession( (void *) &start, &SID, &Pid );
    }
    if( ret->err == ERROR_SMG_START_IN_BACKGROUND ) {
        ret->err = 0;
    }
    if( ret->err != 0 ) {
        Pid = 0;
        /* may need to do this
        ret->task_id = Pid;