private MethodToken GetTokenNoLock() { Debug.Assert(m_tkMethod.Token == 0, "m_tkMethod should not have been initialized"); int sigLength; byte[] sigBytes = GetMethodSignature().InternalGetSignature(out sigLength); int token = TypeBuilder.DefineMethod(m_module.GetNativeHandle(), m_containingType.MetadataTokenInternal, m_strName, sigBytes, sigLength, Attributes); m_tkMethod = new MethodToken(token); if (m_inst != null) { foreach (GenericTypeParameterBuilder tb in m_inst) { if (!tb.m_type.IsCreated()) { tb.m_type.CreateType(); } } } TypeBuilder.SetMethodImpl(m_module.GetNativeHandle(), token, m_dwMethodImplFlags); return(m_tkMethod); }
private int GetMethodToken(MethodBase method, Type[] optionalParameterTypes, bool UseMethodDef) { int tkParent = 0; ModuleBuilder module = (ModuleBuilder)this.m_methodBuilder.Module; MethodInfo info = method as MethodInfo; if (method.IsGenericMethod) { int num2; MethodInfo genericMethodDefinition = info; bool isGenericMethodDefinition = info.IsGenericMethodDefinition; if (!isGenericMethodDefinition) { genericMethodDefinition = info.GetGenericMethodDefinition(); } if (!this.m_methodBuilder.Module.Equals(genericMethodDefinition.Module) || ((genericMethodDefinition.DeclaringType != null) && genericMethodDefinition.DeclaringType.IsGenericType)) { tkParent = this.GetMemberRefToken(genericMethodDefinition, null); } else { tkParent = module.GetMethodTokenInternal(genericMethodDefinition).Token; } if (isGenericMethodDefinition && UseMethodDef) { return(tkParent); } byte[] signature = SignatureHelper.GetMethodSpecSigHelper(module, info.GetGenericArguments()).InternalGetSignature(out num2); return(TypeBuilder.DefineMethodSpec(module.GetNativeHandle(), tkParent, signature, num2)); } if (((method.CallingConvention & CallingConventions.VarArgs) == 0) && ((method.DeclaringType == null) || !method.DeclaringType.IsGenericType)) { if (info != null) { return(module.GetMethodTokenInternal(info).Token); } return(module.GetConstructorToken(method as ConstructorInfo).Token); } return(this.GetMemberRefToken(method, optionalParameterTypes)); }
[System.Security.SecurityCritical] // auto-generated private void Init(String fullname, TypeAttributes attr, Type parent, Type[] interfaces, ModuleBuilder module, PackingSize iPackingSize, int iTypeSize, TypeBuilder enclosingType) { if (fullname == null) throw new ArgumentNullException("fullname"); if (fullname.Length == 0) throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "fullname"); if (fullname[0] == '\0') throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "fullname"); if (fullname.Length > 1023) throw new ArgumentException(Environment.GetResourceString("Argument_TypeNameTooLong"), "fullname"); Contract.EndContractBlock(); int i; m_module = module; m_DeclaringType = enclosingType; AssemblyBuilder containingAssem = m_module.ContainingAssemblyBuilder; // cannot have two types within the same assembly of the same name containingAssem.m_assemblyData.CheckTypeNameConflict(fullname, enclosingType); if (enclosingType != null) { // Nested Type should have nested attribute set. // If we are renumbering TypeAttributes' bit, we need to change the logic here. if (((attr & TypeAttributes.VisibilityMask) == TypeAttributes.Public) ||((attr & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic)) throw new ArgumentException(Environment.GetResourceString("Argument_BadNestedTypeFlags"), "attr"); } int[] interfaceTokens = null; if (interfaces != null) { for(i = 0; i < interfaces.Length; i++) { if (interfaces[i] == null) { // cannot contain null in the interface list throw new ArgumentNullException("interfaces"); } } interfaceTokens = new int[interfaces.Length + 1]; for(i = 0; i < interfaces.Length; i++) { interfaceTokens[i] = m_module.GetTypeTokenInternal(interfaces[i]).Token; } } int iLast = fullname.LastIndexOf('.'); if (iLast == -1 || iLast == 0) { // no name space m_strNameSpace = String.Empty; m_strName = fullname; } else { // split the name space m_strNameSpace = fullname.Substring(0, iLast); m_strName = fullname.Substring(iLast + 1); } VerifyTypeAttributes(attr); m_iAttr = attr; SetParent(parent); m_listMethods = new List<MethodBuilder>(); m_lastTokenizedMethod = -1; SetInterfaces(interfaces); int tkParent = 0; if (m_typeParent != null) tkParent = m_module.GetTypeTokenInternal(m_typeParent).Token; int tkEnclosingType = 0; if (enclosingType != null) { tkEnclosingType = enclosingType.m_tdType.Token; } m_tdType = new TypeToken(DefineType(m_module.GetNativeHandle(), fullname, tkParent, m_iAttr, tkEnclosingType, interfaceTokens)); m_iPackingSize = iPackingSize; m_iTypeSize = iTypeSize; if ((m_iPackingSize != 0) ||(m_iTypeSize != 0)) SetClassLayout(GetModuleBuilder().GetNativeHandle(), m_tdType.Token, m_iPackingSize, m_iTypeSize); #if !FEATURE_CORECLR // If the type is public and it is contained in a assemblyBuilder, // update the public COMType list. if (IsPublicComType(this)) { if (containingAssem.IsPersistable() && m_module.IsTransient() == false) { // This will throw InvalidOperationException if the assembly has been saved // Ideally we should reject all emit operations if the assembly has been saved, // but that would be a breaking change for some. Currently you cannot define // modules and public types, but you can still define private types and global methods. containingAssem.m_assemblyData.AddPublicComType(this); } // Now add the type to the ExportedType table if (!m_module.Equals(containingAssem.ManifestModule)) containingAssem.DefineExportedTypeInMemory(this, m_module.m_moduleData.FileToken, m_tdType.Token); } #endif m_module.AddType(FullName, this); }
[System.Security.SecurityCritical] // auto-generated internal static unsafe void SetConstantValue(ModuleBuilder module, int tk, Type destType, Object value) { // This is a helper function that is used by ParameterBuilder, PropertyBuilder, // and FieldBuilder to validate a default value and save it in the meta-data. if (value != null) { Type type = value.GetType(); // We should allow setting a constant value on a ByRef parameter if (destType.IsByRef) destType = destType.GetElementType(); if (destType.IsEnum) { // | UnderlyingSystemType | Enum.GetUnderlyingType() | IsEnum // ----------------------------------|---------------------------|---------------------------|--------- // runtime Enum Type | self | underlying type of enum | TRUE // EnumBuilder | underlying type of enum | underlying type of enum* | TRUE // TypeBuilder of enum types** | underlying type of enum | Exception | TRUE // TypeBuilder of enum types (baked) | runtime enum type | Exception | TRUE // *: the behavior of Enum.GetUnderlyingType(EnumBuilder) might change in the future // so let's not depend on it. // **: created with System.Enum as the parent type. // The above behaviors might not be the most consistent but we have to live with them. Type underlyingType; EnumBuilder enumBldr; TypeBuilder typeBldr; if ((enumBldr = destType as EnumBuilder) != null) { underlyingType = enumBldr.GetEnumUnderlyingType(); // The constant value supplied should match either the baked enum type or its underlying type // we don't need to compare it with the EnumBuilder itself because you can never have an object of that type if (type != enumBldr.m_typeBuilder.m_bakedRuntimeType && type != underlyingType) throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch")); } else if ((typeBldr = destType as TypeBuilder) != null) { underlyingType = typeBldr.m_enumUnderlyingType; // The constant value supplied should match either the baked enum type or its underlying type // typeBldr.m_enumUnderlyingType is null if the user hasn't created a "value__" field on the enum if (underlyingType == null || (type != typeBldr.UnderlyingSystemType && type != underlyingType)) throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch")); } else // must be a runtime Enum Type { Contract.Assert(destType is RuntimeType, "destType is not a runtime type, an EnumBuilder, or a TypeBuilder."); underlyingType = Enum.GetUnderlyingType(destType); // The constant value supplied should match either the enum itself or its underlying type if (type != destType && type != underlyingType) throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch")); } type = underlyingType; } else { // Note that it is non CLS compliant if destType != type. But RefEmit never guarantees CLS-Compliance. if (!destType.IsAssignableFrom(type)) throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch")); } CorElementType corType = RuntimeTypeHandle.GetCorElementType((RuntimeType)type); switch (corType) { case CorElementType.I1: case CorElementType.U1: case CorElementType.Boolean: case CorElementType.I2: case CorElementType.U2: case CorElementType.Char: case CorElementType.I4: case CorElementType.U4: case CorElementType.R4: case CorElementType.I8: case CorElementType.U8: case CorElementType.R8: fixed (byte* pData = &JitHelpers.GetPinningHelper(value).m_data) SetConstantValue(module.GetNativeHandle(), tk, (int)corType, pData); break; default: if (type == typeof(String)) { fixed (char* pString = (string)value) SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.String, pString); } else if (type == typeof(DateTime)) { //date is a I8 representation long ticks = ((DateTime)value).Ticks; SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.I8, &ticks); } else { throw new ArgumentException(Environment.GetResourceString("Argument_ConstantNotSupported", type.ToString())); } break; } } else { if (destType.IsValueType) { // nullable types can hold null value. if (!(destType.IsGenericType && destType.GetGenericTypeDefinition() == typeof(Nullable<>))) throw new ArgumentException(Environment.GetResourceString("Argument_ConstantNull")); } SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.Class, null); } }
[System.Security.SecurityCritical] // auto-generated internal static void DefineCustomAttribute(ModuleBuilder module, int tkAssociate, int tkConstructor, byte[] attr, bool toDisk, bool updateCompilerFlags) { byte[] localAttr = null; if (attr != null) { localAttr = new byte[attr.Length]; Array.Copy(attr, localAttr, attr.Length); } DefineCustomAttribute(module.GetNativeHandle(), tkAssociate, tkConstructor, localAttr, (localAttr != null) ? localAttr.Length : 0, toDisk, updateCompilerFlags); }
internal QCallModule(ref System.Reflection.Emit.ModuleBuilder module) { _ptr = Unsafe.AsPointer(ref module); _module = module.GetNativeHandle().GetUnderlyingNativeHandle(); }
internal static unsafe void SetConstantValue(ModuleBuilder module, int tk, Type destType, object value) { if (value != null) { Type c = value.GetType(); if (destType.IsByRef) { destType = destType.GetElementType(); } if (destType.IsEnum) { Type underlyingSystemType; EnumBuilder builder = destType as EnumBuilder; if (builder != null) { underlyingSystemType = builder.UnderlyingSystemType; if ((c != builder.RuntimeEnumType) && (c != underlyingSystemType)) { throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch")); } } else { TypeBuilder builder2 = destType as TypeBuilder; if (builder2 != null) { underlyingSystemType = builder2.m_underlyingSystemType; if ((underlyingSystemType == null) || ((c != builder2.UnderlyingSystemType) && (c != underlyingSystemType))) { throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch")); } } else { underlyingSystemType = Enum.GetUnderlyingType(destType); if ((c != destType) && (c != underlyingSystemType)) { throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch")); } } } c = underlyingSystemType; } else if (!destType.IsAssignableFrom(c)) { throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch")); } CorElementType corElementType = RuntimeTypeHandle.GetCorElementType(c.GetTypeHandleInternal().GetRuntimeType()); switch (corElementType) { case CorElementType.Boolean: case CorElementType.Char: case CorElementType.I1: case CorElementType.U1: case CorElementType.I2: case CorElementType.U2: case CorElementType.I4: case CorElementType.U4: case CorElementType.I8: case CorElementType.U8: case CorElementType.R4: case CorElementType.R8: fixed (byte* numRef = &JitHelpers.GetPinningHelper(value).m_data) { SetConstantValue(module.GetNativeHandle(), tk, (int) corElementType, (void*) numRef); } return; } if (c == typeof(string)) { fixed (char* str = ((char*) ((string) value))) { char* chPtr = str; SetConstantValue(module.GetNativeHandle(), tk, 14, (void*) chPtr); } } else { if (c != typeof(DateTime)) { throw new ArgumentException(Environment.GetResourceString("Argument_ConstantNotSupported", new object[] { c.ToString() })); } DateTime time = (DateTime) value; long ticks = time.Ticks; SetConstantValue(module.GetNativeHandle(), tk, 10, (void*) &ticks); } } else { if (destType.IsValueType) { throw new ArgumentException(Environment.GetResourceString("Argument_ConstantNull")); } SetConstantValue(module.GetNativeHandle(), tk, 0x12, null); } }
private void Init(String fullname, TypeAttributes attr, Type parent, Type[] interfaces, ModuleBuilder module, PackingSize iPackingSize, int iTypeSize, TypeBuilder enclosingType) { if (fullname == null) throw new ArgumentNullException(nameof(fullname)); if (fullname.Length == 0) throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), nameof(fullname)); if (fullname[0] == '\0') throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), nameof(fullname)); if (fullname.Length > 1023) throw new ArgumentException(Environment.GetResourceString("Argument_TypeNameTooLong"), nameof(fullname)); Contract.EndContractBlock(); int i; m_module = module; m_DeclaringType = enclosingType; AssemblyBuilder containingAssem = m_module.ContainingAssemblyBuilder; // cannot have two types within the same assembly of the same name containingAssem.m_assemblyData.CheckTypeNameConflict(fullname, enclosingType); if (enclosingType != null) { // Nested Type should have nested attribute set. // If we are renumbering TypeAttributes' bit, we need to change the logic here. if (((attr & TypeAttributes.VisibilityMask) == TypeAttributes.Public) ||((attr & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic)) throw new ArgumentException(Environment.GetResourceString("Argument_BadNestedTypeFlags"), nameof(attr)); } int[] interfaceTokens = null; if (interfaces != null) { for(i = 0; i < interfaces.Length; i++) { if (interfaces[i] == null) { // cannot contain null in the interface list throw new ArgumentNullException(nameof(interfaces)); } } interfaceTokens = new int[interfaces.Length + 1]; for(i = 0; i < interfaces.Length; i++) { interfaceTokens[i] = m_module.GetTypeTokenInternal(interfaces[i]).Token; } } int iLast = fullname.LastIndexOf('.'); if (iLast == -1 || iLast == 0) { // no name space m_strNameSpace = String.Empty; m_strName = fullname; } else { // split the name space m_strNameSpace = fullname.Substring(0, iLast); m_strName = fullname.Substring(iLast + 1); } VerifyTypeAttributes(attr); m_iAttr = attr; SetParent(parent); m_listMethods = new List<MethodBuilder>(); m_lastTokenizedMethod = -1; SetInterfaces(interfaces); int tkParent = 0; if (m_typeParent != null) tkParent = m_module.GetTypeTokenInternal(m_typeParent).Token; int tkEnclosingType = 0; if (enclosingType != null) { tkEnclosingType = enclosingType.m_tdType.Token; } m_tdType = new TypeToken(DefineType(m_module.GetNativeHandle(), fullname, tkParent, m_iAttr, tkEnclosingType, interfaceTokens)); m_iPackingSize = iPackingSize; m_iTypeSize = iTypeSize; if ((m_iPackingSize != 0) ||(m_iTypeSize != 0)) SetClassLayout(GetModuleBuilder().GetNativeHandle(), m_tdType.Token, m_iPackingSize, m_iTypeSize); m_module.AddType(FullName, this); }