public sealed override string WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
string variableName = string.Format("_{0}_marshaled", sourceVariable.GetNiceName());
this.WriteNativeVariableDeclarationOfType(writer, variableName);
this.WriteMarshalVariableToNative(writer, sourceVariable, variableName, managedVariableName, metadataAccess);
return variableName;
}
public override string WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, IList<MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
string marshaledVariableName = variableName.Replace("*", "");
string unmarshaledVariableName = string.Format("_{0}_unmarshaled", DefaultMarshalInfoWriter.CleanVariableName(variableName));
this.WriteDeclareAndAllocateObject(writer, unmarshaledVariableName, marshaledVariableName, metadataAccess);
this.WriteMarshalVariableFromNative(writer, variableName, new ManagedMarshalValue(unmarshaledVariableName), methodParameters, returnValue, forNativeWrapperOfManagedMethod, metadataAccess);
return unmarshaledVariableName;
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
if (!this.CanMarshalTypeToNative())
{
throw new InvalidOperationException("Cannot marshal HandleRef by reference to native code.");
}
if (<>f__am$cache0 == null)
{
public static string Box(TypeReference type, string value, IRuntimeMetadataAccess metadataAccess)
{
if (!Extensions.IsValueType(type))
{
return Cast(type, value);
}
return Call("Box", metadataAccess.TypeInfoFor(type), "&" + value);
}
public override string WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
if (DefaultMarshalInfoWriter.Naming.ForVariable(base._typeRef) != this._marshaledTypes[0].DecoratedName)
{
return string.Format("reinterpret_cast<{0}>({1})", this._marshaledTypes[0].DecoratedName, sourceVariable.Load());
}
return sourceVariable.Load();
}
protected override void WriteMethodPrologue(CppCodeWriter writer, IRuntimeMetadataAccess metadataAccess)
{
string decoratedName = base._marshaledReturnType.DecoratedName;
object[] args = new object[] { decoratedName, InteropMethodBodyWriter.Naming.ForPInvokeFunctionPointerTypedef(), base.FormatParametersForTypedef() };
writer.WriteLine("typedef {0} (STDCALL *{1})({2});", args);
object[] objArray2 = new object[] { InteropMethodBodyWriter.Naming.ForPInvokeFunctionPointerTypedef(), InteropMethodBodyWriter.Naming.ForPInvokeFunctionPointerVariable(), InteropMethodBodyWriter.Naming.ThisParameterName };
writer.WriteLine("{0} {1} = reinterpret_cast<{0}>(((Il2CppDelegate*){2})->method->methodPointer);", objArray2);
writer.WriteLine();
}
public override string WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, IList<MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
string str = DefaultMarshalInfoWriter.Naming.ForVariable(base._typeRef);
if (str != this._marshaledTypes[0].DecoratedName)
{
return string.Format("reinterpret_cast<{0}>({1})", str, variableName);
}
return variableName;
}
protected sealed override void WriteReturnStatement(CppCodeWriter writer, string unmarshaledReturnValueVariableName, IRuntimeMetadataAccess metadataAccess)
{
MarshaledType[] marshaledTypes = base.MarshalInfoWriterFor(this.GetMethodReturnType()).MarshaledTypes;
for (int i = 0; i < (marshaledTypes.Length - 1); i++)
{
object[] args = new object[] { InteropMethodBodyWriter.Naming.ForComInterfaceReturnParameterName(), unmarshaledReturnValueVariableName, marshaledTypes[i].VariableName };
writer.WriteLine("*{0}{2} = {1}{2};", args);
}
this.WriteReturnStatementEpilogue(writer, unmarshaledReturnValueVariableName);
}
protected override void WriteMethodPrologue(CppCodeWriter writer, IRuntimeMetadataAccess metadataAccess)
{
string str = InteropMethodBodyWriter.Naming.ForWindowsRuntimeDelegateComCallableWrapperInterface(base._interfaceType);
string str2 = InteropMethodBodyWriter.Naming.ForInteropInterfaceVariable(base._interfaceType);
object[] args = new object[] { str, str2, InteropMethodBodyWriter.Naming.Null };
writer.WriteLine("{0}* {1} = {2};", args);
object[] objArray2 = new object[] { InteropMethodBodyWriter.Naming.ForInteropHResultVariable(), InteropMethodBodyWriter.Naming.ThisParameterName, InteropMethodBodyWriter.Naming.ForIl2CppComObjectIdentityField(), str, str2 };
writer.WriteLine("il2cpp_hresult_t {0} = {1}->{2}->QueryInterface({3}::IID, reinterpret_cast<void**>(&{4}));", objArray2);
writer.WriteStatement(Emit.Call("il2cpp_codegen_com_raise_exception_if_failed", InteropMethodBodyWriter.Naming.ForInteropHResultVariable()));
writer.WriteLine();
}
protected string GetMethodCallExpression(IRuntimeMetadataAccess metadataAccess, string thisArgument, IEnumerable<string> localVariableNames)
{
List<string> argumentArray = new List<string> {
thisArgument
};
argumentArray.AddRange(localVariableNames);
if (MethodSignatureWriter.NeedsHiddenMethodInfo(this._managedMethod, MethodCallType.Normal, false))
{
argumentArray.Add(metadataAccess.HiddenMethodInfo(this._managedMethod));
}
return ("::" + MethodBodyWriter.GetMethodCallExpression(this._managedMethod, this._managedMethod, this._managedMethod, base._typeResolver, MethodCallType.Normal, metadataAccess, new VTableBuilder(), argumentArray, false, null));
}
protected override void WriteInteropCallStatement(CppCodeWriter writer, string[] localVariableNames, IRuntimeMetadataAccess metadataAccess)
{
MethodReturnType methodReturnType = this.GetMethodReturnType();
if (methodReturnType.ReturnType.MetadataType != MetadataType.Void)
{
base.MarshalInfoWriterFor(methodReturnType).WriteNativeVariableDeclarationOfType(writer, InteropMethodBodyWriter.Naming.ForInteropReturnValue());
}
writer.WriteStatement(this.GetMethodCallExpression(localVariableNames));
this.OnBeforeHResultCheck(writer);
writer.WriteLine();
writer.WriteStatement(Emit.Call("il2cpp_codegen_com_raise_exception_if_failed", InteropMethodBodyWriter.Naming.ForInteropHResultVariable()));
}
public sealed override void WriteMarshalCleanupVariable(CppCodeWriter writer, string variableName, IRuntimeMetadataAccess metadataAccess, string managedVariableName)
{
if (!this._isSealed)
{
object[] args = new object[] { variableName, DefaultMarshalInfoWriter.Naming.Null };
writer.WriteLine("if ({0} != {1})", args);
using (new BlockWriter(writer, false))
{
object[] objArray2 = new object[] { variableName };
writer.WriteLine("({0})->Release();", objArray2);
object[] objArray3 = new object[] { variableName, DefaultMarshalInfoWriter.Naming.Null };
writer.WriteLine("{0} = {1};", objArray3);
}
}
}
protected override void WriteMethodPrologue(CppCodeWriter writer, IRuntimeMetadataAccess metadataAccess)
{
string str = InteropMethodBodyWriter.Naming.ForTypeNameOnly(this._interfaceType);
string str2 = InteropMethodBodyWriter.Naming.ForInteropInterfaceVariable(this._interfaceType);
if (this.UseQueryInterfaceToObtainInterfacePointer)
{
object[] args = new object[] { str, str2, InteropMethodBodyWriter.Naming.Null };
writer.WriteLine("{0}* {1} = {2};", args);
object[] objArray2 = new object[] { InteropMethodBodyWriter.Naming.ForInteropHResultVariable(), InteropMethodBodyWriter.Naming.ForVariable(InteropMethodBodyWriter.TypeProvider.Il2CppComObjectTypeReference), InteropMethodBodyWriter.Naming.ThisParameterName, InteropMethodBodyWriter.Naming.ForIl2CppComObjectIdentityField(), str, str2 };
writer.WriteLine("il2cpp_hresult_t {0} = static_cast<{1}>({2})->{3}->QueryInterface({4}::IID, reinterpret_cast<void**>(&{5}));", objArray2);
writer.WriteStatement(Emit.Call("il2cpp_codegen_com_raise_exception_if_failed", InteropMethodBodyWriter.Naming.ForInteropHResultVariable()));
}
else
{
string str3 = !this._actualMethod.HasThis ? string.Format("(({0}*){1}->static_fields)", InteropMethodBodyWriter.Naming.ForStaticFieldsStruct(this._actualMethod.DeclaringType), metadataAccess.TypeInfoFor(this._actualMethod.DeclaringType)) : string.Format("{0}", InteropMethodBodyWriter.Naming.ThisParameterName);
object[] objArray3 = new object[] { InteropMethodBodyWriter.Naming.ForTypeNameOnly(this._interfaceType), InteropMethodBodyWriter.Naming.ForInteropInterfaceVariable(this._interfaceType), str3, InteropMethodBodyWriter.Naming.ForComTypeInterfaceFieldGetter(this._interfaceType) };
writer.WriteLine("{0}* {1} = {2}->{3}();", objArray3);
}
writer.WriteLine();
}
protected override void WriteInteropCallStatement(CppCodeWriter writer, string[] localVariableNames, IRuntimeMetadataAccess metadataAccess)
{
MethodReturnType methodReturnType = this.GetMethodReturnType();
if (methodReturnType.ReturnType.MetadataType != MetadataType.Void)
{
object[] args = new object[] { InteropMethodBodyWriter.Naming.ForVariable(base._typeResolver.Resolve(methodReturnType.ReturnType)), InteropMethodBodyWriter.Naming.ForInteropReturnValue() };
writer.WriteLine("{0} {1};", args);
}
writer.WriteLine("try");
using (new BlockWriter(writer, false))
{
if (Extensions.IsValueType(base._managedMethod.DeclaringType))
{
object[] objArray2 = new object[] { InteropMethodBodyWriter.Naming.ForTypeNameOnly(base._managedMethod.DeclaringType), InteropMethodBodyWriter.Naming.ThisParameterName, metadataAccess.TypeInfoFor(base._managedMethod.DeclaringType) };
writer.WriteLine("{0}* {1} = ({0}*)UnBox(GetManagedObjectInline(), {2});", objArray2);
}
else
{
object[] objArray3 = new object[] { InteropMethodBodyWriter.Naming.ForVariable(base._managedMethod.DeclaringType), InteropMethodBodyWriter.Naming.ThisParameterName };
writer.WriteLine("{0} {1} = ({0})GetManagedObjectInline();", objArray3);
}
string block = base.GetMethodCallExpression(metadataAccess, InteropMethodBodyWriter.Naming.ThisParameterName, localVariableNames);
if (methodReturnType.ReturnType.MetadataType != MetadataType.Void)
{
object[] objArray4 = new object[] { InteropMethodBodyWriter.Naming.ForInteropReturnValue(), block };
writer.WriteLine("{0} = {1};", objArray4);
}
else
{
writer.WriteStatement(block);
}
}
writer.WriteLine("catch (const Il2CppExceptionWrapper& ex)");
using (new BlockWriter(writer, false))
{
writer.WriteLine("return ex.ex->hresult;");
}
}
private void ActivateThroughCompositionFactory(CppCodeWriter writer, string staticFieldsAccess, string parameters, IRuntimeMetadataAccess metadataAccess)
{
string str = metadataAccess.TypeInfoFor(this.constructedObjectType);
string str2 = InteropMethodBodyWriter.Naming.ForMethod(this.factoryMethod);
TypeReference interfaceType = Extensions.ExtractDefaultInterface(this.constructedObjectType.Resolve());
string str3 = InteropMethodBodyWriter.Naming.ForComTypeInterfaceFieldName(interfaceType);
writer.WriteLine(string.Format("Il2CppIInspectable* outerInstance = {0};", InteropMethodBodyWriter.Naming.Null));
writer.WriteLine(string.Format("Il2CppIInspectable** innerInstance = {0};", InteropMethodBodyWriter.Naming.Null));
writer.WriteLine(string.Format("bool isComposedConstruction = {0}->klass != {1};", this.thisParameter, str));
WriteDeclareActivationFactory(writer, this.factoryMethod.DeclaringType, staticFieldsAccess);
writer.WriteLine();
writer.WriteLine("if (isComposedConstruction)");
using (new BlockWriter(writer, false))
{
writer.WriteLine(string.Format("outerInstance = il2cpp_codegen_com_get_or_create_ccw<Il2CppIInspectable>({0});", this.thisParameter));
writer.WriteLine(string.Format("innerInstance = reinterpret_cast<Il2CppIInspectable**>(&{0}->{1});", this.thisParameter, this.identityField));
}
writer.WriteLine();
writer.WriteLine(string.Format("il2cpp_hresult_t hr = activationFactory->{0}({1}outerInstance, innerInstance, &{2}->{3});", new object[] { str2, parameters, this.thisParameter, str3 }));
writer.WriteLine("il2cpp_codegen_com_raise_exception_if_failed(hr);");
writer.WriteLine();
writer.WriteLine("if (isComposedConstruction)");
using (new BlockWriter(writer, false))
{
writer.WriteLine("outerInstance->Release();");
writer.WriteLine(string.Format("{0}->{1}->Release();", this.thisParameter, str3));
}
writer.WriteLine("else");
using (new BlockWriter(writer, false))
{
writer.WriteLine(string.Format("hr = {0}->{1}->QueryInterface(Il2CppIUnknown::IID, reinterpret_cast<void**>(&{2}->{3}));", new object[] { this.thisParameter, str3, this.thisParameter, this.identityField }));
writer.WriteLine("il2cpp_codegen_com_raise_exception_if_failed(hr);");
writer.WriteLine();
writer.WriteLine(string.Format("il2cpp_codegen_com_register_rcw({0});", this.thisParameter));
}
}
public override void WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, ManagedMarshalValue destinationVariable, IList <MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
writer.WriteLine(destinationVariable.Store(this.WriteMarshalVariableFromNative(writer, variableName, methodParameters, returnValue, forNativeWrapperOfManagedMethod, metadataAccess)));
}
public override void WriteMarshalOutParameterToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IList <MarshaledParameter> methodParameters, IRuntimeMetadataAccess metadataAccess)
{
this._elementTypeMarshalInfoWriter.WriteMarshalVariableToNative(writer, sourceVariable.Dereferenced, DefaultMarshalInfoWriter.Naming.Dereference(this.UndecorateVariable(destinationVariable)), managedVariableName, metadataAccess);
}
public override string WriteMarshalEmptyVariableFromNative(CppCodeWriter writer, string variableName, IList <MarshaledParameter> methodParameters, IRuntimeMetadataAccess metadataAccess)
{
string name = $"_{DefaultMarshalInfoWriter.CleanVariableName(variableName)}_empty";
writer.WriteVariable(this._elementType, name);
return(DefaultMarshalInfoWriter.Naming.AddressOf(name));
}
public override void WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, ManagedMarshalValue destinationVariable, IList<MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
throw new InvalidOperationException("Cannot marshal HandleRef from native code");
}
public sealed override string WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
string variableName = $"_{sourceVariable.GetNiceName()}_marshaled";
this.WriteNativeVariableDeclarationOfType(writer, variableName);
this.WriteMarshalVariableToNative(writer, sourceVariable, variableName, managedVariableName, metadataAccess);
return(variableName);
}
protected virtual void WriteReturnStatement(CppCodeWriter writer, string unmarshaledReturnValueVariableName, IRuntimeMetadataAccess metadataAccess)
{
if (this.GetMethodReturnType().ReturnType.MetadataType != MetadataType.Void)
{
object[] args = new object[] { unmarshaledReturnValueVariableName };
writer.WriteLine("return {0};", args);
}
}
private void WriteMarshalOutputParameters(CppCodeWriter writer, string[] localVariableNames, IRuntimeMetadataAccess metadataAccess)
{
for (int i = 0; i < this._parameters.Length; i++)
{
this.WriteMarshalOutputParameter(writer, localVariableNames[i], this._parameters[i], metadataAccess);
this.WriteCleanupParameter(writer, localVariableNames[i], this._parameters[i], metadataAccess);
}
}
public override void WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, ManagedMarshalValue destinationVariable, IList <MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
string str;
if (this._isStringBuilder)
{
str = !this.IsWideString ? "il2cpp_codegen_marshal_string_builder_result" : "il2cpp_codegen_marshal_wstring_builder_result";
object[] args = new object[] { str, destinationVariable.Load(), variableName };
writer.WriteLine("{0}({1}, {2});", args);
}
else
{
Mono.Cecil.NativeType type = this._nativeType;
if (type == Mono.Cecil.NativeType.BStr)
{
str = "il2cpp_codegen_marshal_bstring_result";
}
else if (type == (Mono.Cecil.NativeType.Error | Mono.Cecil.NativeType.Boolean))
{
str = "il2cpp_codegen_marshal_hstring_result";
}
else
{
str = !this.IsWideString ? "il2cpp_codegen_marshal_string_result" : "il2cpp_codegen_marshal_wstring_result";
}
object[] objArray2 = new object[] { str, variableName };
writer.WriteLine(destinationVariable.Store("{0}({1})", objArray2));
}
}
protected override void WriteMethodPrologue(CppCodeWriter writer, IRuntimeMetadataAccess metadataAccess)
{
writer.WriteLine("il2cpp_native_wrapper_vm_thread_attacher _vmThreadHelper;");
writer.WriteLine();
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
this.WriteMarshalVariableToNative(writer, sourceVariable, destinationVariable, managedVariableName, metadataAccess, false);
}
private void ActivateThroughCompositionFactory(CppCodeWriter writer, string staticFieldsAccess, string parameters, IRuntimeMetadataAccess metadataAccess)
{
string str = metadataAccess.TypeInfoFor(this.constructedObjectType);
string str2 = InteropMethodBodyWriter.Naming.ForMethod(this.factoryMethod);
TypeReference interfaceType = this.constructedObjectType.Resolve().ExtractDefaultInterface();
string str3 = InteropMethodBodyWriter.Naming.ForComTypeInterfaceFieldName(interfaceType);
writer.WriteLine($"Il2CppIInspectable* outerInstance = {InteropMethodBodyWriter.Naming.Null};");
writer.WriteLine($"Il2CppIInspectable** innerInstance = {InteropMethodBodyWriter.Naming.Null};");
writer.WriteLine($"bool isComposedConstruction = {this.thisParameter}->klass != {str};");
WriteDeclareActivationFactory(writer, this.factoryMethod.DeclaringType, staticFieldsAccess);
writer.WriteLine();
writer.WriteLine("if (isComposedConstruction)");
using (new BlockWriter(writer, false))
{
writer.WriteLine($"outerInstance = il2cpp_codegen_com_get_or_create_ccw<Il2CppIInspectable>({this.thisParameter});");
writer.WriteLine($"innerInstance = reinterpret_cast<Il2CppIInspectable**>(&{this.thisParameter}->{this.identityField});");
}
writer.WriteLine();
writer.WriteLine($"il2cpp_hresult_t hr = activationFactory->{str2}({parameters}outerInstance, innerInstance, &{this.thisParameter}->{str3});");
writer.WriteLine("il2cpp_codegen_com_raise_exception_if_failed(hr);");
writer.WriteLine();
writer.WriteLine("if (isComposedConstruction)");
using (new BlockWriter(writer, false))
{
writer.WriteLine("outerInstance->Release();");
writer.WriteLine($"{this.thisParameter}->{str3}->Release();");
}
writer.WriteLine("else");
using (new BlockWriter(writer, false))
{
writer.WriteLine($"hr = {this.thisParameter}->{str3}->QueryInterface(Il2CppIUnknown::IID, reinterpret_cast<void**>(&{this.thisParameter}->{this.identityField}));");
writer.WriteLine("il2cpp_codegen_com_raise_exception_if_failed(hr);");
writer.WriteLine();
writer.WriteLine($"il2cpp_codegen_com_register_rcw({this.thisParameter});");
}
}
protected override void WriteInteropCallStatement(CppCodeWriter writer, string[] localVariableNames, IRuntimeMetadataAccess metadataAccess)
{
string str = InteropMethodBodyWriter.Naming.ForStaticFieldsStruct(this.constructedObjectType);
string str2 = metadataAccess.TypeInfoFor(this.constructedObjectType);
string staticFieldsAccess = string.Format($"(({str}*){str2}->static_fields)", new object[0]);
string functionCallParametersExpression = base.GetFunctionCallParametersExpression(localVariableNames);
if (functionCallParametersExpression.Length > 0)
{
functionCallParametersExpression = functionCallParametersExpression + ", ";
}
if (this.factoryMethod == null)
{
this.WriteActivateThroughIActivationFactory(writer, staticFieldsAccess, functionCallParametersExpression);
}
else if (!this.isComposingConstructor)
{
this.ActivateThroughCustomActivationFactory(writer, staticFieldsAccess, functionCallParametersExpression);
}
else
{
this.ActivateThroughCompositionFactory(writer, staticFieldsAccess, functionCallParametersExpression, metadataAccess);
}
}
protected override void WriteInteropCallStatement(CppCodeWriter writer, string[] localVariableNames, IRuntimeMetadataAccess metadataAccess)
{
MethodReturnType methodReturnType = this.GetMethodReturnType();
if (methodReturnType.ReturnType.MetadataType != MetadataType.Void)
{
object[] args = new object[] { InteropMethodBodyWriter.Naming.ForVariable(base._typeResolver.Resolve(methodReturnType.ReturnType)), InteropMethodBodyWriter.Naming.ForInteropReturnValue() };
writer.WriteLine("{0} {1};", args);
}
writer.WriteLine("try");
using (new BlockWriter(writer, false))
{
if (base._managedMethod.DeclaringType.IsValueType())
{
object[] objArray2 = new object[] { InteropMethodBodyWriter.Naming.ForTypeNameOnly(base._managedMethod.DeclaringType), InteropMethodBodyWriter.Naming.ThisParameterName, metadataAccess.TypeInfoFor(base._managedMethod.DeclaringType) };
writer.WriteLine("{0}* {1} = ({0}*)UnBox(GetManagedObjectInline(), {2});", objArray2);
}
else
{
object[] objArray3 = new object[] { InteropMethodBodyWriter.Naming.ForVariable(base._managedMethod.DeclaringType), InteropMethodBodyWriter.Naming.ThisParameterName };
writer.WriteLine("{0} {1} = ({0})GetManagedObjectInline();", objArray3);
}
string block = base.GetMethodCallExpression(metadataAccess, InteropMethodBodyWriter.Naming.ThisParameterName, localVariableNames);
if (methodReturnType.ReturnType.MetadataType != MetadataType.Void)
{
object[] objArray4 = new object[] { InteropMethodBodyWriter.Naming.ForInteropReturnValue(), block };
writer.WriteLine("{0} = {1};", objArray4);
}
else
{
writer.WriteStatement(block);
}
}
writer.WriteLine("catch (const Il2CppExceptionWrapper& ex)");
using (new BlockWriter(writer, false))
{
writer.WriteLine("return ex.ex->hresult;");
}
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
object[] args = new object[] { destinationVariable, this.WriteMarshalVariableToNative(writer, sourceVariable, managedVariableName, metadataAccess) };
writer.WriteLine("{0} = {1};", args);
}
public override void WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, ManagedMarshalValue destinationVariable, IList<MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
if (this._marshalInfo.ElementType == VariantType.BStr)
{
object[] args = new object[] { DefaultMarshalInfoWriter.Naming.ForType(base._typeRef), metadataAccess.TypeInfoFor(this._elementType), variableName };
writer.WriteLine(destinationVariable.Store("({0}*)il2cpp_codegen_com_marshal_safe_array_bstring_result({1}, {2})", args));
}
else
{
object[] objArray2 = new object[] { DefaultMarshalInfoWriter.Naming.ForType(base._typeRef), this._marshalInfo.ElementType.ToString().ToUpper(), metadataAccess.TypeInfoFor(this._elementType), variableName };
writer.WriteLine(destinationVariable.Store("({0}*)il2cpp_codegen_com_marshal_safe_array_result(IL2CPP_VT_{1}, {2}, {3})", objArray2));
}
}
protected override void WriteInteropCallStatement(CppCodeWriter writer, string[] localVariableNames, IRuntimeMetadataAccess metadataAccess)
{
string str = InteropMethodBodyWriter.Naming.ForStaticFieldsStruct(this.constructedObjectType);
string str2 = metadataAccess.TypeInfoFor(this.constructedObjectType);
string staticFieldsAccess = string.Format(string.Format("(({0}*){1}->static_fields)", str, str2), new object[0]);
string functionCallParametersExpression = base.GetFunctionCallParametersExpression(localVariableNames);
if (functionCallParametersExpression.Length > 0)
{
functionCallParametersExpression = functionCallParametersExpression + ", ";
}
if (this.factoryMethod == null)
{
this.WriteActivateThroughIActivationFactory(writer, staticFieldsAccess, functionCallParametersExpression);
}
else if (!this.isComposingConstructor)
{
this.ActivateThroughCustomActivationFactory(writer, staticFieldsAccess, functionCallParametersExpression);
}
else
{
this.ActivateThroughCompositionFactory(writer, staticFieldsAccess, functionCallParametersExpression, metadataAccess);
}
}
public override string WriteMarshalEmptyVariableFromNative(CppCodeWriter writer, string variableName, IList <MarshaledParameter> methodParameters, IRuntimeMetadataAccess metadataAccess) => DefaultMarshalInfoWriter.Naming.Null;
protected virtual void WriteMethodPrologue(CppCodeWriter writer, IRuntimeMetadataAccess metadataAccess)
{
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
object[] args = new object[] { destinationVariable, sourceVariable.Load() };
writer.WriteLine("{0} = il2cpp_codegen_marshal_delegate(reinterpret_cast<Il2CppCodeGenMulticastDelegate*>({1}));", args);
}
public override string WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, IList <MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
string marshaledVariableName = variableName.Replace("*", "");
string unmarshaledVariableName = $"_{DefaultMarshalInfoWriter.CleanVariableName(variableName)}_unmarshaled";
this.WriteDeclareAndAllocateObject(writer, unmarshaledVariableName, marshaledVariableName, metadataAccess);
this.WriteMarshalVariableFromNative(writer, variableName, new ManagedMarshalValue(unmarshaledVariableName), methodParameters, returnValue, forNativeWrapperOfManagedMethod, metadataAccess);
return(unmarshaledVariableName);
}
protected void AllocateAndStoreManagedArray(CppCodeWriter writer, ManagedMarshalValue destinationVariable, IRuntimeMetadataAccess metadataAccess, string arraySizeVariable)
{
object[] args = new object[] { DefaultMarshalInfoWriter.Naming.ForVariable(this._arrayType), metadataAccess.TypeInfoFor(this._arrayType), arraySizeVariable };
writer.WriteLine(destinationVariable.Store("reinterpret_cast<{0}>(SZArrayNew({1}, {2}))", args));
}
private void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess, bool isMarshalingReturnValue)
{
string str;
if (this._nativeType == (Mono.Cecil.NativeType.Error | Mono.Cecil.NativeType.Boolean))
{
object[] args = new object[] { sourceVariable.Load(), DefaultMarshalInfoWriter.Naming.Null };
writer.WriteLine("if ({0} == {1})", args);
using (new BlockWriter(writer, false))
{
object[] arguments = new object[] { !string.IsNullOrEmpty(managedVariableName) ? managedVariableName : sourceVariable.GetNiceName() };
writer.WriteStatement(Emit.RaiseManagedException("il2cpp_codegen_get_argument_null_exception(\"{0}\")", arguments));
}
}
if (this.IsFixedSizeString)
{
str = !this.IsWideString ? "il2cpp_codegen_marshal_string_fixed" : "il2cpp_codegen_marshal_wstring_fixed";
object[] objArray3 = new object[] { str, sourceVariable.Load(), this._marshaledTypeName, destinationVariable, ((FixedSysStringMarshalInfo) this._marshalInfo).Size };
writer.WriteLine("{0}({1}, ({2})&{3}, {4});", objArray3);
}
else if (this._canReferenceOriginalManagedString && !isMarshalingReturnValue)
{
if (this._nativeType != Mono.Cecil.NativeType.LPWStr)
{
if (this._nativeType != (Mono.Cecil.NativeType.Error | Mono.Cecil.NativeType.Boolean))
{
throw new InvalidOperationException(string.Format("StringMarshalInfoWriter doesn't know how to marshal {0} while maintaining reference to original managed string.", this._nativeType));
}
string niceName = sourceVariable.GetNiceName();
string str4 = niceName + "NativeView";
string str5 = niceName + "HStringReference";
writer.WriteLine();
object[] objArray6 = new object[] { str4, sourceVariable.Load() };
writer.WriteLine("DECLARE_IL2CPP_STRING_AS_STRING_VIEW_OF_NATIVE_CHARS({0}, {1});", objArray6);
object[] objArray7 = new object[] { str5, str4 };
writer.WriteLine("il2cpp::utils::Il2CppHStringReference {0}({1});", objArray7);
object[] objArray8 = new object[] { destinationVariable, str5 };
writer.WriteLine("{0} = {1};", objArray8);
}
else
{
string str2 = sourceVariable.Load();
object[] objArray4 = new object[] { str2, DefaultMarshalInfoWriter.Naming.Null };
writer.WriteLine("if ({0} != {1})", objArray4);
using (new BlockWriter(writer, false))
{
if (<>f__am$cache0 == null)
{
public override void WriteMarshalCleanupVariable(CppCodeWriter writer, string variableName, IRuntimeMetadataAccess metadataAccess, [Optional, DefaultParameterValue(null)] string managedVariableName)
{
object[] args = new object[] { variableName };
writer.WriteLine("il2cpp_codegen_com_destroy_variant(&({0}));", args);
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
this.WriteMarshalVariableToNative(writer, sourceVariable, destinationVariable, managedVariableName, metadataAccess, false);
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
object[] args = new object[] { sourceVariable.Load(), destinationVariable };
writer.WriteLine("il2cpp_codegen_com_marshal_variant((Il2CppCodeGenObject*)({0}), &({1}));", args);
}
public override void WriteMarshalOutParameterFromNative(CppCodeWriter writer, string variableName, ManagedMarshalValue destinationVariable, IList <MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
this._elementTypeMarshalInfoWriter.WriteMarshalVariableFromNative(writer, DefaultMarshalInfoWriter.Naming.Dereference(variableName), destinationVariable.Dereferenced, methodParameters, returnValue, forNativeWrapperOfManagedMethod, metadataAccess);
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
throw new InvalidOperationException(string.Format("Cannot marshal {0} to native!", base._typeRef.FullName));
}
public override string WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, IList <MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
string str = DefaultMarshalInfoWriter.Naming.ForVariable(base._typeRef);
if (str != this._marshaledTypes[0].DecoratedName)
{
return($"reinterpret_cast<{str}>({variableName})");
}
return(variableName);
}
public override string WriteMarshalEmptyVariableFromNative(CppCodeWriter writer, string variableName, IList<MarshaledParameter> methodParameters, IRuntimeMetadataAccess metadataAccess)
{
throw new InvalidOperationException(string.Format("Cannot marshal {0} from native!", base._typeRef.FullName));
}
public override string WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
if (DefaultMarshalInfoWriter.Naming.ForVariable(base._typeRef) != this._marshaledTypes[0].DecoratedName)
{
return($"reinterpret_cast<{this._marshaledTypes[0].DecoratedName}>({sourceVariable.Load()})");
}
return(sourceVariable.Load());
}
private void WriteMarshalOutputParameter(CppCodeWriter writer, string valueName, MarshaledParameter parameter, IRuntimeMetadataAccess metadataAccess)
{
if (this.IsOutParameter(parameter))
{
this._marshaler.WriteMarshalOutputParameter(writer, valueName, parameter, this._parameters, metadataAccess);
}
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
if (this._marshalInfo.ElementType == VariantType.BStr)
{
object[] args = new object[] { destinationVariable, sourceVariable.Load() };
writer.WriteLine("{0} = il2cpp_codegen_com_marshal_safe_array_bstring({1});", args);
}
else
{
object[] objArray2 = new object[] { destinationVariable, this._marshalInfo.ElementType.ToString().ToUpper(), sourceVariable.Load() };
writer.WriteLine("{0} = il2cpp_codegen_com_marshal_safe_array(IL2CPP_VT_{1}, {2});", objArray2);
}
}
private void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess, bool isMarshalingReturnValue)
{
string str;
if (this._nativeType == (Mono.Cecil.NativeType.Error | Mono.Cecil.NativeType.Boolean))
{
object[] args = new object[] { sourceVariable.Load(), DefaultMarshalInfoWriter.Naming.Null };
writer.WriteLine("if ({0} == {1})", args);
using (new BlockWriter(writer, false))
{
object[] arguments = new object[] { !string.IsNullOrEmpty(managedVariableName) ? managedVariableName : sourceVariable.GetNiceName() };
writer.WriteStatement(Emit.RaiseManagedException("il2cpp_codegen_get_argument_null_exception(\"{0}\")", arguments));
}
}
if (this.IsFixedSizeString)
{
str = !this.IsWideString ? "il2cpp_codegen_marshal_string_fixed" : "il2cpp_codegen_marshal_wstring_fixed";
object[] objArray3 = new object[] { str, sourceVariable.Load(), this._marshaledTypeName, destinationVariable, ((FixedSysStringMarshalInfo)this._marshalInfo).Size };
writer.WriteLine("{0}({1}, ({2})&{3}, {4});", objArray3);
}
else if (this._canReferenceOriginalManagedString && !isMarshalingReturnValue)
{
if (this._nativeType != Mono.Cecil.NativeType.LPWStr)
{
if (this._nativeType != (Mono.Cecil.NativeType.Error | Mono.Cecil.NativeType.Boolean))
{
throw new InvalidOperationException($"StringMarshalInfoWriter doesn't know how to marshal {this._nativeType} while maintaining reference to original managed string.");
}
string niceName = sourceVariable.GetNiceName();
string str4 = niceName + "NativeView";
string str5 = niceName + "HStringReference";
writer.WriteLine();
object[] objArray6 = new object[] { str4, sourceVariable.Load() };
writer.WriteLine("DECLARE_IL2CPP_STRING_AS_STRING_VIEW_OF_NATIVE_CHARS({0}, {1});", objArray6);
object[] objArray7 = new object[] { str5, str4 };
writer.WriteLine("il2cpp::utils::Il2CppHStringReference {0}({1});", objArray7);
object[] objArray8 = new object[] { destinationVariable, str5 };
writer.WriteLine("{0} = {1};", objArray8);
}
else
{
string str2 = sourceVariable.Load();
object[] objArray4 = new object[] { str2, DefaultMarshalInfoWriter.Naming.Null };
writer.WriteLine("if ({0} != {1})", objArray4);
using (new BlockWriter(writer, false))
{
if (< > f__am$cache0 == null)
{
public override void WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, ManagedMarshalValue destinationVariable, IList <MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
object[] args = new object[] { DefaultMarshalInfoWriter.Naming.ForType(base._typeRef), variableName, metadataAccess.TypeInfoFor(base._typeRef) };
writer.WriteLine(destinationVariable.Store("il2cpp_codegen_marshal_function_ptr_to_delegate<{0}>({1}, {2})", args));
}
public override void WriteMarshalCleanupVariable(CppCodeWriter writer, string variableName, IRuntimeMetadataAccess metadataAccess, [Optional, DefaultParameterValue(null)] string managedVariableName)
{
object[] args = new object[] { variableName };
writer.WriteLine("il2cpp_codegen_com_destroy_safe_array({0});", args);
object[] objArray2 = new object[] { variableName, DefaultMarshalInfoWriter.Naming.Null };
writer.WriteLine("{0} = {1};", objArray2);
}
protected void WriteCleanupLoop(CppCodeWriter outerWriter, string variableName, IRuntimeMetadataAccess metadataAccess, Func <CppCodeWriter, string> writeLoopCountVariable)
{
public override void WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, ManagedMarshalValue destinationVariable, IList <MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
throw new InvalidOperationException("Cannot marshal HandleRef from native code");
}
protected override void WriteMethodEpilogue(CppCodeWriter writer, IRuntimeMetadataAccess metadataAccess)
{
}
public override void WriteMarshalVariableToNative(CppCodeWriter writer, ManagedMarshalValue sourceVariable, string destinationVariable, string managedVariableName, IRuntimeMetadataAccess metadataAccess)
{
if (!this.CanMarshalTypeToNative())
{
throw new InvalidOperationException("Cannot marshal HandleRef by reference to native code.");
}
if (< > f__am$cache0 == null)
{
public override void WriteMarshalVariableFromNative(CppCodeWriter writer, string variableName, ManagedMarshalValue destinationVariable, IList<MarshaledParameter> methodParameters, bool returnValue, bool forNativeWrapperOfManagedMethod, IRuntimeMetadataAccess metadataAccess)
{
object[] args = new object[] { variableName };
writer.WriteLine(destinationVariable.Store("(Il2CppObject*)il2cpp_codegen_com_marshal_variant_result(&({0}))", args));
}
private void WriteCleanupParameter(CppCodeWriter writer, string valueName, MarshaledParameter parameter, IRuntimeMetadataAccess metadataAccess)
{
if (this.ParameterRequiresCleanup(parameter))
{
if (this.IsInParameter(parameter))
{
this._marshaler.WriteMarshalCleanupParameter(writer, valueName, parameter, metadataAccess);
}
else
{
this._marshaler.WriteMarshalCleanupEmptyParameter(writer, valueName, parameter, metadataAccess);
}
}
}
public override void WriteMarshalCleanupVariable(CppCodeWriter writer, string variableName, IRuntimeMetadataAccess metadataAccess, string managedVariableName = null)
{
protected abstract void WriteInteropCallStatement(CppCodeWriter writer, string[] localVariableNames, IRuntimeMetadataAccess metadataAccess);
public void WriteCallStackInformation(CppCodeWriter writer, MethodReference methodReference, IEnumerable<KeyValuePair<string, TypeReference>> locals, IRuntimeMetadataAccess metadataAccess)
{
}
private string WriteMarshalInputParameter(CppCodeWriter writer, MarshaledParameter parameter, IRuntimeMetadataAccess metadataAccess)
{
if (this.IsInParameter(parameter))
{
return(this._marshaler.WriteMarshalInputParameter(writer, parameter, this._parameters, metadataAccess));
}
return(this._marshaler.WriteMarshalEmptyInputParameter(writer, parameter, this._parameters, metadataAccess));
}
