public override MethodSymbols Clone()
{
var result = new PdbMethodSymbols(method_body);
CloneTo(result);
return(result);
}
private void DefineUsedNamespaces(PdbMethodSymbols pdbSymbols)
{
// Used namespaces
if (pdbSymbols != null && pdbSymbols.UsedNamespaces != null)
{
foreach (var @namespace in pdbSymbols.UsedNamespaces)
{
writer.UsingNamespace(@namespace);
}
}
}
protected void CloneTo(PdbMethodSymbols symbols)
{
base.CloneTo(symbols);
symbols.IteratorClass = IteratorClass;
if (IteratorScopes != null)
{
symbols.IteratorScopes = new Collection <PdbIteratorScope> ();
foreach (var iteratorScope in IteratorScopes)
{
symbols.IteratorScopes.Add(new PdbIteratorScope(iteratorScope.Start, iteratorScope.End));
}
}
if (UsedNamespaces != null)
{
symbols.UsedNamespaces = new Collection <string> (UsedNamespaces);
}
if (UsingCounts != null)
{
symbols.UsingCounts = new Collection <ushort> (UsingCounts);
}
symbols.MethodWhoseUsingInfoAppliesToThisMethod = MethodWhoseUsingInfoAppliesToThisMethod;
if (SynchronizationInformation != null)
{
symbols.SynchronizationInformation = new PdbSynchronizationInformation {
KickoffMethod = SynchronizationInformation.KickoffMethod,
GeneratedCatchHandlerIlOffset = SynchronizationInformation.GeneratedCatchHandlerIlOffset,
};
if (SynchronizationInformation.SynchronizationPoints != null)
{
symbols.SynchronizationInformation.SynchronizationPoints = new Collection <PdbSynchronizationPoint> ();
foreach (var synchronizationPoint in SynchronizationInformation.SynchronizationPoints)
{
symbols.SynchronizationInformation.SynchronizationPoints.Add(new PdbSynchronizationPoint {
SynchronizeOffset = synchronizationPoint.SynchronizeOffset,
ContinuationMethod = synchronizationPoint.ContinuationMethod,
ContinuationOffset = synchronizationPoint.ContinuationOffset,
});
}
}
}
}
void WriteScope(PdbMethodSymbols symbols, ScopeSymbol scope, bool rootScope)
{
writer.OpenScope(scope.Start);
// TODO: Store used namespace per scope?
if (rootScope)
{
DefineUsedNamespaces(symbols);
}
foreach (var s in scope.Scopes)
{
WriteScope(symbols, s, false);
}
DefineVariables(symbols, scope.Variables, scope.Start, scope.End);
writer.CloseScope(scope.End);
}
private void DefineCustomMetadata(PdbMethodSymbols pdbSymbols)
{
// Custom PDB metadata
if (pdbSymbols != null)
{
using (var memoryStream = new MemoryStream()) {
var metadata = new BinaryStreamWriter(memoryStream);
metadata.WriteByte(4); // version
metadata.WriteByte((byte)1); // count
metadata.WriteInt16(0); // padding
var metadataStartPosition = metadata.BaseStream.Position;
var customMetadataCount = 0;
if (pdbSymbols.IteratorClass != null)
{
customMetadataCount++;
metadata.WriteByte(4); // version
metadata.WriteByte(4); // forward iterator
metadata.Align(4);
using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
metadata.WriteString(pdbSymbols.IteratorClass);
metadata.WriteInt16(0);
metadata.Align(4);
}
}
if (pdbSymbols.UsingCounts != null)
{
customMetadataCount++;
metadata.WriteByte(4); // version
metadata.WriteByte(0); // using info
metadata.Align(4);
using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
metadata.WriteUInt16((ushort)pdbSymbols.UsingCounts.Count);
foreach (var uc in pdbSymbols.UsingCounts)
{
metadata.WriteUInt16(uc);
}
metadata.Align(4);
}
}
if (pdbSymbols.MethodWhoseUsingInfoAppliesToThisMethod != null)
{
customMetadataCount++;
metadata.WriteByte(4); // version
metadata.WriteByte(1); // forward info
metadata.Align(4);
using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
metadata.WriteUInt32(pdbSymbols.MethodWhoseUsingInfoAppliesToThisMethod.MetadataToken.ToUInt32());
}
}
if (pdbSymbols.IteratorScopes != null)
{
customMetadataCount++;
metadata.WriteByte(4); // version
metadata.WriteByte(3); // iterator scopes
metadata.Align(4);
using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
metadata.WriteInt32(pdbSymbols.IteratorScopes.Count);
foreach (var scope in pdbSymbols.IteratorScopes)
{
metadata.WriteInt32(scope.Start.Offset);
metadata.WriteInt32(scope.End.Offset);
}
}
}
if (metadata.BaseStream.Position != metadataStartPosition)
{
// Update number of entries
metadata.Flush();
metadata.BaseStream.Position = 1;
metadata.WriteByte((byte)customMetadataCount);
metadata.Flush();
writer.DefineCustomMetadata("MD2", memoryStream.ToArray());
}
}
// Save back asyncMethodInfo
if (pdbSymbols.SynchronizationInformation != null)
{
using (var memoryStream = new MemoryStream()) {
var metadata = new BinaryStreamWriter(memoryStream);
metadata.WriteUInt32(pdbSymbols.SynchronizationInformation.KickoffMethod != null ? pdbSymbols.SynchronizationInformation.KickoffMethod.MetadataToken.ToUInt32() : 0);
metadata.WriteUInt32(pdbSymbols.SynchronizationInformation.GeneratedCatchHandlerIlOffset);
metadata.WriteUInt32((uint)pdbSymbols.SynchronizationInformation.SynchronizationPoints.Count);
foreach (var syncPoint in pdbSymbols.SynchronizationInformation.SynchronizationPoints)
{
metadata.WriteUInt32(syncPoint.SynchronizeOffset);
metadata.WriteUInt32(syncPoint.ContinuationMethod != null ? syncPoint.ContinuationMethod.MetadataToken.ToUInt32() : 0);
metadata.WriteUInt32(syncPoint.ContinuationOffset);
}
writer.DefineCustomMetadata("asyncMethodInfo", memoryStream.ToArray());
}
}
}
}
