public void WriteSequencePoints(SequencePoint[] sequencePoints)
{
if (sequencePoints.Length == 0)
{
return;
}
BlobBuilder blobBuilder = Builder;
int num = -1;
int num2 = -1;
blobBuilder.WriteCompressedInteger(LocalSignatureRowId);
DocumentHandle debugSourceDocument = sequencePoints[0].Document;
for (int i = 0; i < sequencePoints.Length; i++)
{
DocumentHandle document = sequencePoints[i].Document;
if (debugSourceDocument != document)
{
if (debugSourceDocument != null)
{
blobBuilder.WriteCompressedInteger(0);
}
blobBuilder.WriteCompressedInteger(MetadataTokens.GetRowNumber(document));
debugSourceDocument = document;
}
if (i > 0)
{
if (sequencePoints[i].Offset - sequencePoints[i - 1].Offset < 1)
{
throw new InvalidOperationException("There must not be specified more sequence points per offset.");
}
blobBuilder.WriteCompressedInteger(sequencePoints[i].Offset - sequencePoints[i - 1].Offset);
}
else
{
blobBuilder.WriteCompressedInteger(sequencePoints[i].Offset);
}
if (sequencePoints[i].IsHidden)
{
blobBuilder.WriteInt16(0);
}
else
{
this.SerializeDeltaLinesAndColumns(blobBuilder, sequencePoints[i]);
if (num < 0)
{
blobBuilder.WriteCompressedInteger(sequencePoints[i].StartLine);
blobBuilder.WriteCompressedInteger(sequencePoints[i].StartColumn);
}
else
{
blobBuilder.WriteCompressedSignedInteger(sequencePoints[i].StartLine - num);
blobBuilder.WriteCompressedSignedInteger(sequencePoints[i].StartColumn - num2);
}
num = sequencePoints[i].StartLine;
num2 = sequencePoints[i].StartColumn;
}
}
}
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));
}
int ParseCompressedSignedInt()
{
int value = _input.ReadCompressedSignedInteger();
_output.WriteCompressedSignedInteger(value);
return(value);
}
private static byte[] CompressSignedInteger(int value)
{
var writer = new BlobBuilder();
writer.WriteCompressedSignedInteger(value);
return(writer.ToArray());
}
private static void TestCompressedSignedInteger(byte[] expected, int value)
{
var writer = new BlobWriter(4);
writer.WriteCompressedSignedInteger(value);
AssertEx.Equal(expected, writer.ToArray());
var builder = new BlobBuilder();
builder.WriteCompressedSignedInteger(value);
AssertEx.Equal(expected, builder.ToArray());
}
public void CompressSignedIntegersFromSpecExamples()
{
// These examples are straight from the CLI spec.
TestCompressedSignedInteger(new byte[] { 0x00 }, 0);
TestCompressedSignedInteger(new byte[] { 0x02 }, 1);
TestCompressedSignedInteger(new byte[] { 0x06 }, 3);
TestCompressedSignedInteger(new byte[] { 0x7f }, -1);
TestCompressedSignedInteger(new byte[] { 0x7b }, -3);
TestCompressedSignedInteger(new byte[] { 0x80, 0x80 }, 64);
TestCompressedSignedInteger(new byte[] { 0x01 }, -64);
TestCompressedSignedInteger(new byte[] { 0xC0, 0x00, 0x40, 0x00 }, 8192);
TestCompressedSignedInteger(new byte[] { 0x80, 0x01 }, -8192);
TestCompressedSignedInteger(new byte[] { 0xDF, 0xFF, 0xFF, 0xFE }, 268435455);
TestCompressedSignedInteger(new byte[] { 0xC0, 0x00, 0x00, 0x01 }, -268435456);
var writer = new BlobWriter(4);
var builder = new BlobBuilder();
Assert.Throws <ArgumentOutOfRangeException>(() => writer.WriteCompressedSignedInteger(BlobWriterImpl.MinSignedCompressedIntegerValue - 1));
Assert.Throws <ArgumentOutOfRangeException>(() => writer.WriteCompressedSignedInteger(BlobWriterImpl.MaxSignedCompressedIntegerValue + 1));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteCompressedSignedInteger(BlobWriterImpl.MinSignedCompressedIntegerValue - 1));
Assert.Throws <ArgumentOutOfRangeException>(() => builder.WriteCompressedSignedInteger(BlobWriterImpl.MaxSignedCompressedIntegerValue + 1));
}
private static void SerializeDeltaLinesAndColumns(BlobBuilder writer, SymUnmanagedSequencePoint 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 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);
}
}
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
if (!(deltaLines != 0 || deltaColumns != 0 || sequencePoint.IsHidden))
{
throw new InvalidOperationException("Only hidden sequence points have zero width ");
}
writer.WriteCompressedInteger(deltaLines);
if (deltaLines == 0)
{
writer.WriteCompressedInteger(deltaColumns);
}
else
{
writer.WriteCompressedSignedInteger(deltaColumns);
}
}
private static BlobHandle SerializeSequencePoints(
MetadataBuilder metadataBuilder,
int localSignatureRowId,
ImmutableArray <SymUnmanagedSequencePoint> sequencePoints,
Dictionary <string, 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(localSignatureRowId);
DocumentHandle previousDocument = TryGetSingleDocument(sequencePoints, documentIndex);
singleDocumentHandle = previousDocument;
for (int i = 0; i < sequencePoints.Length; i++)
{
var currentDocument = documentIndex[sequencePoints[i].Document.GetName()];
if (previousDocument != currentDocument)
{
// optional document in header or document record:
if (!previousDocument.IsNil)
{
writer.WriteCompressedInteger(0);
}
writer.WriteCompressedInteger(MetadataTokens.GetHeapOffset(currentDocument));
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(metadataBuilder.GetOrAddBlob(writer));
}
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 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);
}
}
public void CompressSignedIntegersFromSpecExamples()
{
// These examples are straight from the CLI spec.
TestCompressedSignedInteger(new byte[] { 0x00 }, 0);
TestCompressedSignedInteger(new byte[] { 0x02 }, 1);
TestCompressedSignedInteger(new byte[] { 0x06 }, 3);
TestCompressedSignedInteger(new byte[] { 0x7f }, -1);
TestCompressedSignedInteger(new byte[] { 0x7b }, -3);
TestCompressedSignedInteger(new byte[] { 0x80, 0x80 }, 64);
TestCompressedSignedInteger(new byte[] { 0x01 }, -64);
TestCompressedSignedInteger(new byte[] { 0xC0, 0x00, 0x40, 0x00 }, 8192);
TestCompressedSignedInteger(new byte[] { 0x80, 0x01 }, -8192);
TestCompressedSignedInteger(new byte[] { 0xDF, 0xFF, 0xFF, 0xFE }, 268435455);
TestCompressedSignedInteger(new byte[] { 0xC0, 0x00, 0x00, 0x01 }, -268435456);
var writer = new BlobWriter(4);
var builder = new BlobBuilder();
Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteCompressedSignedInteger(BlobWriterImpl.MinSignedCompressedIntegerValue - 1));
Assert.Throws<ArgumentOutOfRangeException>(() => writer.WriteCompressedSignedInteger(BlobWriterImpl.MaxSignedCompressedIntegerValue + 1));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteCompressedSignedInteger(BlobWriterImpl.MinSignedCompressedIntegerValue - 1));
Assert.Throws<ArgumentOutOfRangeException>(() => builder.WriteCompressedSignedInteger(BlobWriterImpl.MaxSignedCompressedIntegerValue + 1));
}
private static void TestCompressedSignedInteger(byte[] expected, int value)
{
var writer = new BlobWriter(4);
writer.WriteCompressedSignedInteger(value);
AssertEx.Equal(expected, writer.ToArray());
var builder = new BlobBuilder();
builder.WriteCompressedSignedInteger(value);
AssertEx.Equal(expected, builder.ToArray());
}
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));
}
