Example #1
0
        /// <summary>
        /// Returns true if it's a System.XXX type in the corlib (eg. mscorlib)
        /// </summary>
        /// <param name="name">Name (not including namespace)</param>
        /// <returns></returns>
        public bool IsSystem(string name)
        {
            var mod = Module;

            if (mod == null)
            {
                return(false);
            }
            var names = MetaDataUtils.GetTypeDefFullNames(mod.GetMetaDataInterface <IMetaDataImport>(), Token);

            if (names.Count != 1)
            {
                return(false);
            }
            if (names[0].Name != "System." + name)
            {
                return(false);
            }

            //TODO: Check if it's mscorlib

            return(true);
        }
Example #2
0
        public string ToReflectionString()
        {
            var list = MetaDataUtils.GetTypeDefFullNames(Module.GetMetaDataInterface <IMetaDataImport>(), token);

            if (list.Count == 0)
            {
                return("???");
            }
            if (list.Count == 1)
            {
                return(list[0].Name);
            }
            var sb = new StringBuilder();

            for (int i = 0; i < list.Count; i++)
            {
                if (i > 0)
                {
                    sb.Append('+');
                }
                sb.Append(list[i].Name);
            }
            return(sb.ToString());
        }
Example #3
0
        /// <summary>
        /// Same as <see cref="ElementType"/> except that it tries to return a primitive element
        /// type (eg. <see cref="CorElementType.U4"/>) if it's a primitive type.
        /// </summary>
        public CorElementType TryGetPrimitiveType()
        {
            var etype = ElementType;

            if (etype != CorElementType.Class && etype != CorElementType.ValueType)
            {
                return(etype);
            }

            uint token;
            var  mdi  = GetMetaDataImport(out token);
            var  list = MetaDataUtils.GetTypeDefFullNames(mdi, token);

            if (list.Count != 1)
            {
                return(etype);
            }
            if (DerivesFromSystemValueType)
            {
                switch (list[0].Name)
                {
                case "System.Boolean":  return(CorElementType.Boolean);

                case "System.Byte":             return(CorElementType.U1);

                case "System.Char":             return(CorElementType.Char);

                case "System.Double":   return(CorElementType.R8);

                case "System.Int16":    return(CorElementType.I2);

                case "System.Int32":    return(CorElementType.I4);

                case "System.Int64":    return(CorElementType.I8);

                case "System.IntPtr":   return(CorElementType.I);

                case "System.SByte":    return(CorElementType.I1);

                case "System.Single":   return(CorElementType.R4);

                case "System.TypedReference": return(CorElementType.TypedByRef);

                case "System.UInt16":   return(CorElementType.U2);

                case "System.UInt32":   return(CorElementType.U4);

                case "System.UInt64":   return(CorElementType.U8);

                case "System.UIntPtr":  return(CorElementType.U);

                case "System.Void":             return(CorElementType.Void);
                }
            }
            else
            {
                switch (list[0].Name)
                {
                case "System.Object":
                    if (Base == null)
                    {
                        return(CorElementType.Object);
                    }
                    break;

                case "System.String":
                    var b = Base;
                    if (b != null && b.IsSystemObject)
                    {
                        return(CorElementType.String);
                    }
                    break;
                }
            }
            return(etype);
        }