Added definitions and wrappers for Debugger Symbol Library

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/2.0@1152 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj

@@ -294,12 +294,76 @@
     <Compile Include="Src\Wrappers\MetaData\ParamProps.cs" />
     <Compile Include="Src\Wrappers\MetaData\TypeDefProps.cs" />
     <Compile Include="Src\Wrappers\MetaData\TypeRefProps.cs" />
+    <Compile Include="Src\Interop\CorSym\_FILETIME.cs" />
+    <Compile Include="Src\Interop\CorSym\_LARGE_INTEGER.cs" />
+    <Compile Include="Src\Interop\CorSym\_ULARGE_INTEGER.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymAddrKind.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymBinder_deprecated.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymBinder_deprecatedClass.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymBinder_SxS.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymBinder_SxSClass.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymReader_deprecated.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymReader_deprecatedClass.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymReader_SxS.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymReader_SxSClass.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymSearchPolicyAttributes.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymVarFlag.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymWriter_deprecated.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymWriter_deprecatedClass.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymWriter_SxS.cs" />
+    <Compile Include="Src\Interop\CorSym\CorSymWriter_SxSClass.cs" />
+    <Compile Include="Src\Interop\CorSym\ISequentialStream.cs" />
+    <Compile Include="Src\Interop\CorSym\IStream.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedBinder.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedDocument.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedDocumentWriter.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedMethod.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedNamespace.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedReader.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedReaderSymbolSearchInfo.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedScope.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedSymbolSearchInfo.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedVariable.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedWriter.cs" />
+    <Compile Include="Src\Interop\CorSym\ISymUnmanagedWriter2.cs" />
+    <Compile Include="Src\Interop\CorSym\tagSTATSTG.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymAddrKind.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymBinder_deprecated.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymBinder_deprecatedClass.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymBinder_SxS.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymBinder_SxSClass.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymReader_deprecated.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymReader_deprecatedClass.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymReader_SxS.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymReader_SxSClass.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymSearchPolicyAttributes.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymVarFlag.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymWriter_deprecated.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymWriter_deprecatedClass.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymWriter_SxS.cs" />
+    <Compile Include="Src\Wrappers\CorSym\CorSymWriter_SxSClass.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISequentialStream.cs" />
+    <Compile Include="Src\Wrappers\CorSym\IStream.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedBinder.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedDocument.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedDocumentWriter.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedMethod.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedNamespace.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedReader.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedReaderSymbolSearchInfo.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedScope.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedSymbolSearchInfo.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedVariable.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedWriter.cs" />
+    <Compile Include="Src\Wrappers\CorSym\ISymUnmanagedWriter2.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="README.TXT" />
     <Folder Include="Src\Wrappers" />
     <Folder Include="Src\Wrappers\CorDebug" />
     <Folder Include="Src\Wrappers\MetaData" />
+    <Folder Include="Src\Interop\CorSym" />
+    <Folder Include="Src\Wrappers\CorSym" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" />
 </Project>

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymAddrKind.cs

@@ -0,0 +1,27 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+
+    public enum CorSymAddrKind
+    {
+        // Fields
+        ADDR_BITFIELD = 9,
+        ADDR_IL_OFFSET = 1,
+        ADDR_NATIVE_ISECTOFFSET = 10,
+        ADDR_NATIVE_OFFSET = 5,
+        ADDR_NATIVE_REGISTER = 3,
+        ADDR_NATIVE_REGREG = 6,
+        ADDR_NATIVE_REGREL = 4,
+        ADDR_NATIVE_REGSTK = 7,
+        ADDR_NATIVE_RVA = 2,
+        ADDR_NATIVE_STKREG = 8
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymBinder_SxS.cs

@@ -0,0 +1,17 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System.Runtime.InteropServices;
+
+    [ComImport, CoClass(typeof(CorSymBinder_SxSClass)), Guid("AA544D42-28CB-11D3-BD22-0000F80849BD")]
+    public interface CorSymBinder_SxS : ISymUnmanagedBinder
+    {
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymBinder_SxSClass.cs

@@ -0,0 +1,28 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("0A29FF9E-7F9C-4437-8B11-F424491E3931"), ClassInterface((short) 0), TypeLibType((short) 2)]
+    public class CorSymBinder_SxSClass : ISymUnmanagedBinder, CorSymBinder_SxS
+    {
+        // Methods
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedReader GetReaderForFile([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In] ref ushort filename, [In] ref ushort searchPath);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedReader GetReaderFromStream([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In, MarshalAs(UnmanagedType.Interface)] IStream pstream);
+
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymBinder_deprecated.cs

@@ -0,0 +1,17 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System.Runtime.InteropServices;
+
+    [ComImport, CoClass(typeof(CorSymBinder_deprecatedClass)), Guid("AA544D42-28CB-11D3-BD22-0000F80849BD")]
+    public interface CorSymBinder_deprecated : ISymUnmanagedBinder
+    {
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymBinder_deprecatedClass.cs

@@ -0,0 +1,28 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("AA544D41-28CB-11D3-BD22-0000F80849BD"), ClassInterface((short) 0), TypeLibType((short) 2)]
+    public class CorSymBinder_deprecatedClass : ISymUnmanagedBinder, CorSymBinder_deprecated
+    {
+        // Methods
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedReader GetReaderForFile([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In] ref ushort filename, [In] ref ushort searchPath);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedReader GetReaderFromStream([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In, MarshalAs(UnmanagedType.Interface)] IStream pstream);
+
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymReader_SxS.cs

@@ -0,0 +1,17 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System.Runtime.InteropServices;
+
+    [ComImport, CoClass(typeof(CorSymReader_SxSClass)), Guid("B4CE6286-2A6B-3712-A3B7-1EE1DAD467B5")]
+    public interface CorSymReader_SxS : ISymUnmanagedReader
+    {
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymReader_SxSClass.cs

@@ -0,0 +1,75 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("0A3976C5-4529-4EF8-B0B0-42EED37082CD"), TypeLibType((short) 2), ClassInterface((short) 0), ComConversionLoss]
+    public class CorSymReader_SxSClass : ISymUnmanagedReader, CorSymReader_SxS
+    {
+        // Methods
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedDocument GetDocument([In] ref ushort url, [In] Guid language, [In] Guid languageVendor, [In] Guid documentType);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetDocuments([In] uint cDocs, out uint pcDocs, [Out] IntPtr pDocs);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetDocumentVersion([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument pDoc, out int version, out int pbCurrent);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetGlobalVariables([In] uint cVars, out uint pcVars, [Out] IntPtr pVars);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedMethod GetMethod([In] uint token);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedMethod GetMethodByVersion([In] uint token, [In] int version);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedMethod GetMethodFromDocumentPosition([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument document, [In] uint line, [In] uint column);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetMethodsFromDocumentPosition([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument document, [In] uint line, [In] uint column, [In] uint cMethod, out uint pcMethod, [Out] IntPtr pRetVal);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetMethodVersion([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedMethod pMethod, out int version);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetNamespaces([In] uint cNameSpaces, out uint pcNameSpaces, [Out] IntPtr namespaces);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetSymAttribute([In] uint parent, [In] ref ushort name, [In] uint cBuffer, out uint pcBuffer, [Out] IntPtr buffer);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetSymbolStoreFileName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern uint GetUserEntryPoint();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetVariables([In] uint parent, [In] uint cVars, out uint pcVars, [Out] IntPtr pVars);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Initialize([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In] ref ushort filename, [In] ref ushort searchPath, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void ReplaceSymbolStore([In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void UpdateSymbolStore([In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymReader_deprecated.cs

@@ -0,0 +1,17 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("B4CE6286-2A6B-3712-A3B7-1EE1DAD467B5"), CoClass(typeof(CorSymReader_deprecatedClass))]
+    public interface CorSymReader_deprecated : ISymUnmanagedReader
+    {
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymReader_deprecatedClass.cs

@@ -0,0 +1,75 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ClassInterface((short) 0), Guid("108296C2-281E-11D3-BD22-0000F80849BD"), ComConversionLoss, TypeLibType((short) 2)]
+    public class CorSymReader_deprecatedClass : ISymUnmanagedReader, CorSymReader_deprecated
+    {
+        // Methods
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedDocument GetDocument([In] ref ushort url, [In] Guid language, [In] Guid languageVendor, [In] Guid documentType);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetDocuments([In] uint cDocs, out uint pcDocs, [Out] IntPtr pDocs);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetDocumentVersion([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument pDoc, out int version, out int pbCurrent);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetGlobalVariables([In] uint cVars, out uint pcVars, [Out] IntPtr pVars);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedMethod GetMethod([In] uint token);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedMethod GetMethodByVersion([In] uint token, [In] int version);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedMethod GetMethodFromDocumentPosition([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument document, [In] uint line, [In] uint column);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetMethodsFromDocumentPosition([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument document, [In] uint line, [In] uint column, [In] uint cMethod, out uint pcMethod, [Out] IntPtr pRetVal);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetMethodVersion([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedMethod pMethod, out int version);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetNamespaces([In] uint cNameSpaces, out uint pcNameSpaces, [Out] IntPtr namespaces);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetSymAttribute([In] uint parent, [In] ref ushort name, [In] uint cBuffer, out uint pcBuffer, [Out] IntPtr buffer);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetSymbolStoreFileName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern uint GetUserEntryPoint();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetVariables([In] uint parent, [In] uint cVars, out uint pcVars, [Out] IntPtr pVars);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Initialize([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In] ref ushort filename, [In] ref ushort searchPath, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void ReplaceSymbolStore([In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void UpdateSymbolStore([In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymSearchPolicyAttributes.cs

@@ -0,0 +1,21 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+
+    public enum CorSymSearchPolicyAttributes
+    {
+        // Fields
+        AllowOriginalPathAccess = 4,
+        AllowReferencePathAccess = 8,
+        AllowRegistryAccess = 1,
+        AllowSymbolServerAccess = 2
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymVarFlag.cs

@@ -0,0 +1,18 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+
+    public enum CorSymVarFlag
+    {
+        // Fields
+        VAR_IS_COMP_GEN = 1
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymWriter_SxS.cs

@@ -0,0 +1,17 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System.Runtime.InteropServices;
+
+    [ComImport, CoClass(typeof(CorSymWriter_SxSClass)), Guid("ED14AA72-78E2-4884-84E2-334293AE5214")]
+    public interface CorSymWriter_SxS : ISymUnmanagedWriter
+    {
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymWriter_SxSClass.cs

@@ -0,0 +1,93 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, TypeLibType((short) 2), Guid("0AE2DEB0-F901-478B-BB9F-881EE8066788"), ClassInterface((short) 0), ComConversionLoss]
+    public class CorSymWriter_SxSClass : ISymUnmanagedWriter, CorSymWriter_SxS
+    {
+        // Methods
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Abort();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Close();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CloseMethod();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CloseNamespace();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CloseScope([In] uint endOffset);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineConstant([In] ref ushort name, [In, MarshalAs(UnmanagedType.Struct)] object value, [In] uint cSig, [In] ref byte signature);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedDocumentWriter DefineDocument([In] ref ushort url, [In] ref Guid language, [In] ref Guid languageVendor, [In] ref Guid documentType);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineField([In] uint parent, [In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineGlobalVariable([In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineLocalVariable([In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3, [In] uint startOffset, [In] uint endOffset);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineParameter([In] ref ushort name, [In] uint attributes, [In] uint sequence, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineSequencePoints([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter document, [In] uint spCount, [In] ref uint offsets, [In] ref uint lines, [In] ref uint columns, [In] ref uint endLines, [In] ref uint endColumns);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetDebugInfo([In] ref uint pIDD, [In] uint cData, out uint pcData, [Out] IntPtr data);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Initialize([In, MarshalAs(UnmanagedType.IUnknown)] object emitter, [In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, [In] int fFullBuild);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Initialize2([In, MarshalAs(UnmanagedType.IUnknown)] object emitter, [In] ref ushort tempfilename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, [In] int fFullBuild, [In] ref ushort finalfilename);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void OpenMethod([In] uint method);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void OpenNamespace([In] ref ushort name);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern uint OpenScope([In] uint startOffset);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void RemapToken([In] uint oldToken, [In] uint newToken);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetMethodSourceRange([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter startDoc, [In] uint startLine, [In] uint startColumn, [In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter endDoc, [In] uint endLine, [In] uint endColumn);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetScopeRange([In] uint scopeID, [In] uint startOffset, [In] uint endOffset);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetSymAttribute([In] uint parent, [In] ref ushort name, [In] uint cData, [In] ref byte data);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetUserEntryPoint([In] uint entryMethod);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void UsingNamespace([In] ref ushort fullName);
+
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymWriter_deprecated.cs

@@ -0,0 +1,17 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("ED14AA72-78E2-4884-84E2-334293AE5214"), CoClass(typeof(CorSymWriter_deprecatedClass))]
+    public interface CorSymWriter_deprecated : ISymUnmanagedWriter
+    {
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/CorSymWriter_deprecatedClass.cs

@@ -0,0 +1,93 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ClassInterface((short) 0), Guid("108296C1-281E-11D3-BD22-0000F80849BD"), ComConversionLoss, TypeLibType((short) 2)]
+    public class CorSymWriter_deprecatedClass : ISymUnmanagedWriter, CorSymWriter_deprecated
+    {
+        // Methods
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Abort();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Close();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CloseMethod();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CloseNamespace();
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void CloseScope([In] uint endOffset);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineConstant([In] ref ushort name, [In, MarshalAs(UnmanagedType.Struct)] object value, [In] uint cSig, [In] ref byte signature);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern ISymUnmanagedDocumentWriter DefineDocument([In] ref ushort url, [In] ref Guid language, [In] ref Guid languageVendor, [In] ref Guid documentType);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineField([In] uint parent, [In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineGlobalVariable([In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineLocalVariable([In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3, [In] uint startOffset, [In] uint endOffset);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineParameter([In] ref ushort name, [In] uint attributes, [In] uint sequence, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void DefineSequencePoints([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter document, [In] uint spCount, [In] ref uint offsets, [In] ref uint lines, [In] ref uint columns, [In] ref uint endLines, [In] ref uint endColumns);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void GetDebugInfo([In] ref uint pIDD, [In] uint cData, out uint pcData, [Out] IntPtr data);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Initialize([In, MarshalAs(UnmanagedType.IUnknown)] object emitter, [In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, [In] int fFullBuild);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void Initialize2([In, MarshalAs(UnmanagedType.IUnknown)] object emitter, [In] ref ushort tempfilename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, [In] int fFullBuild, [In] ref ushort finalfilename);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void OpenMethod([In] uint method);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void OpenNamespace([In] ref ushort name);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern uint OpenScope([In] uint startOffset);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void RemapToken([In] uint oldToken, [In] uint newToken);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetMethodSourceRange([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter startDoc, [In] uint startLine, [In] uint startColumn, [In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter endDoc, [In] uint endLine, [In] uint endColumn);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetScopeRange([In] uint scopeID, [In] uint startOffset, [In] uint endOffset);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetSymAttribute([In] uint parent, [In] ref ushort name, [In] uint cData, [In] ref byte data);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void SetUserEntryPoint([In] uint entryMethod);
+
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        public virtual extern void UsingNamespace([In] ref ushort fullName);
+
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISequentialStream.cs

@@ -0,0 +1,23 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("0C733A30-2A1C-11CE-ADE5-00AA0044773D"), InterfaceType((short) 1)]
+    public interface ISequentialStream
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteRead(out byte pv, [In] uint cb, out uint pcbRead);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteWrite([In] ref byte pv, [In] uint cb, out uint pcbWritten);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/IStream.cs

@@ -0,0 +1,41 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("0000000C-0000-0000-C000-000000000046")]
+    public interface IStream : ISequentialStream
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteRead(out byte pv, [In] uint cb, out uint pcbRead);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteWrite([In] ref byte pv, [In] uint cb, out uint pcbWritten);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteSeek([In] _LARGE_INTEGER dlibMove, [In] uint dwOrigin, out _ULARGE_INTEGER plibNewPosition);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetSize([In] _ULARGE_INTEGER libNewSize);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemoteCopyTo([In, MarshalAs(UnmanagedType.Interface)] IStream pstm, [In] _ULARGE_INTEGER cb, out _ULARGE_INTEGER pcbRead, out _ULARGE_INTEGER pcbWritten);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Commit([In] uint grfCommitFlags);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Revert();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void LockRegion([In] _ULARGE_INTEGER libOffset, [In] _ULARGE_INTEGER cb, [In] uint dwLockType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UnlockRegion([In] _ULARGE_INTEGER libOffset, [In] _ULARGE_INTEGER cb, [In] uint dwLockType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Stat(out tagSTATSTG pstatstg, [In] uint grfStatFlag);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Clone([MarshalAs(UnmanagedType.Interface)] out IStream ppstm);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedBinder.cs

@@ -0,0 +1,25 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), Guid("AA544D42-28CB-11D3-BD22-0000F80849BD")]
+    public interface ISymUnmanagedBinder
+    {
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedReader GetReaderForFile([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In] ref ushort filename, [In] ref ushort searchPath);
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedReader GetReaderFromStream([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In, MarshalAs(UnmanagedType.Interface)] IStream pstream);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedDocument.cs

@@ -0,0 +1,39 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("40DE4037-7C81-3E1E-B022-AE1ABFF2CA08"), ComConversionLoss, InterfaceType((short) 1)]
+    public interface ISymUnmanagedDocument
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetURL([In] uint cchUrl, out uint pcchUrl, [Out] IntPtr szUrl);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        Guid GetDocumentType();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        Guid GetLanguage();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        Guid GetLanguageVendor();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        Guid GetCheckSumAlgorithmId();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetCheckSum([In] uint cData, out uint pcData, [Out] IntPtr data);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint FindClosestLine([In] uint line);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        int HasEmbeddedSource();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetSourceLength();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSourceRange([In] uint startLine, [In] uint startColumn, [In] uint endLine, [In] uint endColumn, [In] uint cSourceBytes, out uint pcSourceBytes, [Out] IntPtr source);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedDocumentWriter.cs

@@ -0,0 +1,23 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("B01FAFEB-C450-3A4D-BEEC-B4CEEC01E006"), InterfaceType((short) 1)]
+    public interface ISymUnmanagedDocumentWriter
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetSource([In] uint sourceSize, [In] ref byte source);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetCheckSum([In] Guid algorithmId, [In] uint checkSumSize, [In] ref byte checkSum);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedMethod.cs

@@ -0,0 +1,41 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), ComConversionLoss, Guid("B62B923C-B500-3158-A543-24F307A8B7E1")]
+    public interface ISymUnmanagedMethod
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetToken();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetSequencePointCount();
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedScope GetRootScope();
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedScope GetScopeFromOffset([In] uint offset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetOffset([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument document, [In] uint line, [In] uint column);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetRanges([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument document, [In] uint line, [In] uint column, [In] uint cRanges, out uint pcRanges, [Out] IntPtr ranges);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetParameters([In] uint cParams, out uint pcParams, [Out] IntPtr @params);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNamespace([MarshalAs(UnmanagedType.Interface)] out ISymUnmanagedNamespace pRetVal);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSourceStartEnd([In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0, SizeConst=2)] ISymUnmanagedDocument[] docs, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0, SizeConst=2)] uint[] lines, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0, SizeConst=2)] uint[] columns, out int pRetVal);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSequencePoints([In] uint cPoints, out uint pcPoints, [In] ref uint offsets, [In, MarshalAs(UnmanagedType.Interface)] ref ISymUnmanagedDocument documents, [In] ref uint lines, [In] ref uint columns, [In] ref uint endLines, [In] ref uint endColumns);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedNamespace.cs

@@ -0,0 +1,25 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), ComConversionLoss, Guid("0DFF7289-54F8-11D3-BD28-0000F80849BD")]
+    public interface ISymUnmanagedNamespace
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNamespaces([In] uint cNameSpaces, out uint pcNameSpaces, [Out] IntPtr namespaces);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVariables([In] uint cVars, out uint pcVars, [Out] IntPtr pVars);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedReader.cs

@@ -0,0 +1,57 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, InterfaceType((short) 1), ComConversionLoss, Guid("B4CE6286-2A6B-3712-A3B7-1EE1DAD467B5")]
+    public interface ISymUnmanagedReader
+    {
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedDocument GetDocument([In] ref ushort url, [In] Guid language, [In] Guid languageVendor, [In] Guid documentType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetDocuments([In] uint cDocs, out uint pcDocs, [Out] IntPtr pDocs);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetUserEntryPoint();
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedMethod GetMethod([In] uint token);
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedMethod GetMethodByVersion([In] uint token, [In] int version);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetVariables([In] uint parent, [In] uint cVars, out uint pcVars, [Out] IntPtr pVars);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetGlobalVariables([In] uint cVars, out uint pcVars, [Out] IntPtr pVars);
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedMethod GetMethodFromDocumentPosition([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument document, [In] uint line, [In] uint column);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSymAttribute([In] uint parent, [In] ref ushort name, [In] uint cBuffer, out uint pcBuffer, [Out] IntPtr buffer);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNamespaces([In] uint cNameSpaces, out uint pcNameSpaces, [Out] IntPtr namespaces);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Initialize([In, MarshalAs(UnmanagedType.IUnknown)] object importer, [In] ref ushort filename, [In] ref ushort searchPath, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UpdateSymbolStore([In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void ReplaceSymbolStore([In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSymbolStoreFileName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetMethodsFromDocumentPosition([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument document, [In] uint line, [In] uint column, [In] uint cMethod, out uint pcMethod, [Out] IntPtr pRetVal);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetDocumentVersion([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocument pDoc, out int version, out int pbCurrent);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetMethodVersion([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedMethod pMethod, out int version);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedReaderSymbolSearchInfo.cs

@@ -0,0 +1,23 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("20D9645D-03CD-4E34-9C11-9848A5B084F1"), InterfaceType((short) 1)]
+    public interface ISymUnmanagedReaderSymbolSearchInfo
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSymbolSearchInfoCount(out uint pcSearchInfo);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSymbolSearchInfo([In] uint cSearchInfo, out uint pcSearchInfo, [MarshalAs(UnmanagedType.Interface)] out ISymUnmanagedSymbolSearchInfo rgpSearchInfo);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedScope.cs

@@ -0,0 +1,37 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("68005D0F-B8E0-3B01-84D5-A11A94154942"), ComConversionLoss, InterfaceType((short) 1)]
+    public interface ISymUnmanagedScope
+    {
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedMethod GetMethod();
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedScope GetParent();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetChildren([In] uint cChildren, out uint pcChildren, [Out] IntPtr children);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetStartOffset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetEndOffset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetLocalCount();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetLocals([In] uint cLocals, out uint pcLocals, [Out] IntPtr locals);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetNamespaces([In] uint cNameSpaces, out uint pcNameSpaces, [Out] IntPtr namespaces);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedSymbolSearchInfo.cs

@@ -0,0 +1,25 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ComConversionLoss, InterfaceType((short) 1), Guid("F8B3534A-A46B-4980-B520-BEC4ACEABA8F")]
+    public interface ISymUnmanagedSymbolSearchInfo
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSearchPathLength(out uint pcchPath);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSearchPath([In] uint cchPath, out uint pcchPath, [Out] IntPtr szPath);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetHRESULT([MarshalAs(UnmanagedType.Error)] out int phr);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedVariable.cs

@@ -0,0 +1,37 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("9F60EEBE-2D9A-3F7C-BF58-80BC991C60BB"), InterfaceType((short) 1), ComConversionLoss]
+    public interface ISymUnmanagedVariable
+    {
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetName([In] uint cchName, out uint pcchName, [Out] IntPtr szName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetAttributes();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetSignature([In] uint cSig, out uint pcSig, [Out] IntPtr sig);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetAddressKind();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetAddressField1();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetAddressField2();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetAddressField3();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetStartOffset();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint GetEndOffset();
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedWriter.cs

@@ -0,0 +1,68 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, ComConversionLoss, InterfaceType((short) 1), Guid("ED14AA72-78E2-4884-84E2-334293AE5214")]
+    public interface ISymUnmanagedWriter
+    {
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedDocumentWriter DefineDocument([In] ref ushort url, [In] ref Guid language, [In] ref Guid languageVendor, [In] ref Guid documentType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetUserEntryPoint([In] uint entryMethod);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void OpenMethod([In] uint method);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CloseMethod();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint OpenScope([In] uint startOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CloseScope([In] uint endOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetScopeRange([In] uint scopeID, [In] uint startOffset, [In] uint endOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineLocalVariable([In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3, [In] uint startOffset, [In] uint endOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineParameter([In] ref ushort name, [In] uint attributes, [In] uint sequence, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineField([In] uint parent, [In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineGlobalVariable([In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Close();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetSymAttribute([In] uint parent, [In] ref ushort name, [In] uint cData, [In] ref byte data);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void OpenNamespace([In] ref ushort name);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CloseNamespace();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UsingNamespace([In] ref ushort fullName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetMethodSourceRange([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter startDoc, [In] uint startLine, [In] uint startColumn, [In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter endDoc, [In] uint endLine, [In] uint endColumn);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Initialize([In, MarshalAs(UnmanagedType.IUnknown)] object emitter, [In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, [In] int fFullBuild);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetDebugInfo([In] ref uint pIDD, [In] uint cData, out uint pcData, [Out] IntPtr data);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineSequencePoints([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter document, [In] uint spCount, [In] ref uint offsets, [In] ref uint lines, [In] ref uint columns, [In] ref uint endLines, [In] ref uint endColumns);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemapToken([In] uint oldToken, [In] uint newToken);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Initialize2([In, MarshalAs(UnmanagedType.IUnknown)] object emitter, [In] ref ushort tempfilename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, [In] int fFullBuild, [In] ref ushort finalfilename);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineConstant([In] ref ushort name, [In, MarshalAs(UnmanagedType.Struct)] object value, [In] uint cSig, [In] ref byte signature);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Abort();
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/ISymUnmanagedWriter2.cs

@@ -0,0 +1,74 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    [ComImport, Guid("0B97726E-9E6D-4F05-9A26-424022093CAA"), InterfaceType((short) 1)]
+    public interface ISymUnmanagedWriter2 : ISymUnmanagedWriter
+    {
+        [return: MarshalAs(UnmanagedType.Interface)]
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        ISymUnmanagedDocumentWriter DefineDocument([In] ref ushort url, [In] ref Guid language, [In] ref Guid languageVendor, [In] ref Guid documentType);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetUserEntryPoint([In] uint entryMethod);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void OpenMethod([In] uint method);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CloseMethod();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        uint OpenScope([In] uint startOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CloseScope([In] uint endOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetScopeRange([In] uint scopeID, [In] uint startOffset, [In] uint endOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineLocalVariable([In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3, [In] uint startOffset, [In] uint endOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineParameter([In] ref ushort name, [In] uint attributes, [In] uint sequence, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineField([In] uint parent, [In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineGlobalVariable([In] ref ushort name, [In] uint attributes, [In] uint cSig, [In] ref byte signature, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Close();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetSymAttribute([In] uint parent, [In] ref ushort name, [In] uint cData, [In] ref byte data);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void OpenNamespace([In] ref ushort name);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void CloseNamespace();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void UsingNamespace([In] ref ushort fullName);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void SetMethodSourceRange([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter startDoc, [In] uint startLine, [In] uint startColumn, [In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter endDoc, [In] uint endLine, [In] uint endColumn);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Initialize([In, MarshalAs(UnmanagedType.IUnknown)] object emitter, [In] ref ushort filename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, [In] int fFullBuild);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void GetDebugInfo([In] ref uint pIDD, [In] uint cData, out uint pcData, [Out] IntPtr data);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineSequencePoints([In, MarshalAs(UnmanagedType.Interface)] ISymUnmanagedDocumentWriter document, [In] uint spCount, [In] ref uint offsets, [In] ref uint lines, [In] ref uint columns, [In] ref uint endLines, [In] ref uint endColumns);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void RemapToken([In] uint oldToken, [In] uint newToken);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Initialize2([In, MarshalAs(UnmanagedType.IUnknown)] object emitter, [In] ref ushort tempfilename, [In, MarshalAs(UnmanagedType.Interface)] IStream pIStream, [In] int fFullBuild, [In] ref ushort finalfilename);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineConstant([In] ref ushort name, [In, MarshalAs(UnmanagedType.Struct)] object value, [In] uint cSig, [In] ref byte signature);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void Abort();
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineLocalVariable2([In] ref ushort name, [In] uint attributes, [In] uint sigToken, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3, [In] uint startOffset, [In] uint endOffset);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineGlobalVariable2([In] ref ushort name, [In] uint attributes, [In] uint sigToken, [In] uint addrKind, [In] uint addr1, [In] uint addr2, [In] uint addr3);
+        [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime)]
+        void DefineConstant2([In] ref ushort name, [In, MarshalAs(UnmanagedType.Struct)] object value, [In] uint sigToken);
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/_FILETIME.cs

@@ -0,0 +1,20 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=4)]
+    public struct _FILETIME
+    {
+        public uint dwLowDateTime;
+        public uint dwHighDateTime;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/_LARGE_INTEGER.cs

@@ -0,0 +1,19 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=8)]
+    public struct _LARGE_INTEGER
+    {
+        public long QuadPart;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/_ULARGE_INTEGER.cs

@@ -0,0 +1,19 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=8)]
+    public struct _ULARGE_INTEGER
+    {
+        public ulong QuadPart;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Interop/CorSym/tagSTATSTG.cs

@@ -0,0 +1,30 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Interop.CorSym
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    [StructLayout(LayoutKind.Sequential, Pack=8)]
+    public struct tagSTATSTG
+    {
+        [MarshalAs(UnmanagedType.LPWStr)]
+        public string pwcsName;
+        public uint type;
+        public _ULARGE_INTEGER cbSize;
+        public _FILETIME mtime;
+        public _FILETIME ctime;
+        public _FILETIME atime;
+        public uint grfMode;
+        public uint grfLocksSupported;
+        public Guid clsid;
+        public uint grfStateBits;
+        public uint reserved;
+    }
+}
+

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymAddrKind.cs

@@ -0,0 +1,36 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public enum CorSymAddrKind : int
+	{
+		
+		ADDR_IL_OFFSET = 1,
+		
+		ADDR_NATIVE_RVA = 2,
+		
+		ADDR_NATIVE_REGISTER = 3,
+		
+		ADDR_NATIVE_REGREL = 4,
+		
+		ADDR_NATIVE_OFFSET = 5,
+		
+		ADDR_NATIVE_REGREG = 6,
+		
+		ADDR_NATIVE_REGSTK = 7,
+		
+		ADDR_NATIVE_STKREG = 8,
+		
+		ADDR_BITFIELD = 9,
+		
+		ADDR_NATIVE_ISECTOFFSET = 10,
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymBinder_SxS.cs

@@ -0,0 +1,91 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymBinder_SxS
+	{
+		
+		private Debugger.Interop.CorSym.CorSymBinder_SxS wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymBinder_SxS WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymBinder_SxS(Debugger.Interop.CorSym.CorSymBinder_SxS wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymBinder_SxS));
+		}
+		
+		public static CorSymBinder_SxS Wrap(Debugger.Interop.CorSym.CorSymBinder_SxS objectToWrap)
+		{
+			return new CorSymBinder_SxS(objectToWrap);
+		}
+		
+		~CorSymBinder_SxS()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymBinder_SxS));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymBinder_SxS o1, CorSymBinder_SxS o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymBinder_SxS o1, CorSymBinder_SxS o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymBinder_SxS casted = o as CorSymBinder_SxS;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymBinder_SxSClass.cs

@@ -0,0 +1,101 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymBinder_SxSClass
+	{
+		
+		private Debugger.Interop.CorSym.CorSymBinder_SxSClass wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymBinder_SxSClass WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymBinder_SxSClass(Debugger.Interop.CorSym.CorSymBinder_SxSClass wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymBinder_SxSClass));
+		}
+		
+		public static CorSymBinder_SxSClass Wrap(Debugger.Interop.CorSym.CorSymBinder_SxSClass objectToWrap)
+		{
+			return new CorSymBinder_SxSClass(objectToWrap);
+		}
+		
+		~CorSymBinder_SxSClass()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymBinder_SxSClass));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymBinder_SxSClass o1, CorSymBinder_SxSClass o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymBinder_SxSClass o1, CorSymBinder_SxSClass o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymBinder_SxSClass casted = o as CorSymBinder_SxSClass;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedReader GetReaderForFile(object importer, ref ushort filename, ref ushort searchPath)
+		{
+			return ISymUnmanagedReader.Wrap(this.WrappedObject.GetReaderForFile(importer, ref filename, ref searchPath));
+		}
+		
+		public ISymUnmanagedReader GetReaderFromStream(object importer, IStream pstream)
+		{
+			return ISymUnmanagedReader.Wrap(this.WrappedObject.GetReaderFromStream(importer, pstream.WrappedObject));
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymBinder_deprecated.cs

@@ -0,0 +1,91 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymBinder_deprecated
+	{
+		
+		private Debugger.Interop.CorSym.CorSymBinder_deprecated wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymBinder_deprecated WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymBinder_deprecated(Debugger.Interop.CorSym.CorSymBinder_deprecated wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymBinder_deprecated));
+		}
+		
+		public static CorSymBinder_deprecated Wrap(Debugger.Interop.CorSym.CorSymBinder_deprecated objectToWrap)
+		{
+			return new CorSymBinder_deprecated(objectToWrap);
+		}
+		
+		~CorSymBinder_deprecated()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymBinder_deprecated));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymBinder_deprecated o1, CorSymBinder_deprecated o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymBinder_deprecated o1, CorSymBinder_deprecated o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymBinder_deprecated casted = o as CorSymBinder_deprecated;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymBinder_deprecatedClass.cs

@@ -0,0 +1,101 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymBinder_deprecatedClass
+	{
+		
+		private Debugger.Interop.CorSym.CorSymBinder_deprecatedClass wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymBinder_deprecatedClass WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymBinder_deprecatedClass(Debugger.Interop.CorSym.CorSymBinder_deprecatedClass wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymBinder_deprecatedClass));
+		}
+		
+		public static CorSymBinder_deprecatedClass Wrap(Debugger.Interop.CorSym.CorSymBinder_deprecatedClass objectToWrap)
+		{
+			return new CorSymBinder_deprecatedClass(objectToWrap);
+		}
+		
+		~CorSymBinder_deprecatedClass()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymBinder_deprecatedClass));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymBinder_deprecatedClass o1, CorSymBinder_deprecatedClass o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymBinder_deprecatedClass o1, CorSymBinder_deprecatedClass o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymBinder_deprecatedClass casted = o as CorSymBinder_deprecatedClass;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedReader GetReaderForFile(object importer, ref ushort filename, ref ushort searchPath)
+		{
+			return ISymUnmanagedReader.Wrap(this.WrappedObject.GetReaderForFile(importer, ref filename, ref searchPath));
+		}
+		
+		public ISymUnmanagedReader GetReaderFromStream(object importer, IStream pstream)
+		{
+			return ISymUnmanagedReader.Wrap(this.WrappedObject.GetReaderFromStream(importer, pstream.WrappedObject));
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymReader_SxS.cs

@@ -0,0 +1,91 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymReader_SxS
+	{
+		
+		private Debugger.Interop.CorSym.CorSymReader_SxS wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymReader_SxS WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymReader_SxS(Debugger.Interop.CorSym.CorSymReader_SxS wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymReader_SxS));
+		}
+		
+		public static CorSymReader_SxS Wrap(Debugger.Interop.CorSym.CorSymReader_SxS objectToWrap)
+		{
+			return new CorSymReader_SxS(objectToWrap);
+		}
+		
+		~CorSymReader_SxS()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymReader_SxS));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymReader_SxS o1, CorSymReader_SxS o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymReader_SxS o1, CorSymReader_SxS o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymReader_SxS casted = o as CorSymReader_SxS;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymReader_SxSClass.cs

@@ -0,0 +1,183 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymReader_SxSClass
+	{
+		
+		private Debugger.Interop.CorSym.CorSymReader_SxSClass wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymReader_SxSClass WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymReader_SxSClass(Debugger.Interop.CorSym.CorSymReader_SxSClass wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymReader_SxSClass));
+		}
+		
+		public static CorSymReader_SxSClass Wrap(Debugger.Interop.CorSym.CorSymReader_SxSClass objectToWrap)
+		{
+			return new CorSymReader_SxSClass(objectToWrap);
+		}
+		
+		~CorSymReader_SxSClass()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymReader_SxSClass));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymReader_SxSClass o1, CorSymReader_SxSClass o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymReader_SxSClass o1, CorSymReader_SxSClass o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymReader_SxSClass casted = o as CorSymReader_SxSClass;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedDocument GetDocument(ref ushort url, System.Guid language, System.Guid languageVendor, System.Guid documentType)
+		{
+			return ISymUnmanagedDocument.Wrap(this.WrappedObject.GetDocument(ref url, language, languageVendor, documentType));
+		}
+		
+		public void GetDocuments(uint cDocs, out uint pcDocs, System.IntPtr pDocs)
+		{
+			this.WrappedObject.GetDocuments(cDocs, out pcDocs, pDocs);
+		}
+		
+		public int GetDocumentVersion(ISymUnmanagedDocument pDoc, out int version)
+		{
+			int pbCurrent;
+			this.WrappedObject.GetDocumentVersion(pDoc.WrappedObject, out version, out pbCurrent);
+			return pbCurrent;
+		}
+		
+		public void GetGlobalVariables(uint cVars, out uint pcVars, System.IntPtr pVars)
+		{
+			this.WrappedObject.GetGlobalVariables(cVars, out pcVars, pVars);
+		}
+		
+		public ISymUnmanagedMethod GetMethod(uint token)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethod(token));
+		}
+		
+		public ISymUnmanagedMethod GetMethodByVersion(uint token, int version)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethodByVersion(token, version));
+		}
+		
+		public ISymUnmanagedMethod GetMethodFromDocumentPosition(ISymUnmanagedDocument document, uint line, uint column)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethodFromDocumentPosition(document.WrappedObject, line, column));
+		}
+		
+		public void GetMethodsFromDocumentPosition(ISymUnmanagedDocument document, uint line, uint column, uint cMethod, out uint pcMethod, System.IntPtr pRetVal)
+		{
+			this.WrappedObject.GetMethodsFromDocumentPosition(document.WrappedObject, line, column, cMethod, out pcMethod, pRetVal);
+		}
+		
+		public int GetMethodVersion(ISymUnmanagedMethod pMethod)
+		{
+			int version;
+			this.WrappedObject.GetMethodVersion(pMethod.WrappedObject, out version);
+			return version;
+		}
+		
+		public void GetNamespaces(uint cNameSpaces, out uint pcNameSpaces, System.IntPtr namespaces)
+		{
+			this.WrappedObject.GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
+		}
+		
+		public void GetSymAttribute(uint parent, ref ushort name, uint cBuffer, out uint pcBuffer, System.IntPtr buffer)
+		{
+			this.WrappedObject.GetSymAttribute(parent, ref name, cBuffer, out pcBuffer, buffer);
+		}
+		
+		public void GetSymbolStoreFileName(uint cchName, out uint pcchName, System.IntPtr szName)
+		{
+			this.WrappedObject.GetSymbolStoreFileName(cchName, out pcchName, szName);
+		}
+		
+		public uint UserEntryPoint
+		{
+			get
+			{
+				return this.WrappedObject.GetUserEntryPoint();
+			}
+		}
+		
+		public void GetVariables(uint parent, uint cVars, out uint pcVars, System.IntPtr pVars)
+		{
+			this.WrappedObject.GetVariables(parent, cVars, out pcVars, pVars);
+		}
+		
+		public void Initialize(object importer, ref ushort filename, ref ushort searchPath, IStream pIStream)
+		{
+			this.WrappedObject.Initialize(importer, ref filename, ref searchPath, pIStream.WrappedObject);
+		}
+		
+		public void ReplaceSymbolStore(ref ushort filename, IStream pIStream)
+		{
+			this.WrappedObject.ReplaceSymbolStore(ref filename, pIStream.WrappedObject);
+		}
+		
+		public void UpdateSymbolStore(ref ushort filename, IStream pIStream)
+		{
+			this.WrappedObject.UpdateSymbolStore(ref filename, pIStream.WrappedObject);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymReader_deprecated.cs

@@ -0,0 +1,91 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymReader_deprecated
+	{
+		
+		private Debugger.Interop.CorSym.CorSymReader_deprecated wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymReader_deprecated WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymReader_deprecated(Debugger.Interop.CorSym.CorSymReader_deprecated wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymReader_deprecated));
+		}
+		
+		public static CorSymReader_deprecated Wrap(Debugger.Interop.CorSym.CorSymReader_deprecated objectToWrap)
+		{
+			return new CorSymReader_deprecated(objectToWrap);
+		}
+		
+		~CorSymReader_deprecated()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymReader_deprecated));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymReader_deprecated o1, CorSymReader_deprecated o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymReader_deprecated o1, CorSymReader_deprecated o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymReader_deprecated casted = o as CorSymReader_deprecated;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymReader_deprecatedClass.cs

@@ -0,0 +1,183 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymReader_deprecatedClass
+	{
+		
+		private Debugger.Interop.CorSym.CorSymReader_deprecatedClass wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymReader_deprecatedClass WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymReader_deprecatedClass(Debugger.Interop.CorSym.CorSymReader_deprecatedClass wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymReader_deprecatedClass));
+		}
+		
+		public static CorSymReader_deprecatedClass Wrap(Debugger.Interop.CorSym.CorSymReader_deprecatedClass objectToWrap)
+		{
+			return new CorSymReader_deprecatedClass(objectToWrap);
+		}
+		
+		~CorSymReader_deprecatedClass()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymReader_deprecatedClass));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymReader_deprecatedClass o1, CorSymReader_deprecatedClass o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymReader_deprecatedClass o1, CorSymReader_deprecatedClass o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymReader_deprecatedClass casted = o as CorSymReader_deprecatedClass;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedDocument GetDocument(ref ushort url, System.Guid language, System.Guid languageVendor, System.Guid documentType)
+		{
+			return ISymUnmanagedDocument.Wrap(this.WrappedObject.GetDocument(ref url, language, languageVendor, documentType));
+		}
+		
+		public void GetDocuments(uint cDocs, out uint pcDocs, System.IntPtr pDocs)
+		{
+			this.WrappedObject.GetDocuments(cDocs, out pcDocs, pDocs);
+		}
+		
+		public int GetDocumentVersion(ISymUnmanagedDocument pDoc, out int version)
+		{
+			int pbCurrent;
+			this.WrappedObject.GetDocumentVersion(pDoc.WrappedObject, out version, out pbCurrent);
+			return pbCurrent;
+		}
+		
+		public void GetGlobalVariables(uint cVars, out uint pcVars, System.IntPtr pVars)
+		{
+			this.WrappedObject.GetGlobalVariables(cVars, out pcVars, pVars);
+		}
+		
+		public ISymUnmanagedMethod GetMethod(uint token)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethod(token));
+		}
+		
+		public ISymUnmanagedMethod GetMethodByVersion(uint token, int version)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethodByVersion(token, version));
+		}
+		
+		public ISymUnmanagedMethod GetMethodFromDocumentPosition(ISymUnmanagedDocument document, uint line, uint column)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethodFromDocumentPosition(document.WrappedObject, line, column));
+		}
+		
+		public void GetMethodsFromDocumentPosition(ISymUnmanagedDocument document, uint line, uint column, uint cMethod, out uint pcMethod, System.IntPtr pRetVal)
+		{
+			this.WrappedObject.GetMethodsFromDocumentPosition(document.WrappedObject, line, column, cMethod, out pcMethod, pRetVal);
+		}
+		
+		public int GetMethodVersion(ISymUnmanagedMethod pMethod)
+		{
+			int version;
+			this.WrappedObject.GetMethodVersion(pMethod.WrappedObject, out version);
+			return version;
+		}
+		
+		public void GetNamespaces(uint cNameSpaces, out uint pcNameSpaces, System.IntPtr namespaces)
+		{
+			this.WrappedObject.GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
+		}
+		
+		public void GetSymAttribute(uint parent, ref ushort name, uint cBuffer, out uint pcBuffer, System.IntPtr buffer)
+		{
+			this.WrappedObject.GetSymAttribute(parent, ref name, cBuffer, out pcBuffer, buffer);
+		}
+		
+		public void GetSymbolStoreFileName(uint cchName, out uint pcchName, System.IntPtr szName)
+		{
+			this.WrappedObject.GetSymbolStoreFileName(cchName, out pcchName, szName);
+		}
+		
+		public uint UserEntryPoint
+		{
+			get
+			{
+				return this.WrappedObject.GetUserEntryPoint();
+			}
+		}
+		
+		public void GetVariables(uint parent, uint cVars, out uint pcVars, System.IntPtr pVars)
+		{
+			this.WrappedObject.GetVariables(parent, cVars, out pcVars, pVars);
+		}
+		
+		public void Initialize(object importer, ref ushort filename, ref ushort searchPath, IStream pIStream)
+		{
+			this.WrappedObject.Initialize(importer, ref filename, ref searchPath, pIStream.WrappedObject);
+		}
+		
+		public void ReplaceSymbolStore(ref ushort filename, IStream pIStream)
+		{
+			this.WrappedObject.ReplaceSymbolStore(ref filename, pIStream.WrappedObject);
+		}
+		
+		public void UpdateSymbolStore(ref ushort filename, IStream pIStream)
+		{
+			this.WrappedObject.UpdateSymbolStore(ref filename, pIStream.WrappedObject);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymSearchPolicyAttributes.cs

@@ -0,0 +1,24 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public enum CorSymSearchPolicyAttributes : int
+	{
+		
+		AllowRegistryAccess = 1,
+		
+		AllowSymbolServerAccess = 2,
+		
+		AllowOriginalPathAccess = 4,
+		
+		AllowReferencePathAccess = 8,
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymVarFlag.cs

@@ -0,0 +1,18 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public enum CorSymVarFlag : int
+	{
+		
+		VAR_IS_COMP_GEN = 1,
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymWriter_SxS.cs

@@ -0,0 +1,91 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymWriter_SxS
+	{
+		
+		private Debugger.Interop.CorSym.CorSymWriter_SxS wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymWriter_SxS WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymWriter_SxS(Debugger.Interop.CorSym.CorSymWriter_SxS wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymWriter_SxS));
+		}
+		
+		public static CorSymWriter_SxS Wrap(Debugger.Interop.CorSym.CorSymWriter_SxS objectToWrap)
+		{
+			return new CorSymWriter_SxS(objectToWrap);
+		}
+		
+		~CorSymWriter_SxS()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymWriter_SxS));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymWriter_SxS o1, CorSymWriter_SxS o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymWriter_SxS o1, CorSymWriter_SxS o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymWriter_SxS casted = o as CorSymWriter_SxS;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymWriter_SxSClass.cs

@@ -0,0 +1,211 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymWriter_SxSClass
+	{
+		
+		private Debugger.Interop.CorSym.CorSymWriter_SxSClass wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymWriter_SxSClass WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymWriter_SxSClass(Debugger.Interop.CorSym.CorSymWriter_SxSClass wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymWriter_SxSClass));
+		}
+		
+		public static CorSymWriter_SxSClass Wrap(Debugger.Interop.CorSym.CorSymWriter_SxSClass objectToWrap)
+		{
+			return new CorSymWriter_SxSClass(objectToWrap);
+		}
+		
+		~CorSymWriter_SxSClass()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymWriter_SxSClass));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymWriter_SxSClass o1, CorSymWriter_SxSClass o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymWriter_SxSClass o1, CorSymWriter_SxSClass o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymWriter_SxSClass casted = o as CorSymWriter_SxSClass;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public void Abort()
+		{
+			this.WrappedObject.Abort();
+		}
+		
+		public void Close()
+		{
+			this.WrappedObject.Close();
+		}
+		
+		public void CloseMethod()
+		{
+			this.WrappedObject.CloseMethod();
+		}
+		
+		public void CloseNamespace()
+		{
+			this.WrappedObject.CloseNamespace();
+		}
+		
+		public void CloseScope(uint endOffset)
+		{
+			this.WrappedObject.CloseScope(endOffset);
+		}
+		
+		public void DefineConstant(ref ushort name, object value, uint cSig, ref byte signature)
+		{
+			this.WrappedObject.DefineConstant(ref name, value, cSig, ref signature);
+		}
+		
+		public ISymUnmanagedDocumentWriter DefineDocument(ref ushort url, ref System.Guid language, ref System.Guid languageVendor, ref System.Guid documentType)
+		{
+			return ISymUnmanagedDocumentWriter.Wrap(this.WrappedObject.DefineDocument(ref url, ref language, ref languageVendor, ref documentType));
+		}
+		
+		public void DefineField(uint parent, ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineField(parent, ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineGlobalVariable(ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineGlobalVariable(ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineLocalVariable(ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.DefineLocalVariable(ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3, startOffset, endOffset);
+		}
+		
+		public void DefineParameter(ref ushort name, uint attributes, uint sequence, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineParameter(ref name, attributes, sequence, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineSequencePoints(ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
+		{
+			this.WrappedObject.DefineSequencePoints(document.WrappedObject, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
+		}
+		
+		public void GetDebugInfo(ref uint pIDD, uint cData, out uint pcData, System.IntPtr data)
+		{
+			this.WrappedObject.GetDebugInfo(ref pIDD, cData, out pcData, data);
+		}
+		
+		public void Initialize(object emitter, ref ushort filename, IStream pIStream, int fFullBuild)
+		{
+			this.WrappedObject.Initialize(emitter, ref filename, pIStream.WrappedObject, fFullBuild);
+		}
+		
+		public void Initialize2(object emitter, ref ushort tempfilename, IStream pIStream, int fFullBuild, ref ushort finalfilename)
+		{
+			this.WrappedObject.Initialize2(emitter, ref tempfilename, pIStream.WrappedObject, fFullBuild, ref finalfilename);
+		}
+		
+		public void OpenMethod(uint method)
+		{
+			this.WrappedObject.OpenMethod(method);
+		}
+		
+		public void OpenNamespace(ref ushort name)
+		{
+			this.WrappedObject.OpenNamespace(ref name);
+		}
+		
+		public uint OpenScope(uint startOffset)
+		{
+			return this.WrappedObject.OpenScope(startOffset);
+		}
+		
+		public void RemapToken(uint oldToken, uint newToken)
+		{
+			this.WrappedObject.RemapToken(oldToken, newToken);
+		}
+		
+		public void SetMethodSourceRange(ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
+		{
+			this.WrappedObject.SetMethodSourceRange(startDoc.WrappedObject, startLine, startColumn, endDoc.WrappedObject, endLine, endColumn);
+		}
+		
+		public void SetScopeRange(uint scopeID, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.SetScopeRange(scopeID, startOffset, endOffset);
+		}
+		
+		public void SetSymAttribute(uint parent, ref ushort name, uint cData, ref byte data)
+		{
+			this.WrappedObject.SetSymAttribute(parent, ref name, cData, ref data);
+		}
+		
+		public void SetUserEntryPoint(uint entryMethod)
+		{
+			this.WrappedObject.SetUserEntryPoint(entryMethod);
+		}
+		
+		public void UsingNamespace(ref ushort fullName)
+		{
+			this.WrappedObject.UsingNamespace(ref fullName);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymWriter_deprecated.cs

@@ -0,0 +1,91 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymWriter_deprecated
+	{
+		
+		private Debugger.Interop.CorSym.CorSymWriter_deprecated wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymWriter_deprecated WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymWriter_deprecated(Debugger.Interop.CorSym.CorSymWriter_deprecated wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymWriter_deprecated));
+		}
+		
+		public static CorSymWriter_deprecated Wrap(Debugger.Interop.CorSym.CorSymWriter_deprecated objectToWrap)
+		{
+			return new CorSymWriter_deprecated(objectToWrap);
+		}
+		
+		~CorSymWriter_deprecated()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymWriter_deprecated));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymWriter_deprecated o1, CorSymWriter_deprecated o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymWriter_deprecated o1, CorSymWriter_deprecated o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymWriter_deprecated casted = o as CorSymWriter_deprecated;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/CorSymWriter_deprecatedClass.cs

@@ -0,0 +1,211 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class CorSymWriter_deprecatedClass
+	{
+		
+		private Debugger.Interop.CorSym.CorSymWriter_deprecatedClass wrappedObject;
+		
+		internal Debugger.Interop.CorSym.CorSymWriter_deprecatedClass WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public CorSymWriter_deprecatedClass(Debugger.Interop.CorSym.CorSymWriter_deprecatedClass wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(CorSymWriter_deprecatedClass));
+		}
+		
+		public static CorSymWriter_deprecatedClass Wrap(Debugger.Interop.CorSym.CorSymWriter_deprecatedClass objectToWrap)
+		{
+			return new CorSymWriter_deprecatedClass(objectToWrap);
+		}
+		
+		~CorSymWriter_deprecatedClass()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(CorSymWriter_deprecatedClass));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(CorSymWriter_deprecatedClass o1, CorSymWriter_deprecatedClass o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(CorSymWriter_deprecatedClass o1, CorSymWriter_deprecatedClass o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			CorSymWriter_deprecatedClass casted = o as CorSymWriter_deprecatedClass;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public void Abort()
+		{
+			this.WrappedObject.Abort();
+		}
+		
+		public void Close()
+		{
+			this.WrappedObject.Close();
+		}
+		
+		public void CloseMethod()
+		{
+			this.WrappedObject.CloseMethod();
+		}
+		
+		public void CloseNamespace()
+		{
+			this.WrappedObject.CloseNamespace();
+		}
+		
+		public void CloseScope(uint endOffset)
+		{
+			this.WrappedObject.CloseScope(endOffset);
+		}
+		
+		public void DefineConstant(ref ushort name, object value, uint cSig, ref byte signature)
+		{
+			this.WrappedObject.DefineConstant(ref name, value, cSig, ref signature);
+		}
+		
+		public ISymUnmanagedDocumentWriter DefineDocument(ref ushort url, ref System.Guid language, ref System.Guid languageVendor, ref System.Guid documentType)
+		{
+			return ISymUnmanagedDocumentWriter.Wrap(this.WrappedObject.DefineDocument(ref url, ref language, ref languageVendor, ref documentType));
+		}
+		
+		public void DefineField(uint parent, ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineField(parent, ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineGlobalVariable(ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineGlobalVariable(ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineLocalVariable(ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.DefineLocalVariable(ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3, startOffset, endOffset);
+		}
+		
+		public void DefineParameter(ref ushort name, uint attributes, uint sequence, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineParameter(ref name, attributes, sequence, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineSequencePoints(ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
+		{
+			this.WrappedObject.DefineSequencePoints(document.WrappedObject, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
+		}
+		
+		public void GetDebugInfo(ref uint pIDD, uint cData, out uint pcData, System.IntPtr data)
+		{
+			this.WrappedObject.GetDebugInfo(ref pIDD, cData, out pcData, data);
+		}
+		
+		public void Initialize(object emitter, ref ushort filename, IStream pIStream, int fFullBuild)
+		{
+			this.WrappedObject.Initialize(emitter, ref filename, pIStream.WrappedObject, fFullBuild);
+		}
+		
+		public void Initialize2(object emitter, ref ushort tempfilename, IStream pIStream, int fFullBuild, ref ushort finalfilename)
+		{
+			this.WrappedObject.Initialize2(emitter, ref tempfilename, pIStream.WrappedObject, fFullBuild, ref finalfilename);
+		}
+		
+		public void OpenMethod(uint method)
+		{
+			this.WrappedObject.OpenMethod(method);
+		}
+		
+		public void OpenNamespace(ref ushort name)
+		{
+			this.WrappedObject.OpenNamespace(ref name);
+		}
+		
+		public uint OpenScope(uint startOffset)
+		{
+			return this.WrappedObject.OpenScope(startOffset);
+		}
+		
+		public void RemapToken(uint oldToken, uint newToken)
+		{
+			this.WrappedObject.RemapToken(oldToken, newToken);
+		}
+		
+		public void SetMethodSourceRange(ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
+		{
+			this.WrappedObject.SetMethodSourceRange(startDoc.WrappedObject, startLine, startColumn, endDoc.WrappedObject, endLine, endColumn);
+		}
+		
+		public void SetScopeRange(uint scopeID, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.SetScopeRange(scopeID, startOffset, endOffset);
+		}
+		
+		public void SetSymAttribute(uint parent, ref ushort name, uint cData, ref byte data)
+		{
+			this.WrappedObject.SetSymAttribute(parent, ref name, cData, ref data);
+		}
+		
+		public void SetUserEntryPoint(uint entryMethod)
+		{
+			this.WrappedObject.SetUserEntryPoint(entryMethod);
+		}
+		
+		public void UsingNamespace(ref ushort fullName)
+		{
+			this.WrappedObject.UsingNamespace(ref fullName);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISequentialStream.cs

@@ -0,0 +1,105 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISequentialStream
+	{
+		
+		private Debugger.Interop.CorSym.ISequentialStream wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISequentialStream WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISequentialStream(Debugger.Interop.CorSym.ISequentialStream wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISequentialStream));
+		}
+		
+		public static ISequentialStream Wrap(Debugger.Interop.CorSym.ISequentialStream objectToWrap)
+		{
+			return new ISequentialStream(objectToWrap);
+		}
+		
+		~ISequentialStream()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISequentialStream));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISequentialStream o1, ISequentialStream o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISequentialStream o1, ISequentialStream o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISequentialStream casted = o as ISequentialStream;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public uint RemoteRead(out byte pv, uint cb)
+		{
+			uint pcbRead;
+			this.WrappedObject.RemoteRead(out pv, cb, out pcbRead);
+			return pcbRead;
+		}
+		
+		public uint RemoteWrite(ref byte pv, uint cb)
+		{
+			uint pcbWritten;
+			this.WrappedObject.RemoteWrite(ref pv, cb, out pcbWritten);
+			return pcbWritten;
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/IStream.cs

@@ -0,0 +1,158 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class IStream
+	{
+		
+		private Debugger.Interop.CorSym.IStream wrappedObject;
+		
+		internal Debugger.Interop.CorSym.IStream WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public IStream(Debugger.Interop.CorSym.IStream wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(IStream));
+		}
+		
+		public static IStream Wrap(Debugger.Interop.CorSym.IStream objectToWrap)
+		{
+			return new IStream(objectToWrap);
+		}
+		
+		~IStream()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(IStream));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(IStream o1, IStream o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(IStream o1, IStream o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			IStream casted = o as IStream;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public uint RemoteRead(out byte pv, uint cb)
+		{
+			uint pcbRead;
+			this.WrappedObject.RemoteRead(out pv, cb, out pcbRead);
+			return pcbRead;
+		}
+		
+		public uint RemoteWrite(ref byte pv, uint cb)
+		{
+			uint pcbWritten;
+			this.WrappedObject.RemoteWrite(ref pv, cb, out pcbWritten);
+			return pcbWritten;
+		}
+		
+		public Debugger.Interop.CorSym._ULARGE_INTEGER RemoteSeek(Debugger.Interop.CorSym._LARGE_INTEGER dlibMove, uint dwOrigin)
+		{
+			Debugger.Interop.CorSym._ULARGE_INTEGER plibNewPosition;
+			this.WrappedObject.RemoteSeek(dlibMove, dwOrigin, out plibNewPosition);
+			return plibNewPosition;
+		}
+		
+		public void SetSize(Debugger.Interop.CorSym._ULARGE_INTEGER libNewSize)
+		{
+			this.WrappedObject.SetSize(libNewSize);
+		}
+		
+		public Debugger.Interop.CorSym._ULARGE_INTEGER RemoteCopyTo(IStream pstm, Debugger.Interop.CorSym._ULARGE_INTEGER cb, out Debugger.Interop.CorSym._ULARGE_INTEGER pcbRead)
+		{
+			Debugger.Interop.CorSym._ULARGE_INTEGER pcbWritten;
+			this.WrappedObject.RemoteCopyTo(pstm.WrappedObject, cb, out pcbRead, out pcbWritten);
+			return pcbWritten;
+		}
+		
+		public void Commit(uint grfCommitFlags)
+		{
+			this.WrappedObject.Commit(grfCommitFlags);
+		}
+		
+		public void Revert()
+		{
+			this.WrappedObject.Revert();
+		}
+		
+		public void LockRegion(Debugger.Interop.CorSym._ULARGE_INTEGER libOffset, Debugger.Interop.CorSym._ULARGE_INTEGER cb, uint dwLockType)
+		{
+			this.WrappedObject.LockRegion(libOffset, cb, dwLockType);
+		}
+		
+		public void UnlockRegion(Debugger.Interop.CorSym._ULARGE_INTEGER libOffset, Debugger.Interop.CorSym._ULARGE_INTEGER cb, uint dwLockType)
+		{
+			this.WrappedObject.UnlockRegion(libOffset, cb, dwLockType);
+		}
+		
+		public void Stat(out Debugger.Interop.CorSym.tagSTATSTG pstatstg, uint grfStatFlag)
+		{
+			this.WrappedObject.Stat(out pstatstg, grfStatFlag);
+		}
+		
+		public IStream Clone()
+		{
+			IStream ppstm;
+			Debugger.Interop.CorSym.IStream out_ppstm;
+			this.WrappedObject.Clone(out out_ppstm);
+			ppstm = IStream.Wrap(out_ppstm);
+			return ppstm;
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedBinder.cs

@@ -0,0 +1,101 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedBinder
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedBinder wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedBinder WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedBinder(Debugger.Interop.CorSym.ISymUnmanagedBinder wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedBinder));
+		}
+		
+		public static ISymUnmanagedBinder Wrap(Debugger.Interop.CorSym.ISymUnmanagedBinder objectToWrap)
+		{
+			return new ISymUnmanagedBinder(objectToWrap);
+		}
+		
+		~ISymUnmanagedBinder()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedBinder));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedBinder o1, ISymUnmanagedBinder o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedBinder o1, ISymUnmanagedBinder o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedBinder casted = o as ISymUnmanagedBinder;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedReader GetReaderForFile(object importer, ref ushort filename, ref ushort searchPath)
+		{
+			return ISymUnmanagedReader.Wrap(this.WrappedObject.GetReaderForFile(importer, ref filename, ref searchPath));
+		}
+		
+		public ISymUnmanagedReader GetReaderFromStream(object importer, IStream pstream)
+		{
+			return ISymUnmanagedReader.Wrap(this.WrappedObject.GetReaderFromStream(importer, pstream.WrappedObject));
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedDocument.cs

@@ -0,0 +1,156 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedDocument
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedDocument wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedDocument WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedDocument(Debugger.Interop.CorSym.ISymUnmanagedDocument wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedDocument));
+		}
+		
+		public static ISymUnmanagedDocument Wrap(Debugger.Interop.CorSym.ISymUnmanagedDocument objectToWrap)
+		{
+			return new ISymUnmanagedDocument(objectToWrap);
+		}
+		
+		~ISymUnmanagedDocument()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedDocument));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedDocument o1, ISymUnmanagedDocument o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedDocument o1, ISymUnmanagedDocument o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedDocument casted = o as ISymUnmanagedDocument;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public void GetURL(uint cchUrl, out uint pcchUrl, System.IntPtr szUrl)
+		{
+			this.WrappedObject.GetURL(cchUrl, out pcchUrl, szUrl);
+		}
+		
+		public System.Guid DocumentType
+		{
+			get
+			{
+				return this.WrappedObject.GetDocumentType();
+			}
+		}
+		
+		public System.Guid Language
+		{
+			get
+			{
+				return this.WrappedObject.GetLanguage();
+			}
+		}
+		
+		public System.Guid LanguageVendor
+		{
+			get
+			{
+				return this.WrappedObject.GetLanguageVendor();
+			}
+		}
+		
+		public System.Guid CheckSumAlgorithmId
+		{
+			get
+			{
+				return this.WrappedObject.GetCheckSumAlgorithmId();
+			}
+		}
+		
+		public void GetCheckSum(uint cData, out uint pcData, System.IntPtr data)
+		{
+			this.WrappedObject.GetCheckSum(cData, out pcData, data);
+		}
+		
+		public uint FindClosestLine(uint line)
+		{
+			return this.WrappedObject.FindClosestLine(line);
+		}
+		
+		public int HasEmbeddedSource()
+		{
+			return this.WrappedObject.HasEmbeddedSource();
+		}
+		
+		public uint SourceLength
+		{
+			get
+			{
+				return this.WrappedObject.GetSourceLength();
+			}
+		}
+		
+		public void GetSourceRange(uint startLine, uint startColumn, uint endLine, uint endColumn, uint cSourceBytes, out uint pcSourceBytes, System.IntPtr source)
+		{
+			this.WrappedObject.GetSourceRange(startLine, startColumn, endLine, endColumn, cSourceBytes, out pcSourceBytes, source);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedDocumentWriter.cs

@@ -0,0 +1,101 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedDocumentWriter
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedDocumentWriter wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedDocumentWriter WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedDocumentWriter(Debugger.Interop.CorSym.ISymUnmanagedDocumentWriter wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedDocumentWriter));
+		}
+		
+		public static ISymUnmanagedDocumentWriter Wrap(Debugger.Interop.CorSym.ISymUnmanagedDocumentWriter objectToWrap)
+		{
+			return new ISymUnmanagedDocumentWriter(objectToWrap);
+		}
+		
+		~ISymUnmanagedDocumentWriter()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedDocumentWriter));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedDocumentWriter o1, ISymUnmanagedDocumentWriter o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedDocumentWriter o1, ISymUnmanagedDocumentWriter o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedDocumentWriter casted = o as ISymUnmanagedDocumentWriter;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public void SetSource(uint sourceSize, ref byte source)
+		{
+			this.WrappedObject.SetSource(sourceSize, ref source);
+		}
+		
+		public void SetCheckSum(System.Guid algorithmId, uint checkSumSize, ref byte checkSum)
+		{
+			this.WrappedObject.SetCheckSum(algorithmId, checkSumSize, ref checkSum);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedMethod.cs

@@ -0,0 +1,179 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedMethod
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedMethod wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedMethod WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedMethod(Debugger.Interop.CorSym.ISymUnmanagedMethod wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedMethod));
+		}
+		
+		public static ISymUnmanagedMethod Wrap(Debugger.Interop.CorSym.ISymUnmanagedMethod objectToWrap)
+		{
+			return new ISymUnmanagedMethod(objectToWrap);
+		}
+		
+		~ISymUnmanagedMethod()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedMethod));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedMethod o1, ISymUnmanagedMethod o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedMethod o1, ISymUnmanagedMethod o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedMethod casted = o as ISymUnmanagedMethod;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public uint Token
+		{
+			get
+			{
+				return this.WrappedObject.GetToken();
+			}
+		}
+		
+		public uint SequencePointCount
+		{
+			get
+			{
+				return this.WrappedObject.GetSequencePointCount();
+			}
+		}
+		
+		public ISymUnmanagedScope RootScope
+		{
+			get
+			{
+				return ISymUnmanagedScope.Wrap(this.WrappedObject.GetRootScope());
+			}
+		}
+		
+		public ISymUnmanagedScope GetScopeFromOffset(uint offset)
+		{
+			return ISymUnmanagedScope.Wrap(this.WrappedObject.GetScopeFromOffset(offset));
+		}
+		
+		public uint GetOffset(ISymUnmanagedDocument document, uint line, uint column)
+		{
+			return this.WrappedObject.GetOffset(document.WrappedObject, line, column);
+		}
+		
+		public void GetRanges(ISymUnmanagedDocument document, uint line, uint column, uint cRanges, out uint pcRanges, System.IntPtr ranges)
+		{
+			this.WrappedObject.GetRanges(document.WrappedObject, line, column, cRanges, out pcRanges, ranges);
+		}
+		
+		public void GetParameters(uint cParams, out uint pcParams, System.IntPtr @params)
+		{
+			this.WrappedObject.GetParameters(cParams, out pcParams, @params);
+		}
+		
+		public ISymUnmanagedNamespace Namespace
+		{
+			get
+			{
+				ISymUnmanagedNamespace pRetVal;
+				Debugger.Interop.CorSym.ISymUnmanagedNamespace out_pRetVal;
+				this.WrappedObject.GetNamespace(out out_pRetVal);
+				pRetVal = ISymUnmanagedNamespace.Wrap(out_pRetVal);
+				return pRetVal;
+			}
+		}
+		
+		public int GetSourceStartEnd(ISymUnmanagedDocument[] docs, uint[] lines, uint[] columns)
+		{
+			int pRetVal;
+			Debugger.Interop.CorSym.ISymUnmanagedDocument[] array_docs = new Debugger.Interop.CorSym.ISymUnmanagedDocument[docs.Length];
+			for (int i = 0; (i < docs.Length); i = (i + 1))
+			{
+				if ((docs[i] != null))
+				{
+					array_docs[i] = docs[i].WrappedObject;
+				}
+			}
+			this.WrappedObject.GetSourceStartEnd(array_docs, lines, columns, out pRetVal);
+			for (int i = 0; (i < docs.Length); i = (i + 1))
+			{
+				if ((array_docs[i] != null))
+				{
+					docs[i] = ISymUnmanagedDocument.Wrap(array_docs[i]);
+				} else
+				{
+					docs[i] = null;
+				}
+			}
+			return pRetVal;
+		}
+		
+		public void GetSequencePoints(uint cPoints, out uint pcPoints, ref uint offsets, ref ISymUnmanagedDocument documents, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
+		{
+			Debugger.Interop.CorSym.ISymUnmanagedDocument ref_documents = documents.WrappedObject;
+			this.WrappedObject.GetSequencePoints(cPoints, out pcPoints, ref offsets, ref ref_documents, ref lines, ref columns, ref endLines, ref endColumns);
+			documents = ISymUnmanagedDocument.Wrap(ref_documents);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedNamespace.cs

@@ -0,0 +1,106 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedNamespace
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedNamespace wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedNamespace WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedNamespace(Debugger.Interop.CorSym.ISymUnmanagedNamespace wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedNamespace));
+		}
+		
+		public static ISymUnmanagedNamespace Wrap(Debugger.Interop.CorSym.ISymUnmanagedNamespace objectToWrap)
+		{
+			return new ISymUnmanagedNamespace(objectToWrap);
+		}
+		
+		~ISymUnmanagedNamespace()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedNamespace));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedNamespace o1, ISymUnmanagedNamespace o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedNamespace o1, ISymUnmanagedNamespace o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedNamespace casted = o as ISymUnmanagedNamespace;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public void GetName(uint cchName, out uint pcchName, System.IntPtr szName)
+		{
+			this.WrappedObject.GetName(cchName, out pcchName, szName);
+		}
+		
+		public void GetNamespaces(uint cNameSpaces, out uint pcNameSpaces, System.IntPtr namespaces)
+		{
+			this.WrappedObject.GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
+		}
+		
+		public void GetVariables(uint cVars, out uint pcVars, System.IntPtr pVars)
+		{
+			this.WrappedObject.GetVariables(cVars, out pcVars, pVars);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedReader.cs

@@ -0,0 +1,183 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedReader
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedReader wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedReader WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedReader(Debugger.Interop.CorSym.ISymUnmanagedReader wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedReader));
+		}
+		
+		public static ISymUnmanagedReader Wrap(Debugger.Interop.CorSym.ISymUnmanagedReader objectToWrap)
+		{
+			return new ISymUnmanagedReader(objectToWrap);
+		}
+		
+		~ISymUnmanagedReader()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedReader));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedReader o1, ISymUnmanagedReader o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedReader o1, ISymUnmanagedReader o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedReader casted = o as ISymUnmanagedReader;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedDocument GetDocument(ref ushort url, System.Guid language, System.Guid languageVendor, System.Guid documentType)
+		{
+			return ISymUnmanagedDocument.Wrap(this.WrappedObject.GetDocument(ref url, language, languageVendor, documentType));
+		}
+		
+		public void GetDocuments(uint cDocs, out uint pcDocs, System.IntPtr pDocs)
+		{
+			this.WrappedObject.GetDocuments(cDocs, out pcDocs, pDocs);
+		}
+		
+		public uint UserEntryPoint
+		{
+			get
+			{
+				return this.WrappedObject.GetUserEntryPoint();
+			}
+		}
+		
+		public ISymUnmanagedMethod GetMethod(uint token)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethod(token));
+		}
+		
+		public ISymUnmanagedMethod GetMethodByVersion(uint token, int version)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethodByVersion(token, version));
+		}
+		
+		public void GetVariables(uint parent, uint cVars, out uint pcVars, System.IntPtr pVars)
+		{
+			this.WrappedObject.GetVariables(parent, cVars, out pcVars, pVars);
+		}
+		
+		public void GetGlobalVariables(uint cVars, out uint pcVars, System.IntPtr pVars)
+		{
+			this.WrappedObject.GetGlobalVariables(cVars, out pcVars, pVars);
+		}
+		
+		public ISymUnmanagedMethod GetMethodFromDocumentPosition(ISymUnmanagedDocument document, uint line, uint column)
+		{
+			return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethodFromDocumentPosition(document.WrappedObject, line, column));
+		}
+		
+		public void GetSymAttribute(uint parent, ref ushort name, uint cBuffer, out uint pcBuffer, System.IntPtr buffer)
+		{
+			this.WrappedObject.GetSymAttribute(parent, ref name, cBuffer, out pcBuffer, buffer);
+		}
+		
+		public void GetNamespaces(uint cNameSpaces, out uint pcNameSpaces, System.IntPtr namespaces)
+		{
+			this.WrappedObject.GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
+		}
+		
+		public void Initialize(object importer, ref ushort filename, ref ushort searchPath, IStream pIStream)
+		{
+			this.WrappedObject.Initialize(importer, ref filename, ref searchPath, pIStream.WrappedObject);
+		}
+		
+		public void UpdateSymbolStore(ref ushort filename, IStream pIStream)
+		{
+			this.WrappedObject.UpdateSymbolStore(ref filename, pIStream.WrappedObject);
+		}
+		
+		public void ReplaceSymbolStore(ref ushort filename, IStream pIStream)
+		{
+			this.WrappedObject.ReplaceSymbolStore(ref filename, pIStream.WrappedObject);
+		}
+		
+		public void GetSymbolStoreFileName(uint cchName, out uint pcchName, System.IntPtr szName)
+		{
+			this.WrappedObject.GetSymbolStoreFileName(cchName, out pcchName, szName);
+		}
+		
+		public void GetMethodsFromDocumentPosition(ISymUnmanagedDocument document, uint line, uint column, uint cMethod, out uint pcMethod, System.IntPtr pRetVal)
+		{
+			this.WrappedObject.GetMethodsFromDocumentPosition(document.WrappedObject, line, column, cMethod, out pcMethod, pRetVal);
+		}
+		
+		public int GetDocumentVersion(ISymUnmanagedDocument pDoc, out int version)
+		{
+			int pbCurrent;
+			this.WrappedObject.GetDocumentVersion(pDoc.WrappedObject, out version, out pbCurrent);
+			return pbCurrent;
+		}
+		
+		public int GetMethodVersion(ISymUnmanagedMethod pMethod)
+		{
+			int version;
+			this.WrappedObject.GetMethodVersion(pMethod.WrappedObject, out version);
+			return version;
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedReaderSymbolSearchInfo.cs

@@ -0,0 +1,110 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedReaderSymbolSearchInfo
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedReaderSymbolSearchInfo wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedReaderSymbolSearchInfo WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedReaderSymbolSearchInfo(Debugger.Interop.CorSym.ISymUnmanagedReaderSymbolSearchInfo wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedReaderSymbolSearchInfo));
+		}
+		
+		public static ISymUnmanagedReaderSymbolSearchInfo Wrap(Debugger.Interop.CorSym.ISymUnmanagedReaderSymbolSearchInfo objectToWrap)
+		{
+			return new ISymUnmanagedReaderSymbolSearchInfo(objectToWrap);
+		}
+		
+		~ISymUnmanagedReaderSymbolSearchInfo()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedReaderSymbolSearchInfo));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedReaderSymbolSearchInfo o1, ISymUnmanagedReaderSymbolSearchInfo o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedReaderSymbolSearchInfo o1, ISymUnmanagedReaderSymbolSearchInfo o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedReaderSymbolSearchInfo casted = o as ISymUnmanagedReaderSymbolSearchInfo;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public uint SymbolSearchInfoCount
+		{
+			get
+			{
+				uint pcSearchInfo;
+				this.WrappedObject.GetSymbolSearchInfoCount(out pcSearchInfo);
+				return pcSearchInfo;
+			}
+		}
+		
+		public ISymUnmanagedSymbolSearchInfo GetSymbolSearchInfo(uint cSearchInfo, out uint pcSearchInfo)
+		{
+			ISymUnmanagedSymbolSearchInfo rgpSearchInfo;
+			Debugger.Interop.CorSym.ISymUnmanagedSymbolSearchInfo out_rgpSearchInfo;
+			this.WrappedObject.GetSymbolSearchInfo(cSearchInfo, out pcSearchInfo, out out_rgpSearchInfo);
+			rgpSearchInfo = ISymUnmanagedSymbolSearchInfo.Wrap(out_rgpSearchInfo);
+			return rgpSearchInfo;
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedScope.cs

@@ -0,0 +1,146 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedScope
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedScope wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedScope WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedScope(Debugger.Interop.CorSym.ISymUnmanagedScope wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedScope));
+		}
+		
+		public static ISymUnmanagedScope Wrap(Debugger.Interop.CorSym.ISymUnmanagedScope objectToWrap)
+		{
+			return new ISymUnmanagedScope(objectToWrap);
+		}
+		
+		~ISymUnmanagedScope()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedScope));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedScope o1, ISymUnmanagedScope o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedScope o1, ISymUnmanagedScope o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedScope casted = o as ISymUnmanagedScope;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedMethod Method
+		{
+			get
+			{
+				return ISymUnmanagedMethod.Wrap(this.WrappedObject.GetMethod());
+			}
+		}
+		
+		public ISymUnmanagedScope Parent
+		{
+			get
+			{
+				return ISymUnmanagedScope.Wrap(this.WrappedObject.GetParent());
+			}
+		}
+		
+		public void GetChildren(uint cChildren, out uint pcChildren, System.IntPtr children)
+		{
+			this.WrappedObject.GetChildren(cChildren, out pcChildren, children);
+		}
+		
+		public uint StartOffset
+		{
+			get
+			{
+				return this.WrappedObject.GetStartOffset();
+			}
+		}
+		
+		public uint EndOffset
+		{
+			get
+			{
+				return this.WrappedObject.GetEndOffset();
+			}
+		}
+		
+		public uint LocalCount
+		{
+			get
+			{
+				return this.WrappedObject.GetLocalCount();
+			}
+		}
+		
+		public void GetLocals(uint cLocals, out uint pcLocals, System.IntPtr locals)
+		{
+			this.WrappedObject.GetLocals(cLocals, out pcLocals, locals);
+		}
+		
+		public void GetNamespaces(uint cNameSpaces, out uint pcNameSpaces, System.IntPtr namespaces)
+		{
+			this.WrappedObject.GetNamespaces(cNameSpaces, out pcNameSpaces, namespaces);
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedSymbolSearchInfo.cs

@@ -0,0 +1,116 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedSymbolSearchInfo
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedSymbolSearchInfo wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedSymbolSearchInfo WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedSymbolSearchInfo(Debugger.Interop.CorSym.ISymUnmanagedSymbolSearchInfo wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedSymbolSearchInfo));
+		}
+		
+		public static ISymUnmanagedSymbolSearchInfo Wrap(Debugger.Interop.CorSym.ISymUnmanagedSymbolSearchInfo objectToWrap)
+		{
+			return new ISymUnmanagedSymbolSearchInfo(objectToWrap);
+		}
+		
+		~ISymUnmanagedSymbolSearchInfo()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedSymbolSearchInfo));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedSymbolSearchInfo o1, ISymUnmanagedSymbolSearchInfo o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedSymbolSearchInfo o1, ISymUnmanagedSymbolSearchInfo o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedSymbolSearchInfo casted = o as ISymUnmanagedSymbolSearchInfo;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public uint SearchPathLength
+		{
+			get
+			{
+				uint pcchPath;
+				this.WrappedObject.GetSearchPathLength(out pcchPath);
+				return pcchPath;
+			}
+		}
+		
+		public void GetSearchPath(uint cchPath, out uint pcchPath, System.IntPtr szPath)
+		{
+			this.WrappedObject.GetSearchPath(cchPath, out pcchPath, szPath);
+		}
+		
+		public int HRESULT
+		{
+			get
+			{
+				int phr;
+				this.WrappedObject.GetHRESULT(out phr);
+				return phr;
+			}
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedVariable.cs

@@ -0,0 +1,157 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedVariable
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedVariable wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedVariable WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedVariable(Debugger.Interop.CorSym.ISymUnmanagedVariable wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedVariable));
+		}
+		
+		public static ISymUnmanagedVariable Wrap(Debugger.Interop.CorSym.ISymUnmanagedVariable objectToWrap)
+		{
+			return new ISymUnmanagedVariable(objectToWrap);
+		}
+		
+		~ISymUnmanagedVariable()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedVariable));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedVariable o1, ISymUnmanagedVariable o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedVariable o1, ISymUnmanagedVariable o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedVariable casted = o as ISymUnmanagedVariable;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public void GetName(uint cchName, out uint pcchName, System.IntPtr szName)
+		{
+			this.WrappedObject.GetName(cchName, out pcchName, szName);
+		}
+		
+		public uint Attributes
+		{
+			get
+			{
+				return this.WrappedObject.GetAttributes();
+			}
+		}
+		
+		public void GetSignature(uint cSig, out uint pcSig, System.IntPtr sig)
+		{
+			this.WrappedObject.GetSignature(cSig, out pcSig, sig);
+		}
+		
+		public uint AddressKind
+		{
+			get
+			{
+				return this.WrappedObject.GetAddressKind();
+			}
+		}
+		
+		public uint AddressField1
+		{
+			get
+			{
+				return this.WrappedObject.GetAddressField1();
+			}
+		}
+		
+		public uint AddressField2
+		{
+			get
+			{
+				return this.WrappedObject.GetAddressField2();
+			}
+		}
+		
+		public uint AddressField3
+		{
+			get
+			{
+				return this.WrappedObject.GetAddressField3();
+			}
+		}
+		
+		public uint StartOffset
+		{
+			get
+			{
+				return this.WrappedObject.GetStartOffset();
+			}
+		}
+		
+		public uint EndOffset
+		{
+			get
+			{
+				return this.WrappedObject.GetEndOffset();
+			}
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedWriter.cs

@@ -0,0 +1,211 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedWriter
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedWriter wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedWriter WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedWriter(Debugger.Interop.CorSym.ISymUnmanagedWriter wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedWriter));
+		}
+		
+		public static ISymUnmanagedWriter Wrap(Debugger.Interop.CorSym.ISymUnmanagedWriter objectToWrap)
+		{
+			return new ISymUnmanagedWriter(objectToWrap);
+		}
+		
+		~ISymUnmanagedWriter()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedWriter));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedWriter o1, ISymUnmanagedWriter o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedWriter o1, ISymUnmanagedWriter o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedWriter casted = o as ISymUnmanagedWriter;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedDocumentWriter DefineDocument(ref ushort url, ref System.Guid language, ref System.Guid languageVendor, ref System.Guid documentType)
+		{
+			return ISymUnmanagedDocumentWriter.Wrap(this.WrappedObject.DefineDocument(ref url, ref language, ref languageVendor, ref documentType));
+		}
+		
+		public void SetUserEntryPoint(uint entryMethod)
+		{
+			this.WrappedObject.SetUserEntryPoint(entryMethod);
+		}
+		
+		public void OpenMethod(uint method)
+		{
+			this.WrappedObject.OpenMethod(method);
+		}
+		
+		public void CloseMethod()
+		{
+			this.WrappedObject.CloseMethod();
+		}
+		
+		public uint OpenScope(uint startOffset)
+		{
+			return this.WrappedObject.OpenScope(startOffset);
+		}
+		
+		public void CloseScope(uint endOffset)
+		{
+			this.WrappedObject.CloseScope(endOffset);
+		}
+		
+		public void SetScopeRange(uint scopeID, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.SetScopeRange(scopeID, startOffset, endOffset);
+		}
+		
+		public void DefineLocalVariable(ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.DefineLocalVariable(ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3, startOffset, endOffset);
+		}
+		
+		public void DefineParameter(ref ushort name, uint attributes, uint sequence, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineParameter(ref name, attributes, sequence, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineField(uint parent, ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineField(parent, ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineGlobalVariable(ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineGlobalVariable(ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void Close()
+		{
+			this.WrappedObject.Close();
+		}
+		
+		public void SetSymAttribute(uint parent, ref ushort name, uint cData, ref byte data)
+		{
+			this.WrappedObject.SetSymAttribute(parent, ref name, cData, ref data);
+		}
+		
+		public void OpenNamespace(ref ushort name)
+		{
+			this.WrappedObject.OpenNamespace(ref name);
+		}
+		
+		public void CloseNamespace()
+		{
+			this.WrappedObject.CloseNamespace();
+		}
+		
+		public void UsingNamespace(ref ushort fullName)
+		{
+			this.WrappedObject.UsingNamespace(ref fullName);
+		}
+		
+		public void SetMethodSourceRange(ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
+		{
+			this.WrappedObject.SetMethodSourceRange(startDoc.WrappedObject, startLine, startColumn, endDoc.WrappedObject, endLine, endColumn);
+		}
+		
+		public void Initialize(object emitter, ref ushort filename, IStream pIStream, int fFullBuild)
+		{
+			this.WrappedObject.Initialize(emitter, ref filename, pIStream.WrappedObject, fFullBuild);
+		}
+		
+		public void GetDebugInfo(ref uint pIDD, uint cData, out uint pcData, System.IntPtr data)
+		{
+			this.WrappedObject.GetDebugInfo(ref pIDD, cData, out pcData, data);
+		}
+		
+		public void DefineSequencePoints(ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
+		{
+			this.WrappedObject.DefineSequencePoints(document.WrappedObject, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
+		}
+		
+		public void RemapToken(uint oldToken, uint newToken)
+		{
+			this.WrappedObject.RemapToken(oldToken, newToken);
+		}
+		
+		public void Initialize2(object emitter, ref ushort tempfilename, IStream pIStream, int fFullBuild, ref ushort finalfilename)
+		{
+			this.WrappedObject.Initialize2(emitter, ref tempfilename, pIStream.WrappedObject, fFullBuild, ref finalfilename);
+		}
+		
+		public void DefineConstant(ref ushort name, object value, uint cSig, ref byte signature)
+		{
+			this.WrappedObject.DefineConstant(ref name, value, cSig, ref signature);
+		}
+		
+		public void Abort()
+		{
+			this.WrappedObject.Abort();
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorSym/ISymUnmanagedWriter2.cs

@@ -0,0 +1,226 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+namespace Debugger.Wrappers.CorSym
+{
+	using System;
+	
+	
+	public class ISymUnmanagedWriter2
+	{
+		
+		private Debugger.Interop.CorSym.ISymUnmanagedWriter2 wrappedObject;
+		
+		internal Debugger.Interop.CorSym.ISymUnmanagedWriter2 WrappedObject
+		{
+			get
+			{
+				return this.wrappedObject;
+			}
+		}
+		
+		public ISymUnmanagedWriter2(Debugger.Interop.CorSym.ISymUnmanagedWriter2 wrappedObject)
+		{
+			this.wrappedObject = wrappedObject;
+			ResourceManager.TrackCOMObject(wrappedObject, typeof(ISymUnmanagedWriter2));
+		}
+		
+		public static ISymUnmanagedWriter2 Wrap(Debugger.Interop.CorSym.ISymUnmanagedWriter2 objectToWrap)
+		{
+			return new ISymUnmanagedWriter2(objectToWrap);
+		}
+		
+		~ISymUnmanagedWriter2()
+		{
+			object o = wrappedObject;
+			wrappedObject = null;
+			ResourceManager.ReleaseCOMObject(o, typeof(ISymUnmanagedWriter2));
+		}
+		
+		public bool Is<T>() where T: class
+		{
+			try {
+				CastTo<T>();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		
+		public T As<T>() where T: class
+		{
+			try {
+				return CastTo<T>();
+			} catch {
+				return null;
+			}
+		}
+		
+		public T CastTo<T>() where T: class
+		{
+			return (T)Activator.CreateInstance(typeof(T), this.WrappedObject);
+		}
+		
+		public static bool operator ==(ISymUnmanagedWriter2 o1, ISymUnmanagedWriter2 o2)
+		{
+			return ((object)o1 == null && (object)o2 == null) ||
+			       ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject);
+		}
+		
+		public static bool operator !=(ISymUnmanagedWriter2 o1, ISymUnmanagedWriter2 o2)
+		{
+			return !(o1 == o2);
+		}
+		
+		public override int GetHashCode()
+		{
+			return base.GetHashCode();
+		}
+		
+		public override bool Equals(object o)
+		{
+			ISymUnmanagedWriter2 casted = o as ISymUnmanagedWriter2;
+			return (casted != null) && (casted.WrappedObject == wrappedObject);
+		}
+		
+		
+		public ISymUnmanagedDocumentWriter DefineDocument(ref ushort url, ref System.Guid language, ref System.Guid languageVendor, ref System.Guid documentType)
+		{
+			return ISymUnmanagedDocumentWriter.Wrap(this.WrappedObject.DefineDocument(ref url, ref language, ref languageVendor, ref documentType));
+		}
+		
+		public void SetUserEntryPoint(uint entryMethod)
+		{
+			this.WrappedObject.SetUserEntryPoint(entryMethod);
+		}
+		
+		public void OpenMethod(uint method)
+		{
+			this.WrappedObject.OpenMethod(method);
+		}
+		
+		public void CloseMethod()
+		{
+			this.WrappedObject.CloseMethod();
+		}
+		
+		public uint OpenScope(uint startOffset)
+		{
+			return this.WrappedObject.OpenScope(startOffset);
+		}
+		
+		public void CloseScope(uint endOffset)
+		{
+			this.WrappedObject.CloseScope(endOffset);
+		}
+		
+		public void SetScopeRange(uint scopeID, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.SetScopeRange(scopeID, startOffset, endOffset);
+		}
+		
+		public void DefineLocalVariable(ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.DefineLocalVariable(ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3, startOffset, endOffset);
+		}
+		
+		public void DefineParameter(ref ushort name, uint attributes, uint sequence, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineParameter(ref name, attributes, sequence, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineField(uint parent, ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineField(parent, ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineGlobalVariable(ref ushort name, uint attributes, uint cSig, ref byte signature, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineGlobalVariable(ref name, attributes, cSig, ref signature, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void Close()
+		{
+			this.WrappedObject.Close();
+		}
+		
+		public void SetSymAttribute(uint parent, ref ushort name, uint cData, ref byte data)
+		{
+			this.WrappedObject.SetSymAttribute(parent, ref name, cData, ref data);
+		}
+		
+		public void OpenNamespace(ref ushort name)
+		{
+			this.WrappedObject.OpenNamespace(ref name);
+		}
+		
+		public void CloseNamespace()
+		{
+			this.WrappedObject.CloseNamespace();
+		}
+		
+		public void UsingNamespace(ref ushort fullName)
+		{
+			this.WrappedObject.UsingNamespace(ref fullName);
+		}
+		
+		public void SetMethodSourceRange(ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, ISymUnmanagedDocumentWriter endDoc, uint endLine, uint endColumn)
+		{
+			this.WrappedObject.SetMethodSourceRange(startDoc.WrappedObject, startLine, startColumn, endDoc.WrappedObject, endLine, endColumn);
+		}
+		
+		public void Initialize(object emitter, ref ushort filename, IStream pIStream, int fFullBuild)
+		{
+			this.WrappedObject.Initialize(emitter, ref filename, pIStream.WrappedObject, fFullBuild);
+		}
+		
+		public void GetDebugInfo(ref uint pIDD, uint cData, out uint pcData, System.IntPtr data)
+		{
+			this.WrappedObject.GetDebugInfo(ref pIDD, cData, out pcData, data);
+		}
+		
+		public void DefineSequencePoints(ISymUnmanagedDocumentWriter document, uint spCount, ref uint offsets, ref uint lines, ref uint columns, ref uint endLines, ref uint endColumns)
+		{
+			this.WrappedObject.DefineSequencePoints(document.WrappedObject, spCount, ref offsets, ref lines, ref columns, ref endLines, ref endColumns);
+		}
+		
+		public void RemapToken(uint oldToken, uint newToken)
+		{
+			this.WrappedObject.RemapToken(oldToken, newToken);
+		}
+		
+		public void Initialize2(object emitter, ref ushort tempfilename, IStream pIStream, int fFullBuild, ref ushort finalfilename)
+		{
+			this.WrappedObject.Initialize2(emitter, ref tempfilename, pIStream.WrappedObject, fFullBuild, ref finalfilename);
+		}
+		
+		public void DefineConstant(ref ushort name, object value, uint cSig, ref byte signature)
+		{
+			this.WrappedObject.DefineConstant(ref name, value, cSig, ref signature);
+		}
+		
+		public void Abort()
+		{
+			this.WrappedObject.Abort();
+		}
+		
+		public void DefineLocalVariable2(ref ushort name, uint attributes, uint sigToken, uint addrKind, uint addr1, uint addr2, uint addr3, uint startOffset, uint endOffset)
+		{
+			this.WrappedObject.DefineLocalVariable2(ref name, attributes, sigToken, addrKind, addr1, addr2, addr3, startOffset, endOffset);
+		}
+		
+		public void DefineGlobalVariable2(ref ushort name, uint attributes, uint sigToken, uint addrKind, uint addr1, uint addr2, uint addr3)
+		{
+			this.WrappedObject.DefineGlobalVariable2(ref name, attributes, sigToken, addrKind, addr1, addr2, addr3);
+		}
+		
+		public void DefineConstant2(ref ushort name, object value, uint sigToken)
+		{
+			this.WrappedObject.DefineConstant2(ref name, value, sigToken);
+		}
+	}
+}

src/Tools/WrapperGenerator/Debugger/CorSymGenerator.cs

@@ -0,0 +1,46 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+
+using Microsoft.CSharp;
+
+namespace WrapperGenerator
+{
+	public class CorSymGenerator: CodeGenerator
+	{
+		string namespaceToWrap = "Debugger.Interop.CorSym";
+		
+		public CorSymGenerator(Assembly assembly):base(assembly)
+		{
+			wrapperNamespace = "Debugger.Wrappers.CorSym";
+		}
+		
+		protected override bool ShouldIncludeType(Type type)
+		{
+			return type.Namespace == namespaceToWrap &&
+			       (type.IsClass || type.IsInterface || type.IsEnum);
+		}
+		
+		protected override Type GetBaseClass(Type type) 
+		{
+//			Type[] interfaces = type.GetInterfaces();
+//			if (interfaces.Length > 0) {
+//				return interfaces[0];
+//			}
+//			if (type.Name.EndsWith("2")) {
+//				return type.Assembly.GetType(type.FullName.Remove(type.FullName.Length - 1));
+//			}
+			return null;
+		}
+	}
+}

src/Tools/WrapperGenerator/MainForm.cs

@@ -30,14 +30,17 @@ namespace WrapperGenerator
 				"\r\n";
 		//string dllFileName = Assembly.GetExecutingAssembly().Location;
 		string dllFileName = Path.Combine(Assembly.GetExecutingAssembly().Location, @"..\..\..\..\..\..\AddIns\AddIns\Misc\Debugger\Debugger.Core.dll");
-		string saveDirectory = Path.Combine(Assembly.GetExecutingAssembly().Location, @"..\..\..\..\..\..\src\AddIns\Misc\Debugger\Debugger.Core\Project\Src\Wrappers\CorDebug");
+		string saveDirectory = Path.Combine(Assembly.GetExecutingAssembly().Location, @"..\..\..\..\..\..\src\AddIns\Misc\Debugger\Debugger.Core\Project\Src\Wrappers");
 		
 		public MainForm()
 		{
 			InitializeComponent();
 			
-			CodeGenerator codeGenerator = new CorDebugGenerator(Assembly.LoadFile(dllFileName));
-			textBox1.Text = new FileGenerator(codeGenerator, header).SaveFiles(saveDirectory);
+			CodeGenerator codeGenerator1 = new CorDebugGenerator(Assembly.LoadFile(dllFileName));
+			textBox1.Text = new FileGenerator(codeGenerator1, header).SaveFiles(saveDirectory + @"\CorDebug");
+			
+			CodeGenerator codeGenerator2 = new CorSymGenerator(Assembly.LoadFile(dllFileName));
+			textBox1.Text += new FileGenerator(codeGenerator2, header).SaveFiles(saveDirectory + @"\CorSym");
 		}
 		
 		[STAThread]

src/Tools/WrapperGenerator/WrapperGenerator.csproj

@@ -35,9 +35,13 @@
     <Compile Include="AssemblyInfo.cs" />
     <EmbeddedResource Include="MainForm.resources" />
     <Compile Include="CodeGenerator.cs" />
-    <Compile Include="CorDebugGenerator.cs" />
     <Compile Include="Test.cs" />
     <Compile Include="FileGenerator.cs" />
+    <Compile Include="Debugger\CorDebugGenerator.cs" />
+    <Compile Include="Debugger\CorSymGenerator.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Debugger" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
 </Project>

src/Tools/WrapperGenerator/WrapperGenerator.sln

@@ -1,5 +1,5 @@
 Microsoft Visual Studio Solution File, Format Version 9.00
-# SharpDevelop 2.0.0.920
+# SharpDevelop 2.0.0.1115
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WrapperGenerator", "WrapperGenerator.csproj", "{7ED425D8-30CA-422C-90DF-1CB901E46DE3}"
 EndProject
 Global