dbgset.c

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

    case MWT_ASM:
        rsd = NULL;
        break;
    case MWT_FPU:
        RegFindData( MTK_FLOAT, &rsd );
        if( rsd == NULL ) {
            PendingAdd( SysConfig.mad, wt, start, len );
            return( TRUE );
        }
        break;
    case MWT_REG:
        RegFindData( MTK_INTEGER, &rsd );
        if( rsd == NULL ) {
            PendingAdd( SysConfig.mad, wt, start, len );
            return( TRUE );
        }
        break;
    case MWT_MMX:
        RegFindData( MTK_CUSTOM, &rsd );
        if( rsd == NULL ) {
            PendingAdd( SysConfig.mad, wt, start, len );
            return( TRUE );
        }
        break;
    case MWT_XMM:
        RegFindData( MTK_XMM, &rsd );
        if( rsd == NULL ) {
            PendingAdd( SysConfig.mad, wt, start, len );
            return( TRUE );
        }
        break;
    }
    bit = 1;
    toggles = GetMADToggleList( rsd );
    for( ;; ) {
        if( toggles->on == MSTR_NIL ) return( FALSE );
        GetMADNormalizedString( toggles->on, TXT_LEN, TxtBuff );
        if( TxtBuff[0] != NULLCHAR && strnicmp( start, TxtBuff, len ) == 0 ) {
            DoMADToggle( rsd, bit, 0 );
            break;
        }
        GetMADNormalizedString( toggles->off, TXT_LEN, TxtBuff );
        if( TxtBuff[0] != NULLCHAR && strnicmp( start, TxtBuff, len ) == 0 ) {
            DoMADToggle( rsd, 0, bit );
            break;
        }
        bit <<= 1;
        ++toggles;
    }
    return( TRUE );
}

void PendingToggles( void )
{
    mad_window_toggles          wt;
    pending_toggle_list         **owner;
    pending_toggle_list         *curr;
    char                        *scan;

    scan = ScanPos();
    for( wt = 0; wt < MWT_LAST; ++wt ) {
        owner = &PendToggleList[wt];
        for( ;; ) {
            curr = *owner;
            if( curr == NULL ) break;
            if( curr->mad == SysConfig.mad ) {
                ReScan( curr->toggle );
                DoOneToggle( wt );
                *owner = curr->next;
                _Free( curr );
            } else {
                owner = &curr->next;
            }
        }
    }
    ReScan( scan );
}

static bool OneToggle( mad_window_toggles wt )
{
    char                *name;
    unsigned            len;
    mad_handle          old_mad;
    mad_handle          new_mad;
    char                *scan;
    bool                res;


    scan = ScanPos();
    if( DoOneToggle( wt ) ) return( TRUE );
    ReScan( scan );
    if( !ScanItem( TRUE, &name, &len ) ) return( FALSE );
    scan = name;
    for( ;; ) {
        if( scan > &name[len] ) break;
        if( *scan == '/' ) {
            len = scan - name;
            ReScan( scan );
            break;
        }
        ++scan;
    }
    if( CurrToken != T_DIV ) return( FALSE );
    Scan();
    new_mad = FindMAD( name, len );
    if( new_mad == MAD_NIL ) return( FALSE );
    if( MADLoaded( new_mad ) != MS_OK ) {
        /* put the toggle on the pending list */
        if( !ScanItem( TRUE, &name, &len ) ) return( FALSE );
        PendingAdd( wt, new_mad, name, len );
        return( TRUE );
    }
    old_mad = MADActiveSet( new_mad );
    res = DoOneToggle( wt );
    MADActiveSet( old_mad );
    return( res );
}

static void ToggleWindowSwitches( window_toggle *toggle, int len,
                                char *settings, mad_window_toggles wt )
{
    int idx;
    int i;

    while( !ScanEOC() ) {
        if( settings != NULL ) {
            idx = ScanCmd( settings );
            for( i = 0; i < len; ++i ) {
                if( toggle[ i ].on == idx ) {
                    SwitchTwiddle( toggle[ i ].sw, 1 );
                    break;
                }
                if( toggle[ i ].off == idx ) {
                    SwitchTwiddle( toggle[ i ].sw, 0 );
                    break;
                }
            }
        }
        if( i == len || settings == NULL ) {
            if( wt >= MWT_LAST || !OneToggle( wt ) ) {
                Error( ERR_LOC, LIT( ERR_BAD_SUBCOMMAND ), GetCmdName( CMD_SET ) );
            }
        }
    }
}

static char *DumpAToggle( char *p, mad_handle mh, char *toggle )
{
    if( toggle[0] != NULLCHAR ) {
        MADNameDescription( mh, TXT_LEN - (p-TxtBuff), p );
        for( ;; ) {
            if( *p == '\0' ) break;
            if( *p == ' ' ) break;
            ++p;
        }
        *p++ = '/';
        p = StrCopy( toggle, p );
        *p++ = ' ';
    }
    return( p );
}

struct dump_toggles {
    mad_window_toggles          wt;
    char                        *p;
};

static walk_result DumpToggles( mad_handle mh, void *d )
{
    struct dump_toggles         *td = d;
    const mad_toggle_strings    *toggles;
    unsigned                    bit;
    char                        buff[80];
    const mad_reg_set_data      *rsd;

    if( MADLoaded( mh ) != MS_OK ) return( WR_CONTINUE );
    switch( td->wt ) {
    case MWT_FPU:
        RegFindData( MTK_FLOAT, &rsd );
        if( rsd == NULL ) return( WR_CONTINUE );
        break;
    case MWT_REG:
        RegFindData( MTK_INTEGER, &rsd );
        if( rsd == NULL ) return( WR_CONTINUE );
        break;
    case MWT_MMX:
        RegFindData( MTK_CUSTOM, &rsd );
        if( rsd == NULL ) return( WR_CONTINUE );
        break;
    case MWT_XMM:
        RegFindData( MTK_XMM, &rsd );
        if( rsd == NULL ) return( WR_CONTINUE );
        break;
    default:
        rsd = NULL;
        break;
    }
    bit = DoMADToggle( rsd, 0, 0 );
    toggles = GetMADToggleList( rsd );
    while( toggles->menu != MSTR_NIL ) {
        if( bit & 1 ) {
            GetMADNormalizedString( toggles->on, sizeof( buff ), buff );
        } else {
            GetMADNormalizedString( toggles->off, sizeof( buff ), buff );
        }
        td->p = DumpAToggle( td->p, mh, buff );
        bit >>= 1;
        ++toggles;
    }
    return( WR_CONTINUE );
}

static void ConfWindowSwitches( window_toggle *toggle, int len, char *settings,
                        mad_window_toggles wt )
{
    struct dump_toggles data;
    pending_toggle_list *curr;
    char                *ptr;
    int                 i;

    ptr = TxtBuff;
    for( i = 0; i < len; ++i ) {
        ptr = GetCmdEntry( settings,
                           SwitchIsOn( toggle[ i ].sw ) ?
                               toggle[ i ].on :
                               toggle[ i ].off,
                           ptr );
        *ptr++= ' ';
    }
    if( wt < MWT_LAST ) {
        data.wt = wt;
        data.p = ptr;
        MADWalk( DumpToggles, &data );
        ptr = data.p;
        for( curr = PendToggleList[wt]; curr != NULL; curr = curr->next ) {
            ptr = DumpAToggle( ptr, curr->mad, curr->toggle );
        }
    }
    *ptr = '\0';
    ConfigLine( TxtBuff );
}


/*
        Assembly window
*/

static char AsmSettings[] = {
    "Source\0"
    "NOSource\0"
    "Hexadecimal\0"
    "Decimal\0"
};

enum {
    ASM_SOURCE = 1,
    ASM_NOSOURCE,
    ASM_HEX,
    ASM_DECIMAL,
};

static window_toggle    AsmToggle[] = {
    { ASM_SOURCE, ASM_NOSOURCE, SW_ASM_SOURCE },
    { ASM_HEX, ASM_DECIMAL, SW_ASM_HEX },
};

static void AsmSet( void )
{
    ToggleWindowSwitches( AsmToggle, ArraySize( AsmToggle ), AsmSettings, MWT_ASM );
    AsmChangeOptions();
}

static void AsmConf( void )
{
    ConfWindowSwitches( AsmToggle, ArraySize( AsmToggle ), AsmSettings, MWT_ASM );
}

/*
        FPU Window
*/

static void FPUSet( void )
{
    ToggleWindowSwitches( NULL, 0, NULL, MWT_FPU );
    FPUChangeOptions();
}

static void FPUConf( void )
{
    ConfWindowSwitches( NULL, 0, NULL, MWT_FPU );
}

/*
        Variables window
*/

static char VarSettings[] = {
    "Entire\0"
    "Partial\0"
    "CODe\0"
    "NOCODe\0"
    "INherit\0"
    "NOINherit\0"
    "COMpiler\0"
    "NOCOMpiler\0"
    "PRIvate\0"
    "NOPRIvate\0"
    "PROtected\0"
    "NOPROTected\0"
    "STatic\0"
    "NOSTatic\0"
    "Members\0"
    "NOMembers\0"
};

enum {
    VAR_ENTIRE = 1,
    VAR_PARTIAL,
    VAR_CODE,
    VAR_NOCODE,
    VAR_INHERIT,
    VAR_NOINHERIT,
    VAR_COMPILER,
    VAR_NOCOMPILER,
    VAR_PRIVATE,
    VAR_NOPRIVATE,
    VAR_PROTECTED,
    VAR_NOPROTECTED,
    VAR_STATIC,
    VAR_NOSTATIC,
    VAR_MEMBERS,
    VAR_NOMEMBERS,
};

static window_toggle VarToggle[] = {
    { VAR_ENTIRE, VAR_PARTIAL, SW_VAR_WHOLE_EXPR },
    { VAR_CODE, VAR_NOCODE, SW_VAR_SHOW_CODE },
    { VAR_INHERIT, VAR_NOINHERIT, SW_VAR_SHOW_INHERIT },
    { VAR_COMPILER, VAR_NOCOMPILER, SW_VAR_SHOW_COMPILER },
    { VAR_MEMBERS, VAR_NOMEMBERS, SW_VAR_SHOW_MEMBERS },
    { VAR_PRIVATE, VAR_NOPRIVATE, SW_VAR_SHOW_PRIVATE },
    { VAR_PROTECTED, VAR_NOPROTECTED, SW_VAR_SHOW_PROTECTED },
    { VAR_STATIC, VAR_NOSTATIC, SW_VAR_SHOW_STATIC },
};

static void VarSet( void )
{
    ToggleWindowSwitches( VarToggle, ArraySize( VarToggle ), VarSettings, MWT_LAST );
    VarChangeOptions();
}

static void VarConf( void )
{
    ConfWindowSwitches( VarToggle, ArraySize( VarToggle ), VarSettings, MWT_LAST );
    ConfigLine( TxtBuff );
}


static char FuncSettings[] = {
    "Typed\0"
    "All\0"
};

enum {
    FUNC_TYPED = 1,
    FUNC_ALL,
};

static window_toggle FuncToggle[] = {
    { FUNC_TYPED, FUNC_ALL, SW_FUNC_D2_ONLY },
};

static void FuncSet( void )
{
    ToggleWindowSwitches( FuncToggle, ArraySize( FuncToggle ), FuncSettings, MWT_LAST );
    FuncChangeOptions();
}

static void FuncConf( void )
{
    ConfWindowSwitches( FuncToggle, ArraySize( FuncToggle ), FuncSettings, MWT_LAST );
}


static window_toggle GlobToggle[] = {
    { FUNC_TYPED, FUNC_ALL, SW_GLOB_D2_ONLY },
};

static void GlobSet( void )
{
    ToggleWindowSwitches( GlobToggle, ArraySize( GlobToggle ), FuncSettings, MWT_LAST );
    GlobChangeOptions();
}

static void GlobConf( void )
{
    ConfWindowSwitches( GlobToggle, ArraySize( GlobToggle ), FuncSettings, MWT_LAST );
}


static window_toggle ModToggle[] = {
    { FUNC_ALL, FUNC_TYPED, SW_MOD_ALL_MODULES },
};

static void ModSet( void )
{
    ToggleWindowSwitches( ModToggle, ArraySize( ModToggle ), FuncSettings, MWT_LAST );
    ModChangeOptions();
}

static void ModConf( void )
{
    ConfWindowSwitches( ModToggle, ArraySize( ModToggle ), FuncSettings, MWT_LAST );
}


static void RegSet( void )
{
    ToggleWindowSwitches( NULL, 0, NULL, MWT_REG );
    RegChangeOptions();
}

static void RegConf( void )
{
    ConfWindowSwitches( NULL, 0, NULL, MWT_REG );
}


static void MMXSet( void )
{
    ToggleWindowSwitches( NULL, 0, NULL, MWT_MMX );
    MMXChangeOptions();
}

static void MMXConf( void )
{
    ConfWindowSwitches( NULL, 0, NULL, MWT_MMX );
}


static void XMMSet( void )
{
    ToggleWindowSwitches( NULL, 0, NULL, MWT_XMM );
    XMMChangeOptions();
}

static void XMMConf( void )
{
    ConfWindowSwitches( NULL, 0, NULL, MWT_XMM );
}


void SupportFini( void )
{
    char_ring   *curr, *junk;

    curr = SupportRtns;
    while( curr != NULL ) {
        junk = curr;
        curr = curr->next;
        _Free( junk );
    }
    SupportRtns = NULL;
}


static void SupportSet( void )
{
    char_ring   *new;
    char        *start;
    unsigned    len;
    unsigned    count;

    count = 0;
    while( ScanItem( TRUE, &start, &len ) ) {
        new = DbgMustAlloc( sizeof( *new ) + len );
        new->next = SupportRtns;
        SupportRtns = new;
        memcpy( new->name, start, len );
        new->name[len] = '\0';
        ++count;
    }
    ReqEOC();
    if( count == 0 ) {
        SupportFini();
    }
}

static void SupportConf( void )
{
    char_ring   *curr;
    char        *p;

    p = TxtBuff;
    for( curr = SupportRtns; curr != NULL; curr = curr->next ) {
        p = StrCopy( "}", StrCopy( curr->name, StrCopy( "{", p ) ) );
        if( p - TxtBuff > 50 ) {
            ConfigLine( TxtBuff );
            p = TxtBuff;
        }
    }
    if( p != TxtBuff ) {
        ConfigLine( TxtBuff );
    }
}

static bool SupportName( char *name, char *pattern )
{
    for( ;; ) {
        if( *name == '\0' && *pattern == '\0' ) return( TRUE );
        if( *pattern == '*' ) return( TRUE );
        if( *name != *pattern ) return( FALSE );
        ++name;
        ++pattern;
    }
}

bool IsSupportRoutine( sym_handle *sym )
{
    char_ring                   *curr;
    char                        name[TXT_LEN];

    QualifiedSymName( sym, name, sizeof( name ), TRUE );
    for( curr = SupportRtns; curr != NULL; curr = curr->next ) {
        if( SupportName( name, curr->name ) ) return( TRUE );
    }
    return( FALSE );
}