private MethodDefinition AddSetterStruct(TypeWrapper typeWrapper, FieldWrapper fieldWrapper, string[] members)
{
MethodDefinition item = new MethodDefinition(string.Format("$Set{0}", fieldWrapper.Id), MethodAttributes.CompilerControlled | MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Static, this.voidType);
((TypeDefinition)typeWrapper.Type).Methods.Add(item);
ParameterDefinition definition2 = new ParameterDefinition("instance", ParameterAttributes.None, this.objectType);
ParameterDefinition definition3 = new ParameterDefinition("value", ParameterAttributes.None, this.singleType);
ParameterDefinition definition4 = new ParameterDefinition("index", ParameterAttributes.None, this.int32Type);
item.Parameters.Add(definition2);
item.Parameters.Add(definition3);
item.Parameters.Add(definition4);
MethodBody body = item.Body;
ILProcessor iLProcessor = body.GetILProcessor();
iLProcessor.EmitLdarg(definition2);
iLProcessor.Emit(OpCodes.Castclass, typeWrapper.Type);
if (fieldWrapper.StructSequence != null)
{
this.InjectFieldSetCodeStructMember(typeWrapper.Type.Module, iLProcessor, body, fieldWrapper, definition4, definition3, 0);
return(item);
}
this.EmitKnownStructFieldSetReturn(typeWrapper.Type.Module, iLProcessor, body, fieldWrapper.Field, definition4, definition3);
return(item);
}
private MethodDefinition AddSetter(TypeWrapper typeWrapper, FieldWrapper fieldWrapper)
{
MethodDefinition item = new MethodDefinition(string.Format("$Set{0}", fieldWrapper.Id), MethodAttributes.CompilerControlled | MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Static, this.voidType);
((TypeDefinition)typeWrapper.Type).Methods.Add(item);
ParameterDefinition definition2 = new ParameterDefinition("instance", ParameterAttributes.None, this.objectType);
ParameterDefinition definition3 = new ParameterDefinition("value", ParameterAttributes.None, this.GetType(fieldWrapper));
item.Parameters.Add(definition2);
item.Parameters.Add(definition3);
ILProcessor iLProcessor = item.Body.GetILProcessor();
iLProcessor.EmitLdarg(definition2);
iLProcessor.Emit(OpCodes.Castclass, typeWrapper.Type);
if (fieldWrapper.StructSequence != null)
{
this.InjectFieldSetCode(typeWrapper.Type.Module, iLProcessor, fieldWrapper, definition3, 0);
}
else
{
this.EmitSimpleFieldSetCode(typeWrapper.Type.Module, iLProcessor, fieldWrapper.Field, definition3);
}
iLProcessor.Emit(OpCodes.Ret);
return(item);
}
private MethodDefinition AddGetUnityTypeMethod(TypeDefinition type, AssemblyWrapper assemblyWrapper)
{
MethodDefinition item = new MethodDefinition("GetUnityType", MethodAttributes.CompilerControlled | MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Static, base.ModuleContext.GetCorLibType("System.IntPtr"));
type.Methods.Add(item);
ParameterDefinition definition2 = new ParameterDefinition("id", ParameterAttributes.None, base.ModuleContext.GetCorLibType("System.Int32"));
item.Parameters.Add(definition2);
MethodBody body = item.Body;
ILProcessor iLProcessor = body.GetILProcessor();
Collection <Instruction> instructions = body.Instructions;
iLProcessor.EmitLdarg(definition2);
iLProcessor.EmitLdc_I4(assemblyWrapper.FirstTypeId);
iLProcessor.Emit(OpCodes.Sub);
Instruction[] targets = new Instruction[assemblyWrapper.Types.Length];
iLProcessor.Emit(OpCodes.Switch, targets);
iLProcessor.EmitLdc_I4(0);
iLProcessor.Emit(OpCodes.Conv_I);
iLProcessor.Emit(OpCodes.Ret);
for (int i = 0; i < assemblyWrapper.Types.Length; i++)
{
iLProcessor.Emit(OpCodes.Newobj, assemblyWrapper.Types[i].UnityType.Methods.Single <MethodDefinition>(< > c.< > 9__3_0 ?? (< > c.< > 9__3_0 = new Func <MethodDefinition, bool>(< > c.< > 9. < AddGetUnityTypeMethod > b__3_0))));
targets[i] = instructions.Last <Instruction>();
iLProcessor.Emit(OpCodes.Call, this.allocMethod);
iLProcessor.Emit(OpCodes.Call, this.toIntPtrMethod);
iLProcessor.Emit(OpCodes.Ret);
}
return(item);
}
private void EmitPrivateFieldSetMethodCall(ModuleDefinition destModule, ILProcessor ilProcessor, FieldDefinition structField, FieldWrapper fieldWrapper, ParameterDefinition valueParameter, ParameterDefinition indexParameter)
{
string str = this.MakeName(structField, fieldWrapper);
StructType type = base.MetadataContainer.AddStruct(structField.FieldType);
MethodReference method = base.OperationContext.Import(destModule, type.PrivateSetters[str]);
ilProcessor.EmitLdarg(valueParameter);
if (indexParameter != null)
{
ilProcessor.EmitLdarg(indexParameter);
}
ilProcessor.Emit(OpCodes.Call, method);
if (indexParameter != null)
{
ilProcessor.Emit(OpCodes.Ret);
}
}
private static PropertyDefinition CreateProperty <T>(TypeDefinition wrapper, ModuleDefinition module, string name)
{
FieldDefinition field = wrapper.AddField <T>($"<{name}>k__BackingField", FieldAttributes.Private);
field.CustomAttributes.Add(new CustomAttribute(module.GetConstructor <CompilerGeneratedAttribute>()));
var get = wrapper.AddMethod <T>($"get_{name}",
MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.NewSlot | MethodAttributes.Virtual);
get.AddAttribute <CompilerGeneratedAttribute>();
get.AddAttribute <IsReadOnlyAttribute>();
ILProcessor il = get.BeginEdit();
il.EmitLdarg();
il.Emit(OpCodes.Ldfld, field);
il.Emit(OpCodes.Ret);
get.EndEdit();
var set = wrapper.AddMethod($"set_{name}", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName);
var paraValue = set.AddParameter <T>("value");
set.AddAttribute <CompilerGeneratedAttribute>();
il = set.BeginEdit();
il.EmitLdarg();
il.EmitLdarg(paraValue);
il.Emit(OpCodes.Stfld, field);
il.Emit(OpCodes.Ret);
set.EndEdit();
PropertyDefinition property = new PropertyDefinition(name, PropertyAttributes.None, module.GetTypeReference <T>())
{
GetMethod = get,
SetMethod = set
};
wrapper.Properties.Add(property);
return(property);
}
private void AddConstructor()
{
MethodDefinition item = new MethodDefinition(".ctor", MethodAttributes.CompilerControlled | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.RTSpecialName | MethodAttributes.SpecialName, base.ModuleContext.GetCorLibType("System.Void"));
this.unityType.Methods.Add(item);
MethodBody body = item.Body;
ILProcessor iLProcessor = body.GetILProcessor();
iLProcessor.EmitLdarg(body.ThisParameter);
iLProcessor.Emit(OpCodes.Call, base.ModuleContext.GetCorLibMethod(this.unityType.BaseType, ".ctor"));
iLProcessor.Emit(OpCodes.Ret);
}
private MethodDefinition AddSetterObject(TypeWrapper typeWrapper, FieldWrapper fieldWrapper)
{
MethodDefinition item = new MethodDefinition(string.Format("$Set{0}", fieldWrapper.Id), MethodAttributes.CompilerControlled | MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Static, this.voidType);
((TypeDefinition)typeWrapper.Type).Methods.Add(item);
ParameterDefinition definition2 = new ParameterDefinition("instance", ParameterAttributes.None, this.objectType);
ParameterDefinition definition3 = new ParameterDefinition("value", ParameterAttributes.None, this.int64Type);
item.Parameters.Add(definition2);
item.Parameters.Add(definition3);
ILProcessor iLProcessor = item.Body.GetILProcessor();
iLProcessor.EmitLdarg(definition2);
iLProcessor.Emit(OpCodes.Castclass, typeWrapper.Type);
iLProcessor.EmitLdarg(definition3);
iLProcessor.Emit(OpCodes.Call, this.gcHandleToObjectMethod);
iLProcessor.Emit(OpCodes.Castclass, base.ModuleContext.Import(fieldWrapper.Type.Type.Resolve()));
iLProcessor.Emit(OpCodes.Stfld, base.ModuleContext.Import(fieldWrapper.Field));
iLProcessor.Emit(OpCodes.Ret);
return(item);
}
private void EmitKnownStructFieldSetReturn(ModuleDefinition destModule, ILProcessor ilProcessor, MethodBody body, FieldDefinition field, ParameterDefinition indexParameter, ParameterDefinition valueParameter)
{
int num;
ilProcessor.Emit(OpCodes.Ldflda, base.OperationContext.Import(destModule, field));
ilProcessor.EmitLdarg(valueParameter);
ilProcessor.EmitLdarg(indexParameter);
string[] members = GetKnownStructMembers(field);
Instruction[] targets = new Instruction[members.Length];
ilProcessor.Emit(OpCodes.Switch, targets);
ilProcessor.Emit(OpCodes.Ldstr, indexParameter.Name);
ilProcessor.Emit(OpCodes.Newobj, destModule.ImportReference(base.ModuleContext.GetCorLibMethod("System.ArgumentOutOfRangeException", <> c.< > 9__29_0 ?? (< > c.< > 9__29_0 = new Func <MethodDefinition, bool>(< > c.< > 9. < EmitKnownStructFieldSetReturn > b__29_0)))));
ilProcessor.Emit(OpCodes.Throw);
Collection <FieldDefinition> fields = field.FieldType.Resolve().Fields;
for (int i = 0; i < members.Length; i = num)
{
ilProcessor.Emit(OpCodes.Stfld, destModule.ImportReference(base.ModuleContext.Import(fields.Single <FieldDefinition>(f => f.Name == members[i]))));
targets[i] = body.Instructions.Last <Instruction>();
ilProcessor.Emit(OpCodes.Ret);
num = i + 1;
}
}
private static MethodDefinition Process(ModuleContext moduleContext, MethodWrapper methodWrapper, int index)
{
TypeReference corLibType = moduleContext.GetCorLibType("System.Int64");
MethodReference method = moduleContext.Import(moduleContext.OperationContext.GCHandledObjectsGCHandleToObjectMethod);
MethodReference reference3 = moduleContext.Import(moduleContext.OperationContext.GCHandledObjectsGCHandleToPinnedArrayObjectMethod);
MethodReference reference4 = moduleContext.Import(moduleContext.OperationContext.GCHandledObjectsObjectToGCHandleMethod);
MethodReference corLibMethod = moduleContext.GetCorLibMethod("System.Runtime.InteropServices.Marshal", <> c.< > 9__7_0 ?? (< > c.< > 9__7_0 = new Func <MethodDefinition, bool>(< > c.< > 9. < Process > b__7_0)));
MethodDefinition targetMethod = methodWrapper.TargetMethod;
MethodDefinition definition2 = new MethodDefinition(string.Format("$Invoke{0}", index), MethodAttributes.CompilerControlled | MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Static, corLibType);
methodWrapper.InvokeMethod = definition2;
ParameterDefinition item = new ParameterDefinition("instance", ParameterAttributes.None, corLibType);
ParameterDefinition definition4 = new ParameterDefinition("args", ParameterAttributes.None, new PointerType(corLibType));
definition2.Parameters.Add(item);
definition2.Parameters.Add(definition4);
ILProcessor iLProcessor = definition2.Body.GetILProcessor();
if (targetMethod.HasThis)
{
iLProcessor.EmitLdarg(item);
iLProcessor.Emit(OpCodes.Call, method);
if (targetMethod.DeclaringType.MetadataType != MetadataType.Object)
{
iLProcessor.Emit(OpCodes.Castclass, moduleContext.Import(methodWrapper.DeclaringType.Type));
}
}
for (int i = 0; i < targetMethod.Parameters.Count; i++)
{
TypeDefinition definition6;
ParameterDefinition definition5 = targetMethod.Parameters[i];
iLProcessor.EmitLdarg(definition4);
if (i != 0)
{
iLProcessor.EmitLdc_I4(i * 8);
iLProcessor.Emit(OpCodes.Add);
}
switch (definition5.ParameterType.MetadataType)
{
case MetadataType.Boolean:
{
iLProcessor.Emit(OpCodes.Ldind_I1);
continue;
}
case MetadataType.Byte:
{
iLProcessor.Emit(OpCodes.Ldind_I1);
continue;
}
case MetadataType.Int32:
{
iLProcessor.Emit(OpCodes.Ldind_I4);
continue;
}
case MetadataType.Int64:
{
iLProcessor.Emit(OpCodes.Ldind_I8);
continue;
}
case MetadataType.Single:
{
iLProcessor.Emit(OpCodes.Ldind_R4);
continue;
}
case MetadataType.Double:
{
iLProcessor.Emit(OpCodes.Ldind_R8);
continue;
}
case MetadataType.String:
{
iLProcessor.Emit(OpCodes.Ldind_I);
iLProcessor.Emit(OpCodes.Call, corLibMethod);
continue;
}
case MetadataType.ValueType:
{
definition6 = definition5.ParameterType.Resolve();
if (!definition6.IsEnum)
{
break;
}
iLProcessor.Emit(OpCodes.Ldind_I4);
continue;
}
case MetadataType.Class:
case MetadataType.GenericInstance:
{
iLProcessor.Emit(OpCodes.Ldind_I8);
iLProcessor.Emit(OpCodes.Call, method);
iLProcessor.Emit(definition5.ParameterType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, moduleContext.Import(definition5.ParameterType));
continue;
}
case MetadataType.Array:
{
iLProcessor.Emit(OpCodes.Ldind_I8);
iLProcessor.Emit(OpCodes.Call, reference3);
iLProcessor.Emit(OpCodes.Castclass, moduleContext.Import(definition5.ParameterType));
continue;
}
case MetadataType.IntPtr:
{
iLProcessor.Emit(OpCodes.Ldind_I);
continue;
}
case MetadataType.Object:
{
iLProcessor.Emit(OpCodes.Ldind_I8);
iLProcessor.Emit(OpCodes.Call, method);
continue;
}
default:
throw new NotSupportedException(string.Format("Parameter type {0} is not supported.", definition5.ParameterType.FullName));
}
if (!IsPodStruct(definition6))
{
iLProcessor.Emit(OpCodes.Ldind_I8);
iLProcessor.Emit(OpCodes.Call, method);
iLProcessor.Emit(OpCodes.Unbox_Any, moduleContext.Import(definition5.ParameterType));
}
else
{
iLProcessor.Emit(OpCodes.Ldind_I);
iLProcessor.Emit(OpCodes.Ldobj, moduleContext.Import(definition5.ParameterType));
}
}
iLProcessor.Emit(targetMethod.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, moduleContext.Import(methodWrapper.InvokeTargetMethod));
switch (targetMethod.ReturnType.MetadataType)
{
case MetadataType.Void:
iLProcessor.EmitLdc_I4(-1);
iLProcessor.Emit(OpCodes.Conv_I8);
break;
case MetadataType.Boolean:
case MetadataType.Byte:
case MetadataType.Int32:
case MetadataType.Int64:
case MetadataType.Single:
case MetadataType.ValueType:
iLProcessor.Emit(OpCodes.Box, moduleContext.Import(targetMethod.ReturnType));
iLProcessor.Emit(OpCodes.Call, reference4);
break;
case MetadataType.String:
case MetadataType.Class:
case MetadataType.Array:
case MetadataType.GenericInstance:
case MetadataType.Object:
if (targetMethod.ReturnType.IsValueType)
{
iLProcessor.Emit(OpCodes.Box, moduleContext.Import(targetMethod.ReturnType));
}
iLProcessor.Emit(OpCodes.Call, reference4);
break;
default:
throw new NotSupportedException(string.Format("Return type {0} is not supported.", targetMethod.ReturnType.FullName));
}
iLProcessor.Emit(OpCodes.Ret);
return(definition2);
}
private void EmitSimpleFieldSetCode(ModuleDefinition destModule, ILProcessor ilProcessor, FieldDefinition fieldWrapper, ParameterDefinition valueParameter)
{
ilProcessor.EmitLdarg(valueParameter);
ilProcessor.Emit(OpCodes.Stfld, base.OperationContext.Import(destModule, fieldWrapper));
}
