コード例 #1
0
static void     CallInit( a_window *wnd )
{
    int                 row;
    call_window         *call = WndCall( wnd );
    traceback           *curr,*prev;
    call_chain          *chain;
    int                 i;

    UpdateTraceBack( &call->tb );
    curr = call->tb.curr;
    prev = call->tb.prev;
    WndNoSelect( wnd );
    if( curr->clean_size == 0 || curr->total_depth < prev->total_depth ) {
        WndRepaint( wnd );
    } else {
        row = curr->total_depth;
        if( prev->total_depth > row ) {
            row = prev->total_depth;
        }
        while( --row >= curr->clean_size ) {
            WndRowDirty( wnd, row );
        }
    }
    call->max_sym_len = 0;
    chain = curr->chain;
    for( i = 0; i < curr->current_depth; ++i ) {
        if( chain[ i ].sym_len == 0 ) {
            chain[ i ].sym_len = WndExtentX( wnd, chain[ i ].symbol );
        }
        if( chain[ i ].sym_len > call->max_sym_len ) {
            call->max_sym_len = chain[ i ].sym_len;
        }
    }
}
コード例 #2
0
ファイル: dbgwbrk.c プロジェクト: Azarien/open-watcom-v2
static void     BrkModify( a_window *wnd, int row, int piece )
{
    brkp        *bp;

    if( row < 0 ) {
        BrkMenuItem( wnd, MENU_BREAK_CREATE_NEW, row, piece );
        return;
    }
    bp = BrkGetBP( row );
    if( bp == NULL )
        return;
    if( piece == PIECE_ACTIVE ) {
        WndRowDirty( wnd, row );
        WndBreak( wnd )->toggled_break = true;
        ActPoint( bp, !bp->status.b.active );
#ifdef OPENER_GADGET
    } else if( piece == PIECE_OPENER ) {
        if( bp->size == 0 ) {
            if( bp->source_line != NULL ) {
                WndSrcInspect( bp->loc.addr );
            } else {
                WndAsmInspect( bp->loc.addr );
            }
        }
#endif
    } else {
        WndFirstMenuItem( wnd, row, piece );
    }
}
コード例 #3
0
static  void    FileModify( a_window *wnd, int row, int piece )
{
    file_window *file = WndFile( wnd );
    address     addr;

    if( piece == PIECE_BREAK ) {
        addr = GetRowAddr( file, row, TRUE );
        if( IS_NIL_ADDR( addr ) ) return;
        file->toggled_break = ( ( WndFlags & UP_BREAK_CHANGE ) == 0 );
        ToggleBreak( addr );
        WndRowDirty( wnd, row );
    } else {
        WndFirstMenuItem( wnd, row, piece );
    }
}
コード例 #4
0
static  void    FuncModify( a_window *wnd, int row, int piece )
{
    address     addr;
    func_window *func = WndFunc( wnd );

    if( piece == PIECE_BREAK ) {
        if( row < 0 ) return;
        if( row >= NameListNumRows( NameList( func ) ) ) return;
        addr = NameListAddr( NameList( func ), row );
        func->toggled_break = ( ( UpdateFlags & UP_BREAK_CHANGE ) == 0 );
        ToggleBreak( addr );
        WndRowDirty( wnd, row );
    } else {
        WndFirstMenuItem( wnd, row, piece );
    }
}
コード例 #5
0
static void AsmSetDotAddr( a_window *wnd, address addr )
{
    mod_handle  mod;
    asm_window  *asw = WndAsm( wnd );

    if( AddrComp( asw->dotaddr, addr ) != 0 ) {
        WndRowDirty( wnd, -TITLE_SIZE );
        asw->dotaddr = addr;
        DeAliasAddrMod( addr, &mod );
        if( mod != asw->mod ) {
            DbgUpdate( UP_OPEN_CHANGE );
            asw->mod = mod;
            AsmSetTitle( wnd );
        }
        if( IS_NIL_ADDR( addr ) ) return;
        if( wnd == WndFindActive() ) {
            SrcMoveDot( asw->src, addr );
            SetCodeDot( addr );
        }
    }
}
コード例 #6
0
ファイル: dbgwrep.c プロジェクト: Azarien/open-watcom-v2
static void RepRefresh( a_window *wnd )
{
    event_record        *ev;
    gui_ord             extent, max_addr, max_cue;
    int                 count, row;

    if( EventList != NULL )
        WndMoveCurrent( wnd, RepNumRows( wnd ) - 1, 0 );
    max_addr = 0;
    max_cue = 0;
    count = 0;
    for( ev = EventList; ev != NULL; ev = ev->next ) {
        RepInitEv( ev );
        extent = WndExtentX( wnd, ev->addr_string );
        if( max_addr < extent )
            max_addr = extent;
        extent = WndExtentX( wnd, ev->cue );
        if( max_cue < extent )
            max_cue = extent;
        ++count;
    }
    max_addr += WndMaxCharX( wnd );
    max_cue += WndMaxCharX( wnd );
    if( Indents[PIECE_SOURCE] != max_addr ||
        Indents[PIECE_COMMAND] != max_addr + max_cue ) {
        WndRepaint( wnd );
    } else {
        row = count;
        while( --row >= LastEventCount ) {
            WndRowDirty( wnd, row );
        }
    }
    LastEventCount = count;
    Indents[PIECE_ADDRESS] = 0;
    Indents[PIECE_SOURCE] = max_addr;
    Indents[PIECE_COMMAND] = max_addr + max_cue;
}
コード例 #7
0
static  void    VarModify( a_window *wnd, int row, int piece )
{
    var_node            *v;
    type_kind           class;
    var_window          *var = WndVar( wnd );
    bool                ok;
    bool                followable;
    unsigned            old;

    if( row < 0 ) {
        if( var->vtype == VAR_WATCH || var->vtype == VAR_VARIABLE ) {
            VarMenuItem( wnd, MENU_VAR_NEW_EXPRESSION, row, piece );
        }
        return;
    }
    VarErrState();
    VarKillExprSPCache( &var->i );
    v = VarFindRow( &var->i, row );
    if( v == NULL ) {
        v = VarFindRowNode( &var->i, row );
        if( v == NULL ) return;
        if( piece != VAR_PIECE_GADGET && piece != VAR_PIECE_NAME ) return;
        if( v->expand != NULL || v->node_type == NODE_INHERIT ) {
            VarExpandRow( &var->i, v, row );
            WndNewCurrent( wnd, row, VAR_PIECE_NAME );
            VarRepaint( wnd );
        }
        return;
    }
    followable = VarGetStackClass( &class );
    switch( piece ) {
    case VAR_PIECE_GADGET:
    case VAR_PIECE_NAME:
        if( VarExpandable( class ) || followable || v->expand != NULL ) {
            VarExpandRow( &var->i, v, row );
            WndNewCurrent( wnd, row, VAR_PIECE_NAME );
            VarRepaint( wnd );
        }
        break;
    case VAR_PIECE_VALUE:
        if( !VarExpandable( class ) ) {
            char *value = DbgAlloc( TXT_LEN );
            char *name = DbgAlloc( TXT_LEN );
            old = VarNewCurrRadix( v );
            ExprValue( ExprSP );
            VarBuildName( &var->i, v, FALSE );
            StrCopy( TxtBuff, name );
            VarPrintText( &var->i, value, PrintValue, TXT_LEN );
            VarKillExprSPCache( &var->i );
            v = VarFindRow( &var->i, row );
            FreezeStack();
            ok = DlgAnyExpr( name, value, TXT_LEN );
            UnFreezeStack( FALSE );
            if( ok ) VarDoAssign( &var->i, v, value );
            NewCurrRadix( old );
            WndRowDirty( wnd, row );
            DbgFree( value );
            DbgFree( name );
        }
        break;
    }
    VarDoneRow( &var->i );
    VarOldErrState();
}
コード例 #8
0
ファイル: wpsamp.c プロジェクト: Azarien/open-watcom-v2
STATIC void sampFixDirtyCurr( a_window *wnd )
/*******************************************/
{
    sio_data        *curr_sio;
    wp_srcfile      *src_file;
    rtn_info        *curr_rtn;
    int             src_line;
    int             row;
    int             piece;

    curr_sio = WndExtra( wnd );
    WndGetCurrent( wnd, &row, &piece );
    if( row == WND_NO_ROW ) return;
    if( curr_sio->level_open == LEVEL_SAMPLE ) {
        if( !simageGetLine( wnd, row ) ) return;
    } else if( curr_sio->level_open == LEVEL_IMAGE ) {
        if( !smodGetLine( wnd, row ) ) return;
    } else if( curr_sio->level_open == LEVEL_MODULE ) {
        if( !sfileGetLine( wnd, row ) ) return;
    } else if( curr_sio->level_open == LEVEL_FILE ) {
        if( !srtnGetLine( wnd, row ) ) return;
    } else {
        if( curr_sio->level_open == LEVEL_ROUTINE ) {
            if( !ssrcGetLine( wnd, row ) ) return;
        } else {
            if( !sasmGetLine( wnd, row ) ) return;
        }
        src_line = row + 1;
        if( curr_sio->level_open == LEVEL_SOURCE ) {
            src_line = WPAsmFindSrcLine( curr_sio, src_line );
        }
        curr_rtn = curr_sio->curr_rtn;
        findRtnFromRow( curr_sio, src_line );
        if( curr_rtn != curr_sio->curr_rtn ) {
            WndRowDirty( wnd, LEVEL_ROUTINE-STATUS_ROW-1+WndTop(wnd) );
        }
        src_file = curr_sio->src_file;
        if( src_file != NULL ) {
            src_file->samp_line = src_line;
        }
    }
    curr_sio->curr_proc_row = -WND_MAX_ROW;
    if( row != curr_sio->curr_display_row ) {
        curr_sio->curr_display_row = row;
        if( curr_sio->total_samples == 0 || localTicks == 0 ) {
            curr_sio->abs_count = 0;
            curr_sio->rel_count = 0;
        } else {
            curr_sio->abs_count = (dispCount*1000) / curr_sio->total_samples;
            curr_sio->rel_count = (dispCount*1000) / localTicks;
        }
        curr_sio->abs_on_screen = absGraphBar;
        curr_sio->rel_on_screen = relGraphBar;
        if( dispCount > 0 ) {
            if( curr_sio->rel_count == 0 ) {
                curr_sio->rel_count = 1;
            }
            if( curr_sio->abs_count == 0 ) {
                curr_sio->abs_count = 1;
            }
        }
        WndRowDirty( wnd, -2+WndTop(wnd) );
    }
}
コード例 #9
0
OVL_EXTERN void     IOMenuItem( a_window wnd, gui_ctl_id id, wnd_row row, wnd_piece piece )
{
    io_window   *io = WndIO( wnd );
    address     addr;
    bool        ok;
    item_mach   item;
    io_location *curr;
    mad_radix   old_radix;

    /* unused parameters */ (void)piece;

    if( row < io->num_rows && row >= 0 ) {
        curr = &io->list[row];
    } else {
        curr = NULL;
    }
    switch( id ) {
    case MENU_INITIALIZE:
        if( curr == NULL ) {
            WndMenuGrayAll( wnd );
        } else {
            WndMenuEnableAll( wnd );
        }
        WndMenuEnable( wnd, MENU_IO_NEW_ADDRESS, true );
        break;
    case MENU_IO_DELETE:
        io->num_rows--;
        memcpy( &io->list[row], &io->list[row + 1],
                ( io->num_rows - row ) * sizeof( io_location ) );
        WndNoSelect( wnd );
        WndSetRepaint( wnd );
        break;
    case MENU_IO_NEW_ADDRESS:
        addr = NilAddr;
        if( !DlgGivenAddr( LIT_DUI( New_Port_Addr ), &addr ) )
            return;
        WndRowDirty( wnd, io->num_rows );
        IOAddNewAddr( wnd, &addr, MENU_IO_FIRST_TYPE );
        WndScrollBottom( wnd );
        break;
    case MENU_IO_MODIFY:
        if( row >= io->num_rows || row < 0 )
            break;
        if( piece == PIECE_VALUE ) {
            old_radix = NewCurrRadix( IOData.info[curr->type].piece_radix );
            item.ud = curr->value_known ? curr->value.ud : 0;
            ok = DlgMadTypeExpr( TxtBuff, &item, IOData.info[curr->type].mth );
            if( ok ) {
                curr->value = item;
                curr->value_known = true;
            }
            NewCurrRadix( old_radix );
        } else {
            addr = curr->addr;
            if( !DlgGivenAddr( LIT_DUI( New_Port_Addr ), &addr ) )
                return;
            curr->addr = addr;
            curr->value_known = false;
        }
        WndRowDirty( wnd, row );
        break;
    case MENU_IO_READ:
        curr->value_known = true;
        if( ItemGetMAD( &curr->addr, &curr->value, IT_IO, IOData.info[curr->type].mth ) == IT_NIL ) {
            curr->value_known = false;
        }
        WndPieceDirty( wnd, row, PIECE_VALUE );
        break;
    case MENU_IO_WRITE:
        if( curr->value_known ) {
            ItemPutMAD( &curr->addr, &curr->value, IT_IO, IOData.info[curr->type].mth );
        }
        break;
    default:
        curr->type = PIECE_TYPE( id );
        WndZapped( wnd );
        break;
    }
}
コード例 #10
0
static void FileTrack( a_window *wnd, cue_handle *ch )
{
    unsigned    active, old_active;
    unsigned    end_line;
    int         slack;
    file_window *file = WndFile( wnd );
    mod_handle  mod;
    cue_fileid  id;
    wnd_row     curr_row;
    int         curr_piece;

    if( ch == NULL ) {
        mod = NO_MOD;
        id = 0;
    } else {
        mod = CueMod( ch );
        id = CueFileId( ch );
    }
    if( file->viewhndl == NULL
      || file->mod != mod
      || file->file_id != id ) {
        if( file->viewhndl != NULL ) {
            FDoneSource( file->viewhndl );
        }
        file->mod = mod;
        file->file_id = id;
        FileSetDotAddr( wnd, GetCodeDot() );
        if( file->mod == NO_MOD ) {
            file->viewhndl = NULL;
        } else {
            file->viewhndl = OpenSrcFile( ch );
        }
        FileSetTitle( wnd, mod );
        SeekToTheEnd( file );
        file->eof = UINT_MAX;
        WndZapped( wnd );
        FilePosInit( wnd );
        file->active = NOT_ACTIVE;
        FilePos( wnd, 0 );
        DbgUpdate( UP_OPEN_CHANGE );
    }
    active = ActiveLine();
    if( active != file->active ) {
        FileSetDotAddr( wnd, GetCodeDot() );
        WndGetCurrent( wnd, &curr_row, &curr_piece );
        WndNoCurrent( wnd );
        if( curr_row != WND_NO_ROW ) {
            WndRowDirty( wnd, curr_row );
        }
    }
    old_active = file->active;
    file->active = NOT_ACTIVE;
    slack = WndRows( wnd ) / 4;
    if( slack > 2 )
        slack = 2;
    end_line = WndTop( wnd ) + WndRows( wnd ) - 1;
    if( old_active == NOT_ACTIVE || active > end_line ) {
        WndZapped( wnd );
        WndScroll( wnd, active - slack - WndTop( wnd ) );
    } else if( active > end_line - slack ) {
        WndRowDirtyImmed( wnd, old_active );
        WndScroll( wnd, WndRows( wnd ) - 2 * slack );
    } else if( active < WndTop( wnd ) ) {
        WndRowDirtyImmed( wnd, old_active );
        WndScroll( wnd, active - WndTop( wnd ) - slack );
    } else {
        WndRowDirty( wnd, old_active );
    }
    WndNewCurrent( wnd, active, PIECE_SOURCE );
    WndRowDirty( wnd, active );
    file->active = active;
}