Mono.Debugger.Backend.Mono.MonoLanguageBackend.ReadType C# (CSharp) Метод

        TargetType ReadType(TargetMemoryAccess memory, MonoTypeEnum type, TargetAddress data)
        {
            switch (type) {
            case MonoTypeEnum.MONO_TYPE_BOOLEAN:
                return BuiltinTypes.BooleanType;
            case MonoTypeEnum.MONO_TYPE_CHAR:
                return BuiltinTypes.CharType;
            case MonoTypeEnum.MONO_TYPE_I1:
                return BuiltinTypes.SByteType;
            case MonoTypeEnum.MONO_TYPE_U1:
                return BuiltinTypes.ByteType;
            case MonoTypeEnum.MONO_TYPE_I2:
                return BuiltinTypes.Int16Type;
            case MonoTypeEnum.MONO_TYPE_U2:
                return BuiltinTypes.UInt16Type;
            case MonoTypeEnum.MONO_TYPE_I4:
                return BuiltinTypes.Int32Type;
            case MonoTypeEnum.MONO_TYPE_U4:
                return BuiltinTypes.UInt32Type;
            case MonoTypeEnum.MONO_TYPE_I8:
                return BuiltinTypes.Int64Type;
            case MonoTypeEnum.MONO_TYPE_U8:
                return BuiltinTypes.UInt64Type;
            case MonoTypeEnum.MONO_TYPE_R4:
                return BuiltinTypes.SingleType;
            case MonoTypeEnum.MONO_TYPE_R8:
                return BuiltinTypes.DoubleType;
            case MonoTypeEnum.MONO_TYPE_STRING:
                return BuiltinTypes.StringType;
            case MonoTypeEnum.MONO_TYPE_OBJECT:
                return BuiltinTypes.ObjectType;
            case MonoTypeEnum.MONO_TYPE_I:
                return BuiltinTypes.IntType;
            case MonoTypeEnum.MONO_TYPE_U:
                return BuiltinTypes.UIntType;
            case MonoTypeEnum.MONO_TYPE_VOID:
                return BuiltinTypes.VoidType;

            case MonoTypeEnum.MONO_TYPE_PTR: {
                TargetType target_type = ReadType (memory, data);
                return new MonoPointerType (target_type);
            }

            case MonoTypeEnum.MONO_TYPE_VALUETYPE:
            case MonoTypeEnum.MONO_TYPE_CLASS:
                return LookupMonoClass (memory, data);

            case MonoTypeEnum.MONO_TYPE_SZARRAY: {
                TargetType etype = ReadMonoClass (memory, data);
                return new MonoArrayType (etype, 1);
            }

            case MonoTypeEnum.MONO_TYPE_ARRAY: {
                TargetAddress klass = MetadataHelper.MonoArrayTypeGetClass (memory, data);
                int rank = MetadataHelper.MonoArrayTypeGetRank (memory, data);

                MetadataHelper.MonoArrayTypeGetBounds (memory, data);

                TargetType etype = ReadMonoClass (memory, klass);
                return new MonoArrayType (etype, rank);
            }

            case MonoTypeEnum.MONO_TYPE_GENERICINST:
                return ReadGenericClass (memory, data, true);

            case MonoTypeEnum.MONO_TYPE_VAR:
            case MonoTypeEnum.MONO_TYPE_MVAR: {
                MetadataHelper.GenericParamInfo info = MetadataHelper.GetGenericParameter (
                    memory, data);

                return new MonoGenericParameterType (this, info.Name);
            }

            default:
                Report.Error ("UNKNOWN TYPE: {0}", type);
                return null;
            }
        }

        public MonoMethodSignature GetMethodSignature(MonoLanguageBackend mono,
							       TargetMemoryAccess memory,
							       TargetAddress signature)
        {
            int count = memory.ReadInteger (signature + 4) & 0x0000ffff;

            int offset = memory.TargetAddressSize == 8 ? 16 : 12;
            TargetAddress ret = memory.ReadAddress (signature + offset);

            TargetType ret_type = mono.ReadType (memory, ret);
            if (count == 0)
                return new MonoMethodSignature (ret_type, new TargetType [0]);

            offset += memory.TargetAddressSize;
            TargetReader reader = new TargetReader (
                memory.ReadMemory (signature + offset, count * memory.TargetAddressSize));

            TargetType[] param_types = new TargetType [count];
            for (int i = 0; i < count; i++)
                param_types [i] = mono.ReadType (memory, reader.ReadAddress ());

            return new MonoMethodSignature (ret_type, param_types);
        }