static bool UserType( type_handle *th )
{
unsigned i;
unsigned len;
sym_info info;
//NYI:begin temp
if( ExprSP->flags & SF_NAME ) {
static const char * const TagIds[] = { "struct", "class", "union", "enum", NULL };
ExprSP->v.li.type = ST_TYPE;
for( i = 0; TagIds[i] != NULL; ++i ) {
len = strlen( TagIds[i] );
if( len == ExprSP->v.li.name.len
&& memcmp( ExprSP->v.li.name.start, TagIds[i], len ) == 0 ) {
ExprSP->v.li.type = ST_STRUCT_TAG + i;
ExprSP->v.li.name.start = NamePos();
ExprSP->v.li.name.len = NameLen();
Scan();
}
}
}
//NYI: end temp
NameResolve( ExprSP, TRUE );
if( !(ExprSP->flags & SF_SYM) ) return( FALSE );
if( ExprSP->th == NULL ) return( FALSE );
SymInfo( ExprSP->v.sh, ExprSP->lc, &info );
if( info.kind != SK_TYPE ) return( FALSE );
HDLAssign( type, th, ExprSP->th );
return( TRUE );
}
void BreakAllModEntries( mod_handle handle )
{
name_list list;
address addr;
int i;
bool have_mod_cue;
sym_info sinfo;
DIPHDL( cue, ch );
DIPHDL( cue, ch_mod );
NameListInit( &list, WF_CODE );
NameListAddModules( &list, handle, false, true );
have_mod_cue = FindFirstCue( handle, ch_mod );
for( i = 0; i < NameListNumRows( &list ); ++i ) {
addr = NameListAddr( &list, i );
SymInfo( NameListHandle( &list, i ), NULL, &sinfo );
if( !sinfo.is_global && !sinfo.is_public )
continue;
if( have_mod_cue && DeAliasAddrCue( handle, addr, ch ) != SR_NONE ) {
if( CueFileId( ch ) != CueFileId( ch_mod ) ) {
continue;
}
}
if( FindBreak( addr ) != NULL ) {
continue;
}
AddBreak( addr );
}
NameListFree( &list );
}
inspect_type WndGetExprSPInspectType( address *paddr )
{
sym_info info;
DIPHDL( sym, sh );
LValue( ExprSP );
*paddr = NilAddr;
if( ExprSP->info.kind == TK_FUNCTION ) {
ExprValue( ExprSP );
*paddr = ExprSP->v.addr;
PopEntry();
return( INSP_CODE );
} else if( (ExprSP->flags & SF_LOCATION) && ExprSP->th != NULL && !IsInternalMod( TypeMod( ExprSP->th ) ) ) {
if( ExprSP->v.loc.num == 1 && ExprSP->v.loc.e[0].type == LT_ADDR ) {
*paddr = ExprSP->v.loc.e[0].u.addr;
}
PopEntry();
return( INSP_DATA );
} else {
if( (ExprSP->flags & SF_LOCATION) && ExprSP->v.loc.e[0].type == LT_ADDR ) {
*paddr = ExprSP->v.loc.e[0].u.addr;
} else if( ExprSP->info.kind == TK_ADDRESS
|| ExprSP->info.kind == TK_POINTER ) {
*paddr = ExprSP->v.addr;
}
if( !IS_NIL_ADDR( (*paddr) ) ) {
AddrFloat( paddr );
if( DeAliasAddrSym( NO_MOD, *paddr, sh ) != SR_NONE ) {
SymInfo( sh, ExprSP->lc, &info );
PopEntry();
switch( info.kind ) {
case SK_CODE:
case SK_PROCEDURE:
return( INSP_CODE );
break;
default:
return( INSP_RAW_DATA );
break;
}
}
}
}
ExprValue( ExprSP );
MakeMemoryAddr( TRUE, EXPR_DATA, paddr );
return( INSP_RAW_DATA );
}
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 );
}
static unsigned MechStack( unsigned select, unsigned parm )
{
unsigned result = 0;
stack_entry *entry;
sym_info info;
switch( select ) {
case 0:
SwapStack( parm );
break;
case 1:
MoveSP( parm );
break;
case 2:
entry = StkEntry( parm );
LValue( entry );
result = TypeInfoToClass( &entry->info ) & (BASE_TYPE | STK_UNSIGNED);
break;
case 3:
ExprValue( StkEntry( parm ) );
break;
case 4:
LValue( StkEntry( parm ) );
break;
case 5:
RValue( StkEntry( parm ) );
break;
case 6:
LRValue( StkEntry( parm ) );
break;
case 7:
entry = StkEntry( parm );
LValue( entry );
result = TI_CREATE( entry->info.kind, TM_NONE, 0 );
break;
case 8:
entry = StkEntry( parm );
NameResolve( entry, FALSE );
if( entry->flags & SF_SYM ) {
SymInfo( entry->v.sh, entry->lc, &info );
result = info.kind;
} else {
result = SK_NONE;
}
break;
case 9:
entry = StkEntry( parm );
result = NameResolve( entry, FALSE );
break;
case 10:
entry = StkEntry( parm );
if( entry->flags & SF_NAME ) {
result = 0;
} else if( entry->flags & SF_SYM ) {
result = 1;
} else if( entry->flags & SF_LOCATION ) {
result = 2;
} else {
result = 3;
}
break;
}
return( result );
}
/**
* 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 );
}
