public GenericTypeArgumentsEncoder GenericInstantiation(bool isValueType, EntityHandle typeRefDefSpec, int genericArgumentCount)
{
Builder.WriteByte((byte)SignatureTypeCode.GenericTypeInstance);
ClassOrValue(isValueType);
Builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(typeRefDefSpec));
Builder.WriteCompressedInteger(genericArgumentCount);
return(new GenericTypeArgumentsEncoder(Builder));
}
public CustomModifiersEncoder AddModifier(bool isOptional, EntityHandle typeDefRefSpec)
{
if (isOptional)
{
Builder.WriteByte((byte)SignatureTypeCode.OptionalModifier);
}
else
{
Builder.WriteByte((byte)SignatureTypeCode.RequiredModifier);
}
Builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(typeDefRefSpec));
return(this);
}
private void SerializeImport(BlobBuilder writer, UsedNamespaceOrType import)
{
if (import.TargetXmlNamespaceOpt != null)
{
Debug.Assert(import.TargetNamespaceOpt == null);
Debug.Assert(import.TargetAssemblyOpt == null);
Debug.Assert(import.TargetTypeOpt == null);
// <import> ::= ImportXmlNamespace <alias> <target-namespace>
writer.WriteByte((byte)ImportDefinitionKind.ImportXmlNamespace);
writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.TargetXmlNamespaceOpt)));
}
else if (import.TargetTypeOpt != null)
{
Debug.Assert(import.TargetNamespaceOpt == null);
Debug.Assert(import.TargetAssemblyOpt == null);
if (import.AliasOpt != null)
{
// <import> ::= AliasType <alias> <target-type>
writer.WriteByte((byte)ImportDefinitionKind.AliasType);
writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
}
else
{
// <import> ::= ImportType <target-type>
writer.WriteByte((byte)ImportDefinitionKind.ImportType);
}
writer.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(import.TargetTypeOpt))); // TODO: index in release build
}
else if (import.TargetNamespaceOpt != null)
{
if (import.TargetAssemblyOpt != null)
{
if (import.AliasOpt != null)
{
// <import> ::= AliasAssemblyNamespace <alias> <target-assembly> <target-namespace>
writer.WriteByte((byte)ImportDefinitionKind.AliasAssemblyNamespace);
writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
}
else
{
// <import> ::= ImportAssemblyNamespace <target-assembly> <target-namespace>
writer.WriteByte((byte)ImportDefinitionKind.ImportAssemblyNamespace);
}
writer.WriteCompressedInteger(MetadataTokens.GetRowNumber(GetAssemblyReferenceHandle(import.TargetAssemblyOpt)));
}
else
{
if (import.AliasOpt != null)
{
// <import> ::= AliasNamespace <alias> <target-namespace>
writer.WriteByte((byte)ImportDefinitionKind.AliasNamespace);
writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
}
else
{
// <import> ::= ImportNamespace <target-namespace>
writer.WriteByte((byte)ImportDefinitionKind.ImportNamespace);
}
}
// TODO: cache?
string namespaceName = TypeNameSerializer.BuildQualifiedNamespaceName(import.TargetNamespaceOpt);
writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(namespaceName)));
}
else
{
// <import> ::= ImportReferenceAlias <alias>
Debug.Assert(import.AliasOpt != null);
Debug.Assert(import.TargetAssemblyOpt == null);
writer.WriteByte((byte)ImportDefinitionKind.ImportAssemblyReferenceAlias);
writer.WriteCompressedInteger(_debugMetadataOpt.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUtf8(import.AliasOpt)));
}
}
public void TypeDefOrRefOrSpec(bool isValueType, EntityHandle typeRefDefSpec)
{
ClassOrValue(isValueType);
Builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(typeRefDefSpec));
}
private BlobHandle SerializeLocalConstantSignature(ILocalDefinition localConstant)
{
var builder = new BlobBuilder();
// TODO: BlobEncoder.LocalConstantSignature
// CustomMod*
var encoder = new CustomModifiersEncoder(builder);
SerializeCustomModifiers(encoder, localConstant.CustomModifiers);
var type = localConstant.Type;
var typeCode = type.TypeCode(Context);
object value = localConstant.CompileTimeValue.Value;
// PrimitiveConstant or EnumConstant
if (value is decimal)
{
builder.WriteByte(0x11);
builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(type)));
builder.WriteDecimal((decimal)value);
}
else if (value is DateTime)
{
builder.WriteByte(0x11);
builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(type)));
builder.WriteDateTime((DateTime)value);
}
else if (typeCode == PrimitiveTypeCode.String)
{
builder.WriteByte((byte)ConstantTypeCode.String);
if (value == null)
{
builder.WriteByte(0xff);
}
else
{
builder.WriteUTF16((string)value);
}
}
else if (value != null)
{
// TypeCode
builder.WriteByte((byte)MetadataWriterUtilities.GetConstantTypeCode(value));
// Value
builder.WriteConstant(value);
// EnumType
if (type.IsEnum)
{
builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(type)));
}
}
else if (this.module.IsPlatformType(type, PlatformType.SystemObject))
{
builder.WriteByte(0x1c);
}
else
{
builder.WriteByte((byte)(type.IsValueType ? 0x11 : 0x12));
builder.WriteCompressedInteger(CodedIndex.ToTypeDefOrRefOrSpec(GetTypeHandle(type)));
}
return(_debugMetadataOpt.GetOrAddBlob(builder));
}
