diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj index 513c61ffde..8551fb3230 100644 --- a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Debugger.Core.csproj @@ -208,9 +208,97 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebug.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebug.cs new file mode 100644 index 0000000000..4a8fdc1da8 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebug.cs @@ -0,0 +1,83 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class CorDebug + { + + private Debugger.Interop.CorDebug.CorDebug wrappedObject; + + internal Debugger.Interop.CorDebug.CorDebug WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public CorDebug(Debugger.Interop.CorDebug.CorDebug wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static CorDebug Wrap(Debugger.Interop.CorDebug.CorDebug objectToWrap) + { + return new CorDebug(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(CorDebug o1, CorDebug o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(CorDebug o1, CorDebug o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + CorDebug casted = o as CorDebug; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugChainReason.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugChainReason.cs new file mode 100644 index 0000000000..c8ece6e05f --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugChainReason.cs @@ -0,0 +1,42 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugChainReason : int + { + + CHAIN_NONE = 0, + + CHAIN_CLASS_INIT = 1, + + CHAIN_EXCEPTION_FILTER = 2, + + CHAIN_SECURITY = 4, + + CHAIN_CONTEXT_POLICY = 8, + + CHAIN_INTERCEPTION = 16, + + CHAIN_PROCESS_START = 32, + + CHAIN_THREAD_START = 64, + + CHAIN_ENTER_MANAGED = 128, + + CHAIN_ENTER_UNMANAGED = 256, + + CHAIN_DEBUGGER_EVAL = 512, + + CHAIN_CONTEXT_SWITCH = 1024, + + CHAIN_FUNC_EVAL = 2048, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugClass.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugClass.cs new file mode 100644 index 0000000000..5d5a72b6e4 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugClass.cs @@ -0,0 +1,136 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class CorDebugClass + { + + private Debugger.Interop.CorDebug.CorDebugClass wrappedObject; + + internal Debugger.Interop.CorDebug.CorDebugClass WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public CorDebugClass(Debugger.Interop.CorDebug.CorDebugClass wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static CorDebugClass Wrap(Debugger.Interop.CorDebug.CorDebugClass objectToWrap) + { + return new CorDebugClass(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(CorDebugClass o1, CorDebugClass o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(CorDebugClass o1, CorDebugClass o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + CorDebugClass casted = o as CorDebugClass; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void CanLaunchOrAttach(uint dwProcessId, int win32DebuggingEnabled) + { + this.WrappedObject.CanLaunchOrAttach(dwProcessId, win32DebuggingEnabled); + } + + public void CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, ((Debugger.Interop.CorDebug.CorDebugCreateProcessFlags)(debuggingFlags)), out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess; + this.WrappedObject.EnumerateProcesses(out out_ppProcess); + ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess); + } + + public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void Initialize() + { + this.WrappedObject.Initialize(); + } + + public void SetManagedHandler(ICorDebugManagedCallback pCallback) + { + this.WrappedObject.SetManagedHandler(pCallback.WrappedObject); + } + + public void SetUnmanagedHandler(ICorDebugUnmanagedCallback pCallback) + { + this.WrappedObject.SetUnmanagedHandler(pCallback.WrappedObject); + } + + public void Terminate() + { + this.WrappedObject.Terminate(); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugCreateProcessFlags.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugCreateProcessFlags.cs new file mode 100644 index 0000000000..566b7c68b1 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugCreateProcessFlags.cs @@ -0,0 +1,18 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugCreateProcessFlags : int + { + + DEBUG_NO_SPECIAL_OPTIONS = 0, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugExceptionCallbackType.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugExceptionCallbackType.cs new file mode 100644 index 0000000000..d51caeddb3 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugExceptionCallbackType.cs @@ -0,0 +1,24 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugExceptionCallbackType : int + { + + DEBUG_EXCEPTION_FIRST_CHANCE = 1, + + DEBUG_EXCEPTION_USER_FIRST_CHANCE = 2, + + DEBUG_EXCEPTION_CATCH_HANDLER_FOUND = 3, + + DEBUG_EXCEPTION_UNHANDLED = 4, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugExceptionUnwindCallbackType.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugExceptionUnwindCallbackType.cs new file mode 100644 index 0000000000..62866cc060 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugExceptionUnwindCallbackType.cs @@ -0,0 +1,20 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugExceptionUnwindCallbackType : int + { + + DEBUG_EXCEPTION_UNWIND_BEGIN = 1, + + DEBUG_EXCEPTION_INTERCEPTED = 2, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugHandleType.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugHandleType.cs new file mode 100644 index 0000000000..2e53181f55 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugHandleType.cs @@ -0,0 +1,20 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugHandleType : int + { + + HANDLE_STRONG = 1, + + HANDLE_WEAK_TRACK_RESURRECTION = 2, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugIntercept.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugIntercept.cs new file mode 100644 index 0000000000..931ce80435 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugIntercept.cs @@ -0,0 +1,30 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugIntercept : int + { + + INTERCEPT_NONE = 0, + + INTERCEPT_CLASS_INIT = 1, + + INTERCEPT_EXCEPTION_FILTER = 2, + + INTERCEPT_SECURITY = 4, + + INTERCEPT_CONTEXT_POLICY = 8, + + INTERCEPT_INTERCEPTION = 16, + + INTERCEPT_ALL = 65535, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugInternalFrameType.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugInternalFrameType.cs new file mode 100644 index 0000000000..1de8f8fe60 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugInternalFrameType.cs @@ -0,0 +1,30 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugInternalFrameType : int + { + + STUBFRAME_NONE = 0, + + STUBFRAME_M2U = 1, + + STUBFRAME_U2M = 2, + + STUBFRAME_APPDOMAIN_TRANSITION = 3, + + STUBFRAME_LIGHTWEIGHT_FUNCTION = 4, + + STUBFRAME_FUNC_EVAL = 5, + + STUBFRAME_INTERNALCALL = 6, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugMDAFlags.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugMDAFlags.cs new file mode 100644 index 0000000000..8d7ca31331 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugMDAFlags.cs @@ -0,0 +1,18 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugMDAFlags : int + { + + MDA_FLAG_SLIP = 2, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugMappingResult.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugMappingResult.cs new file mode 100644 index 0000000000..e1ab13dbd5 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugMappingResult.cs @@ -0,0 +1,28 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugMappingResult : int + { + + MAPPING_PROLOG = 1, + + MAPPING_EPILOG = 2, + + MAPPING_NO_INFO = 4, + + MAPPING_UNMAPPED_ADDRESS = 8, + + MAPPING_EXACT = 16, + + MAPPING_APPROXIMATE = 32, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugRegister.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugRegister.cs new file mode 100644 index 0000000000..faff15c4b6 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugRegister.cs @@ -0,0 +1,128 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugRegister : int + { + + REGISTER_AMD64_RIP = 0, + + REGISTER_X86_EIP = 0, + + REGISTER_INSTRUCTION_POINTER = 0, + + REGISTER_AMD64_RSP = 1, + + REGISTER_STACK_POINTER = 1, + + REGISTER_X86_ESP = 1, + + REGISTER_IA64_BSP = 2, + + REGISTER_AMD64_RBP = 2, + + REGISTER_X86_EBP = 2, + + REGISTER_FRAME_POINTER = 2, + + REGISTER_X86_EAX = 3, + + REGISTER_IA64_R0 = 3, + + REGISTER_AMD64_RAX = 3, + + REGISTER_X86_ECX = 4, + + REGISTER_AMD64_RCX = 4, + + REGISTER_AMD64_RDX = 5, + + REGISTER_X86_EDX = 5, + + REGISTER_X86_EBX = 6, + + REGISTER_AMD64_RBX = 6, + + REGISTER_AMD64_RSI = 7, + + REGISTER_X86_ESI = 7, + + REGISTER_X86_EDI = 8, + + REGISTER_AMD64_RDI = 8, + + REGISTER_AMD64_R8 = 9, + + REGISTER_X86_FPSTACK_0 = 9, + + REGISTER_AMD64_R9 = 10, + + REGISTER_X86_FPSTACK_1 = 10, + + REGISTER_AMD64_R10 = 11, + + REGISTER_X86_FPSTACK_2 = 11, + + REGISTER_AMD64_R11 = 12, + + REGISTER_X86_FPSTACK_3 = 12, + + REGISTER_AMD64_R12 = 13, + + REGISTER_X86_FPSTACK_4 = 13, + + REGISTER_AMD64_R13 = 14, + + REGISTER_X86_FPSTACK_5 = 14, + + REGISTER_AMD64_R14 = 15, + + REGISTER_X86_FPSTACK_6 = 15, + + REGISTER_AMD64_R15 = 16, + + REGISTER_X86_FPSTACK_7 = 16, + + REGISTER_AMD64_XMM0 = 17, + + REGISTER_AMD64_XMM1 = 18, + + REGISTER_AMD64_XMM2 = 19, + + REGISTER_AMD64_XMM3 = 20, + + REGISTER_AMD64_XMM4 = 21, + + REGISTER_AMD64_XMM5 = 22, + + REGISTER_AMD64_XMM6 = 23, + + REGISTER_AMD64_XMM7 = 24, + + REGISTER_AMD64_XMM8 = 25, + + REGISTER_AMD64_XMM9 = 26, + + REGISTER_AMD64_XMM10 = 27, + + REGISTER_AMD64_XMM11 = 28, + + REGISTER_AMD64_XMM12 = 29, + + REGISTER_AMD64_XMM13 = 30, + + REGISTER_AMD64_XMM14 = 31, + + REGISTER_AMD64_XMM15 = 32, + + REGISTER_IA64_F0 = 131, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugStepReason.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugStepReason.cs new file mode 100644 index 0000000000..7f27b27320 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugStepReason.cs @@ -0,0 +1,30 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugStepReason : int + { + + STEP_NORMAL = 0, + + STEP_RETURN = 1, + + STEP_CALL = 2, + + STEP_EXCEPTION_FILTER = 3, + + STEP_EXCEPTION_HANDLER = 4, + + STEP_INTERCEPT = 5, + + STEP_EXIT = 6, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugThreadState.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugThreadState.cs new file mode 100644 index 0000000000..4c1ae6fa6d --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugThreadState.cs @@ -0,0 +1,20 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugThreadState : int + { + + THREAD_RUN = 0, + + THREAD_SUSPEND = 1, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugUnmappedStop.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugUnmappedStop.cs new file mode 100644 index 0000000000..0cfff0d7f4 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugUnmappedStop.cs @@ -0,0 +1,30 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugUnmappedStop : int + { + + STOP_NONE = 0, + + STOP_PROLOG = 1, + + STOP_EPILOG = 2, + + STOP_NO_MAPPING_INFO = 4, + + STOP_OTHER_UNMAPPED = 8, + + STOP_UNMANAGED = 16, + + STOP_ALL = 65535, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugUserState.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugUserState.cs new file mode 100644 index 0000000000..c7e945d2fd --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugUserState.cs @@ -0,0 +1,32 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public enum CorDebugUserState : int + { + + USER_STOP_REQUESTED = 1, + + USER_SUSPEND_REQUESTED = 2, + + USER_BACKGROUND = 4, + + USER_UNSTARTED = 8, + + USER_STOPPED = 16, + + USER_WAIT_SLEEP_JOIN = 32, + + USER_SUSPENDED = 64, + + USER_UNSAFE_POINT = 128, + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebug.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebug.cs new file mode 100644 index 0000000000..a79a35a6e2 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebug.cs @@ -0,0 +1,83 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class EmbeddedCLRCorDebug + { + + private Debugger.Interop.CorDebug.EmbeddedCLRCorDebug wrappedObject; + + internal Debugger.Interop.CorDebug.EmbeddedCLRCorDebug WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public EmbeddedCLRCorDebug(Debugger.Interop.CorDebug.EmbeddedCLRCorDebug wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static EmbeddedCLRCorDebug Wrap(Debugger.Interop.CorDebug.EmbeddedCLRCorDebug objectToWrap) + { + return new EmbeddedCLRCorDebug(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(EmbeddedCLRCorDebug o1, EmbeddedCLRCorDebug o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(EmbeddedCLRCorDebug o1, EmbeddedCLRCorDebug o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + EmbeddedCLRCorDebug casted = o as EmbeddedCLRCorDebug; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebugClass.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebugClass.cs new file mode 100644 index 0000000000..9fe4adbd0e --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebugClass.cs @@ -0,0 +1,136 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class EmbeddedCLRCorDebugClass + { + + private Debugger.Interop.CorDebug.EmbeddedCLRCorDebugClass wrappedObject; + + internal Debugger.Interop.CorDebug.EmbeddedCLRCorDebugClass WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public EmbeddedCLRCorDebugClass(Debugger.Interop.CorDebug.EmbeddedCLRCorDebugClass wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static EmbeddedCLRCorDebugClass Wrap(Debugger.Interop.CorDebug.EmbeddedCLRCorDebugClass objectToWrap) + { + return new EmbeddedCLRCorDebugClass(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(EmbeddedCLRCorDebugClass o1, EmbeddedCLRCorDebugClass o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(EmbeddedCLRCorDebugClass o1, EmbeddedCLRCorDebugClass o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + EmbeddedCLRCorDebugClass casted = o as EmbeddedCLRCorDebugClass; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void CanLaunchOrAttach(uint dwProcessId, int win32DebuggingEnabled) + { + this.WrappedObject.CanLaunchOrAttach(dwProcessId, win32DebuggingEnabled); + } + + public void CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, ((Debugger.Interop.CorDebug.CorDebugCreateProcessFlags)(debuggingFlags)), out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess; + this.WrappedObject.EnumerateProcesses(out out_ppProcess); + ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess); + } + + public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void Initialize() + { + this.WrappedObject.Initialize(); + } + + public void SetManagedHandler(ICorDebugManagedCallback pCallback) + { + this.WrappedObject.SetManagedHandler(pCallback.WrappedObject); + } + + public void SetUnmanagedHandler(ICorDebugUnmanagedCallback pCallback) + { + this.WrappedObject.SetUnmanagedHandler(pCallback.WrappedObject); + } + + public void Terminate() + { + this.WrappedObject.Terminate(); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebug.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebug.cs new file mode 100644 index 0000000000..fe41ae9320 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebug.cs @@ -0,0 +1,136 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebug + { + + private Debugger.Interop.CorDebug.ICorDebug wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebug WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebug(Debugger.Interop.CorDebug.ICorDebug wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebug Wrap(Debugger.Interop.CorDebug.ICorDebug objectToWrap) + { + return new ICorDebug(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebug o1, ICorDebug o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebug o1, ICorDebug o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebug casted = o as ICorDebug; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Initialize() + { + this.WrappedObject.Initialize(); + } + + public void Terminate() + { + this.WrappedObject.Terminate(); + } + + public void SetManagedHandler(ICorDebugManagedCallback pCallback) + { + this.WrappedObject.SetManagedHandler(pCallback.WrappedObject); + } + + public void SetUnmanagedHandler(ICorDebugUnmanagedCallback pCallback) + { + this.WrappedObject.SetUnmanagedHandler(pCallback.WrappedObject); + } + + public void CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, ((Debugger.Interop.CorDebug.CorDebugCreateProcessFlags)(debuggingFlags)), out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess; + this.WrappedObject.EnumerateProcesses(out out_ppProcess); + ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess); + } + + public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void CanLaunchOrAttach(uint dwProcessId, int win32DebuggingEnabled) + { + this.WrappedObject.CanLaunchOrAttach(dwProcessId, win32DebuggingEnabled); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain.cs new file mode 100644 index 0000000000..5aecadcdbe --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain.cs @@ -0,0 +1,205 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugAppDomain + { + + private Debugger.Interop.CorDebug.ICorDebugAppDomain wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugAppDomain WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugAppDomain(Debugger.Interop.CorDebug.ICorDebugAppDomain wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugAppDomain Wrap(Debugger.Interop.CorDebug.ICorDebugAppDomain objectToWrap) + { + return new ICorDebugAppDomain(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugAppDomain o1, ICorDebugAppDomain o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugAppDomain o1, ICorDebugAppDomain o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugAppDomain casted = o as ICorDebugAppDomain; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Stop(uint dwTimeoutIgnored) + { + this.WrappedObject.Stop(dwTimeoutIgnored); + } + + public void Continue(int fIsOutOfBand) + { + this.WrappedObject.Continue(fIsOutOfBand); + } + + public void IsRunning(out int pbRunning) + { + this.WrappedObject.IsRunning(out pbRunning); + } + + public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued) + { + this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued); + } + + public void EnumerateThreads(out ICorDebugThreadEnum ppThreads) + { + Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads; + this.WrappedObject.EnumerateThreads(out out_ppThreads); + ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads); + } + + public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread) + { + this.WrappedObject.SetAllThreadsDebugState(((Debugger.Interop.CorDebug.CorDebugThreadState)(state)), pExceptThisThread.WrappedObject); + } + + public void Detach() + { + this.WrappedObject.Detach(); + } + + public void Terminate(uint exitCode) + { + this.WrappedObject.Terminate(exitCode); + } + + public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError) + { + Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError; + this.WrappedObject.CanCommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError); + pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots); + pError = ICorDebugErrorInfoEnum.Wrap(out_pError); + } + + public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError) + { + Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError; + this.WrappedObject.CommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError); + pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots); + pError = ICorDebugErrorInfoEnum.Wrap(out_pError); + } + + public void GetProcess(out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.GetProcess(out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void EnumerateAssemblies(out ICorDebugAssemblyEnum ppAssemblies) + { + Debugger.Interop.CorDebug.ICorDebugAssemblyEnum out_ppAssemblies; + this.WrappedObject.EnumerateAssemblies(out out_ppAssemblies); + ppAssemblies = ICorDebugAssemblyEnum.Wrap(out_ppAssemblies); + } + + public void GetModuleFromMetaDataInterface(object pIMetaData, out ICorDebugModule ppModule) + { + Debugger.Interop.CorDebug.ICorDebugModule out_ppModule; + this.WrappedObject.GetModuleFromMetaDataInterface(pIMetaData, out out_ppModule); + ppModule = ICorDebugModule.Wrap(out_ppModule); + } + + public void EnumerateBreakpoints(out ICorDebugBreakpointEnum ppBreakpoints) + { + Debugger.Interop.CorDebug.ICorDebugBreakpointEnum out_ppBreakpoints; + this.WrappedObject.EnumerateBreakpoints(out out_ppBreakpoints); + ppBreakpoints = ICorDebugBreakpointEnum.Wrap(out_ppBreakpoints); + } + + public void EnumerateSteppers(out ICorDebugStepperEnum ppSteppers) + { + Debugger.Interop.CorDebug.ICorDebugStepperEnum out_ppSteppers; + this.WrappedObject.EnumerateSteppers(out out_ppSteppers); + ppSteppers = ICorDebugStepperEnum.Wrap(out_ppSteppers); + } + + public void IsAttached(out int pbAttached) + { + this.WrappedObject.IsAttached(out pbAttached); + } + + public void GetName(uint cchName, out uint pcchName, System.IntPtr szName) + { + this.WrappedObject.GetName(cchName, out pcchName, szName); + } + + public void GetObject(out ICorDebugValue ppObject) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppObject; + this.WrappedObject.GetObject(out out_ppObject); + ppObject = ICorDebugValue.Wrap(out_ppObject); + } + + public void Attach() + { + this.WrappedObject.Attach(); + } + + public void GetID(out uint pId) + { + this.WrappedObject.GetID(out pId); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain2.cs new file mode 100644 index 0000000000..9c8521b20e --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain2.cs @@ -0,0 +1,99 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugAppDomain2 + { + + private Debugger.Interop.CorDebug.ICorDebugAppDomain2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugAppDomain2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugAppDomain2(Debugger.Interop.CorDebug.ICorDebugAppDomain2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugAppDomain2 Wrap(Debugger.Interop.CorDebug.ICorDebugAppDomain2 objectToWrap) + { + return new ICorDebugAppDomain2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugAppDomain2 o1, ICorDebugAppDomain2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugAppDomain2 o1, ICorDebugAppDomain2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugAppDomain2 casted = o as ICorDebugAppDomain2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetArrayOrPointerType(uint elementType, uint nRank, ICorDebugType pTypeArg, out ICorDebugType ppType) + { + Debugger.Interop.CorDebug.ICorDebugType out_ppType; + this.WrappedObject.GetArrayOrPointerType(elementType, nRank, pTypeArg.WrappedObject, out out_ppType); + ppType = ICorDebugType.Wrap(out_ppType); + } + + public void GetFunctionPointerType(uint nTypeArgs, ref ICorDebugType ppTypeArgs, out ICorDebugType ppType) + { + Debugger.Interop.CorDebug.ICorDebugType ref_ppTypeArgs = ppTypeArgs.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugType out_ppType; + this.WrappedObject.GetFunctionPointerType(nTypeArgs, ref ref_ppTypeArgs, out out_ppType); + ppTypeArgs = ICorDebugType.Wrap(ref_ppTypeArgs); + ppType = ICorDebugType.Wrap(out_ppType); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomainEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomainEnum.cs new file mode 100644 index 0000000000..2e001bc660 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomainEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugAppDomainEnum + { + + private Debugger.Interop.CorDebug.ICorDebugAppDomainEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugAppDomainEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugAppDomainEnum(Debugger.Interop.CorDebug.ICorDebugAppDomainEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugAppDomainEnum Wrap(Debugger.Interop.CorDebug.ICorDebugAppDomainEnum objectToWrap) + { + return new ICorDebugAppDomainEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugAppDomainEnum o1, ICorDebugAppDomainEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugAppDomainEnum o1, ICorDebugAppDomainEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugAppDomainEnum casted = o as ICorDebugAppDomainEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr values, out uint pceltFetched) + { + this.WrappedObject.Next(celt, values, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugArrayValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugArrayValue.cs new file mode 100644 index 0000000000..f53a96bdee --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugArrayValue.cs @@ -0,0 +1,161 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugArrayValue + { + + private Debugger.Interop.CorDebug.ICorDebugArrayValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugArrayValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugArrayValue(Debugger.Interop.CorDebug.ICorDebugArrayValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugArrayValue Wrap(Debugger.Interop.CorDebug.ICorDebugArrayValue objectToWrap) + { + return new ICorDebugArrayValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugArrayValue o1, ICorDebugArrayValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugArrayValue o1, ICorDebugArrayValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugArrayValue casted = o as ICorDebugArrayValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void IsValid(out int pbValid) + { + this.WrappedObject.IsValid(out pbValid); + } + + public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetElementType(out uint pType) + { + this.WrappedObject.GetElementType(out pType); + } + + public void GetRank(out uint pnRank) + { + this.WrappedObject.GetRank(out pnRank); + } + + public void GetCount(out uint pnCount) + { + this.WrappedObject.GetCount(out pnCount); + } + + public void GetDimensions(uint cdim, System.IntPtr dims) + { + this.WrappedObject.GetDimensions(cdim, dims); + } + + public void HasBaseIndicies(out int pbHasBaseIndicies) + { + this.WrappedObject.HasBaseIndicies(out pbHasBaseIndicies); + } + + public void GetBaseIndicies(uint cdim, System.IntPtr indicies) + { + this.WrappedObject.GetBaseIndicies(cdim, indicies); + } + + public void GetElement(uint cdim, System.IntPtr indices, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetElement(cdim, indices, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetElementAtPosition(uint nPosition, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetElementAtPosition(nPosition, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssembly.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssembly.cs new file mode 100644 index 0000000000..023f060cab --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssembly.cs @@ -0,0 +1,114 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugAssembly + { + + private Debugger.Interop.CorDebug.ICorDebugAssembly wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugAssembly WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugAssembly(Debugger.Interop.CorDebug.ICorDebugAssembly wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugAssembly Wrap(Debugger.Interop.CorDebug.ICorDebugAssembly objectToWrap) + { + return new ICorDebugAssembly(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugAssembly o1, ICorDebugAssembly o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugAssembly o1, ICorDebugAssembly o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugAssembly casted = o as ICorDebugAssembly; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetProcess(out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.GetProcess(out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void GetAppDomain(out ICorDebugAppDomain ppAppDomain) + { + Debugger.Interop.CorDebug.ICorDebugAppDomain out_ppAppDomain; + this.WrappedObject.GetAppDomain(out out_ppAppDomain); + ppAppDomain = ICorDebugAppDomain.Wrap(out_ppAppDomain); + } + + public void EnumerateModules(out ICorDebugModuleEnum ppModules) + { + Debugger.Interop.CorDebug.ICorDebugModuleEnum out_ppModules; + this.WrappedObject.EnumerateModules(out out_ppModules); + ppModules = ICorDebugModuleEnum.Wrap(out_ppModules); + } + + public void GetCodeBase(uint cchName, out uint pcchName, System.IntPtr szName) + { + this.WrappedObject.GetCodeBase(cchName, out pcchName, szName); + } + + public void GetName(uint cchName, out uint pcchName, System.IntPtr szName) + { + this.WrappedObject.GetName(cchName, out pcchName, szName); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssemblyEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssemblyEnum.cs new file mode 100644 index 0000000000..c5d100af37 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssemblyEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugAssemblyEnum + { + + private Debugger.Interop.CorDebug.ICorDebugAssemblyEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugAssemblyEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugAssemblyEnum(Debugger.Interop.CorDebug.ICorDebugAssemblyEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugAssemblyEnum Wrap(Debugger.Interop.CorDebug.ICorDebugAssemblyEnum objectToWrap) + { + return new ICorDebugAssemblyEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugAssemblyEnum o1, ICorDebugAssemblyEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugAssemblyEnum o1, ICorDebugAssemblyEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugAssemblyEnum casted = o as ICorDebugAssemblyEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr values, out uint pceltFetched) + { + this.WrappedObject.Next(celt, values, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBoxValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBoxValue.cs new file mode 100644 index 0000000000..30146186ef --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBoxValue.cs @@ -0,0 +1,124 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugBoxValue + { + + private Debugger.Interop.CorDebug.ICorDebugBoxValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugBoxValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugBoxValue(Debugger.Interop.CorDebug.ICorDebugBoxValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugBoxValue Wrap(Debugger.Interop.CorDebug.ICorDebugBoxValue objectToWrap) + { + return new ICorDebugBoxValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugBoxValue o1, ICorDebugBoxValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugBoxValue o1, ICorDebugBoxValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugBoxValue casted = o as ICorDebugBoxValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void IsValid(out int pbValid) + { + this.WrappedObject.IsValid(out pbValid); + } + + public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetObject(out ICorDebugObjectValue ppObject) + { + Debugger.Interop.CorDebug.ICorDebugObjectValue out_ppObject; + this.WrappedObject.GetObject(out out_ppObject); + ppObject = ICorDebugObjectValue.Wrap(out_ppObject); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpoint.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpoint.cs new file mode 100644 index 0000000000..daf8d31505 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpoint.cs @@ -0,0 +1,93 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugBreakpoint + { + + private Debugger.Interop.CorDebug.ICorDebugBreakpoint wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugBreakpoint WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugBreakpoint(Debugger.Interop.CorDebug.ICorDebugBreakpoint wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugBreakpoint Wrap(Debugger.Interop.CorDebug.ICorDebugBreakpoint objectToWrap) + { + return new ICorDebugBreakpoint(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugBreakpoint o1, ICorDebugBreakpoint o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugBreakpoint o1, ICorDebugBreakpoint o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugBreakpoint casted = o as ICorDebugBreakpoint; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Activate(int bActive) + { + this.WrappedObject.Activate(bActive); + } + + public void IsActive(out int pbActive) + { + this.WrappedObject.IsActive(out pbActive); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpointEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpointEnum.cs new file mode 100644 index 0000000000..e6aabf65fe --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpointEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugBreakpointEnum + { + + private Debugger.Interop.CorDebug.ICorDebugBreakpointEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugBreakpointEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugBreakpointEnum(Debugger.Interop.CorDebug.ICorDebugBreakpointEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugBreakpointEnum Wrap(Debugger.Interop.CorDebug.ICorDebugBreakpointEnum objectToWrap) + { + return new ICorDebugBreakpointEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugBreakpointEnum o1, ICorDebugBreakpointEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugBreakpointEnum o1, ICorDebugBreakpointEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugBreakpointEnum casted = o as ICorDebugBreakpointEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr breakpoints, out uint pceltFetched) + { + this.WrappedObject.Next(celt, breakpoints, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChain.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChain.cs new file mode 100644 index 0000000000..aca4764b06 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChain.cs @@ -0,0 +1,163 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugChain + { + + private Debugger.Interop.CorDebug.ICorDebugChain wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugChain WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugChain(Debugger.Interop.CorDebug.ICorDebugChain wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugChain Wrap(Debugger.Interop.CorDebug.ICorDebugChain objectToWrap) + { + return new ICorDebugChain(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugChain o1, ICorDebugChain o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugChain o1, ICorDebugChain o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugChain casted = o as ICorDebugChain; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetThread(out ICorDebugThread ppThread) + { + Debugger.Interop.CorDebug.ICorDebugThread out_ppThread; + this.WrappedObject.GetThread(out out_ppThread); + ppThread = ICorDebugThread.Wrap(out_ppThread); + } + + public void GetStackRange(out ulong pStart, out ulong pEnd) + { + this.WrappedObject.GetStackRange(out pStart, out pEnd); + } + + public void GetContext(out ICorDebugContext ppContext) + { + Debugger.Interop.CorDebug.ICorDebugContext out_ppContext; + this.WrappedObject.GetContext(out out_ppContext); + ppContext = ICorDebugContext.Wrap(out_ppContext); + } + + public void GetCaller(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetCaller(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void GetCallee(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetCallee(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void GetPrevious(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetPrevious(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void GetNext(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetNext(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void IsManaged(out int pManaged) + { + this.WrappedObject.IsManaged(out pManaged); + } + + public void EnumerateFrames(out ICorDebugFrameEnum ppFrames) + { + Debugger.Interop.CorDebug.ICorDebugFrameEnum out_ppFrames; + this.WrappedObject.EnumerateFrames(out out_ppFrames); + ppFrames = ICorDebugFrameEnum.Wrap(out_ppFrames); + } + + public void GetActiveFrame(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetActiveFrame(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters) + { + Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters; + this.WrappedObject.GetRegisterSet(out out_ppRegisters); + ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters); + } + + public void GetReason(out CorDebugChainReason pReason) + { + Debugger.Interop.CorDebug.CorDebugChainReason out_pReason; + this.WrappedObject.GetReason(out out_pReason); + pReason = ((CorDebugChainReason)(out_pReason)); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChainEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChainEnum.cs new file mode 100644 index 0000000000..d45b477ecd --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChainEnum.cs @@ -0,0 +1,128 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugChainEnum + { + + private Debugger.Interop.CorDebug.ICorDebugChainEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugChainEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugChainEnum(Debugger.Interop.CorDebug.ICorDebugChainEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugChainEnum Wrap(Debugger.Interop.CorDebug.ICorDebugChainEnum objectToWrap) + { + return new ICorDebugChainEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugChainEnum o1, ICorDebugChainEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugChainEnum o1, ICorDebugChainEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugChainEnum casted = o as ICorDebugChainEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, ICorDebugChain[] chains, out uint pceltFetched) + { + Debugger.Interop.CorDebug.ICorDebugChain[] array_chains = new Debugger.Interop.CorDebug.ICorDebugChain[chains.Length]; + for (int i = 0; (i < chains.Length); i = (i + 1)) + { + if ((chains[i] != null)) + { + array_chains[i] = chains[i].WrappedObject; + } + } + this.WrappedObject.Next(celt, array_chains, out pceltFetched); + for (int i = 0; (i < chains.Length); i = (i + 1)) + { + if ((array_chains[i] != null)) + { + chains[i] = ICorDebugChain.Wrap(array_chains[i]); + } else + { + chains[i] = null; + } + } + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass.cs new file mode 100644 index 0000000000..0ab1f9006c --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass.cs @@ -0,0 +1,102 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugClass + { + + private Debugger.Interop.CorDebug.ICorDebugClass wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugClass WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugClass(Debugger.Interop.CorDebug.ICorDebugClass wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugClass Wrap(Debugger.Interop.CorDebug.ICorDebugClass objectToWrap) + { + return new ICorDebugClass(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugClass o1, ICorDebugClass o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugClass o1, ICorDebugClass o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugClass casted = o as ICorDebugClass; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetModule(out ICorDebugModule pModule) + { + Debugger.Interop.CorDebug.ICorDebugModule out_pModule; + this.WrappedObject.GetModule(out out_pModule); + pModule = ICorDebugModule.Wrap(out_pModule); + } + + public void GetToken(out uint pTypeDef) + { + this.WrappedObject.GetToken(out pTypeDef); + } + + public void GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetStaticFieldValue(fieldDef, pFrame.WrappedObject, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass2.cs new file mode 100644 index 0000000000..e3e432a65b --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass2.cs @@ -0,0 +1,97 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugClass2 + { + + private Debugger.Interop.CorDebug.ICorDebugClass2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugClass2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugClass2(Debugger.Interop.CorDebug.ICorDebugClass2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugClass2 Wrap(Debugger.Interop.CorDebug.ICorDebugClass2 objectToWrap) + { + return new ICorDebugClass2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugClass2 o1, ICorDebugClass2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugClass2 o1, ICorDebugClass2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugClass2 casted = o as ICorDebugClass2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetParameterizedType(uint elementType, uint nTypeArgs, ref ICorDebugType ppTypeArgs, out ICorDebugType ppType) + { + Debugger.Interop.CorDebug.ICorDebugType ref_ppTypeArgs = ppTypeArgs.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugType out_ppType; + this.WrappedObject.GetParameterizedType(elementType, nTypeArgs, ref ref_ppTypeArgs, out out_ppType); + ppTypeArgs = ICorDebugType.Wrap(ref_ppTypeArgs); + ppType = ICorDebugType.Wrap(out_ppType); + } + + public void SetJMCStatus(int bIsJustMyCode) + { + this.WrappedObject.SetJMCStatus(bIsJustMyCode); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCode.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCode.cs new file mode 100644 index 0000000000..af0281d200 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCode.cs @@ -0,0 +1,132 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugCode + { + + private Debugger.Interop.CorDebug.ICorDebugCode wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugCode WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugCode(Debugger.Interop.CorDebug.ICorDebugCode wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugCode Wrap(Debugger.Interop.CorDebug.ICorDebugCode objectToWrap) + { + return new ICorDebugCode(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugCode o1, ICorDebugCode o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugCode o1, ICorDebugCode o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugCode casted = o as ICorDebugCode; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void IsIL(out int pbIL) + { + this.WrappedObject.IsIL(out pbIL); + } + + public void GetFunction(out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetFunction(out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetAddress(out ulong pStart) + { + this.WrappedObject.GetAddress(out pStart); + } + + public void GetSize(out uint pcBytes) + { + this.WrappedObject.GetSize(out pcBytes); + } + + public void CreateBreakpoint(uint offset, out ICorDebugFunctionBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(offset, out out_ppBreakpoint); + ppBreakpoint = ICorDebugFunctionBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetCode(uint startOffset, uint endOffset, uint cBufferAlloc, System.IntPtr buffer, out uint pcBufferSize) + { + this.WrappedObject.GetCode(startOffset, endOffset, cBufferAlloc, buffer, out pcBufferSize); + } + + public void GetVersionNumber(out uint nVersion) + { + this.WrappedObject.GetVersionNumber(out nVersion); + } + + public void GetILToNativeMapping(uint cMap, out uint pcMap, System.IntPtr map) + { + this.WrappedObject.GetILToNativeMapping(cMap, out pcMap, map); + } + + public void GetEnCRemapSequencePoints(uint cMap, out uint pcMap, System.IntPtr offsets) + { + this.WrappedObject.GetEnCRemapSequencePoints(cMap, out pcMap, offsets); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCodeEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCodeEnum.cs new file mode 100644 index 0000000000..3a898b7528 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCodeEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugCodeEnum + { + + private Debugger.Interop.CorDebug.ICorDebugCodeEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugCodeEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugCodeEnum(Debugger.Interop.CorDebug.ICorDebugCodeEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugCodeEnum Wrap(Debugger.Interop.CorDebug.ICorDebugCodeEnum objectToWrap) + { + return new ICorDebugCodeEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugCodeEnum o1, ICorDebugCodeEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugCodeEnum o1, ICorDebugCodeEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugCodeEnum casted = o as ICorDebugCodeEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr values, out uint pceltFetched) + { + this.WrappedObject.Next(celt, values, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugContext.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugContext.cs new file mode 100644 index 0000000000..28a31e60d7 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugContext.cs @@ -0,0 +1,148 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugContext + { + + private Debugger.Interop.CorDebug.ICorDebugContext wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugContext WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugContext(Debugger.Interop.CorDebug.ICorDebugContext wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugContext Wrap(Debugger.Interop.CorDebug.ICorDebugContext objectToWrap) + { + return new ICorDebugContext(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugContext o1, ICorDebugContext o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugContext o1, ICorDebugContext o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugContext casted = o as ICorDebugContext; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetClass(out ICorDebugClass ppClass) + { + Debugger.Interop.CorDebug.ICorDebugClass out_ppClass; + this.WrappedObject.GetClass(out out_ppClass); + ppClass = ICorDebugClass.Wrap(out_ppClass); + } + + public void GetFieldValue(ICorDebugClass pClass, uint fieldDef, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetFieldValue(pClass.WrappedObject, fieldDef, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetVirtualMethod(uint memberRef, out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetVirtualMethod(memberRef, out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetContext(out ICorDebugContext ppContext) + { + Debugger.Interop.CorDebug.ICorDebugContext out_ppContext; + this.WrappedObject.GetContext(out out_ppContext); + ppContext = ICorDebugContext.Wrap(out_ppContext); + } + + public void IsValueClass(out int pbIsValueClass) + { + this.WrappedObject.IsValueClass(out pbIsValueClass); + } + + public void GetManagedCopy(out object ppObject) + { + this.WrappedObject.GetManagedCopy(out ppObject); + } + + public void SetFromManagedCopy(object pObject) + { + this.WrappedObject.SetFromManagedCopy(pObject); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugController.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugController.cs new file mode 100644 index 0000000000..04f1fff530 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugController.cs @@ -0,0 +1,143 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugController + { + + private Debugger.Interop.CorDebug.ICorDebugController wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugController WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugController(Debugger.Interop.CorDebug.ICorDebugController wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugController Wrap(Debugger.Interop.CorDebug.ICorDebugController objectToWrap) + { + return new ICorDebugController(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugController o1, ICorDebugController o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugController o1, ICorDebugController o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugController casted = o as ICorDebugController; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Stop(uint dwTimeoutIgnored) + { + this.WrappedObject.Stop(dwTimeoutIgnored); + } + + public void Continue(int fIsOutOfBand) + { + this.WrappedObject.Continue(fIsOutOfBand); + } + + public void IsRunning(out int pbRunning) + { + this.WrappedObject.IsRunning(out pbRunning); + } + + public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued) + { + this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued); + } + + public void EnumerateThreads(out ICorDebugThreadEnum ppThreads) + { + Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads; + this.WrappedObject.EnumerateThreads(out out_ppThreads); + ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads); + } + + public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread) + { + this.WrappedObject.SetAllThreadsDebugState(((Debugger.Interop.CorDebug.CorDebugThreadState)(state)), pExceptThisThread.WrappedObject); + } + + public void Detach() + { + this.WrappedObject.Detach(); + } + + public void Terminate(uint exitCode) + { + this.WrappedObject.Terminate(exitCode); + } + + public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError) + { + Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError; + this.WrappedObject.CanCommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError); + pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots); + pError = ICorDebugErrorInfoEnum.Wrap(out_pError); + } + + public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError) + { + Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError; + this.WrappedObject.CommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError); + pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots); + pError = ICorDebugErrorInfoEnum.Wrap(out_pError); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEditAndContinueSnapshot.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEditAndContinueSnapshot.cs new file mode 100644 index 0000000000..d41a1e24e8 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEditAndContinueSnapshot.cs @@ -0,0 +1,118 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugEditAndContinueSnapshot + { + + private Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugEditAndContinueSnapshot(Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugEditAndContinueSnapshot Wrap(Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot objectToWrap) + { + return new ICorDebugEditAndContinueSnapshot(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugEditAndContinueSnapshot o1, ICorDebugEditAndContinueSnapshot o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugEditAndContinueSnapshot o1, ICorDebugEditAndContinueSnapshot o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugEditAndContinueSnapshot casted = o as ICorDebugEditAndContinueSnapshot; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void CopyMetaData(IStream pIStream, out System.Guid pMvid) + { + this.WrappedObject.CopyMetaData(pIStream.WrappedObject, out pMvid); + } + + public void GetMvid(out System.Guid pMvid) + { + this.WrappedObject.GetMvid(out pMvid); + } + + public void GetRoDataRVA(out uint pRoDataRVA) + { + this.WrappedObject.GetRoDataRVA(out pRoDataRVA); + } + + public void GetRwDataRVA(out uint pRwDataRVA) + { + this.WrappedObject.GetRwDataRVA(out pRwDataRVA); + } + + public void SetPEBytes(IStream pIStream) + { + this.WrappedObject.SetPEBytes(pIStream.WrappedObject); + } + + public void SetILMap(uint mdFunction, uint cMapSize, ref Debugger.Interop.CorDebug._COR_IL_MAP map) + { + this.WrappedObject.SetILMap(mdFunction, cMapSize, ref map); + } + + public void SetPESymbolBytes(IStream pIStream) + { + this.WrappedObject.SetPESymbolBytes(pIStream.WrappedObject); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEnum.cs new file mode 100644 index 0000000000..38b62b2c62 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEnum.cs @@ -0,0 +1,105 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugEnum + { + + private Debugger.Interop.CorDebug.ICorDebugEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugEnum(Debugger.Interop.CorDebug.ICorDebugEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugEnum Wrap(Debugger.Interop.CorDebug.ICorDebugEnum objectToWrap) + { + return new ICorDebugEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugEnum o1, ICorDebugEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugEnum o1, ICorDebugEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugEnum casted = o as ICorDebugEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugErrorInfoEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugErrorInfoEnum.cs new file mode 100644 index 0000000000..013cbe3a42 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugErrorInfoEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugErrorInfoEnum + { + + private Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugErrorInfoEnum(Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugErrorInfoEnum Wrap(Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum objectToWrap) + { + return new ICorDebugErrorInfoEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugErrorInfoEnum o1, ICorDebugErrorInfoEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugErrorInfoEnum o1, ICorDebugErrorInfoEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugErrorInfoEnum casted = o as ICorDebugErrorInfoEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr errors, out uint pceltFetched) + { + this.WrappedObject.Next(celt, errors, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval.cs new file mode 100644 index 0000000000..735bfd1b1b --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval.cs @@ -0,0 +1,159 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugEval + { + + private Debugger.Interop.CorDebug.ICorDebugEval wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugEval WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugEval(Debugger.Interop.CorDebug.ICorDebugEval wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugEval Wrap(Debugger.Interop.CorDebug.ICorDebugEval objectToWrap) + { + return new ICorDebugEval(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugEval o1, ICorDebugEval o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugEval o1, ICorDebugEval o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugEval casted = o as ICorDebugEval; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void CallFunction(ICorDebugFunction pFunction, uint nArgs, ICorDebugValue[] ppArgs) + { + Debugger.Interop.CorDebug.ICorDebugValue[] array_ppArgs = new Debugger.Interop.CorDebug.ICorDebugValue[ppArgs.Length]; + for (int i = 0; (i < ppArgs.Length); i = (i + 1)) + { + if ((ppArgs[i] != null)) + { + array_ppArgs[i] = ppArgs[i].WrappedObject; + } + } + this.WrappedObject.CallFunction(pFunction.WrappedObject, nArgs, array_ppArgs); + for (int i = 0; (i < ppArgs.Length); i = (i + 1)) + { + if ((array_ppArgs[i] != null)) + { + ppArgs[i] = ICorDebugValue.Wrap(array_ppArgs[i]); + } else + { + ppArgs[i] = null; + } + } + } + + public void NewObject(ICorDebugFunction pConstructor, uint nArgs, ref ICorDebugValue ppArgs) + { + Debugger.Interop.CorDebug.ICorDebugValue ref_ppArgs = ppArgs.WrappedObject; + this.WrappedObject.NewObject(pConstructor.WrappedObject, nArgs, ref ref_ppArgs); + ppArgs = ICorDebugValue.Wrap(ref_ppArgs); + } + + public void NewObjectNoConstructor(ICorDebugClass pClass) + { + this.WrappedObject.NewObjectNoConstructor(pClass.WrappedObject); + } + + public void NewString(string @string) + { + this.WrappedObject.NewString(@string); + } + + public void NewArray(uint elementType, ICorDebugClass pElementClass, uint rank, ref uint dims, ref uint lowBounds) + { + this.WrappedObject.NewArray(elementType, pElementClass.WrappedObject, rank, ref dims, ref lowBounds); + } + + public void IsActive(out int pbActive) + { + this.WrappedObject.IsActive(out pbActive); + } + + public void Abort() + { + this.WrappedObject.Abort(); + } + + public void GetResult(out ICorDebugValue ppResult) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppResult; + this.WrappedObject.GetResult(out out_ppResult); + ppResult = ICorDebugValue.Wrap(out_ppResult); + } + + public void GetThread(out ICorDebugThread ppThread) + { + Debugger.Interop.CorDebug.ICorDebugThread out_ppThread; + this.WrappedObject.GetThread(out out_ppThread); + ppThread = ICorDebugThread.Wrap(out_ppThread); + } + + public void CreateValue(uint elementType, ICorDebugClass pElementClass, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.CreateValue(elementType, pElementClass.WrappedObject, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval2.cs new file mode 100644 index 0000000000..2f444caab9 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval2.cs @@ -0,0 +1,130 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugEval2 + { + + private Debugger.Interop.CorDebug.ICorDebugEval2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugEval2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugEval2(Debugger.Interop.CorDebug.ICorDebugEval2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugEval2 Wrap(Debugger.Interop.CorDebug.ICorDebugEval2 objectToWrap) + { + return new ICorDebugEval2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugEval2 o1, ICorDebugEval2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugEval2 o1, ICorDebugEval2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugEval2 casted = o as ICorDebugEval2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void CallParameterizedFunction(ICorDebugFunction pFunction, uint nTypeArgs, ref ICorDebugType ppTypeArgs, uint nArgs, ref ICorDebugValue ppArgs) + { + Debugger.Interop.CorDebug.ICorDebugType ref_ppTypeArgs = ppTypeArgs.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugValue ref_ppArgs = ppArgs.WrappedObject; + this.WrappedObject.CallParameterizedFunction(pFunction.WrappedObject, nTypeArgs, ref ref_ppTypeArgs, nArgs, ref ref_ppArgs); + ppTypeArgs = ICorDebugType.Wrap(ref_ppTypeArgs); + ppArgs = ICorDebugValue.Wrap(ref_ppArgs); + } + + public void CreateValueForType(ICorDebugType pType, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.CreateValueForType(pType.WrappedObject, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void NewParameterizedObject(ICorDebugFunction pConstructor, uint nTypeArgs, ref ICorDebugType ppTypeArgs, uint nArgs, ref ICorDebugValue ppArgs) + { + Debugger.Interop.CorDebug.ICorDebugType ref_ppTypeArgs = ppTypeArgs.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugValue ref_ppArgs = ppArgs.WrappedObject; + this.WrappedObject.NewParameterizedObject(pConstructor.WrappedObject, nTypeArgs, ref ref_ppTypeArgs, nArgs, ref ref_ppArgs); + ppTypeArgs = ICorDebugType.Wrap(ref_ppTypeArgs); + ppArgs = ICorDebugValue.Wrap(ref_ppArgs); + } + + public void NewParameterizedObjectNoConstructor(ICorDebugClass pClass, uint nTypeArgs, ref ICorDebugType ppTypeArgs) + { + Debugger.Interop.CorDebug.ICorDebugType ref_ppTypeArgs = ppTypeArgs.WrappedObject; + this.WrappedObject.NewParameterizedObjectNoConstructor(pClass.WrappedObject, nTypeArgs, ref ref_ppTypeArgs); + ppTypeArgs = ICorDebugType.Wrap(ref_ppTypeArgs); + } + + public void NewParameterizedArray(ICorDebugType pElementType, uint rank, ref uint dims, ref uint lowBounds) + { + this.WrappedObject.NewParameterizedArray(pElementType.WrappedObject, rank, ref dims, ref lowBounds); + } + + public void NewStringWithLength(string @string, uint uiLength) + { + this.WrappedObject.NewStringWithLength(@string, uiLength); + } + + public void RudeAbort() + { + this.WrappedObject.RudeAbort(); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrame.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrame.cs new file mode 100644 index 0000000000..a1691c7586 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrame.cs @@ -0,0 +1,135 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugFrame + { + + private Debugger.Interop.CorDebug.ICorDebugFrame wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugFrame WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugFrame(Debugger.Interop.CorDebug.ICorDebugFrame wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugFrame Wrap(Debugger.Interop.CorDebug.ICorDebugFrame objectToWrap) + { + return new ICorDebugFrame(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugFrame o1, ICorDebugFrame o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugFrame o1, ICorDebugFrame o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugFrame casted = o as ICorDebugFrame; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetChain(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetChain(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void GetCode(out ICorDebugCode ppCode) + { + Debugger.Interop.CorDebug.ICorDebugCode out_ppCode; + this.WrappedObject.GetCode(out out_ppCode); + ppCode = ICorDebugCode.Wrap(out_ppCode); + } + + public void GetFunction(out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetFunction(out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetFunctionToken(out uint pToken) + { + this.WrappedObject.GetFunctionToken(out pToken); + } + + public void GetStackRange(out ulong pStart, out ulong pEnd) + { + this.WrappedObject.GetStackRange(out pStart, out pEnd); + } + + public void GetCaller(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetCaller(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void GetCallee(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetCallee(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void CreateStepper(out ICorDebugStepper ppStepper) + { + Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper; + this.WrappedObject.CreateStepper(out out_ppStepper); + ppStepper = ICorDebugStepper.Wrap(out_ppStepper); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrameEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrameEnum.cs new file mode 100644 index 0000000000..e9c230a352 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrameEnum.cs @@ -0,0 +1,128 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugFrameEnum + { + + private Debugger.Interop.CorDebug.ICorDebugFrameEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugFrameEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugFrameEnum(Debugger.Interop.CorDebug.ICorDebugFrameEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugFrameEnum Wrap(Debugger.Interop.CorDebug.ICorDebugFrameEnum objectToWrap) + { + return new ICorDebugFrameEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugFrameEnum o1, ICorDebugFrameEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugFrameEnum o1, ICorDebugFrameEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugFrameEnum casted = o as ICorDebugFrameEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, ICorDebugFrame[] frames, out uint pceltFetched) + { + Debugger.Interop.CorDebug.ICorDebugFrame[] array_frames = new Debugger.Interop.CorDebug.ICorDebugFrame[frames.Length]; + for (int i = 0; (i < frames.Length); i = (i + 1)) + { + if ((frames[i] != null)) + { + array_frames[i] = frames[i].WrappedObject; + } + } + this.WrappedObject.Next(celt, array_frames, out pceltFetched); + for (int i = 0; (i < frames.Length); i = (i + 1)) + { + if ((array_frames[i] != null)) + { + frames[i] = ICorDebugFrame.Wrap(array_frames[i]); + } else + { + frames[i] = null; + } + } + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction.cs new file mode 100644 index 0000000000..b8ef8e2f38 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction.cs @@ -0,0 +1,133 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugFunction + { + + private Debugger.Interop.CorDebug.ICorDebugFunction wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugFunction WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugFunction(Debugger.Interop.CorDebug.ICorDebugFunction wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugFunction Wrap(Debugger.Interop.CorDebug.ICorDebugFunction objectToWrap) + { + return new ICorDebugFunction(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugFunction o1, ICorDebugFunction o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugFunction o1, ICorDebugFunction o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugFunction casted = o as ICorDebugFunction; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetModule(out ICorDebugModule ppModule) + { + Debugger.Interop.CorDebug.ICorDebugModule out_ppModule; + this.WrappedObject.GetModule(out out_ppModule); + ppModule = ICorDebugModule.Wrap(out_ppModule); + } + + public void GetClass(out ICorDebugClass ppClass) + { + Debugger.Interop.CorDebug.ICorDebugClass out_ppClass; + this.WrappedObject.GetClass(out out_ppClass); + ppClass = ICorDebugClass.Wrap(out_ppClass); + } + + public void GetToken(out uint pMethodDef) + { + this.WrappedObject.GetToken(out pMethodDef); + } + + public void GetILCode(out ICorDebugCode ppCode) + { + Debugger.Interop.CorDebug.ICorDebugCode out_ppCode; + this.WrappedObject.GetILCode(out out_ppCode); + ppCode = ICorDebugCode.Wrap(out_ppCode); + } + + public void GetNativeCode(out ICorDebugCode ppCode) + { + Debugger.Interop.CorDebug.ICorDebugCode out_ppCode; + this.WrappedObject.GetNativeCode(out out_ppCode); + ppCode = ICorDebugCode.Wrap(out_ppCode); + } + + public void CreateBreakpoint(out ICorDebugFunctionBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugFunctionBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetLocalVarSigToken(out uint pmdSig) + { + this.WrappedObject.GetLocalVarSigToken(out pmdSig); + } + + public void GetCurrentVersionNumber(out uint pnCurrentVersion) + { + this.WrappedObject.GetCurrentVersionNumber(out pnCurrentVersion); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction2.cs new file mode 100644 index 0000000000..ccf9c4e32e --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction2.cs @@ -0,0 +1,105 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugFunction2 + { + + private Debugger.Interop.CorDebug.ICorDebugFunction2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugFunction2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugFunction2(Debugger.Interop.CorDebug.ICorDebugFunction2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugFunction2 Wrap(Debugger.Interop.CorDebug.ICorDebugFunction2 objectToWrap) + { + return new ICorDebugFunction2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugFunction2 o1, ICorDebugFunction2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugFunction2 o1, ICorDebugFunction2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugFunction2 casted = o as ICorDebugFunction2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void SetJMCStatus(int bIsJustMyCode) + { + this.WrappedObject.SetJMCStatus(bIsJustMyCode); + } + + public void GetJMCStatus(out int pbIsJustMyCode) + { + this.WrappedObject.GetJMCStatus(out pbIsJustMyCode); + } + + public void EnumerateNativeCode(out ICorDebugCodeEnum ppCodeEnum) + { + Debugger.Interop.CorDebug.ICorDebugCodeEnum out_ppCodeEnum; + this.WrappedObject.EnumerateNativeCode(out out_ppCodeEnum); + ppCodeEnum = ICorDebugCodeEnum.Wrap(out_ppCodeEnum); + } + + public void GetVersionNumber(out uint pnVersion) + { + this.WrappedObject.GetVersionNumber(out pnVersion); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunctionBreakpoint.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunctionBreakpoint.cs new file mode 100644 index 0000000000..9af77e481c --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunctionBreakpoint.cs @@ -0,0 +1,105 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugFunctionBreakpoint + { + + private Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugFunctionBreakpoint(Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugFunctionBreakpoint Wrap(Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint objectToWrap) + { + return new ICorDebugFunctionBreakpoint(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugFunctionBreakpoint o1, ICorDebugFunctionBreakpoint o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugFunctionBreakpoint o1, ICorDebugFunctionBreakpoint o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugFunctionBreakpoint casted = o as ICorDebugFunctionBreakpoint; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Activate(int bActive) + { + this.WrappedObject.Activate(bActive); + } + + public void IsActive(out int pbActive) + { + this.WrappedObject.IsActive(out pbActive); + } + + public void GetFunction(out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetFunction(out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetOffset(out uint pnOffset) + { + this.WrappedObject.GetOffset(out pnOffset); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugGenericValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugGenericValue.cs new file mode 100644 index 0000000000..40c6d8f577 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugGenericValue.cs @@ -0,0 +1,115 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugGenericValue + { + + private Debugger.Interop.CorDebug.ICorDebugGenericValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugGenericValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugGenericValue(Debugger.Interop.CorDebug.ICorDebugGenericValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugGenericValue Wrap(Debugger.Interop.CorDebug.ICorDebugGenericValue objectToWrap) + { + return new ICorDebugGenericValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugGenericValue o1, ICorDebugGenericValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugGenericValue o1, ICorDebugGenericValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugGenericValue casted = o as ICorDebugGenericValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetValue(System.IntPtr pTo) + { + this.WrappedObject.GetValue(pTo); + } + + public void SetValue(System.IntPtr pFrom) + { + this.WrappedObject.SetValue(pFrom); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHandleValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHandleValue.cs new file mode 100644 index 0000000000..b8f396aeaf --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHandleValue.cs @@ -0,0 +1,146 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugHandleValue + { + + private Debugger.Interop.CorDebug.ICorDebugHandleValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugHandleValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugHandleValue(Debugger.Interop.CorDebug.ICorDebugHandleValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugHandleValue Wrap(Debugger.Interop.CorDebug.ICorDebugHandleValue objectToWrap) + { + return new ICorDebugHandleValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugHandleValue o1, ICorDebugHandleValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugHandleValue o1, ICorDebugHandleValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugHandleValue casted = o as ICorDebugHandleValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void IsNull(out int pbNull) + { + this.WrappedObject.IsNull(out pbNull); + } + + public void GetValue(out ulong pValue) + { + this.WrappedObject.GetValue(out pValue); + } + + public void SetValue(ulong value) + { + this.WrappedObject.SetValue(value); + } + + public void Dereference(out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.Dereference(out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void DereferenceStrong(out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.DereferenceStrong(out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetHandleType(out CorDebugHandleType pType) + { + Debugger.Interop.CorDebug.CorDebugHandleType out_pType; + this.WrappedObject.GetHandleType(out out_pType); + pType = ((CorDebugHandleType)(out_pType)); + } + + public void Dispose() + { + this.WrappedObject.Dispose(); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue.cs new file mode 100644 index 0000000000..8d36cf91b6 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue.cs @@ -0,0 +1,117 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugHeapValue + { + + private Debugger.Interop.CorDebug.ICorDebugHeapValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugHeapValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugHeapValue(Debugger.Interop.CorDebug.ICorDebugHeapValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugHeapValue Wrap(Debugger.Interop.CorDebug.ICorDebugHeapValue objectToWrap) + { + return new ICorDebugHeapValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugHeapValue o1, ICorDebugHeapValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugHeapValue o1, ICorDebugHeapValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugHeapValue casted = o as ICorDebugHeapValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void IsValid(out int pbValid) + { + this.WrappedObject.IsValid(out pbValid); + } + + public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue2.cs new file mode 100644 index 0000000000..8ffb825b71 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue2.cs @@ -0,0 +1,90 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugHeapValue2 + { + + private Debugger.Interop.CorDebug.ICorDebugHeapValue2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugHeapValue2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugHeapValue2(Debugger.Interop.CorDebug.ICorDebugHeapValue2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugHeapValue2 Wrap(Debugger.Interop.CorDebug.ICorDebugHeapValue2 objectToWrap) + { + return new ICorDebugHeapValue2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugHeapValue2 o1, ICorDebugHeapValue2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugHeapValue2 o1, ICorDebugHeapValue2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugHeapValue2 casted = o as ICorDebugHeapValue2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void CreateHandle(CorDebugHandleType type, out ICorDebugHandleValue ppHandle) + { + Debugger.Interop.CorDebug.ICorDebugHandleValue out_ppHandle; + this.WrappedObject.CreateHandle(((Debugger.Interop.CorDebug.CorDebugHandleType)(type)), out out_ppHandle); + ppHandle = ICorDebugHandleValue.Wrap(out_ppHandle); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame.cs new file mode 100644 index 0000000000..bf6e1f9eed --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame.cs @@ -0,0 +1,192 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugILFrame + { + + private Debugger.Interop.CorDebug.ICorDebugILFrame wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugILFrame WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugILFrame(Debugger.Interop.CorDebug.ICorDebugILFrame wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugILFrame Wrap(Debugger.Interop.CorDebug.ICorDebugILFrame objectToWrap) + { + return new ICorDebugILFrame(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugILFrame o1, ICorDebugILFrame o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugILFrame o1, ICorDebugILFrame o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugILFrame casted = o as ICorDebugILFrame; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetChain(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetChain(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void GetCode(out ICorDebugCode ppCode) + { + Debugger.Interop.CorDebug.ICorDebugCode out_ppCode; + this.WrappedObject.GetCode(out out_ppCode); + ppCode = ICorDebugCode.Wrap(out_ppCode); + } + + public void GetFunction(out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetFunction(out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetFunctionToken(out uint pToken) + { + this.WrappedObject.GetFunctionToken(out pToken); + } + + public void GetStackRange(out ulong pStart, out ulong pEnd) + { + this.WrappedObject.GetStackRange(out pStart, out pEnd); + } + + public void GetCaller(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetCaller(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void GetCallee(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetCallee(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void CreateStepper(out ICorDebugStepper ppStepper) + { + Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper; + this.WrappedObject.CreateStepper(out out_ppStepper); + ppStepper = ICorDebugStepper.Wrap(out_ppStepper); + } + + public void GetIP(out uint pnOffset, out CorDebugMappingResult pMappingResult) + { + Debugger.Interop.CorDebug.CorDebugMappingResult out_pMappingResult; + this.WrappedObject.GetIP(out pnOffset, out out_pMappingResult); + pMappingResult = ((CorDebugMappingResult)(out_pMappingResult)); + } + + public void SetIP(uint nOffset) + { + this.WrappedObject.SetIP(nOffset); + } + + public void EnumerateLocalVariables(out ICorDebugValueEnum ppValueEnum) + { + Debugger.Interop.CorDebug.ICorDebugValueEnum out_ppValueEnum; + this.WrappedObject.EnumerateLocalVariables(out out_ppValueEnum); + ppValueEnum = ICorDebugValueEnum.Wrap(out_ppValueEnum); + } + + public void GetLocalVariable(uint dwIndex, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetLocalVariable(dwIndex, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void EnumerateArguments(out ICorDebugValueEnum ppValueEnum) + { + Debugger.Interop.CorDebug.ICorDebugValueEnum out_ppValueEnum; + this.WrappedObject.EnumerateArguments(out out_ppValueEnum); + ppValueEnum = ICorDebugValueEnum.Wrap(out_ppValueEnum); + } + + public void GetArgument(uint dwIndex, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetArgument(dwIndex, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetStackDepth(out uint pDepth) + { + this.WrappedObject.GetStackDepth(out pDepth); + } + + public void GetStackValue(uint dwIndex, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetStackValue(dwIndex, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void CanSetIP(uint nOffset) + { + this.WrappedObject.CanSetIP(nOffset); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame2.cs new file mode 100644 index 0000000000..92ab3bfebe --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame2.cs @@ -0,0 +1,95 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugILFrame2 + { + + private Debugger.Interop.CorDebug.ICorDebugILFrame2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugILFrame2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugILFrame2(Debugger.Interop.CorDebug.ICorDebugILFrame2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugILFrame2 Wrap(Debugger.Interop.CorDebug.ICorDebugILFrame2 objectToWrap) + { + return new ICorDebugILFrame2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugILFrame2 o1, ICorDebugILFrame2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugILFrame2 o1, ICorDebugILFrame2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugILFrame2 casted = o as ICorDebugILFrame2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void RemapFunction(uint newILOffset) + { + this.WrappedObject.RemapFunction(newILOffset); + } + + public void EnumerateTypeParameters(out ICorDebugTypeEnum ppTyParEnum) + { + Debugger.Interop.CorDebug.ICorDebugTypeEnum out_ppTyParEnum; + this.WrappedObject.EnumerateTypeParameters(out out_ppTyParEnum); + ppTyParEnum = ICorDebugTypeEnum.Wrap(out_ppTyParEnum); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugInternalFrame.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugInternalFrame.cs new file mode 100644 index 0000000000..8d6387ea3d --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugInternalFrame.cs @@ -0,0 +1,142 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugInternalFrame + { + + private Debugger.Interop.CorDebug.ICorDebugInternalFrame wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugInternalFrame WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugInternalFrame(Debugger.Interop.CorDebug.ICorDebugInternalFrame wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugInternalFrame Wrap(Debugger.Interop.CorDebug.ICorDebugInternalFrame objectToWrap) + { + return new ICorDebugInternalFrame(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugInternalFrame o1, ICorDebugInternalFrame o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugInternalFrame o1, ICorDebugInternalFrame o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugInternalFrame casted = o as ICorDebugInternalFrame; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetChain(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetChain(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void GetCode(out ICorDebugCode ppCode) + { + Debugger.Interop.CorDebug.ICorDebugCode out_ppCode; + this.WrappedObject.GetCode(out out_ppCode); + ppCode = ICorDebugCode.Wrap(out_ppCode); + } + + public void GetFunction(out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetFunction(out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetFunctionToken(out uint pToken) + { + this.WrappedObject.GetFunctionToken(out pToken); + } + + public void GetStackRange(out ulong pStart, out ulong pEnd) + { + this.WrappedObject.GetStackRange(out pStart, out pEnd); + } + + public void GetCaller(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetCaller(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void GetCallee(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetCallee(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void CreateStepper(out ICorDebugStepper ppStepper) + { + Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper; + this.WrappedObject.CreateStepper(out out_ppStepper); + ppStepper = ICorDebugStepper.Wrap(out_ppStepper); + } + + public void GetFrameType(out CorDebugInternalFrameType pType) + { + Debugger.Interop.CorDebug.CorDebugInternalFrameType out_pType; + this.WrappedObject.GetFrameType(out out_pType); + pType = ((CorDebugInternalFrameType)(out_pType)); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugMDA.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugMDA.cs new file mode 100644 index 0000000000..10955e912b --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugMDA.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugMDA + { + + private Debugger.Interop.CorDebug.ICorDebugMDA wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugMDA WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugMDA(Debugger.Interop.CorDebug.ICorDebugMDA wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugMDA Wrap(Debugger.Interop.CorDebug.ICorDebugMDA objectToWrap) + { + return new ICorDebugMDA(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugMDA o1, ICorDebugMDA o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugMDA o1, ICorDebugMDA o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugMDA casted = o as ICorDebugMDA; + 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 GetDescription(uint cchName, out uint pcchName, System.IntPtr szName) + { + this.WrappedObject.GetDescription(cchName, out pcchName, szName); + } + + public void GetXML(uint cchName, out uint pcchName, System.IntPtr szName) + { + this.WrappedObject.GetXML(cchName, out pcchName, szName); + } + + public void GetFlags(ref CorDebugMDAFlags pFlags) + { + Debugger.Interop.CorDebug.CorDebugMDAFlags ref_pFlags = ((Debugger.Interop.CorDebug.CorDebugMDAFlags)(pFlags)); + this.WrappedObject.GetFlags(ref ref_pFlags); + pFlags = ((CorDebugMDAFlags)(ref_pFlags)); + } + + public void GetOSThreadId(out uint pOsTid) + { + this.WrappedObject.GetOSThreadId(out pOsTid); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugManagedCallback.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugManagedCallback.cs new file mode 100644 index 0000000000..c6fac20bf7 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugManagedCallback.cs @@ -0,0 +1,213 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugManagedCallback + { + + private Debugger.Interop.CorDebug.ICorDebugManagedCallback wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugManagedCallback WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugManagedCallback(Debugger.Interop.CorDebug.ICorDebugManagedCallback wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugManagedCallback Wrap(Debugger.Interop.CorDebug.ICorDebugManagedCallback objectToWrap) + { + return new ICorDebugManagedCallback(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugManagedCallback o1, ICorDebugManagedCallback o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugManagedCallback o1, ICorDebugManagedCallback o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugManagedCallback casted = o as ICorDebugManagedCallback; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Breakpoint(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pBreakpoint) + { + this.WrappedObject.Breakpoint(pAppDomain, pThread, pBreakpoint); + } + + public void StepComplete(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pStepper, CorDebugStepReason reason) + { + this.WrappedObject.StepComplete(pAppDomain, pThread, pStepper, ((Debugger.Interop.CorDebug.CorDebugStepReason)(reason))); + } + + public void Break(System.IntPtr pAppDomain, System.IntPtr thread) + { + this.WrappedObject.Break(pAppDomain, thread); + } + + public void Exception(System.IntPtr pAppDomain, System.IntPtr pThread, int unhandled) + { + this.WrappedObject.Exception(pAppDomain, pThread, unhandled); + } + + public void EvalComplete(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pEval) + { + this.WrappedObject.EvalComplete(pAppDomain, pThread, pEval); + } + + public void EvalException(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pEval) + { + this.WrappedObject.EvalException(pAppDomain, pThread, pEval); + } + + public void CreateProcess(System.IntPtr pProcess) + { + this.WrappedObject.CreateProcess(pProcess); + } + + public void ExitProcess(System.IntPtr pProcess) + { + this.WrappedObject.ExitProcess(pProcess); + } + + public void CreateThread(System.IntPtr pAppDomain, System.IntPtr thread) + { + this.WrappedObject.CreateThread(pAppDomain, thread); + } + + public void ExitThread(System.IntPtr pAppDomain, System.IntPtr thread) + { + this.WrappedObject.ExitThread(pAppDomain, thread); + } + + public void LoadModule(System.IntPtr pAppDomain, System.IntPtr pModule) + { + this.WrappedObject.LoadModule(pAppDomain, pModule); + } + + public void UnloadModule(System.IntPtr pAppDomain, System.IntPtr pModule) + { + this.WrappedObject.UnloadModule(pAppDomain, pModule); + } + + public void LoadClass(System.IntPtr pAppDomain, System.IntPtr c) + { + this.WrappedObject.LoadClass(pAppDomain, c); + } + + public void UnloadClass(System.IntPtr pAppDomain, System.IntPtr c) + { + this.WrappedObject.UnloadClass(pAppDomain, c); + } + + public void DebuggerError(System.IntPtr pProcess, int errorHR, uint errorCode) + { + this.WrappedObject.DebuggerError(pProcess, errorHR, errorCode); + } + + public void LogMessage(System.IntPtr pAppDomain, System.IntPtr pThread, int lLevel, System.IntPtr pLogSwitchName, System.IntPtr pMessage) + { + this.WrappedObject.LogMessage(pAppDomain, pThread, lLevel, pLogSwitchName, pMessage); + } + + public void LogSwitch(System.IntPtr pAppDomain, System.IntPtr pThread, int lLevel, uint ulReason, System.IntPtr pLogSwitchName, System.IntPtr pParentName) + { + this.WrappedObject.LogSwitch(pAppDomain, pThread, lLevel, ulReason, pLogSwitchName, pParentName); + } + + public void CreateAppDomain(System.IntPtr pProcess, System.IntPtr pAppDomain) + { + this.WrappedObject.CreateAppDomain(pProcess, pAppDomain); + } + + public void ExitAppDomain(System.IntPtr pProcess, System.IntPtr pAppDomain) + { + this.WrappedObject.ExitAppDomain(pProcess, pAppDomain); + } + + public void LoadAssembly(System.IntPtr pAppDomain, System.IntPtr pAssembly) + { + this.WrappedObject.LoadAssembly(pAppDomain, pAssembly); + } + + public void UnloadAssembly(System.IntPtr pAppDomain, System.IntPtr pAssembly) + { + this.WrappedObject.UnloadAssembly(pAppDomain, pAssembly); + } + + public void ControlCTrap(System.IntPtr pProcess) + { + this.WrappedObject.ControlCTrap(pProcess); + } + + public void NameChange(System.IntPtr pAppDomain, System.IntPtr pThread) + { + this.WrappedObject.NameChange(pAppDomain, pThread); + } + + public void UpdateModuleSymbols(System.IntPtr pAppDomain, System.IntPtr pModule, System.IntPtr pSymbolStream) + { + this.WrappedObject.UpdateModuleSymbols(pAppDomain, pModule, pSymbolStream); + } + + public void EditAndContinueRemap(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pFunction, int fAccurate) + { + this.WrappedObject.EditAndContinueRemap(pAppDomain, pThread, pFunction, fAccurate); + } + + public void BreakpointSetError(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pBreakpoint, uint dwError) + { + this.WrappedObject.BreakpointSetError(pAppDomain, pThread, pBreakpoint, dwError); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugManagedCallback2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugManagedCallback2.cs new file mode 100644 index 0000000000..7a20a65fc5 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugManagedCallback2.cs @@ -0,0 +1,123 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugManagedCallback2 + { + + private Debugger.Interop.CorDebug.ICorDebugManagedCallback2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugManagedCallback2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugManagedCallback2(Debugger.Interop.CorDebug.ICorDebugManagedCallback2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugManagedCallback2 Wrap(Debugger.Interop.CorDebug.ICorDebugManagedCallback2 objectToWrap) + { + return new ICorDebugManagedCallback2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugManagedCallback2 o1, ICorDebugManagedCallback2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugManagedCallback2 o1, ICorDebugManagedCallback2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugManagedCallback2 casted = o as ICorDebugManagedCallback2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void FunctionRemapOpportunity(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pOldFunction, System.IntPtr pNewFunction, uint oldILOffset) + { + this.WrappedObject.FunctionRemapOpportunity(pAppDomain, pThread, pOldFunction, pNewFunction, oldILOffset); + } + + public void CreateConnection(System.IntPtr pProcess, uint dwConnectionId, ref ushort pConnName) + { + this.WrappedObject.CreateConnection(pProcess, dwConnectionId, ref pConnName); + } + + public void ChangeConnection(System.IntPtr pProcess, uint dwConnectionId) + { + this.WrappedObject.ChangeConnection(pProcess, dwConnectionId); + } + + public void DestroyConnection(System.IntPtr pProcess, uint dwConnectionId) + { + this.WrappedObject.DestroyConnection(pProcess, dwConnectionId); + } + + public void Exception(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pFrame, uint nOffset, CorDebugExceptionCallbackType dwEventType, uint dwFlags) + { + this.WrappedObject.Exception(pAppDomain, pThread, pFrame, nOffset, ((Debugger.Interop.CorDebug.CorDebugExceptionCallbackType)(dwEventType)), dwFlags); + } + + public void ExceptionUnwind(System.IntPtr pAppDomain, System.IntPtr pThread, CorDebugExceptionUnwindCallbackType dwEventType, uint dwFlags) + { + this.WrappedObject.ExceptionUnwind(pAppDomain, pThread, ((Debugger.Interop.CorDebug.CorDebugExceptionUnwindCallbackType)(dwEventType)), dwFlags); + } + + public void FunctionRemapComplete(System.IntPtr pAppDomain, System.IntPtr pThread, System.IntPtr pFunction) + { + this.WrappedObject.FunctionRemapComplete(pAppDomain, pThread, pFunction); + } + + public void MDANotification(System.IntPtr pController, System.IntPtr pThread, System.IntPtr pMDA) + { + this.WrappedObject.MDANotification(pController, pThread, pMDA); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule.cs new file mode 100644 index 0000000000..0d4d9bfd13 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule.cs @@ -0,0 +1,184 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugModule + { + + private Debugger.Interop.CorDebug.ICorDebugModule wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugModule WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugModule(Debugger.Interop.CorDebug.ICorDebugModule wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugModule Wrap(Debugger.Interop.CorDebug.ICorDebugModule objectToWrap) + { + return new ICorDebugModule(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugModule o1, ICorDebugModule o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugModule o1, ICorDebugModule o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugModule casted = o as ICorDebugModule; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetProcess(out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.GetProcess(out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void GetBaseAddress(out ulong pAddress) + { + this.WrappedObject.GetBaseAddress(out pAddress); + } + + public void GetAssembly(out ICorDebugAssembly ppAssembly) + { + Debugger.Interop.CorDebug.ICorDebugAssembly out_ppAssembly; + this.WrappedObject.GetAssembly(out out_ppAssembly); + ppAssembly = ICorDebugAssembly.Wrap(out_ppAssembly); + } + + public void GetName(uint cchName, out uint pcchName, System.IntPtr szName) + { + this.WrappedObject.GetName(cchName, out pcchName, szName); + } + + public void EnableJITDebugging(int bTrackJITInfo, int bAllowJitOpts) + { + this.WrappedObject.EnableJITDebugging(bTrackJITInfo, bAllowJitOpts); + } + + public void EnableClassLoadCallbacks(int bClassLoadCallbacks) + { + this.WrappedObject.EnableClassLoadCallbacks(bClassLoadCallbacks); + } + + public void GetFunctionFromToken(uint methodDef, out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetFunctionFromToken(methodDef, out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetFunctionFromRVA(ulong rva, out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetFunctionFromRVA(rva, out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetClassFromToken(uint typeDef, out ICorDebugClass ppClass) + { + Debugger.Interop.CorDebug.ICorDebugClass out_ppClass; + this.WrappedObject.GetClassFromToken(typeDef, out out_ppClass); + ppClass = ICorDebugClass.Wrap(out_ppClass); + } + + public void CreateBreakpoint(out ICorDebugModuleBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugModuleBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugModuleBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetEditAndContinueSnapshot(out ICorDebugEditAndContinueSnapshot ppEditAndContinueSnapshot) + { + Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot out_ppEditAndContinueSnapshot; + this.WrappedObject.GetEditAndContinueSnapshot(out out_ppEditAndContinueSnapshot); + ppEditAndContinueSnapshot = ICorDebugEditAndContinueSnapshot.Wrap(out_ppEditAndContinueSnapshot); + } + + public void GetMetaDataInterface(ref System.Guid riid, out object ppObj) + { + this.WrappedObject.GetMetaDataInterface(ref riid, out ppObj); + } + + public void GetToken(out uint pToken) + { + this.WrappedObject.GetToken(out pToken); + } + + public void IsDynamic(out int pDynamic) + { + this.WrappedObject.IsDynamic(out pDynamic); + } + + public void GetGlobalVariableValue(uint fieldDef, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetGlobalVariableValue(fieldDef, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetSize(out uint pcBytes) + { + this.WrappedObject.GetSize(out pcBytes); + } + + public void IsInMemory(out int pInMemory) + { + this.WrappedObject.IsInMemory(out pInMemory); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule2.cs new file mode 100644 index 0000000000..5e46e3172e --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule2.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugModule2 + { + + private Debugger.Interop.CorDebug.ICorDebugModule2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugModule2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugModule2(Debugger.Interop.CorDebug.ICorDebugModule2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugModule2 Wrap(Debugger.Interop.CorDebug.ICorDebugModule2 objectToWrap) + { + return new ICorDebugModule2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugModule2 o1, ICorDebugModule2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugModule2 o1, ICorDebugModule2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugModule2 casted = o as ICorDebugModule2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void SetJMCStatus(int bIsJustMyCode, uint cTokens, ref uint pTokens) + { + this.WrappedObject.SetJMCStatus(bIsJustMyCode, cTokens, ref pTokens); + } + + public void ApplyChanges(uint cbMetadata, byte[] pbMetadata, uint cbIL, byte[] pbIL) + { + this.WrappedObject.ApplyChanges(cbMetadata, pbMetadata, cbIL, pbIL); + } + + public void SetJITCompilerFlags(uint dwFlags) + { + this.WrappedObject.SetJITCompilerFlags(dwFlags); + } + + public void GetJITCompilerFlags(out uint pdwFlags) + { + this.WrappedObject.GetJITCompilerFlags(out pdwFlags); + } + + public void ResolveAssembly(uint tkAssemblyRef, ref ICorDebugAssembly ppAssembly) + { + Debugger.Interop.CorDebug.ICorDebugAssembly ref_ppAssembly = ppAssembly.WrappedObject; + this.WrappedObject.ResolveAssembly(tkAssemblyRef, ref ref_ppAssembly); + ppAssembly = ICorDebugAssembly.Wrap(ref_ppAssembly); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleBreakpoint.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleBreakpoint.cs new file mode 100644 index 0000000000..6c8bf148b0 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleBreakpoint.cs @@ -0,0 +1,100 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugModuleBreakpoint + { + + private Debugger.Interop.CorDebug.ICorDebugModuleBreakpoint wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugModuleBreakpoint WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugModuleBreakpoint(Debugger.Interop.CorDebug.ICorDebugModuleBreakpoint wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugModuleBreakpoint Wrap(Debugger.Interop.CorDebug.ICorDebugModuleBreakpoint objectToWrap) + { + return new ICorDebugModuleBreakpoint(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugModuleBreakpoint o1, ICorDebugModuleBreakpoint o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugModuleBreakpoint o1, ICorDebugModuleBreakpoint o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugModuleBreakpoint casted = o as ICorDebugModuleBreakpoint; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Activate(int bActive) + { + this.WrappedObject.Activate(bActive); + } + + public void IsActive(out int pbActive) + { + this.WrappedObject.IsActive(out pbActive); + } + + public void GetModule(out ICorDebugModule ppModule) + { + Debugger.Interop.CorDebug.ICorDebugModule out_ppModule; + this.WrappedObject.GetModule(out out_ppModule); + ppModule = ICorDebugModule.Wrap(out_ppModule); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleEnum.cs new file mode 100644 index 0000000000..0b00c5f068 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugModuleEnum + { + + private Debugger.Interop.CorDebug.ICorDebugModuleEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugModuleEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugModuleEnum(Debugger.Interop.CorDebug.ICorDebugModuleEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugModuleEnum Wrap(Debugger.Interop.CorDebug.ICorDebugModuleEnum objectToWrap) + { + return new ICorDebugModuleEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugModuleEnum o1, ICorDebugModuleEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugModuleEnum o1, ICorDebugModuleEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugModuleEnum casted = o as ICorDebugModuleEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr modules, out uint pceltFetched) + { + this.WrappedObject.Next(celt, modules, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugNativeFrame.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugNativeFrame.cs new file mode 100644 index 0000000000..6ca0ef519d --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugNativeFrame.cs @@ -0,0 +1,192 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugNativeFrame + { + + private Debugger.Interop.CorDebug.ICorDebugNativeFrame wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugNativeFrame WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugNativeFrame(Debugger.Interop.CorDebug.ICorDebugNativeFrame wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugNativeFrame Wrap(Debugger.Interop.CorDebug.ICorDebugNativeFrame objectToWrap) + { + return new ICorDebugNativeFrame(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugNativeFrame o1, ICorDebugNativeFrame o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugNativeFrame o1, ICorDebugNativeFrame o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugNativeFrame casted = o as ICorDebugNativeFrame; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetChain(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetChain(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void GetCode(out ICorDebugCode ppCode) + { + Debugger.Interop.CorDebug.ICorDebugCode out_ppCode; + this.WrappedObject.GetCode(out out_ppCode); + ppCode = ICorDebugCode.Wrap(out_ppCode); + } + + public void GetFunction(out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetFunction(out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetFunctionToken(out uint pToken) + { + this.WrappedObject.GetFunctionToken(out pToken); + } + + public void GetStackRange(out ulong pStart, out ulong pEnd) + { + this.WrappedObject.GetStackRange(out pStart, out pEnd); + } + + public void GetCaller(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetCaller(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void GetCallee(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetCallee(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void CreateStepper(out ICorDebugStepper ppStepper) + { + Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper; + this.WrappedObject.CreateStepper(out out_ppStepper); + ppStepper = ICorDebugStepper.Wrap(out_ppStepper); + } + + public void GetIP(out uint pnOffset) + { + this.WrappedObject.GetIP(out pnOffset); + } + + public void SetIP(uint nOffset) + { + this.WrappedObject.SetIP(nOffset); + } + + public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters) + { + Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters; + this.WrappedObject.GetRegisterSet(out out_ppRegisters); + ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters); + } + + public void GetLocalRegisterValue(CorDebugRegister reg, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetLocalRegisterValue(((Debugger.Interop.CorDebug.CorDebugRegister)(reg)), cbSigBlob, pvSigBlob, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetLocalDoubleRegisterValue(CorDebugRegister highWordReg, CorDebugRegister lowWordReg, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetLocalDoubleRegisterValue(((Debugger.Interop.CorDebug.CorDebugRegister)(highWordReg)), ((Debugger.Interop.CorDebug.CorDebugRegister)(lowWordReg)), cbSigBlob, pvSigBlob, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetLocalMemoryValue(ulong address, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetLocalMemoryValue(address, cbSigBlob, pvSigBlob, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetLocalRegisterMemoryValue(CorDebugRegister highWordReg, ulong lowWordAddress, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetLocalRegisterMemoryValue(((Debugger.Interop.CorDebug.CorDebugRegister)(highWordReg)), lowWordAddress, cbSigBlob, pvSigBlob, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetLocalMemoryRegisterValue(ulong highWordAddress, CorDebugRegister lowWordRegister, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetLocalMemoryRegisterValue(highWordAddress, ((Debugger.Interop.CorDebug.CorDebugRegister)(lowWordRegister)), cbSigBlob, pvSigBlob, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void CanSetIP(uint nOffset) + { + this.WrappedObject.CanSetIP(nOffset); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectEnum.cs new file mode 100644 index 0000000000..def1dea785 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugObjectEnum + { + + private Debugger.Interop.CorDebug.ICorDebugObjectEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugObjectEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugObjectEnum(Debugger.Interop.CorDebug.ICorDebugObjectEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugObjectEnum Wrap(Debugger.Interop.CorDebug.ICorDebugObjectEnum objectToWrap) + { + return new ICorDebugObjectEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugObjectEnum o1, ICorDebugObjectEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugObjectEnum o1, ICorDebugObjectEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugObjectEnum casted = o as ICorDebugObjectEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr objects, out uint pceltFetched) + { + this.WrappedObject.Next(celt, objects, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue.cs new file mode 100644 index 0000000000..a2d508874c --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue.cs @@ -0,0 +1,148 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugObjectValue + { + + private Debugger.Interop.CorDebug.ICorDebugObjectValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugObjectValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugObjectValue(Debugger.Interop.CorDebug.ICorDebugObjectValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugObjectValue Wrap(Debugger.Interop.CorDebug.ICorDebugObjectValue objectToWrap) + { + return new ICorDebugObjectValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugObjectValue o1, ICorDebugObjectValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugObjectValue o1, ICorDebugObjectValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugObjectValue casted = o as ICorDebugObjectValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetClass(out ICorDebugClass ppClass) + { + Debugger.Interop.CorDebug.ICorDebugClass out_ppClass; + this.WrappedObject.GetClass(out out_ppClass); + ppClass = ICorDebugClass.Wrap(out_ppClass); + } + + public void GetFieldValue(ICorDebugClass pClass, uint fieldDef, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetFieldValue(pClass.WrappedObject, fieldDef, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetVirtualMethod(uint memberRef, out ICorDebugFunction ppFunction) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + this.WrappedObject.GetVirtualMethod(memberRef, out out_ppFunction); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + } + + public void GetContext(out ICorDebugContext ppContext) + { + Debugger.Interop.CorDebug.ICorDebugContext out_ppContext; + this.WrappedObject.GetContext(out out_ppContext); + ppContext = ICorDebugContext.Wrap(out_ppContext); + } + + public void IsValueClass(out int pbIsValueClass) + { + this.WrappedObject.IsValueClass(out pbIsValueClass); + } + + public void GetManagedCopy(out object ppObject) + { + this.WrappedObject.GetManagedCopy(out ppObject); + } + + public void SetFromManagedCopy(object pObject) + { + this.WrappedObject.SetFromManagedCopy(pObject); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue2.cs new file mode 100644 index 0000000000..0cf649e423 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue2.cs @@ -0,0 +1,92 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugObjectValue2 + { + + private Debugger.Interop.CorDebug.ICorDebugObjectValue2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugObjectValue2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugObjectValue2(Debugger.Interop.CorDebug.ICorDebugObjectValue2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugObjectValue2 Wrap(Debugger.Interop.CorDebug.ICorDebugObjectValue2 objectToWrap) + { + return new ICorDebugObjectValue2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugObjectValue2 o1, ICorDebugObjectValue2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugObjectValue2 o1, ICorDebugObjectValue2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugObjectValue2 casted = o as ICorDebugObjectValue2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetVirtualMethodAndType(uint memberRef, out ICorDebugFunction ppFunction, out ICorDebugType ppType) + { + Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction; + Debugger.Interop.CorDebug.ICorDebugType out_ppType; + this.WrappedObject.GetVirtualMethodAndType(memberRef, out out_ppFunction, out out_ppType); + ppFunction = ICorDebugFunction.Wrap(out_ppFunction); + ppType = ICorDebugType.Wrap(out_ppType); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess.cs new file mode 100644 index 0000000000..12645ecc91 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess.cs @@ -0,0 +1,238 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugProcess + { + + private Debugger.Interop.CorDebug.ICorDebugProcess wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugProcess WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugProcess(Debugger.Interop.CorDebug.ICorDebugProcess wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugProcess Wrap(Debugger.Interop.CorDebug.ICorDebugProcess objectToWrap) + { + return new ICorDebugProcess(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugProcess o1, ICorDebugProcess o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugProcess o1, ICorDebugProcess o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugProcess casted = o as ICorDebugProcess; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Stop(uint dwTimeoutIgnored) + { + this.WrappedObject.Stop(dwTimeoutIgnored); + } + + public void Continue(int fIsOutOfBand) + { + this.WrappedObject.Continue(fIsOutOfBand); + } + + public void IsRunning(out int pbRunning) + { + this.WrappedObject.IsRunning(out pbRunning); + } + + public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued) + { + this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued); + } + + public void EnumerateThreads(out ICorDebugThreadEnum ppThreads) + { + Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads; + this.WrappedObject.EnumerateThreads(out out_ppThreads); + ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads); + } + + public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread) + { + this.WrappedObject.SetAllThreadsDebugState(((Debugger.Interop.CorDebug.CorDebugThreadState)(state)), pExceptThisThread.WrappedObject); + } + + public void Detach() + { + this.WrappedObject.Detach(); + } + + public void Terminate(uint exitCode) + { + this.WrappedObject.Terminate(exitCode); + } + + public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError) + { + Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError; + this.WrappedObject.CanCommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError); + pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots); + pError = ICorDebugErrorInfoEnum.Wrap(out_pError); + } + + public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError) + { + Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject; + Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError; + this.WrappedObject.CommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError); + pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots); + pError = ICorDebugErrorInfoEnum.Wrap(out_pError); + } + + public void GetID(out uint pdwProcessId) + { + this.WrappedObject.GetID(out pdwProcessId); + } + + public void GetHandle(out uint phProcessHandle) + { + this.WrappedObject.GetHandle(out phProcessHandle); + } + + public void GetThread(uint dwThreadId, out ICorDebugThread ppThread) + { + Debugger.Interop.CorDebug.ICorDebugThread out_ppThread; + this.WrappedObject.GetThread(dwThreadId, out out_ppThread); + ppThread = ICorDebugThread.Wrap(out_ppThread); + } + + public void EnumerateObjects(out ICorDebugObjectEnum ppObjects) + { + Debugger.Interop.CorDebug.ICorDebugObjectEnum out_ppObjects; + this.WrappedObject.EnumerateObjects(out out_ppObjects); + ppObjects = ICorDebugObjectEnum.Wrap(out_ppObjects); + } + + public void IsTransitionStub(ulong address, out int pbTransitionStub) + { + this.WrappedObject.IsTransitionStub(address, out pbTransitionStub); + } + + public void IsOSSuspended(uint threadID, out int pbSuspended) + { + this.WrappedObject.IsOSSuspended(threadID, out pbSuspended); + } + + public void GetThreadContext(uint threadID, uint contextSize, System.IntPtr context) + { + this.WrappedObject.GetThreadContext(threadID, contextSize, context); + } + + public void SetThreadContext(uint threadID, uint contextSize, System.IntPtr context) + { + this.WrappedObject.SetThreadContext(threadID, contextSize, context); + } + + public void ReadMemory(ulong address, uint size, System.IntPtr buffer, out uint read) + { + this.WrappedObject.ReadMemory(address, size, buffer, out read); + } + + public void WriteMemory(ulong address, uint size, ref byte buffer, out uint written) + { + this.WrappedObject.WriteMemory(address, size, ref buffer, out written); + } + + public void ClearCurrentException(uint threadID) + { + this.WrappedObject.ClearCurrentException(threadID); + } + + public void EnableLogMessages(int fOnOff) + { + this.WrappedObject.EnableLogMessages(fOnOff); + } + + public void ModifyLogSwitch(ref ushort pLogSwitchName, int lLevel) + { + this.WrappedObject.ModifyLogSwitch(ref pLogSwitchName, lLevel); + } + + public void EnumerateAppDomains(out ICorDebugAppDomainEnum ppAppDomains) + { + Debugger.Interop.CorDebug.ICorDebugAppDomainEnum out_ppAppDomains; + this.WrappedObject.EnumerateAppDomains(out out_ppAppDomains); + ppAppDomains = ICorDebugAppDomainEnum.Wrap(out_ppAppDomains); + } + + public void GetObject(out ICorDebugValue ppObject) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppObject; + this.WrappedObject.GetObject(out out_ppObject); + ppObject = ICorDebugValue.Wrap(out_ppObject); + } + + public void ThreadForFiberCookie(uint fiberCookie, out ICorDebugThread ppThread) + { + Debugger.Interop.CorDebug.ICorDebugThread out_ppThread; + this.WrappedObject.ThreadForFiberCookie(fiberCookie, out out_ppThread); + ppThread = ICorDebugThread.Wrap(out_ppThread); + } + + public void GetHelperThreadID(out uint pThreadID) + { + this.WrappedObject.GetHelperThreadID(out pThreadID); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess2.cs new file mode 100644 index 0000000000..c073b26cfe --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess2.cs @@ -0,0 +1,122 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugProcess2 + { + + private Debugger.Interop.CorDebug.ICorDebugProcess2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugProcess2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugProcess2(Debugger.Interop.CorDebug.ICorDebugProcess2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugProcess2 Wrap(Debugger.Interop.CorDebug.ICorDebugProcess2 objectToWrap) + { + return new ICorDebugProcess2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugProcess2 o1, ICorDebugProcess2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugProcess2 o1, ICorDebugProcess2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugProcess2 casted = o as ICorDebugProcess2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetThreadForTaskID(ulong taskid, out ICorDebugThread2 ppThread) + { + Debugger.Interop.CorDebug.ICorDebugThread2 out_ppThread; + this.WrappedObject.GetThreadForTaskID(taskid, out out_ppThread); + ppThread = ICorDebugThread2.Wrap(out_ppThread); + } + + public void GetVersion(out Debugger.Interop.CorDebug._COR_VERSION version) + { + this.WrappedObject.GetVersion(out version); + } + + public void SetUnmanagedBreakpoint(ulong address, uint bufsize, System.IntPtr buffer, out uint bufLen) + { + this.WrappedObject.SetUnmanagedBreakpoint(address, bufsize, buffer, out bufLen); + } + + public void ClearUnmanagedBreakpoint(ulong address) + { + this.WrappedObject.ClearUnmanagedBreakpoint(address); + } + + public void SetDesiredNGENCompilerFlags(uint pdwFlags) + { + this.WrappedObject.SetDesiredNGENCompilerFlags(pdwFlags); + } + + public void GetDesiredNGENCompilerFlags(out uint pdwFlags) + { + this.WrappedObject.GetDesiredNGENCompilerFlags(out pdwFlags); + } + + public void GetReferenceValueFromGCHandle(uint handle, out ICorDebugReferenceValue pOutValue) + { + Debugger.Interop.CorDebug.ICorDebugReferenceValue out_pOutValue; + this.WrappedObject.GetReferenceValueFromGCHandle(handle, out out_pOutValue); + pOutValue = ICorDebugReferenceValue.Wrap(out_pOutValue); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcessEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcessEnum.cs new file mode 100644 index 0000000000..138428f882 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcessEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugProcessEnum + { + + private Debugger.Interop.CorDebug.ICorDebugProcessEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugProcessEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugProcessEnum(Debugger.Interop.CorDebug.ICorDebugProcessEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugProcessEnum Wrap(Debugger.Interop.CorDebug.ICorDebugProcessEnum objectToWrap) + { + return new ICorDebugProcessEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugProcessEnum o1, ICorDebugProcessEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugProcessEnum o1, ICorDebugProcessEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugProcessEnum casted = o as ICorDebugProcessEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr processes, out uint pceltFetched) + { + this.WrappedObject.Next(celt, processes, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugReferenceValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugReferenceValue.cs new file mode 100644 index 0000000000..fc7f8151b1 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugReferenceValue.cs @@ -0,0 +1,134 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugReferenceValue + { + + private Debugger.Interop.CorDebug.ICorDebugReferenceValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugReferenceValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugReferenceValue(Debugger.Interop.CorDebug.ICorDebugReferenceValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugReferenceValue Wrap(Debugger.Interop.CorDebug.ICorDebugReferenceValue objectToWrap) + { + return new ICorDebugReferenceValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugReferenceValue o1, ICorDebugReferenceValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugReferenceValue o1, ICorDebugReferenceValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugReferenceValue casted = o as ICorDebugReferenceValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void IsNull(out int pbNull) + { + this.WrappedObject.IsNull(out pbNull); + } + + public void GetValue(out ulong pValue) + { + this.WrappedObject.GetValue(out pValue); + } + + public void SetValue(ulong value) + { + this.WrappedObject.SetValue(value); + } + + public void Dereference(out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.Dereference(out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void DereferenceStrong(out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.DereferenceStrong(out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugRegisterSet.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugRegisterSet.cs new file mode 100644 index 0000000000..82740e2a9e --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugRegisterSet.cs @@ -0,0 +1,108 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugRegisterSet + { + + private Debugger.Interop.CorDebug.ICorDebugRegisterSet wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugRegisterSet WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugRegisterSet(Debugger.Interop.CorDebug.ICorDebugRegisterSet wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugRegisterSet Wrap(Debugger.Interop.CorDebug.ICorDebugRegisterSet objectToWrap) + { + return new ICorDebugRegisterSet(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugRegisterSet o1, ICorDebugRegisterSet o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugRegisterSet o1, ICorDebugRegisterSet o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugRegisterSet casted = o as ICorDebugRegisterSet; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetRegistersAvailable(out ulong pAvailable) + { + this.WrappedObject.GetRegistersAvailable(out pAvailable); + } + + public void GetRegisters(ulong mask, uint regCount, System.IntPtr regBuffer) + { + this.WrappedObject.GetRegisters(mask, regCount, regBuffer); + } + + public void SetRegisters(ulong mask, uint regCount, ref ulong regBuffer) + { + this.WrappedObject.SetRegisters(mask, regCount, ref regBuffer); + } + + public void GetThreadContext(uint contextSize, System.IntPtr context) + { + this.WrappedObject.GetThreadContext(contextSize, context); + } + + public void SetThreadContext(uint contextSize, System.IntPtr context) + { + this.WrappedObject.SetThreadContext(contextSize, context); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper.cs new file mode 100644 index 0000000000..430ea5ba68 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper.cs @@ -0,0 +1,123 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugStepper + { + + private Debugger.Interop.CorDebug.ICorDebugStepper wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugStepper WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugStepper(Debugger.Interop.CorDebug.ICorDebugStepper wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugStepper Wrap(Debugger.Interop.CorDebug.ICorDebugStepper objectToWrap) + { + return new ICorDebugStepper(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugStepper o1, ICorDebugStepper o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugStepper o1, ICorDebugStepper o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugStepper casted = o as ICorDebugStepper; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void IsActive(out int pbActive) + { + this.WrappedObject.IsActive(out pbActive); + } + + public void Deactivate() + { + this.WrappedObject.Deactivate(); + } + + public void SetInterceptMask(CorDebugIntercept mask) + { + this.WrappedObject.SetInterceptMask(((Debugger.Interop.CorDebug.CorDebugIntercept)(mask))); + } + + public void SetUnmappedStopMask(CorDebugUnmappedStop mask) + { + this.WrappedObject.SetUnmappedStopMask(((Debugger.Interop.CorDebug.CorDebugUnmappedStop)(mask))); + } + + public void Step(int bStepIn) + { + this.WrappedObject.Step(bStepIn); + } + + public void StepRange(int bStepIn, System.IntPtr ranges, uint cRangeCount) + { + this.WrappedObject.StepRange(bStepIn, ranges, cRangeCount); + } + + public void StepOut() + { + this.WrappedObject.StepOut(); + } + + public void SetRangeIL(int bIL) + { + this.WrappedObject.SetRangeIL(bIL); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper2.cs new file mode 100644 index 0000000000..ec897f89e0 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper2.cs @@ -0,0 +1,88 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugStepper2 + { + + private Debugger.Interop.CorDebug.ICorDebugStepper2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugStepper2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugStepper2(Debugger.Interop.CorDebug.ICorDebugStepper2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugStepper2 Wrap(Debugger.Interop.CorDebug.ICorDebugStepper2 objectToWrap) + { + return new ICorDebugStepper2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugStepper2 o1, ICorDebugStepper2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugStepper2 o1, ICorDebugStepper2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugStepper2 casted = o as ICorDebugStepper2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void SetJMC(int fIsJMCStepper) + { + this.WrappedObject.SetJMC(fIsJMCStepper); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepperEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepperEnum.cs new file mode 100644 index 0000000000..29b0f84c7f --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepperEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugStepperEnum + { + + private Debugger.Interop.CorDebug.ICorDebugStepperEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugStepperEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugStepperEnum(Debugger.Interop.CorDebug.ICorDebugStepperEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugStepperEnum Wrap(Debugger.Interop.CorDebug.ICorDebugStepperEnum objectToWrap) + { + return new ICorDebugStepperEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugStepperEnum o1, ICorDebugStepperEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugStepperEnum o1, ICorDebugStepperEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugStepperEnum casted = o as ICorDebugStepperEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr steppers, out uint pceltFetched) + { + this.WrappedObject.Next(celt, steppers, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStringValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStringValue.cs new file mode 100644 index 0000000000..dcb3b97036 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStringValue.cs @@ -0,0 +1,127 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugStringValue + { + + private Debugger.Interop.CorDebug.ICorDebugStringValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugStringValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugStringValue(Debugger.Interop.CorDebug.ICorDebugStringValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugStringValue Wrap(Debugger.Interop.CorDebug.ICorDebugStringValue objectToWrap) + { + return new ICorDebugStringValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugStringValue o1, ICorDebugStringValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugStringValue o1, ICorDebugStringValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugStringValue casted = o as ICorDebugStringValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void IsValid(out int pbValid) + { + this.WrappedObject.IsValid(out pbValid); + } + + public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + + public void GetLength(out uint pcchString) + { + this.WrappedObject.GetLength(out pcchString); + } + + public void GetString(uint cchString, out uint pcchString, System.IntPtr szString) + { + this.WrappedObject.GetString(cchString, out pcchString, szString); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread.cs new file mode 100644 index 0000000000..cf2b0bc309 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread.cs @@ -0,0 +1,187 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugThread + { + + private Debugger.Interop.CorDebug.ICorDebugThread wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugThread WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugThread(Debugger.Interop.CorDebug.ICorDebugThread wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugThread Wrap(Debugger.Interop.CorDebug.ICorDebugThread objectToWrap) + { + return new ICorDebugThread(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugThread o1, ICorDebugThread o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugThread o1, ICorDebugThread o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugThread casted = o as ICorDebugThread; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetProcess(out ICorDebugProcess ppProcess) + { + Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess; + this.WrappedObject.GetProcess(out out_ppProcess); + ppProcess = ICorDebugProcess.Wrap(out_ppProcess); + } + + public void GetID(out uint pdwThreadId) + { + this.WrappedObject.GetID(out pdwThreadId); + } + + public void GetHandle(out uint phThreadHandle) + { + this.WrappedObject.GetHandle(out phThreadHandle); + } + + public void GetAppDomain(out ICorDebugAppDomain ppAppDomain) + { + Debugger.Interop.CorDebug.ICorDebugAppDomain out_ppAppDomain; + this.WrappedObject.GetAppDomain(out out_ppAppDomain); + ppAppDomain = ICorDebugAppDomain.Wrap(out_ppAppDomain); + } + + public void SetDebugState(CorDebugThreadState state) + { + this.WrappedObject.SetDebugState(((Debugger.Interop.CorDebug.CorDebugThreadState)(state))); + } + + public void GetDebugState(out CorDebugThreadState pState) + { + Debugger.Interop.CorDebug.CorDebugThreadState out_pState; + this.WrappedObject.GetDebugState(out out_pState); + pState = ((CorDebugThreadState)(out_pState)); + } + + public void GetUserState(out CorDebugUserState pState) + { + Debugger.Interop.CorDebug.CorDebugUserState out_pState; + this.WrappedObject.GetUserState(out out_pState); + pState = ((CorDebugUserState)(out_pState)); + } + + public void GetCurrentException(out ICorDebugValue ppExceptionObject) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppExceptionObject; + this.WrappedObject.GetCurrentException(out out_ppExceptionObject); + ppExceptionObject = ICorDebugValue.Wrap(out_ppExceptionObject); + } + + public void ClearCurrentException() + { + this.WrappedObject.ClearCurrentException(); + } + + public void CreateStepper(out ICorDebugStepper ppStepper) + { + Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper; + this.WrappedObject.CreateStepper(out out_ppStepper); + ppStepper = ICorDebugStepper.Wrap(out_ppStepper); + } + + public void EnumerateChains(out ICorDebugChainEnum ppChains) + { + Debugger.Interop.CorDebug.ICorDebugChainEnum out_ppChains; + this.WrappedObject.EnumerateChains(out out_ppChains); + ppChains = ICorDebugChainEnum.Wrap(out_ppChains); + } + + public void GetActiveChain(out ICorDebugChain ppChain) + { + Debugger.Interop.CorDebug.ICorDebugChain out_ppChain; + this.WrappedObject.GetActiveChain(out out_ppChain); + ppChain = ICorDebugChain.Wrap(out_ppChain); + } + + public void GetActiveFrame(out ICorDebugFrame ppFrame) + { + Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame; + this.WrappedObject.GetActiveFrame(out out_ppFrame); + ppFrame = ICorDebugFrame.Wrap(out_ppFrame); + } + + public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters) + { + Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters; + this.WrappedObject.GetRegisterSet(out out_ppRegisters); + ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters); + } + + public void CreateEval(out ICorDebugEval ppEval) + { + Debugger.Interop.CorDebug.ICorDebugEval out_ppEval; + this.WrappedObject.CreateEval(out out_ppEval); + ppEval = ICorDebugEval.Wrap(out_ppEval); + } + + public void GetObject(out ICorDebugValue ppObject) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppObject; + this.WrappedObject.GetObject(out out_ppObject); + ppObject = ICorDebugValue.Wrap(out_ppObject); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread2.cs new file mode 100644 index 0000000000..803d2f08e2 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread2.cs @@ -0,0 +1,108 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugThread2 + { + + private Debugger.Interop.CorDebug.ICorDebugThread2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugThread2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugThread2(Debugger.Interop.CorDebug.ICorDebugThread2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugThread2 Wrap(Debugger.Interop.CorDebug.ICorDebugThread2 objectToWrap) + { + return new ICorDebugThread2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugThread2 o1, ICorDebugThread2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugThread2 o1, ICorDebugThread2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugThread2 casted = o as ICorDebugThread2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetActiveFunctions(uint cFunctions, out uint pcFunctions, System.IntPtr pFunctions) + { + this.WrappedObject.GetActiveFunctions(cFunctions, out pcFunctions, pFunctions); + } + + public void GetConnectionID(out uint pdwConnectionId) + { + this.WrappedObject.GetConnectionID(out pdwConnectionId); + } + + public void GetTaskID(out ulong pTaskId) + { + this.WrappedObject.GetTaskID(out pTaskId); + } + + public void GetVolatileOSThreadID(out uint pdwTid) + { + this.WrappedObject.GetVolatileOSThreadID(out pdwTid); + } + + public void InterceptCurrentException(ICorDebugFrame pFrame) + { + this.WrappedObject.InterceptCurrentException(pFrame.WrappedObject); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThreadEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThreadEnum.cs new file mode 100644 index 0000000000..126e9ed239 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThreadEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugThreadEnum + { + + private Debugger.Interop.CorDebug.ICorDebugThreadEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugThreadEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugThreadEnum(Debugger.Interop.CorDebug.ICorDebugThreadEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugThreadEnum Wrap(Debugger.Interop.CorDebug.ICorDebugThreadEnum objectToWrap) + { + return new ICorDebugThreadEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugThreadEnum o1, ICorDebugThreadEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugThreadEnum o1, ICorDebugThreadEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugThreadEnum casted = o as ICorDebugThreadEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr threads, out uint pceltFetched) + { + this.WrappedObject.Next(celt, threads, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugType.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugType.cs new file mode 100644 index 0000000000..b03aab7d35 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugType.cs @@ -0,0 +1,128 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugType + { + + private Debugger.Interop.CorDebug.ICorDebugType wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugType WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugType(Debugger.Interop.CorDebug.ICorDebugType wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugType Wrap(Debugger.Interop.CorDebug.ICorDebugType objectToWrap) + { + return new ICorDebugType(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugType o1, ICorDebugType o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugType o1, ICorDebugType o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugType casted = o as ICorDebugType; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint ty) + { + this.WrappedObject.GetType(out ty); + } + + public void GetClass(out ICorDebugClass ppClass) + { + Debugger.Interop.CorDebug.ICorDebugClass out_ppClass; + this.WrappedObject.GetClass(out out_ppClass); + ppClass = ICorDebugClass.Wrap(out_ppClass); + } + + public void EnumerateTypeParameters(out ICorDebugTypeEnum ppTyParEnum) + { + Debugger.Interop.CorDebug.ICorDebugTypeEnum out_ppTyParEnum; + this.WrappedObject.EnumerateTypeParameters(out out_ppTyParEnum); + ppTyParEnum = ICorDebugTypeEnum.Wrap(out_ppTyParEnum); + } + + public void GetFirstTypeParameter(out ICorDebugType value) + { + Debugger.Interop.CorDebug.ICorDebugType out_value; + this.WrappedObject.GetFirstTypeParameter(out out_value); + value = ICorDebugType.Wrap(out_value); + } + + public void GetBase(out ICorDebugType pBase) + { + Debugger.Interop.CorDebug.ICorDebugType out_pBase; + this.WrappedObject.GetBase(out out_pBase); + pBase = ICorDebugType.Wrap(out_pBase); + } + + public void GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetStaticFieldValue(fieldDef, pFrame.WrappedObject, out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + + public void GetRank(out uint pnRank) + { + this.WrappedObject.GetRank(out pnRank); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugTypeEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugTypeEnum.cs new file mode 100644 index 0000000000..440507d4cb --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugTypeEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugTypeEnum + { + + private Debugger.Interop.CorDebug.ICorDebugTypeEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugTypeEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugTypeEnum(Debugger.Interop.CorDebug.ICorDebugTypeEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugTypeEnum Wrap(Debugger.Interop.CorDebug.ICorDebugTypeEnum objectToWrap) + { + return new ICorDebugTypeEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugTypeEnum o1, ICorDebugTypeEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugTypeEnum o1, ICorDebugTypeEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugTypeEnum casted = o as ICorDebugTypeEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr values, out uint pceltFetched) + { + this.WrappedObject.Next(celt, values, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugUnmanagedCallback.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugUnmanagedCallback.cs new file mode 100644 index 0000000000..7e1db041cc --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugUnmanagedCallback.cs @@ -0,0 +1,88 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugUnmanagedCallback + { + + private Debugger.Interop.CorDebug.ICorDebugUnmanagedCallback wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugUnmanagedCallback WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugUnmanagedCallback(Debugger.Interop.CorDebug.ICorDebugUnmanagedCallback wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugUnmanagedCallback Wrap(Debugger.Interop.CorDebug.ICorDebugUnmanagedCallback objectToWrap) + { + return new ICorDebugUnmanagedCallback(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugUnmanagedCallback o1, ICorDebugUnmanagedCallback o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugUnmanagedCallback o1, ICorDebugUnmanagedCallback o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugUnmanagedCallback casted = o as ICorDebugUnmanagedCallback; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void DebugEvent(uint pDebugEvent, int fOutOfBand) + { + this.WrappedObject.DebugEvent(pDebugEvent, fOutOfBand); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue.cs new file mode 100644 index 0000000000..b69b920353 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue.cs @@ -0,0 +1,105 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugValue + { + + private Debugger.Interop.CorDebug.ICorDebugValue wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugValue WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugValue(Debugger.Interop.CorDebug.ICorDebugValue wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugValue Wrap(Debugger.Interop.CorDebug.ICorDebugValue objectToWrap) + { + return new ICorDebugValue(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugValue o1, ICorDebugValue o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugValue o1, ICorDebugValue o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugValue casted = o as ICorDebugValue; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetType(out uint pType) + { + this.WrappedObject.GetType(out pType); + } + + public void GetSize(out uint pSize) + { + this.WrappedObject.GetSize(out pSize); + } + + public void GetAddress(out ulong pAddress) + { + this.WrappedObject.GetAddress(out pAddress); + } + + public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint) + { + Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint; + this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint); + ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue2.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue2.cs new file mode 100644 index 0000000000..9fc6f974e0 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue2.cs @@ -0,0 +1,90 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugValue2 + { + + private Debugger.Interop.CorDebug.ICorDebugValue2 wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugValue2 WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugValue2(Debugger.Interop.CorDebug.ICorDebugValue2 wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugValue2 Wrap(Debugger.Interop.CorDebug.ICorDebugValue2 objectToWrap) + { + return new ICorDebugValue2(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugValue2 o1, ICorDebugValue2 o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugValue2 o1, ICorDebugValue2 o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugValue2 casted = o as ICorDebugValue2; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void GetExactType(out ICorDebugType ppType) + { + Debugger.Interop.CorDebug.ICorDebugType out_ppType; + this.WrappedObject.GetExactType(out out_ppType); + ppType = ICorDebugType.Wrap(out_ppType); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueBreakpoint.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueBreakpoint.cs new file mode 100644 index 0000000000..9a9deadde3 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueBreakpoint.cs @@ -0,0 +1,100 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugValueBreakpoint + { + + private Debugger.Interop.CorDebug.ICorDebugValueBreakpoint wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugValueBreakpoint WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugValueBreakpoint(Debugger.Interop.CorDebug.ICorDebugValueBreakpoint wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugValueBreakpoint Wrap(Debugger.Interop.CorDebug.ICorDebugValueBreakpoint objectToWrap) + { + return new ICorDebugValueBreakpoint(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugValueBreakpoint o1, ICorDebugValueBreakpoint o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugValueBreakpoint o1, ICorDebugValueBreakpoint o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugValueBreakpoint casted = o as ICorDebugValueBreakpoint; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Activate(int bActive) + { + this.WrappedObject.Activate(bActive); + } + + public void IsActive(out int pbActive) + { + this.WrappedObject.IsActive(out pbActive); + } + + public void GetValue(out ICorDebugValue ppValue) + { + Debugger.Interop.CorDebug.ICorDebugValue out_ppValue; + this.WrappedObject.GetValue(out out_ppValue); + ppValue = ICorDebugValue.Wrap(out_ppValue); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueEnum.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueEnum.cs new file mode 100644 index 0000000000..f9b47c7041 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueEnum.cs @@ -0,0 +1,110 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ICorDebugValueEnum + { + + private Debugger.Interop.CorDebug.ICorDebugValueEnum wrappedObject; + + internal Debugger.Interop.CorDebug.ICorDebugValueEnum WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ICorDebugValueEnum(Debugger.Interop.CorDebug.ICorDebugValueEnum wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ICorDebugValueEnum Wrap(Debugger.Interop.CorDebug.ICorDebugValueEnum objectToWrap) + { + return new ICorDebugValueEnum(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() where T: class + { + return (T)Activator.CreateInstance(typeof(T), this.WrappedObject); + } + + public static bool operator ==(ICorDebugValueEnum o1, ICorDebugValueEnum o2) + { + return ((object)o1 == null && (object)o2 == null) || + ((object)o1 != null && (object)o2 != null && o1.WrappedObject == o2.WrappedObject); + } + + public static bool operator !=(ICorDebugValueEnum o1, ICorDebugValueEnum o2) + { + return !(o1 == o2); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public override bool Equals(object o) + { + ICorDebugValueEnum casted = o as ICorDebugValueEnum; + return (casted != null) && (casted.WrappedObject == wrappedObject); + } + + + public void Skip(uint celt) + { + this.WrappedObject.Skip(celt); + } + + public void Reset() + { + this.WrappedObject.Reset(); + } + + public void Clone(out ICorDebugEnum ppEnum) + { + Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum; + this.WrappedObject.Clone(out out_ppEnum); + ppEnum = ICorDebugEnum.Wrap(out_ppEnum); + } + + public void GetCount(out uint pcelt) + { + this.WrappedObject.GetCount(out pcelt); + } + + public void Next(uint celt, System.IntPtr values, out uint pceltFetched) + { + this.WrappedObject.Next(celt, values, out pceltFetched); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ISequentialStream.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ISequentialStream.cs new file mode 100644 index 0000000000..d88c064b01 --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ISequentialStream.cs @@ -0,0 +1,93 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class ISequentialStream + { + + private Debugger.Interop.CorDebug.ISequentialStream wrappedObject; + + internal Debugger.Interop.CorDebug.ISequentialStream WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public ISequentialStream(Debugger.Interop.CorDebug.ISequentialStream wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static ISequentialStream Wrap(Debugger.Interop.CorDebug.ISequentialStream objectToWrap) + { + return new ISequentialStream(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() 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 void RemoteRead(out byte pv, uint cb, out uint pcbRead) + { + this.WrappedObject.RemoteRead(out pv, cb, out pcbRead); + } + + public void RemoteWrite(ref byte pv, uint cb, out uint pcbWritten) + { + this.WrappedObject.RemoteWrite(ref pv, cb, out pcbWritten); + } + } +} diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/IStream.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/IStream.cs new file mode 100644 index 0000000000..52356c301b --- /dev/null +++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/IStream.cs @@ -0,0 +1,140 @@ +// +// +// +// +// $Revision$ +// + +namespace Debugger.Wrappers.CorDebug +{ + using System; + + + public class IStream + { + + private Debugger.Interop.CorDebug.IStream wrappedObject; + + internal Debugger.Interop.CorDebug.IStream WrappedObject + { + get + { + return this.wrappedObject; + } + } + + public IStream(Debugger.Interop.CorDebug.IStream wrappedObject) + { + this.wrappedObject = wrappedObject; + } + + public static IStream Wrap(Debugger.Interop.CorDebug.IStream objectToWrap) + { + return new IStream(objectToWrap); + } + + public bool Is() where T: class + { + try { + CastTo(); + return true; + } catch { + return false; + } + } + + public T As() where T: class + { + try { + return CastTo(); + } catch { + return null; + } + } + + public T CastTo() 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 void RemoteRead(out byte pv, uint cb, out uint pcbRead) + { + this.WrappedObject.RemoteRead(out pv, cb, out pcbRead); + } + + public void RemoteWrite(ref byte pv, uint cb, out uint pcbWritten) + { + this.WrappedObject.RemoteWrite(ref pv, cb, out pcbWritten); + } + + public void RemoteSeek(Debugger.Interop.CorDebug._LARGE_INTEGER dlibMove, uint dwOrigin, out Debugger.Interop.CorDebug._ULARGE_INTEGER plibNewPosition) + { + this.WrappedObject.RemoteSeek(dlibMove, dwOrigin, out plibNewPosition); + } + + public void SetSize(Debugger.Interop.CorDebug._ULARGE_INTEGER libNewSize) + { + this.WrappedObject.SetSize(libNewSize); + } + + public void RemoteCopyTo(IStream pstm, Debugger.Interop.CorDebug._ULARGE_INTEGER cb, out Debugger.Interop.CorDebug._ULARGE_INTEGER pcbRead, out Debugger.Interop.CorDebug._ULARGE_INTEGER pcbWritten) + { + this.WrappedObject.RemoteCopyTo(pstm.WrappedObject, cb, out pcbRead, out pcbWritten); + } + + public void Commit(uint grfCommitFlags) + { + this.WrappedObject.Commit(grfCommitFlags); + } + + public void Revert() + { + this.WrappedObject.Revert(); + } + + public void LockRegion(Debugger.Interop.CorDebug._ULARGE_INTEGER libOffset, Debugger.Interop.CorDebug._ULARGE_INTEGER cb, uint dwLockType) + { + this.WrappedObject.LockRegion(libOffset, cb, dwLockType); + } + + public void UnlockRegion(Debugger.Interop.CorDebug._ULARGE_INTEGER libOffset, Debugger.Interop.CorDebug._ULARGE_INTEGER cb, uint dwLockType) + { + this.WrappedObject.UnlockRegion(libOffset, cb, dwLockType); + } + + public void Stat(out Debugger.Interop.CorDebug.tagSTATSTG pstatstg, uint grfStatFlag) + { + this.WrappedObject.Stat(out pstatstg, grfStatFlag); + } + + public void Clone(out IStream ppstm) + { + Debugger.Interop.CorDebug.IStream out_ppstm; + this.WrappedObject.Clone(out out_ppstm); + ppstm = IStream.Wrap(out_ppstm); + } + } +}