dbgset.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 1,059 行 · 第 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:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include <string.h>
#include <ctype.h>
#include "dbgdefn.h"
#include "dbgtoken.h"
#include "dbgerr.h"
#include "dbgtoggl.h"
#include "dbglit.h"
#include "dbgmem.h"
#include "dbginfo.h"
#include "dbgio.h"
#include "mad.h"
#include "madcli.h"


extern unsigned int     ScanCmd( char * );
extern void             Scan( void );
extern char             *ScanPos( void );
extern char             *ReScan( char * );
extern bool             ScanEOC( void );
extern bool             ScanItem( bool, char **, unsigned int * );
extern void             ReqEOC( void );
extern unsigned         SetCurrRadix( unsigned int );
extern char             *GetCmdEntry( char *, int, char * );
extern char             *CnvULongDec( unsigned long, char * );
extern unsigned         ReqExpr( void );
extern unsigned         OptExpr( void );
extern void             WndUserAdd( char *, unsigned int );
extern void             CallSet( void );
extern void             ImplicitSet( void );
extern void             LookSet( void );
extern void             RadixSet( void );
extern void             SourceSet( void );
extern void             LevelSet( void );
extern void             CallConf( void );
extern void             ImplicitConf( void );
extern void             LookConf( void );
extern void             RadixConf( void );
extern void             SourceConf( void );
extern void             LevelConf( void );
extern void             DoConfig( char *,char *,void (**)(), void (**)() );
extern void             ConfigLine( char * );
extern void             WndMenuOn( void );
extern void             WndMenuOff( void );
extern void             LangInit( void );
extern void             LangFini( void );
extern bool             LangLoad( char *, int );
extern char             *StrCopy( char *, char * );
extern cmd_list         *AllocCmdList( char *, unsigned int );
extern void             FreeCmdList( cmd_list * );
extern char             *Format( char *, char *, ... );
extern void             Recog( unsigned int );
extern void             VarChangeOptions( void );
extern void             RegChangeOptions( void );
extern void             FPUChangeOptions( void );
extern void             MMXChangeOptions( void );
extern void             XMMChangeOptions( void );
extern void             AsmChangeOptions( void );
extern void             FuncChangeOptions( void );
extern void             GlobChangeOptions( void );
extern void             ModChangeOptions( void );
extern void             ConfigCmdList( char *cmds, int indent );
extern void             WndDlgTxt( char * );
extern char             *UniqStrAddr( address *addr, char *p ,unsigned);
extern char             *GetCmdName( int );
extern void             RegFindData( mad_type_kind kind, mad_reg_set_data const **pdata );
extern mad_handle       FindMAD( char *, unsigned );
extern unsigned         QualifiedSymName( sym_handle *sh, char *name, unsigned max, bool uniq );
extern void             AddrFloat( address * );
unsigned                GetMADNormalizedString( mad_string, unsigned, char * );

extern char             OnOffNameTab[];
extern char             *TxtBuff;
extern char             *Language;
extern char             WndNameTab[];
extern tokens           CurrToken;
extern margins          SrcMar;
extern margins          AsmMar;
extern system_config    SysConfig;

static char_ring        *SupportRtns;

typedef struct pending_toggle_list      pending_toggle_list;

struct pending_toggle_list {
    pending_toggle_list *next;
    mad_handle          mad;
    char                toggle[1]; /* variable sized */
};

typedef enum {
    MWT_ASM,
    MWT_REG,
    MWT_FPU,
    MWT_MMX,
    MWT_XMM,
    MWT_LAST
} mad_window_toggles;

static pending_toggle_list *PendToggleList[MWT_LAST];

static char SetNameTab[] = {
    "AUtosave\0"
    "ASsembly\0"
    "Variable\0"
    "FUnctions\0"
    "GLobals\0"
    "MOdules\0"
    "REGister\0"
    "Fpu\0"
    "MMx\0"
    "XMm\0"
    "Bell\0"
    "Call\0"
    "Dclick\0"
    "Implicit\0"
    "INput\0"
    "Radix\0"
    "RECursion\0"
    "SEarch\0"
    "SOurce\0"
    "SYmbol\0"
    "TAb\0"
    "TYpes\0"
    "Level\0"
    "LAnguage\0"
    "MAcro\0"
    "SUpportroutine\0"
};

static void     AutoConf( void );
static void     AsmConf( void );
static void     VarConf( void );
static void     FuncConf( void );
static void     GlobConf( void );
static void     ModConf( void );
static void     RegConf( void );
static void     FPUConf( void );
static void     MMXConf( void );
static void     XMMConf( void );
extern void     DClickConf( void );
extern void     TabConf( void );
extern void     TypeConf( void );
extern void     InputConf( void );
extern void     MacroConf( void );
static void     BellConf( void );
extern void     SearchConf( void );
static void     LangConf( void );
static void     RecursionConf( void );
static void     SupportConf( void );

static void     BadSet( void );
static void     AutoSet( void );
static void     AsmSet( void );
static void     VarSet( void );
static void     FuncSet( void );
static void     GlobSet( void );
static void     ModSet( void );
static void     RegSet( void );
static void     FPUSet( void );
static void     MMXSet( void );
static void     XMMSet( void );
extern void     DClickSet( void );
static void     BellSet( void );
extern void     TabSet( void );
extern void     TypeSet( void );
static void     LangSet( void );
extern void     InputSet( void );
extern void     MacroSet( void );
extern void     SearchSet( void );
static void     RecursionSet( void );
static void     SupportSet( void );

static void (* const SetJmpTab[])( void ) = {
    &BadSet,
    &AutoSet,
    &AsmSet,
    &VarSet,
    &FuncSet,
    &GlobSet,
    &ModSet,
    &RegSet,
    &FPUSet,
    &MMXSet,
    &XMMSet,
    &BellSet,
    &CallSet,
    &DClickSet,
    &ImplicitSet,
    &InputSet,
    &RadixSet,
    &RecursionSet,
    &SearchSet,
    &SourceSet,
    &LookSet,
    &TabSet,
    &TypeSet,
    &LevelSet,
    &LangSet,
    &MacroSet,
    &SupportSet,
};

static void (* SetConfJmpTab[])( void ) = {
    &AutoConf,
    &AsmConf,
    &VarConf,
    &FuncConf,
    &GlobConf,
    &ModConf,
    &RegConf,
    &FPUConf,
    &MMXConf,
    &XMMConf,
    &BellConf,
    &CallConf,
    &DClickConf,
    &ImplicitConf,
    &InputConf,
    &RadixConf,
    &RecursionConf,
    &SearchConf,
    &SourceConf,
    &LookConf,
    &TabConf,
    &TypeConf,
    &LevelConf,
    &LangConf,
    &MacroConf,
    &SupportConf,
    NULL,
};


static void (* SetNotAllTab[])( void ) =
{
    &CallConf,
    &LevelConf,
    &LangConf,
    &InputConf,
    NULL,
};




bool SwitchOnOff( void )
{
    unsigned which;

    which = ScanCmd( OnOffNameTab );
    if( which == 0 ) Error( ERR_LOC, LIT( ERR_WANT_ON_OFF ) );
    ReqEOC();
    return( which == 1 );
}


void ShowSwitch( bool on )
{
    GetCmdEntry( OnOffNameTab, on ? 1 : 2, TxtBuff );
    ConfigLine( TxtBuff );
}


static void BadSet( void )
{
    Error( ERR_LOC, LIT( ERR_BAD_SUBCOMMAND ), GetCmdName( CMD_SET ) );
}


/*
 * ProcSet -- process set command
 */


void ProcSet( void )
{
    (*SetJmpTab[ ScanCmd( SetNameTab ) ])();
}


void ConfigSet( void )
{
    DoConfig( GetCmdName( CMD_SET ), SetNameTab, SetConfJmpTab, SetNotAllTab );
}


/*
 * BellSet - set bell on/off processing
 */

static void BellSet( void )
{
    _SwitchSet( SW_BELL, SwitchOnOff() );
}

static void BellConf( void )
{
    ShowSwitch( _IsOn( SW_BELL ) );
}


/*
 * AutoSet - set autoconfig on/off processing
 */

static void AutoSet( void )
{
    _SwitchSet( SW_AUTO_SAVE_CONFIG, SwitchOnOff() );
}

static void AutoConf( void )
{
    ShowSwitch( _IsOn( SW_AUTO_SAVE_CONFIG ) );
}


/*
 * RecursionSet - set recursion checking on/off processing
 */

static void RecursionSet( void )
{
    _SwitchSet( SW_RECURSE_CHECK, SwitchOnOff() );
}

static void RecursionConf( void )
{
    ShowSwitch( _IsOn( SW_RECURSE_CHECK ) );
}


bool LangSetInit( void )
{
    static char InitialLang[] = { "cpp" };

    LangInit();
    _Alloc( Language, sizeof( InitialLang ) + 1 );
    if( Language == NULL ) return( FALSE );
    StrCopy( InitialLang, Language );
    return( LangLoad( Language, strlen( Language ) ) );
}

void LangSetFini( void )
{
    _Free( Language );
    LangFini();
}




/*
 * NewLang -- load a new expression language, if different from current one
 */

void NewLang( char *lang )
{
    char       *new;
    unsigned    len;

    if( lang == NULL ) return;
    strlwr( lang );
    len = strlen( lang );
    if( (len != strlen( Language )) || memcmp( lang, Language, len ) != 0 ) {
        new = DbgMustAlloc( len + 1 );
        memcpy( new, lang, len );
        new[ len ] = NULLCHAR;
        if( !LangLoad( new, len ) ) {
            LangLoad( Language, strlen( Language ) );
            _Free( new );
            Error( ERR_NONE, LIT( ERR_NO_LANG ) );
        }
        _Free( Language );
        Language = new;
    }
}


static void LangSet( void )
{
    char        *start;
    unsigned    len;

    ScanItem( TRUE, &start, &len );
    ReqEOC();
    NewLang( start );
}

static void LangConf( void )
{
    ConfigLine( Language );
}


/*
        Individual Window Settings
*/
#define ONCE_FOR_ALL_SWITCHES \
    once( SW_ASM_SOURCE ) \
    once( SW_ASM_HEX ) \
    once( SW_VAR_WHOLE_EXPR ) \
    once( SW_VAR_SHOW_CODE ) \
    once( SW_VAR_SHOW_INHERIT ) \
    once( SW_VAR_SHOW_COMPILER ) \
    once( SW_VAR_SHOW_MEMBERS ) \
    once( SW_VAR_SHOW_PRIVATE ) \
    once( SW_VAR_SHOW_PROTECTED ) \
    once( SW_VAR_SHOW_STATIC ) \
    once( SW_FUNC_D2_ONLY ) \
    once( SW_GLOB_D2_ONLY ) \
    once( SW_MOD_ALL_MODULES )

enum {
    #define once( x ) x,
    ONCE_FOR_ALL_SWITCHES
    #undef once
};

typedef struct window_toggle {
    char        on;
    char        off;
    char        sw;
} window_toggle;

enum {
    ON,
    OFF
};


static void SwitchTwiddle( int which, int on )
{
    switch( which ) {
    #define once( x ) \
    case x: \
        _SwitchSet( x, on ); \
        break;
    ONCE_FOR_ALL_SWITCHES
    #undef once
    }
}

static int SwitchIsOn( int which )
{
    switch( which ) {
    #define once( x ) \
    case x: \
        return( _IsOn( x ) ); \
        break;
    ONCE_FOR_ALL_SWITCHES
    #undef once
    }
    return( 0 );
}

static const mad_toggle_strings *GetMADToggleList( const mad_reg_set_data *rsd )
{
    if( rsd == NULL ) return( MADDisasmToggleList() );
    return( MADRegSetDisplayToggleList( rsd ) );
}

static unsigned DoMADToggle( const mad_reg_set_data *rsd, unsigned on, unsigned off )
{
    if( rsd == NULL ) return( MADDisasmToggle( on, off ) );
    return( MADRegSetDisplayToggle( rsd, on, off ) );
}

static void PendingAdd( mad_window_toggles wt, mad_handle mh,
                        char *name, unsigned len )
{
    pending_toggle_list **owner;
    pending_toggle_list *new;

    owner = &PendToggleList[wt];
    for( ;; ) {
        new = *owner;
        if( new == NULL ) break;
        owner = &new->next;
    }
    new = DbgMustAlloc( sizeof( *new ) + len );
    *owner = new;
    new->next = NULL;
    new->mad = mh;
    memcpy( new->toggle, name, len );
    new->toggle[len] = '\0';
}


static bool DoOneToggle( mad_window_toggles wt )
{
    unsigned                    bit;
    char                        *start;
    unsigned                    len;
    const mad_toggle_strings    *toggles;
    const mad_reg_set_data      *rsd;

    if( !ScanItem( TRUE, &start, &len ) ) return( FALSE );
    switch( wt ) {