extern void AsmMoveDot( a_window *wnd, address addr )
{
int row;
asm_window *asw;
DIPHDL( cue, ch1 );
DIPHDL( cue, ch2 );
if( wnd == NULL ) return;
asw = WndAsm( wnd );
if( DeAliasAddrCue( asw->mod, addr, ch1 ) != SR_NONE &&
DeAliasAddrCue( asw->mod, asw->dotaddr, ch2 ) != SR_NONE ) {
if( CueMod( ch1 ) == CueMod( ch2 ) &&
CueFileId( ch1 ) == CueFileId( ch2 ) &&
CueLine( ch1 ) == CueLine( ch2 ) ) {
return;
}
}
WndNoSelect( wnd );
row = AsmAddrRow( wnd, addr );
if( row == WndRows( wnd ) ) {
AsmSetFirst( wnd, addr, TRUE );
row = AsmAddrRow( wnd, addr );
WndDirtyCurr( wnd );
WndNewCurrent( wnd, row, PIECE_CURRENT );
WndRepaint( wnd );
row = 0;
} else {
WndDirtyCurr( wnd );
WndNewCurrent( wnd, row, PIECE_CURRENT );
}
AsmSetDotAddr( wnd, addr );
}
static walk_result FindModCue( mod_handle mod, void *d )
{
DIPHDL( cue, ch );
cue_find *fd = d;
unsigned long curr_line;
fd->id = 0;
fd->ambig = FALSE;
fd->match = CMP_NONE;
if( mod != NO_MOD && fd->len != 0 ) {
WalkFileList( mod, FindCue, fd );
if( fd->id == 0 ) return( WR_CONTINUE );
if( fd->ambig ) {
Error( ERR_NONE, LIT( ERR_AMBIG_SRC_FILE ), fd->name, fd->len );
}
}
fd->found_a_file = TRUE;
switch( LineCue( mod, fd->id, CurrGet.li.name.len, 0, ch ) ) {
case SR_EXACT:
HDLAssign( cue, fd->best_ch, ch );
fd->best_line = CurrGet.li.name.len;
return( WR_STOP );
case SR_CLOSEST:
curr_line = CueLine( ch );
if( curr_line < CurrGet.li.name.len && curr_line > fd->best_line ) {
HDLAssign( cue, fd->best_ch, ch );
fd->best_line = CurrGet.li.name.len;
}
break;
case SR_FAIL:
return( WR_FAIL );
}
return( WR_CONTINUE );
}
extern bool SrcMoveDot( a_window *wnd, address addr )
{
unsigned line;
mod_handle mod;
file_window *file;
DIPHDL( cue, ch );
if( wnd == NULL ) return( FALSE );
file = WndFile( wnd );
if( file->mod == NO_MOD && !file->track ) return( FALSE );
if( IS_NIL_ADDR( addr ) ) {
WndScrollAbs( wnd, 0 );
return( FALSE );
}
DeAliasAddrMod( addr, &mod );
if( DeAliasAddrCue( mod, addr, ch ) == SR_NONE ) {
if( LineCue( mod, 0, 0, 0, ch ) == SR_NONE ) return( FALSE );
}
line = CueLine( ch );
if( mod != file->mod || CueFileId( ch ) != file->file_id ) {
if( !file->track ) return( FALSE );
FileTrack( wnd, ch );
}
--line;
WndScrollAbs( wnd, line ); //
WndMoveCurrent( wnd, line, PIECE_SOURCE );
FileSetDotAddr( wnd, addr );
FileSetTitle( wnd, CueMod( ch ) );
return( TRUE );
}
static unsigned ActiveLine( void )
{
DIPHDL( cue, ch );
if( DeAliasAddrCue( ContextMod, Context.execution, ch ) == SR_NONE ) return( 0 );
return( CueLine( ch ) - 1 );
}
bool DUIGetSourceLine( cue_handle *ch, char *buff, unsigned len )
{
void *viewhndl;
viewhndl = OpenSrcFile( ch );
if( viewhndl == NULL ) return( false );
buff[FReadLine( viewhndl, CueLine( ch ), 0, buff, len )] = NULLCHAR;
FDoneSource( viewhndl );
return( true );
}
bool DUIGetSourceLine( cue_handle *ch, char *buff, unsigned len )
{
void *viewhndl;
viewhndl = OpenSrcFile( ch );
if( viewhndl == NULL ) return( FALSE );
buff[ FReadLine( viewhndl, CueLine( ch ), 0, buff, len )] = '\0';
FDoneSource( viewhndl );
return( TRUE );
}
static remap_return ReMapOnePoint( brkp *bp, image_entry *image )
{
mod_handle himage, mod;
bool ok;
address addr;
DIPHDL( cue, ch );
DIPHDL( cue, ch2 );
remap_return rc = REMAP_REMAPPED;
if( !bp->status.b.unmapped )
return( REMAP_WRONG_IMAGE );
if( bp->image_name == NULL || bp->mod_name == NULL ) {
if( image == NULL ) {
if( ReMapAddress( &bp->loc ) ) {
rc = REMAP_REMAPPED;
} else {
rc = REMAP_ERROR;
}
} else {
rc = ReMapImageAddress( &bp->loc, image );
}
} else {
himage = LookupImageName( bp->image_name, strlen( bp->image_name ) );
if( himage == NO_MOD )
return( REMAP_ERROR );
mod = LookupModName( himage, bp->mod_name, strlen( bp->mod_name ) );
if( mod == NO_MOD )
return( REMAP_ERROR );
ok = GetBPSymAddr( bp, &addr );
if( !ok )
return( REMAP_ERROR );
if( bp->cue_diff != 0 ) {
if( DeAliasAddrCue( mod, addr, ch ) != SR_EXACT )
return( REMAP_ERROR );
if( LineCue( mod, CueFileId( ch ), CueLine( ch ) + bp->cue_diff, 0, ch2 ) != SR_EXACT )
return( REMAP_ERROR );
addr = CueAddr( ch2 );
}
if( bp->addr_diff != 0 ) {
addr.mach.offset += bp->addr_diff;
}
bp->loc.addr = addr;
rc = REMAP_REMAPPED;
}
if( rc == REMAP_REMAPPED ) {
bp->status.b.unmapped = false;
}
SetPointAddr( bp, bp->loc.addr );
if( bp->status.b.activate_on_remap ) {
ActPoint( bp, true );
}
return( rc );
}
/*
* doFindSymbol
*/
BOOL doFindSymbol( ADDRESS *addr, syminfo *si, int getsrcinfo ) {
sym_handle *symhdl;
cue_handle *cue;
search_result sr;
location_list ll;
address dipaddr;
BOOL ret;
si->segnum = -1;
si->name[0] = 0;
if( !StatShowSymbols || curProcess == NULL ) {
return( FALSE );
}
symhdl = MemAlloc( DIPHandleSize( HK_SYM ) );
dipaddr.sect_id = 0;
dipaddr.indirect = FALSE;
dipaddr.mach.offset = addr->offset;
dipaddr.mach.segment = addr->seg;
sr = AddrSym( NO_MOD, dipaddr, symhdl );
switch( sr ) {
case SR_CLOSEST:
SymLocation( symhdl, NULL, &ll );
si->symoff = addr->offset - ll.e[0].u.addr.mach.offset;
break;
case SR_EXACT:
si->symoff = 0;
break;
case SR_NONE:
ret = FALSE;
break;
}
if( sr != SR_NONE ) {
SymName( symhdl, NULL, SN_OBJECT, si->name, MAX_SYM_NAME );
// SymName( symhdl, NULL, SN_SOURCE, si->name, MAX_SYM_NAME );
if( getsrcinfo ) {
cue = MemAlloc( DIPHandleSize( HK_CUE ) );
if( AddrCue( NO_MOD, dipaddr, cue ) == SR_NONE ) {
MemFree( cue );
ret = FALSE;
} else {
CueFile( cue, si->filename, MAX_FILE_NAME );
si->linenum = CueLine( cue );
MemFree( cue );
ret = TRUE;
}
}
}
MemFree( symhdl );
return( ret );
}
extern wp_srcfile * WPSourceOpen( sio_data * curr_sio, bint quiet )
/*****************************************************************/
{
file_info * curr_file;
rtn_info * curr_rtn;
wp_srcfile * wpsrc_file;
void * src_file;
mod_info * curr_mod;
cue_handle * ch;
location_list ll;
int line;
curr_mod = curr_sio->curr_mod;
curr_file = curr_sio->curr_file;
curr_rtn = curr_sio->curr_rtn;
if( curr_file->unknown_file ) {
src_file = NULL;
} else {
src_file = FOpenSource( curr_file->name, curr_mod->mh, curr_file->fid );
}
if( src_file == NULL ) {
curr_sio->src_file = NULL;
if( !quiet ) {
if( curr_file->unknown_file ) {
ErrorMsg( LIT( Src_File_Not_Known ) );
} else {
ErrorMsg( LIT( Src_File_Not_Found ), curr_file->name );
}
}
return( NULL );
}
wpsrc_file = ProfCAlloc( sizeof( wp_srcfile ) );
wpsrc_file->src_file = src_file;
curr_sio->src_file = wpsrc_file;
if( SymLocation( curr_rtn->sh, NULL, &ll ) == DS_OK ) {
ch = alloca( DIPHandleSize( HK_CUE ) );
AddrCue( curr_mod->mh, ll.e[0].u.addr, ch );
wpsrc_file->rtn_line = CueLine( ch );
}
setSrcLineData( wpsrc_file, curr_sio, curr_mod, curr_file, curr_rtn );
line = 1;
for( ;; ) {
WPSourceGetLine( curr_sio->sample_window, line );
if( wpsrc_file->src_eof ) break;
line++;
}
wpsrc_file->src_rows = line - 1;
return( wpsrc_file );
}
/**
* Compares two cues, the first one being the one which information we use
* searching for the 2nd.
*
* @param cue The first cue.
* @param cue2 The result cue (depends on search_rc).
* @param expected_rc The expected search result.
* @param actual_rc The actual search result.
* @param exp_exact_line Set if we're to expect a matching line number.
* @param exp_le_line Set if we're to expect a less or equal line number.
* @param exp_exact_addr Set if we're to expect a matching address.
* @param exp_le_line Set if we're to expect a less or equal address.
* @param operation The name of the search operation.
*/
static void CompareCues( cue_handle *cue, cue_handle *cue2,
search_result expected_rc, search_result actual_rc,
bool exp_exact_line, bool exp_le_line,
bool exp_exact_addr, bool exp_le_addr,
const char *operation )
{
if( actual_rc != expected_rc ) {
printf( "FAILED: %s returned %d instead of %d\n", operation,
actual_rc, expected_rc );
}
if( actual_rc == SR_CLOSEST || actual_rc == SR_EXACT ) {
address addr = CueAddr( cue );
unsigned long line = CueLine( cue );
address addr2 = CueAddr( cue2 );
unsigned long line2 = CueLine( cue2 );
int failed;
failed = CueFileId( cue2 ) != CueFileId( cue );
failed |= exp_exact_line && line2 != line;
failed |= exp_le_line && line2 <= line;
failed |= exp_exact_addr
&& ( addr2.mach.segment != addr.mach.segment
|| addr2.mach.offset != addr.mach.offset );
failed |= exp_le_addr
&& ( addr2.mach.segment != addr.mach.segment
|| addr2.mach.offset <= addr.mach.offset );
if( failed ) {
printf( "FAILED: %s: cue2:{file=%#x line=%lu addr=%04x:%08lx}\n"
" %*s != cue:{file=%#x line=%lu addr=%04x:%08lx}\n",
operation,
CueFileId( cue2 ), line2, addr2.mach.segment, (long)addr2.mach.offset,
strlen( operation ), "",
CueFileId( cue ), line, addr.mach.segment, (long)addr.mach.offset );
}
}
}
brkp *FindBreakByLine( mod_handle mod, cue_fileid id, unsigned line )
{
brkp *bp;
mod_handle brk_mod;
DIPHDL( cue, ch );
for( bp = BrkList; bp != NULL; bp = bp->next ) {
if( DeAliasAddrMod( bp->loc.addr, &brk_mod ) == SR_NONE )continue;
if( brk_mod != mod )continue;
if( DeAliasAddrCue( brk_mod, bp->loc.addr, ch ) == SR_NONE ) continue;
if( CueFileId( ch ) != id ) continue;
if( CueLine( ch ) != line ) continue;
return( bp );
}
return( NULL );
}
static void AsmSetFirst( a_window *wnd, address addr, bool use_first_source )
{
int row,rows;
asm_window *asw = WndAsm( wnd );
char chr;
mad_disasm_data *dd;
unsigned addr_len;
DIPHDL( cue, ch );
_AllocA( dd, asw->ddsize );
if( IS_NIL_ADDR( addr ) || ProgPeek( addr, &chr, 1 ) != 1 ) {
addr = NilAddr;
}
asw->ins[ 0 ].addr = addr;
asw->ins[ 0 ].line = 0;
addr_len = AddrToString( &addr, MAF_OFFSET, TxtBuff, TXT_LEN ) - TxtBuff;
if( addr_len != asw->addr_len ) {
asw->addr_len = addr_len;
AsmResize( wnd ); // recusively calls this routine!
WndZapped( wnd );
return;
}
rows = WndRows( wnd );
for( row = 0; row < rows; ++row ) {
asw->ins[ row ].addr = addr;
if( IS_NIL_ADDR( addr ) ) continue;
if( ExactCueAt( asw, addr, ch ) ) {
if( row != 0 || use_first_source ) {
asw->ins[ row ].addr = addr;
asw->ins[ row ].line = CueLine( ch );
++row;
if( row >= rows ) break;
}
}
asw->ins[ row ].addr = addr;
asw->ins[ row ].line = 0;
if( MADDisasm( dd, &addr, 0 ) != MS_OK ) {
addr = NilAddr;
}
}
}
STATIC void setSrcLineData( wp_srcfile * wpsrc_file, sio_data * curr_sio,
mod_info * curr_mod, file_info * curr_file,
rtn_info * curr_rtn )
/***************************************************************************/
{
massgd_sample_addr * samp_data;
wp_srcline * lines;
rtn_info * rtn_rover;
cue_handle * ch;
clicks_t click_index;
unsigned long last_srcline;
unsigned long new_line;
int line_count;
int line_index;
int count;
int count2;
ch = alloca( DIPHandleSize( HK_CUE ) );
lines = NULL;
line_index = -1;
last_srcline = 0;
new_line = 0;
line_count = 0;
wpsrc_file->max_time = 0;
count = 0;
while( count < curr_file->rtn_count ) {
rtn_rover = curr_file->routine[count];
if( rtn_rover->tick_count == 0 ) {
count2 = 0;
} else {
click_index = rtn_rover->first_tick_index - 1;
count2 = rtn_rover->last_tick_index - click_index;
line_count += count2;
lines = ProfRealloc( lines, sizeof(wp_srcline)*line_count );
}
while( count2-- > 0 ) {
samp_data = WPGetMassgdSampData( curr_sio, click_index );
if( AddrCue( curr_mod->mh, *samp_data->raw, ch ) != SR_NONE ) {
if( CueFileId( ch ) == curr_file->fid ) {
new_line = CueLine( ch );
}
}
if( last_srcline != new_line || line_index == -1 ) {
line_index++;
lines[line_index].line = new_line;
lines[line_index].tick_count = 0;
last_srcline = new_line;
if( line_index == 0 && curr_rtn == rtn_rover ) {
wpsrc_file->samp_line = new_line;
}
}
lines[line_index].tick_count += samp_data->hits;
if( lines[line_index].tick_count > wpsrc_file->max_time ) {
wpsrc_file->max_time = lines[line_index].tick_count;
}
click_index++;
}
line_count = line_index + 1;
count++;
}
wpsrc_file->wp_line_count = line_count;
if( line_count != 0 ) {
wpsrc_file->src_lines
= ProfRealloc( lines, sizeof(wp_srcline)*line_count );
}
}
void SetPointAddr( brkp *bp, address addr )
{
DIPHDL( cue, ch );
image_entry *image;
mod_handle mod;
char const *start;
bool ok;
if( bp->status.b.unmapped )
return;
_Free( bp->source_line );
bp->source_line = NULL;
bp->loc.addr = addr;
_Free( bp->mod_name );
bp->mod_name = NULL;
_Free( bp->image_name );
bp->image_name = NULL;
_Free( bp->sym_name );
bp->sym_name = NULL;
bp->cue_diff = 0;
bp->addr_diff = 0;
if( !IS_BP_EXECUTE( bp->th ) ) {
GetWPVal( bp );
} else if( DeAliasAddrMod( addr, &mod ) != SR_NONE ) {
image = ImageEntry( mod );
if( image == NULL )
return;
ModName( mod, TxtBuff, TXT_LEN );
bp->mod_name = DupStr( TxtBuff );
if( image->image_name != NULL ) {
start = SkipPathInfo( image->image_name, OP_REMOTE );
bp->image_name = DupStrLen( start, ExtPointer( start, OP_REMOTE ) - start );
} else {
bp->image_name = NULL;
}
switch( DeAliasAddrCue( NO_MOD, addr, ch ) ) {
case SR_EXACT:
bp->source_line = CopySourceLine( ch );
Format( TxtBuff, "%d", CueLine( ch ) );
bp->sym_name = DupStr( TxtBuff );
ok = GetBPSymAddr( bp, &addr );
break;
case SR_CLOSEST:
Format( TxtBuff, "%d", CueLine( ch ) );
bp->sym_name = DupStr( TxtBuff );
bp->addr_diff = addr.mach.offset - CueAddr( ch ).mach.offset;
ok = GetBPSymAddr( bp, &addr );
break;
default:
ok = false;
}
if( !ok ) {
_Free( bp->image_name );
_Free( bp->mod_name );
_Free( bp->sym_name );
bp->image_name = NULL;
bp->mod_name = NULL;
bp->sym_name = NULL;
}
}
}
wp_asmfile *WPAsmOpen( sio_data * curr_sio, int src_row, bool quiet )
/*******************************************************************/
{
wp_asmfile * wpasm_file;
cue_handle * ch;
cue_handle * ch2;
mod_info * curr_mod;
file_info * curr_file;
massgd_sample_addr * samp_data;
wp_asmline * asm_line;
mod_handle mh;
file_handle fh;
address addr;
cue_fileid fid;
search_result cue_find;
int rows;
int asm_group;
int asm_row;
int file_index;
int addr_cmp;
clicks_t addr_tick_index;
quiet=quiet;
ch = alloca( DIPHandleSize( HK_CUE ) );
ch2 = alloca( DIPHandleSize( HK_CUE ) );
curr_file = curr_sio->curr_file;
curr_mod = curr_sio->curr_mod;
if( curr_file->fid == 0 || LineCue( curr_mod->mh, curr_sio->curr_file->fid,
src_row, 0, ch2 ) == SR_NONE ) {
ch2 = NULL;
}
fh = ExeOpen( curr_sio->curr_image->name );
if( fh == -1 ) {
ErrorMsg( LIT( Exe_Not_Found ), curr_sio->curr_image->name );
return( NULL );
}
wpasm_file = ProfCAlloc( sizeof(wp_asmfile) );
curr_sio->asm_file = wpasm_file;
wpasm_file->asm_buff = ProfAlloc( MAX_ASM_BUFF_LEN );
wpasm_file->asm_buff_len = MAX_ASM_BUFF_LEN;
SetNumBytes( 0 );
SetExeFile( fh, false );
wpasm_file->fh = fh;
addr = ModAddr( curr_mod->mh );
SetExeOffset( addr );
wpasm_file->max_time = 0;
addr_tick_index = curr_mod->first_tick_index - 1;
samp_data = WPGetMassgdSampData( curr_sio, addr_tick_index++ );
wpasm_file->asm_data = ProfAlloc( sizeof(wp_asm_groups) );
wpasm_file->asm_data[0].asm_lines = ProfAlloc( MAX_ASM_LINE_SIZE );
wpasm_file->asm_groups = 0;
rows = 0;
for( ;; ) {
mh = curr_mod->mh;
if( EndOfSegment()
|| AddrMod( addr, &mh ) == SR_NONE || mh != curr_mod->mh ) break;
cue_find = (AddrCue( curr_mod->mh, addr, ch ) == SR_EXACT);
if( ch2 != NULL && CueCmp( ch, ch2 ) == 0 ) {
wpasm_file->entry_line = rows;
ch2 = NULL;
}
asm_line = WPGetAsmLoc( wpasm_file, rows, &asm_group, &asm_row );
if( cue_find ) {
asm_line->source_line = true;
asm_line->u.src.line = CueLine( ch );
asm_line->u.src.src_file = NULL;
if( !curr_file->unknown_file ) {
fid = CueFileId( ch );
file_index = 0;
while( file_index < curr_mod->file_count ) {
curr_file = curr_mod->mod_file[file_index];
if( curr_file->fid == fid ) {
asm_line->u.src.src_file =
FOpenSource( curr_file->name, mh, fid );
break;
}
file_index++;
}
}
rows++;
asm_line = WPGetAsmLoc( wpasm_file, rows, &asm_group, &asm_row );
}
asm_line = &wpasm_file->asm_data[asm_group].asm_lines[asm_row];
asm_line->source_line = false;
asm_line->u.asm_line.addr = addr;
asm_line->u.asm_line.tick_count = 0;
for( ;; ) {
if( samp_data == NULL ) break;
addr_cmp = AddrCmp( &addr, samp_data->raw );
if( addr_cmp < 0 ) break;
if( addr_cmp == 0 ) {
asm_line->u.asm_line.tick_count = samp_data->hits;
if( asm_line->u.asm_line.tick_count > wpasm_file->max_time ) {
wpasm_file->max_time = asm_line->u.asm_line.tick_count;
}
}
samp_data = WPGetMassgdSampData( curr_sio, addr_tick_index++ );
}
rows++;
CodeAdvance( &addr );
}
WPGetAsmLoc( wpasm_file, rows, &asm_group, &asm_row );
wpasm_file->asm_data[asm_group].asm_lines =
ProfRealloc( wpasm_file->asm_data[asm_group].asm_lines,
sizeof(wp_asmline)*(asm_row+1) );
wpasm_file->asm_rows = rows;
return( wpasm_file );
}
static bool FileGetLine( a_window *wnd, int row, int piece,
wnd_line_piece *line )
{
int len;
file_window *file = WndFile( wnd );
address addr;
brkp *bp;
bool curr;
DIPHDL( cue, ch );
line->text = LIT_ENG( Empty );
if( file->viewhndl == NULL && ModHasInfo( file->mod, HK_CUE ) != DS_OK ) {
return( false );
}
curr = ( row == file->active && ContextMod == file->mod );
switch( piece ) {
case PIECE_BREAK:
line->tabstop = false;
if( row >= file->eof )
return( false );
if( file->mod == NO_MOD )
return( true );
addr = NilAddr;
if( !WndDoingSearch ) { // too expensive
addr = GetRowAddr( file, row, true );
}
if( !IS_NIL_ADDR( addr ) ) {
bp = FindBreakByLine( file->mod, file->file_id, row+1 );
FileBreakGadget( wnd, line, curr, bp );
}
return( true );
case PIECE_SOURCE:
line->text = TxtBuff;
line->extent = WND_MAX_EXTEND;
if( curr )
line->attr = WND_STANDOUT;
if( file->mod != NO_MOD ) {
line->indent = MaxGadgetLength;
}
if( file->viewhndl == NULL ) {
Format( TxtBuff, LIT_DUI( No_Source_Line ), row+1 );
if( LineCue( file->mod, file->file_id, 0, 0, ch ) != SR_NONE ) {
if( (CueAdjust( ch, -1, ch ) & DS_ERR) ) {
file->eof = CueLine( ch );
}
}
return( true );
}
len = FReadLine( file->viewhndl, row+1, 0, TxtBuff, MAX_LINE_LEN );
if( len < 0 ) {
file->eof = row;
return( false );
}
if( len == MAX_LINE_LEN ) {
StrCopy( " ...", TxtBuff + MAX_LINE_LEN );
} else {
TxtBuff[len] = NULLCHAR;
}
if( row >= file->rows ) {
file->rows = row + 1;
file->rows_offset = FLastOffset( file->viewhndl );
}
return( true );
default:
return( false );
}
}
/**
* WalkFileList callback, the module pass.
*
* @returns WR_CONTINUE
* @param cue The file.
* @param ignored Unused user argument.
*/
static walk_result File2Callback( cue_handle *cue, void *ignored )
{
address prev_addr = {0};
long prev_line = -1;
cue_handle *next_cue = alloca( DIPHandleSize( HK_CUE, false ) );
cue_handle *prev_cue = NULL;
cue_handle *cue2 = alloca( DIPHandleSize( HK_CUE, false ) );
mod_handle mod = CueMod( cue );
cue_fileid file_id = CueFileId( cue );
search_result search_rc;
char buff[1024];
size_t len;
dip_status rc;
/* filename */
buff[0] = '\0';
len = CueFile( cue, buff, sizeof( buff ) );
if( len > 0 ) {
printf( " %lx %s\n", file_id, buff );
} else {
printf( " %lx (len=%u)\n", file_id, len );
}
/* check the LineCue function */
if( Opts.do_cue_tests ) {
search_rc = LineCue( mod, file_id, 0, 0, cue2 );
CompareCues( cue, cue2, SR_EXACT, search_rc, true, false, true, false,
"LineCue(,,0,)" );
}
/* lines */
do {
long line = CueLine( cue );
unsigned column = CueColumn( cue );
address addr = CueAddr( cue );
printf( " Line %5ld ", line );
if( column ) {
printf( "Col %2d ", column );
}
printf( "at %04x:%08lx%s\n", addr.mach.segment, (long)addr.mach.offset,
prev_line >= 0 && addr.mach.offset < prev_addr.mach.offset
? "^"
: prev_line >= 0 && line < prev_line ? "!" : "" );
/* do tests */
if( Opts.do_cue_tests ) {
if( CueFileId( cue ) != file_id ) {
printf( "ERROR: file id changed! new:%#lx old:%#lx\n",
(long)CueFileId( cue ), (long)file_id );
}
if( CueMod( cue ) != mod ) {
printf( "ERROR: module changed! new:%#lx old:%#lx\n",
(long)CueMod( cue ), (long)file_id );
}
/* line searches */
search_rc = LineCue( mod, file_id, line, 0, cue2 );
CompareCues( cue, cue2, SR_EXACT, search_rc, true, false, false, false,
"LineCue(,,n,)" );
if( line > prev_line + 1 && prev_line >= 0 ) {
search_rc = LineCue( mod, file_id, line - 1, 0, cue2 );
CompareCues( prev_cue, cue2,
prev_line == line - 1 ? SR_EXACT : SR_CLOSEST,
search_rc, true, false, false, false,
"LineCue(,,n-1,)" );
}
/* address searches */
search_rc = AddrCue( mod, addr, cue2 );
CompareCues( cue, cue2, SR_EXACT, search_rc, false, false, true, false,
"AddrCue(,,n,)" );
}
/* next */
rc = CueAdjust( cue, 1, next_cue );
prev_cue = cue;
cue = next_cue;
next_cue = prev_cue;
prev_addr = addr;
prev_line = line;
} while( rc == DS_OK );
return( WR_CONTINUE );
}
