private void SerializeImport(BlobBuilder writer, AssemblyReferenceAlias alias)
{
// <import> ::= AliasAssemblyReference <alias> <target-assembly>
writer.WriteByte((byte)ImportDefinitionKind.AliasAssemblyReference);
writer.WriteCompressedInteger((uint)_debugHeapsOpt.ResolveBlobIndex(_debugHeapsOpt.GetBlobIndexUtf8(alias.Name)));
writer.WriteCompressedInteger((uint)GetOrAddAssemblyRefIndex(alias.Assembly));
}
private void SerializeImport(BlobBuilder writer, AssemblyReferenceAlias alias)
{
// <import> ::= AliasAssemblyReference <alias> <target-assembly>
writer.WriteByte((byte)ImportDefinitionKind.AliasAssemblyReference);
writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(alias.Name)));
writer.WriteCompressedInteger(MetadataTokens.GetRowNumber(GetOrAddAssemblyReferenceHandle(alias.Assembly)));
}
private BlobHandle SerializeSpans(
ImmutableArray <SourceSpan> spans,
Dictionary <DebugSourceDocument, int> documentIndex
)
{
if (spans.Length == 0)
{
return(default(BlobHandle));
}
// 4 bytes per span plus a header, the builder expands by the same amount.
var writer = new BlobBuilder(4 + spans.Length * 4);
int previousStartLine = -1;
int previousStartColumn = -1;
DebugSourceDocument previousDocument = spans[0].Document;
// header:
writer.WriteCompressedInteger(GetOrAddDocument(previousDocument, documentIndex));
for (int i = 0; i < spans.Length; i++)
{
var currentDocument = spans[i].Document;
if (previousDocument != currentDocument)
{
writer.WriteInt16(0);
writer.WriteCompressedInteger(GetOrAddDocument(currentDocument, documentIndex));
previousDocument = currentDocument;
}
// Delta Lines & Columns:
SerializeDeltaLinesAndColumns(writer, spans[i]);
// delta Start Lines & Columns:
if (previousStartLine < 0)
{
Debug.Assert(previousStartColumn < 0);
writer.WriteCompressedInteger(spans[i].StartLine);
writer.WriteCompressedInteger(spans[i].StartColumn);
}
else
{
writer.WriteCompressedSignedInteger(spans[i].StartLine - previousStartLine);
writer.WriteCompressedSignedInteger(spans[i].StartColumn - previousStartColumn);
}
previousStartLine = spans[i].StartLine;
previousStartColumn = spans[i].StartColumn;
}
return(GetOrAddBlob(writer));
}
private BlobHandle SerializeDocumentName(string name)
{
Debug.Assert(name != null);
int c1 = Count(name, s_separator1[0]);
int c2 = Count(name, s_separator2[0]);
char[] separator = (c1 >= c2) ? s_separator1 : s_separator2;
// Estimate 2 bytes per part, if the blob heap gets big we expand the builder once.
var writer = new BlobBuilder(1 + Math.Max(c1, c2) * 2);
writer.WriteByte((byte)separator[0]);
// TODO: avoid allocations
foreach (var part in name.Split(separator))
{
BlobHandle partIndex = GetOrAddBlob(
ImmutableArray.Create(MetadataWriter.s_utf8Encoding.GetBytes(part))
);
writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(partIndex));
}
return(GetOrAddBlob(writer));
}
private void WriteAlignedBlobHeap(BlobBuilder writer)
{
int heapStart = writer.Position;
// ensure enough space in the buffer:
writer.SetPosition(writer.Position + _blobHeapSize);
// Perf consideration: With large heap the following loop may cause a lot of cache misses
// since the order of entries in _blobs dictionary depends on the hash of the array values,
// which is not correlated to the heap index. If we observe such issue we should order
// the entries by heap position before running this loop.
foreach (var entry in _blobs)
{
int heapOffset = entry.Value.HeapPosition;
var blob = entry.Key;
writer.SetPosition(heapStart + heapOffset);
writer.WriteCompressedInteger((uint)blob.Length);
writer.WriteBytes(blob);
}
Debug.Assert(writer.Length - heapStart == _blobHeapSize);
// add padding:
writer.SetPosition(writer.Length);
writer.WriteBytes(0, BitArithmeticUtilities.Align(_blobHeapSize, 4) - _blobHeapSize);
}
private void SerializeAsyncMethodSteppingInfo(
AsyncMoveNextBodyDebugInfo asyncInfo,
MethodDefinitionHandle moveNextMethod
)
{
Debug.Assert(asyncInfo.ResumeOffsets.Length == asyncInfo.YieldOffsets.Length);
Debug.Assert(asyncInfo.CatchHandlerOffset >= -1);
var writer = new BlobBuilder();
writer.WriteUInt32((uint)((long)asyncInfo.CatchHandlerOffset + 1));
for (int i = 0; i < asyncInfo.ResumeOffsets.Length; i++)
{
writer.WriteUInt32((uint)asyncInfo.YieldOffsets[i]);
writer.WriteUInt32((uint)asyncInfo.ResumeOffsets[i]);
writer.WriteCompressedInteger(MetadataTokens.GetRowNumber(moveNextMethod));
}
_debugMetadataOpt.AddCustomDebugInformation(
parent: moveNextMethod,
kind: _debugMetadataOpt.GetOrAddGuid(
PortableCustomDebugInfoKinds.AsyncMethodSteppingInformationBlob
),
value: _debugMetadataOpt.GetOrAddBlob(writer)
);
}
private void SerializeDeltaLinesAndColumns(BlobBuilder writer, SourceSpan span)
{
int deltaLines = span.EndLine - span.StartLine;
int deltaColumns = span.EndColumn - span.StartColumn;
// spans can't have zero width
Debug.Assert(deltaLines != 0 || deltaColumns != 0);
writer.WriteCompressedInteger(deltaLines);
if (deltaLines == 0)
{
writer.WriteCompressedInteger(deltaColumns);
}
else
{
writer.WriteCompressedSignedInteger(deltaColumns);
}
}
private void SerializeDeltaLinesAndColumns(BlobBuilder writer, SequencePoint sequencePoint)
{
int deltaLines = sequencePoint.EndLine - sequencePoint.StartLine;
int deltaColumns = sequencePoint.EndColumn - sequencePoint.StartColumn;
// only hidden sequence points have zero width
Debug.Assert(deltaLines != 0 || deltaColumns != 0 || sequencePoint.IsHidden);
writer.WriteCompressedInteger(deltaLines);
if (deltaLines == 0)
{
writer.WriteCompressedInteger(deltaColumns);
}
else
{
writer.WriteCompressedSignedInteger(deltaColumns);
}
}
private BlobIdx SerializeDocumentName(string name)
{
Debug.Assert(name != null);
var writer = new BlobBuilder();
int c1 = Count(name, Separator1[0]);
int c2 = Count(name, Separator2[0]);
char[] separator = (c1 >= c2) ? Separator1 : Separator2;
writer.WriteByte((byte)separator[0]);
// TODO: avoid allocations
foreach (var part in name.Split(separator))
{
BlobIdx partIndex = _debugHeapsOpt.GetBlobIndex(ImmutableArray.Create(s_utf8Encoding.GetBytes(part)));
writer.WriteCompressedInteger((uint)_debugHeapsOpt.ResolveBlobIndex(partIndex));
}
return(_debugHeapsOpt.GetBlobIndex(writer));
}
private BlobHandle SerializeDocumentName(string name)
{
Debug.Assert(name != null);
var writer = new BlobBuilder();
int c1 = Count(name, s_separator1[0]);
int c2 = Count(name, s_separator2[0]);
char[] separator = (c1 >= c2) ? s_separator1 : s_separator2;
writer.WriteByte((byte)separator[0]);
// TODO: avoid allocations
foreach (var part in name.Split(separator))
{
BlobHandle partIndex = _debugMetadataOpt.GetOrAddBlob(ImmutableArray.Create(s_utf8Encoding.GetBytes(part)));
writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(partIndex));
}
return(_debugMetadataOpt.GetOrAddBlob(writer));
}
private void SerializeAsyncMethodSteppingInfo(AsyncMethodBodyDebugInfo asyncInfo, int moveNextMethodRid)
{
Debug.Assert(asyncInfo.ResumeOffsets.Length == asyncInfo.YieldOffsets.Length);
Debug.Assert(asyncInfo.CatchHandlerOffset >= -1);
var writer = new BlobBuilder();
writer.WriteUInt32((uint)((long)asyncInfo.CatchHandlerOffset + 1));
for (int i = 0; i < asyncInfo.ResumeOffsets.Length; i++)
{
writer.WriteUInt32((uint)asyncInfo.YieldOffsets[i]);
writer.WriteUInt32((uint)asyncInfo.ResumeOffsets[i]);
writer.WriteCompressedInteger((uint)moveNextMethodRid);
}
_customDebugInformationTable.Add(new CustomDebugInformationRow
{
Parent = HasCustomDebugInformation(HasCustomDebugInformationTag.MethodDef, moveNextMethodRid),
Kind = (uint)_debugHeapsOpt.GetGuidIndex(PortableCustomDebugInfoKinds.AsyncMethodSteppingInformationBlob),
Value = _debugHeapsOpt.GetBlobIndex(writer),
});
}
private BlobIdx SerializeLocalConstantSignature(ILocalDefinition localConstant)
{
var writer = new BlobBuilder();
// CustomMod*
SerializeCustomModifiers(localConstant.CustomModifiers, writer);
var type = localConstant.Type;
var typeCode = type.TypeCode(Context);
object value = localConstant.CompileTimeValue.Value;
// PrimitiveConstant or EnumConstant
if (value is decimal)
{
writer.WriteByte(0x11);
writer.WriteCompressedInteger(GetTypeDefOrRefCodedIndex(type, treatRefAsPotentialTypeSpec: true));
writer.WriteDecimal((decimal)value);
}
else if (value is DateTime)
{
writer.WriteByte(0x11);
writer.WriteCompressedInteger(GetTypeDefOrRefCodedIndex(type, treatRefAsPotentialTypeSpec: true));
writer.WriteDateTime((DateTime)value);
}
else if (typeCode == PrimitiveTypeCode.String)
{
writer.WriteByte((byte)ConstantTypeCode.String);
if (value == null)
{
writer.WriteByte(0xff);
}
else
{
writer.WriteUTF16((string)value);
}
}
else if (value != null)
{
// TypeCode
writer.WriteByte((byte)GetConstantTypeCode(value));
// Value
writer.WriteConstant(value);
// EnumType
if (type.IsEnum)
{
writer.WriteCompressedInteger(GetTypeDefOrRefCodedIndex(type, treatRefAsPotentialTypeSpec: true));
}
}
else if (this.module.IsPlatformType(type, PlatformType.SystemObject))
{
writer.WriteByte(0x1c);
}
else
{
writer.WriteByte((byte)(type.IsValueType ? 0x11 : 0x12));
writer.WriteCompressedInteger(GetTypeDefOrRefCodedIndex(type, treatRefAsPotentialTypeSpec: true));
}
return(_debugHeapsOpt.GetBlobIndex(writer));
}
private BlobHandle SerializeSequencePoints(
StandaloneSignatureHandle localSignatureHandleOpt,
ImmutableArray <SequencePoint> sequencePoints,
Dictionary <DebugSourceDocument, DocumentHandle> documentIndex,
out DocumentHandle singleDocumentHandle)
{
if (sequencePoints.Length == 0)
{
singleDocumentHandle = default(DocumentHandle);
return(default(BlobHandle));
}
var writer = new BlobBuilder();
int previousNonHiddenStartLine = -1;
int previousNonHiddenStartColumn = -1;
// header:
writer.WriteCompressedInteger(MetadataTokens.GetRowNumber(localSignatureHandleOpt));
var previousDocument = TryGetSingleDocument(sequencePoints);
singleDocumentHandle = (previousDocument != null) ? GetOrAddDocument(previousDocument, documentIndex) : default(DocumentHandle);
for (int i = 0; i < sequencePoints.Length; i++)
{
var currentDocument = sequencePoints[i].Document;
if (previousDocument != currentDocument)
{
var documentHandle = GetOrAddDocument(currentDocument, documentIndex);
// optional document in header or document record:
if (previousDocument != null)
{
writer.WriteCompressedInteger(0);
}
writer.WriteCompressedInteger(MetadataTokens.GetRowNumber(documentHandle));
previousDocument = currentDocument;
}
// delta IL offset:
if (i > 0)
{
writer.WriteCompressedInteger(sequencePoints[i].Offset - sequencePoints[i - 1].Offset);
}
else
{
writer.WriteCompressedInteger(sequencePoints[i].Offset);
}
if (sequencePoints[i].IsHidden)
{
writer.WriteInt16(0);
continue;
}
// Delta Lines & Columns:
SerializeDeltaLinesAndColumns(writer, sequencePoints[i]);
// delta Start Lines & Columns:
if (previousNonHiddenStartLine < 0)
{
Debug.Assert(previousNonHiddenStartColumn < 0);
writer.WriteCompressedInteger(sequencePoints[i].StartLine);
writer.WriteCompressedInteger(sequencePoints[i].StartColumn);
}
else
{
writer.WriteCompressedSignedInteger(sequencePoints[i].StartLine - previousNonHiddenStartLine);
writer.WriteCompressedSignedInteger(sequencePoints[i].StartColumn - previousNonHiddenStartColumn);
}
previousNonHiddenStartLine = sequencePoints[i].StartLine;
previousNonHiddenStartColumn = sequencePoints[i].StartColumn;
}
return(_debugMetadataOpt.GetOrAddBlob(writer));
}
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(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.AliasOpt)));
writer.WriteCompressedInteger(MetadataTokens.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(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.AliasOpt)));
}
else
{
// <import> ::= ImportType <target-type>
writer.WriteByte((byte)ImportDefinitionKind.ImportType);
}
writer.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(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(MetadataTokens.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(MetadataTokens.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(MetadataTokens.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(MetadataTokens.GetHeapOffset(_debugMetadataOpt.GetOrAddBlobUTF8(import.AliasOpt)));
}
}
private static byte[] CompressUnsignedInteger(int value)
{
var writer = new BlobBuilder();
writer.WriteCompressedInteger((uint)value);
return writer.ToArray();
}
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((byte)SignatureTypeKind.ValueType);
builder.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(GetTypeHandle(type)));
builder.WriteDecimal((decimal)value);
}
else if (value is DateTime)
{
builder.WriteByte((byte)SignatureTypeKind.ValueType);
builder.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(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)GetConstantTypeCode(value));
// Value
builder.WriteConstant(value);
// EnumType
if (type.IsEnum)
{
builder.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(GetTypeHandle(type)));
}
}
else if (this.module.IsPlatformType(type, PlatformType.SystemObject))
{
builder.WriteByte((byte)SignatureTypeCode.Object);
}
else
{
builder.WriteByte((byte)(type.IsValueType ? SignatureTypeKind.ValueType : SignatureTypeKind.Class));
builder.WriteCompressedInteger(CodedIndex.TypeDefOrRefOrSpec(GetTypeHandle(type)));
}
return(_debugMetadataOpt.GetOrAddBlob(builder));
}
private BlobIdx SerializeSequencePoints(int localSignatureRowId, ImmutableArray <SequencePoint> sequencePoints, Dictionary <DebugSourceDocument, int> documentIndex)
{
if (sequencePoints.Length == 0)
{
return(default(BlobIdx));
}
var writer = new BlobBuilder();
int previousNonHiddenStartLine = -1;
int previousNonHiddenStartColumn = -1;
uint currentDocumentRowId = GetOrAddDocument(sequencePoints[0].Document, documentIndex);
// header:
writer.WriteCompressedInteger((uint)localSignatureRowId);
writer.WriteCompressedInteger(currentDocumentRowId);
for (int i = 0; i < sequencePoints.Length; i++)
{
uint documentRowId = GetOrAddDocument(sequencePoints[i].Document, documentIndex);
if (documentRowId != currentDocumentRowId)
{
// document record:
writer.WriteCompressedInteger(0);
writer.WriteCompressedInteger(documentRowId);
currentDocumentRowId = documentRowId;
}
// delta IL offset:
if (i > 0)
{
writer.WriteCompressedInteger((uint)(sequencePoints[i].Offset - sequencePoints[i - 1].Offset));
}
else
{
writer.WriteCompressedInteger((uint)sequencePoints[i].Offset);
}
if (sequencePoints[i].IsHidden)
{
writer.WriteInt16(0);
continue;
}
// Delta Lines & Columns:
SerializeDeltaLinesAndColumns(writer, sequencePoints[i]);
// delta Start Lines & Columns:
if (previousNonHiddenStartLine < 0)
{
Debug.Assert(previousNonHiddenStartColumn < 0);
writer.WriteCompressedInteger((uint)sequencePoints[i].StartLine);
writer.WriteCompressedInteger((uint)sequencePoints[i].StartColumn);
}
else
{
writer.WriteCompressedSignedInteger(sequencePoints[i].StartLine - previousNonHiddenStartLine);
writer.WriteCompressedSignedInteger(sequencePoints[i].StartColumn - previousNonHiddenStartColumn);
}
previousNonHiddenStartLine = sequencePoints[i].StartLine;
previousNonHiddenStartColumn = sequencePoints[i].StartColumn;
}
return(_debugHeapsOpt.GetBlobIndex(writer));
}
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((uint)_debugHeapsOpt.ResolveBlobIndex(_debugHeapsOpt.GetBlobIndexUtf8(import.AliasOpt)));
writer.WriteCompressedInteger((uint)_debugHeapsOpt.ResolveBlobIndex(_debugHeapsOpt.GetBlobIndexUtf8(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((uint)_debugHeapsOpt.ResolveBlobIndex(_debugHeapsOpt.GetBlobIndexUtf8(import.AliasOpt)));
}
else
{
// <import> ::= ImportType <target-type>
writer.WriteByte((byte)ImportDefinitionKind.ImportType);
}
writer.WriteCompressedInteger(GetTypeDefOrRefCodedIndex(import.TargetTypeOpt, treatRefAsPotentialTypeSpec: true)); // 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((uint)_debugHeapsOpt.ResolveBlobIndex(_debugHeapsOpt.GetBlobIndexUtf8(import.AliasOpt)));
}
else
{
// <import> ::= ImportAssemblyNamespace <target-assembly> <target-namespace>
writer.WriteByte((byte)ImportDefinitionKind.ImportAssemblyNamespace);
}
writer.WriteCompressedInteger((uint)GetAssemblyRefIndex(import.TargetAssemblyOpt));
}
else
{
if (import.AliasOpt != null)
{
// <import> ::= AliasNamespace <alias> <target-namespace>
writer.WriteByte((byte)ImportDefinitionKind.AliasNamespace);
writer.WriteCompressedInteger((uint)_debugHeapsOpt.ResolveBlobIndex(_debugHeapsOpt.GetBlobIndexUtf8(import.AliasOpt)));
}
else
{
// <import> ::= ImportNamespace <target-namespace>
writer.WriteByte((byte)ImportDefinitionKind.ImportNamespace);
}
}
// TODO: cache?
string namespaceName = TypeNameSerializer.BuildQualifiedNamespaceName(import.TargetNamespaceOpt);
writer.WriteCompressedInteger((uint)_debugHeapsOpt.ResolveBlobIndex(_debugHeapsOpt.GetBlobIndexUtf8(namespaceName)));
}
else
{
// <import> ::= ImportReferenceAlias <alias>
Debug.Assert(import.AliasOpt != null);
Debug.Assert(import.TargetAssemblyOpt == null);
writer.WriteByte((byte)ImportDefinitionKind.ImportAssemblyReferenceAlias);
writer.WriteCompressedInteger((uint)_debugHeapsOpt.ResolveBlobIndex(_debugHeapsOpt.GetBlobIndexUtf8(import.AliasOpt)));
}
}
public int GetUserStringToken(string str)
{
int index;
if (!_userStrings.TryGetValue(str, out index))
{
Debug.Assert(!_streamsAreComplete);
index = _userStringWriter.Position + _userStringHeapStartOffset;
_userStrings.Add(str, index);
_userStringWriter.WriteCompressedInteger((uint)str.Length * 2 + 1);
_userStringWriter.WriteUTF16(str);
// Write out a trailing byte indicating if the string is really quite simple
byte stringKind = 0;
foreach (char ch in str)
{
if (ch >= 0x7F)
{
stringKind = 1;
}
else
{
switch ((int)ch)
{
case 0x1:
case 0x2:
case 0x3:
case 0x4:
case 0x5:
case 0x6:
case 0x7:
case 0x8:
case 0xE:
case 0xF:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x15:
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1A:
case 0x1B:
case 0x1C:
case 0x1D:
case 0x1E:
case 0x1F:
case 0x27:
case 0x2D:
stringKind = 1;
break;
default:
continue;
}
}
break;
}
_userStringWriter.WriteByte(stringKind);
}
return(0x70000000 | index);
}
public bool TryGetUserStringToken(string str, out int token)
{
int index;
if (!_userStrings.TryGetValue(str, out index))
{
Debug.Assert(!_streamsAreComplete);
index = _userStringWriter.Position + _userStringHeapStartOffset;
// User strings are referenced by metadata tokens (8 bits of which are used for the token type) leaving only 24 bits for the offset.
if ((index & 0xFF000000) != 0)
{
token = 0;
return(false);
}
_userStrings.Add(str, index);
_userStringWriter.WriteCompressedInteger((uint)str.Length * 2 + 1);
_userStringWriter.WriteUTF16(str);
// Write out a trailing byte indicating if the string is really quite simple
byte stringKind = 0;
foreach (char ch in str)
{
if (ch >= 0x7F)
{
stringKind = 1;
}
else
{
switch ((int)ch)
{
case 0x1:
case 0x2:
case 0x3:
case 0x4:
case 0x5:
case 0x6:
case 0x7:
case 0x8:
case 0xE:
case 0xF:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x15:
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1A:
case 0x1B:
case 0x1C:
case 0x1D:
case 0x1E:
case 0x1F:
case 0x27:
case 0x2D:
stringKind = 1;
break;
default:
continue;
}
}
break;
}
_userStringWriter.WriteByte(stringKind);
}
token = 0x70000000 | index;
return(true);
}
// TODO:
// WriteBytes(byte*)
// WriteBytes(stream)
// WriteBytes(byte[])
// WriteBytes(IA<byte>)
// WriteReference
private static void TestCompressedUnsignedInteger(byte[] expected, int value)
{
var writer = new BlobWriter(4);
writer.WriteCompressedInteger((uint)value);
AssertEx.Equal(expected, writer.ToArray());
var builder = new BlobBuilder();
builder.WriteCompressedInteger((uint)value);
AssertEx.Equal(expected, builder.ToArray());
}
