STATIC void findRtnFromRow( sio_data *curr_sio, int row )
/*******************************************************/
{
file_info *curr_file;
rtn_info *curr_rtn;
cue_handle *ch;
sym_handle *sh;
int index;
mod_handle mh;
address addr;
index = 0;
ch = alloca( DIPHandleSize( HK_CUE, false ) );
curr_file = curr_sio->curr_file;
mh = curr_sio->curr_mod->mh;
if( DIPLineCue( mh, curr_sio->curr_file->fid, row, 0, ch ) == SR_NONE ) {
if( DIPLineCue( mh, curr_sio->curr_file->fid, 0, 0, ch ) == SR_NONE ) {
return;
}
}
sh = alloca( DIPHandleSize( HK_SYM, false ) );
addr = DIPCueAddr( ch );
if( DIPAddrSym( mh, addr, sh ) == SR_NONE )
return;
while( index < curr_file->rtn_count ) {
curr_rtn = curr_file->routine[index];
if( curr_rtn->sh != NULL && DIPSymCmp( curr_rtn->sh, sh ) == 0 ) {
curr_sio->curr_rtn = curr_rtn;
break;
}
index++;
}
}
/*
* 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 );
}
/*
* GetLineNum
*/
bool GetLineNum( address *addr, char *fname, DWORD bufsize, DWORD *line )
{
cue_handle *cueh;
cueh = walloca( DIPHandleSize( HK_CUE ) );
if( DIPAddrCue( NO_MOD, *addr, cueh ) == SR_NONE ) {
return( false );
}
DIPCueFile( cueh, fname, bufsize );
*line = DIPCueLine( cueh );
return( true );
}
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 );
}
STATIC file_info *loadFileInfo( mod_info *curr_mod, sym_handle *sym )
/********************************************************************/
{
file_info *sym_file;
cue_handle *ch;
cue_fileid fid;
int file_count;
int count;
location_list ll;
if( SymLocation( sym, NULL, &ll ) != DS_OK ) {
return( curr_mod->mod_file[0] );
}
ch = alloca( DIPHandleSize( HK_CUE ) );
switch( AddrCue( curr_mod->mh, ll.e[0].u.addr, ch ) ) {
case SR_NONE:
case SR_FAIL:
return( curr_mod->mod_file[0] );
}
fid = CueFileId( ch );
file_count = curr_mod->file_count;
count = 0;
while( count < file_count ) {
sym_file = curr_mod->mod_file[count];
if( sym_file->fid == fid ) {
return( sym_file );
}
count++;
}
curr_mod->file_count++;
curr_mod->mod_file = ProfRealloc( curr_mod->mod_file,
curr_mod->file_count * sizeof( pointer ) );
count = CueFile( ch, NULL, 0 ) + 1;
sym_file = ProfCAlloc( sizeof( file_info ) + count );
sym_file->fid = fid;
CueFile( ch, sym_file->name, count );
initRoutineInfo( sym_file );
curr_mod->mod_file[file_count] = sym_file;
return( sym_file );
}
STATIC walk_result loadRoutineInfo( sym_walk_info swi, sym_handle *sym,
void *_new_mod )
/*********************************************************************/
{
mod_info *new_mod = _new_mod;
sym_info sinfo;
file_info *sym_file;
rtn_info *new_rtn;
int rtn_count;
int name_len;
int sym_size;
int demangle_type;
if( swi != SWI_SYMBOL ) {
return( WR_CONTINUE );
}
SymInfo( sym, NULL, &sinfo );
if( sinfo.kind != SK_CODE && sinfo.kind != SK_PROCEDURE ) {
return( WR_CONTINUE );
}
sym_file = loadFileInfo( new_mod, sym );
name_len = SymName( sym, NULL, SN_DEMANGLED, NULL, 0 );
if( name_len == 0 ) {
name_len = SymName( sym, NULL, SN_SOURCE, NULL, 0 );
demangle_type = SN_SOURCE;
} else {
demangle_type = SN_DEMANGLED;
}
new_rtn = ProfCAlloc( sizeof( rtn_info ) + name_len );
SymName( sym, NULL, demangle_type, new_rtn->name, name_len + 1 );
sym_size = DIPHandleSize( HK_SYM );
new_rtn->sh = ProfAlloc( sym_size );
memcpy( new_rtn->sh, sym, sym_size );
rtn_count = sym_file->rtn_count;
sym_file->rtn_count++;
sym_file->routine = ProfRealloc( sym_file->routine, sym_file->rtn_count * sizeof( pointer ) );
sym_file->routine[rtn_count] = new_rtn;
return( WR_CONTINUE );
}
/*
* GetSymbolName
*/
bool GetSymbolName( address *addr, char *name, DWORD *symoff )
{
sym_handle *symhdl;
search_result sr;
location_list ll;
symhdl = MemAlloc( DIPHandleSize( HK_SYM ) );
sr = DIPAddrSym( NO_MOD, *addr, symhdl );
switch( sr ) {
case SR_CLOSEST:
DIPSymLocation( symhdl, NULL, &ll );
*symoff = MADAddrDiff( addr,&(ll.e[0].u.addr), MAF_FULL );
break;
case SR_EXACT:
*symoff = 0;
break;
case SR_NONE:
MemFree( symhdl );
return( false );
}
DIPSymName( symhdl, NULL, SNT_OBJECT, name, MAX_SYM_NAME );
MemFree( symhdl );
return( true );
}
STATIC void resolveImageSamples( void )
/*************************************/
{
image_info *curr_image;
massgd_sample_addr **massgd_data;
mod_info *curr_mod;
file_info *curr_file;
rtn_info *curr_rtn;
address *addr;
sample_index_t tick_index;
mod_handle mh;
sym_handle *sh;
long int count;
int count2;
int count3;
int count4;
int index;
int index2;
sh = alloca( DIPHandleSize( HK_SYM ) );
massgd_data = CurrSIOData->massaged_sample;
tick_index = 1;
index = 0;
index2 = 0;
for( count = 0; count < CurrSIOData->number_massaged; ++count, ++index2 ) {
if( index2 > MAX_MASSGD_BUCKET_INDEX ) {
++index;
index2 = 0;
}
addr = massgd_data[index][index2].raw;
if( AddrMod( *addr, &mh ) == SR_NONE ) {
curr_image = AddrImage( addr );
if( curr_image == NULL ) {
curr_image = CurrSIOData->images[0];
}
curr_mod = curr_image->module[0];
curr_rtn = curr_mod->mod_file[0]->routine[0];
} else {
curr_image = *(image_info **)ImageExtra( mh );
curr_mod = findCurrMod( curr_image, mh );
if( AddrSym( mh, *addr, sh ) == SR_NONE ) {
curr_rtn = curr_mod->mod_file[0]->routine[0];
} else {
curr_rtn = findCurrRtn( curr_mod, sh );
/**/ myassert( curr_rtn != NULL );
}
}
if( curr_rtn != NULL ) {
curr_rtn->tick_count += massgd_data[index][index2].hits;
if( curr_rtn->first_tick_index == 0 ) {
curr_rtn->first_tick_index = tick_index;
if( curr_mod->first_tick_index == 0
|| curr_mod->first_tick_index > tick_index ) {
curr_mod->first_tick_index = tick_index;
}
}
curr_rtn->last_tick_index = tick_index;
}
tick_index++;
}
CurrSIOData->max_time = 0;
count = 0;
while( count < CurrSIOData->image_count ) {
curr_image = CurrSIOData->images[count];
curr_image->max_time = 0;
count2 = 0;
while( count2 < curr_image->mod_count ) {
curr_mod = curr_image->module[count2];
curr_mod->max_time = 0;
count3 = 0;
while( count3 < curr_mod->file_count ) {
curr_file = curr_mod->mod_file[count3];
curr_rtn = curr_file->routine[0];
if( curr_rtn->unknown_routine && curr_rtn->tick_count == 0 ) {
curr_rtn->ignore_unknown_rtn = true;
curr_file->ignore_unknown_rtn = true;
}
curr_file->max_time = 0;
count4 = 0;
while( count4 < curr_file->rtn_count ) {
curr_rtn = curr_file->routine[count4];
curr_file->agg_count += curr_rtn->tick_count;
if( curr_rtn->tick_count > curr_file->max_time ) {
curr_file->max_time = curr_rtn->tick_count;
}
count4++;
}
curr_mod->agg_count += curr_file->agg_count;
if( curr_file->agg_count > curr_mod->max_time ) {
curr_mod->max_time = curr_file->agg_count;
}
count3++;
}
curr_file = curr_mod->mod_file[0];
if( curr_file->unknown_file && curr_file->agg_count == 0 ) {
curr_file->ignore_unknown_file = true;
curr_mod->ignore_unknown_file = true;
}
curr_image->agg_count += curr_mod->agg_count;
if( curr_mod->agg_count > curr_image->max_time ) {
curr_image->max_time = curr_mod->agg_count;
}
count2++;
}
curr_mod = curr_image->module[0];
if( curr_mod->unknown_module && curr_mod->agg_count == 0 ) {
curr_mod->ignore_unknown_mod = true;
curr_image->ignore_unknown_mod = true;
}
if( curr_image->agg_count > CurrSIOData->max_time ) {
CurrSIOData->max_time = curr_image->agg_count;
}
count++;
}
curr_image = CurrSIOData->images[0];
if( curr_image->unknown_image && curr_image->agg_count == 0 ) {
curr_image->ignore_unknown_image = true;
}
}
/**
* 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 );
}
/**
* WalkSymList callback, the module pass.
*
* @returns WR_CONTINUE;
* @param info Symbol walk info.
* @param sym The Symbol.
* @param _idx Pointer to the symbol index number.
*/
static walk_result Sym2Callback( sym_walk_info info, sym_handle *sym, void *_idx )
{
int *idx = (int *)_idx;
char buff[2048];
unsigned len;
dip_status rc;
location_list ll = {0};
sym_info sinfo;
int i;
/* index */
printf( "%5d ", ++*idx );
/* symbol info */
rc = SymInfo( sym, NULL, &sinfo );
if( rc == DS_OK ) {
switch( sinfo.kind ) {
case SK_NONE: printf( "NONE " ); break;
case SK_CODE: printf( "CODE " ); break;
case SK_DATA: printf( "DATA " ); break;
case SK_CONST: printf( "CNST " ); break;
case SK_TYPE: printf( "TYPE " ); break;
case SK_PROCEDURE: printf( "PROC " ); break;
case SK_NAMESPACE: printf( "NSPC " ); break;
default: printf( "kind=%#x! ", sinfo.kind ); break;
}
} else {
printf( "rc=%#x ", rc );
memset( &sinfo, 0, sizeof( sinfo ) );
sinfo.kind= SK_NONE;
}
/* location (i.e. address) */
ll.num = MAX_LOC_ENTRIES;
rc = SymLocation( sym, NULL, &ll );
if( rc == DS_OK ) {
if( ll.num > 0 ) {
if( ll.e[0].type == LT_ADDR ) {
printf( "%04x:%08lx ", ll.e[0].u.addr.mach.segment, (long)ll.e[0].u.addr.mach.offset );
} else {
printf( "%p ", ll.e[0].u.p ); /// what's this?
}
} else {
printf( " ");
}
} else if( sinfo.kind == SK_CONST ) {
ll.num = 0;
memset( buff, 0, sizeof( buff ) );
rc = SymValue( sym, NULL, &buff[0] );
if( rc == DS_OK ) {
switch( sinfo.ret_modifier ) {
}
printf( " " );
} else {
printf( "SymValue rc=%#x ", rc );
}
} else if( sinfo.kind == SK_NONE || sinfo.kind == SK_TYPE
|| sinfo.kind == SK_NAMESPACE ) {
printf( " " );
ll.num = 0;
} else {
printf( "rc=%#x ", rc );
ll.num = 0;
}
/* info */
switch( info ) {
case SWI_SYMBOL:
printf( "SYMBOL " );
break;
case SWI_INHERIT_START:
printf( "INH-STRT " );
break;
case SWI_INHERIT_END:
printf( "INH-END " );
break;
default:
printf( "%#d ", info );
break;
}
/* finally, the name. */
/* try get the name */
buff[0] = '\0';
len = SymName( sym, NULL, SN_DEMANGLED, buff, sizeof( buff ) );
if( len == 0 ) {
len = SymName( sym, NULL, SN_OBJECT, buff, sizeof( buff ) );
}
if( len == 0 ) {
len = SymName( sym, NULL, SN_SOURCE, buff, sizeof( buff ) );
}
if( len > 0 ) {
printf( "%s\n", buff );
} else {
printf( "(len=%u)\n", len );
}
/* Get more stuff, mainly to test the APIs. */
if( 1 ) {
type_handle *type = alloca( DIPHandleSize( HK_TYPE, false ) );
rc = SymType( sym, type );
if( rc ) {
}
#if 0
mod_handle SymMod( sym_handle * );
unsigned SymName( sym_handle *, location_context *, symbol_name, char *buff, unsigned buff_size );
dip_status SymType( sym_handle *, type_handle * );
dip_status SymValue( sym_handle *, location_context *, void * );
dip_status SymInfo( sym_handle *, location_context *, sym_info * );
dip_status SymParmLocation( sym_handle *, location_context *, location_list *, unsigned p );
dip_status SymObjType( sym_handle *, type_handle *, dip_type_info * );
dip_status SymObjLocation( sym_handle *, location_context *, location_list * );
search_result AddrSym( mod_handle, address, sym_handle * );
search_result LookupSym( symbol_source, void *, lookup_item *, void * );
search_result LookupSymEx( symbol_source, void *, lookup_item *, location_context *, void * );
search_result AddrScope( mod_handle, address, scope_block * );
search_result ScopeOuter( mod_handle, scope_block *, scope_block * );
int SymCmp( sym_handle *, sym_handle * );
dip_status SymAddRef( sym_handle * );
dip_status SymRelease( sym_handle * );
dip_status SymFreeAll();
#endif
}
/* more locations. */
for( i = 1; i < ll.num; i++ ) {
if( ll.e[0].type == LT_ADDR ) {
printf( " %04x:%08lx\n",
ll.e[i].u.addr.mach.segment, (long)ll.e[i].u.addr.mach.offset );
} else {
printf( " %p\n", ll.e[i].u.p); /// what's this?
}
}
/*
* Perform alternative lookups to the those interfaces.
*/
return( WR_CONTINUE );
}
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 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 );
}
}
