/// <summary>
/// Adds a new VTable.
/// </summary>
/// <param name="table">The table.</param>
public void AddVTable(VTable table)
{
mVTableLookup.Add(table.Type, table);
}
/// <summary>
/// Creates the parent VTable.
/// </summary>
/// <param name="parentType">The parent type.</param>
private void createParentTable(TypeDefinition parentType)
{
VTable parentTable = mLookup.GetVTable(parentType);
// Match method signatures against own.
Dictionary <int, MethodDefinition> own = new Dictionary <int, MethodDefinition>();
foreach (MethodDefinition method in parentType.Methods)
{
if (!shouldAddMethod(method))
{
continue;
}
string shortName = NameHelper.CreateShortMethodName(method);
string parentName = shortName;
mLookup.SetMethodNotUnique(method);
// It could have an explicit override...
// But that's only possible with interfaces.
if (parentType.IsInterface)
{
string explicitName = string.Format("{0}_{1}", NameHelper.CreateTypeName(parentType), shortName);
if (MyNameTable.ContainsKey(explicitName))
{
shortName = explicitName;
}
}
// This type overrides the method in the parent type.
if (MyNameTable.ContainsKey(shortName) && MyTable[MyNameTable[shortName]].IsVirtual)
{
int nameTableIndex = MyNameTable[shortName];
own.Add(parentTable.MyNameTable[parentName], MyTable[nameTableIndex]);
}
// Use parent method definition.
else
{
int nameTableIndex = parentTable.MyNameTable[shortName];
own.Add(nameTableIndex, method);
}
}
mTable.Add(parentType, own);
// Generate name table.
Dictionary <string, int> nameTable = new Dictionary <string, int>();
foreach (KeyValuePair <int, MethodDefinition> pair in own)
{
nameTable.Add(NameHelper.CreateShortMethodName(pair.Value), pair.Key);
}
mNameTable.Add(parentType, nameTable);
// Add other tables that are inside the parent table.
foreach (KeyValuePair <TypeDefinition, Dictionary <string, int> > pair in parentTable.mNameTable)
{
// Skip parent type itself.
if (pair.Key == parentType)
{
continue;
}
// Create own copies of this table.
Dictionary <int, MethodDefinition> tableCopy = new Dictionary <int, MethodDefinition>();
mTable.Add(pair.Key, tableCopy);
mNameTable.Add(pair.Key, pair.Value);
// Create own copy of table with possible modifications.
Dictionary <int, MethodDefinition> parentLookupTable = parentTable.mTable[pair.Key];
foreach (KeyValuePair <string, int> methodPair in pair.Value)
{
string shortName = methodPair.Key;
// Did we override this method?
if (MyNameTable.ContainsKey(shortName) && (MyTable[MyNameTable[shortName]].IsVirtual))
{
int nameTableIndex = MyNameTable[shortName];
MethodDefinition method = MyTable[nameTableIndex];
mLookup.SetMethodNotUnique(method);
tableCopy.Add(methodPair.Value, MyTable[nameTableIndex]);
}
// Use existing method definition.
else
{
tableCopy.Add(methodPair.Value, parentLookupTable[methodPair.Value]);
}
}
}
}