internal static void FromSystemType(
this SignatureTypeEncoder typeEncoder,
Type type,
AssemblyGenerator generator)
{
if (type.IsPrimitive)
{
typeEncoder.PrimitiveType(GetPrimitiveTypeCode(type));
}
else if (type == typeof(string))
{
typeEncoder.String();
}
else if (type == typeof(object))
{
typeEncoder.Object();
}
else if (type == typeof(void))
{
throw new ArgumentException(
"Void type is not allowed in SignatureTypeEncoder. Please, use FromSystemType from ReturnTypeEncoder.");
//typeEncoder.VoidPointer();
}
else if (type.IsArray)
{
var elementType = type.GetElementType();
var rank = type.GetArrayRank();
typeEncoder.Array(
x => x.FromSystemType(elementType, generator),
x => x.Shape(
type.GetArrayRank(),
ImmutableArray.Create <int>(),
ImmutableArray.Create <int>()));
}
else if (type.IsGenericType)
{
var genericTypeDef = type.GetGenericTypeDefinition();
var typeHandler = generator.GetOrCreateType(genericTypeDef);
var genericArguments = type.GetGenericArguments();
var inst = typeEncoder.GenericInstantiation(typeHandler, genericArguments.Length, false);
foreach (var ga in genericArguments)
{
if (ga.IsGenericParameter)
{
inst.AddArgument().GenericTypeParameter(ga.GenericParameterPosition);
}
else
{
inst.AddArgument().FromSystemType(ga, generator);
}
}
}
else
{
var typeHandler = generator.GetOrCreateType(type);
typeEncoder.Type(typeHandler, type.IsValueType);
}
}
internal static void FromSystemType(
this SignatureTypeEncoder typeEncoder,
Type type,
AssemblyGenerator generator)
{
if (type.IsPrimitive)
{
typeEncoder.PrimitiveType(GetPrimitiveTypeCode(type));
}
else if (type == typeof(String))
{
typeEncoder.String();
}
else if (type == typeof(Object))
{
typeEncoder.Object();
}
else if (type == typeof(void))
{
throw new ArgumentException("Void type is not allowed in SignatureTypeEncoder. Please, use FromSystemType from ReturnTypeEncoder.");
//typeEncoder.VoidPointer();
}
else if (type.IsArray)
{
var elementType = type.GetElementType();
var rank = type.GetArrayRank();
typeEncoder.Array(
x => x.FromSystemType(elementType, generator),
x => x.Shape(
type.GetArrayRank(),
ImmutableArray.Create <int>(),
ImmutableArray.Create <int>()));
}
else if (type.IsGenericType)
{
throw new ArgumentException("Generic types not supported for now!");
}
else
{
var typeHandler = generator.GetOrCreateType(type);
typeEncoder.Type(typeHandler, type.IsValueType);
}
}
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();
}
internal static void FromSystemType(this SignatureTypeEncoder typeEncoder, Type type,
IAssemblyMetadata metadata)
{
if (type.IsByRef)
{
throw new ArgumentException("ByRef types should be handled by parameter encoder or return type encoder");
}
else if (type.IsPointer)
{
typeEncoder.Pointer().FromSystemType(type.GetElementType(), metadata);
}
else if (type.IsPrimitive)
{
typeEncoder.PrimitiveType(GetPrimitiveTypeCode(type));
}
else if (type == typeof(string))
{
typeEncoder.String();
}
else if (type == typeof(object))
{
typeEncoder.Object();
}
else if (type == typeof(void))
{
throw new ArgumentException(
"Void type is not allowed in SignatureTypeEncoder. Please, use FromSystemType from ReturnTypeEncoder.",
nameof(type));
}
else if (type.IsArray)
{
var elementType = type.GetElementType();
if (type.GetArrayRank() == 1)
{
typeEncoder.SZArray().FromSystemType(elementType, metadata);
}
else
{
typeEncoder.Array(
x => x.FromSystemType(elementType, metadata),
x => x.Shape(
type.GetArrayRank(),
ImmutableArray.Create <int>(),
ImmutableArray.CreateRange <int>(Enumerable.Repeat(0, type.GetArrayRank())) // better matches metadata from C#
));
}
}
else if (type.IsGenericType)
{
var genericTypeDef = type.GetGenericTypeDefinition();
var typeHandler = metadata.GetTypeHandle(genericTypeDef);
var genericArguments = type.GetGenericArguments();
var inst = typeEncoder.GenericInstantiation(typeHandler, genericArguments.Length, type.IsValueType);
foreach (var ga in genericArguments)
{
if (ga.IsGenericParameter)
{
inst.AddArgument().GenericTypeParameter(ga.GenericParameterPosition);
}
else
{
inst.AddArgument().FromSystemType(ga, metadata);
}
}
}
else if (type.IsGenericMethodParameter())
{
typeEncoder.GenericMethodTypeParameter(type.GenericParameterPosition);
}
else if (type.IsGenericParameter)
{
typeEncoder.GenericTypeParameter(type.GenericParameterPosition);
}
else
{
var typeHandler = metadata.GetTypeHandle(type);
typeEncoder.Type(typeHandler, type.IsValueType);
}
}
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();
}
