rtdbgst.cpp

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

        break;
      case DTC_ARRAY_INIT :
      { RT_ARRAY_INIT* init;        // - run-time array initialization
        init = PointUsingOffset( RT_ARRAY_INIT, rw, cmd->array_init.offset );
        dump( FT_TEXT, "ARRAY_INIT"
            , FT_OFF,  "offset", cmd->array_init.offset
            , FT_PTR,  "addr", init
            , FT_END );
        if( CPPLIB( cmd_active )( rw, cmd ) ) {
            dumpArrayInit( init );
        }
      } break;
      case DTC_DLT_1 :
        dump( FT_TEXT, "DLT_1"
            , FT_OFF,  "offset", cmd->delete_1.offset
            , FT_RTN,  "op-delete", cmd->delete_1.op_del
            , FT_CONT );
        if( CPPLIB( cmd_active )( rw, cmd ) ) {
            dump( FT_PTR, "object", PointOffset( rw, cmd->delete_1.offset )
                , FT_END );
        } else {
            dump( FT_END );
        }
        break;
      case DTC_DLT_1_ARRAY :
        dump( FT_TEXT, "DLT_1_ARRAY"
            , FT_OFF,  "offset", cmd->delete_1.offset
            , FT_RTN,  "op-delete", cmd->delete_1.op_del
            , FT_CONT );
        if( CPPLIB( cmd_active )( rw, cmd ) ) {
            dump( FT_PTR, "object", PointOffset( rw, cmd->delete_1.offset )
                , FT_END );
        } else {
            dump( FT_END );
        }
        break;
      case DTC_DLT_2 :
        dump( FT_TEXT, "DLT_2"
            , FT_OFF,  "offset", cmd->delete_2.offset
            , FT_RTN,  "op-delete", cmd->delete_2.op_del
            , FT_OFF,  "size", cmd->delete_2.size
            , FT_CONT );
        if( CPPLIB( cmd_active )( rw, cmd ) ) {
            dump( FT_PTR, "object", PointOffset( rw, cmd->delete_2.offset )
                , FT_END );
        } else {
            dump( FT_END );
        }
        break;
      case DTC_DLT_2_ARRAY :
        dump( FT_TEXT, "DLT_2_ARRAY"
            , FT_OFF,  "offset", cmd->delete_2.offset
            , FT_RTN,  "op-delete", cmd->delete_2.op_del
            , FT_OFF,  "size", cmd->delete_2.size
            , FT_CONT );
        if( CPPLIB( cmd_active )( rw, cmd ) ) {
            dump( FT_PTR, "object", PointOffset( rw, cmd->delete_2.offset )
                , FT_END );
        } else {
            dump( FT_END );
        }
        break;
      default :
        dump( FT_TEXT, "**** UNRECOGNIZED COMMAND ****"
            , FT_END );
        break;
    }
}


static void dumpRwRoBlk(        // DUMP R/W, R/O BLOCK
    RW_DTREG* rw,               // - R/W block
    RO_DTREG* ro )              // - R/O block
{

    switch( ro->base.reg_type ) {
      case DTRG_FUN :
        dump( FT_RW,    "RW_FUN",   rw,
              FT_BYTE,  "flags",    rw->fun.flags[0],
              FT_RO,    "RO_FUN",   ro,
              FT_STATE,             ro->fun.state_table,
              FT_END );
        break;
#if 0
      case DTRG_ARRAY :
        dump( FT_RW,    "RW_ARR",   rw,
              FT_PTR,   "array",    rw->array.array,
              FT_RO,    "RO_ARR",   ro,
              FT_TSIG,              ro->array.sig,
              FT_STATE,             ro->array.state_table,
              FT_END );
        break;
      case DTRG_STATIC_INITLS :
        dump( FT_RW,    "RW_INIT_LS", rw,
              FT_PTR,   "object",     rw->init_ls.object,
              FT_RO,    "RO_INIT_LS", ro,
              FT_STATE,               ro->init_ls.state_table,
              FT_END );
        break;
#endif
      default :
        printf( "*** UNKNOWN BLOCKS *** RW=%x RO=%x\n\n", rw, ro );
        break;
    }
    printf( "\n" );
}


#ifdef FS_REGISTRATION
static void dumpFsBlock(        // DUMP NON-WATCOM FS BLOCK
    RW_DTREG* rw )              // - R/W block
{
    dump( FT_PTR, "\nBLK-FS:", rw
        , FT_PTR, "prev", rw->base.prev
        , FT_RTN, "handler", rw->base.handler
        , FT_END );
}
#endif


#ifdef PD_REGISTRATION
static void dumpPdata           // DUMP PDATA BLOCK
    ( PData* p )                // block
{
    dump( FT_PTR,   "\nPDATA:", p
        , FT_RTN,   "entry",    p->entry
        , FT_RTN,   "end",      p->end
        , FT_RTN,   "handler",  p->exc
        , FT_PTR,   "data",     p->exc_data
        , FT_RTN,   "endpr",    p->endpr
        , FT_END );
}
#endif


static void dumpDtorList        // DUMP REGISTRATION LIST
    ( const char* title         // - title
#ifdef RW_REGISTRATION
    , RW_DTREG* list            // - list to be dumped
#endif
    )
{
    indent = 0;
    dumpTitle( title );
#ifdef FS_REGISTRATION
    {
        for( ; list != (void*)-1L; list = list->base.prev ) {
            if( list->base.handler == & CPPLIB( fs_handler ) ) {
                dumpRwRoBlk( list, list->base.ro );
            } else {
                dumpFsBlock( list );
            }
        }
    }
#elif defined( PD_REGISTRATION )
    {
        CPPLIB( pd_dump_rws )( &dumpRwRoBlk, &dumpPdata );
    }
#else
    {
        for( ; list != NULL; list = list->base.prev ) {
            dumpRwRoBlk( list, list->base.ro );
        }
    }
#endif
}


static void dumpExc(            // DUMP EXCEPTION BLOCK
    ACTIVE_EXC* exc )           // - current exception
{
    dump( FT_PTR    ,"\nEXCEPTION"  ,exc
        , FT_PTR    ,"prev"         ,exc->prev
        , FT_PTR    ,"throw"        ,exc->throw_ro
        , FT_BYTE   ,"state"        ,exc->state
        , FT_BYTE   ,"fnexc-state"  ,exc->fnexc_state
        , FT_BYTE   ,"zero"         ,exc->zero_thrown
        , FT_PTR    ,"extra"        ,exc->extra_object
        , FT_PTR    ,"\n exc_area"  ,exc->exc_area
        , FT_PTR    ,"cat_try"      ,exc->cat_try
        , FT_PTR    ,"dispatch"     ,exc->dispatch
        , FT_PTR    ,"rw"           ,exc->rw
        , FT_TSIG                   ,exc->sig
        , FT_END );
}


static void dumpExcs(           // DUMP EXCEPTIONS LIST
    void )
{
    THREAD_CTL *thr;            // - thread-specific information
    ACTIVE_EXC* exc;            // - current exception

    thr = PgmThread();
    dumpTitle( "Pending Exceptions:" );
    if( NULL == thr->excepts ) {
        printf( "    *** No active exceptions\n" );
    } else {
        for( exc = thr->excepts; exc != NULL; exc = exc->prev ) {
            dumpExc( exc );
        }
    }
    dump( FT_PTR, "\nThread Control Block:", thr
        , FT_BYTE, "\n  terminated",   thr->flags.terminated
        , FT_PTR,  "\n  excepts:",     thr->excepts
        , FT_RTN,  "unexpected",       thr->unexpected
        , FT_RTN,  "terminate",        thr->terminate
        , FT_RTN,  "\n  new_handler",  thr->new_handler
        , FT_RTN,  "_new_handler",     thr->_new_handler
        , FT_PTR,  "exc_pr",           thr->exc_pr
        , FT_END );
    if( NULL != thr->exc_pr ) {
        puts( "\n_EXC_PR blocks\n" );
        for( _EXC_PR* excpr = thr->exc_pr
           ; excpr != NULL
           ; excpr = excpr->_prev ) {
            dump( FT_PTR,   "_EXC_PR",  excpr
                , FT_BYTE,  "_type",    excpr->_type
                , FT_PTR,   "rw",       excpr->_rw
                , FT_PTR,   "rtctl",    excpr->_rtc
                , FT_PTR,   "prev",     excpr->_prev
                , FT_BYTE,  "state",    excpr->_state
                , FT_CONT );
            switch( excpr->_type ) {
              default :
                dump( FT_TEXT,  "***BAD TYPE***"
                    , FT_END );
                break;
              case EXCPR_BASIC :
                dump( FT_END );
                break;
              case EXCPR_FREE :
              {
                _EXC_PR_FREE* p = (_EXC_PR_FREE*)excpr;
                dump( FT_TEXT,  "FREE"
                    , FT_PTR,   "_exc",     p->_exc
                    , FT_END );
                break;
              }
              case EXCPR_DTOR :
              {
                _EXC_PR_DTOR* p = (_EXC_PR_DTOR*)excpr;
                dump( FT_TEXT,  "DTOR"
                    , FT_PTR,   "_exc",     p->_exc
                    , FT_END );
                break;
              }
              case EXCPR_FNEXC :
              {
                _EXC_PR_FNEXC* p = (_EXC_PR_FNEXC*)excpr;
                dump( FT_TEXT,  "FNEXC"
                    , FT_PTR,   "_exc",     p->_exc
                    , FT_PTR,   "_skip",    p->_fnexc_skip
                    , FT_END );
                break;
              }
            }
        }
    }
}


extern "C"
void CPPLIB( DbgRtDumpModuleDtor )( // DUMP MODULE DTOR BLOCKS
    void )
{
#ifdef RW_REGISTRATION
    THREAD_CTL *thr;            // - thread-specific information

    thr = PgmThread();
    dumpDtorList( "\nStatic Initialization List:", _RWD_ModuleInit );
#else
    printf( "\nStatic Initialization List:\n" );
    RW_DTREG* list             // - list to be dumped
        = _RWD_ModuleInit;
    for( ; list != (void*)-1L; list = list->init_ls_st.base.prev ) {
        dumpRwRoBlk( list, list->base.ro );
    }
#endif
    printf( "\n" );
    fflush( __get_std_stream( STDOUT_FILENO ) );
}


extern "C"
void CPPLIB( DbgRtDumpAutoDtor )( // DUMP REGISTRATION BLOCKS
    void )
{
#ifdef RW_REGISTRATION
    THREAD_CTL *thr;            // - thread-specific information

    thr = PgmThread();
    dumpDtorList( "\nRegistration List:", RwTop( thr ) );
#else
    dumpDtorList( "\nRegistration List:" );
#endif
    dumpExcs();
    printf( "\n" );
    fflush( __get_std_stream( STDOUT_FILENO ) );
}


#ifdef PD_REGISTRATION

extern "C"
void __DumpPdata()
{
    PData* p = (PData*)0x430000;
    PData* l = 0;
    printf( "PDATA at 430000\n\n" );
    for( ; p->entry < p->end; ++p ) {
        if( p <= l ) {
            printf( "Out of order\n" );
        }
        printf( "%8x %8x %8x %8x %8x %8x "
              , p->entry
              , p->end
              , p->exc
              , p->exc_data
              , p->endpr
              , (char*)p->endpr - (char*)p->entry );
        if( p->endpr < p->entry
         || p->endpr >= p->end ) {
            printf( "BAD" );
        }
        printf( "\n" );
        l = p;
    }
    fflush( __get_std_stream( STDOUT_FILENO ) );
}
#endif

static void reDirSwitch         // SWITCH TWO FILE AREAS
    ( void )
{
    FILE temp;                  // - temporary area
    FILE* fp;                   // - file

    fflush( __get_std_stream( STDOUT_FILENO ) );
    temp = *__get_std_stream( STDOUT_FILENO );
    fp = fstk[ index ];
    *__get_std_stream( STDOUT_FILENO ) = *fp;
    *fp = temp;
}

static void reDirBeg            // START REDIRECTION FOR A FILE
    ( void )
{
    if( index >= MX_FSTK ) {
        puts( "DBGIO -- too many log files active" );
        fflush( __get_std_stream( STDOUT_FILENO ) );
    } else {
        char fname[32];
        FILE* fp;
        strcpy( fname, default_file );
        itoa( index, &fname[ sizeof( default_file ) - 1 ], 10 );
        fp =  fopen( fname, "wt" );
        if( NULL == fp ) {
            puts( "DBGIO -- failure to open file" );
            puts( fname );
            fstk[ index ] = 0;
        } else {
            fstk[ index ] = fp;
            reDirSwitch();
        }
    }
    ++ index;
}

static void reDirEnd            // COMPLETE REDIRECTION FOR A FILE
    ( void )
{
    if( index == 0 ) {
        puts( "DBGIO -- too many files closed" );
    } else {
        -- index;
        if( index < MX_FSTK ) {
            FILE* fp = fstk[ index ];
            if( fp != 0 ) {
                reDirSwitch();
                fclose( fstk[ index ] );
            }
        }
    }
}

extern "C"
void DbgRedirectBeg             // START REDIRECTION
    ( void )
{
    if( index == 0 ) {
        reDirBeg();
        logging = 0;
    }
}

extern "C"
int DbgRedirectEnd              // COMPLETE REDIRECTION
    ( void )
{
    int retn;                   // - # of file to view

    retn = index - 1;
    if( index > 1 || logging ) {
        fflush( __get_std_stream( STDOUT_FILENO ) );
    } else {
        reDirEnd();
    }
    return retn;
}

extern "C"
void DbgLogBeg                  // START LOGGING
    ( void )
{
    if( index == 0 ) {
        logging = 1;
    }
    reDirBeg();
}

extern "C"
int DbgLogEnd                   // END LOGGING
    ( void )
{
    if( index > 0 ) {
        reDirEnd();
    }
    return index;
}

#endif