We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

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

SSCLI
  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. // ==--==
  16. using System;
  17. using System.Text;
  18. using System.Reflection;
  19. using System.Diagnostics;
  20. using System.Security.Permissions;
  21. using System.Diagnostics.SymbolStore;
  22. using System.Runtime.InteropServices;
  23. using Microsoft.Win32;
  25. namespace System.Diagnostics.SymbolStore
  26. {
  27.     internal sealed class Win32Native
  28.     {
  29.         #if !PLATFORM_UNIX
  30.         internal const string DLLPREFIX = "";
  31.         internal const string DLLSUFFIX = ".dll";
  32.         #else // !PLATFORM_UNIX
  33.         #if __APPLE__
  34.         internal const string DLLPREFIX = "lib";
  35.         internal const string DLLSUFFIX = ".dylib";
  36.         #else
  37.         internal const string DLLPREFIX = "lib";
  38.         internal const string DLLSUFFIX = ".so";
  39.         #endif
  40.         #endif // !PLATFORM_UNIX
  41.     }
  42.    
  43.     //
  44.     // Class to CoCreate a class via PInvoke and DllGetClassObject
  45.     //
  46.     class CreateSymClass
  47.     {
  48.         public const string NATIVE_DLL = Win32Native.DLLPREFIX + "ildbsymbols" + Win32Native.DLLSUFFIX;
  49.        
  50.         private static readonly Guid IID_IClassFactory = new Guid(1, 0, 0, 192, 0, 0, 0, 0, 0, 0,
  51.         70);
  52.        
  53.         [DllImport(NATIVE_DLL)]
  54.         static extern int DllGetClassObject(        [In()]
  55. ref Guid rclsid,         [In()]
  56. ref Guid riid, out IntPtr ClassObject);
  57.        
  58.         [DllImport(NATIVE_DLL)]
  59.         static extern int ClassFactory_CreateInstance(IntPtr classfactory,         [In()]
  60. ref Guid rclsid, out IntPtr ClassInstance);
  61.        
  62.         [DllImport(NATIVE_DLL)]
  63.         static extern void ClassFactory_Release(IntPtr classfactory);
  64.        
  65.         public static IntPtr CreateClass(Guid rclsid, Guid riid)
  66.         {
  67.             IntPtr classFactory;
  68.             IntPtr objCreatedObject;
  69.            
  70.             COMException Exception;
  71.             // Create a local copy so that we can pass it's reference
  72.             Guid IClassFactory = IID_IClassFactory;
  73.             int hr;
  74.             hr = DllGetClassObject(ref rclsid, ref IClassFactory, out classFactory);
  75.             try {
  76.                 if (hr < 0) {
  77.                     Exception = new COMException("Call to DllGetClassObject failed.", hr);
  78.                     throw Exception;
  79.                 }
  80.                 hr = ClassFactory_CreateInstance(classFactory, ref riid, out objCreatedObject);
  81.                 if (hr < 0) {
  82.                     Exception = new COMException("Call to CreateInstance failed.", hr);
  83.                     throw Exception;
  84.                 }
  85.             }
  86.             finally {
  87.                 ClassFactory_Release(classFactory);
  88.             }
  89.            
  90.             return objCreatedObject;
  91.         }
  92.     }
  93.    
  94.     //
  95.     // Document
  96.     //
  97.     public class SymDocument : ISymbolDocument
  98.     {
  99.        
  100.         private IntPtr m_Document;
  101.         // Unmanaged document pointer
  102.         [DllImport(CreateSymClass.NATIVE_DLL)]
  103.         static extern int SymDocument_Release(IntPtr DocumentWriter);
  104.        
  105.         [DllImport(CreateSymClass.NATIVE_DLL)]
  106.         static extern int SymDocument_GetCheckSum(IntPtr Document, int cData, out int pcData,         [In()]
  107. byte[] data);
  108.        
  109.         [DllImport(CreateSymClass.NATIVE_DLL)]
  110.         static extern int SymDocument_GetCheckSumAlgorithmId(IntPtr Document, out Guid pRetVal);
  111.        
  112.         [DllImport(CreateSymClass.NATIVE_DLL)]
  113.         static extern int SymDocument_GetDocumentType(IntPtr Document, out Guid pRetVal);
  114.        
  115.         [DllImport(CreateSymClass.NATIVE_DLL)]
  116.         static extern int SymDocument_GetLanguage(IntPtr Document, out Guid pRetVal);
  117.        
  118.         [DllImport(CreateSymClass.NATIVE_DLL)]
  119.         static extern int SymDocument_GetLanguageVendor(IntPtr Document, out Guid pRetVal);
  120.        
  121.         [DllImport(CreateSymClass.NATIVE_DLL)]
  122.         static extern int SymDocument_HasEmbeddedSource(IntPtr Document, out bool pRetVal);
  123.        
  124.         [DllImport(CreateSymClass.NATIVE_DLL)]
  125.         static extern int SymDocument_GetSourceLength(IntPtr Document, out int pRetVal);
  126.        
  127.         [DllImport(CreateSymClass.NATIVE_DLL)]
  128.         static extern int SymDocument_GetSourceRange(IntPtr Document, int startLine, int startColumn, int endLine, int endColumn, int cSourceBytes, out int pcSourceBytes,         [In()]
  129. byte[] source);
  130.        
  131.        
  132.         [DllImport(CreateSymClass.NATIVE_DLL)]
  133.         static extern int SymDocument_FindClosestLine(IntPtr Document, int line, out int pRetVal);
  134.        
  135.         [DllImport(CreateSymClass.NATIVE_DLL)]
  136.         static extern int SymDocument_GetUrl(IntPtr Document, int cchUrl, out int pcchUrl, StringBuilder szUrl);
  137.        
  138.        
  139.         //-----------------------------------------------------------------------
  140.         // SymDocument
  141.         //-----------------------------------------------------------------------
  142.        
  143.         public SymDocument(IntPtr pDocument)
  144.         {
  145.             m_Document = pDocument;
  146.         }
  147.        
  148.         ~SymDocument()
  149.         {
  150.             SymDocument_Release(m_Document);
  151.         }
  152.        
  153.         public byte[] GetCheckSum()
  154.         {
  155.             int hr;
  156.             byte[] Data;
  157.             COMException Exception;
  158.             int cData;
  159.             hr = SymDocument_GetCheckSum(m_Document, 0, out cData, null);
  160.             if (hr < 0) {
  161.                 Exception = new COMException("Call to GetCheckSum failed.", hr);
  162.                 throw Exception;
  163.             }
  164.             Data = new byte[cData];
  165.             hr = SymDocument_GetCheckSum(m_Document, cData, out cData, Data);
  166.             if (hr < 0) {
  167.                 Exception = new COMException("Call to GetCheckSum failed.", hr);
  168.                 throw Exception;
  169.             }
  170.             return Data;
  171.         }
  172.        
  173.         public Guid CheckSumAlgorithmId {
  174.             get {
  175.                 int hr;
  176.                 Guid AlgorigthId;
  177.                 COMException Exception;
  178.                 hr = SymDocument_GetCheckSumAlgorithmId(m_Document, out AlgorigthId);
  179.                 if (hr < 0) {
  180.                     Exception = new COMException("Call to GetCheckSumAlgorithmId failed.", hr);
  181.                     throw Exception;
  182.                 }
  183.                 return AlgorigthId;
  184.             }
  185.         }
  186.        
  187.         public Guid DocumentType {
  188.             get {
  189.                 int hr;
  190.                 Guid DocumentType;
  191.                 COMException Exception;
  192.                 hr = SymDocument_GetDocumentType(m_Document, out DocumentType);
  193.                 if (hr < 0) {
  194.                     Exception = new COMException("Call to GetDocumentType failed.", hr);
  195.                     throw Exception;
  196.                 }
  197.                 return DocumentType;
  198.             }
  199.         }
  200.        
  201.         public Guid Language {
  202.             get {
  203.                 int hr;
  204.                 Guid Language;
  205.                 COMException Exception;
  206.                 hr = SymDocument_GetLanguage(m_Document, out Language);
  207.                 if (hr < 0) {
  208.                     Exception = new COMException("Call to GetLanguage failed.", hr);
  209.                     throw Exception;
  210.                 }
  211.                 return Language;
  212.             }
  213.         }
  214.        
  215.         public Guid LanguageVendor {
  216.             get {
  217.                 int hr;
  218.                 Guid LanguageVendor;
  219.                 COMException Exception;
  220.                 hr = SymDocument_GetLanguageVendor(m_Document, out LanguageVendor);
  221.                 if (hr < 0) {
  222.                     Exception = new COMException("Call to GetLanguageVendor failed.", hr);
  223.                     throw Exception;
  224.                 }
  225.                 return LanguageVendor;
  226.             }
  227.         }
  228.        
  229.         public bool HasEmbeddedSource {
  230.             get {
  231.                 int hr;
  232.                 bool HasEmbeddedSource;
  233.                 COMException Exception;
  234.                 hr = SymDocument_HasEmbeddedSource(m_Document, out HasEmbeddedSource);
  235.                 if (hr < 0) {
  236.                     Exception = new COMException("Call to HasEmbeddedSource failed.", hr);
  237.                     throw Exception;
  238.                 }
  239.                 return HasEmbeddedSource;
  240.             }
  241.         }
  242.        
  243.         public int FindClosestLine(int line)
  244.         {
  245.             int hr;
  246.             int ClosestLine = 0;
  247.             COMException Exception;
  248.             hr = SymDocument_FindClosestLine(m_Document, line, out ClosestLine);
  249.             if (hr < 0) {
  250.                 Exception = new COMException("Call to FindClosestLine failed.", hr);
  251.                 throw Exception;
  252.             }
  253.             return ClosestLine;
  254.         }
  255.        
  256.         public byte[] GetSourceRange(int startLine, int startColumn, int endLine, int endColumn)
  257.         {
  258.             int hr;
  259.             byte[] Range;
  260.             int cSourceBytes;
  261.             COMException Exception;
  262.             hr = SymDocument_GetSourceRange(m_Document, startLine, startColumn, endLine, endColumn, 0, out cSourceBytes, null);
  263.             if (hr < 0) {
  264.                 Exception = new COMException("Call to GetSourceRange failed.", hr);
  265.                 throw Exception;
  266.             }
  267.             Range = new byte[cSourceBytes];
  268.             hr = SymDocument_GetSourceRange(m_Document, startLine, startColumn, endLine, endColumn, cSourceBytes, out cSourceBytes, Range);
  269.             if (hr < 0) {
  270.                 Exception = new COMException("Call to GetSourceRange failed.", hr);
  271.                 throw Exception;
  272.             }
  273.             return Range;
  274.         }
  275.        
  276.         public int SourceLength {
  277.             get {
  278.                 int hr;
  279.                 int SourceLength;
  280.                 COMException Exception;
  281.                 hr = SymDocument_GetSourceLength(m_Document, out SourceLength);
  282.                 if (hr < 0) {
  283.                     Exception = new COMException("Call to GetSourceLength failed.", hr);
  284.                     throw Exception;
  285.                 }
  286.                 return SourceLength;
  287.             }
  288.         }
  289.         public string URL {
  290.             get {
  291.                 int hr;
  292.                 StringBuilder URL;
  293.                 int cchUrl;
  294.                 COMException Exception;
  295.                 hr = SymDocument_GetUrl(m_Document, 0, out cchUrl, null);
  296.                 if (hr < 0) {
  297.                     Exception = new COMException("Call to GetUrl failed.", hr);
  298.                     throw Exception;
  299.                 }
  300.                 // *2 since it's wchar's
  301.                 URL = new StringBuilder(cchUrl);
  302.                 hr = SymDocument_GetUrl(m_Document, cchUrl, out cchUrl, URL);
  303.                 if (hr < 0) {
  304.                     Exception = new COMException("Call to GetUrl failed.", hr);
  305.                     throw Exception;
  306.                 }
  307.                 return URL.ToString();
  308.             }
  309.         }
  310.        
  311.         // Public API
  312.         public IntPtr InternalDocument {
  313.             get { return m_Document; }
  314.         }
  315.        
  316.     }
  317.    
  318.     public class SymDocumentWriter : ISymbolDocumentWriter
  319.     {
  320.        
  321.         private IntPtr m_DocumentWriter;
  322.         // Unmanaged DocumentWriter pointer
  323.         [DllImport(CreateSymClass.NATIVE_DLL)]
  324.         static extern int SymDocumentWriter_Release(IntPtr DocumentWriter);
  325.        
  326.         [DllImport(CreateSymClass.NATIVE_DLL)]
  327.         static extern int SymDocumentWriter_SetSource(IntPtr DocumentWriter, int sourceSize, byte[] source);
  328.        
  329.         [DllImport(CreateSymClass.NATIVE_DLL)]
  330.         static extern int SymDocumentWriter_SetCheckSum(IntPtr DocumentWriter, Guid algorithmId, int CheckSumSize, byte[] CheckSum);
  331.        
  332.        
  333.         //-----------------------------------------------------------------------
  334.         // SymDocumentWriter
  335.         //-----------------------------------------------------------------------
  336.        
  337.         public SymDocumentWriter(IntPtr DocumentWriter)
  338.         {
  339.             m_DocumentWriter = DocumentWriter;
  340.         }
  341.        
  342.         ~SymDocumentWriter()
  343.         {
  344.             SymDocumentWriter_Release(m_DocumentWriter);
  345.         }
  346.        
  347.         public void SetSource(byte[] source)
  348.         {
  349.             int hr;
  350.             COMException Exception;
  351.             hr = SymDocumentWriter_SetSource(m_DocumentWriter, source.Length, source);
  352.             if (hr < 0) {
  353.                 Exception = new COMException("Call to SetSource failed.", hr);
  354.                 throw Exception;
  355.             }
  356.         }
  357.        
  358.         public void SetCheckSum(Guid algorithmId, byte[] source)
  359.         {
  360.             int hr;
  361.             COMException Exception;
  362.             hr = SymDocumentWriter_SetCheckSum(m_DocumentWriter, algorithmId, source.Length, source);
  363.             if (hr < 0) {
  364.                 Exception = new COMException("Call to SetCheckSum failed.", hr);
  365.                 throw Exception;
  366.             }
  367.         }
  368.        
  369.         public IntPtr InternalDocumentWriter {
  370.             get { return m_DocumentWriter; }
  371.         }
  372.     }
  373.    
  374.     //-----------------------------------------------------------------------
  375.     // SymMethod
  376.     //-----------------------------------------------------------------------
  377.     public class SymMethod : ISymbolMethod
  378.     {
  379.         private IntPtr m_Method;
  380.         // Unmanaged method pointer
  381.         [DllImport(CreateSymClass.NATIVE_DLL)]
  382.         static extern int SymMethod_Release(IntPtr Method);
  383.        
  384.         [DllImport(CreateSymClass.NATIVE_DLL)]
  385.         static extern int SymMethod_GetSequencePoints(IntPtr Method, int cPoint, out int pcPoints,         [In()]
  386. IntPtr[] document,         [In()]
  387. int[] offsets,         [In()]
  388. int[] lines,         [In()]
  389. int[] columns,         [In()]
  390. int[] endLines,         [In()]
  391. int[] endColumns);
  392.        
  393.         [DllImport(CreateSymClass.NATIVE_DLL)]
  394.         static extern int SymMethod_GetRootScope(IntPtr Method, out IntPtr pScope);
  395.        
  396.         [DllImport(CreateSymClass.NATIVE_DLL)]
  397.         static extern int SymMethod_GetScopeFromOffset(IntPtr Method, int offset, out IntPtr pScope);
  398.        
  399.         [DllImport(CreateSymClass.NATIVE_DLL)]
  400.         static extern int SymMethod_GetOffset(IntPtr Method, IntPtr Document, int line, int column, out int offset);
  401.        
  402.         [DllImport(CreateSymClass.NATIVE_DLL)]
  403.         static extern int SymMethod_GetToken(IntPtr Method, out int Token);
  404.        
  405.         [DllImport(CreateSymClass.NATIVE_DLL)]
  406.         static extern int SymMethod_GetSequencePointCount(IntPtr Method, out int Count);
  407.        
  408.         [DllImport(CreateSymClass.NATIVE_DLL)]
  409.         static extern int SymMethod_GetRanges(IntPtr Method, IntPtr Document, int line, int column, int cRanges, out int pcRanges,         [In()]
  410. int[] Ranges);
  411.        
  412.         [DllImport(CreateSymClass.NATIVE_DLL)]
  413.         static extern int SymMethod_GetParameters(IntPtr Method, int cParams, out int pcParams,         [In()]
  414. IntPtr[] parameters);
  415.        
  416.         [DllImport(CreateSymClass.NATIVE_DLL)]
  417.         static extern int SymMethod_GetNamespace(IntPtr Method, out IntPtr pNamespace);
  418.        
  419.         [DllImport(CreateSymClass.NATIVE_DLL)]
  420.         static extern int SymMethod_GetSourceStartEnd(IntPtr Method,         [In()]
  421. IntPtr[] docs,         [In()]
  422. int[] lines,         [In()]
  423. int[] columns, out bool pRetVal);
  424.        
  425.         //
  426.         // Implementation
  427.         //
  428.         public SymMethod(IntPtr pMethod)
  429.         {
  430.             m_Method = pMethod;
  431.         }
  432.        
  433.         ~SymMethod()
  434.         {
  435.             SymMethod_Release(m_Method);
  436.         }
  437.        
  438.         public void GetSequencePoints(int[] offsets, ISymbolDocument[] documents, int[] lines, int[] columns, int[] endLines, int[] endColumns)
  439.         {
  440.             int hr;
  441.             int spCount = 0;
  442.             if (offsets != null)
  443.                 spCount = offsets.Length;
  444.             else if (documents != null)
  445.                 spCount = documents.Length;
  446.             else if (lines != null)
  447.                 spCount = lines.Length;
  448.             else if (columns != null)
  449.                 spCount = columns.Length;
  450.             else if (endLines != null)
  451.                 spCount = endLines.Length;
  452.             else if (endColumns != null)
  453.                 spCount = endColumns.Length;
  454.            
  455.             // Don't do anything if they're not really asking for anything.
  456.             if (spCount == 0)
  457.                 return;
  458.            
  459.             // Make sure all arrays are the same length.
  460.             if ((offsets != null) && (spCount != offsets.Length))
  461.                 throw new ArgumentException();
  462.            
  463.             if ((lines != null) && (spCount != lines.Length))
  464.                 throw new ArgumentException();
  465.            
  466.             if ((columns != null) && (spCount != columns.Length))
  467.                 throw new ArgumentException();
  468.            
  469.             if ((endLines != null) && (spCount != endLines.Length))
  470.                 throw new ArgumentException();
  471.            
  472.             if ((endColumns != null) && (spCount != endColumns.Length))
  473.                 throw new ArgumentException();
  474.            
  475.             COMException Exception;
  476.             IntPtr[] IDocuments = new IntPtr[documents.Length];
  477.             int cPoints;
  478.             uint i;
  479.             hr = SymMethod_GetSequencePoints(m_Method, documents.Length, out cPoints, IDocuments, offsets, lines, columns, endLines, endColumns);
  480.            
  481.             if (hr < 0) {
  482.                 Exception = new COMException("Call to GetSequencePoints failed.", hr);
  483.                 throw Exception;
  484.             }
  485.            
  486.             // Create the SymDocument form the IntPtr's
  487.             for (i = 0; i < documents.Length; i++) {
  488.                 documents[i] = new SymDocument(IDocuments[i]);
  489.             }
  490.            
  491.             return;
  492.         }
  493.        
  494.         public ISymbolScope RootScope {
  495.             get {
  496.                 int hr;
  497.                 IntPtr pRootScope;
  498.                 COMException Exception;
  499.                 hr = SymMethod_GetRootScope(m_Method, out pRootScope);
  500.                 if (hr < 0) {
  501.                     Exception = new COMException("Call to GetRootScope failed.", hr);
  502.                     throw Exception;
  503.                 }
  504.                 return new SymScope(pRootScope);
  505.             }
  506.         }
  507.        
  508.         public ISymbolScope GetScope(int offset)
  509.         {
  510.             int hr;
  511.             IntPtr pScope;
  512.             COMException Exception;
  513.             hr = SymMethod_GetScopeFromOffset(m_Method, offset, out pScope);
  514.             if (hr < 0) {
  515.                 Exception = new COMException("Call to GetScopeFromOffset failed.", hr);
  516.                 throw Exception;
  517.             }
  518.             return new SymScope(pScope);
  519.         }
  520.        
  521.         public int GetOffset(ISymbolDocument document, int line, int column)
  522.         {
  523.             int hr;
  524.             int offset = 0;
  525.             COMException Exception;
  526.             hr = SymMethod_GetOffset(m_Method, ((SymDocument)document).InternalDocument, line, column, out offset);
  527.             if (hr < 0) {
  528.                 Exception = new COMException("Call to GetOffset failed.", hr);
  529.                 throw Exception;
  530.             }
  531.            
  532.             return offset;
  533.         }
  534.         public SymbolToken Token {
  535.             get {
  536.                 int hr;
  537.                 int tokenId;
  538.                 COMException Exception;
  539.                 hr = SymMethod_GetToken(m_Method, out tokenId);
  540.                 if (hr < 0) {
  541.                     Exception = new COMException("Call to GetToken failed.", hr);
  542.                     throw Exception;
  543.                 }
  544.                
  545.                 SymbolToken t = new SymbolToken(tokenId);
  546.                 return t;
  547.             }
  548.         }
  549.        
  550.         public int SequencePointCount {
  551.             get {
  552.                 int hr;
  553.                 int Count;
  554.                 COMException Exception;
  555.                 hr = SymMethod_GetSequencePointCount(m_Method, out Count);
  556.                 if (hr < 0) {
  557.                     Exception = new COMException("Call to GetSequencePointCount failed.", hr);
  558.                     throw Exception;
  559.                 }
  560.                
  561.                 return Count;
  562.             }
  563.         }
  564.         public int[] GetRanges(ISymbolDocument document, int line, int column)
  565.         {
  566.             int hr;
  567.             int cRanges;
  568.             int[] Ranges;
  569.             COMException Exception;
  570.             hr = SymMethod_GetRanges(m_Method, ((SymDocument)document).InternalDocument, line, column, 0, out cRanges, null);
  571.             if (hr < 0) {
  572.                 Exception = new COMException("Call to GetRanges failed.", hr);
  573.                 throw Exception;
  574.             }
  575.             Ranges = new int[cRanges];
  576.             hr = SymMethod_GetRanges(m_Method, ((SymDocument)document).InternalDocument, line, column, cRanges, out cRanges, Ranges);
  577.             if (hr < 0) {
  578.                 Exception = new COMException("Call to GetRanges failed.", hr);
  579.                 throw Exception;
  580.             }
  581.            
  582.             return Ranges;
  583.         }
  584.        
  585.         public ISymbolVariable[] GetParameters()
  586.         {
  587.             int hr;
  588.             int cVariables;
  589.             uint i;
  590.             SymVariable[] Variables;
  591.             IntPtr[] VariablePointers;
  592.             COMException Exception;
  593.             hr = SymMethod_GetParameters(m_Method, 0, out cVariables, null);
  594.             if (hr < 0) {
  595.                 Exception = new COMException("Call to GetParameters failed.", hr);
  596.                 throw Exception;
  597.             }
  598.             VariablePointers = new IntPtr[cVariables];
  599.             hr = SymMethod_GetParameters(m_Method, cVariables, out cVariables, VariablePointers);
  600.             if (hr < 0) {
  601.                 Exception = new COMException("Call to GetParameters failed.", hr);
  602.                 throw Exception;
  603.             }
  604.            
  605.             Variables = new SymVariable[cVariables];
  606.            
  607.             for (i = 0; i < cVariables; i++) {
  608.                 Variables[i] = new SymVariable(VariablePointers[i]);
  609.             }
  610.            
  611.             return Variables;
  612.         }
  613.        
  614.         public ISymbolNamespace GetNamespace()
  615.         {
  616.             int hr;
  617.             IntPtr pNamespace;
  618.             COMException Exception;
  619.             hr = SymMethod_GetNamespace(m_Method, out pNamespace);
  620.             if (hr < 0) {
  621.                 Exception = new COMException("Call to GetNamespace failed.", hr);
  622.                 throw Exception;
  623.             }
  624.             return new SymNamespace(pNamespace);
  625.         }
  626.        
  627.         public bool GetSourceStartEnd(ISymbolDocument[] docs, int[] lines, int[] columns)
  628.         {
  629.             int hr;
  630.             uint i;
  631.             bool pRetVal;
  632.             int spCount = 0;
  633.             if (docs != null)
  634.                 spCount = docs.Length;
  635.             else if (lines != null)
  636.                 spCount = lines.Length;
  637.             else if (columns != null)
  638.                 spCount = columns.Length;
  639.            
  640.             // If we don't have at least 2 entries then return an error
  641.             if (spCount < 2)
  642.                 throw new ArgumentException();
  643.            
  644.             // Make sure all arrays are the same length.
  645.             if ((docs != null) && (spCount != docs.Length))
  646.                 throw new ArgumentException();
  647.            
  648.             if ((lines != null) && (spCount != lines.Length))
  649.                 throw new ArgumentException();
  650.            
  651.             if ((columns != null) && (spCount != columns.Length))
  652.                 throw new ArgumentException();
  653.            
  654.             COMException Exception;
  655.             IntPtr[] Documents = new IntPtr[docs.Length];
  656.             hr = SymMethod_GetSourceStartEnd(m_Method, Documents, lines, columns, out pRetVal);
  657.             if (hr < 0) {
  658.                 Exception = new COMException("Call to GetSourceStartEnd failed.", hr);
  659.                 throw Exception;
  660.             }
  661.             if (pRetVal) {
  662.                 for (i = 0; i < docs.Length; i++) {
  663.                     docs[i] = new SymDocument(Documents[i]);
  664.                 }
  665.             }
  666.             return pRetVal;
  667.            
  668.         }
  669.     }
  670.    
  671.     //-----------------------------------------------------------------------
  672.     // SymReader
  673.     //-----------------------------------------------------------------------
  674.     public class SymReader : ISymbolReader
  675.     {
  676.        
  677.         private IntPtr m_Reader;
  678.         // Unmanaged Reader pointer
  679.         [DllImport(CreateSymClass.NATIVE_DLL)]
  680.         static extern int SymReader_Release(IntPtr Reader);
  681.        
  682.         [DllImport(CreateSymClass.NATIVE_DLL)]
  683.         static extern int SymReader_GetUserEntryPoint(IntPtr Reader, out int EntryPoint);
  684.        
  685.         [DllImport(CreateSymClass.NATIVE_DLL)]
  686.         static extern int SymReader_GetDocuments(IntPtr Reader, int cDocs, out int pcDocs,         [In()]
  687. IntPtr[] pDocs);
  688.        
  689.         [DllImport(CreateSymClass.NATIVE_DLL)]
  690.         static extern int SymReader_GetDocument(IntPtr Reader,         [MarshalAs(UnmanagedType.LPWStr)]
  691. string Url, Guid Language, Guid LanguageVendor, Guid DocumentType, out IntPtr Document);
  692.        
  693.         [DllImport(CreateSymClass.NATIVE_DLL)]
  694.         static extern int SymReader_GetMethod(IntPtr Reader, int MethodToken, out IntPtr Document);
  695.        
  696.         [DllImport(CreateSymClass.NATIVE_DLL)]
  697.         static extern int SymReader_GetMethodByVersion(IntPtr Reader, int MethodToken, int Version, out IntPtr Document);
  698.        
  699.         [DllImport(CreateSymClass.NATIVE_DLL)]
  700.         static extern int SymReader_GetVariables(IntPtr Reader, int ParentToken, int cVars, out int pcVars,         [In()]
  701. IntPtr[] Variables);
  702.        
  703.         [DllImport(CreateSymClass.NATIVE_DLL)]
  704.         static extern int SymReader_GetGlobalVariables(IntPtr Reader, int cVars, out int pcVars,         [In()]
  705. IntPtr[] Variables);
  706.        
  707.         [DllImport(CreateSymClass.NATIVE_DLL)]
  708.         static extern int SymReader_GetMethodFromDocumentPosition(IntPtr Reader, IntPtr Document, int line, int column, out IntPtr MethodPointer);
  709.        
  710.         [DllImport(CreateSymClass.NATIVE_DLL)]
  711.         static extern int SymReader_GetSymAttribute(IntPtr Reader, int parentToken,         [MarshalAs(UnmanagedType.LPWStr)]
  712. string name, int cBuffer, out int pcBuffer, byte[] buffer);
  713.        
  714.         [DllImport(CreateSymClass.NATIVE_DLL)]
  715.         static extern int SymReader_GetNamespaces(IntPtr Reader, int cNamespaces, out int pcNamespaces,         [In()]
  716. IntPtr[] NamespacePointers);
  717.        
  718.         //
  719.         // Implementation
  720.         //
  721.         public SymReader(IntPtr Reader)
  722.         {
  723.             m_Reader = Reader;
  724.         }
  725.        
  726.         ~SymReader()
  727.         {
  728.             SymReader_Release(m_Reader);
  729.         }
  730.        
  731.         public SymbolToken UserEntryPoint {
  732.             get {
  733.                 COMException Exception;
  734.                 int hr;
  735.                 int EntryPoint;
  736.                 hr = SymReader_GetUserEntryPoint(m_Reader, out EntryPoint);
  737.                 if (hr < 0) {
  738.                     Exception = new COMException("Call to GetUserEntryPoint failed.", hr);
  739.                     throw Exception;
  740.                 }
  741.                
  742.                 SymbolToken t = new SymbolToken(EntryPoint);
  743.                 return t;
  744.             }
  745.         }
  746.        
  747.         public ISymbolDocument[] GetDocuments()
  748.         {
  749.             COMException Exception;
  750.             int hr;
  751.             uint i;
  752.             int cDocs;
  753.             IntPtr[] DocumentPointers;
  754.             SymDocument[] Documents;
  755.             hr = SymReader_GetDocuments(m_Reader, 0, out cDocs, null);
  756.             if (hr < 0) {
  757.                 Exception = new COMException("Call to GetDocuments failed.", hr);
  758.                 throw Exception;
  759.             }
  760.             DocumentPointers = new IntPtr[cDocs];
  761.             Documents = new SymDocument[cDocs];
  762.             hr = SymReader_GetDocuments(m_Reader, cDocs, out cDocs, DocumentPointers);
  763.             if (hr < 0) {
  764.                 Exception = new COMException("Call to GetDocuments failed.", hr);
  765.                 throw Exception;
  766.             }
  767.            
  768.             for (i = 0; i < cDocs; i++) {
  769.                 Documents[i] = new SymDocument(DocumentPointers[i]);
  770.             }
  771.            
  772.             return Documents;
  773.         }
  774.        
  775.         public ISymbolDocument GetDocument(string url, Guid language, Guid languageVendor, Guid documentType)
  776.         {
  777.             COMException Exception;
  778.             int hr;
  779.             IntPtr DocumentPointer;
  780.             hr = SymReader_GetDocument(m_Reader, url, language, languageVendor, documentType, out DocumentPointer);
  781.             if (hr < 0) {
  782.                 Exception = new COMException("Call to GetDocument failed.", hr);
  783.                 throw Exception;
  784.             }
  785.             return new SymDocument(DocumentPointer);
  786.         }
  787.        
  788.         public ISymbolMethod GetMethod(SymbolToken method)
  789.         {
  790.             COMException Exception;
  791.             int hr;
  792.             IntPtr MethodPointer;
  793.             hr = SymReader_GetMethod(m_Reader, method.GetToken(), out MethodPointer);
  794.             if (hr < 0) {
  795.                 Exception = new COMException("Call to GetMethod failed.", hr);
  796.                 throw Exception;
  797.             }
  798.             return new SymMethod(MethodPointer);
  799.         }
  800.        
  801.         public ISymbolMethod GetMethod(SymbolToken method, int version)
  802.         {
  803.             COMException Exception;
  804.             int hr;
  805.             IntPtr MethodPointer;
  806.             hr = SymReader_GetMethodByVersion(m_Reader, method.GetToken(), version, out MethodPointer);
  807.             if (hr < 0) {
  808.                 Exception = new COMException("Call to GetMethodByVersion failed.", hr);
  809.                 throw Exception;
  810.             }
  811.             return new SymMethod(MethodPointer);
  812.         }
  813.        
  814.         public