/// <summary>
/// Gets method reference identifier (external or internal) encoded with appropriate prefix.
/// </summary>
/// <param name="methodReference">Method reference in Mono.Cecil format.</param>
/// <returns>Refernce identifier for passed <paramref name="methodReference"/> value.</returns>
public UInt16 GetMethodReferenceId(
MethodReference methodReference)
{
UInt16 referenceId;
if (MethodReferencesTable.TryGetMethodReferenceId(methodReference, out referenceId))
{
referenceId |= 0x8000; // External method reference
}
else
{
MethodDefinitionTable.TryGetMethodReferenceId(methodReference.Resolve(), out referenceId);
}
return(referenceId);
}
private void AddDummyMethod(MethodDefinitionTable methodTable, MethodDefinition method)
{
var methodRow = new MetadataRow <FileSegment, MethodImplAttributes, MethodAttributes, uint, uint, uint>
{
Column1 = null, // Body
Column2 = method.ImplAttributes,
Column3 = method.Attributes,
Column4 = _parentBuffer.StringStreamBuffer.GetStringOffset(method.Name),
Column5 = 0, // Signature
Column6 = _paramList
};
methodTable.Add(methodRow);
_members.Add(method, methodRow.MetadataToken);
_paramList += (uint)method.Parameters.Count;
}
private void FinalizeTypeRow(TypeDefinition type, MetadataRow <TypeAttributes, uint, uint, uint, uint, uint> typeRow, FieldDefinitionTable fieldTable,
MethodDefinitionTable methodTable)
{
// Add base type.
if (type.BaseType != null)
{
var baseToken = GetTypeToken(type.BaseType);
typeRow.Column4 = _tableStream.GetIndexEncoder(CodedIndex.TypeDefOrRef).EncodeToken(baseToken);
}
// Finalize fields.
foreach (var field in type.Fields)
{
var fieldRow = fieldTable[(int)(GetNewToken(field).Rid - 1)];
FinalizeFieldRow(field, fieldRow);
}
// Finalize methods.
foreach (var method in type.Methods)
{
var methodRow = methodTable[(int)(GetNewToken(method).Rid - 1)];
FinalizeMethodRow(method, methodRow);
}
// Add nested classes.
foreach (var nestedClass in type.NestedClasses)
{
AddNestedClass(nestedClass);
}
// Add interfaces.
foreach (var @interface in type.Interfaces)
{
AddInterface(@interface);
}
// Add method implementations.
foreach (var implementation in type.MethodImplementations)
{
AddImplementation(implementation);
}
// Add class layout if present.
if (type.ClassLayout != null)
{
AddClassLayout(type.ClassLayout);
}
// Add property map if present.
if (type.PropertyMap != null)
{
AddPropertyMap(type.PropertyMap);
}
// Add event map if present.
if (type.EventMap != null)
{
AddEventMap(type.EventMap);
}
AddGenericParmeters(type);
AddCustomAttributes(type);
AddSecurityDeclarations(type);
}
private void AddDummyType(TypeDefinitionTable typeTable, FieldDefinitionTable fieldTable, MethodDefinitionTable methodTable, TypeDefinition type)
{
// Add dummy type.
var typeRow = new MetadataRow <TypeAttributes, uint, uint, uint, uint, uint>
{
Column1 = type.Attributes,
Column2 = _parentBuffer.StringStreamBuffer.GetStringOffset(type.Name),
Column3 = _parentBuffer.StringStreamBuffer.GetStringOffset(type.Namespace),
Column4 = 0, // BaseType
Column5 = _fieldList,
Column6 = _methodList
};
typeTable.Add(typeRow);
_members.Add(type, typeRow.MetadataToken);
// Add dummy fields.
foreach (var field in type.Fields)
{
AddDummyField(fieldTable, field);
}
_fieldList += (uint)type.Fields.Count;
// Add dummy methods.
foreach (var method in type.Methods)
{
AddDummyMethod(methodTable, method);
}
_methodList += (uint)type.Methods.Count;
}
