private static string GetTypeName(Il2CppType pType)
{
string ret;
switch (pType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
{
var klass = metadata.typeDefs[pType.data.klassIndex];
ret = metadata.GetStringFromIndex(klass.nameIndex);
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
var generic_class = il2cpp.MapVATR <Il2CppGenericClass>(pType.data.generic_class);
var pMainDef = metadata.typeDefs[generic_class.typeDefinitionIndex];
ret = metadata.GetStringFromIndex(pMainDef.nameIndex);
var typeNames = new List <string>();
var pInst = il2cpp.MapVATR <Il2CppGenericInst>(generic_class.context.class_inst);
var pointers = il2cpp.GetPointers(pInst.type_argv, (long)pInst.type_argc);
for (uint i = 0; i < pInst.type_argc; ++i)
{
var pOriType = il2cpp.GetIl2CppType(pointers[i]);
typeNames.Add(GetTypeName(pOriType));
}
ret += $"<{string.Join(", ", typeNames)}>";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
{
var arrayType = il2cpp.MapVATR <Il2CppArrayType>(pType.data.array);
var type = il2cpp.GetIl2CppType(arrayType.etype);
ret = $"{GetTypeName(type)}[{new string(',', arrayType.rank - 1)}]";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
var type = il2cpp.GetIl2CppType(pType.data.type);
ret = $"{GetTypeName(type)}[]";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var type = il2cpp.GetIl2CppType(pType.data.type);
ret = $"{GetTypeName(type)}*";
break;
}
default:
ret = TypeString[(int)pType.type];
break;
}
return(ret);
}
public Il2CppTypeDefinition GetTypeDefinitionFromIl2CppType(Il2CppType il2CppType)
{
if (il2Cpp.Version >= 27 && il2Cpp is ElfBase elf && elf.IsDumped)
{
var offset = il2CppType.data.typeHandle - metadata.Address - metadata.header.typeDefinitionsOffset;
var index = offset / (ulong)metadata.SizeOf(typeof(Il2CppTypeDefinition));
return(metadata.typeDefs[index]);
}
private bool IsValueType(Il2CppType il2CppType, Il2CppGenericContext context)
{
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
{
var typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
if (!typeDef.IsEnum)
{
return(true);
}
else
{
return(false);
}
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex];
return(typeDef.IsValueType);
}
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
{
if (context != null)
{
var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex];
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.class_inst);
var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc);
var pointer = pointers[genericParameter.num];
var type = il2Cpp.GetIl2CppType(pointer);
return(IsValueType(type, null));
}
return(false);
}
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
{
if (context != null)
{
var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex];
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.method_inst);
var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc);
var pointer = pointers[genericParameter.num];
var type = il2Cpp.GetIl2CppType(pointer);
return(IsValueType(type, null));
}
return(false);
}
default:
return(false);
}
}
private TypeReference GetBlobValueTypeReference(BlobValue blobValue, MemberReference memberReference)
{
if (blobValue.EnumType != null)
{
return(GetTypeReference(memberReference, blobValue.EnumType));
}
var il2CppType = new Il2CppType();
il2CppType.type = blobValue.il2CppTypeEnum;
return(GetTypeReference(memberReference, il2CppType));
}
private string include_path(Il2CppType type)
{
string output;
string type_name = "";
switch (type.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
return("cs/array");
}
case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
{
return("cs/string");
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
Il2CppTypeDefinition typeDef;
Il2CppGenericClass genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(type.data.generic_class);
typeDef = executor.GetGenericClassTypeDefinition(genericClass);
var @namespace = metadata.GetStringFromIndex(typeDef.namespaceIndex);
if (@namespace != "")
{
type_name += @namespace + ".";
}
type_name += metadata.GetStringFromIndex(typeDef.nameIndex);
var index = type_name.IndexOf("`");
if (index != -1)
{
type_name = type_name.Substring(0, index);
}
break;
}
default:
type_name = executor.GetTypeName(type, true, false);
break;
}
type_name = deobfu(type_name);
type_name = type_name.Replace(".", "/");
type_name = type_name.Replace("::", "/");
type_name = type_name.Replace("*", "");
output = "au/" + type_name;
return(output);
}
private void ParseArrayClassStruct(Il2CppType il2CppType, Il2CppGenericContext context)
{
var structName = GetIl2CppStructName(il2CppType, context);
arrayClassPreHeader.Append($"struct {structName}_array;\n");
arrayClassHeader.Append($"struct {structName}_array {{\n" +
$"\tIl2CppObject obj;\n" +
$"\tIl2CppArrayBounds *bounds;\n" +
$"\tuintptr_t max_length;\n" +
$"\t{ParseType(il2CppType, context)} m_Items[65535];\n" +
$"}};\n");
}
public Il2CppType[] GetGenericInstParamList(Il2CppGenericInst genericInst)
{
var genericParameterTypes = new Il2CppType[genericInst.type_argc];
var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc);
for (int i = 0; i < genericInst.type_argc; i++)
{
var il2CppType = il2Cpp.GetIl2CppType(pointers[i]);
genericParameterTypes[i] = il2CppType;
}
return(genericParameterTypes);
}
public Il2CppGenericParameter GetGenericParameteFromIl2CppType(Il2CppType il2CppType)
{
if (il2Cpp.Version >= 27 && il2Cpp.IsDumped)
{
var offset = il2CppType.data.genericParameterHandle - metadata.ImageBase - metadata.header.genericParametersOffset;
var index = offset / (ulong)metadata.SizeOf(typeof(Il2CppGenericParameter));
return(metadata.genericParameters[index]);
}
else
{
return(metadata.genericParameters[il2CppType.data.genericParameterIndex]);
}
}
public Il2CppTypeDefinition GetTypeDefinitionFromIl2CppType(Il2CppType il2CppType)
{
if (il2Cpp.Version >= 27 && il2Cpp.IsDumped)
{
var offset = il2CppType.data.typeHandle - metadata.ImageBase - metadata.header.typeDefinitionsOffset;
var index = offset / (ulong)metadata.SizeOf(typeof(Il2CppTypeDefinition));
return(metadata.typeDefs[index]);
}
else
{
return(metadata.typeDefs[il2CppType.data.klassIndex]);
}
}
private static string get_type_name(Il2CppType pType)
{
string ret;
if (pType.type == Il2CppTypeEnum.IL2CPP_TYPE_CLASS || pType.type == Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE)
{
Il2CppTypeDefinition klass = metadata.typeDefs[pType.data.klassIndex];
ret = metadata.GetString(klass.nameIndex);
}
else if (pType.type == Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST)
{
Il2CppGenericClass generic_class = il2cpp.MapVATR <Il2CppGenericClass>(pType.data.generic_class);
Il2CppTypeDefinition pMainDef = metadata.typeDefs[generic_class.typeDefinitionIndex];
ret = metadata.GetString(pMainDef.nameIndex);
var typeNames = new List <string>();
Il2CppGenericInst pInst = il2cpp.MapVATR <Il2CppGenericInst>(generic_class.context.class_inst);
var pointers = il2cpp.MapVATR <uint>(pInst.type_argv, (int)pInst.type_argc);
for (int i = 0; i < pInst.type_argc; ++i)
{
var pOriType = il2cpp.MapVATR <Il2CppType>(pointers[i]);
pOriType.Init();
typeNames.Add(get_type_name(pOriType));
}
ret += $"<{string.Join(", ", typeNames)}>";
}
else if (pType.type == Il2CppTypeEnum.IL2CPP_TYPE_ARRAY)
{
Il2CppArrayType arrayType = il2cpp.MapVATR <Il2CppArrayType>(pType.data.array);
var type = il2cpp.MapVATR <Il2CppType>(arrayType.etype);
type.Init();
ret = $"{get_type_name(type)}[]";
}
else if (pType.type == Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY)
{
var type = il2cpp.MapVATR <Il2CppType>(pType.data.type);
type.Init();
ret = $"{get_type_name(type)}[]";
}
else
{
if ((int)pType.type >= szTypeString.Length)
{
ret = "unknow";
}
else
{
ret = szTypeString[(int)pType.type];
}
}
return(ret);
}
public Il2CppTypeEnum ReadEncodedTypeEnum(BinaryReader reader, out Il2CppType enumType)
{
enumType = null;
var type = (Il2CppTypeEnum)reader.ReadByte();
if (type == Il2CppTypeEnum.IL2CPP_TYPE_ENUM)
{
var enumTypeIndex = reader.ReadCompressedInt32();
enumType = il2Cpp.types[enumTypeIndex];
var typeDef = GetTypeDefinitionFromIl2CppType(enumType);
type = il2Cpp.types[typeDef.elementTypeIndex].type;
}
return(type);
}
public string GetName(Il2CppType il2CppType, string originalName)
{
if (_typeDefToName.ContainsKey(il2CppType))
{
return(_typeDefToName[il2CppType].Split('|')[1]);
}
Il2CppExecutor executor;
if (!_executor.TryGetTarget(out executor))
{
throw new InvalidOperationException("Cannot be used with disposed executor!");
}
var typeDef = executor.GetTypeDefinitionFromIl2CppType(il2CppType);
return(GetName(executor, typeDef, il2CppType, originalName));
}
private string GetNameSpace(Il2CppType il2CppType)
{
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
var typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
var ret = metadata.GetStringFromIndex(typeDef.namespaceIndex);
if (ret != string.Empty)
{
ret += ".";
}
return(ret);
default:
return(string.Empty);
}
}
private Il2CppTypeDefinition GetTypeDefinition(Il2CppType il2CppType)
{
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
return(metadata.typeDefs[il2CppType.data.klassIndex]);
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
return(metadata.typeDefs[genericClass.typeDefinitionIndex]);
case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
return(null);
default:
throw new NotSupportedException();
}
}
private void ParseParent(Il2CppType il2CppType, out Il2CppTypeDefinition typeDef, out Il2CppGenericContext context)
{
context = null;
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
break;
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
context = genericClass.context;
typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex];
break;
case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
typeDef = null;
break;
default:
throw new NotSupportedException();
}
}
private TypeReference GetTypeReference(MemberReference memberReference, Il2CppType pType)
{
var moduleDefinition = memberReference.Module;
switch (pType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
return(moduleDefinition.Import(typeof(Object)));
case Il2CppTypeEnum.IL2CPP_TYPE_VOID:
return(moduleDefinition.Import(typeof(void)));
case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN:
return(moduleDefinition.Import(typeof(Boolean)));
case Il2CppTypeEnum.IL2CPP_TYPE_CHAR:
return(moduleDefinition.Import(typeof(Char)));
case Il2CppTypeEnum.IL2CPP_TYPE_I1:
return(moduleDefinition.Import(typeof(SByte)));
case Il2CppTypeEnum.IL2CPP_TYPE_U1:
return(moduleDefinition.Import(typeof(Byte)));
case Il2CppTypeEnum.IL2CPP_TYPE_I2:
return(moduleDefinition.Import(typeof(Int16)));
case Il2CppTypeEnum.IL2CPP_TYPE_U2:
return(moduleDefinition.Import(typeof(UInt16)));
case Il2CppTypeEnum.IL2CPP_TYPE_I4:
return(moduleDefinition.Import(typeof(Int32)));
case Il2CppTypeEnum.IL2CPP_TYPE_U4:
return(moduleDefinition.Import(typeof(UInt32)));
case Il2CppTypeEnum.IL2CPP_TYPE_I:
return(moduleDefinition.Import(typeof(IntPtr)));
case Il2CppTypeEnum.IL2CPP_TYPE_U:
return(moduleDefinition.Import(typeof(UIntPtr)));
case Il2CppTypeEnum.IL2CPP_TYPE_I8:
return(moduleDefinition.Import(typeof(Int64)));
case Il2CppTypeEnum.IL2CPP_TYPE_U8:
return(moduleDefinition.Import(typeof(UInt64)));
case Il2CppTypeEnum.IL2CPP_TYPE_R4:
return(moduleDefinition.Import(typeof(Single)));
case Il2CppTypeEnum.IL2CPP_TYPE_R8:
return(moduleDefinition.Import(typeof(Double)));
case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
return(moduleDefinition.Import(typeof(String)));
case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF:
return(moduleDefinition.Import(typeof(TypedReference)));
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
{
var typeDefinition = typeDefinitionDic[pType.data.klassIndex];
return(moduleDefinition.Import(typeDefinition));
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
{
var arrayType = il2cpp.MapVATR <Il2CppArrayType>(pType.data.array);
var type = il2cpp.GetIl2CppType(arrayType.etype);
return(new ArrayType(GetTypeReference(memberReference, type), arrayType.rank));
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
var generic_class = il2cpp.MapVATR <Il2CppGenericClass>(pType.data.generic_class);
var typeDefinition = typeDefinitionDic[generic_class.typeDefinitionIndex];
var genericInstanceType = new GenericInstanceType(moduleDefinition.Import(typeDefinition));
var pInst = il2cpp.MapVATR <Il2CppGenericInst>(generic_class.context.class_inst);
var pointers = il2cpp.GetPointers(pInst.type_argv, (long)pInst.type_argc);
foreach (var pointer in pointers)
{
var pOriType = il2cpp.GetIl2CppType(pointer);
genericInstanceType.GenericArguments.Add(GetTypeReference(memberReference, pOriType));
}
return(genericInstanceType);
}
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
var type = il2cpp.GetIl2CppType(pType.data.type);
return(new ArrayType(GetTypeReference(memberReference, type)));
}
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
{
if (genericParameterDic.TryGetValue(pType, out var genericParameter))
{
return(genericParameter);
}
if (memberReference is MethodDefinition methodDefinition)
{
var genericName = "T" + (methodDefinition.DeclaringType.GenericParameters.Count + 1);
genericParameter = new GenericParameter(genericName, methodDefinition.DeclaringType);
methodDefinition.DeclaringType.GenericParameters.Add(genericParameter);
genericParameterDic.Add(pType, genericParameter);
return(genericParameter);
}
var typeDefinition = (TypeDefinition)memberReference;
var genericName2 = "T" + (typeDefinition.GenericParameters.Count + 1);
genericParameter = new GenericParameter(genericName2, typeDefinition);
typeDefinition.GenericParameters.Add(genericParameter);
genericParameterDic.Add(pType, genericParameter);
return(genericParameter);
}
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
{
if (genericParameterDic.TryGetValue(pType, out var genericParameter))
{
return(genericParameter);
}
var methodDefinition = (MethodDefinition)memberReference;
var genericName = "T" + (methodDefinition.GenericParameters.Count + 1);
genericParameter = new GenericParameter(genericName, methodDefinition);
methodDefinition.GenericParameters.Add(genericParameter);
genericParameterDic.Add(pType, genericParameter);
return(genericParameter);
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var type = il2cpp.GetIl2CppType(pType.data.type);
return(new PointerType(GetTypeReference(memberReference, type)));
}
default:
return(moduleDefinition.Import(typeof(Object)));
}
}
private string GetTypeName(Il2CppType type)
{
string ret;
switch (type.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
{
var typeDef = metadata.typeDefs[type.data.klassIndex];
ret = string.Empty;
if (typeDef.declaringTypeIndex != -1)
{
ret += GetTypeName(il2cpp.types[typeDef.declaringTypeIndex]) + ".";
}
ret += metadata.GetStringFromIndex(typeDef.nameIndex);
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
var genericClass = il2cpp.MapVATR <Il2CppGenericClass>(type.data.generic_class);
var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex];
ret = metadata.GetStringFromIndex(typeDef.nameIndex);
var typeNames = new List <string>();
var genericInst = il2cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst);
var pointers = il2cpp.ReadPointers(genericInst.type_argv, genericInst.type_argc);
for (uint i = 0; i < genericInst.type_argc; ++i)
{
var oriType = il2cpp.GetIl2CppType(pointers[i]);
typeNames.Add(GetTypeName(oriType));
}
ret += $"<{string.Join(", ", typeNames)}>";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
{
var arrayType = il2cpp.MapVATR <Il2CppArrayType>(type.data.array);
var oriType = il2cpp.GetIl2CppType(arrayType.etype);
ret = $"{GetTypeName(oriType)}[{new string(',', arrayType.rank - 1)}]";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
var oriType = il2cpp.GetIl2CppType(type.data.type);
ret = $"{GetTypeName(oriType)}[]";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var oriType = il2cpp.GetIl2CppType(type.data.type);
ret = $"{GetTypeName(oriType)}*";
break;
}
default:
ret = DefineConstants.TypeString[(int)type.type];
break;
}
return(ret);
}
private string GetIl2CppStructName(Il2CppType il2CppType, Il2CppGenericContext context = null)
{
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_VOID:
case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN:
case Il2CppTypeEnum.IL2CPP_TYPE_CHAR:
case Il2CppTypeEnum.IL2CPP_TYPE_I1:
case Il2CppTypeEnum.IL2CPP_TYPE_U1:
case Il2CppTypeEnum.IL2CPP_TYPE_I2:
case Il2CppTypeEnum.IL2CPP_TYPE_U2:
case Il2CppTypeEnum.IL2CPP_TYPE_I4:
case Il2CppTypeEnum.IL2CPP_TYPE_U4:
case Il2CppTypeEnum.IL2CPP_TYPE_I8:
case Il2CppTypeEnum.IL2CPP_TYPE_U8:
case Il2CppTypeEnum.IL2CPP_TYPE_R4:
case Il2CppTypeEnum.IL2CPP_TYPE_R8:
case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF:
case Il2CppTypeEnum.IL2CPP_TYPE_I:
case Il2CppTypeEnum.IL2CPP_TYPE_U:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
{
var typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
return(structNameDic[typeDef]);
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type);
return(GetIl2CppStructName(oriType));
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
{
var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array);
var elementType = il2Cpp.GetIl2CppType(arrayType.etype);
var elementStructName = GetIl2CppStructName(elementType, context);
var typeStructName = elementStructName + "_array";
if (structNameHashSet.Add(typeStructName))
{
ParseArrayClassStruct(elementType, context);
}
return(typeStructName);
}
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
var elementType = il2Cpp.GetIl2CppType(il2CppType.data.type);
var elementStructName = GetIl2CppStructName(elementType, context);
var typeStructName = elementStructName + "_array";
if (structNameHashSet.Add(typeStructName))
{
ParseArrayClassStruct(elementType, context);
}
return(typeStructName);
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
if (!genericClassStructNameDic.TryGetValue(il2CppType.data.generic_class, out var typeStructName))
{
var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex];
var typeOriName = structNameDic[typeDef];
var typeToReplaceName = FixName(executor.GetTypeDefName(typeDef, true, true));
var typeReplaceName = FixName(executor.GetTypeName(il2CppType, true, false));
typeStructName = typeOriName.Replace(typeToReplaceName, typeReplaceName);
genericClassStructNameDic.Add(il2CppType.data.generic_class, typeStructName);
if (structNameHashSet.Add(typeStructName))
{
genericClassList.Add(il2CppType.data.generic_class);
}
}
return(typeStructName);
}
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
{
if (context != null)
{
var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex];
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.class_inst);
var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc);
var pointer = pointers[genericParameter.num];
var type = il2Cpp.GetIl2CppType(pointer);
return(GetIl2CppStructName(type));
}
return("System_Object");
}
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
{
if (context != null)
{
var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex];
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.method_inst);
var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc);
var pointer = pointers[genericParameter.num];
var type = il2Cpp.GetIl2CppType(pointer);
return(GetIl2CppStructName(type));
}
return("System_Object");
}
default:
throw new NotSupportedException();
}
}
public string GetTypeName(Il2CppType il2CppType, bool addNamespace, bool is_nested, bool is_pointer = true)
{
/*
* if (il2CppType.data.klassIndex)
* var typeDef = metadata.typeDefs[typeDefIndex];
* var typeName = executor.GetTypeDefName(typeDef, false, true);*/
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($"cs::array<{GetTypeName(elementType, addNamespace, false, 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 = GetGenericParameteFromIl2CppType(il2CppType);
return(metadata.GetStringFromIndex(param.nameIndex));
}
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
string str = string.Empty;
string str_params = string.Empty;
string str_pointer = "*";
if (!is_pointer)
{
str_pointer = "";
}
Il2CppTypeDefinition typeDef;
Il2CppGenericClass genericClass = null;
if (il2CppType.type == Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST)
{
genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
typeDef = GetGenericClassTypeDefinition(genericClass);
}
else
{
typeDef = GetTypeDefinitionFromIl2CppType(il2CppType);
}
if (typeDef.declaringTypeIndex != -1)
{
// nested
str += GetTypeName(il2Cpp.types[typeDef.declaringTypeIndex], addNamespace, true, true);
str += "_";
}
else if (addNamespace)
{
var @namespace = metadata.GetStringFromIndex(typeDef.namespaceIndex);
if (@namespace != "")
{
@namespace = @namespace.Replace(".", "::");
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 (genericClass != null)
{
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst);
str_params += GetGenericInstParams(genericInst);
}
else if (typeDef.genericContainerIndex >= 0)
{
var genericContainer = metadata.genericContainers[typeDef.genericContainerIndex];
str_params += GetGenericContainerParams(genericContainer);
}
if (il2CppType.type == Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE)
{
str_pointer = "";
}
str = str.Replace("<", "_");
str = str.Replace(">", "_");
str = Il2CppDecompiler.deobfu(str);
return(str + str_params + str_pointer);
}
default:
return(TypeString[(int)il2CppType.type]);
}
}
public Il2CppTypeInfo(Il2CppType cppType)
{
this._cppType = cppType;
this._cppTypeEnum = cppType.type;
}
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 = GetGenericParameteFromIl2CppType(il2CppType);
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;
Il2CppGenericClass genericClass = null;
if (il2CppType.type == Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST)
{
genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
typeDef = GetGenericClassTypeDefinition(genericClass);
}
else
{
typeDef = GetTypeDefinitionFromIl2CppType(il2CppType);
}
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 (genericClass != null)
{
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst);
str += GetGenericInstParams(genericInst);
}
else if (typeDef.genericContainerIndex >= 0)
{
var genericContainer = metadata.genericContainers[typeDef.genericContainerIndex];
str += GetGenericContainerParams(genericContainer);
}
return(str);
}
default:
return(TypeString[(int)il2CppType.type]);
}
}
private TypeReference GetTypeReferenceWithByRef(MemberReference memberReference, Il2CppType il2CppType)
{
var typeReference = GetTypeReference(memberReference, il2CppType);
if (il2CppType.byref == 1)
{
return(new ByReferenceType(typeReference));
}
else
{
return(typeReference);
}
}
private TypeReference GetTypeReference(MemberReference memberReference, Il2CppType il2CppType)
{
var moduleDefinition = memberReference.Module;
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
return(moduleDefinition.ImportReference(typeof(object)));
case Il2CppTypeEnum.IL2CPP_TYPE_VOID:
return(moduleDefinition.ImportReference(typeof(void)));
case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN:
return(moduleDefinition.ImportReference(typeof(bool)));
case Il2CppTypeEnum.IL2CPP_TYPE_CHAR:
return(moduleDefinition.ImportReference(typeof(char)));
case Il2CppTypeEnum.IL2CPP_TYPE_I1:
return(moduleDefinition.ImportReference(typeof(sbyte)));
case Il2CppTypeEnum.IL2CPP_TYPE_U1:
return(moduleDefinition.ImportReference(typeof(byte)));
case Il2CppTypeEnum.IL2CPP_TYPE_I2:
return(moduleDefinition.ImportReference(typeof(short)));
case Il2CppTypeEnum.IL2CPP_TYPE_U2:
return(moduleDefinition.ImportReference(typeof(ushort)));
case Il2CppTypeEnum.IL2CPP_TYPE_I4:
return(moduleDefinition.ImportReference(typeof(int)));
case Il2CppTypeEnum.IL2CPP_TYPE_U4:
return(moduleDefinition.ImportReference(typeof(uint)));
case Il2CppTypeEnum.IL2CPP_TYPE_I:
return(moduleDefinition.ImportReference(typeof(IntPtr)));
case Il2CppTypeEnum.IL2CPP_TYPE_U:
return(moduleDefinition.ImportReference(typeof(UIntPtr)));
case Il2CppTypeEnum.IL2CPP_TYPE_I8:
return(moduleDefinition.ImportReference(typeof(long)));
case Il2CppTypeEnum.IL2CPP_TYPE_U8:
return(moduleDefinition.ImportReference(typeof(ulong)));
case Il2CppTypeEnum.IL2CPP_TYPE_R4:
return(moduleDefinition.ImportReference(typeof(float)));
case Il2CppTypeEnum.IL2CPP_TYPE_R8:
return(moduleDefinition.ImportReference(typeof(double)));
case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
return(moduleDefinition.ImportReference(typeof(string)));
case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF:
return(moduleDefinition.ImportReference(typeof(TypedReference)));
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
{
var typeDefinition = typeDefinitionDic[il2CppType.data.klassIndex];
return(moduleDefinition.ImportReference(typeDefinition));
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
{
var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array);
var oriType = il2Cpp.GetIl2CppType(arrayType.etype);
return(new ArrayType(GetTypeReference(memberReference, oriType), arrayType.rank));
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
var typeDefinition = typeDefinitionDic[genericClass.typeDefinitionIndex];
var genericInstanceType = new GenericInstanceType(moduleDefinition.ImportReference(typeDefinition));
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst);
var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc);
foreach (var pointer in pointers)
{
var oriType = il2Cpp.GetIl2CppType(pointer);
genericInstanceType.GenericArguments.Add(GetTypeReference(memberReference, oriType));
}
return(genericInstanceType);
}
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type);
return(new ArrayType(GetTypeReference(memberReference, oriType)));
}
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
{
if (genericParameterDic.TryGetValue(il2CppType.data.genericParameterIndex, out var genericParameter))
{
return(genericParameter);
}
if (memberReference is MethodDefinition methodDefinition)
{
return(CreateGenericParameter(il2CppType.data.genericParameterIndex, methodDefinition.DeclaringType));
}
var typeDefinition = (TypeDefinition)memberReference;
return(CreateGenericParameter(il2CppType.data.genericParameterIndex, typeDefinition));
}
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
{
if (genericParameterDic.TryGetValue(il2CppType.data.genericParameterIndex, out var genericParameter))
{
return(genericParameter);
}
var methodDefinition = (MethodDefinition)memberReference;
return(CreateGenericParameter(il2CppType.data.genericParameterIndex, methodDefinition));
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type);
return(new PointerType(GetTypeReference(memberReference, oriType)));
}
default:
throw new ArgumentOutOfRangeException();
}
}
private static string GetTypeName(Il2CppType type, bool fullName = false)
{
string ret;
switch (type.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
{
var typeDef = metadata.typeDefs[type.data.klassIndex];
ret = string.Empty;
if (fullName)
{
ret = metadata.GetStringFromIndex(typeDef.namespaceIndex);
if (ret != string.Empty)
{
ret += ".";
}
}
ret += GetTypeName(typeDef);
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
var generic_class = il2cpp.MapVATR <Il2CppGenericClass>(type.data.generic_class);
var typeDef = metadata.typeDefs[generic_class.typeDefinitionIndex];
ret = metadata.GetStringFromIndex(typeDef.nameIndex);
var genericInst = il2cpp.MapVATR <Il2CppGenericInst>(generic_class.context.class_inst);
ret += GetGenericTypeParams(genericInst);
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
{
var arrayType = il2cpp.MapVATR <Il2CppArrayType>(type.data.array);
var oriType = il2cpp.GetIl2CppType(arrayType.etype);
ret = $"{GetTypeName(oriType)}[{new string(',', arrayType.rank - 1)}]";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
var oriType = il2cpp.GetIl2CppType(type.data.type);
ret = $"{GetTypeName(oriType)}[]";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var oriType = il2cpp.GetIl2CppType(type.data.type);
ret = $"{GetTypeName(oriType)}*";
break;
}
default:
ret = TypeString[(int)type.type];
break;
}
return(ret);
}
private string header_include(Il2CppType type)
{
string output;
string type_name = "";
string namespaze = "";
string template_decl = "";
switch (type.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
return("#include <cs/array.hpp>");
}
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: return("");
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: return($"#include <{include_path(type)}.hpp>");
case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
{
return("#include <cs/string.hpp>");
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
Il2CppTypeDefinition typeDef;
Il2CppGenericClass genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(type.data.generic_class);
typeDef = executor.GetGenericClassTypeDefinition(genericClass);
var @namespace = metadata.GetStringFromIndex(typeDef.namespaceIndex);
if (@namespace != "")
{
type_name += @namespace + ".";
}
type_name += metadata.GetStringFromIndex(typeDef.nameIndex);
var index = type_name.IndexOf("`");
if (index != -1)
{
type_name = type_name.Substring(0, index);
}
template_decl = "template <class...> "; //Il2CppExecutor.GetGenericContainerParams(genericContainer, generic_decl)
break;
}
default:
{
if (type.type > Il2CppTypeEnum.IL2CPP_TYPE_R8)
{
type_name = executor.GetTypeName(type, true, false);
}
else
{
return("");
}
break;
}
}
type_name = type_name.Replace(".", "::");
type_name = type_name.Replace("*", "");
var nsindex = type_name.LastIndexOf("::");
if (nsindex > 0)
{
namespaze = type_name.Substring(0, nsindex);
type_name = type_name.Substring(nsindex + 2);
output = "namespace " + namespaze + "{ " + template_decl + "struct " + deobfu(type_name) + "; }";
}
else
{
output = "struct " + deobfu(type_name) + ";";
}
return(output);
}
private string ParseType(Il2CppType il2CppType, Il2CppGenericContext context = null)
{
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_VOID:
return("void");
case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN:
return("bool");
case Il2CppTypeEnum.IL2CPP_TYPE_CHAR:
return("uint16_t"); //Il2CppChar
case Il2CppTypeEnum.IL2CPP_TYPE_I1:
return("int8_t");
case Il2CppTypeEnum.IL2CPP_TYPE_U1:
return("uint8_t");
case Il2CppTypeEnum.IL2CPP_TYPE_I2:
return("int16_t");
case Il2CppTypeEnum.IL2CPP_TYPE_U2:
return("uint16_t");
case Il2CppTypeEnum.IL2CPP_TYPE_I4:
return("int32_t");
case Il2CppTypeEnum.IL2CPP_TYPE_U4:
return("uint32_t");
case Il2CppTypeEnum.IL2CPP_TYPE_I8:
return("int64_t");
case Il2CppTypeEnum.IL2CPP_TYPE_U8:
return("uint64_t");
case Il2CppTypeEnum.IL2CPP_TYPE_R4:
return("float");
case Il2CppTypeEnum.IL2CPP_TYPE_R8:
return("double");
case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
return("System_String_o*");
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type);
return(ParseType(oriType) + "*");
}
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
{
var typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
if (typeDef.IsEnum)
{
return(ParseType(il2Cpp.types[typeDef.elementTypeIndex]));
}
return(structNameDic[typeDef] + "_o");
}
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
{
var typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
return(structNameDic[typeDef] + "_o*");
}
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
{
if (context != null)
{
var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex];
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.class_inst);
var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc);
var pointer = pointers[genericParameter.num];
var type = il2Cpp.GetIl2CppType(pointer);
return(ParseType(type));
}
return("Il2CppObject*");
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
{
var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array);
var elementType = il2Cpp.GetIl2CppType(arrayType.etype);
var elementStructName = GetIl2CppStructName(elementType, context);
var typeStructName = elementStructName + "_array";
if (structNameHashSet.Add(typeStructName))
{
ParseArrayClassStruct(elementType, context);
}
return(typeStructName + "*");
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex];
var typeStructName = genericClassStructNameDic[il2CppType.data.generic_class];
if (structNameHashSet.Add(typeStructName))
{
genericClassList.Add(il2CppType.data.generic_class);
}
if (typeDef.IsValueType)
{
if (typeDef.IsEnum)
{
return(ParseType(il2Cpp.types[typeDef.elementTypeIndex]));
}
return(typeStructName + "_o");
}
return(typeStructName + "_o*");
}
case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF:
return("Il2CppObject*");
case Il2CppTypeEnum.IL2CPP_TYPE_I:
return("intptr_t");
case Il2CppTypeEnum.IL2CPP_TYPE_U:
return("uintptr_t");
case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
return("Il2CppObject*");
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
var elementType = il2Cpp.GetIl2CppType(il2CppType.data.type);
var elementStructName = GetIl2CppStructName(elementType, context);
var typeStructName = elementStructName + "_array";
if (structNameHashSet.Add(typeStructName))
{
ParseArrayClassStruct(elementType, context);
}
return(typeStructName + "*");
}
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
{
if (context != null)
{
var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex];
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.method_inst);
var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc);
var pointer = pointers[genericParameter.num];
var type = il2Cpp.GetIl2CppType(pointer);
return(ParseType(type));
}
return("Il2CppObject*");
}
default:
throw new NotSupportedException();
}
}
public string GetTypeName(Il2CppType il2CppType)
{
string ret;
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
{
var typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
ret = GetTypeDefName(typeDef);
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex];
ret = metadata.GetStringFromIndex(typeDef.nameIndex);
var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst);
ret = ret.Replace($"`{genericInst.type_argc}", "");
ret += GetGenericTypeParams(genericInst);
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
{
var param = metadata.genericParameters[il2CppType.data.genericParameterIndex];
ret = metadata.GetStringFromIndex(param.nameIndex);
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
{
var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array);
var oriType = il2Cpp.GetIl2CppType(arrayType.etype);
ret = $"{GetTypeName(oriType)}[{new string(',', arrayType.rank - 1)}]";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
{
var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type);
ret = $"{GetTypeName(oriType)}[]";
break;
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type);
ret = $"{GetTypeName(oriType)}*";
break;
}
default:
ret = TypeString[(int)il2CppType.type];
break;
}
return(ret);
}
static void Main(string[] args)
{
Console.WriteLine("Select Mode: 1. Manual 2.Auto");
var key = Console.ReadKey(true);
try
{
if (key.KeyChar == '2')
{
metadata = new Metadata(new MemoryStream(File.ReadAllBytes("global-metadata.dat")));
il2cpp = new Il2Cpp(new MemoryStream(File.ReadAllBytes("libil2cpp.so")));
}
else if (key.KeyChar == '1')
{
Console.Write("Input CodeRegistration(R0): ");
var codeRegistration = Convert.ToUInt32(Console.ReadLine(), 16);
Console.Write("Input MetadataRegistration(R1): ");
var metadataRegistration = Convert.ToUInt32(Console.ReadLine(), 16);
metadata = new Metadata(new MemoryStream(File.ReadAllBytes("global-metadata.dat")));
il2cpp = new Il2Cpp(new MemoryStream(File.ReadAllBytes("libil2cpp.so")), codeRegistration, metadataRegistration);
}
else
{
return;
}
var writer = new StreamWriter(new FileStream("dump.cs", FileMode.Create));
Console.WriteLine("Dumping...");
//dump_image();
for (int imageIndex = 0; imageIndex < metadata.uiImageCount; imageIndex++)
{
var imageDef = metadata.imageDefs[imageIndex];
writer.Write($"// Image {imageIndex}: {metadata.GetString(imageDef.nameIndex)} - {imageDef.typeStart}\n");
}
for (int idx = 0; idx < metadata.uiNumTypes; ++idx)
{
//dump_class(i);
var typeDef = metadata.typeDefs[idx];
writer.Write($"// Namespace: {metadata.GetString(typeDef.namespaceIndex)}\n");
if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_SERIALIZABLE) != 0)
{
writer.Write("[Serializable]\n");
}
if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_VISIBILITY_MASK) == DefineConstants.TYPE_ATTRIBUTE_PUBLIC)
{
writer.Write("public ");
}
if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_ABSTRACT) != 0)
{
writer.Write("abstract ");
}
if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_SEALED) != 0)
{
writer.Write("sealed ");
}
if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_INTERFACE) != 0)
{
writer.Write("interface ");
}
else
{
writer.Write("class ");
}
writer.Write($"{metadata.GetString(typeDef.nameIndex)} // TypeDefIndex: {idx}\n{{\n");
writer.Write("\t// Fields\n");
var fieldEnd = typeDef.fieldStart + typeDef.field_count;
for (int i = typeDef.fieldStart; i < fieldEnd; ++i)
{
//dump_field(i, idx, i - typeDef.fieldStart);
var pField = metadata.fieldDefs[i];
var pType = il2cpp.GetTypeFromTypeIndex(pField.typeIndex);
var pDefault = metadata.GetFieldDefaultFromIndex(i);
writer.Write("\t");
if ((pType.attrs & DefineConstants.FIELD_ATTRIBUTE_PRIVATE) == DefineConstants.FIELD_ATTRIBUTE_PRIVATE)
{
writer.Write("private ");
}
if ((pType.attrs & DefineConstants.FIELD_ATTRIBUTE_PUBLIC) == DefineConstants.FIELD_ATTRIBUTE_PUBLIC)
{
writer.Write("public ");
}
if ((pType.attrs & DefineConstants.FIELD_ATTRIBUTE_STATIC) != 0)
{
writer.Write("static ");
}
if ((pType.attrs & DefineConstants.FIELD_ATTRIBUTE_INIT_ONLY) != 0)
{
writer.Write("readonly ");
}
writer.Write($"{get_type_name(pType)} {metadata.GetString(pField.nameIndex)}");
if (pDefault != null && pDefault.dataIndex != -1)
{
var pointer = metadata.GetDefaultValueFromIndex(pDefault.dataIndex);
Il2CppType pTypeToUse = il2cpp.GetTypeFromTypeIndex(pDefault.typeIndex);
if (pointer > 0)
{
metadata.Position = pointer;
object multi = null;
switch (pTypeToUse.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN:
multi = metadata.ReadBoolean();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_U1:
case Il2CppTypeEnum.IL2CPP_TYPE_I1:
multi = metadata.ReadByte();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_CHAR:
multi = metadata.ReadChar();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_U2:
multi = metadata.ReadUInt16();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_I2:
multi = metadata.ReadInt16();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_U4:
multi = metadata.ReadUInt32();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_I4:
multi = metadata.ReadInt32();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_U8:
multi = metadata.ReadUInt64();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_I8:
multi = metadata.ReadInt64();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_R4:
multi = metadata.ReadSingle();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_R8:
multi = metadata.ReadDouble();
break;
case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
var uiLen = metadata.ReadInt32();
multi = Encoding.UTF8.GetString(metadata.ReadBytes(uiLen));
break;
}
if (multi is string)
{
writer.Write($" = \"{multi}\"");
}
else if (multi != null)
{
writer.Write($" = {multi}");
}
}
}
writer.Write("; // 0x{0:x}\n", il2cpp.GetFieldOffsetFromIndex(idx, i - typeDef.fieldStart));
}
writer.Write("\t// Methods\n");
var methodEnd = typeDef.methodStart + typeDef.method_count;
for (int i = typeDef.methodStart; i < methodEnd; ++i)
{
//dump_method(i);
var methodDef = metadata.methodDefs[i];
writer.Write("\t");
Il2CppType pReturnType = il2cpp.GetTypeFromTypeIndex(methodDef.returnType);
if ((methodDef.flags & DefineConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == DefineConstants.METHOD_ATTRIBUTE_PRIVATE)
{
writer.Write("private ");
}
if ((methodDef.flags & DefineConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == DefineConstants.METHOD_ATTRIBUTE_PUBLIC)
{
writer.Write("public ");
}
if ((methodDef.flags & DefineConstants.METHOD_ATTRIBUTE_VIRTUAL) != 0)
{
writer.Write("virtual ");
}
if ((methodDef.flags & DefineConstants.METHOD_ATTRIBUTE_STATIC) != 0)
{
writer.Write("static ");
}
writer.Write($"{get_type_name(pReturnType)} {metadata.GetString(methodDef.nameIndex)}(");
for (int j = 0; j < methodDef.parameterCount; ++j)
{
Il2CppParameterDefinition pParam = metadata.parameterDefs[methodDef.parameterStart + j];
string szParamName = metadata.GetString(pParam.nameIndex);
Il2CppType pType = il2cpp.GetTypeFromTypeIndex(pParam.typeIndex);
string szTypeName = get_type_name(pType);
if ((pType.attrs & DefineConstants.PARAM_ATTRIBUTE_OPTIONAL) != 0)
{
writer.Write("optional ");
}
if ((pType.attrs & DefineConstants.PARAM_ATTRIBUTE_OUT) != 0)
{
writer.Write("out ");
}
if (j != methodDef.parameterCount - 1)
{
writer.Write($"{szTypeName} {szParamName}, ");
}
else
{
writer.Write($"{szTypeName} {szParamName}");
}
}
if (methodDef.methodIndex >= 0)
{
writer.Write("); // {0:x} - {1}\n", il2cpp.pCodeRegistration.methodPointers[methodDef.methodIndex], methodDef.methodIndex);
}
else
{
writer.Write("); // 0 - -1\n");
}
}
writer.Write("}\n");
}
writer.Close();
Console.WriteLine("Done !");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey(true);
}
private string GetName(Il2CppExecutor executor, Il2CppTypeDefinition typeDef, Il2CppType il2CppType, string originalName)
{
if (_typeDefToName.ContainsKey(il2CppType))
{
return(_typeDefToName[il2CppType].Split('|')[1]);
}
var uniqueTypeNamePair = $"{typeDef.namespaceIndex}|{originalName}";
int n = 0;
while (_uniqueNames.Contains(uniqueTypeNamePair))
{
uniqueTypeNamePair = $"{typeDef.namespaceIndex}|_{++n}_{originalName}";
}
_uniqueNames.Add(uniqueTypeNamePair);
_typeDefToName[il2CppType] = uniqueTypeNamePair;
return(uniqueTypeNamePair.Split('|')[1]);
}
private string GetIl2CppStructName(Il2CppType il2CppType)
{
switch (il2CppType.type)
{
case Il2CppTypeEnum.IL2CPP_TYPE_VOID:
case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN:
case Il2CppTypeEnum.IL2CPP_TYPE_CHAR:
case Il2CppTypeEnum.IL2CPP_TYPE_I1:
case Il2CppTypeEnum.IL2CPP_TYPE_U1:
case Il2CppTypeEnum.IL2CPP_TYPE_I2:
case Il2CppTypeEnum.IL2CPP_TYPE_U2:
case Il2CppTypeEnum.IL2CPP_TYPE_I4:
case Il2CppTypeEnum.IL2CPP_TYPE_U4:
case Il2CppTypeEnum.IL2CPP_TYPE_I8:
case Il2CppTypeEnum.IL2CPP_TYPE_U8:
case Il2CppTypeEnum.IL2CPP_TYPE_R4:
case Il2CppTypeEnum.IL2CPP_TYPE_R8:
case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF:
case Il2CppTypeEnum.IL2CPP_TYPE_I:
case Il2CppTypeEnum.IL2CPP_TYPE_U:
case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
{
var typeDef = metadata.typeDefs[il2CppType.data.klassIndex];
return(structNameDic[typeDef]);
}
case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
{
var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type);
return(GetIl2CppStructName(oriType));
}
case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: //TODO
case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: //TODO
return("Il2CppArray*");
case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
{
if (!genericClassStructNameDic.TryGetValue(il2CppType.data.generic_class, out var typeStructName))
{
var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class);
var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex];
var typeOriName = structNameDic[typeDef];
var typeToReplaceName = FixName(executor.GetTypeDefName(typeDef, true, true));
var typeReplaceName = FixName(executor.GetTypeName(il2CppType, true, false));
typeStructName = typeOriName.Replace(typeToReplaceName, typeReplaceName);
genericClassStructNameDic.Add(il2CppType.data.generic_class, typeStructName);
if (structNameHashSet.Add(typeStructName))
{
genericClassList.Add(il2CppType.data.generic_class);
}
}
return(typeStructName);
}
default:
throw new NotSupportedException();
}
}
