public static void EncodeSpecialType(this SignatureTypeEncoder typeEncoder, SpecialType specialType) { switch (specialType) { case SpecialType.System_Boolean: typeEncoder.Boolean(); break; case SpecialType.System_SByte: typeEncoder.SByte(); break; case SpecialType.System_Byte: typeEncoder.Byte(); break; case SpecialType.System_Int16: typeEncoder.Int16(); break; case SpecialType.System_Int32: typeEncoder.Int32(); break; case SpecialType.System_Int64: typeEncoder.Int64(); break; case SpecialType.System_UInt16: typeEncoder.UInt16(); break; case SpecialType.System_UInt32: typeEncoder.UInt32(); break; case SpecialType.System_UInt64: typeEncoder.UInt64(); break; case SpecialType.System_Single: typeEncoder.Single(); break; case SpecialType.System_Double: typeEncoder.Double(); break; case SpecialType.System_Char: typeEncoder.Char(); break; case SpecialType.System_String: typeEncoder.String(); break; case SpecialType.System_Object: typeEncoder.Object(); break; case SpecialType.System_IntPtr: typeEncoder.IntPtr(); break; case SpecialType.System_UIntPtr: typeEncoder.UIntPtr(); break; default: throw new NotImplementedException(); } // TODO: handle C# interface mappings for special types }
public void SignatureTypeEncoder_Primitives() { var b = new BlobBuilder(); var e = new SignatureTypeEncoder(b); Assert.Same(b, e.Builder); e.Boolean(); AssertEx.Equal(new byte[] { 0x02 }, b.ToArray()); b.Clear(); e.Char(); AssertEx.Equal(new byte[] { 0x03 }, b.ToArray()); b.Clear(); e.SByte(); AssertEx.Equal(new byte[] { 0x04 }, b.ToArray()); b.Clear(); e.Byte(); AssertEx.Equal(new byte[] { 0x05 }, b.ToArray()); b.Clear(); e.Int16(); AssertEx.Equal(new byte[] { 0x06 }, b.ToArray()); b.Clear(); e.UInt16(); AssertEx.Equal(new byte[] { 0x07 }, b.ToArray()); b.Clear(); e.Int32(); AssertEx.Equal(new byte[] { 0x08 }, b.ToArray()); b.Clear(); e.UInt32(); AssertEx.Equal(new byte[] { 0x09 }, b.ToArray()); b.Clear(); e.Int64(); AssertEx.Equal(new byte[] { 0x0A }, b.ToArray()); b.Clear(); e.UInt64(); AssertEx.Equal(new byte[] { 0x0B }, b.ToArray()); b.Clear(); e.Single(); AssertEx.Equal(new byte[] { 0x0C }, b.ToArray()); b.Clear(); e.Double(); AssertEx.Equal(new byte[] { 0x0D }, b.ToArray()); b.Clear(); e.String(); AssertEx.Equal(new byte[] { 0x0E }, b.ToArray()); b.Clear(); e.IntPtr(); AssertEx.Equal(new byte[] { 0x18 }, b.ToArray()); b.Clear(); e.UIntPtr(); AssertEx.Equal(new byte[] { 0x19 }, b.ToArray()); b.Clear(); e.Object(); AssertEx.Equal(new byte[] { 0x1C }, b.ToArray()); b.Clear(); }
private void EncodeTypeSignature(SignatureTypeEncoder encoder, TypeDesc type) { if (type is RuntimeDeterminedType) { EncodeTypeSignature(encoder, ((RuntimeDeterminedType)type).RuntimeDeterminedDetailsType); return; } switch (type.Category) { case TypeFlags.Boolean: encoder.Boolean(); break; case TypeFlags.Byte: encoder.Byte(); break; case TypeFlags.SByte: encoder.SByte(); break; case TypeFlags.Char: encoder.Char(); break; case TypeFlags.Int16: encoder.Int16(); break; case TypeFlags.UInt16: encoder.UInt16(); break; case TypeFlags.Int32: encoder.Int32(); break; case TypeFlags.UInt32: encoder.UInt32(); break; case TypeFlags.Int64: encoder.Int64(); break; case TypeFlags.UInt64: encoder.UInt64(); break; case TypeFlags.Single: encoder.Single(); break; case TypeFlags.Double: encoder.Double(); break; case TypeFlags.IntPtr: encoder.IntPtr(); break; case TypeFlags.UIntPtr: encoder.UIntPtr(); break; case TypeFlags.Void: encoder.Builder.WriteByte((byte)PrimitiveTypeCode.Void); break; case TypeFlags.SignatureTypeVariable: encoder.GenericTypeParameter(((SignatureVariable)type).Index); break; case TypeFlags.SignatureMethodVariable: encoder.GenericMethodTypeParameter(((SignatureMethodVariable)type).Index); break; case TypeFlags.GenericParameter: { var genericTypeDesc = (GenericParameterDesc)type; if (genericTypeDesc.Kind == GenericParameterKind.Type) { encoder.GenericTypeParameter(genericTypeDesc.Index); } else { encoder.GenericMethodTypeParameter(genericTypeDesc.Index); } } break; case TypeFlags.FunctionPointer: { FunctionPointerType fptrType = (FunctionPointerType)type; encoder.FunctionPointer( SignatureCallingConvention.Default, fptrType.Signature.IsStatic ? default(FunctionPointerAttributes) : FunctionPointerAttributes.HasThis, fptrType.Signature.GenericParameterCount); // Return Type Sig EncodeTypeSignature(encoder, fptrType.Signature.ReturnType); // Parameter Types Sig for (int i = 0; i < fptrType.Signature.Length; i++) { EncodeTypeSignature(encoder, fptrType.Signature[i]); } } break; case TypeFlags.Array: { // Skip bounds and lobounds (TODO) ImmutableArray <int> bounds = ImmutableArray.Create <int>(); ImmutableArray <int> lowerBounds = ImmutableArray.Create <int>(); encoder.Array( elementType => EncodeTypeSignature(elementType, ((ArrayType)type).ElementType), arrayShape => arrayShape.Shape(((ArrayType)type).Rank, bounds, lowerBounds)); } break; case TypeFlags.SzArray: encoder.SZArray(); EncodeTypeSignature(encoder, ((ParameterizedType)type).ParameterType); break; case TypeFlags.ByRef: encoder.Builder.WriteByte((byte)SignatureTypeCode.ByReference); EncodeTypeSignature(encoder, ((ParameterizedType)type).ParameterType); break; case TypeFlags.Pointer: encoder.Builder.WriteByte((byte)SignatureTypeCode.Pointer); EncodeTypeSignature(encoder, ((ParameterizedType)type).ParameterType); break; case TypeFlags.Enum: case TypeFlags.Class: case TypeFlags.ValueType: case TypeFlags.Interface: case TypeFlags.Nullable: { if (type == _typeSystemContext.GetWellKnownType(WellKnownType.TypedReference)) { encoder.Builder.WriteByte((byte)PrimitiveTypeCode.TypedReference); } else if (type == _typeSystemContext.GetWellKnownType(WellKnownType.Object)) { encoder.PrimitiveType(PrimitiveTypeCode.Object); } else if (type == _typeSystemContext.GetWellKnownType(WellKnownType.String)) { encoder.PrimitiveType(PrimitiveTypeCode.String); } else if (type.HasInstantiation && !type.IsGenericDefinition) { encoder.GenericInstantiation(MakeTypeRefOrSpecHandle(type.GetTypeDefinition()), type.Instantiation.Length, type.IsValueType); for (int i = 0; i < type.Instantiation.Length; i++) { EncodeTypeSignature(encoder, type.Instantiation[i]); } } else { encoder.Type(MakeTypeRefHandle(type), type.IsValueType); } } break; default: throw new InvalidOperationException("Attempting to encode an invalid type signature."); } }