private static Exception ParseBoxedEnumConstantValue(this ConstantBoxedEnumValueHandle handle, ReflectionDomain reflectionDomain, MetadataReader reader, out Object value) { if (!(reflectionDomain is Internal.Reflection.Core.Execution.ExecutionDomain)) { throw new PlatformNotSupportedException(); // Cannot work because boxing enums won't work in non-execution domains. } ConstantBoxedEnumValue record = handle.GetConstantBoxedEnumValue(reader); Exception exception = null; Type enumType = reflectionDomain.TryResolve(reader, record.Type, new TypeContext(null, null), ref exception); if (enumType == null) { value = null; return(exception); } if (!enumType.GetTypeInfo().IsEnum) { throw new BadImageFormatException(); } Type underlyingType = Enum.GetUnderlyingType(enumType); // Now box the value as the specified enum type. unsafe { switch (record.Value.HandleType) { case HandleType.ConstantByteValue: { if (underlyingType != typeof(byte)) { throw new BadImageFormatException(); } byte v = record.Value.ToConstantByteValueHandle(reader).GetConstantByteValue(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantSByteValue: { if (underlyingType != typeof(sbyte)) { throw new BadImageFormatException(); } sbyte v = record.Value.ToConstantSByteValueHandle(reader).GetConstantSByteValue(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantInt16Value: { if (underlyingType != typeof(short)) { throw new BadImageFormatException(); } short v = record.Value.ToConstantInt16ValueHandle(reader).GetConstantInt16Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantUInt16Value: { if (underlyingType != typeof(ushort)) { throw new BadImageFormatException(); } ushort v = record.Value.ToConstantUInt16ValueHandle(reader).GetConstantUInt16Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantInt32Value: { if (underlyingType != typeof(int)) { throw new BadImageFormatException(); } int v = record.Value.ToConstantInt32ValueHandle(reader).GetConstantInt32Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantUInt32Value: { if (underlyingType != typeof(uint)) { throw new BadImageFormatException(); } uint v = record.Value.ToConstantUInt32ValueHandle(reader).GetConstantUInt32Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantInt64Value: { if (underlyingType != typeof(long)) { throw new BadImageFormatException(); } long v = record.Value.ToConstantInt64ValueHandle(reader).GetConstantInt64Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantUInt64Value: { if (underlyingType != typeof(ulong)) { throw new BadImageFormatException(); } ulong v = record.Value.ToConstantUInt64ValueHandle(reader).GetConstantUInt64Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } default: throw new BadImageFormatException(); } } }
private static Exception ParseBoxedEnumConstantValue(this ConstantBoxedEnumValueHandle handle, MetadataReader reader, out Object value) { ConstantBoxedEnumValue record = handle.GetConstantBoxedEnumValue(reader); Exception exception = null; Type enumType = record.Type.TryResolve(reader, new TypeContext(null, null), ref exception); if (enumType == null) { value = null; return(exception); } if (!enumType.IsEnum) { throw new BadImageFormatException(); } Type underlyingType = Enum.GetUnderlyingType(enumType); // Now box the value as the specified enum type. unsafe { switch (record.Value.HandleType) { case HandleType.ConstantByteValue: { if (underlyingType != CommonRuntimeTypes.Byte) { throw new BadImageFormatException(); } byte v = record.Value.ToConstantByteValueHandle(reader).GetConstantByteValue(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantSByteValue: { if (underlyingType != CommonRuntimeTypes.SByte) { throw new BadImageFormatException(); } sbyte v = record.Value.ToConstantSByteValueHandle(reader).GetConstantSByteValue(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantInt16Value: { if (underlyingType != CommonRuntimeTypes.Int16) { throw new BadImageFormatException(); } short v = record.Value.ToConstantInt16ValueHandle(reader).GetConstantInt16Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantUInt16Value: { if (underlyingType != CommonRuntimeTypes.UInt16) { throw new BadImageFormatException(); } ushort v = record.Value.ToConstantUInt16ValueHandle(reader).GetConstantUInt16Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantInt32Value: { if (underlyingType != CommonRuntimeTypes.Int32) { throw new BadImageFormatException(); } int v = record.Value.ToConstantInt32ValueHandle(reader).GetConstantInt32Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantUInt32Value: { if (underlyingType != CommonRuntimeTypes.UInt32) { throw new BadImageFormatException(); } uint v = record.Value.ToConstantUInt32ValueHandle(reader).GetConstantUInt32Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantInt64Value: { if (underlyingType != CommonRuntimeTypes.Int64) { throw new BadImageFormatException(); } long v = record.Value.ToConstantInt64ValueHandle(reader).GetConstantInt64Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } case HandleType.ConstantUInt64Value: { if (underlyingType != CommonRuntimeTypes.UInt64) { throw new BadImageFormatException(); } ulong v = record.Value.ToConstantUInt64ValueHandle(reader).GetConstantUInt64Value(reader).Value; value = RuntimeAugments.Box(enumType.TypeHandle, (IntPtr)(&v)); return(null); } default: throw new BadImageFormatException(); } } }
private MetadataRecord HandleCustomAttributeConstantArray( Cts.ArrayType type, ImmutableArray <Ecma.CustomAttributeTypedArgument <Cts.TypeDesc> > value) { Cts.TypeDesc elementType = type.ElementType; switch (elementType.UnderlyingType.Category) { case Cts.TypeFlags.Boolean: return(new ConstantBooleanArray { Value = GetCustomAttributeConstantArrayElements <bool>(value) }); case Cts.TypeFlags.Byte: return(new ConstantByteArray { Value = GetCustomAttributeConstantArrayElements <byte>(value) }); case Cts.TypeFlags.Char: return(new ConstantCharArray { Value = GetCustomAttributeConstantArrayElements <char>(value) }); case Cts.TypeFlags.Double: return(new ConstantDoubleArray { Value = GetCustomAttributeConstantArrayElements <double>(value) }); case Cts.TypeFlags.Int16: return(new ConstantInt16Array { Value = GetCustomAttributeConstantArrayElements <short>(value) }); case Cts.TypeFlags.Int32: return(new ConstantInt32Array { Value = GetCustomAttributeConstantArrayElements <int>(value) }); case Cts.TypeFlags.Int64: return(new ConstantInt64Array { Value = GetCustomAttributeConstantArrayElements <long>(value) }); case Cts.TypeFlags.SByte: return(new ConstantSByteArray { Value = GetCustomAttributeConstantArrayElements <sbyte>(value) }); case Cts.TypeFlags.Single: return(new ConstantSingleArray { Value = GetCustomAttributeConstantArrayElements <float>(value) }); case Cts.TypeFlags.UInt16: return(new ConstantUInt16Array { Value = GetCustomAttributeConstantArrayElements <ushort>(value) }); case Cts.TypeFlags.UInt32: return(new ConstantUInt32Array { Value = GetCustomAttributeConstantArrayElements <uint>(value) }); case Cts.TypeFlags.UInt64: return(new ConstantUInt64Array { Value = GetCustomAttributeConstantArrayElements <ulong>(value) }); } if (elementType.IsString) { var record = new ConstantStringArray(); record.Value.Capacity = value.Length; foreach (var element in value) { MetadataRecord elementRecord = element.Value == null ? (MetadataRecord) new ConstantReferenceValue() : HandleString((string)element.Value); record.Value.Add(elementRecord); } return(record); } var result = new ConstantHandleArray(); result.Value.Capacity = value.Length; for (int i = 0; i < value.Length; i++) { MetadataRecord elementRecord = HandleCustomAttributeConstantValue(value[i].Type, value[i].Value); if (value[i].Type.IsEnum) { elementRecord = new ConstantBoxedEnumValue { Value = elementRecord, Type = HandleType(value[i].Type) }; } result.Value.Add(elementRecord); } return(result); }