protected void CoreExpand()
{
do
{
var pointer = Type as DbgPointerTypeInfo;
if (null != pointer)
{
string pointeeName;
if (Name.StartsWith("(*", StringComparison.OrdinalIgnoreCase))
{
pointeeName = "(*" + Name.Substring(1);
}
else
{
pointeeName = "(*" + Name + ")";
}
ulong pointee = ReadAs_pointer();
m_children.Add(new DbgSimpleSymbol(Debugger,
pointeeName,
pointer.PointeeType,
pointee,
this));
break;
}
var udt = Type as DbgUdtTypeInfo;
if (null != udt)
{
foreach (var member in udt.Members)
{
m_children.Add(new DbgMemberSymbol(Debugger,
this,
member));
}
foreach (var staticMember in udt.StaticMembers)
{
m_children.Add(new DbgSimpleSymbol(Debugger,
staticMember.Name,
staticMember.DataType,
staticMember.Address,
this));
}
// TODO: functions, nested types, etc.
break;
}
// var clr = Type as DbgClrTypeTypeInfo;
// if( null != clr )
// {
// clr.
// break;
// }
var bt = Type as DbgBaseTypeInfo;
if (null != bt)
{
// No children.
break;
}
var dmti = Type as DbgDataMemberTypeInfo;
if (null != dmti)
{
// No children.
break;
}
var at = Type as DbgArrayTypeInfo;
if (null != at)
{
// No children... I think it would be too crazy/expensive
// to have a child "symbol" for each element.
break;
}
var et = Type as DbgEnumTypeInfo;
if (null != et)
{
// No children.
break;
}
var ft = Type as DbgFunctionTypeTypeInfo;
if (null != ft)
{
// No children.
break;
}
var nt = Type as DbgNullTypeInfo;
if (null != nt)
{
// No children.
break;
}
var dgt = Type as DbgGeneratedTypeInfo;
if (null != dgt)
{
// No children.
break;
}
Util.Fail(Util.Sprintf("Need to handle expand for type: {0}",
Util.GetGenericTypeName(Type)));
} while(false);
m_children.Freeze();
m_isExpanded = true;
} // end CoreExpand()
private void _PopulateMembers()
{
Util.Assert(null == m_members); // shouldn't need to do this more than once
var members = new NameIndexableList <DbgDataMemberTypeInfo>();
var statics = new NameIndexableList <DbgDataStaticMemberTypeInfo>();
var bases = new NameIndexableList <DbgBaseClassTypeInfo>();
var virtBases = new NameIndexableList <DbgVirtualBaseClassTypeInfo>();
var nestedTypes = new NameIndexableList <DbgUdtTypeInfo>();
var nestedEnums = new NameIndexableList <DbgEnumTypeInfo>();
var typedefs = new NameIndexableList <DbgTypedefTypeInfo>();
var functions = new NameIndexableList <DbgFunctionTypeInfo>();
var childrenIds = GetChildrenIds(m_numChildren); // _EnsureValid() called here
var children = new List <DbgTypeInfo>(childrenIds.Length);
foreach (var childId in childrenIds)
{
var child = DbgTypeInfo.GetTypeInfo(Debugger, Module, childId);
children.Add(child);
if (child is DbgDataMemberTypeInfo)
{
members.Add((DbgDataMemberTypeInfo)child);
}
else if (child is DbgDataStaticMemberTypeInfo)
{
statics.Add((DbgDataStaticMemberTypeInfo)child);
}
else if (child is DbgBaseClassTypeInfo)
{
DbgBaseClassTypeInfo bcti = (DbgBaseClassTypeInfo)child;
bases.Add(bcti);
bcti.AggregateMembers(members, statics);
}
else if (child is DbgVirtualBaseClassTypeInfo)
{
virtBases.Add((DbgVirtualBaseClassTypeInfo)child);
}
else if (child is DbgUdtTypeInfo)
{
nestedTypes.Add((DbgUdtTypeInfo)child);
}
else if (child is DbgEnumTypeInfo)
{
nestedEnums.Add((DbgEnumTypeInfo)child);
}
else if (child is DbgTypedefTypeInfo)
{
typedefs.Add((DbgTypedefTypeInfo)child);
}
else if (child is DbgFunctionTypeInfo)
{
functions.Add((DbgFunctionTypeInfo)child);
}
else if (child is DbgVTableTypeInfo)
{
m_vtable = (DbgVTableTypeInfo)child;
}
else
{
#if DEBUG
string key = Util.Sprintf("{0}+{1}", Util.GetGenericTypeName(child), child.SymTag);
if (sm_unhandledTypes.Add(key))
{
LogManager.Trace("Need to handle children of type {0} ({1}, parent {2}, id {3}).", Util.GetGenericTypeName(child), child.SymTag, TypeId, child.TypeId);
}
#endif
}
}
m_children = children.AsReadOnly();
members.Freeze();
statics.Freeze();
bases.Freeze();
virtBases.Freeze();
nestedTypes.Freeze();
nestedEnums.Freeze();
typedefs.Freeze();
functions.Freeze();
m_members = members;
m_staticMembers = statics;
m_baseClasses = bases;
m_virtBaseClasses = virtBases;
m_nestedTypes = nestedTypes;
m_nestedEnums = nestedEnums;
m_typedefs = typedefs;
m_functions = functions;
} // end _PopulateMembers()