The Labs \ Source Viewer \ SSCLI \ System.Diagnostics.SymbolStore \ SymVariable

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. using System;
  16. using System.Text;
  17. using System.Reflection;
  18. using System.Diagnostics;
  19. using System.Security.Permissions;
  20. using System.Diagnostics.SymbolStore;
  21. using System.Runtime.InteropServices;
  22. using Microsoft.Win32;
  23. namespace System.Diagnostics.SymbolStore
  24. {
  25.     internal sealed class Win32Native
  26.     {
  27.         #if !PLATFORM_UNIX
  28.         internal const string DLLPREFIX = "";
  29.         internal const string DLLSUFFIX = ".dll";
  30.         #else // !PLATFORM_UNIX
  31.         #if __APPLE__
  32.         internal const string DLLPREFIX = "lib";
  33.         internal const string DLLSUFFIX = ".dylib";
  34.         #else
  35.         internal const string DLLPREFIX = "lib";
  36.         internal const string DLLSUFFIX = ".so";
  37.         #endif
  38.         #endif // !PLATFORM_UNIX
  39.     }
  40.    
  41.     //
  42.     // Class to CoCreate a class via PInvoke and DllGetClassObject
  43.     //
  44.     class CreateSymClass
  45.     {
  46.         public const string NATIVE_DLL = Win32Native.DLLPREFIX + "ildbsymbols" + Win32Native.DLLSUFFIX;
  47.        
  48.         private static readonly Guid IID_IClassFactory = new Guid(1, 0, 0, 192, 0, 0, 0, 0, 0, 0,
  49.         70);
  50.        
  51.         [DllImport(NATIVE_DLL)]
  52.         static extern int DllGetClassObject(        [In()]
  53. ref Guid rclsid,         [In()]
  54. ref Guid riid, out IntPtr ClassObject);
  55.        
  56.         [DllImport(NATIVE_DLL)]
  57.         static extern int ClassFactory_CreateInstance(IntPtr classfactory,         [In()]
  58. ref Guid rclsid, out IntPtr ClassInstance);
  59.        
  60.         [DllImport(NATIVE_DLL)]
  61.         static extern void ClassFactory_Release(IntPtr classfactory);
  62.        
  63.         public static IntPtr CreateClass(Guid rclsid, Guid riid)
  64.         {
  65.             IntPtr classFactory;
  66.             IntPtr objCreatedObject;
  67.            
  68.             COMException Exception;
  69.             // Create a local copy so that we can pass it's reference
  70.             Guid IClassFactory = IID_IClassFactory;
  71.             int hr;
  72.             hr = DllGetClassObject(ref rclsid, ref IClassFactory, out classFactory);
  73.             try {
  74.                 if (hr < 0) {
  75.                     Exception = new COMException("Call to DllGetClassObject failed.", hr);
  76.                     throw Exception;
  77.                 }
  78.                 hr = ClassFactory_CreateInstance(classFactory, ref riid, out objCreatedObject);
  79.                 if (hr < 0) {
  80.                     Exception = new COMException("Call to CreateInstance failed.", hr);
  81.                     throw Exception;
  82.                 }
  83.             }
  84.             finally {
  85.                 ClassFactory_Release(classFactory);
  86.             }
  87.            
  88.             return objCreatedObject;
  89.         }
  90.     }
  91.    
  92.     //
  93.     // Document
  94.     //
  95.     public class SymDocument : ISymbolDocument
  96.     {
  97.        
  98.         private IntPtr m_Document;
  99.         // Unmanaged document pointer
  100.         [DllImport(CreateSymClass.NATIVE_DLL)]
  101.         static extern int SymDocument_Release(IntPtr DocumentWriter);
  102.        
  103.         [DllImport(CreateSymClass.NATIVE_DLL)]
  104.         static extern int SymDocument_GetCheckSum(IntPtr Document, int cData, out int pcData,         [In()]
  105. byte[] data);
  106.        
  107.         [DllImport(CreateSymClass.NATIVE_DLL)]
  108.         static extern int SymDocument_GetCheckSumAlgorithmId(IntPtr Document, out Guid pRetVal);
  109.        
  110.         [DllImport(CreateSymClass.NATIVE_DLL)]
  111.         static extern int SymDocument_GetDocumentType(IntPtr Document, out Guid pRetVal);
  112.        
  113.         [DllImport(CreateSymClass.NATIVE_DLL)]
  114.         static extern int SymDocument_GetLanguage(IntPtr Document, out Guid pRetVal);
  115.        
  116.         [DllImport(CreateSymClass.NATIVE_DLL)]
  117.         static extern int SymDocument_GetLanguageVendor(IntPtr Document, out Guid pRetVal);
  118.        
  119.         [DllImport(CreateSymClass.NATIVE_DLL)]
  120.         static extern int SymDocument_HasEmbeddedSource(IntPtr Document, out bool pRetVal);
  121.        
  122.         [DllImport(CreateSymClass.NATIVE_DLL)]
  123.         static extern int SymDocument_GetSourceLength(IntPtr Document, out int pRetVal);
  124.        
  125.         [DllImport(CreateSymClass.NATIVE_DLL)]
  126.         static extern int SymDocument_GetSourceRange(IntPtr Document, int startLine, int startColumn, int endLine, int endColumn, int cSourceBytes, out int pcSourceBytes,         [In()]
  127. byte[] source);
  128.        
  129.        
  130.         [DllImport(CreateSymClass.NATIVE_DLL)]
  131.         static extern int SymDocument_FindClosestLine(IntPtr Document, int line, out int pRetVal);
  132.        
  133.         [DllImport(CreateSymClass.NATIVE_DLL)]
  134.         static extern int SymDocument_GetUrl(IntPtr Document, int cchUrl, out int pcchUrl, StringBuilder szUrl);
  135.        
  136.        
  137.         //-----------------------------------------------------------------------
  138.         // SymDocument
  139.         //-----------------------------------------------------------------------
  140.        
  141.         public SymDocument(IntPtr pDocument)
  142.         {
  143.             m_Document = pDocument;
  144.         }
  145.        
  146.         ~SymDocument()
  147.         {
  148.             SymDocument_Release(m_Document);
  149.         }
  150.        
  151.         public byte[] GetCheckSum()
  152.         {
  153.             int hr;
  154.             byte[] Data;
  155.             COMException Exception;
  156.             int cData;
  157.             hr = SymDocument_GetCheckSum(m_Document, 0, out cData, null);
  158.             if (hr < 0) {
  159.                 Exception = new COMException("Call to GetCheckSum failed.", hr);
  160.                 throw Exception;
  161.             }
  162.             Data = new byte[cData];
  163.             hr = SymDocument_GetCheckSum(m_Document, cData, out cData, Data);
  164.             if (hr < 0) {
  165.                 Exception = new COMException("Call to GetCheckSum failed.", hr);
  166.                 throw Exception;
  167.             }
  168.             return Data;
  169.         }
  170.        
  171.         public Guid CheckSumAlgorithmId {
  172.             get {
  173.                 int hr;
  174.                 Guid AlgorigthId;
  175.                 COMException Exception;
  176.                 hr = SymDocument_GetCheckSumAlgorithmId(m_Document, out AlgorigthId);
  177.                 if (hr < 0) {
  178.                     Exception = new COMException("Call to GetCheckSumAlgorithmId failed.", hr);
  179.                     throw Exception;
  180.                 }
  181.                 return AlgorigthId;
  182.             }
  183.         }
  184.        
  185.         public Guid DocumentType {
  186.             get {
  187.                 int hr;
  188.                 Guid DocumentType;
  189.                 COMException Exception;
  190.                 hr = SymDocument_GetDocumentType(m_Document, out DocumentType);
  191.                 if (hr < 0) {
  192.                     Exception = new COMException("Call to GetDocumentType failed.", hr);
  193.                     throw Exception;
  194.                 }
  195.                 return DocumentType;
  196.             }
  197.         }
  198.        
  199.         public Guid Language {
  200.             get {
  201.                 int hr;
  202.                 Guid Language;
  203.                 COMException Exception;
  204.                 hr = SymDocument_GetLanguage(m_Document, out Language);
  205.                 if (hr < 0) {
  206.                     Exception = new COMException("Call to GetLanguage failed.", hr);
  207.                     throw Exception;
  208.                 }
  209.                 return Language;
  210.             }
  211.         }
  212.        
  213.         public Guid LanguageVendor {
  214.             get {
  215.                 int hr;
  216.                 Guid LanguageVendor;
  217.                 COMException Exception;
  218.                 hr = SymDocument_GetLanguageVendor(m_Document, out LanguageVendor);
  219.                 if (hr < 0) {
  220.                     Exception = new COMException("Call to GetLanguageVendor failed.", hr);
  221.                     throw Exception;
  222.                 }
  223.                 return LanguageVendor;
  224.             }
  225.         }
  226.        
  227.         public bool HasEmbeddedSource {
  228.             get {
  229.                 int hr;
  230.                 bool HasEmbeddedSource;
  231.                 COMException Exception;
  232.                 hr = SymDocument_HasEmbeddedSource(m_Document, out HasEmbeddedSource);
  233.                 if (hr < 0) {
  234.                     Exception = new COMException("Call to HasEmbeddedSource failed.", hr);
  235.                     throw Exception;
  236.                 }
  237.                 return HasEmbeddedSource;
  238.             }
  239.         }
  240.        
  241.         public int FindClosestLine(int line)
  242.         {
  243.             int hr;
  244.             int ClosestLine = 0;
  245.             COMException Exception;
  246.             hr = SymDocument_FindClosestLine(m_Document, line, out ClosestLine);
  247.             if (hr < 0) {
  248.                 Exception = new COMException("Call to FindClosestLine failed.", hr);
  249.                 throw Exception;
  250.             }
  251.             return ClosestLine;
  252.         }
  253.        
  254.         public byte[] GetSourceRange(int startLine, int startColumn, int endLine, int endColumn)
  255.         {
  256.             int hr;
  257.             byte[] Range;
  258.             int cSourceBytes;
  259.             COMException Exception;
  260.             hr = SymDocument_GetSourceRange(m_Document, startLine, startColumn, endLine, endColumn, 0, out cSourceBytes, null);
  261.             if (hr < 0) {
  262.                 Exception = new COMException("Call to GetSourceRange failed.", hr);
  263.                 throw Exception;
  264.             }
  265.             Range = new byte[cSourceBytes];
  266.             hr = SymDocument_GetSourceRange(m_Document, startLine, startColumn, endLine, endColumn, cSourceBytes, out cSourceBytes, Range);
  267.             if (hr < 0) {
  268.                 Exception = new COMException("Call to GetSourceRange failed.", hr);
  269.                 throw Exception;
  270.             }
  271.             return Range;
  272.         }
  273.        
  274.         public int SourceLength {
  275.             get {
  276.                 int hr;
  277.                 int SourceLength;
  278.                 COMException Exception;
  279.                 hr = SymDocument_GetSourceLength(m_Document, out SourceLength);
  280.                 if (hr < 0) {
  281.                     Exception = new COMException("Call to GetSourceLength failed.", hr);
  282.                     throw Exception;
  283.                 }
  284.                 return SourceLength;
  285.             }
  286.         }
  287.         public string URL {
  288.             get {
  289.                 int hr;
  290.                 StringBuilder URL;
  291.                 int cchUrl;
  292.                 COMException Exception;
  293.                 hr = SymDocument_GetUrl(m_Document, 0, out cchUrl, null);
  294.                 if (hr < 0) {
  295.                     Exception = new COMException("Call to GetUrl failed.", hr);
  296.                     throw Exception;
  297.                 }
  298.                 // *2 since it's wchar's
  299.                 URL = new StringBuilder(cchUrl);
  300.                 hr = SymDocument_GetUrl(m_Document, cchUrl, out cchUrl, URL);
  301.                 if (hr < 0) {
  302.                     Exception = new COMException("Call to GetUrl failed.", hr);
  303.                     throw Exception;
  304.                 }
  305.                 return URL.ToString();
  306.             }
  307.         }
  308.        
  309.         // Public API
  310.         public IntPtr InternalDocument {
  311.             get { return m_Document; }
  312.         }
  313.        
  314.     }
  315.    
  316.     public class SymDocumentWriter : ISymbolDocumentWriter
  317.     {
  318.        
  319.         private IntPtr m_DocumentWriter;
  320.         // Unmanaged DocumentWriter pointer
  321.         [DllImport(CreateSymClass.NATIVE_DLL)]
  322.         static extern int SymDocumentWriter_Release(IntPtr DocumentWriter);
  323.        
  324.         [DllImport(CreateSymClass.NATIVE_DLL)]
  325.         static extern int SymDocumentWriter_SetSource(IntPtr DocumentWriter, int sourceSize, byte[] source);
  326.        
  327.         [DllImport(CreateSymClass.NATIVE_DLL)]
  328.         static extern int SymDocumentWriter_SetCheckSum(IntPtr DocumentWriter, Guid algorithmId, int CheckSumSize, byte[] CheckSum);
  329.        
  330.        
  331.         //-----------------------------------------------------------------------
  332.         // SymDocumentWriter
  333.         //-----------------------------------------------------------------------
  334.        
  335.         public SymDocumentWriter(IntPtr DocumentWriter)
  336.         {
  337.             m_DocumentWriter = DocumentWriter;
  338.         }
  339.        
  340.         ~SymDocumentWriter()
  341.         {
  342.             SymDocumentWriter_Release(m_DocumentWriter);
  343.         }
  344.        
  345.         public void SetSource(byte[] source)
  346.         {
  347.             int hr;
  348.             COMException Exception;
  349.             hr = SymDocumentWriter_SetSource(m_DocumentWriter, source.Length, source);
  350.             if (hr < 0) {
  351.                 Exception = new COMException("Call to SetSource failed.", hr);
  352.                 throw Exception;
  353.             }
  354.         }
  355.        
  356.         public void SetCheckSum(Guid algorithmId, byte[] source)
  357.         {
  358.             int hr;
  359.             COMException Exception;
  360.             hr = SymDocumentWriter_SetCheckSum(m_DocumentWriter, algorithmId, source.Length, source);
  361.             if (hr < 0) {
  362.                 Exception = new COMException("Call to SetCheckSum failed.", hr);
  363.                 throw Exception;
  364.             }
  365.         }
  366.        
  367.         public IntPtr InternalDocumentWriter {
  368.             get { return m_DocumentWriter; }
  369.         }
  370.     }
  371.    
  372.     //-----------------------------------------------------------------------
  373.     // SymMethod
  374.     //-----------------------------------------------------------------------
  375.     public class SymMethod : ISymbolMethod
  376.     {
  377.         private IntPtr m_Method;
  378.         // Unmanaged method pointer
  379.         [DllImport(CreateSymClass.NATIVE_DLL)]
  380.         static extern int SymMethod_Release(IntPtr Method);
  381.        
  382.         [DllImport(CreateSymClass.NATIVE_DLL)]
  383.         static extern int SymMethod_GetSequencePoints(IntPtr Method, int cPoint, out int pcPoints,         [In()]
  384. IntPtr[] document,         [In()]
  385. int[] offsets,         [In()]
  386. int[] lines,         [In()]
  387. int[] columns,         [In()]
  388. int[] endLines,         [In()]
  389. int[] endColumns);
  390.        
  391.         [DllImport(CreateSymClass.NATIVE_DLL)]
  392.         static extern int SymMethod_GetRootScope(IntPtr Method, out IntPtr pScope);
  393.        
  394.         [DllImport(CreateSymClass.NATIVE_DLL)]
  395.         static extern int SymMethod_GetScopeFromOffset(IntPtr Method, int offset, out IntPtr pScope);
  396.        
  397.         [DllImport(CreateSymClass.NATIVE_DLL)]
  398.         static extern int SymMethod_GetOffset(IntPtr Method, IntPtr Document, int line, int column, out int offset);
  399.        
  400.         [DllImport(CreateSymClass.NATIVE_DLL)]
  401.         static extern int SymMethod_GetToken(IntPtr Method, out int Token);
  402.        
  403.         [DllImport(CreateSymClass.NATIVE_DLL)]
  404.         static extern int SymMethod_GetSequencePointCount(IntPtr Method, out int Count);
  405.        
  406.         [DllImport(CreateSymClass.NATIVE_DLL)]
  407.         static extern int SymMethod_GetRanges(IntPtr Method, IntPtr Document, int line, int column, int cRanges, out int pcRanges,         [In()]
  408. int[] Ranges);
  409.        
  410.         [DllImport(CreateSymClass.NATIVE_DLL)]
  411.         static extern int SymMethod_GetParameters(IntPtr Method, int cParams, out int pcParams,         [In()]
  412. IntPtr[] parameters);
  413.        
  414.         [DllImport(CreateSymClass.NATIVE_DLL)]
  415.         static extern int SymMethod_GetNamespace(IntPtr Method, out IntPtr pNamespace);
  416.        
  417.         [DllImport(CreateSymClass.NATIVE_DLL)]
  418.         static extern int SymMethod_GetSourceStartEnd(IntPtr Method,         [In()]
  419. IntPtr[] docs,         [In()]
  420. int[] lines,         [In()]
  421. int[] columns, out bool pRetVal);
  422.        
  423.         //
  424.         // Implementation
  425.         //
  426.         public SymMethod(IntPtr pMethod)
  427.         {
  428.             m_Method = pMethod;
  429.         }
  430.        
  431.         ~SymMethod()
  432.         {
  433.             SymMethod_Release(m_Method);
  434.         }
  435.        
  436.         public void GetSequencePoints(int[] offsets, ISymbolDocument[] documents, int[] lines, int[] columns, int[] endLines, int[] endColumns)
  437.         {
  438.             int hr;
  439.             int spCount = 0;
  440.             if (offsets != null)
  441.                 spCount = offsets.Length;
  442.             else if (documents != null)
  443.                 spCount = documents.Length;
  444.             else if (lines != null)
  445.                 spCount = lines.Length;
  446.             else if (columns != null)
  447.                 spCount = columns.Length;
  448.             else if (endLines != null)
  449.                 spCount = endLines.Length;
  450.             else if (endColumns != null)
  451.                 spCount = endColumns.Length;
  452.            
  453.             // Don't do anything if they're not really asking for anything.
  454.             if (spCount == 0)
  455.                 return;
  456.            
  457.             // Make sure all arrays are the same length.
  458.             if ((offsets != null) && (spCount != offsets.Length))
  459.                 throw new ArgumentException();
  460.            
  461.             if ((lines != null) && (spCount != lines.Length))
  462.                 throw new ArgumentException();
  463.            
  464.             if ((columns != null) && (spCount != columns.Length))
  465.                 throw new ArgumentException();
  466.            
  467.             if ((endLines != null) && (spCount != endLines.Length))
  468.                 throw new ArgumentException();
  469.            
  470.             if ((endColumns != null) && (spCount != endColumns.Length))
  471.                 throw new ArgumentException();
  472.            
  473.             COMException Exception;
  474.             IntPtr[] IDocuments = new IntPtr[documents.Length];
  475.             int cPoints;
  476.             uint i;
  477.             hr = SymMethod_GetSequencePoints(m_Method, documents.Length, out cPoints, IDocuments, offsets, lines, columns, endLines, endColumns);
  478.            
  479.             if (hr < 0) {
  480.                 Exception = new COMException("Call to GetSequencePoints failed.", hr);
  481.                 throw Exception;
  482.             }
  483.            
  484.             // Create the SymDocument form the IntPtr's
  485.             for (i = 0; i < documents.Length; i++) {
  486.                 documents[i] = new SymDocument(IDocuments[i]);
  487.             }
  488.            
  489.             return;
  490.         }
  491.        
  492.         public ISymbolScope RootScope {
  493.             get {
  494.                 int hr;
  495.                 IntPtr pRootScope;
  496.                 COMException Exception;
  497.                 hr = SymMethod_GetRootScope(m_Method, out pRootScope);
  498.                 if (hr < 0) {
  499.                     Exception = new COMException("Call to GetRootScope failed.", hr);
  500.                     throw Exception;
  501.                 }
  502.                 return new SymScope(pRootScope);
  503.             }
  504.         }
  505.        
  506.         public ISymbolScope GetScope(int offset)
  507.         {
  508.             int hr;
  509.             IntPtr pScope;
  510.             COMException Exception;
  511.             hr = SymMethod_GetScopeFromOffset(m_Method, offset, out pScope);
  512.             if (hr < 0) {
  513.                 Exception = new COMException("Call to GetScopeFromOffset failed.", hr);
  514.                 throw Exception;
  515.             }
  516.             return new SymScope(pScope);
  517.         }
  518.        
  519.         public int GetOffset(ISymbolDocument document, int line, int column)
  520.         {
  521.             int hr;
  522.             int offset = 0;
  523.             COMException Exception;
  524.             hr = SymMethod_GetOffset(m_Method, ((SymDocument)document).InternalDocument, line, column, out offset);
  525.             if (hr < 0) {
  526.                 Exception = new COMException("Call to GetOffset failed.", hr);
  527.                 throw Exception;
  528.             }
  529.            
  530.             return offset;
  531.         }
  532.         public SymbolToken Token {
  533.             get {
  534.                 int hr;
  535.                 int tokenId;
  536.                 COMException Exception;
  537.                 hr = SymMethod_GetToken(m_Method, out tokenId);
  538.                 if (hr < 0) {
  539.                     Exception = new COMException("Call to GetToken failed.", hr);
  540.                     throw Exception;
  541.                 }
  542.                
  543.                 SymbolToken t = new SymbolToken(tokenId);
  544.                 return t;
  545.             }
  546.         }
  547.        
  548.         public int SequencePointCount {
  549.             get {
  550.                 int hr;
  551.                 int Count;
  552.                 COMException Exception;
  553.                 hr = SymMethod_GetSequencePointCount(m_Method, out Count);
  554.                 if (hr < 0) {
  555.                     Exception = new COMException("Call to GetSequencePointCount failed.", hr);
  556.                     throw Exception;
  557.                 }
  558.                
  559.                 return Count;
  560.             }
  561.         }
  562.         public int[] GetRanges(ISymbolDocument document, int line, int column)
  563.         {
  564.             int hr;
  565.             int cRanges;
  566.             int[] Ranges;
  567.             COMException Exception;
  568.             hr = SymMethod_GetRanges(m_Method, ((SymDocument)document).InternalDocument, line, column, 0, out cRanges, null);
  569.             if (hr < 0) {
  570.                 Exception = new COMException("Call to GetRanges failed.", hr);
  571.                 throw Exception;
  572.             }
  573.             Ranges = new int[cRanges];
  574.             hr = SymMethod_GetRanges(m_Method, ((SymDocument)document).InternalDocument, line, column, cRanges, out cRanges, Ranges);
  575.             if (hr < 0) {
  576.                 Exception = new COMException("Call to GetRanges failed.", hr);
  577.                 throw Exception;
  578.             }
  579.            
  580.             return Ranges;
  581.         }
  582.        
  583.         public ISymbolVariable[] GetParameters()
  584.         {
  585.             int hr;
  586.             int cVariables;
  587.             uint i;
  588.             SymVariable[] Variables;
  589.             IntPtr[] VariablePointers;
  590.             COMException Exception;
  591.             hr = SymMethod_GetParameters(m_Method, 0, out cVariables, null);
  592.             if (hr < 0) {
  593.                 Exception = new COMException("Call to GetParameters failed.", hr);
  594.                 throw Exception;
  595.             }
  596.             VariablePointers = new IntPtr[cVariables];
  597.             hr = SymMethod_GetParameters(m_Method, cVariables, out cVariables, VariablePointers);
  598.             if (hr < 0) {
  599.                 Exception = new COMException("Call to GetParameters failed.", hr);
  600.                 throw Exception;
  601.             }
  602.            
  603.             Variables = new SymVariable[cVariables];
  604.            
  605.             for (i = 0; i < cVariables; i++) {
  606.                 Variables[i] = new SymVariable(VariablePointers[i]);
  607.             }
  608.            
  609.             return Variables;
  610.         }
  611.        
  612.         public ISymbolNamespace GetNamespace()
  613.         {
  614.             int hr;
  615.             IntPtr pNamespace;
  616.             COMException Exception;
  617.             hr = SymMethod_GetNamespace(m_Method, out pNamespace);
  618.             if (hr < 0) {
  619.                 Exception = new COMException("Call to GetNamespace failed.", hr);
  620.                 throw Exception;
  621.             }
  622.             return new SymNamespace(pNamespace);
  623.         }
  624.        
  625.         public bool GetSourceStartEnd(ISymbolDocument[] docs, int[] lines, int[] columns)
  626.         {
  627.             int hr;
  628.             uint i;
  629.             bool pRetVal;
  630.             int spCount = 0;
  631.             if (docs != null)
  632.                 spCount = docs.Length;
  633.             else if (lines != null)
  634.                 spCount = lines.Length;
  635.             else if (columns != null)
  636.                 spCount = columns.Length;
  637.            
  638.             // If we don't have at least 2 entries then return an error
  639.             if (spCount < 2)
  640.                 throw new ArgumentException();
  641.            
  642.             // Make sure all arrays are the same length.
  643.             if ((docs != null) && (spCount != docs.Length))
  644.                 throw new ArgumentException();
  645.            
  646.             if ((lines != null) && (spCount != lines.Length))
  647.                 throw new ArgumentException();
  648.            
  649.             if ((columns != null) && (spCount != columns.Length))
  650.                 throw new ArgumentException();
  651.            
  652.             COMException Exception;
  653.             IntPtr[] Documents = new IntPtr[docs.Length];
  654.             hr = SymMethod_GetSourceStartEnd(m_Method, Documents, lines, columns, out pRetVal);
  655.             if (hr < 0) {
  656.                 Exception = new COMException("Call to GetSourceStartEnd failed.", hr);
  657.                 throw Exception;
  658.             }
  659.             if (pRetVal) {
  660.                 for (i = 0; i < docs.Length; i++) {
  661.                     docs[i] = new SymDocument(Documents[i]);
  662.                 }
  663.             }
  664.             return pRetVal;
  665.            
  666.         }
  667.     }
  668.    
  669.     //-----------------------------------------------------------------------
  670.     // SymReader
  671.     //-----------------------------------------------------------------------
  672.     public class SymReader : ISymbolReader
  673.     {
  674.        
  675.         private IntPtr m_Reader;
  676.         // Unmanaged Reader pointer
  677.         [DllImport(CreateSymClass.NATIVE_DLL)]
  678.         static extern int SymReader_Release(IntPtr Reader);
  679.        
  680.         [DllImport(CreateSymClass.NATIVE_DLL)]
  681.         static extern int SymReader_GetUserEntryPoint(IntPtr Reader, out int EntryPoint);
  682.        
  683.         [DllImport(CreateSymClass.NATIVE_DLL)]
  684.         static extern int SymReader_GetDocuments(IntPtr Reader, int cDocs, out int pcDocs,         [In()]
  685. IntPtr[] pDocs);
  686.        
  687.         [DllImport(CreateSymClass.NATIVE_DLL)]
  688.         static extern int SymReader_GetDocument(IntPtr Reader,         [MarshalAs(UnmanagedType.LPWStr)]
  689. string Url, Guid Language, Guid LanguageVendor, Guid DocumentType, out IntPtr Document);
  690.        
  691.         [DllImport(CreateSymClass.NATIVE_DLL)]
  692.         static extern int SymReader_GetMethod(IntPtr Reader, int MethodToken, out IntPtr Document);
  693.        
  694.         [DllImport(CreateSymClass.NATIVE_DLL)]
  695.         static extern int SymReader_GetMethodByVersion(IntPtr Reader, int MethodToken, int Version, out IntPtr Document);
  696.        
  697.         [DllImport(CreateSymClass.NATIVE_DLL)]
  698.         static extern int SymReader_GetVariables(IntPtr Reader, int ParentToken, int cVars, out int pcVars,         [In()]
  699. IntPtr[] Variables);
  700.        
  701.         [DllImport(CreateSymClass.NATIVE_DLL)]
  702.         static extern int SymReader_GetGlobalVariables(IntPtr Reader, int cVars, out int pcVars,         [In()]
  703. IntPtr[] Variables);
  704.        
  705.         [DllImport(CreateSymClass.NATIVE_DLL)]
  706.         static extern int SymReader_GetMethodFromDocumentPosition(IntPtr Reader, IntPtr Document, int line, int column, out IntPtr MethodPointer);
  707.        
  708.         [DllImport(CreateSymClass.NATIVE_DLL)]
  709.         static extern int SymReader_GetSymAttribute(IntPtr Reader, int parentToken,         [MarshalAs(UnmanagedType.LPWStr)]
  710. string name, int cBuffer, out int pcBuffer, byte[] buffer);
  711.        
  712.         [DllImport(CreateSymClass.NATIVE_DLL)]
  713.         static extern int SymReader_GetNamespaces(IntPtr Reader, int cNamespaces, out int pcNamespaces,         [In()]
  714. IntPtr[] NamespacePointers);
  715.        
  716.         //
  717.         // Implementation
  718.         //
  719.         public SymReader(IntPtr Reader)
  720.         {
  721.             m_Reader = Reader;
  722.         }
  723.        
  724.         ~SymReader()
  725.         {
  726.             SymReader_Release(m_Reader);
  727.         }
  728.        
  729.         public SymbolToken UserEntryPoint {
  730.             get {
  731.                 COMException Exception;
  732.                 int hr;
  733.                 int EntryPoint;
  734.                 hr = SymReader_GetUserEntryPoint(m_Reader, out EntryPoint);
  735.                 if (hr < 0) {
  736.                     Exception = new COMException("Call to GetUserEntryPoint failed.", hr);
  737.                     throw Exception;
  738.                 }
  739.                
  740.                 SymbolToken t = new SymbolToken(EntryPoint);
  741.                 return t;
  742.             }
  743.         }
  744.        
  745.         public ISymbolDocument[] GetDocuments()
  746.         {
  747.             COMException Exception;
  748.             int hr;
  749.             uint i;
  750.             int cDocs;
  751.             IntPtr[] DocumentPointers;
  752.             SymDocument[] Documents;
  753.             hr = SymReader_GetDocuments(m_Reader, 0, out cDocs, null);
  754.             if (hr < 0) {
  755.                 Exception = new COMException("Call to GetDocuments failed.", hr);
  756.                 throw Exception;
  757.             }
  758.             DocumentPointers = new IntPtr[cDocs];
  759.             Documents = new SymDocument[cDocs];
  760.             hr = SymReader_GetDocuments(m_Reader, cDocs, out cDocs, DocumentPointers);
  761.             if (hr < 0) {
  762.                 Exception = new COMException("Call to GetDocuments failed.", hr);
  763.                 throw Exception;
  764.             }
  765.            
  766.             for (i = 0; i < cDocs; i++) {
  767.                 Documents[i] = new SymDocument(DocumentPointers[i]);
  768.             }
  769.            
  770.             return Documents;
  771.         }
  772.        
  773.         public ISymbolDocument GetDocument(string url, Guid language, Guid languageVendor, Guid documentType)
  774.         {
  775.             COMException Exception;
  776.             int hr;
  777.             IntPtr DocumentPointer;
  778.             hr = SymReader_GetDocument(m_Reader, url, language, languageVendor, documentType, out DocumentPointer);
  779.             if (hr < 0) {
  780.                 Exception = new COMException("Call to GetDocument failed.", hr);
  781.                 throw Exception;
  782.             }
  783.             return new SymDocument(DocumentPointer);
  784.         }
  785.        
  786.         public ISymbolMethod GetMethod(SymbolToken method)
  787.         {
  788.             COMException Exception;
  789.             int hr;
  790.             IntPtr MethodPointer;
  791.             hr = SymReader_GetMethod(m_Reader, method.GetToken(), out MethodPointer);
  792.             if (hr < 0) {
  793.                 Exception = new COMException("Call to GetMethod failed.", hr);
  794.                 throw Exception;
  795.             }
  796.             return new SymMethod(MethodPointer);
  797.         }
  798.        
  799.         public ISymbolMethod GetMethod(SymbolToken method, int version)
  800.         {
  801.             COMException Exception;
  802.             int hr;
  803.             IntPtr MethodPointer;
  804.             hr = SymReader_GetMethodByVersion(m_Reader, method.GetToken(), version, out MethodPointer);
  805.             if (hr < 0) {
  806.                 Exception = new COMException("Call to GetMethodByVersion failed.", hr);
  807.                 throw Exception;
  808.             }
  809.             return new SymMethod(MethodPointer);
  810.         }
  811.        
  812.         public ISymbolVariable[] GetVariables(SymbolToken parent)
  813.         {
  814.             COMException Exception;
  815.             int hr;
  816.             IntPtr[] VariablePointers;
  817.             SymVariable[] Variables;
  818.             int cVars;
  819.             uint i;
  820.             hr = SymReader_GetVariables(m_Reader, parent.GetToken(), 0, out cVars, null);
  821.             if (hr < 0) {
  822.                 Exception = new COMException("Call to GetVariables failed.", hr);
  823.                 throw Exception;
  824.             }
  825.             Variables = new SymVariable[cVars];
  826.             VariablePointers = new IntPtr[cVars];
  827.            
  828.             hr = SymReader_GetVariables(m_Reader, parent.GetToken(), cVars, out cVars, VariablePointers);
  829.             if (hr < 0) {
  830.                 Exception = new COMException("Call to GetVariables failed.", hr);
  831.                 throw Exception;
  832.             }
  833.             for (i = 0; i < cVars; i++) {
  834.                 Variables[i] = new SymVariable(VariablePointers[i]);
  835.             }
  836.             return Variables;
  837.         }
  838.        
  839.         public ISymbolVariable[] GetGlobalVariables()
  840.         {
  841.             COMException Exception;
  842.             int hr;
  843.             IntPtr[] VariablePointers;
  844.             SymVariable[] Variables;
  845.             int cVars;
  846.             uint i;
  847.             hr = SymReader_GetGlobalVariables(m_Reader, 0, out cVars, null);
  848.             if (hr < 0) {
  849.                 Exception = new COMException("Call to GetGlobalVariables failed.", hr);
  850.                 throw Exception;
  851.             }
  852.             Variables = new SymVariable[cVars];
  853.             VariablePointers = new IntPtr[cVars];
  854.            
  855.             hr = SymReader_GetGlobalVariables(m_Reader, cVars, out cVars, VariablePointers);
  856.             if (hr < 0) {
  857.                 Exception = new COMException("Call to GetGlobalVariables failed.", hr);
  858.                 throw Exception;
  859.             }
  860.             for (i = 0; i < cVars; i++) {
  861.                 Variables[i] = new SymVariable(VariablePointers[i]);
  862.             }
  863.             return Variables;
  864.         }
  865.        
  866.         public ISymbolMethod GetMethodFromDocumentPosition(ISymbolDocument document, int line, int column)
  867.         {
  868.             COMException Exception;
  869.             int hr;
  870.             IntPtr MethodPointer;
  871.             hr = SymReader_GetMethodFromDocumentPosition(m_Reader, ((SymDocument)document).InternalDocument, line, column, out MethodPointer);
  872.             if (hr < 0) {
  873.                 Exception = new COMException("Call to GetMethodFromDocumentPosition failed.", hr);
  874.                 throw Exception;
  875.             }
  876.             return new SymMethod(MethodPointer);
  877.         }
  878.        
  879.         public byte[] GetSymAttribute(SymbolToken parent, string name)
  880.         {
  881.             COMException Exception;
  882.             int hr;
  883.             int cBuffer;
  884.             byte[] Buffer;
  885.             hr = SymReader_GetSymAttribute(m_Reader, parent.GetToken(), name, 0, out cBuffer, null);
  886.             if (hr < 0) {
  887.                 Exception = new COMException("Call to GetSymAttribute failed.", hr);
  888.                 throw Exception;
  889.             }
  890.             Buffer = new byte[cBuffer];
  891.             hr = SymReader_GetSymAttribute(m_Reader, parent.GetToken(), name, cBuffer, out cBuffer, Buffer);
  892.             if (hr < 0) {
  893.                 Exception = new COMException("Call to GetSymAttribute failed.", hr);
  894.                 throw Exception;
  895.             }
  896.             return Buffer;
  897.         }
  898.        
  899.         public ISymbolNamespace[] GetNamespaces()
  900.         {
  901.             COMException Exception;
  902.             int hr;
  903.             uint i;
  904.             int cNamespaces;
  905.             IntPtr[] NamespacePointers;
  906.             SymNamespace[] Namespaces;
  907.             hr = SymReader_GetNamespaces(m_Reader, 0, out cNamespaces, null);
  908.             if (hr < 0) {
  909.                 Exception = new COMException("Call to GetNamespaces failed.", hr);
  910.                 throw Exception;
  911.             }
  912.             NamespacePointers = new IntPtr[cNamespaces];
  913.             Namespaces = new SymNamespace[cNamespaces];
  914.             hr = SymReader_GetNamespaces(m_Reader, cNamespaces, out cNamespaces, NamespacePointers);
  915.             if (hr < 0) {
  916.                 Exception = new COMException("Call to GetNamespaces failed.", hr);
  917.                 throw Exception;
  918.             }
  919.             for (i = 0; i < cNamespaces; i++) {
  920.                 Namespaces[i] = new SymNamespace(NamespacePointers[i]);
  921.             }
  922.             return Namespaces;
  923.         }
  924.     }
  925.    
  926.     //-----------------------------------------------------------------------
  927.     // SymScope
  928.     //-----------------------------------------------------------------------
  929.     public class SymScope : ISymbolScope
  930.     {
  931.        
  932.         private IntPtr m_Scope;
  933.         // Unmanaged scope pointer
  934.         [DllImport(CreateSymClass.NATIVE_DLL)]
  935.         static extern int SymScope_Release(IntPtr Variable);
  936.        
  937.         [DllImport(CreateSymClass.NATIVE_DLL)]
  938.         static extern int SymScope_GetStartOffset(IntPtr Scope, out int pRetVal);
  939.        
  940.         [DllImport(CreateSymClass.NATIVE_DLL)]
  941.         static extern int SymScope_GetEndOffset(IntPtr Scope, out int pRetVal);
  942.        
  943.         [DllImport(CreateSymClass.NATIVE_DLL)]
  944.         static extern int SymScope_GetMethod(IntPtr Scope, out IntPtr Method);
  945.        
  946.         [DllImport(CreateSymClass.NATIVE_DLL)]
  947.         static extern int SymScope_GetParent(IntPtr Scope, out IntPtr ParentScope);
  948.        
  949.         [DllImport(CreateSymClass.NATIVE_DLL)]
  950.         static extern int SymScope_GetChildren(IntPtr Scope, int cChildren, out int pcChildren,         [In()]
  951. IntPtr[] ScopePointers);
  952.        
  953.         [DllImport(CreateSymClass.NATIVE_DLL)]
  954.         static extern int SymScope_GetLocals(IntPtr Scope, int cVariables, out int pcVariables,         [In()]
  955. IntPtr[] VariablePointers);
  956.        
  957.         [DllImport(CreateSymClass.NATIVE_DLL)]
  958.         static extern int SymScope_GetNamespaces(IntPtr Scope, int cNamespaces, out int pcNamespaces,         [In()]
  959. IntPtr[] NamespacePointers);
  960.        
  961.         //
  962.         // Implementation
  963.         //
  964.         public SymScope(IntPtr pScope)
  965.         {
  966.             m_Scope = pScope;
  967.         }
  968.        
  969.         ~SymScope()
  970.         {
  971.             SymScope_Release(m_Scope);
  972.         }
  973.        
  974.         public int StartOffset {
  975.             get {
  976.                 int hr;
  977.                 COMException Exception;
  978.                 int RetVal;
  979.                 hr = SymScope_GetStartOffset(m_Scope, out RetVal);
  980.                 if (hr < 0) {
  981.                     Exception = new COMException("Call to GetStartOffset failed.", hr);
  982.                     throw Exception;
  983.                 }
  984.                 return RetVal;
  985.             }
  986.         }
  987.        
  988.         public int EndOffset {
  989.             get {
  990.                 int hr;
  991.                 COMException Exception;
  992.                 int RetVal;
  993.                 hr = SymScope_GetEndOffset(m_Scope, out RetVal);
  994.                 if (hr < 0) {
  995.                     Exception = new COMException("Call to GetEndOffset failed.", hr);
  996.                     throw Exception;
  997.                 }
  998.                 return RetVal;
  999.             }
  1000.         }
  1001.        
  1002.         public ISymbolMethod Method {
  1003.             get {
  1004.                 COMException Exception;
  1005.                 int hr;
  1006.                 IntPtr MethodPointer;
  1007.                 hr = SymScope_GetMethod(m_Scope, out MethodPointer);
  1008.                 if (hr < 0) {
  1009.                     Exception = new COMException("Call to GetMethod failed.", hr);
  1010.                     throw Exception;
  1011.                 }
  1012.                 return new SymMethod(MethodPointer);
  1013.             }
  1014.         }
  1015.         public ISymbolScope Parent {
  1016.             get {
  1017.                 COMException Exception;
  1018.                 int hr;
  1019.                 IntPtr ScopePointer;
  1020.                 hr = SymScope_GetParent(m_Scope, out ScopePointer);
  1021.                 if (hr < 0) {
  1022.                     Exception = new COMException("Call to GetParent failed.", hr);
  1023.                     throw Exception;
  1024.                 }
  1025.                 return new SymScope(ScopePointer);
  1026.             }
  1027.         }
  1028.        
  1029.         public ISymbolScope[] GetChildren()
  1030.         {
  1031.             COMException Exception;
  1032.             int hr;
  1033.             uint i;
  1034.             int cChildren;
  1035.             IntPtr[] ChildrenPointers;
  1036.             SymScope[] Children;
  1037.             hr = SymScope_GetChildren(m_Scope, 0, out cChildren, null);
  1038.             if (hr < 0) {
  1039.                 Exception = new COMException("Call to GetChildren failed.", hr);
  1040.                 throw Exception;
  1041.             }
  1042.             ChildrenPointers = new IntPtr[cChildren];
  1043.             Children = new SymScope[cChildren];
  1044.             hr = SymScope_GetChildren(m_Scope, cChildren, out cChildren, ChildrenPointers);
  1045.             if (hr < 0) {
  1046.                 Exception = new COMException("Call to GetChildren failed.", hr);
  1047.                 throw Exception;
  1048.             }
  1049.             for (i = 0; i < cChildren; i++) {
  1050.                 Children[i] = new SymScope(ChildrenPointers[i]);
  1051.             }
  1052.             return Children;
  1053.         }
  1054.        
  1055.         public ISymbolVariable[] GetLocals()
  1056.         {
  1057.             COMException Exception;
  1058.             int hr;
  1059.             uint i;
  1060.             int cLocals;
  1061.             IntPtr[] LocalPointers;
  1062.             SymVariable[] Locals;
  1063.             hr = SymScope_GetLocals(m_Scope, 0, out cLocals, null);
  1064.             if (hr < 0) {
  1065.                 Exception = new COMException("Call to GetLocals failed.", hr);
  1066.                 throw Exception;
  1067.             }
  1068.             LocalPointers = new IntPtr[cLocals];
  1069.             Locals = new SymVariable[cLocals];
  1070.             hr = SymScope_GetLocals(m_Scope, cLocals, out cLocals, LocalPointers);
  1071.             if (hr < 0) {
  1072.                 Exception = new COMException("Call to GetLocals failed.", hr);
  1073.                 throw Exception;
  1074.             }
  1075.             for (i = 0; i < cLocals; i++) {
  1076.                 Locals[i] = new SymVariable(LocalPointers[i]);
  1077.             }
  1078.             return Locals;
  1079.         }
  1080.        
  1081.         public ISymbolNamespace[] GetNamespaces()
  1082.         {
  1083.             COMException Exception;
  1084.             int hr;
  1085.             uint i;
  1086.             int cNamespaces;
  1087.             IntPtr[] NamespacePointers;
  1088.             SymNamespace[] Namespaces;
  1089.             hr = SymScope_GetNamespaces(m_Scope, 0, out cNamespaces, null);
  1090.             if (hr < 0) {
  1091.                 Exception = new COMException("Call to GetNamespaces failed.", hr);
  1092.                 throw Exception;
  1093.             }
  1094.             NamespacePointers = new IntPtr[cNamespaces];
  1095.             Namespaces = new SymNamespace[cNamespaces];
  1096.             hr = SymScope_GetNamespaces(m_Scope, cNamespaces, out cNamespaces, NamespacePointers);
  1097.             if (hr < 0) {
  1098.                 Exception = new COMException("Call to GetNamespaces failed.", hr);
  1099.                 throw Exception;
  1100.             }
  1101.             for (i = 0; i < cNamespaces; i++) {
  1102.                 Namespaces[i] = new SymNamespace(NamespacePointers[i]);
  1103.             }
  1104.             return Namespaces;
  1105.         }
  1106.     }
  1107.    
  1108.     //-----------------------------------------------------------------------
  1109.     // SymVariable
  1110.     //-----------------------------------------------------------------------
  1111.     public class SymVariable : ISymbolVariable
  1112.     {
  1113.         private IntPtr m_Variable;
  1114.         // Unmanaged variable pointer
  1115.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1116.         static extern int SymVariable_Release(IntPtr Variable);
  1117.        
  1118.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1119.         static extern int SymVariable_GetAddressField1(IntPtr Variable, out int pRetVal);
  1120.        
  1121.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1122.         static extern int SymVariable_GetAddressField2(IntPtr Variable, out int pRetVal);
  1123.        
  1124.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1125.         static extern int SymVariable_GetAddressField3(IntPtr Variable, out int pRetVal);
  1126.        
  1127.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1128.         static extern int SymVariable_GetAddressKind(IntPtr Variable, out int pRetVal);
  1129.        
  1130.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1131.         static extern int SymVariable_GetAttributes(IntPtr Variable, out int pRetVal);
  1132.        
  1133.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1134.         static extern int SymVariable_GetStartOffset(IntPtr Variable, out int pRetVal);
  1135.        
  1136.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1137.         static extern int SymVariable_GetEndOffset(IntPtr Variable, out int pRetVal);
  1138.        
  1139.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1140.         static extern int SymVariable_GetName(IntPtr Variable, int cchName, out int pcchName, StringBuilder szName);
  1141.        
  1142.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1143.         static extern int SymVariable_GetSignature(IntPtr Variable, int cSig, out int pcSig,         [In()]
  1144. byte[] sig);
  1145.        
  1146.         //
  1147.         // Implementation
  1148.         //
  1149.         public SymVariable(IntPtr pVariable)
  1150.         {
  1151.             m_Variable = pVariable;
  1152.         }
  1153.        
  1154.         ~SymVariable()
  1155.         {
  1156.             SymVariable_Release(m_Variable);
  1157.         }
  1158.        
  1159.         public int AddressField1 {
  1160.             get {
  1161.                 int hr;
  1162.                 COMException Exception;
  1163.                 int RetVal;
  1164.                 hr = SymVariable_GetAddressField1(m_Variable, out RetVal);
  1165.                 if (hr < 0) {
  1166.                     Exception = new COMException("Call to GetAddressField1 failed.", hr);
  1167.                     throw Exception;
  1168.                 }
  1169.                 return RetVal;
  1170.             }
  1171.         }
  1172.         public int AddressField2 {
  1173.             get {
  1174.                 int hr;
  1175.                 COMException Exception;
  1176.                 int RetVal;
  1177.                 hr = SymVariable_GetAddressField2(m_Variable, out RetVal);
  1178.                 if (hr < 0) {
  1179.                     Exception = new COMException("Call to GetAddressField2 failed.", hr);
  1180.                     throw Exception;
  1181.                 }
  1182.                 return RetVal;
  1183.             }
  1184.         }
  1185.         public int AddressField3 {
  1186.             get {
  1187.                 int hr;
  1188.                 COMException Exception;
  1189.                 int RetVal;
  1190.                 hr = SymVariable_GetAddressField3(m_Variable, out RetVal);
  1191.                 if (hr < 0) {
  1192.                     Exception = new COMException("Call to GetAddressField3 failed.", hr);
  1193.                     throw Exception;
  1194.                 }
  1195.                 return RetVal;
  1196.             }
  1197.         }
  1198.         public SymAddressKind AddressKind {
  1199.             get {
  1200.                 int hr;
  1201.                 COMException Exception;
  1202.                 int RetVal;
  1203.                 SymAddressKind ret = SymAddressKind.ILOffset;
  1204.                 hr = SymVariable_GetAddressKind(m_Variable, out RetVal);
  1205.                 if (hr < 0) {
  1206.                     Exception = new COMException("Call to GetAddressKind failed.", hr);
  1207.                     throw Exception;
  1208.                 }
  1209.                 switch (RetVal) {
  1210.                     case 1:
  1211.                         ret = SymAddressKind.ILOffset;
  1212.                         break;
  1213.                     case 2:
  1214.                         ret = SymAddressKind.NativeRVA;
  1215.                         break;
  1216.                     case 3:
  1217.                         ret = SymAddressKind.NativeRegister;
  1218.                         break;
  1219.                     case 4:
  1220.                         ret = SymAddressKind.NativeRegisterRelative;
  1221.                         break;
  1222.                     case 5:
  1223.                         ret = SymAddressKind.NativeOffset;
  1224.                         break;
  1225.                     case 6:
  1226.                         ret = SymAddressKind.NativeRegisterRegister;
  1227.                         break;
  1228.                     case 7:
  1229.                         ret = SymAddressKind.NativeRegisterStack;
  1230.                         break;
  1231.                     case 8:
  1232.                         ret = SymAddressKind.NativeStackRegister;
  1233.                         break;
  1234.                     case 9:
  1235.                         ret = SymAddressKind.BitField;
  1236.                         break;
  1237.                 }
  1238.                 return ret;
  1239.             }
  1240.         }
  1241.         public object Attributes {
  1242.             get {
  1243.                 int hr;
  1244.                 COMException Exception;
  1245.                 int RetVal;
  1246.                 object Attribute;
  1247.                 hr = SymVariable_GetAttributes(m_Variable, out RetVal);
  1248.                 if (hr < 0) {
  1249.                     Exception = new COMException("Call to GetAttributes failed.", hr);
  1250.                     throw Exception;
  1251.                 }
  1252.                 Attribute = (object)RetVal;
  1253.                 return Attribute;
  1254.             }
  1255.         }
  1256.        
  1257.         public int StartOffset {
  1258.             get {
  1259.                 int hr;
  1260.                 COMException Exception;
  1261.                 int RetVal;
  1262.                 hr = SymVariable_GetStartOffset(m_Variable, out RetVal);
  1263.                 if (hr < 0) {
  1264.                     Exception = new COMException("Call to GetStartOffset failed.", hr);
  1265.                     throw Exception;
  1266.                 }
  1267.                 return RetVal;
  1268.             }
  1269.         }
  1270.        
  1271.         public int EndOffset {
  1272.             get {
  1273.                 int hr;
  1274.                 COMException Exception;
  1275.                 int RetVal;
  1276.                 hr = SymVariable_GetEndOffset(m_Variable, out RetVal);
  1277.                 if (hr < 0) {
  1278.                     Exception = new COMException("Call to GetEndOffset failed.", hr);
  1279.                     throw Exception;
  1280.                 }
  1281.                 return RetVal;
  1282.             }
  1283.         }
  1284.        
  1285.         public string Name {
  1286.             get {
  1287.                 int hr;
  1288.                 StringBuilder Name;
  1289.                 int cchName;
  1290.                 COMException Exception;
  1291.                 hr = SymVariable_GetName(m_Variable, 0, out cchName, null);
  1292.                 if (hr < 0) {
  1293.                     Exception = new COMException("Call to GetName failed.", hr);
  1294.                     throw Exception;
  1295.                 }
  1296.                 Name = new StringBuilder(cchName);
  1297.                 hr = SymVariable_GetName(m_Variable, cchName, out cchName, Name);
  1298.                 if (hr < 0) {
  1299.                     Exception = new COMException("Call to GetName failed.", hr);
  1300.                     throw Exception;
  1301.                 }
  1302.                 return Name.ToString();
  1303.             }
  1304.         }
  1305.        
  1306.         public byte[] GetSignature()
  1307.         {
  1308.             int hr;
  1309.             byte[] Data;
  1310.             COMException Exception;
  1311.             int cData;
  1312.             hr = SymVariable_GetSignature(m_Variable, 0, out cData, null);
  1313.             if (hr < 0) {
  1314.                 Exception = new COMException("Call to GetSignature failed.", hr);
  1315.                 throw Exception;
  1316.             }
  1317.             Data = new byte[cData];
  1318.             hr = SymVariable_GetSignature(m_Variable, cData, out cData, Data);
  1319.             if (hr < 0) {
  1320.                 Exception = new COMException("Call to GetSignature failed.", hr);
  1321.                 throw Exception;
  1322.             }
  1323.             return Data;
  1324.         }
  1325.     }
  1326.    
  1327.     //-----------------------------------------------------------------------
  1328.     // SymNamespace
  1329.     //-----------------------------------------------------------------------
  1330.     public class SymNamespace : ISymbolNamespace
  1331.     {
  1332.         private IntPtr m_Namespace;
  1333.         // unmanaged namespace pointer
  1334.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1335.         static extern int SymNamespace_Release(IntPtr Namespace);
  1336.        
  1337.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1338.         static extern int SymNamespace_GetNamespaces(IntPtr Namespace, int cNamespaces, out int pcNamespaces,         [In()]
  1339. IntPtr[] NamespacePointers);
  1340.        
  1341.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1342.         static extern int SymNamespace_GetVariables(IntPtr Namespace, int cVariables, out int pcVariables,         [In()]
  1343. IntPtr[] VariablePointers);
  1344.        
  1345.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1346.         static extern int SymNamespace_GetName(IntPtr Namespace, int cchName, out int pcchName, StringBuilder szName);
  1347.        
  1348.         //
  1349.         // Implementation
  1350.         //
  1351.        
  1352.         // Constructor
  1353.         public SymNamespace(IntPtr pNamespace)
  1354.         {
  1355.             m_Namespace = pNamespace;
  1356.         }
  1357.        
  1358.         // Destructor
  1359.         ~SymNamespace()
  1360.         {
  1361.             SymNamespace_Release(m_Namespace);
  1362.         }
  1363.        
  1364.         public ISymbolNamespace[] GetNamespaces()
  1365.         {
  1366.             COMException Exception;
  1367.             int hr;
  1368.             uint i;
  1369.             int cNamespaces;
  1370.             IntPtr[] NamespacePointers;
  1371.             SymNamespace[] Namespaces;
  1372.             hr = SymNamespace_GetNamespaces(m_Namespace, 0, out cNamespaces, null);
  1373.             if (hr < 0) {
  1374.                 Exception = new COMException("Call to GetNamespaces failed.", hr);
  1375.                 throw Exception;
  1376.             }
  1377.             NamespacePointers = new IntPtr[cNamespaces];
  1378.             Namespaces = new SymNamespace[cNamespaces];
  1379.             hr = SymNamespace_GetNamespaces(m_Namespace, cNamespaces, out cNamespaces, NamespacePointers);
  1380.             if (hr < 0) {
  1381.                 Exception = new COMException("Call to GetNamespaces failed.", hr);
  1382.                 throw Exception;
  1383.             }
  1384.             for (i = 0; i < cNamespaces; i++) {
  1385.                 Namespaces[i] = new SymNamespace(NamespacePointers[i]);
  1386.             }
  1387.             return Namespaces;
  1388.         }
  1389.        
  1390.         public ISymbolVariable[] GetVariables()
  1391.         {
  1392.             COMException Exception;
  1393.             int hr;
  1394.             IntPtr[] VariablePointers;
  1395.             SymVariable[] Variables;
  1396.             int cVars;
  1397.             uint i;
  1398.             hr = SymNamespace_GetVariables(m_Namespace, 0, out cVars, null);
  1399.             if (hr < 0) {
  1400.                 Exception = new COMException("Call to GetVariables failed.", hr);
  1401.                 throw Exception;
  1402.             }
  1403.             Variables = new SymVariable[cVars];
  1404.             VariablePointers = new IntPtr[cVars];
  1405.            
  1406.             hr = SymNamespace_GetVariables(m_Namespace, cVars, out cVars, VariablePointers);
  1407.             if (hr < 0) {
  1408.                 Exception = new COMException("Call to GetVariables failed.", hr);
  1409.                 throw Exception;
  1410.             }
  1411.             for (i = 0; i < cVars; i++) {
  1412.                 Variables[i] = new SymVariable(VariablePointers[i]);
  1413.             }
  1414.             return Variables;
  1415.         }
  1416.        
  1417.         public string Name {
  1418.             get {
  1419.                 int hr;
  1420.                 StringBuilder Name;
  1421.                 int cchName;
  1422.                 COMException Exception;
  1423.                 hr = SymNamespace_GetName(m_Namespace, 0, out cchName, null);
  1424.                 if (hr < 0) {
  1425.                     Exception = new COMException("Call to GetName failed.", hr);
  1426.                     throw Exception;
  1427.                 }
  1428.                 Name = new StringBuilder(cchName);
  1429.                 hr = SymNamespace_GetName(m_Namespace, cchName, out cchName, Name);
  1430.                 if (hr < 0) {
  1431.                     Exception = new COMException("Call to GetName failed.", hr);
  1432.                     throw Exception;
  1433.                 }
  1434.                 return Name.ToString();
  1435.             }
  1436.         }
  1437.     }
  1438.    
  1439.     //-----------------------------------------------------------------------
  1440.     // SymWriter
  1441.     //-----------------------------------------------------------------------
  1442.     public class SymWriter : ISymbolWriter
  1443.     {
  1444.        
  1445.         private IntPtr m_Writer;
  1446.         // unmanaged writer pointer
  1447.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1448.         static extern int SymWriter_Release(IntPtr Writer);
  1449.        
  1450.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1451.         static extern int SymWriter_GetWriter(IntPtr ppWriter, out IntPtr Writer);
  1452.        
  1453.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1454.         static extern int SymWriter_Initialize(IntPtr Writer, IntPtr emitter,         [MarshalAs(UnmanagedType.LPWStr)]
  1455. string szFilename, bool fullBuild);
  1456.        
  1457.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1458.         static extern int SymWriter_DefineDocument(IntPtr Writer,         [MarshalAs(UnmanagedType.LPWStr)]
  1459. string szUrl,         [In()]
  1460. ref Guid pLanguage,         [In()]
  1461. ref Guid pLanguageVendor,         [In()]
  1462. ref Guid pDocumentType, out IntPtr pDocumentWriter);
  1463.        
  1464.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1465.         static extern int SymWriter_SetUserEntryPoint(IntPtr Writer, int Token);
  1466.        
  1467.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1468.         static extern int SymWriter_OpenMethod(IntPtr Writer, int Token);
  1469.        
  1470.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1471.         static extern int SymWriter_CloseMethod(IntPtr Writer);
  1472.        
  1473.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1474.         static extern int SymWriter_DefineSequencePoints(IntPtr Writer, IntPtr document, int spCount,         [In()]
  1475. int[] offsets,         [In()]
  1476. int[] lines,         [In()]
  1477. int[] columns,         [In()]
  1478. int[] endLines,         [In()]
  1479. int[] endColumns);
  1480.        
  1481.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1482.         static extern int SymWriter_OpenScope(IntPtr Writer, int startOffset, out int pScopeId);
  1483.        
  1484.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1485.         static extern int SymWriter_CloseScope(IntPtr Writer, int endOffset);
  1486.        
  1487.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1488.         static extern int SymWriter_SetScopeRange(IntPtr Writer, int scopeID, int startOffset, int endOffset);
  1489.        
  1490.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1491.         static extern int SymWriter_DefineLocalVariable(IntPtr Writer,         [MarshalAs(UnmanagedType.LPWStr)]
  1492. string name, int attributes, int cSig, byte[] signature, int addrKind, int addr1, int addr2, int addr3, int startOffset,
  1493.         int endOffset);
  1494.        
  1495.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1496.         static extern int SymWriter_DefineParameter(IntPtr Writer,         [MarshalAs(UnmanagedType.LPWStr)]
  1497. string name, int attributes, int sequence, int addrKind, int addr1, int addr2, int addr3);
  1498.        
  1499.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1500.         static extern int SymWriter_DefineField(IntPtr Writer, int ParentToken,         [MarshalAs(UnmanagedType.LPWStr)]
  1501. string name, int attributes, byte[] signature, int addrKind, int addr1, int addr2, int addr3);
  1502.        
  1503.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1504.         static extern int SymWriter_DefineGlobalVariable(IntPtr Writer,         [MarshalAs(UnmanagedType.LPWStr)]
  1505. string name, int attributes, byte[] signature, int cSig, int addrKind, int addr1, int addr2, int addr3);
  1506.        
  1507.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1508.         static extern int SymWriter_Close(IntPtr Writer);
  1509.        
  1510.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1511.         static extern int SymWriter_SetSymAttribute(IntPtr Writer, int parent,         [MarshalAs(UnmanagedType.LPWStr)]
  1512. string name, byte[] data);
  1513.        
  1514.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1515.         static extern int SymWriter_OpenNamespace(IntPtr Writer,         [MarshalAs(UnmanagedType.LPWStr)]
  1516. string name);
  1517.        
  1518.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1519.         static extern int SymWriter_CloseNamespace(IntPtr Writer);
  1520.        
  1521.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1522.         static extern int SymWriter_UsingNamespace(IntPtr Writer,         [MarshalAs(UnmanagedType.LPWStr)]
  1523. string fullName);
  1524.        
  1525.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1526.         static extern int SymWriter_SetMethodSourceRange(IntPtr Writer, IntPtr startDoc, int startLine, int startColumn, IntPtr endDoc, int endLine, int endColumn);
  1527.        
  1528.         // Guids for Unmanaged Writer
  1529.         static readonly Guid CLSID_CorSymWriter = new Guid(182640304, 63745, 18315, 187, 159, 136, 30, 232, 6, 103,
  1530.         136);
  1531.         static readonly Guid IID_ISymUnmanagedWriter = new Guid(3977554546u, 30946, 18564, 132, 226, 51, 66, 147, 174, 82,
  1532.         20);
  1533.        
  1534.         public SymWriter()
  1535.         {
  1536.             // Create an unmanaged binder
  1537.             m_Writer = CreateSymClass.CreateClass(CLSID_CorSymWriter, IID_ISymUnmanagedWriter);
  1538.         }
  1539.        
  1540.         ~SymWriter()
  1541.         {
  1542.             SymWriter_Release(m_Writer);
  1543.         }
  1544.        
  1545.         public void SetUnderlyingWriter(IntPtr underlyingWriter)
  1546.         {
  1547.             // Demand the permission to access unmanaged code. We do this since we are casting an int to a COM interface, and
  1548.             // this can be used improperly.
  1549.             (new SecurityPermission(SecurityPermissionFlag.UnmanagedCode)).Demand();
  1550.            
  1551.             int hr;
  1552.             COMException Exception;
  1553.             SymWriter_Release(m_Writer);
  1554.             hr = SymWriter_GetWriter(underlyingWriter, out m_Writer);
  1555.             if (hr < 0) {
  1556.                 Exception = new COMException("Call to GetWriter failed.", hr);
  1557.                 throw Exception;
  1558.             }
  1559.         }
  1560.        
  1561.        
  1562.         public void Initialize(IntPtr emitter, string filename, bool fullBuild)
  1563.         {
  1564.             COMException Exception;
  1565.             int hr;
  1566.            
  1567.             // Demand the permission to access unmanaged code. We do this since we are casting an int to a COM interface, and
  1568.             // this can be used improperly.
  1569.             (new SecurityPermission(SecurityPermissionFlag.UnmanagedCode)).Demand();
  1570.            
  1571.             hr = SymWriter_Initialize(m_Writer, emitter, filename, fullBuild);
  1572.             if (hr < 0) {
  1573.                 Exception = new COMException("Call to Initialize failed.", hr);
  1574.                 throw Exception;
  1575.             }
  1576.         }
  1577.        
  1578.         public ISymbolDocumentWriter DefineDocument(string url, Guid language, Guid languageVendor, Guid documentType)
  1579.         {
  1580.             int hr;
  1581.             IntPtr pDocumentWriter;
  1582.             SymDocumentWriter DocumentWriter;
  1583.             COMException Exception;
  1584.             hr = SymWriter_DefineDocument(m_Writer, url, ref language, ref languageVendor, ref documentType, out pDocumentWriter);
  1585.             if (hr < 0) {
  1586.                 Exception = new COMException("Call to DefineDocument failed.", hr);
  1587.                 throw Exception;
  1588.             }
  1589.             DocumentWriter = new SymDocumentWriter(pDocumentWriter);
  1590.             return DocumentWriter;
  1591.         }
  1592.        
  1593.         public void SetUserEntryPoint(SymbolToken entryMethod)
  1594.         {
  1595.             int hr;
  1596.             COMException Exception;
  1597.             hr = SymWriter_SetUserEntryPoint(m_Writer, entryMethod.GetToken());
  1598.             if (hr < 0) {
  1599.                 Exception = new COMException("Call to SetUserEntryPoint failed.", hr);
  1600.                 throw Exception;
  1601.             }
  1602.         }
  1603.        
  1604.         public void OpenMethod(SymbolToken method)
  1605.         {
  1606.             int hr;
  1607.             COMException Exception;
  1608.             hr = SymWriter_OpenMethod(m_Writer, method.GetToken());
  1609.             if (hr < 0) {
  1610.                 Exception = new COMException("Call to OpenMethod failed.", hr);
  1611.                 throw Exception;
  1612.             }
  1613.         }
  1614.        
  1615.         public void CloseMethod()
  1616.         {
  1617.             int hr;
  1618.             COMException Exception;
  1619.             hr = SymWriter_CloseMethod(m_Writer);
  1620.             if (hr < 0) {
  1621.                 Exception = new COMException("Call to CloseMethod failed.", hr);
  1622.                 throw Exception;
  1623.             }
  1624.         }
  1625.        
  1626.         public void DefineSequencePoints(ISymbolDocumentWriter document, int[] offsets, int[] lines, int[] columns, int[] endLines, int[] endColumns)
  1627.         {
  1628.             int hr;
  1629.             COMException Exception;
  1630.            
  1631.             int spCount = 0;
  1632.             if (offsets != null)
  1633.                 spCount = offsets.Length;
  1634.             else if (lines != null)
  1635.                 spCount = lines.Length;
  1636.             else if (columns != null)
  1637.                 spCount = columns.Length;
  1638.             else if (endLines != null)
  1639.                 spCount = endLines.Length;
  1640.             else if (endColumns != null)
  1641.                 spCount = endColumns.Length;
  1642.            
  1643.             // Don't do anything if they're not really asking for anything.
  1644.             if (spCount == 0)
  1645.                 return;
  1646.            
  1647.             // Make sure all arrays are the same length.
  1648.             if ((offsets != null) && (spCount != offsets.Length))
  1649.                 throw new ArgumentException();
  1650.            
  1651.             if ((lines != null) && (spCount != lines.Length))
  1652.                 throw new ArgumentException();
  1653.            
  1654.             if ((columns != null) && (spCount != columns.Length))
  1655.                 throw new ArgumentException();
  1656.            
  1657.             if ((endLines != null) && (spCount != endLines.Length))
  1658.                 throw new ArgumentException();
  1659.            
  1660.             if ((endColumns != null) && (spCount != endColumns.Length))
  1661.                 throw new ArgumentException();
  1662.            
  1663.             hr = SymWriter_DefineSequencePoints(m_Writer, ((SymDocumentWriter)document).InternalDocumentWriter, offsets.Length, offsets, lines, columns, endLines, endColumns);
  1664.            
  1665.             if (hr < 0) {
  1666.                 Exception = new COMException("Call to DefineSequencePoints failed.", hr);
  1667.                 throw Exception;
  1668.             }
  1669.         }
  1670.        
  1671.         public int OpenScope(int startOffset)
  1672.         {
  1673.             int hr;
  1674.             int ScopeId = 0;
  1675.             COMException Exception;
  1676.             hr = SymWriter_OpenScope(m_Writer, startOffset, out ScopeId);
  1677.             if (hr < 0) {
  1678.                 Exception = new COMException("Call to OpenScope failed.", hr);
  1679.                 throw Exception;
  1680.             }
  1681.             return ScopeId;
  1682.         }
  1683.        
  1684.         public void CloseScope(int endOffset)
  1685.         {
  1686.             int hr;
  1687.             COMException Exception;
  1688.             hr = SymWriter_CloseScope(m_Writer, endOffset);
  1689.             if (hr < 0) {
  1690.                 Exception = new COMException("Call to CloseScope failed.", hr);
  1691.                 throw Exception;
  1692.             }
  1693.         }
  1694.        
  1695.         public void SetScopeRange(int scopeID, int startOffset, int endOffset)
  1696.         {
  1697.             int hr;
  1698.             COMException Exception;
  1699.             hr = SymWriter_SetScopeRange(m_Writer, scopeID, startOffset, endOffset);
  1700.             if (hr < 0) {
  1701.                 Exception = new COMException("Call to SetScopeRange failed.", hr);
  1702.                 throw Exception;
  1703.             }
  1704.         }
  1705.        
  1706.         public void DefineLocalVariable(string name, FieldAttributes attributes, byte[] signature, SymAddressKind addrKind, int addr1, int addr2, int addr3, int startOffset, int endOffset)
  1707.         {
  1708.             int hr;
  1709.             COMException Exception;
  1710.             hr = SymWriter_DefineLocalVariable(m_Writer, name, (int)attributes, signature.Length, signature, (int)addrKind, addr1, addr2, addr3, startOffset,
  1711.             endOffset);
  1712.             if (hr < 0) {
  1713.                 Exception = new COMException("Call to DefineLocalVariable failed.", hr);
  1714.                 throw Exception;
  1715.             }
  1716.         }
  1717.        
  1718.         public void DefineParameter(string name, ParameterAttributes attributes, int sequence, SymAddressKind addrKind, int addr1, int addr2, int addr3)
  1719.         {
  1720.             int hr;
  1721.             COMException Exception;
  1722.             hr = SymWriter_DefineParameter(m_Writer, name, (int)attributes, sequence, (int)addrKind, addr1, addr2, addr3);
  1723.             if (hr < 0) {
  1724.                 Exception = new COMException("Call to DefineParameter failed.", hr);
  1725.                 throw Exception;
  1726.             }
  1727.         }
  1728.        
  1729.         public void DefineField(SymbolToken parent, string name, FieldAttributes attributes, byte[] signature, SymAddressKind addrKind, int addr1, int addr2, int addr3)
  1730.         {
  1731.             int hr;
  1732.             COMException Exception;
  1733.             hr = SymWriter_DefineField(m_Writer, parent.GetToken(), name, attributes.GetHashCode(), signature, (int)addrKind, addr1, addr2, addr3);
  1734.             if (hr < 0) {
  1735.                 Exception = new COMException("Call to DefineField failed.", hr);
  1736.                 throw Exception;
  1737.             }
  1738.         }
  1739.        
  1740.         public void DefineGlobalVariable(string name, FieldAttributes attributes, byte[] signature, SymAddressKind addrKind, int addr1, int addr2, int addr3)
  1741.         {
  1742.             int hr;
  1743.             COMException Exception;
  1744.             hr = SymWriter_DefineGlobalVariable(m_Writer, name, attributes.GetHashCode(), signature, signature.Length, addrKind.GetHashCode(), addr1, addr2, addr3);
  1745.             if (hr < 0) {
  1746.                 Exception = new COMException("Call to DefineGlobalVariable failed.", hr);
  1747.                 throw Exception;
  1748.             }
  1749.         }
  1750.        
  1751.         public void Close()
  1752.         {
  1753.             int hr;
  1754.             COMException Exception;
  1755.             hr = SymWriter_Close(m_Writer);
  1756.             if (hr < 0) {
  1757.                 Exception = new COMException("Call to Close failed.", hr);
  1758.                 throw Exception;
  1759.             }
  1760.         }
  1761.        
  1762.         public void SetSymAttribute(SymbolToken parent, string name, byte[] data)
  1763.         {
  1764.             int hr;
  1765.             COMException Exception;
  1766.             hr = SymWriter_SetSymAttribute(m_Writer, parent.GetToken(), name, data);
  1767.             if (hr < 0) {
  1768.                 Exception = new COMException("Call to SetSymAttribute failed.", hr);
  1769.                 throw Exception;
  1770.             }
  1771.         }
  1772.        
  1773.         public void OpenNamespace(string name)
  1774.         {
  1775.             int hr;
  1776.             COMException Exception;
  1777.             hr = SymWriter_OpenNamespace(m_Writer, name);
  1778.             if (hr < 0) {
  1779.                 Exception = new COMException("Call to OpenNamespace failed.", hr);
  1780.                 throw Exception;
  1781.             }
  1782.         }
  1783.        
  1784.         public void CloseNamespace()
  1785.         {
  1786.             int hr;
  1787.             COMException Exception;
  1788.             hr = SymWriter_CloseNamespace(m_Writer);
  1789.             if (hr < 0) {
  1790.                 Exception = new COMException("Call to CloseNamespace failed.", hr);
  1791.                 throw Exception;
  1792.             }
  1793.         }
  1794.        
  1795.         public void UsingNamespace(string fullName)
  1796.         {
  1797.             int hr;
  1798.             COMException Exception;
  1799.             hr = SymWriter_UsingNamespace(m_Writer, fullName);
  1800.             if (hr < 0) {
  1801.                 Exception = new COMException("Call to UsingNamespace failed.", hr);
  1802.                 throw Exception;
  1803.             }
  1804.         }
  1805.        
  1806.         public void SetMethodSourceRange(ISymbolDocumentWriter startDoc, int startLine, int startColumn, ISymbolDocumentWriter endDoc, int endLine, int endColumn)
  1807.         {
  1808.             int hr;
  1809.             COMException Exception;
  1810.             hr = SymWriter_SetMethodSourceRange(m_Writer, ((SymDocumentWriter)startDoc).InternalDocumentWriter, startLine, startColumn, ((SymDocumentWriter)endDoc).InternalDocumentWriter, endLine, endColumn);
  1811.             if (hr < 0) {
  1812.                 Exception = new COMException("Call to SetMethodSourceRange failed.", hr);
  1813.                 throw Exception;
  1814.             }
  1815.         }
  1816.     }
  1817.    
  1818.     //-----------------------------------------------------------------------
  1819.     // SymBinder
  1820.     //-----------------------------------------------------------------------
  1821.     public class SymBinder : ISymbolBinder
  1822.     {
  1823.         private IntPtr m_Binder;
  1824.         // unmanaged binder pointer
  1825.         // Import calls
  1826.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1827.         static extern int SymBinder_Release(IntPtr Binder);
  1828.        
  1829.         [DllImport(CreateSymClass.NATIVE_DLL)]
  1830.         static extern int SymBinder_GetReaderForFile(IntPtr Binder, int importer,         [MarshalAs(UnmanagedType.LPWStr)]
  1831. string filename,         [MarshalAs(UnmanagedType.LPWStr)]
  1832. string SearchPath, out IntPtr reader);
  1833.        
  1834.         // Guid for Unmanaged Binder
  1835.         static readonly Guid CLSID_CorSymBinder = new Guid(170524574, 32668, 17463, 139, 17, 244, 36, 73, 30, 57,
  1836.         49);
  1837.         static readonly Guid IID_ISymUnmanagedBinder = new Guid(2857651522u, 10443, 4563, 189, 34, 0, 0, 248, 8, 73,
  1838.         189);
  1839.        
  1840.         // Constructor
  1841.         public SymBinder()
  1842.         {
  1843.             // Create an unmanaged binder
  1844.             m_Binder = CreateSymClass.CreateClass(CLSID_CorSymBinder, IID_ISymUnmanagedBinder);
  1845.         }
  1846.        
  1847.         // Destructor
  1848.         ~SymBinder()
  1849.         {
  1850.             SymBinder_Release(m_Binder);
  1851.         }
  1852.        
  1853.         // Get a reader for the the file
  1854.         public ISymbolReader GetReader(int importer, string filename, string searchPath)
  1855.         {
  1856.            
  1857.             IntPtr Reader;
  1858.            
  1859.             // Demand the permission to access unmanaged code. We do this since we are casting an int to a COM interface, and
  1860.             // this can be used improperly.
  1861.             (new SecurityPermission(SecurityPermissionFlag.UnmanagedCode)).Demand();
  1862.            
  1863.             int hr;
  1864.             COMException Exception;
  1865.            
  1866.             hr = SymBinder_GetReaderForFile(m_Binder, importer, filename, searchPath, out Reader);
  1867.             if (hr < 0) {
  1868.                 Exception = new COMException("Call to GetReaderForFile failed.", hr);
  1869.                 throw Exception;
  1870.             }
  1871.            
  1872.             SymReader symReader = new SymReader(Reader);
  1873.             return symReader;
  1874.         }
  1875.     }
  1876. }

Developer Fusion