void ReadAllFields()
{
TypeDefTable tdefTable = m_tableReader.GetTypeDefTable();
if (!m_tHeap.HasTable(FieldTable.RId))
{
m_fields = new FieldDefinition [0];
return;
}
FieldTable fldTable = m_tableReader.GetFieldTable();
m_fields = new FieldDefinition [fldTable.Rows.Count];
for (int i = 0; i < m_typeDefs.Length; i++)
{
TypeDefinition dec = m_typeDefs [i];
GenericContext context = new GenericContext(dec);
int index = i, next;
if (index == tdefTable.Rows.Count - 1)
{
next = fldTable.Rows.Count + 1;
}
else
{
next = (int)(tdefTable [index + 1]).FieldList;
}
for (int j = (int)tdefTable [index].FieldList; j < next; j++)
{
FieldRow frow = fldTable [j - 1];
FieldSig fsig = m_sigReader.GetFieldSig(frow.Signature);
FieldDefinition fdef = new FieldDefinition(
m_root.Streams.StringsHeap [frow.Name],
this.GetTypeRefFromSig(fsig.Type, context), frow.Flags);
fdef.MetadataToken = MetadataToken.FromMetadataRow(TokenType.Field, j - 1);
if (fsig.CustomMods.Length > 0)
{
fdef.FieldType = GetModifierType(fsig.CustomMods, fdef.FieldType);
}
dec.Fields.Add(fdef);
m_fields [j - 1] = fdef;
}
}
}
void CompleteMethods()
{
TypeDefTable tdefTable = m_tableReader.GetTypeDefTable();
if (!m_tHeap.HasTable(MethodTable.RId))
{
m_meths = new MethodDefinition [0];
return;
}
MethodTable methTable = m_tableReader.GetMethodTable();
ParamTable paramTable = m_tableReader.GetParamTable();
if (!m_tHeap.HasTable(ParamTable.RId))
{
m_parameters = new ParameterDefinition [0];
}
else
{
m_parameters = new ParameterDefinition [paramTable.Rows.Count];
}
for (int i = 0; i < m_typeDefs.Length; i++)
{
TypeDefinition dec = m_typeDefs [i];
int index = i, next;
if (index == tdefTable.Rows.Count - 1)
{
next = methTable.Rows.Count + 1;
}
else
{
next = (int)(tdefTable [index + 1]).MethodList;
}
for (int j = (int)tdefTable [index].MethodList; j < next; j++)
{
MethodRow methRow = methTable [j - 1];
MethodDefinition mdef = m_meths [j - 1];
if (mdef.IsConstructor)
{
dec.Constructors.Add(mdef);
}
else
{
dec.Methods.Add(mdef);
}
GenericContext context = new GenericContext(mdef);
MethodDefSig msig = m_sigReader.GetMethodDefSig(methRow.Signature);
mdef.HasThis = msig.HasThis;
mdef.ExplicitThis = msig.ExplicitThis;
mdef.CallingConvention = msig.MethCallConv;
int prms;
if (j == methTable.Rows.Count)
{
prms = m_parameters.Length + 1;
}
else
{
prms = (int)(methTable [j]).ParamList;
}
ParameterDefinition retparam = null;
//TODO: optimize this
ParamRow pRow = null;
int start = (int)methRow.ParamList - 1;
if (paramTable != null && start < prms - 1)
{
pRow = paramTable [start];
}
if (pRow != null && pRow.Sequence == 0) // ret type
{
retparam = new ParameterDefinition(
m_root.Streams.StringsHeap [pRow.Name],
0,
pRow.Flags,
null);
retparam.Method = mdef;
m_parameters [start] = retparam;
start++;
}
for (int k = 0; k < msig.ParamCount; k++)
{
int pointer = start + k;
if (paramTable != null && pointer < prms - 1)
{
pRow = paramTable [pointer];
}
Param psig = msig.Parameters [k];
ParameterDefinition pdef;
if (pRow != null)
{
pdef = BuildParameterDefinition(
m_root.Streams.StringsHeap [pRow.Name],
pRow.Sequence, pRow.Flags, psig, context);
pdef.MetadataToken = MetadataToken.FromMetadataRow(TokenType.Param, pointer);
m_parameters [pointer] = pdef;
}
else
{
pdef = BuildParameterDefinition(
string.Concat("A_", mdef.IsStatic ? k : k + 1),
k + 1, (ParamAttributes)0, psig, context);
}
pdef.Method = mdef;
mdef.Parameters.Add(pdef);
}
mdef.ReturnType = GetMethodReturnType(msig, context);
MethodReturnType mrt = mdef.ReturnType as MethodReturnType;
mrt.Method = mdef;
if (retparam != null)
{
mrt.Parameter = retparam;
mrt.Parameter.ParameterType = mrt.ReturnType;
}
}
}
uint eprid = CodeReader.GetRid((int)m_reader.Image.CLIHeader.EntryPointToken);
if (eprid > 0 && eprid <= m_meths.Length)
{
m_module.Assembly.EntryPoint = GetMethodDefAt(eprid);
}
}
public override void VisitTypeDefinitionCollection(TypeDefinitionCollection types)
{
// type def reading
TypeDefTable typesTable = m_tableReader.GetTypeDefTable();
m_typeDefs = new TypeDefinition [typesTable.Rows.Count];
for (int i = 0; i < typesTable.Rows.Count; i++)
{
TypeDefRow type = typesTable [i];
TypeDefinition t = new TypeDefinition(
m_root.Streams.StringsHeap [type.Name],
m_root.Streams.StringsHeap [type.Namespace],
type.Flags);
t.MetadataToken = MetadataToken.FromMetadataRow(TokenType.TypeDef, i);
m_typeDefs [i] = t;
}
// nested types
if (m_tHeap.HasTable(NestedClassTable.RId))
{
NestedClassTable nested = m_tableReader.GetNestedClassTable();
for (int i = 0; i < nested.Rows.Count; i++)
{
NestedClassRow row = nested [i];
TypeDefinition parent = GetTypeDefAt(row.EnclosingClass);
TypeDefinition child = GetTypeDefAt(row.NestedClass);
parent.NestedTypes.Add(child);
}
}
foreach (TypeDefinition type in m_typeDefs)
{
types.Add(type);
}
// type ref reading
if (m_tHeap.HasTable(TypeRefTable.RId))
{
TypeRefTable typesRef = m_tableReader.GetTypeRefTable();
m_typeRefs = new TypeReference [typesRef.Rows.Count];
for (int i = 0; i < typesRef.Rows.Count; i++)
{
AddTypeRef(typesRef, i);
}
}
else
{
m_typeRefs = new TypeReference [0];
}
ReadTypeSpecs();
ReadMethodSpecs();
ReadMethods();
ReadGenericParameters();
// set base types
for (int i = 0; i < typesTable.Rows.Count; i++)
{
TypeDefRow type = typesTable [i];
TypeDefinition child = m_typeDefs [i];
child.BaseType = GetTypeDefOrRef(type.Extends, new GenericContext(child));
}
CompleteMethods();
ReadAllFields();
ReadMemberReferences();
}
