dbgmisc.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 744 行 · 第 1/2 页

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  Miscellaneous odds and ends that don't have a home.
*
****************************************************************************/


#include <string.h>
#include "dbgdefn.h"
#include "dbgtoken.h"
#include "dbgerr.h"
#include "dbgtoggl.h"
#include "dbginfo.h"
#include "dbgbreak.h"
#include "dbgmem.h"
#include "dbgreg.h"
#include "trpcore.h"
#include "dui.h"
#include "dbglit.h"
#include "i64.h"


extern char             *StrCopy( char *, char * );
extern unsigned int     ReqExpr( void );
extern unsigned_64      ReqU64Expr( void );
extern void             ReqMemAddr( memory_expr ,address *);
extern unsigned         OptExpr( unsigned );
extern unsigned int     ScanCmd( char * );
extern void             DebugExit( void );
extern void             ReqEOC( void );
extern bool             ScanQuote( char **, unsigned int * );
extern bool             ScanItem( bool, char **, unsigned int * );
extern void             Scan( void );
extern bool             ScanEOC( void );
extern unsigned         Go( bool );
extern void             PopEntry( void );
extern void             NormalExpr( void );
extern cmd_list         *AllocCmdList( char *, unsigned int );
extern void             FreeCmdList( cmd_list * );
extern char             *GetCmdEntry( char *, int , char * );
extern char             *GetCmdName( int );
extern void             FlipScreen( void );
extern void             DbgUpdate( update_list );
extern void             PushCmdList( cmd_list * );
extern address          GetRegIP( void );
extern void             RecordSetRegIP( address );
extern char             *ScanPos( void );
extern char             *ReScan( char * );
extern void             DUIWndUser( void );
extern unsigned         RemoteReadUserKey( unsigned );
extern void             ReadDbgRegs( void );
extern void             WriteDbgRegs( void );
extern dtid_t           RemoteGetNextThread( dtid_t, unsigned * );
extern dtid_t           RemoteSetThreadWithErr( dtid_t, unsigned * );
extern void             RemoteThdName( dtid_t, char * );
extern void             TraceKill( void );
extern unsigned         SetCurrRadix( unsigned );
extern address          ReturnAddress( void );
extern void             SetCodeDot( address );
extern void             ChkExpr( void );
extern bool             AdvMachState( int );
extern void             CopyInpFlags( void );
extern void             FlushEOC( void );
extern void             RecordCommand( char *startpos, int cmd );
extern void             RawScanInit( void );
extern char             RawScanChar( void );
extern void             RawScanAdvance( void );
extern void             RawScanFini( void );
extern char             *CnvULongHex( unsigned long value, char *p );
extern int              AddrComp( address a, address b );

extern char             *CmdStart;
extern brk              UserTmpBrk;
extern brk              DbgTmpBrk;
extern char             *TxtBuff;
extern tokens           CurrToken;
extern char             OnOffNameTab[];
extern debug_level      DbgLevel;
extern screen_state     ScrnState;
extern thread_state     *HeadThd;
extern thread_state     *ExecThd;
extern machine_state    *DbgRegs;
extern system_config    SysConfig;
extern address          NilAddr;


static char ElseifTab[]         = { "ELSEIF\0" };
static char ElseTab[]           = { "ELSE\0" };
static char GoOptionTab[]       = { "Keep\0Noflip\0Until\0" };
static char ThreadOps[]         = { "Show\0Freeze\0Thaw\0Change\0" };

enum {
    KEEP = 1,
    NOFLIP,
    UNTIL
};


void Flip( unsigned wait )
{
    char        ch;

    if( !(ScrnState & USR_SCRN_VISIBLE) ) {
        DUIWndUser();
    }
    if( !(ScrnState & DBG_SCRN_VISIBLE) ) {
        ch = RemoteReadUserKey( wait );
    }
}

void ProcFlip( void )
{
    char        *old;
    unsigned    wait;
    unsigned    cmd;

    wait = 0;
    if( !ScanEOC() ) {
        old = ScanPos();
        cmd = ScanCmd( OnOffNameTab );
        switch( cmd ) {
        case 1:
            ReqEOC();
            _SwitchOn( SW_FLIP );
            return;
        case 2:
            ReqEOC();
            _SwitchOff( SW_FLIP );
            return;
        default:
            ReScan( old );
            wait = ReqExpr();
            ReqEOC();
            break;
        }
    }
    Flip( wait );
}


void ConfigFlip( void )
{
    char *p;

    ReqEOC();
    p = StrCopy( GetCmdName( CMD_FLIP ), TxtBuff );
    *p++ = ' ';
    GetCmdEntry( &OnOffNameTab, _IsOn( SW_FLIP ) ? 1 : 2, p );
    DUIDlgTxt( TxtBuff );
}

/*
 * ProcRemark - process a remark command
 */

void ProcRemark( void )
{
    char        c;

    RawScanInit();
    for( ;; ) {
        c = RawScanChar();
        if( c == '\0' ) break;
        RawScanAdvance();
        /* The CR character indicates end of line in a multi-line command
           list. */
        if( c == '\r' ) break;
    }
    RawScanFini();
}



/*
 * ProcDo - process do command
 */

void ProcDo( void )
{
    NormalExpr();
    PopEntry();
    ReqEOC();
}


void ProcAssign( void )
{
    char        *startpos;

    if( !AdvMachState( ACTION_ASSIGNMENT ) ) {
        FlushEOC();
        return;
    }
    startpos = ScanPos();
    NormalExpr();
    PopEntry();
    ReqEOC();
    RecordCommand( startpos, CMD_ASSIGN );
}


static void SetTempBreak( address addr )
{
    NullStatus( &UserTmpBrk );
    UserTmpBrk.status.b.has_address = TRUE;
    UserTmpBrk.status.b.active = TRUE;
    UserTmpBrk.loc.addr = addr;
}


void GoToAddr( address addr )
{
    if( IS_NIL_ADDR( addr ) ) return;
    SetTempBreak( addr );
    Go( TRUE );
    NullStatus( &UserTmpBrk );
}


void StepIntoFunction( char *func )
{
    char        *old;
    address     stop;

    old = ReScan( func );
    ReqMemAddr( EXPR_CODE, &stop );
    ReScan( old );
    GoToAddr( stop );
}


void SkipToAddr( address addr )
{
    if( IS_NIL_ADDR( addr ) ) return;
    if( !AdvMachState( ACTION_MODIFY_IP ) ) return;
    RecordSetRegIP( addr );
    DbgUpdate( UP_CSIP_CHANGE | UP_REG_CHANGE );
}


void GoToReturn( void )
{
    address     ra;

    ra = ReturnAddress();
    if( !IS_NIL_ADDR( ra ) ) {
        GoToAddr( ra );
    } else {
        Error( ERR_NONE, LIT( ERR_NO_RETURN_ADDRESS ) );
    }
}


/*
 * ProcGo -- process go command
 */

void ProcGo( void )
{
    address     start;
    address     stop;
    bool        have_start;
    bool        have_stop;
    bool        have_keep;
    bool        doflip;
    bool        flip_on;
    bool        until;
    unsigned    conditions;
    int         count;

    have_keep = FALSE;
    doflip = TRUE;
    until = FALSE;
    while( CurrToken == T_DIV ) {
        Scan();
        switch( ScanCmd( GoOptionTab ) ) {
        case KEEP:
            have_keep = TRUE;
            break;
        case NOFLIP:
            doflip = FALSE;
            break;
        case UNTIL:
            until = TRUE;
            break;
        default:
            Error( ERR_LOC, LIT( ERR_BAD_OPTION ), GetCmdName( CMD_GO ) );
        }
    }
    if( !have_keep ) TraceKill();
    NullStatus( &DbgTmpBrk );
    start = GetRegIP();
    have_stop = FALSE;
    have_start = FALSE;
    if( !ScanEOC() ) {
        stop = start;
        ReqMemAddr( EXPR_GIVEN, &stop );
        if( CurrToken == T_COMMA ) {
            start = stop;
            have_start = TRUE;
            Scan();
            if( !ScanEOC() ) {
                ReqMemAddr( EXPR_GIVEN, &stop );
                have_stop = TRUE;
            }
        } else {
            have_stop = TRUE;
        }
    }
    ReqEOC();
    count = 0;
    do {
        if( have_stop ) {
            if( have_keep ) {
                if( UserTmpBrk.status.b.has_address ) {
                    NullStatus( &UserTmpBrk );
                    UserTmpBrk.status.b.has_address = TRUE;
                } else {
                    NullStatus( &UserTmpBrk );
                }
                Error( ERR_NONE, LIT( ERR_INCONSISTENT_GO ) );
            }
            SetTempBreak( stop );
        } else if( have_keep ) {
            if( UserTmpBrk.status.b.has_address ) {
                UserTmpBrk.status.b.active = TRUE;
            }
        } else {
            NullStatus( &UserTmpBrk );
        }
        if( have_start ) {
            RecordSetRegIP( start );
        }
        flip_on = _IsOn( SW_FLIP );
        if( !doflip ) {
            _SwitchOff( SW_FLIP );
        }
        conditions = Go( doflip );
        if( flip_on ) _SwitchOn( SW_FLIP );
        if( UserTmpBrk.status.b.has_address ) {
            NullStatus( &UserTmpBrk );
            UserTmpBrk.status.b.has_address = TRUE;
        } else {
            NullStatus( &UserTmpBrk );
        }
    } while( until && (conditions & COND_BREAK) && AddrComp( stop, GetRegIP() ) != 0 && ++count < 100 );
}