public ulong GetRVA(string fullName)
{
string[] fullNameParts = fullName.Split('.');
if (fullNameParts.Length != 3)
{
return(0);
}
lock (syncLock) {
for (int imageIndex = 0; imageIndex < metadata.imageDefs.Length; imageIndex++)
{
var imageDef = metadata.imageDefs[imageIndex];
string imageName = metadata.GetStringFromIndex(imageDef.nameIndex);
if (imageName.IndexOf(fullNameParts[0], StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
var typeEnd = imageDef.typeStart + imageDef.typeCount;
for (int typeDefIndex = imageDef.typeStart; typeDefIndex < typeEnd; typeDefIndex++)
{
var typeDef = metadata.typeDefs[typeDefIndex];
string typeName = executor.GetTypeDefName(typeDef, false, true);
if (!typeName.Equals(fullNameParts[1], StringComparison.OrdinalIgnoreCase))
{
continue;
}
var methodEnd = typeDef.methodStart + typeDef.method_count;
for (var i = typeDef.methodStart; i < methodEnd; ++i)
{
var methodDef = metadata.methodDefs[i];
var methodName = metadata.GetStringFromIndex(methodDef.nameIndex);
if (!methodName.Equals(fullNameParts[2], StringComparison.OrdinalIgnoreCase))
{
continue;
}
var methodPointer = il2Cpp.GetMethodPointer(methodDef.methodIndex, i, imageIndex, methodDef.token);
if (methodPointer > 0)
{
return(il2Cpp.GetRVA(methodPointer));
}
return(0);
}
}
}
}
return(0);
}
public string GetTypeName(Il2CppType il2CppType, bool addNamespace, bool is_nested)
{
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: {
var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array);
var elementType = il2Cpp.GetIl2CppType(arrayType.etype);
return($"{GetTypeName(elementType, addNamespace, false)}[{new string(',', arrayType.rank - 1)}]");
}
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: {
var elementType = il2Cpp.GetIl2CppType(il2CppType.data.type);
return($"{GetTypeName(elementType, addNamespace, false)}[]");
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR: {
var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type);
return($"{GetTypeName(oriType, addNamespace, false)}*");
}
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: {
var param = metadata.genericParameters[il2CppType.data.genericParameterIndex];
return(metadata.GetStringFromIndex(param.nameIndex));
}
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: {
string str = string.Empty;
Il2CppTypeDefinition typeDef;
bool wasUsed = false;
Il2CppGenericClass genericClass = default(Il2CppGenericClass);
if (il2CppType.type == Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST)
{
genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex];
wasUsed = true;
}
else
{
typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
}
if (typeDef.declaringTypeIndex != -1)
{
str += GetTypeName(il2Cpp.types[typeDef.declaringTypeIndex], addNamespace, true);
str += '.';
}
else if (addNamespace)
{
var @namespace = metadata.GetStringFromIndex(typeDef.namespaceIndex);
if (@namespace != "")
{
str += @namespace + ".";
}
}
var typeName = metadata.GetStringFromIndex(typeDef.nameIndex);
var index = typeName.IndexOf("`");
if (index != -1)
{
str += typeName.Substring(0, index);
}
else
{
str += typeName;
}
if (is_nested)
{
return(str);
}
if (wasUsed)
{
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst);
str += GetGenericInstParams(genericInst);
}
else if (typeDef.genericContainerIndex >= 0)
{
var genericContainer = metadata.genericContainers[typeDef.genericContainerIndex];
var genericParameterNames = new List <string>();
for (int i = 0; i < genericContainer.type_argc; i++)
{
var genericParameterIndex = genericContainer.genericParameterStart + i;
var param = metadata.genericParameters[genericParameterIndex];
genericParameterNames.Add(metadata.GetStringFromIndex(param.nameIndex));
}
str += $"<{string.Join(", ", genericParameterNames)}>";
}
return(str);
}
default:
return(TypeString[(int)il2CppType.type]);
}
}
