|
public Resolve ( |
||
| field | ||
| return | ||
private static void CallBaseTypeFinalizer(MethodDefinition finalizer, CppCodeWriter writer, IRuntimeMetadataAccess metadataAccess)
{
MethodReference method = null;
TypeDefinition definition;
Unity.IL2CPP.ILPreProcessor.TypeResolver resolver;
for (TypeReference reference2 = finalizer.DeclaringType.BaseType; reference2 != null; reference2 = resolver.Resolve(definition.BaseType))
{
definition = reference2.Resolve();
resolver = Unity.IL2CPP.ILPreProcessor.TypeResolver.For(reference2);
foreach (MethodDefinition definition2 in definition.Methods)
{
if (definition2.IsFinalizerMethod())
{
method = resolver.Resolve(definition2);
break;
}
}
}
if (method != null)
{
List <string> argumentArray = new List <string>(2)
{
Naming.ThisParameterName
};
if (MethodSignatureWriter.NeedsHiddenMethodInfo(method, MethodCallType.Normal, false))
{
argumentArray.Add(metadataAccess.HiddenMethodInfo(method));
}
Unity.IL2CPP.ILPreProcessor.TypeResolver typeResolverForMethodToCall = Unity.IL2CPP.ILPreProcessor.TypeResolver.For(finalizer.DeclaringType);
string block = MethodBodyWriter.GetMethodCallExpression(finalizer, typeResolverForMethodToCall.Resolve(method), method, typeResolverForMethodToCall, MethodCallType.Normal, metadataAccess, new VTableBuilder(), argumentArray, false, null);
writer.WriteStatement(block);
}
}
internal static string BuildMethodParameterList(MethodReference interopMethod, MethodReference interfaceMethod, Unity.IL2CPP.ILPreProcessor.TypeResolver typeResolver, MarshalType marshalType, bool includeTypeNames)
{
List <string> elements = new List <string>();
int num = 0;
foreach (ParameterDefinition definition in interopMethod.Parameters)
{
MarshalInfo marshalInfo = interfaceMethod.Parameters[num].MarshalInfo;
DefaultMarshalInfoWriter writer = MarshalDataCollector.MarshalInfoWriterFor(typeResolver.Resolve(definition.ParameterType), marshalType, marshalInfo, true, false, false, null);
foreach (MarshaledType type in writer.MarshaledTypes)
{
elements.Add(string.Format(!includeTypeNames ? "{1}" : "{0} {1}", type.DecoratedName, Naming.ForParameterName(definition) + type.VariableName));
}
num++;
}
TypeReference reference2 = typeResolver.Resolve(interopMethod.ReturnType);
if (reference2.MetadataType != MetadataType.Void)
{
MarshalInfo info2 = interfaceMethod.MethodReturnType.MarshalInfo;
MarshaledType[] marshaledTypes = MarshalDataCollector.MarshalInfoWriterFor(reference2, marshalType, info2, true, false, false, null).MarshaledTypes;
for (int i = 0; i < (marshaledTypes.Length - 1); i++)
{
elements.Add(string.Format(!includeTypeNames ? "{1}" : "{0}* {1}", marshaledTypes[i].DecoratedName, Naming.ForComInterfaceReturnParameterName() + marshaledTypes[i].VariableName));
}
elements.Add(string.Format(!includeTypeNames ? "{1}" : "{0}* {1}", marshaledTypes[marshaledTypes.Length - 1].DecoratedName, Naming.ForComInterfaceReturnParameterName()));
}
return(elements.AggregateWithComma());
}
private void WriteForwardDeclarations(TypeReference type)
{
Unity.IL2CPP.ILPreProcessor.TypeResolver resolver = Unity.IL2CPP.ILPreProcessor.TypeResolver.For(type);
MarshalType marshalType = !type.Resolve().IsWindowsRuntime ? MarshalType.COM : MarshalType.WindowsRuntime;
foreach (MethodDefinition definition in type.Resolve().Methods)
{
foreach (ParameterDefinition definition2 in definition.Parameters)
{
MarshalDataCollector.MarshalInfoWriterFor(resolver.Resolve(definition2.ParameterType), marshalType, definition2.MarshalInfo, true, false, false, null).WriteMarshaledTypeForwardDeclaration(this._writer);
}
if (definition.ReturnType.MetadataType != MetadataType.Void)
{
MarshalDataCollector.MarshalInfoWriterFor(resolver.Resolve(definition.ReturnType), marshalType, definition.MethodReturnType.MarshalInfo, true, false, false, null).WriteMarshaledTypeForwardDeclaration(this._writer);
}
}
}
public static string GetSharedMethodSignature(CppCodeWriter writer, MethodReference method)
{
Unity.IL2CPP.ILPreProcessor.TypeResolver typeResolver = new Unity.IL2CPP.ILPreProcessor.TypeResolver(method.DeclaringType as GenericInstanceType, method as GenericInstanceMethod);
TypeReference variableType = typeResolver.Resolve(Unity.IL2CPP.GenericParameterResolver.ResolveReturnTypeIfNeeded(method));
RecordIncludes(writer, method, typeResolver);
string attributes = BuildMethodAttributes(method);
return(GetMethodSignature(Naming.ForMethodNameOnly(method) + "_gshared", Naming.ForVariable(variableType), FormatParameters(method, ParameterFormat.WithTypeAndName, false, true), "extern \"C\"", attributes));
}
private void CollectIncludes(CppCodeWriter writer, TypeReference type, TypeDefinition typeDefinition)
{
if (!type.HasGenericParameters)
{
if (type is ArrayType)
{
writer.AddIncludeForTypeDefinition(TypeProvider.Corlib.MainModule.GetType("System.Array"));
}
else
{
Unity.IL2CPP.ILPreProcessor.TypeResolver resolver = new Unity.IL2CPP.ILPreProcessor.TypeResolver(type as GenericInstanceType);
TypeReference typeReference = resolver.Resolve(typeDefinition.BaseType);
if (typeReference != null)
{
writer.AddIncludeForTypeDefinition(typeReference);
}
foreach (FieldDefinition definition in typeDefinition.Fields)
{
writer.AddIncludesForTypeReference(resolver.Resolve(definition.FieldType), false);
}
foreach (FieldDefinition definition2 in typeDefinition.Fields)
{
PointerType fieldType = definition2.FieldType as PointerType;
if (fieldType != null)
{
writer.AddForwardDeclaration(resolver.Resolve(fieldType.ElementType));
}
}
foreach (TypeReference reference2 in type.GetAllFactoryTypes())
{
writer.AddForwardDeclaration(reference2);
}
if (typeDefinition.IsDelegate())
{
MethodDefinition[] definitionArray;
if (!typeDefinition.IsWindowsRuntime)
{
MethodDefinition[] definitionArray1 = new MethodDefinition[3];
if (< > f__am$cache2 == null)
{
public void WriteComInterfaceFor(TypeReference type)
{
this._writer.WriteCommentedLine(type.FullName);
this.WriteForwardDeclarations(type);
string str = !type.Resolve().IsWindowsRuntime ? "Il2CppIUnknown" : "Il2CppIInspectable";
object[] args = new object[] { Naming.ForTypeNameOnly(type), str };
this._writer.WriteLine("struct NOVTABLE {0} : {1}", args);
using (new BlockWriter(this._writer, true))
{
this._writer.WriteStatement("static const Il2CppGuid IID");
Unity.IL2CPP.ILPreProcessor.TypeResolver typeResolver = Unity.IL2CPP.ILPreProcessor.TypeResolver.For(type);
foreach (MethodDefinition definition in type.Resolve().Methods)
{
MethodReference method = typeResolver.Resolve(definition);
this._writer.Write(GetSignature(method, method, typeResolver, null));
this._writer.WriteLine(" = 0;");
}
}
}
