public SymDocumentWriter(ISymUnmanagedDocumentWriter unmanagedDocumentWriter)
{
// We should not wrap null instances
if (unmanagedDocumentWriter == null)
throw new ArgumentNullException("unmanagedDocumentWriter");
m_unmanagedDocumentWriter = unmanagedDocumentWriter;
}
/// <summary>
/// Flushes accumulated sequence points and re-initializes sequence point state.
/// </summary>
private void DefineSequencePointsForCurrentDocument()
{
//^ requires this.currentDocument != null && this.currentDocument != SourceDummy.PrimarySourceDocument
ISymUnmanagedDocumentWriter document = this.GetDocumentWriterFor(this.currentDocument);
uint seqPointCount = (uint)this.offsets.Count;
if (seqPointCount > 0)
{
uint[] offsets = this.offsets.ToArray();
uint[] startLines = this.startLines.ToArray();
uint[] startColumns = this.startColumns.ToArray();
uint[] endLines = this.endLines.ToArray();
uint[] endColumns = this.endColumns.ToArray();
this.SymWriter.DefineSequencePoints(document, seqPointCount, offsets, startLines, startColumns, endLines, endColumns);
}
this.currentDocument = null;
this.offsets.Clear();
this.startLines.Clear();
this.startColumns.Clear();
this.endLines.Clear();
this.endColumns.Clear();
}
internal ISymUnmanagedDocumentWriter GetUnmanagedDocument(ISymUnmanagedWriter2 symUnmanagedWriter)
{
if (unmanagedDocument == null)
{
unmanagedDocument = symUnmanagedWriter.DefineDocument(url, ref language, ref languageVendor, ref documentType);
}
return unmanagedDocument;
}
public virtual extern void __DefineSequencePoints([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter document, [In] uint spCount, [In] ref uint offsets, [In] ref uint lines, [In] ref uint columns, [In] ref uint endLines, [In] ref uint endColumns);
public SymDocumentWriter(ISymUnmanagedDocumentWriter unmanagedDocumentWriter)
{
m_unmanagedDocumentWriter = unmanagedDocumentWriter;
}
private void WriteSequencePoints(ISymUnmanagedDocumentWriter symDocument, int count)
{
try
{
symWriter.DefineSequencePoints(
symDocument,
(uint)count,
sequencePointOffsets,
sequencePointStartLines,
sequencePointStartColumns,
sequencePointEndLines,
sequencePointEndColumns);
}
catch (Exception ex)
{
throw new PdbWritingException(ex);
}
}
// Constructors.
public unsafe SymDocumentWriter
(ISymUnmanagedDocumentWriter *pDocumentWriter)
{
this.pDocumentWriter = pDocumentWriter;
}
public virtual void DefineSequencePoints(ISymUnmanagedDocumentWriter document, uint count, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] offsets, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] lines, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] columns, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] endLines, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] endColumns)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates symbols for method identified by <c>oldToken</c> by translating symbols
/// from new version of method identified by <c>newToken</c>.
/// </summary>
/// <param name="newToken">Identifies new version of method.</param>
/// <param name="oldToken">Identifies old version of method.</param>
/// <param name="placeholder">Translation definition for local variables.</param>
public List<SequencePoint> EmitMethod(uint oldToken,uint newToken,Dictionary<int,int> placeholder=null)
{
if(State != WriterState.Building){
throw new TranslatingException("ISym* interfaces were not initializde. (EnC)");
}
int bla = ((IMetaDataImport)manager.MetadataManager.OldEmitter.CorMetaDataEmit).IsValidToken(oldToken);
ISymUnmanagedMethod smMethod = mReader.__GetMethod(newToken);
mWriter.__OpenMethod(oldToken);
uint seqCount = smMethod.__GetSequencePointCount();
uint[] lines = new uint[seqCount];
uint[] offsets = new uint[seqCount];
uint[] columns = new uint[seqCount];
uint[] endLines = new uint[seqCount];
uint[] endColumns = new uint[seqCount];
ISymUnmanagedDocument[] documents = new ISymUnmanagedDocument[seqCount];
ISymUnmanagedDocumentWriter[] docWriters = new ISymUnmanagedDocumentWriter[seqCount];
uint cCount;
smMethod.__GetSequencePoints(seqCount,out cCount,offsets,documents,lines,columns,endLines,endColumns);
for (int i = 0; i < seqCount; i++) {
docWriters[i] = DefineDocument(documents[i]);
mWriter.__DefineSequencePoints(docWriters[i],1,ref offsets[i],ref lines[i],ref columns[i],
ref endLines[i],ref endColumns[i]);
}
mWriter.__SetMethodSourceRange(docWriters[0],lines[0],columns[0],docWriters[seqCount - 1],endLines[seqCount - 1],endColumns[seqCount - 1]);
EmitScope(smMethod.__GetRootScope(),placeholder); //
try{
mWriter.__CloseMethod();
} catch(COMException){
}
return SequencePoint.StoreSequencePoints(offsets,lines,columns,endLines,endColumns);
}
public static void SetSource(this ISymUnmanagedDocumentWriter instance, uint sourceSize, ref byte source)
{
instance.__SetSource(sourceSize, ref source);
ProcessOutParameter(source);
}
public static ISymUnmanagedDocumentWriter DefineDocument(this ISymUnmanagedWriter2 instance, IntPtr url, ref Guid language, ref Guid languageVendor, ref Guid documentType)
{
ISymUnmanagedDocumentWriter returnValue = instance.__DefineDocument(url, ref language, ref languageVendor, ref documentType);
return(returnValue);
}
/// <summary>
/// Gets methods(described by metadata token) sequence points from <c>ISymUnmanagedReader</c>.
/// </summary>
/// <param name="reader">Reader for getting debugging symbols.</param>
/// <param name="mToken">Metadata token of the method.</param>
/// <returns><c>List</c> of SequencePoint.</returns>
public static List<SequencePoint> GetMethodSequencePoints(ISymUnmanagedReader reader,uint mToken)
{
ISymUnmanagedMethod pMethod = reader.__GetMethod(mToken);
uint seqCount = pMethod.__GetSequencePointCount();
uint[] lines = new uint[seqCount];
uint[] offsets = new uint[seqCount];
uint[] columns = new uint[seqCount];
uint[] endLines = new uint[seqCount];
uint[] endColumns = new uint[seqCount];
ISymUnmanagedDocument[] documents = new ISymUnmanagedDocument[seqCount];
ISymUnmanagedDocumentWriter[] docWriters = new ISymUnmanagedDocumentWriter[seqCount];
uint cCount;
pMethod.__GetSequencePoints(seqCount,out cCount,offsets,documents,lines,columns,endLines,endColumns);
List<SequencePoint> store = new List<SequencePoint>();
for (int i = 0; i < offsets.Length; i++) {
SequencePoint point;
point.Column = columns[i];
point.Offset = offsets[i];
point.Line = lines[i];
point.EndColumn = endColumns[i];
point.EndLine = endLines[i];
store.Add(point);
}
return store;
}
public void MapTokenToSourceSpan (uint token, ISymUnmanagedDocumentWriter document, uint startLine, uint startColumn, uint endLine, uint endColumn)
{
var assembly = writer.Context.Module.AsAssembly;
if (assembly != null && assembly.Kind == OutputKind.WindowsRuntimeMetadata) {
//I guess Mono doesn't care about .winmdobj file generation
} else {
throw new NotUsedInRoslynException ();
}
}
public void SetMethodSourceRange (ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, object endDoc, uint endLine, uint endColumn)
{
throw new NotUsedInRoslynException ();
}
public void DefineSequencePoints (ISymUnmanagedDocumentWriter document, uint count, uint[] offsets, uint[] lines, uint[] columns, uint[] endLines, uint[] endColumns)
{
msw.SetMethodUnit (((ICompileUnit)document).Entry);
var doc = (SymbolDocumentWriterImpl)document;
var file = doc != null ? doc.Entry.SourceFile : null;
for (int n = 0; n < count; n++) {
if (n > 0 && offsets [n] == offsets [n - 1] && lines [n] == lines [n - 1] && columns [n] == columns [n - 1])
continue;
msw.MarkSequencePoint ((int)offsets [n], file, (int)lines [n], (int)columns [n], (int)endLines [n], (int)endColumns [n], lines [n] == 0xfeefee);
}
}
public virtual extern void __SetMethodSourceRange([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter startDoc, [In] uint startLine, [In] uint startColumn, [In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter endDoc, [In] uint endLine, [In] uint endColumn);
public static void SetMethodSourceRange(this ISymUnmanagedWriter2 instance, ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
{
instance.__SetMethodSourceRange(startDoc, startLine, startColumn, endDoc, endLine, endColumn);
}
public SymbolDocumentWriter(ISymUnmanagedDocumentWriter writer) {
this.writer = writer;
}
public void MapTokenToSourceSpan(uint token, ISymUnmanagedDocumentWriter document, uint startLine, uint startColumn, uint endLine, uint endColumn)
{
throw new NotImplementedException();
}
public static void SetCheckSum(this ISymUnmanagedDocumentWriter instance, Guid algorithmId, uint checkSumSize, ref byte checkSum)
{
instance.__SetCheckSum(algorithmId, checkSumSize, ref checkSum);
ProcessOutParameter(checkSum);
}
internal void Release()
{
if (unmanagedDocument != null)
{
Marshal.ReleaseComObject(unmanagedDocument);
unmanagedDocument = null;
}
}
public static void DefineSequencePoints(this ISymUnmanagedWriter2 instance, ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
{
instance.__DefineSequencePoints(document, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
}
public SymDocumentWriter (ISymUnmanagedDocumentWriter unmanagedDocumentWriter)
{
m_unmanagedDocumentWriter = unmanagedDocumentWriter;
}
public virtual void SetMethodSourceRange(ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, object endDoc, uint endLine, uint endColumn)
{
throw new NotImplementedException();
}
public void SetMethodSourceRange(ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, object endDoc, uint endLine, uint endColumn)
{
throw new NotUsedInRoslynException();
}
private void WriteSequencePoints(ISymUnmanagedDocumentWriter symDocument, int count)
{
try
{
_symWriter.DefineSequencePoints(
symDocument,
(uint)count,
_sequencePointOffsets,
_sequencePointStartLines,
_sequencePointStartColumns,
_sequencePointEndLines,
_sequencePointEndColumns);
if (_callLogger.LogOperation(OP.DefineSequencePoints))
{
_callLogger.LogArgument((uint)count);
_callLogger.LogArgument(_sequencePointOffsets);
_callLogger.LogArgument(_sequencePointStartLines);
_callLogger.LogArgument(_sequencePointStartColumns);
_callLogger.LogArgument(_sequencePointEndLines);
_callLogger.LogArgument(_sequencePointEndColumns);
}
}
catch (Exception ex)
{
throw new PdbWritingException(ex);
}
}
public static void SetMethodSourceRange(this ISymUnmanagedWriter2 instance, ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
{
instance.__SetMethodSourceRange(startDoc, startLine, startColumn, endDoc, endLine, endColumn);
}
public SymDocumentWriter(ISymUnmanagedDocumentWriter writer)
{
this.writer = writer;
}
public static void DefineSequencePoints(this ISymUnmanagedWriter2 instance, ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
{
instance.__DefineSequencePoints(document, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
}
public SymbolDocumentWriter(ISymUnmanagedDocumentWriter writer) => this.writer = writer;
public SymbolDocumentWriter(ISymUnmanagedDocumentWriter writer)
{
SymUnmanagedDocumentWriter = writer;
}
