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)); }