示例#1
0
        public static void EmitExtended(this ILGenerator il, OpCode opcode, Type type)
        {
            TypeConstruct tc = type as TypeConstruct;

            if (tc != null)
            {
                var       mb = GetMethodBuilder(il);
                TypeToken token;
                if (mb is DynamicMethod)
                {
                    throw new NotSupportedException();

                    /*var sig = SignatureTools.GetSigHelper(null);
                     * sig.AddArgumentSignature(type);
                     * object scope = GetDynamicScope(il);
                     * int tok = GetTokenFor(scope, sig.GetSignature());
                     * tok &= 0x00FFFFFF;
                     * tok |= 0x1b000000;
                     * token = NewTypeToken(tok);*/
                }
                else
                {
                    token = GetTypeTokenExtended((ModuleBuilder)((MethodBuilder)mb).Module, type);
                }
                Emit(il, opcode, token);
            }
            else
            {
                il.Emit(opcode, type);
            }
        }
示例#2
0
        public static CorElementType GetCorElementType(this Type type)
        {
            TypeConstruct tc = type as TypeConstruct;

            if (tc != null)
            {
                return(tc.CorElementType);
            }
            else
            {
                return(GetCorElType.Invoke(type));
            }
        }
示例#3
0
        public static TypeToken GetTypeTokenExtended(this ModuleBuilder builder, Type type)
        {
            TypeConstruct tc = type as TypeConstruct;

            if (tc != null || builder == null)
            {
                var sig = SignatureTools.GetSigHelper(builder);
                sig.AddArgumentSignature(type);
                return(GetTokenFromTypeSpec(builder, sig.GetSignature()));
            }
            else
            {
                return(builder.GetTypeToken(type));
            }
        }
示例#4
0
        /// <summary>
        /// Creates a new field using extended field type.
        /// </summary>
        /// <param name="builder">The TypeBuilder where the field will be created.</param>
        /// <param name="name">The name of the field.</param>
        /// <param name="type">The extended field type.</param>
        /// <param name="attributes">The field attributes.</param>
        /// <returns>The created FieldBuilder.</returns>
        public static FieldBuilder DefineFieldExtended(this TypeBuilder builder, string name, Type type, FieldAttributes attributes)
        {
            TypeConstruct tc = type as TypeConstruct;

            if (tc == null)
            {
                return(builder.DefineField(name, type, attributes));
            }
            var             t   = TypeOf <FieldBuilder> .TypeID;
            FieldBuilder    fb  = (FieldBuilder)FormatterServices.GetUninitializedObject(t);
            var             mod = GetNativeModule((ModuleBuilder)builder.Module);
            SignatureHelper sig = SignatureHelper.GetFieldSigHelper(builder.Module);

            sig.AddElement(tc);
            byte[] sigd = sig.GetSignature();
            int    tok  = DefineFieldInternal.Invoke(mod, builder.TypeToken.Token, name, sigd, sigd.Length, attributes);

            InitField.Invoke(fb, name, builder, type.UnderlyingSystemType, attributes, tok, NewFieldToken(tok, type.UnderlyingSystemType));
            return(fb);
        }
示例#5
0
        public static void AddTypeToken(this SignatureHelper signature, Type type)
        {
            var           mod  = get_m_module(signature);
            TypeConstruct tcon = type as TypeConstruct;

            if (tcon != null)            //generate TypeSpec for custom type
            {
                byte[]    sig   = BuilderTools.GetSignature(mod, tcon);
                TypeToken token = mod.GetTokenFromTypeSpec(sig);
                Sig_AddToken(signature, token.Token);
            }
            else if (type.IsByRef)             //unsupported by GetTypeToken
            {
                SignatureHelper sig = SignatureTools.GetSigHelper(mod);
                sig.AddArgument(type);
                TypeToken token = mod.GetTokenFromTypeSpec(sig.GetSignature());
                Sig_AddToken(signature, token.Token);
            }
            else
            {
                Sig_AddToken(signature, mod.GetTypeToken(type).Token);
            }
        }
示例#6
0
 public static TypeToken GetTypeToken(this ModuleBuilder builder, TypeConstruct tc)
 {
     return(GetTypeTokenExtended(builder, tc));
 }