Browse Source

Last out parameter used as return value in CorDebugger wrapper; Methods starting with Get or Is converted to properties

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@933 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61
shortcuts
David Srbecký 20 years ago
parent
commit
6f424029ab
  1. 11
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Breakpoints/Breakpoint.cs
  2. 5
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/Internal/ManagedCallback.cs
  3. 18
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Modules/Module.cs
  4. 2
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Exception.cs
  5. 55
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs
  6. 34
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Process.cs
  7. 4
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/SourcecodeSegment.cs
  8. 54
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Thread.cs
  9. 10
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs
  10. 6
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Evals/Eval.cs
  11. 24
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValue.cs
  12. 13
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Value.cs
  13. 16
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugClass.cs
  14. 16
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebugClass.cs
  15. 16
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebug.cs
  16. 85
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain.cs
  17. 8
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain2.cs
  18. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomainEnum.cs
  19. 83
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugArrayValue.cs
  20. 30
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssembly.cs
  21. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssemblyEnum.cs
  22. 57
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBoxValue.cs
  23. 9
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpoint.cs
  24. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpointEnum.cs
  25. 134
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChain.cs
  26. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChainEnum.cs
  27. 26
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass.cs
  28. 4
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass2.cs
  29. 57
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCode.cs
  30. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCodeEnum.cs
  31. 83
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugContext.cs
  32. 25
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugController.cs
  33. 31
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEditAndContinueSnapshot.cs
  34. 13
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEnum.cs
  35. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugErrorInfoEnum.cs
  36. 39
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval.cs
  37. 4
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval2.cs
  38. 82
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrame.cs
  39. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrameEnum.cs
  40. 83
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction.cs
  41. 22
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction2.cs
  42. 31
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunctionBreakpoint.cs
  43. 31
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugGenericValue.cs
  44. 70
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHandleValue.cs
  45. 44
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue.cs
  46. 4
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue2.cs
  47. 115
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame.cs
  48. 4
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame2.cs
  49. 95
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugInternalFrame.cs
  50. 9
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugMDA.cs
  51. 108
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule.cs
  52. 9
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule2.cs
  53. 22
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleBreakpoint.cs
  54. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleEnum.cs
  55. 124
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugNativeFrame.cs
  56. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectEnum.cs
  57. 83
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue.cs
  58. 4
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue2.cs
  59. 97
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess.cs
  60. 30
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess2.cs
  61. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcessEnum.cs
  62. 57
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugReferenceValue.cs
  63. 9
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugRegisterSet.cs
  64. 9
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper.cs
  65. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepperEnum.cs
  66. 53
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStringValue.cs
  67. 147
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread.cs
  68. 27
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread2.cs
  69. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThreadEnum.cs
  70. 65
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugType.cs
  71. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugTypeEnum.cs
  72. 31
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue.cs
  73. 13
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue2.cs
  74. 22
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueBreakpoint.cs
  75. 17
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueEnum.cs
  76. 8
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ISequentialStream.cs
  77. 20
      src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/IStream.cs
  78. 81
      src/Tools/WrapperGenerator/CodeGenerator.cs

11
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Breakpoints/Breakpoint.cs

@ -46,12 +46,10 @@ namespace Debugger @@ -46,12 +46,10 @@ namespace Debugger
}
}
public bool Enabled {
public bool Enabled {
get {
if (HadBeenSet) {
int active;
corBreakpoint.IsActive(out active);
enabled = (active == 1);
enabled = (corBreakpoint.IsActive == 1);
}
return enabled;
}
@ -127,10 +125,7 @@ namespace Debugger @@ -127,10 +125,7 @@ namespace Debugger
return false;
}
ICorDebugCode code;
corFunction.GetILCode(out code);
code.CreateBreakpoint((uint)ilOffset, out corBreakpoint);
corBreakpoint = corFunction.ILCode.CreateBreakpoint((uint)ilOffset);
hadBeenSet = true;
corBreakpoint.Activate(enabled?1:0);

5
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/Internal/ManagedCallback.cs

@ -59,10 +59,7 @@ namespace Debugger @@ -59,10 +59,7 @@ namespace Debugger
{
EnterCallback(name);
ICorDebugProcess pProcess;
pAppDomain.GetProcess(out pProcess);
callingProcess = debugger.GetProcess(pProcess);
callingProcess = debugger.GetProcess(pAppDomain.Process);
callingProcess.IsRunning = false;
}

18
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Modules/Module.cs

@ -22,9 +22,6 @@ namespace Debugger @@ -22,9 +22,6 @@ namespace Debugger
bool unloaded = false;
string fullPath;
string fullPathPDB;
ulong baseAdress;
int isDynamic;
int isInMemory;
int orderOfLoading = 0;
readonly ICorDebugModule corModule;
@ -63,19 +60,19 @@ namespace Debugger @@ -63,19 +60,19 @@ namespace Debugger
public ulong BaseAdress {
get {
return baseAdress;
return corModule.BaseAddress;
}
}
public bool IsDynamic {
get {
return isDynamic == 1;
return corModule.IsDynamic == 1;
}
}
public bool IsInMemory {
get {
return isInMemory == 1;
return corModule.IsInMemory == 1;
}
}
@ -129,15 +126,8 @@ namespace Debugger @@ -129,15 +126,8 @@ namespace Debugger
corModule = pModule;
pModule.GetBaseAddress(out baseAdress);
pModule.IsDynamic(out isDynamic);
pModule.IsInMemory(out isInMemory);
Guid metaDataInterfaceGuid = new Guid("{ 0x7dac8207, 0xd3ae, 0x4c75, { 0x9b, 0x67, 0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44 } }");
object pMetaDataInterface;
pModule.GetMetaDataInterface(ref metaDataInterfaceGuid, out pMetaDataInterface);
object pMetaDataInterface = pModule.GetMetaDataInterface(ref metaDataInterfaceGuid);
metaDataInterface = (IMetaDataImport) pMetaDataInterface;

2
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Exception.cs

@ -40,7 +40,7 @@ namespace Debugger @@ -40,7 +40,7 @@ namespace Debugger
creationTime = DateTime.Now;
this.debugger = thread.Debugger;
this.thread = thread;
thread.CorThread.GetCurrentException(out corValue);
corValue = thread.CorThread.CurrentException;
exceptionType = thread.CurrentExceptionType;
runtimeValue = Value.CreateValue(debugger, corValue);
runtimeValueException = runtimeValue as ObjectValue;

55
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs

@ -65,9 +65,7 @@ namespace Debugger @@ -65,9 +65,7 @@ namespace Debugger
internal ICorDebugClass ContaingClass {
get {
ICorDebugClass corClass;
corFunction.GetClass(out corClass);
return corClass;
return corFunction.Class;
}
}
@ -88,9 +86,7 @@ namespace Debugger @@ -88,9 +86,7 @@ namespace Debugger
if (this.HasExpired) {
return new UnavailableValue(debugger, "Function has expired");
} else {
ICorDebugValue argThis = null;
CorILFrame.GetArgument(0, out argThis);
return new ObjectValue(debugger, argThis, ContaingClass);
return new ObjectValue(debugger, CorILFrame.GetArgument(0), ContaingClass);
}
}
}
@ -104,14 +100,10 @@ namespace Debugger @@ -104,14 +100,10 @@ namespace Debugger
this.frameIndex = frameIndex;
this.corILFrame = corILFrame;
this.corILFrameDebuggerSessionID = debugger.SessionID;
corILFrame.GetFunction(out corFunction);
uint functionToken;
corFunction.GetToken(out functionToken);
ICorDebugModule corModule;
corFunction.GetModule(out corModule);
module = debugger.GetModule(corModule);
corFunction = corILFrame.Function;
module = debugger.GetModule(corFunction.Module);
methodProps = module.MetaData.GetMethodProps(functionToken);
methodProps = module.MetaData.GetMethodProps(corFunction.Token);
// Expiry the function when it is finished
Stepper tracingStepper = thread.CreateStepper();
@ -136,8 +128,7 @@ namespace Debugger @@ -136,8 +128,7 @@ namespace Debugger
internal uint corInstructionPtr {
get {
uint corInstructionPtr;
CorDebugMappingResult MappingResult;
CorILFrame.GetIP(out corInstructionPtr,out MappingResult);
CorILFrame.GetIP(out corInstructionPtr);
return corInstructionPtr;
}
}
@ -176,8 +167,7 @@ namespace Debugger @@ -176,8 +167,7 @@ namespace Debugger
public void StepOut()
{
ICorDebugStepper stepper;
CorILFrame.CreateStepper(out stepper);
ICorDebugStepper stepper = CorILFrame.CreateStepper();
stepper.StepOut();
debugger.CurrentThread.AddActiveStepper(stepper);
@ -201,7 +191,7 @@ namespace Debugger @@ -201,7 +191,7 @@ namespace Debugger
ICorDebugStepper stepper;
if (stepIn) {
CorILFrame.CreateStepper(out stepper);
stepper = CorILFrame.CreateStepper();
if (stepper.Is<ICorDebugStepper2>()) { // Is the debuggee .NET 2.0?
stepper.SetUnmappedStopMask(CorDebugUnmappedStop.STOP_NONE);
@ -218,7 +208,7 @@ namespace Debugger @@ -218,7 +208,7 @@ namespace Debugger
// Mind that step in which ends in code without symblols is cotinued
// so the next step over ensures that we atleast do step over
CorILFrame.CreateStepper(out stepper);
stepper = CorILFrame.CreateStepper();
if (stepper.Is<ICorDebugStepper2>()) { // Is the debuggee .NET 2.0?
stepper.SetUnmappedStopMask(CorDebugUnmappedStop.STOP_NONE);
@ -286,14 +276,11 @@ namespace Debugger @@ -286,14 +276,11 @@ namespace Debugger
for (int i = sequencePointCount - 1; i >= 0; i--) // backwards
if (offsets[i] <= offset || i == 0) {
// Set inforamtion about current IL range
ICorDebugCode code;
corFunction.GetILCode(out code);
uint codeSize;
code.GetSize(out codeSize);
int codeSize = (int)corFunction.ILCode.Size;
retVal.ILOffset = (int)offset;
retVal.ILStart = offsets[i];
retVal.ILEnd = (i + 1 < sequencePointCount) ? offsets[i + 1] : (int)codeSize;
retVal.ILEnd = (i + 1 < sequencePointCount) ? offsets[i + 1] : codeSize;
// 0xFeeFee means "code generated by compiler"
// If we are in generated sequence use to closest real one instead,
@ -302,7 +289,7 @@ namespace Debugger @@ -302,7 +289,7 @@ namespace Debugger
// Look ahead for 'real' sequence
while (i + 1 < sequencePointCount && startLine[i] == 0xFeeFee) {
i++;
retVal.ILEnd = (i + 1 < sequencePointCount) ? offsets[i + 1] : (int)codeSize;
retVal.ILEnd = (i + 1 < sequencePointCount) ? offsets[i + 1] : codeSize;
}
// Look back for 'real' sequence
while (i - 1 >= 0 && startLine[i] == 0xFeeFee) {
@ -339,7 +326,7 @@ namespace Debugger @@ -339,7 +326,7 @@ namespace Debugger
if (j + 1 < sequencePointCount) {
stepRanges.Add(offsets[j + 1]);
} else {
stepRanges.Add((int)codeSize);
stepRanges.Add(codeSize);
}
}
}
@ -371,9 +358,7 @@ namespace Debugger @@ -371,9 +358,7 @@ namespace Debugger
if (!suggestion.GetFunctionAndOffset(debugger, false, out corFunction, out ilOffset)) {
return null;
} else {
uint token;
corFunction.GetToken(out token);
if (token != methodProps.Token) {
if (corFunction.Token != methodProps.Token) {
return null;
} else {
try {
@ -428,10 +413,8 @@ namespace Debugger @@ -428,10 +413,8 @@ namespace Debugger
public int ArgumentCount {
get {
ICorDebugValueEnum argumentEnum;
CorILFrame.EnumerateArguments(out argumentEnum);
uint argCount;
argumentEnum.GetCount(out argCount);
ICorDebugValueEnum argumentEnum = CorILFrame.EnumerateArguments();
uint argCount = argumentEnum.Count;
if (!IsStatic) {
argCount--; // Remove 'this' from count
}
@ -441,10 +424,8 @@ namespace Debugger @@ -441,10 +424,8 @@ namespace Debugger
internal ICorDebugValue GetArgumentValue(int index)
{
ICorDebugValue arg;
// Non-static functions include 'this' as first argument
CorILFrame.GetArgument((uint)(IsStatic? index : (index + 1)), out arg);
return arg;
return CorILFrame.GetArgument((uint)(IsStatic? index : (index + 1)));
}
public Variable GetArgumentVariable(int index)
@ -508,7 +489,7 @@ namespace Debugger @@ -508,7 +489,7 @@ namespace Debugger
} else {
ICorDebugValue corValue;
try {
CorILFrame.GetLocalVariable((uint)symVar.AddressField1, out corValue);
corValue = CorILFrame.GetLocalVariable((uint)symVar.AddressField1);
} catch (COMException e) {
if ((uint)e.ErrorCode == 0x80131304) return new UnavailableValue(debugger, "Unavailable in optimized code");
throw;

34
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Process.cs

@ -104,21 +104,21 @@ namespace Debugger @@ -104,21 +104,21 @@ namespace Debugger
fixed (uint* pprocessStartupInfo = processStartupInfo)
fixed (uint* pprocessInfo = processInfo)
debugger.CorDebug.CreateProcess(
filename, // lpApplicationName
// If we do not prepend " ", the first argument migh just get lost
" " + arguments, // lpCommandLine
ref secAttr, // lpProcessAttributes
ref secAttr, // lpThreadAttributes
1,//TRUE // bInheritHandles
0, // dwCreationFlags
IntPtr.Zero, // lpEnvironment
workingDirectory, // lpCurrentDirectory
(uint)pprocessStartupInfo, // lpStartupInfo
(uint)pprocessInfo, // lpProcessInformation,
CorDebugCreateProcessFlags.DEBUG_NO_SPECIAL_OPTIONS, // debuggingFlags
out outProcess // ppProcess
);
outProcess =
debugger.CorDebug.CreateProcess(
filename, // lpApplicationName
// If we do not prepend " ", the first argument migh just get lost
" " + arguments, // lpCommandLine
ref secAttr, // lpProcessAttributes
ref secAttr, // lpThreadAttributes
1,//TRUE // bInheritHandles
0, // dwCreationFlags
IntPtr.Zero, // lpEnvironment
workingDirectory, // lpCurrentDirectory
(uint)pprocessStartupInfo, // lpStartupInfo
(uint)pprocessInfo, // lpProcessInformation,
CorDebugCreateProcessFlags.DEBUG_NO_SPECIAL_OPTIONS // debuggingFlags
);
return new Process(debugger, outProcess);
}
@ -160,10 +160,8 @@ namespace Debugger @@ -160,10 +160,8 @@ namespace Debugger
public void Terminate()
{
int running;
corProcess.IsRunning(out running);
// Resume stoped tread
if (running == 0) {
if (corProcess.IsRunning == 0) {
Continue(); // TODO: Remove this...
}
// Stop&terminate - both must be called

4
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/SourcecodeSegment.cs

@ -212,9 +212,7 @@ namespace Debugger @@ -212,9 +212,7 @@ namespace Debugger
ISymbolMethod symMethod;
symMethod = symReader.GetMethodFromDocumentPosition(symDoc, StartLine, StartColumn);
ICorDebugFunction corFunction;
module.CorModule.GetFunctionFromToken((uint)symMethod.Token.GetToken(), out corFunction);
function = corFunction;
function = module.CorModule.GetFunctionFromToken((uint)symMethod.Token.GetToken());
ilOffset = symMethod.GetOffset(symDoc, StartLine, StartColumn);

54
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Thread.cs

@ -82,24 +82,20 @@ namespace Debugger @@ -82,24 +82,20 @@ namespace Debugger
{
this.debugger = debugger;
this.corThread = corThread;
corThread.GetID(out id);
id = corThread.ID;
ICorDebugProcess corProcess;
corThread.GetProcess(out corProcess);
this.process = debugger.GetProcess(corProcess);
this.process = debugger.GetProcess(corThread.Process);
}
public bool Suspended {
get {
get {
if (process.IsRunning) return lastSuspendedState;
CorDebugThreadState state;
corThread.GetDebugState(out state);
lastSuspendedState = (state == CorDebugThreadState.THREAD_SUSPEND);
lastSuspendedState = (corThread.DebugState == CorDebugThreadState.THREAD_SUSPEND);
return lastSuspendedState;
}
set {
corThread.SetDebugState((value==true)?CorDebugThreadState.THREAD_SUSPEND:CorDebugThreadState.THREAD_RUN);
set {
corThread.SetDebugState((value==true)?CorDebugThreadState.THREAD_SUSPEND:CorDebugThreadState.THREAD_RUN);
}
}
@ -120,9 +116,7 @@ namespace Debugger @@ -120,9 +116,7 @@ namespace Debugger
if (!HasBeenLoaded) throw new DebuggerException("Thread has not started jet");
process.AssertPaused();
ICorDebugValue corValue;
corThread.GetObject(out corValue);
return Value.CreateValue(debugger, corValue);
return Value.CreateValue(debugger, corThread.Object);
}
}
@ -149,10 +143,7 @@ namespace Debugger @@ -149,10 +143,7 @@ namespace Debugger
internal Stepper CreateStepper()
{
ICorDebugStepper corStepper;
corThread.CreateStepper(out corStepper);
Stepper stepper = new Stepper(debugger, corStepper);
Stepper stepper = new Stepper(debugger, corThread.CreateStepper());
stepper.StepComplete += delegate {
steppers.Remove(stepper);
};
@ -192,9 +183,7 @@ namespace Debugger @@ -192,9 +183,7 @@ namespace Debugger
internal void DeactivateAllSteppers()
{
foreach(ICorDebugStepper stepper in activeSteppers) {
int active;
stepper.IsActive(out active);
if (active != 0) {
if (stepper.IsActive != 0) {
stepper.Deactivate();
debugger.TraceMessage("Stepper deactivated");
}
@ -241,11 +230,9 @@ namespace Debugger @@ -241,11 +230,9 @@ namespace Debugger
{
process.AssertPaused();
ICorDebugChainEnum corChainEnum;
corThread.EnumerateChains(out corChainEnum);
ICorDebugChainEnum corChainEnum = corThread.EnumerateChains();
uint chainCount;
corChainEnum.GetCount(out chainCount);
uint chainCount = corChainEnum.Count;
uint chainIndex = chainCount;
@ -258,25 +245,19 @@ namespace Debugger @@ -258,25 +245,19 @@ namespace Debugger
}
while (true) {
uint chainsFetched;
ICorDebugChain[] corChains = new ICorDebugChain[1]; // One at time
corChainEnum.Next(1, corChains, out chainsFetched);
uint chainsFetched = corChainEnum.Next(1, corChains);
if (chainsFetched == 0) break; // We are done
chainIndex--;
CorDebugChainReason reason;
corChains[0].GetReason(out reason);
CorDebugChainReason reason = corChains[0].Reason;
int isManaged;
corChains[0].IsManaged(out isManaged);
if (isManaged == 0) continue; // Only managed ones
if (corChains[0].IsManaged == 0) continue; // Only managed ones
ICorDebugFrameEnum corFrameEnum;
corChains[0].EnumerateFrames(out corFrameEnum);
ICorDebugFrameEnum corFrameEnum = corChains[0].EnumerateFrames();
uint frameCount;
corFrameEnum.GetCount(out frameCount);
uint frameCount = corFrameEnum.Count;
uint frameIndex = frameCount;
@ -288,9 +269,8 @@ namespace Debugger @@ -288,9 +269,8 @@ namespace Debugger
}
while (true) {
uint framesFetched;
ICorDebugFrame[] corFrames = new ICorDebugFrame[1]; // Only one at time
corFrameEnum.Next(1, corFrames, out framesFetched);
uint framesFetched = corFrameEnum.Next(1, corFrames);
if (framesFetched == 0) break; // We are done
frameIndex--;

10
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs

@ -58,12 +58,10 @@ namespace Debugger @@ -58,12 +58,10 @@ namespace Debugger
internal unsafe ArrayValue(NDebugger debugger, ICorDebugValue corValue):base(debugger, corValue)
{
corArrayValue = this.corValue.CastTo<ICorDebugArrayValue>();
uint corElementTypeRaw;
corArrayValue.GetElementType(out corElementTypeRaw);
corElementType = (CorElementType)corElementTypeRaw;
corElementType = (CorElementType)corArrayValue.ElementType;
corArrayValue.GetRank(out rank);
corArrayValue.GetCount(out lenght);
rank = corArrayValue.Rank;
lenght = corArrayValue.Count;
dimensions = new uint[rank];
fixed (void* pDimensions = dimensions)
@ -112,7 +110,7 @@ namespace Debugger @@ -112,7 +110,7 @@ namespace Debugger
ICorDebugValue element;
unsafe {
fixed (void* pIndices = indices) {
updatedVal.corArrayValue.GetElement(rank, new IntPtr(pIndices), out element);
element = updatedVal.corArrayValue.GetElement(rank, new IntPtr(pIndices));
}
}
return Value.CreateValue(debugger, element);

6
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Evals/Eval.cs

@ -122,7 +122,7 @@ namespace Debugger @@ -122,7 +122,7 @@ namespace Debugger
ICorDebugValue[] args = getArgs();
// TODO: What if this thread is not suitable?
targetThread.CorThread.CreateEval(out corEval);
corEval = targetThread.CorThread.CreateEval();
try {
corEval.CallFunction(corFunction, (uint)args.Length, args);
@ -152,9 +152,7 @@ namespace Debugger @@ -152,9 +152,7 @@ namespace Debugger
protected internal virtual void OnEvalComplete(bool successful)
{
ICorDebugValue corValue;
corEval.GetResult(out corValue);
result = Value.CreateValue(debugger, corValue);
result = Value.CreateValue(debugger, corEval.Result);
if (result == null) {
evalState = EvalState.EvaluatedNoResult;

24
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValue.cs

@ -73,9 +73,7 @@ namespace Debugger @@ -73,9 +73,7 @@ namespace Debugger
if (heapValue == null) { // TODO: Investigate
return null;
}
ICorDebugHandleValue corHandle;
heapValue.CreateHandle(CorDebugHandleType.HANDLE_WEAK_TRACK_RESURRECTION, out corHandle);
return corHandle;
return heapValue.CreateHandle(CorDebugHandleType.HANDLE_WEAK_TRACK_RESURRECTION);
}
}
@ -99,7 +97,7 @@ namespace Debugger @@ -99,7 +97,7 @@ namespace Debugger
internal unsafe ObjectValue(NDebugger debugger, ICorDebugValue corValue):base(debugger, corValue)
{
this.corValue.CastTo<ICorDebugObjectValue>().GetClass(out corClass);
corClass = this.corValue.CastTo<ICorDebugObjectValue>().Class;
InitObjectVariable();
}
@ -111,13 +109,9 @@ namespace Debugger @@ -111,13 +109,9 @@ namespace Debugger
void InitObjectVariable ()
{
uint classToken;
corClass.GetToken(out classToken);
corClass.GetModule(out corModule);
corModule = corClass.Module;
metaData = Module.MetaData;
classProps = metaData.GetTypeDefProps(classToken);
classProps = metaData.GetTypeDefProps(corClass.Token);
corModuleSuperclass = corModule;
}
@ -188,8 +182,7 @@ namespace Debugger @@ -188,8 +182,7 @@ namespace Debugger
Eval CreatePropertyEval(MethodProps method, ValueGetter getter)
{
ICorDebugFunction evalCorFunction;
Module.CorModule.GetFunctionFromToken(method.Token, out evalCorFunction);
ICorDebugFunction evalCorFunction = Module.CorModule.GetFunctionFromToken(method.Token);
return new Eval(debugger, evalCorFunction, delegate {
if (method.IsStatic) {
@ -218,9 +211,9 @@ namespace Debugger @@ -218,9 +211,9 @@ namespace Debugger
try {
ICorDebugValue fieldValue;
if (field.IsStatic) {
corClass.GetStaticFieldValue(field.Token, curFrame, out fieldValue);
fieldValue = corClass.GetStaticFieldValue(field.Token, curFrame);
} else {
(val.CorValue.CastTo<ICorDebugObjectValue>()).GetFieldValue(corClass, field.Token, out fieldValue);
fieldValue = (val.CorValue.CastTo<ICorDebugObjectValue>()).GetFieldValue(corClass, field.Token);
}
return Value.CreateValue(debugger, fieldValue);
} catch {
@ -297,8 +290,7 @@ namespace Debugger @@ -297,8 +290,7 @@ namespace Debugger
if ((classProps.SuperClassToken & 0x00FFFFFF) == 0) {
throw new DebuggerException("Unable to get base class: " + fullTypeName);
} else {
ICorDebugClass superClass;
corModuleSuperclass.GetClassFromToken(classProps.SuperClassToken, out superClass);
ICorDebugClass superClass = corModuleSuperclass.GetClassFromToken(classProps.SuperClassToken);
return new ObjectValue(debugger, corValue, superClass);
}
}

13
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Value.cs

@ -119,9 +119,7 @@ namespace Debugger @@ -119,9 +119,7 @@ namespace Debugger
if (corValue == null) {
return (CorElementType)0;
}
uint typeRaw;
corValue.GetType(out typeRaw);
return (CorElementType)typeRaw;
return (CorElementType)corValue.Type;
}
internal static System.Type CorTypeToManagedType(CorElementType corType)
@ -161,12 +159,11 @@ namespace Debugger @@ -161,12 +159,11 @@ namespace Debugger
internal static ICorDebugValue DereferenceUnbox(ICorDebugValue corValue)
{
if (corValue.Is<ICorDebugReferenceValue>()) {
int isNull;
(corValue.CastTo<ICorDebugReferenceValue>()).IsNull(out isNull);
int isNull = corValue.CastTo<ICorDebugReferenceValue>().IsNull;
if (isNull == 0) {
ICorDebugValue dereferencedValue;
try {
(corValue.CastTo<ICorDebugReferenceValue>()).Dereference(out dereferencedValue);
dereferencedValue = (corValue.CastTo<ICorDebugReferenceValue>()).Dereference();
} catch {
// Error during dereferencing
return null;
@ -178,9 +175,7 @@ namespace Debugger @@ -178,9 +175,7 @@ namespace Debugger
}
if (corValue.Is<ICorDebugBoxValue>()) {
ICorDebugObjectValue corUnboxedValue;
(corValue.CastTo<ICorDebugBoxValue>()).GetObject(out corUnboxedValue);
return DereferenceUnbox(corUnboxedValue.CastTo<ICorDebugValue>()); // Try again
return DereferenceUnbox(corValue.CastTo<ICorDebugBoxValue>().Object.CastTo<ICorDebugValue>()); // Try again
}
return corValue;

16
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugClass.cs

@ -85,32 +85,40 @@ namespace Debugger.Wrappers.CorDebug @@ -85,32 +85,40 @@ namespace Debugger.Wrappers.CorDebug
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)
public ICorDebugProcess 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)
{
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);
return ppProcess;
}
public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess)
public ICorDebugProcess DebugActiveProcess(uint id, int win32Attach)
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess)
public ICorDebugProcessEnum EnumerateProcesses()
{
ICorDebugProcessEnum ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess;
this.WrappedObject.EnumerateProcesses(out out_ppProcess);
ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess);
return ppProcess;
}
public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess)
public ICorDebugProcess GetProcess(uint dwProcessId)
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
public void Initialize()

16
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebugClass.cs

@ -85,32 +85,40 @@ namespace Debugger.Wrappers.CorDebug @@ -85,32 +85,40 @@ namespace Debugger.Wrappers.CorDebug
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)
public ICorDebugProcess 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)
{
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);
return ppProcess;
}
public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess)
public ICorDebugProcess DebugActiveProcess(uint id, int win32Attach)
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess)
public ICorDebugProcessEnum EnumerateProcesses()
{
ICorDebugProcessEnum ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess;
this.WrappedObject.EnumerateProcesses(out out_ppProcess);
ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess);
return ppProcess;
}
public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess)
public ICorDebugProcess GetProcess(uint dwProcessId)
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
public void Initialize()

16
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebug.cs

@ -100,32 +100,40 @@ namespace Debugger.Wrappers.CorDebug @@ -100,32 +100,40 @@ namespace Debugger.Wrappers.CorDebug
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)
public ICorDebugProcess 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)
{
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);
return ppProcess;
}
public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess)
public ICorDebugProcess DebugActiveProcess(uint id, int win32Attach)
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess)
public ICorDebugProcessEnum EnumerateProcesses()
{
ICorDebugProcessEnum ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess;
this.WrappedObject.EnumerateProcesses(out out_ppProcess);
ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess);
return ppProcess;
}
public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess)
public ICorDebugProcess GetProcess(uint dwProcessId)
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
public void CanLaunchOrAttach(uint dwProcessId, int win32DebuggingEnabled)

85
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Continue(fIsOutOfBand);
}
public void IsRunning(out int pbRunning)
public int IsRunning
{
this.WrappedObject.IsRunning(out pbRunning);
get
{
int pbRunning;
this.WrappedObject.IsRunning(out pbRunning);
return pbRunning;
}
}
public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued)
public int HasQueuedCallbacks(ICorDebugThread pThread)
{
int pbQueued;
this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued);
return pbQueued;
}
public void EnumerateThreads(out ICorDebugThreadEnum ppThreads)
public ICorDebugThreadEnum EnumerateThreads()
{
ICorDebugThreadEnum ppThreads;
Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads;
this.WrappedObject.EnumerateThreads(out out_ppThreads);
ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads);
return ppThreads;
}
public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread)
@ -122,62 +131,84 @@ namespace Debugger.Wrappers.CorDebug @@ -122,62 +131,84 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Terminate(exitCode);
}
public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
public ICorDebugErrorInfoEnum CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
{
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);
return pError;
}
public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
public ICorDebugErrorInfoEnum CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
{
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);
return pError;
}
public void GetProcess(out ICorDebugProcess ppProcess)
public ICorDebugProcess Process
{
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
get
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
}
public void EnumerateAssemblies(out ICorDebugAssemblyEnum ppAssemblies)
public ICorDebugAssemblyEnum EnumerateAssemblies()
{
ICorDebugAssemblyEnum ppAssemblies;
Debugger.Interop.CorDebug.ICorDebugAssemblyEnum out_ppAssemblies;
this.WrappedObject.EnumerateAssemblies(out out_ppAssemblies);
ppAssemblies = ICorDebugAssemblyEnum.Wrap(out_ppAssemblies);
return ppAssemblies;
}
public void GetModuleFromMetaDataInterface(object pIMetaData, out ICorDebugModule ppModule)
public ICorDebugModule GetModuleFromMetaDataInterface(object pIMetaData)
{
ICorDebugModule ppModule;
Debugger.Interop.CorDebug.ICorDebugModule out_ppModule;
this.WrappedObject.GetModuleFromMetaDataInterface(pIMetaData, out out_ppModule);
ppModule = ICorDebugModule.Wrap(out_ppModule);
return ppModule;
}
public void EnumerateBreakpoints(out ICorDebugBreakpointEnum ppBreakpoints)
public ICorDebugBreakpointEnum EnumerateBreakpoints()
{
ICorDebugBreakpointEnum ppBreakpoints;
Debugger.Interop.CorDebug.ICorDebugBreakpointEnum out_ppBreakpoints;
this.WrappedObject.EnumerateBreakpoints(out out_ppBreakpoints);
ppBreakpoints = ICorDebugBreakpointEnum.Wrap(out_ppBreakpoints);
return ppBreakpoints;
}
public void EnumerateSteppers(out ICorDebugStepperEnum ppSteppers)
public ICorDebugStepperEnum EnumerateSteppers()
{
ICorDebugStepperEnum ppSteppers;
Debugger.Interop.CorDebug.ICorDebugStepperEnum out_ppSteppers;
this.WrappedObject.EnumerateSteppers(out out_ppSteppers);
ppSteppers = ICorDebugStepperEnum.Wrap(out_ppSteppers);
return ppSteppers;
}
public void IsAttached(out int pbAttached)
public int IsAttached
{
this.WrappedObject.IsAttached(out pbAttached);
get
{
int pbAttached;
this.WrappedObject.IsAttached(out pbAttached);
return pbAttached;
}
}
public void GetName(uint cchName, out uint pcchName, System.IntPtr szName)
@ -185,11 +216,16 @@ namespace Debugger.Wrappers.CorDebug @@ -185,11 +216,16 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.GetName(cchName, out pcchName, szName);
}
public void GetObject(out ICorDebugValue ppObject)
public ICorDebugValue Object
{
Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
this.WrappedObject.GetObject(out out_ppObject);
ppObject = ICorDebugValue.Wrap(out_ppObject);
get
{
ICorDebugValue ppObject;
Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
this.WrappedObject.GetObject(out out_ppObject);
ppObject = ICorDebugValue.Wrap(out_ppObject);
return ppObject;
}
}
public void Attach()
@ -197,9 +233,14 @@ namespace Debugger.Wrappers.CorDebug @@ -197,9 +233,14 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Attach();
}
public void GetID(out uint pId)
public uint ID
{
this.WrappedObject.GetID(out pId);
get
{
uint pId;
this.WrappedObject.GetID(out pId);
return pId;
}
}
}
}

8
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain2.cs

@ -80,20 +80,24 @@ namespace Debugger.Wrappers.CorDebug @@ -80,20 +80,24 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetArrayOrPointerType(uint elementType, uint nRank, ICorDebugType pTypeArg, out ICorDebugType ppType)
public ICorDebugType GetArrayOrPointerType(uint elementType, uint nRank, ICorDebugType pTypeArg)
{
ICorDebugType ppType;
Debugger.Interop.CorDebug.ICorDebugType out_ppType;
this.WrappedObject.GetArrayOrPointerType(elementType, nRank, pTypeArg.WrappedObject, out out_ppType);
ppType = ICorDebugType.Wrap(out_ppType);
return ppType;
}
public void GetFunctionPointerType(uint nTypeArgs, ref ICorDebugType ppTypeArgs, out ICorDebugType ppType)
public ICorDebugType GetFunctionPointerType(uint nTypeArgs, ref ICorDebugType ppTypeArgs)
{
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);
return ppType;
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomainEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr values)
{
uint pceltFetched;
this.WrappedObject.Next(celt, values, out pceltFetched);
return pceltFetched;
}
}
}

83
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugArrayValue.cs

@ -80,53 +80,92 @@ namespace Debugger.Wrappers.CorDebug @@ -80,53 +80,92 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void IsValid(out int pbValid)
public int IsValid
{
this.WrappedObject.IsValid(out pbValid);
get
{
int pbValid;
this.WrappedObject.IsValid(out pbValid);
return pbValid;
}
}
public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateRelocBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetElementType(out uint pType)
public uint ElementType
{
this.WrappedObject.GetElementType(out pType);
get
{
uint pType;
this.WrappedObject.GetElementType(out pType);
return pType;
}
}
public void GetRank(out uint pnRank)
public uint Rank
{
this.WrappedObject.GetRank(out pnRank);
get
{
uint pnRank;
this.WrappedObject.GetRank(out pnRank);
return pnRank;
}
}
public void GetCount(out uint pnCount)
public uint Count
{
this.WrappedObject.GetCount(out pnCount);
get
{
uint pnCount;
this.WrappedObject.GetCount(out pnCount);
return pnCount;
}
}
public void GetDimensions(uint cdim, System.IntPtr dims)
@ -134,9 +173,11 @@ namespace Debugger.Wrappers.CorDebug @@ -134,9 +173,11 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.GetDimensions(cdim, dims);
}
public void HasBaseIndicies(out int pbHasBaseIndicies)
public int HasBaseIndicies()
{
int pbHasBaseIndicies;
this.WrappedObject.HasBaseIndicies(out pbHasBaseIndicies);
return pbHasBaseIndicies;
}
public void GetBaseIndicies(uint cdim, System.IntPtr indicies)
@ -144,18 +185,22 @@ namespace Debugger.Wrappers.CorDebug @@ -144,18 +185,22 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.GetBaseIndicies(cdim, indicies);
}
public void GetElement(uint cdim, System.IntPtr indices, out ICorDebugValue ppValue)
public ICorDebugValue GetElement(uint cdim, System.IntPtr indices)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetElement(cdim, indices, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void GetElementAtPosition(uint nPosition, out ICorDebugValue ppValue)
public ICorDebugValue GetElementAtPosition(uint nPosition)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetElementAtPosition(nPosition, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
}
}

30
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssembly.cs

@ -80,25 +80,37 @@ namespace Debugger.Wrappers.CorDebug @@ -80,25 +80,37 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetProcess(out ICorDebugProcess ppProcess)
public ICorDebugProcess Process
{
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
get
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
}
public void GetAppDomain(out ICorDebugAppDomain ppAppDomain)
public ICorDebugAppDomain AppDomain
{
Debugger.Interop.CorDebug.ICorDebugAppDomain out_ppAppDomain;
this.WrappedObject.GetAppDomain(out out_ppAppDomain);
ppAppDomain = ICorDebugAppDomain.Wrap(out_ppAppDomain);
get
{
ICorDebugAppDomain ppAppDomain;
Debugger.Interop.CorDebug.ICorDebugAppDomain out_ppAppDomain;
this.WrappedObject.GetAppDomain(out out_ppAppDomain);
ppAppDomain = ICorDebugAppDomain.Wrap(out_ppAppDomain);
return ppAppDomain;
}
}
public void EnumerateModules(out ICorDebugModuleEnum ppModules)
public ICorDebugModuleEnum EnumerateModules()
{
ICorDebugModuleEnum ppModules;
Debugger.Interop.CorDebug.ICorDebugModuleEnum out_ppModules;
this.WrappedObject.EnumerateModules(out out_ppModules);
ppModules = ICorDebugModuleEnum.Wrap(out_ppModules);
return ppModules;
}
public void GetCodeBase(uint cchName, out uint pcchName, System.IntPtr szName)

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssemblyEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr values)
{
uint pceltFetched;
this.WrappedObject.Next(celt, values, out pceltFetched);
return pceltFetched;
}
}
}

57
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBoxValue.cs

@ -80,45 +80,74 @@ namespace Debugger.Wrappers.CorDebug @@ -80,45 +80,74 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void IsValid(out int pbValid)
public int IsValid
{
this.WrappedObject.IsValid(out pbValid);
get
{
int pbValid;
this.WrappedObject.IsValid(out pbValid);
return pbValid;
}
}
public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateRelocBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetObject(out ICorDebugObjectValue ppObject)
public ICorDebugObjectValue Object
{
Debugger.Interop.CorDebug.ICorDebugObjectValue out_ppObject;
this.WrappedObject.GetObject(out out_ppObject);
ppObject = ICorDebugObjectValue.Wrap(out_ppObject);
get
{
ICorDebugObjectValue ppObject;
Debugger.Interop.CorDebug.ICorDebugObjectValue out_ppObject;
this.WrappedObject.GetObject(out out_ppObject);
ppObject = ICorDebugObjectValue.Wrap(out_ppObject);
return ppObject;
}
}
}
}

9
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpoint.cs

@ -85,9 +85,14 @@ namespace Debugger.Wrappers.CorDebug @@ -85,9 +85,14 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Activate(bActive);
}
public void IsActive(out int pbActive)
public int IsActive
{
this.WrappedObject.IsActive(out pbActive);
get
{
int pbActive;
this.WrappedObject.IsActive(out pbActive);
return pbActive;
}
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpointEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr breakpoints, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr breakpoints)
{
uint pceltFetched;
this.WrappedObject.Next(celt, breakpoints, out pceltFetched);
return pceltFetched;
}
}
}

134
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChain.cs

@ -80,84 +80,138 @@ namespace Debugger.Wrappers.CorDebug @@ -80,84 +80,138 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetThread(out ICorDebugThread ppThread)
public ICorDebugThread Thread
{
Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
this.WrappedObject.GetThread(out out_ppThread);
ppThread = ICorDebugThread.Wrap(out_ppThread);
get
{
ICorDebugThread ppThread;
Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
this.WrappedObject.GetThread(out out_ppThread);
ppThread = ICorDebugThread.Wrap(out_ppThread);
return ppThread;
}
}
public void GetStackRange(out ulong pStart, out ulong pEnd)
public ulong GetStackRange(out ulong pStart)
{
ulong pEnd;
this.WrappedObject.GetStackRange(out pStart, out pEnd);
return pEnd;
}
public void GetContext(out ICorDebugContext ppContext)
public ICorDebugContext Context
{
Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
this.WrappedObject.GetContext(out out_ppContext);
ppContext = ICorDebugContext.Wrap(out_ppContext);
get
{
ICorDebugContext ppContext;
Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
this.WrappedObject.GetContext(out out_ppContext);
ppContext = ICorDebugContext.Wrap(out_ppContext);
return ppContext;
}
}
public void GetCaller(out ICorDebugChain ppChain)
public ICorDebugChain Caller
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetCaller(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetCaller(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void GetCallee(out ICorDebugChain ppChain)
public ICorDebugChain Callee
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetCallee(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetCallee(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void GetPrevious(out ICorDebugChain ppChain)
public ICorDebugChain Previous
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetPrevious(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetPrevious(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void GetNext(out ICorDebugChain ppChain)
public ICorDebugChain Next
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetNext(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetNext(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void IsManaged(out int pManaged)
public int IsManaged
{
this.WrappedObject.IsManaged(out pManaged);
get
{
int pManaged;
this.WrappedObject.IsManaged(out pManaged);
return pManaged;
}
}
public void EnumerateFrames(out ICorDebugFrameEnum ppFrames)
public ICorDebugFrameEnum EnumerateFrames()
{
ICorDebugFrameEnum ppFrames;
Debugger.Interop.CorDebug.ICorDebugFrameEnum out_ppFrames;
this.WrappedObject.EnumerateFrames(out out_ppFrames);
ppFrames = ICorDebugFrameEnum.Wrap(out_ppFrames);
return ppFrames;
}
public void GetActiveFrame(out ICorDebugFrame ppFrame)
public ICorDebugFrame ActiveFrame
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetActiveFrame(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetActiveFrame(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters)
public ICorDebugRegisterSet RegisterSet
{
Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
this.WrappedObject.GetRegisterSet(out out_ppRegisters);
ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
get
{
ICorDebugRegisterSet ppRegisters;
Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
this.WrappedObject.GetRegisterSet(out out_ppRegisters);
ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
return ppRegisters;
}
}
public void GetReason(out CorDebugChainReason pReason)
public CorDebugChainReason Reason
{
Debugger.Interop.CorDebug.CorDebugChainReason out_pReason;
this.WrappedObject.GetReason(out out_pReason);
pReason = ((CorDebugChainReason)(out_pReason));
get
{
CorDebugChainReason pReason;
Debugger.Interop.CorDebug.CorDebugChainReason out_pReason;
this.WrappedObject.GetReason(out out_pReason);
pReason = ((CorDebugChainReason)(out_pReason));
return pReason;
}
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChainEnum.cs

@ -90,20 +90,28 @@ namespace Debugger.Wrappers.CorDebug @@ -90,20 +90,28 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, ICorDebugChain[] chains, out uint pceltFetched)
public uint Next(uint celt, ICorDebugChain[] chains)
{
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))
{
@ -123,6 +131,7 @@ namespace Debugger.Wrappers.CorDebug @@ -123,6 +131,7 @@ namespace Debugger.Wrappers.CorDebug
chains[i] = null;
}
}
return pceltFetched;
}
}
}

26
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass.cs

@ -80,23 +80,35 @@ namespace Debugger.Wrappers.CorDebug @@ -80,23 +80,35 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetModule(out ICorDebugModule pModule)
public ICorDebugModule Module
{
Debugger.Interop.CorDebug.ICorDebugModule out_pModule;
this.WrappedObject.GetModule(out out_pModule);
pModule = ICorDebugModule.Wrap(out_pModule);
get
{
ICorDebugModule pModule;
Debugger.Interop.CorDebug.ICorDebugModule out_pModule;
this.WrappedObject.GetModule(out out_pModule);
pModule = ICorDebugModule.Wrap(out_pModule);
return pModule;
}
}
public void GetToken(out uint pTypeDef)
public uint Token
{
this.WrappedObject.GetToken(out pTypeDef);
get
{
uint pTypeDef;
this.WrappedObject.GetToken(out pTypeDef);
return pTypeDef;
}
}
public void GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
public ICorDebugValue GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetStaticFieldValue(fieldDef, pFrame.WrappedObject, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
}
}

4
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass2.cs

@ -80,13 +80,15 @@ namespace Debugger.Wrappers.CorDebug @@ -80,13 +80,15 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetParameterizedType(uint elementType, uint nTypeArgs, ref ICorDebugType ppTypeArgs, out ICorDebugType ppType)
public ICorDebugType GetParameterizedType(uint elementType, uint nTypeArgs, ref ICorDebugType ppTypeArgs)
{
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);
return ppType;
}
public void SetJMCStatus(int bIsJustMyCode)

57
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCode.cs

@ -80,43 +80,72 @@ namespace Debugger.Wrappers.CorDebug @@ -80,43 +80,72 @@ namespace Debugger.Wrappers.CorDebug
}
public void IsIL(out int pbIL)
public int IsIL
{
this.WrappedObject.IsIL(out pbIL);
get
{
int pbIL;
this.WrappedObject.IsIL(out pbIL);
return pbIL;
}
}
public void GetFunction(out ICorDebugFunction ppFunction)
public ICorDebugFunction Function
{
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
get
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
}
public void GetAddress(out ulong pStart)
public ulong Address
{
this.WrappedObject.GetAddress(out pStart);
get
{
ulong pStart;
this.WrappedObject.GetAddress(out pStart);
return pStart;
}
}
public void GetSize(out uint pcBytes)
public uint Size
{
this.WrappedObject.GetSize(out pcBytes);
get
{
uint pcBytes;
this.WrappedObject.GetSize(out pcBytes);
return pcBytes;
}
}
public void CreateBreakpoint(uint offset, out ICorDebugFunctionBreakpoint ppBreakpoint)
public ICorDebugFunctionBreakpoint CreateBreakpoint(uint offset)
{
ICorDebugFunctionBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(offset, out out_ppBreakpoint);
ppBreakpoint = ICorDebugFunctionBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetCode(uint startOffset, uint endOffset, uint cBufferAlloc, System.IntPtr buffer, out uint pcBufferSize)
public uint GetCode(uint startOffset, uint endOffset, uint cBufferAlloc, System.IntPtr buffer)
{
uint pcBufferSize;
this.WrappedObject.GetCode(startOffset, endOffset, cBufferAlloc, buffer, out pcBufferSize);
return pcBufferSize;
}
public void GetVersionNumber(out uint nVersion)
public uint VersionNumber
{
this.WrappedObject.GetVersionNumber(out nVersion);
get
{
uint nVersion;
this.WrappedObject.GetVersionNumber(out nVersion);
return nVersion;
}
}
public void GetILToNativeMapping(uint cMap, out uint pcMap, System.IntPtr map)

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCodeEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr values)
{
uint pceltFetched;
this.WrappedObject.Next(celt, values, out pceltFetched);
return pceltFetched;
}
}
}

83
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugContext.cs

@ -80,64 +80,105 @@ namespace Debugger.Wrappers.CorDebug @@ -80,64 +80,105 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetClass(out ICorDebugClass ppClass)
public ICorDebugClass Class
{
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClass(out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
get
{
ICorDebugClass ppClass;
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClass(out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
return ppClass;
}
}
public void GetFieldValue(ICorDebugClass pClass, uint fieldDef, out ICorDebugValue ppValue)
public ICorDebugValue GetFieldValue(ICorDebugClass pClass, uint fieldDef)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetFieldValue(pClass.WrappedObject, fieldDef, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void GetVirtualMethod(uint memberRef, out ICorDebugFunction ppFunction)
public ICorDebugFunction GetVirtualMethod(uint memberRef)
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetVirtualMethod(memberRef, out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
public void GetContext(out ICorDebugContext ppContext)
public ICorDebugContext Context
{
Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
this.WrappedObject.GetContext(out out_ppContext);
ppContext = ICorDebugContext.Wrap(out_ppContext);
get
{
ICorDebugContext ppContext;
Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
this.WrappedObject.GetContext(out out_ppContext);
ppContext = ICorDebugContext.Wrap(out_ppContext);
return ppContext;
}
}
public void IsValueClass(out int pbIsValueClass)
public int IsValueClass
{
this.WrappedObject.IsValueClass(out pbIsValueClass);
get
{
int pbIsValueClass;
this.WrappedObject.IsValueClass(out pbIsValueClass);
return pbIsValueClass;
}
}
public void GetManagedCopy(out object ppObject)
public object ManagedCopy
{
this.WrappedObject.GetManagedCopy(out ppObject);
get
{
object ppObject;
this.WrappedObject.GetManagedCopy(out ppObject);
return ppObject;
}
}
public void SetFromManagedCopy(object pObject)

25
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugController.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Continue(fIsOutOfBand);
}
public void IsRunning(out int pbRunning)
public int IsRunning
{
this.WrappedObject.IsRunning(out pbRunning);
get
{
int pbRunning;
this.WrappedObject.IsRunning(out pbRunning);
return pbRunning;
}
}
public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued)
public int HasQueuedCallbacks(ICorDebugThread pThread)
{
int pbQueued;
this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued);
return pbQueued;
}
public void EnumerateThreads(out ICorDebugThreadEnum ppThreads)
public ICorDebugThreadEnum EnumerateThreads()
{
ICorDebugThreadEnum ppThreads;
Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads;
this.WrappedObject.EnumerateThreads(out out_ppThreads);
ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads);
return ppThreads;
}
public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread)
@ -122,22 +131,26 @@ namespace Debugger.Wrappers.CorDebug @@ -122,22 +131,26 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Terminate(exitCode);
}
public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
public ICorDebugErrorInfoEnum CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
{
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);
return pError;
}
public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
public ICorDebugErrorInfoEnum CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
{
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);
return pError;
}
}
}

31
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEditAndContinueSnapshot.cs

@ -80,24 +80,41 @@ namespace Debugger.Wrappers.CorDebug @@ -80,24 +80,41 @@ namespace Debugger.Wrappers.CorDebug
}
public void CopyMetaData(IStream pIStream, out System.Guid pMvid)
public System.Guid CopyMetaData(IStream pIStream)
{
System.Guid pMvid;
this.WrappedObject.CopyMetaData(pIStream.WrappedObject, out pMvid);
return pMvid;
}
public void GetMvid(out System.Guid pMvid)
public System.Guid Mvid
{
this.WrappedObject.GetMvid(out pMvid);
get
{
System.Guid pMvid;
this.WrappedObject.GetMvid(out pMvid);
return pMvid;
}
}
public void GetRoDataRVA(out uint pRoDataRVA)
public uint RoDataRVA
{
this.WrappedObject.GetRoDataRVA(out pRoDataRVA);
get
{
uint pRoDataRVA;
this.WrappedObject.GetRoDataRVA(out pRoDataRVA);
return pRoDataRVA;
}
}
public void GetRwDataRVA(out uint pRwDataRVA)
public uint RwDataRVA
{
this.WrappedObject.GetRwDataRVA(out pRwDataRVA);
get
{
uint pRwDataRVA;
this.WrappedObject.GetRwDataRVA(out pRwDataRVA);
return pRwDataRVA;
}
}
public void SetPEBytes(IStream pIStream)

13
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEnum.cs

@ -90,16 +90,23 @@ namespace Debugger.Wrappers.CorDebug @@ -90,16 +90,23 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugErrorInfoEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr errors, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr errors)
{
uint pceltFetched;
this.WrappedObject.Next(celt, errors, out pceltFetched);
return pceltFetched;
}
}
}

39
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval.cs

@ -125,9 +125,14 @@ namespace Debugger.Wrappers.CorDebug @@ -125,9 +125,14 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.NewArray(elementType, pElementClass.WrappedObject, rank, ref dims, ref lowBounds);
}
public void IsActive(out int pbActive)
public int IsActive
{
this.WrappedObject.IsActive(out pbActive);
get
{
int pbActive;
this.WrappedObject.IsActive(out pbActive);
return pbActive;
}
}
public void Abort()
@ -135,25 +140,37 @@ namespace Debugger.Wrappers.CorDebug @@ -135,25 +140,37 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Abort();
}
public void GetResult(out ICorDebugValue ppResult)
public ICorDebugValue Result
{
Debugger.Interop.CorDebug.ICorDebugValue out_ppResult;
this.WrappedObject.GetResult(out out_ppResult);
ppResult = ICorDebugValue.Wrap(out_ppResult);
get
{
ICorDebugValue ppResult;
Debugger.Interop.CorDebug.ICorDebugValue out_ppResult;
this.WrappedObject.GetResult(out out_ppResult);
ppResult = ICorDebugValue.Wrap(out_ppResult);
return ppResult;
}
}
public void GetThread(out ICorDebugThread ppThread)
public ICorDebugThread Thread
{
Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
this.WrappedObject.GetThread(out out_ppThread);
ppThread = ICorDebugThread.Wrap(out_ppThread);
get
{
ICorDebugThread ppThread;
Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
this.WrappedObject.GetThread(out out_ppThread);
ppThread = ICorDebugThread.Wrap(out_ppThread);
return ppThread;
}
}
public void CreateValue(uint elementType, ICorDebugClass pElementClass, out ICorDebugValue ppValue)
public ICorDebugValue CreateValue(uint elementType, ICorDebugClass pElementClass)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.CreateValue(elementType, pElementClass.WrappedObject, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
}
}

4
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval2.cs

@ -89,11 +89,13 @@ namespace Debugger.Wrappers.CorDebug @@ -89,11 +89,13 @@ namespace Debugger.Wrappers.CorDebug
ppArgs = ICorDebugValue.Wrap(ref_ppArgs);
}
public void CreateValueForType(ICorDebugType pType, out ICorDebugValue ppValue)
public ICorDebugValue CreateValueForType(ICorDebugType pType)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.CreateValueForType(pType.WrappedObject, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void NewParameterizedObject(ICorDebugFunction pConstructor, uint nTypeArgs, ref ICorDebugType ppTypeArgs, uint nArgs, ref ICorDebugValue ppArgs)

82
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrame.cs

@ -80,56 +80,90 @@ namespace Debugger.Wrappers.CorDebug @@ -80,56 +80,90 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetChain(out ICorDebugChain ppChain)
public ICorDebugChain Chain
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void GetCode(out ICorDebugCode ppCode)
public ICorDebugCode Code
{
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
get
{
ICorDebugCode ppCode;
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
return ppCode;
}
}
public void GetFunction(out ICorDebugFunction ppFunction)
public ICorDebugFunction Function
{
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
get
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
}
public void GetFunctionToken(out uint pToken)
public uint FunctionToken
{
this.WrappedObject.GetFunctionToken(out pToken);
get
{
uint pToken;
this.WrappedObject.GetFunctionToken(out pToken);
return pToken;
}
}
public void GetStackRange(out ulong pStart, out ulong pEnd)
public ulong GetStackRange(out ulong pStart)
{
ulong pEnd;
this.WrappedObject.GetStackRange(out pStart, out pEnd);
return pEnd;
}
public void GetCaller(out ICorDebugFrame ppFrame)
public ICorDebugFrame Caller
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCaller(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCaller(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void GetCallee(out ICorDebugFrame ppFrame)
public ICorDebugFrame Callee
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCallee(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCallee(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void CreateStepper(out ICorDebugStepper ppStepper)
public ICorDebugStepper CreateStepper()
{
ICorDebugStepper ppStepper;
Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
this.WrappedObject.CreateStepper(out out_ppStepper);
ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
return ppStepper;
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrameEnum.cs

@ -90,20 +90,28 @@ namespace Debugger.Wrappers.CorDebug @@ -90,20 +90,28 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, ICorDebugFrame[] frames, out uint pceltFetched)
public uint Next(uint celt, ICorDebugFrame[] frames)
{
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))
{
@ -123,6 +131,7 @@ namespace Debugger.Wrappers.CorDebug @@ -123,6 +131,7 @@ namespace Debugger.Wrappers.CorDebug
frames[i] = null;
}
}
return pceltFetched;
}
}
}

83
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction.cs

@ -80,54 +80,91 @@ namespace Debugger.Wrappers.CorDebug @@ -80,54 +80,91 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetModule(out ICorDebugModule ppModule)
public ICorDebugModule Module
{
Debugger.Interop.CorDebug.ICorDebugModule out_ppModule;
this.WrappedObject.GetModule(out out_ppModule);
ppModule = ICorDebugModule.Wrap(out_ppModule);
get
{
ICorDebugModule ppModule;
Debugger.Interop.CorDebug.ICorDebugModule out_ppModule;
this.WrappedObject.GetModule(out out_ppModule);
ppModule = ICorDebugModule.Wrap(out_ppModule);
return ppModule;
}
}
public void GetClass(out ICorDebugClass ppClass)
public ICorDebugClass Class
{
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClass(out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
get
{
ICorDebugClass ppClass;
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClass(out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
return ppClass;
}
}
public void GetToken(out uint pMethodDef)
public uint Token
{
this.WrappedObject.GetToken(out pMethodDef);
get
{
uint pMethodDef;
this.WrappedObject.GetToken(out pMethodDef);
return pMethodDef;
}
}
public void GetILCode(out ICorDebugCode ppCode)
public ICorDebugCode ILCode
{
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetILCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
get
{
ICorDebugCode ppCode;
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetILCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
return ppCode;
}
}
public void GetNativeCode(out ICorDebugCode ppCode)
public ICorDebugCode NativeCode
{
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetNativeCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
get
{
ICorDebugCode ppCode;
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetNativeCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
return ppCode;
}
}
public void CreateBreakpoint(out ICorDebugFunctionBreakpoint ppBreakpoint)
public ICorDebugFunctionBreakpoint CreateBreakpoint()
{
ICorDebugFunctionBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugFunctionBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetLocalVarSigToken(out uint pmdSig)
public uint LocalVarSigToken
{
this.WrappedObject.GetLocalVarSigToken(out pmdSig);
get
{
uint pmdSig;
this.WrappedObject.GetLocalVarSigToken(out pmdSig);
return pmdSig;
}
}
public void GetCurrentVersionNumber(out uint pnCurrentVersion)
public uint CurrentVersionNumber
{
this.WrappedObject.GetCurrentVersionNumber(out pnCurrentVersion);
get
{
uint pnCurrentVersion;
this.WrappedObject.GetCurrentVersionNumber(out pnCurrentVersion);
return pnCurrentVersion;
}
}
}
}

22
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction2.cs

@ -85,21 +85,33 @@ namespace Debugger.Wrappers.CorDebug @@ -85,21 +85,33 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetJMCStatus(bIsJustMyCode);
}
public void GetJMCStatus(out int pbIsJustMyCode)
public int JMCStatus
{
this.WrappedObject.GetJMCStatus(out pbIsJustMyCode);
get
{
int pbIsJustMyCode;
this.WrappedObject.GetJMCStatus(out pbIsJustMyCode);
return pbIsJustMyCode;
}
}
public void EnumerateNativeCode(out ICorDebugCodeEnum ppCodeEnum)
public ICorDebugCodeEnum EnumerateNativeCode()
{
ICorDebugCodeEnum ppCodeEnum;
Debugger.Interop.CorDebug.ICorDebugCodeEnum out_ppCodeEnum;
this.WrappedObject.EnumerateNativeCode(out out_ppCodeEnum);
ppCodeEnum = ICorDebugCodeEnum.Wrap(out_ppCodeEnum);
return ppCodeEnum;
}
public void GetVersionNumber(out uint pnVersion)
public uint VersionNumber
{
this.WrappedObject.GetVersionNumber(out pnVersion);
get
{
uint pnVersion;
this.WrappedObject.GetVersionNumber(out pnVersion);
return pnVersion;
}
}
}
}

31
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunctionBreakpoint.cs

@ -85,21 +85,36 @@ namespace Debugger.Wrappers.CorDebug @@ -85,21 +85,36 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Activate(bActive);
}
public void IsActive(out int pbActive)
public int IsActive
{
this.WrappedObject.IsActive(out pbActive);
get
{
int pbActive;
this.WrappedObject.IsActive(out pbActive);
return pbActive;
}
}
public void GetFunction(out ICorDebugFunction ppFunction)
public ICorDebugFunction Function
{
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
get
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
}
public void GetOffset(out uint pnOffset)
public uint Offset
{
this.WrappedObject.GetOffset(out pnOffset);
get
{
uint pnOffset;
this.WrappedObject.GetOffset(out pnOffset);
return pnOffset;
}
}
}
}

31
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugGenericValue.cs

@ -80,26 +80,43 @@ namespace Debugger.Wrappers.CorDebug @@ -80,26 +80,43 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetValue(System.IntPtr pTo)

70
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHandleValue.cs

@ -80,36 +80,63 @@ namespace Debugger.Wrappers.CorDebug @@ -80,36 +80,63 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void IsNull(out int pbNull)
public int IsNull
{
this.WrappedObject.IsNull(out pbNull);
get
{
int pbNull;
this.WrappedObject.IsNull(out pbNull);
return pbNull;
}
}
public void GetValue(out ulong pValue)
public ulong Value
{
this.WrappedObject.GetValue(out pValue);
get
{
ulong pValue;
this.WrappedObject.GetValue(out pValue);
return pValue;
}
}
public void SetValue(ulong value)
@ -117,25 +144,34 @@ namespace Debugger.Wrappers.CorDebug @@ -117,25 +144,34 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetValue(value);
}
public void Dereference(out ICorDebugValue ppValue)
public ICorDebugValue Dereference()
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.Dereference(out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void DereferenceStrong(out ICorDebugValue ppValue)
public ICorDebugValue DereferenceStrong()
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.DereferenceStrong(out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void GetHandleType(out CorDebugHandleType pType)
public CorDebugHandleType HandleType
{
Debugger.Interop.CorDebug.CorDebugHandleType out_pType;
this.WrappedObject.GetHandleType(out out_pType);
pType = ((CorDebugHandleType)(out_pType));
get
{
CorDebugHandleType pType;
Debugger.Interop.CorDebug.CorDebugHandleType out_pType;
this.WrappedObject.GetHandleType(out out_pType);
pType = ((CorDebugHandleType)(out_pType));
return pType;
}
}
public void Dispose()

44
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue.cs

@ -80,38 +80,62 @@ namespace Debugger.Wrappers.CorDebug @@ -80,38 +80,62 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void IsValid(out int pbValid)
public int IsValid
{
this.WrappedObject.IsValid(out pbValid);
get
{
int pbValid;
this.WrappedObject.IsValid(out pbValid);
return pbValid;
}
}
public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateRelocBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
}
}

4
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue2.cs

@ -80,11 +80,13 @@ namespace Debugger.Wrappers.CorDebug @@ -80,11 +80,13 @@ namespace Debugger.Wrappers.CorDebug
}
public void CreateHandle(CorDebugHandleType type, out ICorDebugHandleValue ppHandle)
public ICorDebugHandleValue CreateHandle(CorDebugHandleType type)
{
ICorDebugHandleValue ppHandle;
Debugger.Interop.CorDebug.ICorDebugHandleValue out_ppHandle;
this.WrappedObject.CreateHandle(((Debugger.Interop.CorDebug.CorDebugHandleType)(type)), out out_ppHandle);
ppHandle = ICorDebugHandleValue.Wrap(out_ppHandle);
return ppHandle;
}
}
}

115
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame.cs

@ -80,63 +80,99 @@ namespace Debugger.Wrappers.CorDebug @@ -80,63 +80,99 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetChain(out ICorDebugChain ppChain)
public ICorDebugChain Chain
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void GetCode(out ICorDebugCode ppCode)
public ICorDebugCode Code
{
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
get
{
ICorDebugCode ppCode;
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
return ppCode;
}
}
public void GetFunction(out ICorDebugFunction ppFunction)
public ICorDebugFunction Function
{
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
get
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
}
public void GetFunctionToken(out uint pToken)
public uint FunctionToken
{
this.WrappedObject.GetFunctionToken(out pToken);
get
{
uint pToken;
this.WrappedObject.GetFunctionToken(out pToken);
return pToken;
}
}
public void GetStackRange(out ulong pStart, out ulong pEnd)
public ulong GetStackRange(out ulong pStart)
{
ulong pEnd;
this.WrappedObject.GetStackRange(out pStart, out pEnd);
return pEnd;
}
public void GetCaller(out ICorDebugFrame ppFrame)
public ICorDebugFrame Caller
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCaller(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCaller(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void GetCallee(out ICorDebugFrame ppFrame)
public ICorDebugFrame Callee
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCallee(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCallee(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void CreateStepper(out ICorDebugStepper ppStepper)
public ICorDebugStepper CreateStepper()
{
ICorDebugStepper ppStepper;
Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
this.WrappedObject.CreateStepper(out out_ppStepper);
ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
return ppStepper;
}
public void GetIP(out uint pnOffset, out CorDebugMappingResult pMappingResult)
public CorDebugMappingResult GetIP(out uint pnOffset)
{
CorDebugMappingResult pMappingResult;
Debugger.Interop.CorDebug.CorDebugMappingResult out_pMappingResult;
this.WrappedObject.GetIP(out pnOffset, out out_pMappingResult);
pMappingResult = ((CorDebugMappingResult)(out_pMappingResult));
return pMappingResult;
}
public void SetIP(uint nOffset)
@ -144,44 +180,59 @@ namespace Debugger.Wrappers.CorDebug @@ -144,44 +180,59 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetIP(nOffset);
}
public void EnumerateLocalVariables(out ICorDebugValueEnum ppValueEnum)
public ICorDebugValueEnum EnumerateLocalVariables()
{
ICorDebugValueEnum ppValueEnum;
Debugger.Interop.CorDebug.ICorDebugValueEnum out_ppValueEnum;
this.WrappedObject.EnumerateLocalVariables(out out_ppValueEnum);
ppValueEnum = ICorDebugValueEnum.Wrap(out_ppValueEnum);
return ppValueEnum;
}
public void GetLocalVariable(uint dwIndex, out ICorDebugValue ppValue)
public ICorDebugValue GetLocalVariable(uint dwIndex)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetLocalVariable(dwIndex, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void EnumerateArguments(out ICorDebugValueEnum ppValueEnum)
public ICorDebugValueEnum EnumerateArguments()
{
ICorDebugValueEnum ppValueEnum;
Debugger.Interop.CorDebug.ICorDebugValueEnum out_ppValueEnum;
this.WrappedObject.EnumerateArguments(out out_ppValueEnum);
ppValueEnum = ICorDebugValueEnum.Wrap(out_ppValueEnum);
return ppValueEnum;
}
public void GetArgument(uint dwIndex, out ICorDebugValue ppValue)
public ICorDebugValue GetArgument(uint dwIndex)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetArgument(dwIndex, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void GetStackDepth(out uint pDepth)
public uint StackDepth
{
this.WrappedObject.GetStackDepth(out pDepth);
get
{
uint pDepth;
this.WrappedObject.GetStackDepth(out pDepth);
return pDepth;
}
}
public void GetStackValue(uint dwIndex, out ICorDebugValue ppValue)
public ICorDebugValue GetStackValue(uint dwIndex)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetStackValue(dwIndex, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void CanSetIP(uint nOffset)

4
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame2.cs

@ -85,11 +85,13 @@ namespace Debugger.Wrappers.CorDebug @@ -85,11 +85,13 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.RemapFunction(newILOffset);
}
public void EnumerateTypeParameters(out ICorDebugTypeEnum ppTyParEnum)
public ICorDebugTypeEnum EnumerateTypeParameters()
{
ICorDebugTypeEnum ppTyParEnum;
Debugger.Interop.CorDebug.ICorDebugTypeEnum out_ppTyParEnum;
this.WrappedObject.EnumerateTypeParameters(out out_ppTyParEnum);
ppTyParEnum = ICorDebugTypeEnum.Wrap(out_ppTyParEnum);
return ppTyParEnum;
}
}
}

95
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugInternalFrame.cs

@ -80,63 +80,102 @@ namespace Debugger.Wrappers.CorDebug @@ -80,63 +80,102 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetChain(out ICorDebugChain ppChain)
public ICorDebugChain Chain
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void GetCode(out ICorDebugCode ppCode)
public ICorDebugCode Code
{
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
get
{
ICorDebugCode ppCode;
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
return ppCode;
}
}
public void GetFunction(out ICorDebugFunction ppFunction)
public ICorDebugFunction Function
{
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
get
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
}
public void GetFunctionToken(out uint pToken)
public uint FunctionToken
{
this.WrappedObject.GetFunctionToken(out pToken);
get
{
uint pToken;
this.WrappedObject.GetFunctionToken(out pToken);
return pToken;
}
}
public void GetStackRange(out ulong pStart, out ulong pEnd)
public ulong GetStackRange(out ulong pStart)
{
ulong pEnd;
this.WrappedObject.GetStackRange(out pStart, out pEnd);
return pEnd;
}
public void GetCaller(out ICorDebugFrame ppFrame)
public ICorDebugFrame Caller
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCaller(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCaller(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void GetCallee(out ICorDebugFrame ppFrame)
public ICorDebugFrame Callee
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCallee(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCallee(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void CreateStepper(out ICorDebugStepper ppStepper)
public ICorDebugStepper CreateStepper()
{
ICorDebugStepper ppStepper;
Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
this.WrappedObject.CreateStepper(out out_ppStepper);
ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
return ppStepper;
}
public void GetFrameType(out CorDebugInternalFrameType pType)
public CorDebugInternalFrameType FrameType
{
Debugger.Interop.CorDebug.CorDebugInternalFrameType out_pType;
this.WrappedObject.GetFrameType(out out_pType);
pType = ((CorDebugInternalFrameType)(out_pType));
get
{
CorDebugInternalFrameType pType;
Debugger.Interop.CorDebug.CorDebugInternalFrameType out_pType;
this.WrappedObject.GetFrameType(out out_pType);
pType = ((CorDebugInternalFrameType)(out_pType));
return pType;
}
}
}
}

9
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugMDA.cs

@ -102,9 +102,14 @@ namespace Debugger.Wrappers.CorDebug @@ -102,9 +102,14 @@ namespace Debugger.Wrappers.CorDebug
pFlags = ((CorDebugMDAFlags)(ref_pFlags));
}
public void GetOSThreadId(out uint pOsTid)
public uint OSThreadId
{
this.WrappedObject.GetOSThreadId(out pOsTid);
get
{
uint pOsTid;
this.WrappedObject.GetOSThreadId(out pOsTid);
return pOsTid;
}
}
}
}

108
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule.cs

@ -80,23 +80,38 @@ namespace Debugger.Wrappers.CorDebug @@ -80,23 +80,38 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetProcess(out ICorDebugProcess ppProcess)
public ICorDebugProcess Process
{
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
get
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
}
public void GetBaseAddress(out ulong pAddress)
public ulong BaseAddress
{
this.WrappedObject.GetBaseAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetBaseAddress(out pAddress);
return pAddress;
}
}
public void GetAssembly(out ICorDebugAssembly ppAssembly)
public ICorDebugAssembly Assembly
{
Debugger.Interop.CorDebug.ICorDebugAssembly out_ppAssembly;
this.WrappedObject.GetAssembly(out out_ppAssembly);
ppAssembly = ICorDebugAssembly.Wrap(out_ppAssembly);
get
{
ICorDebugAssembly ppAssembly;
Debugger.Interop.CorDebug.ICorDebugAssembly out_ppAssembly;
this.WrappedObject.GetAssembly(out out_ppAssembly);
ppAssembly = ICorDebugAssembly.Wrap(out_ppAssembly);
return ppAssembly;
}
}
public void GetName(uint cchName, out uint pcchName, System.IntPtr szName)
@ -114,71 +129,108 @@ namespace Debugger.Wrappers.CorDebug @@ -114,71 +129,108 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.EnableClassLoadCallbacks(bClassLoadCallbacks);
}
public void GetFunctionFromToken(uint methodDef, out ICorDebugFunction ppFunction)
public ICorDebugFunction GetFunctionFromToken(uint methodDef)
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunctionFromToken(methodDef, out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
public void GetFunctionFromRVA(ulong rva, out ICorDebugFunction ppFunction)
public ICorDebugFunction GetFunctionFromRVA(ulong rva)
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunctionFromRVA(rva, out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
public void GetClassFromToken(uint typeDef, out ICorDebugClass ppClass)
public ICorDebugClass GetClassFromToken(uint typeDef)
{
ICorDebugClass ppClass;
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClassFromToken(typeDef, out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
return ppClass;
}
public void CreateBreakpoint(out ICorDebugModuleBreakpoint ppBreakpoint)
public ICorDebugModuleBreakpoint CreateBreakpoint()
{
ICorDebugModuleBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugModuleBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugModuleBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetEditAndContinueSnapshot(out ICorDebugEditAndContinueSnapshot ppEditAndContinueSnapshot)
public ICorDebugEditAndContinueSnapshot EditAndContinueSnapshot
{
Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot out_ppEditAndContinueSnapshot;
this.WrappedObject.GetEditAndContinueSnapshot(out out_ppEditAndContinueSnapshot);
ppEditAndContinueSnapshot = ICorDebugEditAndContinueSnapshot.Wrap(out_ppEditAndContinueSnapshot);
get
{
ICorDebugEditAndContinueSnapshot ppEditAndContinueSnapshot;
Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot out_ppEditAndContinueSnapshot;
this.WrappedObject.GetEditAndContinueSnapshot(out out_ppEditAndContinueSnapshot);
ppEditAndContinueSnapshot = ICorDebugEditAndContinueSnapshot.Wrap(out_ppEditAndContinueSnapshot);
return ppEditAndContinueSnapshot;
}
}
public void GetMetaDataInterface(ref System.Guid riid, out object ppObj)
public object GetMetaDataInterface(ref System.Guid riid)
{
object ppObj;
this.WrappedObject.GetMetaDataInterface(ref riid, out ppObj);
return ppObj;
}
public void GetToken(out uint pToken)
public uint Token
{
this.WrappedObject.GetToken(out pToken);
get
{
uint pToken;
this.WrappedObject.GetToken(out pToken);
return pToken;
}
}
public void IsDynamic(out int pDynamic)
public int IsDynamic
{
this.WrappedObject.IsDynamic(out pDynamic);
get
{
int pDynamic;
this.WrappedObject.IsDynamic(out pDynamic);
return pDynamic;
}
}
public void GetGlobalVariableValue(uint fieldDef, out ICorDebugValue ppValue)
public ICorDebugValue GetGlobalVariableValue(uint fieldDef)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetGlobalVariableValue(fieldDef, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void GetSize(out uint pcBytes)
public uint Size
{
this.WrappedObject.GetSize(out pcBytes);
get
{
uint pcBytes;
this.WrappedObject.GetSize(out pcBytes);
return pcBytes;
}
}
public void IsInMemory(out int pInMemory)
public int IsInMemory
{
this.WrappedObject.IsInMemory(out pInMemory);
get
{
int pInMemory;
this.WrappedObject.IsInMemory(out pInMemory);
return pInMemory;
}
}
}
}

9
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule2.cs

@ -95,9 +95,14 @@ namespace Debugger.Wrappers.CorDebug @@ -95,9 +95,14 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetJITCompilerFlags(dwFlags);
}
public void GetJITCompilerFlags(out uint pdwFlags)
public uint JITCompilerFlags
{
this.WrappedObject.GetJITCompilerFlags(out pdwFlags);
get
{
uint pdwFlags;
this.WrappedObject.GetJITCompilerFlags(out pdwFlags);
return pdwFlags;
}
}
public void ResolveAssembly(uint tkAssemblyRef, ref ICorDebugAssembly ppAssembly)

22
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleBreakpoint.cs

@ -85,16 +85,26 @@ namespace Debugger.Wrappers.CorDebug @@ -85,16 +85,26 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Activate(bActive);
}
public void IsActive(out int pbActive)
public int IsActive
{
this.WrappedObject.IsActive(out pbActive);
get
{
int pbActive;
this.WrappedObject.IsActive(out pbActive);
return pbActive;
}
}
public void GetModule(out ICorDebugModule ppModule)
public ICorDebugModule Module
{
Debugger.Interop.CorDebug.ICorDebugModule out_ppModule;
this.WrappedObject.GetModule(out out_ppModule);
ppModule = ICorDebugModule.Wrap(out_ppModule);
get
{
ICorDebugModule ppModule;
Debugger.Interop.CorDebug.ICorDebugModule out_ppModule;
this.WrappedObject.GetModule(out out_ppModule);
ppModule = ICorDebugModule.Wrap(out_ppModule);
return ppModule;
}
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr modules, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr modules)
{
uint pceltFetched;
this.WrappedObject.Next(celt, modules, out pceltFetched);
return pceltFetched;
}
}
}

124
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugNativeFrame.cs

@ -80,61 +80,100 @@ namespace Debugger.Wrappers.CorDebug @@ -80,61 +80,100 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetChain(out ICorDebugChain ppChain)
public ICorDebugChain Chain
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void GetCode(out ICorDebugCode ppCode)
public ICorDebugCode Code
{
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
get
{
ICorDebugCode ppCode;
Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
this.WrappedObject.GetCode(out out_ppCode);
ppCode = ICorDebugCode.Wrap(out_ppCode);
return ppCode;
}
}
public void GetFunction(out ICorDebugFunction ppFunction)
public ICorDebugFunction Function
{
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
get
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetFunction(out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
}
public void GetFunctionToken(out uint pToken)
public uint FunctionToken
{
this.WrappedObject.GetFunctionToken(out pToken);
get
{
uint pToken;
this.WrappedObject.GetFunctionToken(out pToken);
return pToken;
}
}
public void GetStackRange(out ulong pStart, out ulong pEnd)
public ulong GetStackRange(out ulong pStart)
{
ulong pEnd;
this.WrappedObject.GetStackRange(out pStart, out pEnd);
return pEnd;
}
public void GetCaller(out ICorDebugFrame ppFrame)
public ICorDebugFrame Caller
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCaller(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCaller(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void GetCallee(out ICorDebugFrame ppFrame)
public ICorDebugFrame Callee
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCallee(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetCallee(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void CreateStepper(out ICorDebugStepper ppStepper)
public ICorDebugStepper CreateStepper()
{
ICorDebugStepper ppStepper;
Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
this.WrappedObject.CreateStepper(out out_ppStepper);
ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
return ppStepper;
}
public void GetIP(out uint pnOffset)
public uint IP
{
this.WrappedObject.GetIP(out pnOffset);
get
{
uint pnOffset;
this.WrappedObject.GetIP(out pnOffset);
return pnOffset;
}
}
public void SetIP(uint nOffset)
@ -142,46 +181,61 @@ namespace Debugger.Wrappers.CorDebug @@ -142,46 +181,61 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetIP(nOffset);
}
public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters)
public ICorDebugRegisterSet RegisterSet
{
Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
this.WrappedObject.GetRegisterSet(out out_ppRegisters);
ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
get
{
ICorDebugRegisterSet ppRegisters;
Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
this.WrappedObject.GetRegisterSet(out out_ppRegisters);
ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
return ppRegisters;
}
}
public void GetLocalRegisterValue(CorDebugRegister reg, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
public ICorDebugValue GetLocalRegisterValue(CorDebugRegister reg, uint cbSigBlob, uint pvSigBlob)
{
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);
return ppValue;
}
public void GetLocalDoubleRegisterValue(CorDebugRegister highWordReg, CorDebugRegister lowWordReg, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
public ICorDebugValue GetLocalDoubleRegisterValue(CorDebugRegister highWordReg, CorDebugRegister lowWordReg, uint cbSigBlob, uint pvSigBlob)
{
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);
return ppValue;
}
public void GetLocalMemoryValue(ulong address, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
public ICorDebugValue GetLocalMemoryValue(ulong address, uint cbSigBlob, uint pvSigBlob)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetLocalMemoryValue(address, cbSigBlob, pvSigBlob, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void GetLocalRegisterMemoryValue(CorDebugRegister highWordReg, ulong lowWordAddress, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
public ICorDebugValue GetLocalRegisterMemoryValue(CorDebugRegister highWordReg, ulong lowWordAddress, uint cbSigBlob, uint pvSigBlob)
{
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);
return ppValue;
}
public void GetLocalMemoryRegisterValue(ulong highWordAddress, CorDebugRegister lowWordRegister, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
public ICorDebugValue GetLocalMemoryRegisterValue(ulong highWordAddress, CorDebugRegister lowWordRegister, uint cbSigBlob, uint pvSigBlob)
{
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);
return ppValue;
}
public void CanSetIP(uint nOffset)

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr objects, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr objects)
{
uint pceltFetched;
this.WrappedObject.Next(celt, objects, out pceltFetched);
return pceltFetched;
}
}
}

83
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue.cs

@ -80,64 +80,105 @@ namespace Debugger.Wrappers.CorDebug @@ -80,64 +80,105 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetClass(out ICorDebugClass ppClass)
public ICorDebugClass Class
{
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClass(out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
get
{
ICorDebugClass ppClass;
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClass(out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
return ppClass;
}
}
public void GetFieldValue(ICorDebugClass pClass, uint fieldDef, out ICorDebugValue ppValue)
public ICorDebugValue GetFieldValue(ICorDebugClass pClass, uint fieldDef)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetFieldValue(pClass.WrappedObject, fieldDef, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void GetVirtualMethod(uint memberRef, out ICorDebugFunction ppFunction)
public ICorDebugFunction GetVirtualMethod(uint memberRef)
{
ICorDebugFunction ppFunction;
Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
this.WrappedObject.GetVirtualMethod(memberRef, out out_ppFunction);
ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
return ppFunction;
}
public void GetContext(out ICorDebugContext ppContext)
public ICorDebugContext Context
{
Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
this.WrappedObject.GetContext(out out_ppContext);
ppContext = ICorDebugContext.Wrap(out_ppContext);
get
{
ICorDebugContext ppContext;
Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
this.WrappedObject.GetContext(out out_ppContext);
ppContext = ICorDebugContext.Wrap(out_ppContext);
return ppContext;
}
}
public void IsValueClass(out int pbIsValueClass)
public int IsValueClass
{
this.WrappedObject.IsValueClass(out pbIsValueClass);
get
{
int pbIsValueClass;
this.WrappedObject.IsValueClass(out pbIsValueClass);
return pbIsValueClass;
}
}
public void GetManagedCopy(out object ppObject)
public object ManagedCopy
{
this.WrappedObject.GetManagedCopy(out ppObject);
get
{
object ppObject;
this.WrappedObject.GetManagedCopy(out ppObject);
return ppObject;
}
}
public void SetFromManagedCopy(object pObject)

4
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue2.cs

@ -80,13 +80,15 @@ namespace Debugger.Wrappers.CorDebug @@ -80,13 +80,15 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetVirtualMethodAndType(uint memberRef, out ICorDebugFunction ppFunction, out ICorDebugType ppType)
public ICorDebugType GetVirtualMethodAndType(uint memberRef, out ICorDebugFunction ppFunction)
{
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);
return ppType;
}
}
}

97
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Continue(fIsOutOfBand);
}
public void IsRunning(out int pbRunning)
public int IsRunning
{
this.WrappedObject.IsRunning(out pbRunning);
get
{
int pbRunning;
this.WrappedObject.IsRunning(out pbRunning);
return pbRunning;
}
}
public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued)
public int HasQueuedCallbacks(ICorDebugThread pThread)
{
int pbQueued;
this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued);
return pbQueued;
}
public void EnumerateThreads(out ICorDebugThreadEnum ppThreads)
public ICorDebugThreadEnum EnumerateThreads()
{
ICorDebugThreadEnum ppThreads;
Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads;
this.WrappedObject.EnumerateThreads(out out_ppThreads);
ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads);
return ppThreads;
}
public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread)
@ -122,56 +131,78 @@ namespace Debugger.Wrappers.CorDebug @@ -122,56 +131,78 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Terminate(exitCode);
}
public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
public ICorDebugErrorInfoEnum CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
{
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);
return pError;
}
public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
public ICorDebugErrorInfoEnum CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
{
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);
return pError;
}
public void GetID(out uint pdwProcessId)
public uint ID
{
this.WrappedObject.GetID(out pdwProcessId);
get
{
uint pdwProcessId;
this.WrappedObject.GetID(out pdwProcessId);
return pdwProcessId;
}
}
public void GetHandle(out uint phProcessHandle)
public uint Handle
{
this.WrappedObject.GetHandle(out phProcessHandle);
get
{
uint phProcessHandle;
this.WrappedObject.GetHandle(out phProcessHandle);
return phProcessHandle;
}
}
public void GetThread(uint dwThreadId, out ICorDebugThread ppThread)
public ICorDebugThread GetThread(uint dwThreadId)
{
ICorDebugThread ppThread;
Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
this.WrappedObject.GetThread(dwThreadId, out out_ppThread);
ppThread = ICorDebugThread.Wrap(out_ppThread);
return ppThread;
}
public void EnumerateObjects(out ICorDebugObjectEnum ppObjects)
public ICorDebugObjectEnum EnumerateObjects()
{
ICorDebugObjectEnum ppObjects;
Debugger.Interop.CorDebug.ICorDebugObjectEnum out_ppObjects;
this.WrappedObject.EnumerateObjects(out out_ppObjects);
ppObjects = ICorDebugObjectEnum.Wrap(out_ppObjects);
return ppObjects;
}
public void IsTransitionStub(ulong address, out int pbTransitionStub)
public int IsTransitionStub(ulong address)
{
int pbTransitionStub;
this.WrappedObject.IsTransitionStub(address, out pbTransitionStub);
return pbTransitionStub;
}
public void IsOSSuspended(uint threadID, out int pbSuspended)
public int IsOSSuspended(uint threadID)
{
int pbSuspended;
this.WrappedObject.IsOSSuspended(threadID, out pbSuspended);
return pbSuspended;
}
public void GetThreadContext(uint threadID, uint contextSize, System.IntPtr context)
@ -184,14 +215,18 @@ namespace Debugger.Wrappers.CorDebug @@ -184,14 +215,18 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetThreadContext(threadID, contextSize, context);
}
public void ReadMemory(ulong address, uint size, System.IntPtr buffer, out uint read)
public uint ReadMemory(ulong address, uint size, System.IntPtr buffer)
{
uint read;
this.WrappedObject.ReadMemory(address, size, buffer, out read);
return read;
}
public void WriteMemory(ulong address, uint size, ref byte buffer, out uint written)
public uint WriteMemory(ulong address, uint size, ref byte buffer)
{
uint written;
this.WrappedObject.WriteMemory(address, size, ref buffer, out written);
return written;
}
public void ClearCurrentException(uint threadID)
@ -209,30 +244,44 @@ namespace Debugger.Wrappers.CorDebug @@ -209,30 +244,44 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.ModifyLogSwitch(ref pLogSwitchName, lLevel);
}
public void EnumerateAppDomains(out ICorDebugAppDomainEnum ppAppDomains)
public ICorDebugAppDomainEnum EnumerateAppDomains()
{
ICorDebugAppDomainEnum ppAppDomains;
Debugger.Interop.CorDebug.ICorDebugAppDomainEnum out_ppAppDomains;
this.WrappedObject.EnumerateAppDomains(out out_ppAppDomains);
ppAppDomains = ICorDebugAppDomainEnum.Wrap(out_ppAppDomains);
return ppAppDomains;
}
public void GetObject(out ICorDebugValue ppObject)
public ICorDebugValue Object
{
Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
this.WrappedObject.GetObject(out out_ppObject);
ppObject = ICorDebugValue.Wrap(out_ppObject);
get
{
ICorDebugValue ppObject;
Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
this.WrappedObject.GetObject(out out_ppObject);
ppObject = ICorDebugValue.Wrap(out_ppObject);
return ppObject;
}
}
public void ThreadForFiberCookie(uint fiberCookie, out ICorDebugThread ppThread)
public ICorDebugThread ThreadForFiberCookie(uint fiberCookie)
{
ICorDebugThread ppThread;
Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
this.WrappedObject.ThreadForFiberCookie(fiberCookie, out out_ppThread);
ppThread = ICorDebugThread.Wrap(out_ppThread);
return ppThread;
}
public void GetHelperThreadID(out uint pThreadID)
public uint HelperThreadID
{
this.WrappedObject.GetHelperThreadID(out pThreadID);
get
{
uint pThreadID;
this.WrappedObject.GetHelperThreadID(out pThreadID);
return pThreadID;
}
}
}
}

30
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess2.cs

@ -80,21 +80,30 @@ namespace Debugger.Wrappers.CorDebug @@ -80,21 +80,30 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetThreadForTaskID(ulong taskid, out ICorDebugThread2 ppThread)
public ICorDebugThread2 GetThreadForTaskID(ulong taskid)
{
ICorDebugThread2 ppThread;
Debugger.Interop.CorDebug.ICorDebugThread2 out_ppThread;
this.WrappedObject.GetThreadForTaskID(taskid, out out_ppThread);
ppThread = ICorDebugThread2.Wrap(out_ppThread);
return ppThread;
}
public void GetVersion(out Debugger.Interop.CorDebug._COR_VERSION version)
public Debugger.Interop.CorDebug._COR_VERSION Version
{
this.WrappedObject.GetVersion(out version);
get
{
Debugger.Interop.CorDebug._COR_VERSION version;
this.WrappedObject.GetVersion(out version);
return version;
}
}
public void SetUnmanagedBreakpoint(ulong address, uint bufsize, System.IntPtr buffer, out uint bufLen)
public uint SetUnmanagedBreakpoint(ulong address, uint bufsize, System.IntPtr buffer)
{
uint bufLen;
this.WrappedObject.SetUnmanagedBreakpoint(address, bufsize, buffer, out bufLen);
return bufLen;
}
public void ClearUnmanagedBreakpoint(ulong address)
@ -107,16 +116,23 @@ namespace Debugger.Wrappers.CorDebug @@ -107,16 +116,23 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetDesiredNGENCompilerFlags(pdwFlags);
}
public void GetDesiredNGENCompilerFlags(out uint pdwFlags)
public uint DesiredNGENCompilerFlags
{
this.WrappedObject.GetDesiredNGENCompilerFlags(out pdwFlags);
get
{
uint pdwFlags;
this.WrappedObject.GetDesiredNGENCompilerFlags(out pdwFlags);
return pdwFlags;
}
}
public void GetReferenceValueFromGCHandle(uint handle, out ICorDebugReferenceValue pOutValue)
public ICorDebugReferenceValue GetReferenceValueFromGCHandle(uint handle)
{
ICorDebugReferenceValue pOutValue;
Debugger.Interop.CorDebug.ICorDebugReferenceValue out_pOutValue;
this.WrappedObject.GetReferenceValueFromGCHandle(handle, out out_pOutValue);
pOutValue = ICorDebugReferenceValue.Wrap(out_pOutValue);
return pOutValue;
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcessEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr processes, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr processes)
{
uint pceltFetched;
this.WrappedObject.Next(celt, processes, out pceltFetched);
return pceltFetched;
}
}
}

57
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugReferenceValue.cs

@ -80,36 +80,63 @@ namespace Debugger.Wrappers.CorDebug @@ -80,36 +80,63 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void IsNull(out int pbNull)
public int IsNull
{
this.WrappedObject.IsNull(out pbNull);
get
{
int pbNull;
this.WrappedObject.IsNull(out pbNull);
return pbNull;
}
}
public void GetValue(out ulong pValue)
public ulong Value
{
this.WrappedObject.GetValue(out pValue);
get
{
ulong pValue;
this.WrappedObject.GetValue(out pValue);
return pValue;
}
}
public void SetValue(ulong value)
@ -117,18 +144,22 @@ namespace Debugger.Wrappers.CorDebug @@ -117,18 +144,22 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetValue(value);
}
public void Dereference(out ICorDebugValue ppValue)
public ICorDebugValue Dereference()
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.Dereference(out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void DereferenceStrong(out ICorDebugValue ppValue)
public ICorDebugValue DereferenceStrong()
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.DereferenceStrong(out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
}
}

9
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugRegisterSet.cs

@ -80,9 +80,14 @@ namespace Debugger.Wrappers.CorDebug @@ -80,9 +80,14 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetRegistersAvailable(out ulong pAvailable)
public ulong RegistersAvailable
{
this.WrappedObject.GetRegistersAvailable(out pAvailable);
get
{
ulong pAvailable;
this.WrappedObject.GetRegistersAvailable(out pAvailable);
return pAvailable;
}
}
public void GetRegisters(ulong mask, uint regCount, System.IntPtr regBuffer)

9
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper.cs

@ -80,9 +80,14 @@ namespace Debugger.Wrappers.CorDebug @@ -80,9 +80,14 @@ namespace Debugger.Wrappers.CorDebug
}
public void IsActive(out int pbActive)
public int IsActive
{
this.WrappedObject.IsActive(out pbActive);
get
{
int pbActive;
this.WrappedObject.IsActive(out pbActive);
return pbActive;
}
}
public void Deactivate()

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepperEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr steppers, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr steppers)
{
uint pceltFetched;
this.WrappedObject.Next(celt, steppers, out pceltFetched);
return pceltFetched;
}
}
}

53
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStringValue.cs

@ -80,43 +80,72 @@ namespace Debugger.Wrappers.CorDebug @@ -80,43 +80,72 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void IsValid(out int pbValid)
public int IsValid
{
this.WrappedObject.IsValid(out pbValid);
get
{
int pbValid;
this.WrappedObject.IsValid(out pbValid);
return pbValid;
}
}
public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateRelocBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
public void GetLength(out uint pcchString)
public uint Length
{
this.WrappedObject.GetLength(out pcchString);
get
{
uint pcchString;
this.WrappedObject.GetLength(out pcchString);
return pcchString;
}
}
public void GetString(uint cchString, out uint pcchString, System.IntPtr szString)

147
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread.cs

@ -80,28 +80,48 @@ namespace Debugger.Wrappers.CorDebug @@ -80,28 +80,48 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetProcess(out ICorDebugProcess ppProcess)
public ICorDebugProcess Process
{
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
get
{
ICorDebugProcess ppProcess;
Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
this.WrappedObject.GetProcess(out out_ppProcess);
ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
return ppProcess;
}
}
public void GetID(out uint pdwThreadId)
public uint ID
{
this.WrappedObject.GetID(out pdwThreadId);
get
{
uint pdwThreadId;
this.WrappedObject.GetID(out pdwThreadId);
return pdwThreadId;
}
}
public void GetHandle(out uint phThreadHandle)
public uint Handle
{
this.WrappedObject.GetHandle(out phThreadHandle);
get
{
uint phThreadHandle;
this.WrappedObject.GetHandle(out phThreadHandle);
return phThreadHandle;
}
}
public void GetAppDomain(out ICorDebugAppDomain ppAppDomain)
public ICorDebugAppDomain AppDomain
{
Debugger.Interop.CorDebug.ICorDebugAppDomain out_ppAppDomain;
this.WrappedObject.GetAppDomain(out out_ppAppDomain);
ppAppDomain = ICorDebugAppDomain.Wrap(out_ppAppDomain);
get
{
ICorDebugAppDomain ppAppDomain;
Debugger.Interop.CorDebug.ICorDebugAppDomain out_ppAppDomain;
this.WrappedObject.GetAppDomain(out out_ppAppDomain);
ppAppDomain = ICorDebugAppDomain.Wrap(out_ppAppDomain);
return ppAppDomain;
}
}
public void SetDebugState(CorDebugThreadState state)
@ -109,25 +129,40 @@ namespace Debugger.Wrappers.CorDebug @@ -109,25 +129,40 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.SetDebugState(((Debugger.Interop.CorDebug.CorDebugThreadState)(state)));
}
public void GetDebugState(out CorDebugThreadState pState)
public CorDebugThreadState DebugState
{
Debugger.Interop.CorDebug.CorDebugThreadState out_pState;
this.WrappedObject.GetDebugState(out out_pState);
pState = ((CorDebugThreadState)(out_pState));
get
{
CorDebugThreadState pState;
Debugger.Interop.CorDebug.CorDebugThreadState out_pState;
this.WrappedObject.GetDebugState(out out_pState);
pState = ((CorDebugThreadState)(out_pState));
return pState;
}
}
public void GetUserState(out CorDebugUserState pState)
public CorDebugUserState UserState
{
Debugger.Interop.CorDebug.CorDebugUserState out_pState;
this.WrappedObject.GetUserState(out out_pState);
pState = ((CorDebugUserState)(out_pState));
get
{
CorDebugUserState pState;
Debugger.Interop.CorDebug.CorDebugUserState out_pState;
this.WrappedObject.GetUserState(out out_pState);
pState = ((CorDebugUserState)(out_pState));
return pState;
}
}
public void GetCurrentException(out ICorDebugValue ppExceptionObject)
public ICorDebugValue CurrentException
{
Debugger.Interop.CorDebug.ICorDebugValue out_ppExceptionObject;
this.WrappedObject.GetCurrentException(out out_ppExceptionObject);
ppExceptionObject = ICorDebugValue.Wrap(out_ppExceptionObject);
get
{
ICorDebugValue ppExceptionObject;
Debugger.Interop.CorDebug.ICorDebugValue out_ppExceptionObject;
this.WrappedObject.GetCurrentException(out out_ppExceptionObject);
ppExceptionObject = ICorDebugValue.Wrap(out_ppExceptionObject);
return ppExceptionObject;
}
}
public void ClearCurrentException()
@ -135,53 +170,79 @@ namespace Debugger.Wrappers.CorDebug @@ -135,53 +170,79 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.ClearCurrentException();
}
public void CreateStepper(out ICorDebugStepper ppStepper)
public ICorDebugStepper CreateStepper()
{
ICorDebugStepper ppStepper;
Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
this.WrappedObject.CreateStepper(out out_ppStepper);
ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
return ppStepper;
}
public void EnumerateChains(out ICorDebugChainEnum ppChains)
public ICorDebugChainEnum EnumerateChains()
{
ICorDebugChainEnum ppChains;
Debugger.Interop.CorDebug.ICorDebugChainEnum out_ppChains;
this.WrappedObject.EnumerateChains(out out_ppChains);
ppChains = ICorDebugChainEnum.Wrap(out_ppChains);
return ppChains;
}
public void GetActiveChain(out ICorDebugChain ppChain)
public ICorDebugChain ActiveChain
{
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetActiveChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
get
{
ICorDebugChain ppChain;
Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
this.WrappedObject.GetActiveChain(out out_ppChain);
ppChain = ICorDebugChain.Wrap(out_ppChain);
return ppChain;
}
}
public void GetActiveFrame(out ICorDebugFrame ppFrame)
public ICorDebugFrame ActiveFrame
{
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetActiveFrame(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
get
{
ICorDebugFrame ppFrame;
Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
this.WrappedObject.GetActiveFrame(out out_ppFrame);
ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
return ppFrame;
}
}
public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters)
public ICorDebugRegisterSet RegisterSet
{
Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
this.WrappedObject.GetRegisterSet(out out_ppRegisters);
ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
get
{
ICorDebugRegisterSet ppRegisters;
Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
this.WrappedObject.GetRegisterSet(out out_ppRegisters);
ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
return ppRegisters;
}
}
public void CreateEval(out ICorDebugEval ppEval)
public ICorDebugEval CreateEval()
{
ICorDebugEval ppEval;
Debugger.Interop.CorDebug.ICorDebugEval out_ppEval;
this.WrappedObject.CreateEval(out out_ppEval);
ppEval = ICorDebugEval.Wrap(out_ppEval);
return ppEval;
}
public void GetObject(out ICorDebugValue ppObject)
public ICorDebugValue Object
{
Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
this.WrappedObject.GetObject(out out_ppObject);
ppObject = ICorDebugValue.Wrap(out_ppObject);
get
{
ICorDebugValue ppObject;
Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
this.WrappedObject.GetObject(out out_ppObject);
ppObject = ICorDebugValue.Wrap(out_ppObject);
return ppObject;
}
}
}
}

27
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread2.cs

@ -85,19 +85,34 @@ namespace Debugger.Wrappers.CorDebug @@ -85,19 +85,34 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.GetActiveFunctions(cFunctions, out pcFunctions, pFunctions);
}
public void GetConnectionID(out uint pdwConnectionId)
public uint ConnectionID
{
this.WrappedObject.GetConnectionID(out pdwConnectionId);
get
{
uint pdwConnectionId;
this.WrappedObject.GetConnectionID(out pdwConnectionId);
return pdwConnectionId;
}
}
public void GetTaskID(out ulong pTaskId)
public ulong TaskID
{
this.WrappedObject.GetTaskID(out pTaskId);
get
{
ulong pTaskId;
this.WrappedObject.GetTaskID(out pTaskId);
return pTaskId;
}
}
public void GetVolatileOSThreadID(out uint pdwTid)
public uint VolatileOSThreadID
{
this.WrappedObject.GetVolatileOSThreadID(out pdwTid);
get
{
uint pdwTid;
this.WrappedObject.GetVolatileOSThreadID(out pdwTid);
return pdwTid;
}
}
public void InterceptCurrentException(ICorDebugFrame pFrame)

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThreadEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr threads, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr threads)
{
uint pceltFetched;
this.WrappedObject.Next(celt, threads, out pceltFetched);
return pceltFetched;
}
}
}

65
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugType.cs

@ -80,49 +80,78 @@ namespace Debugger.Wrappers.CorDebug @@ -80,49 +80,78 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint ty)
public uint Type
{
this.WrappedObject.GetType(out ty);
get
{
uint ty;
this.WrappedObject.GetType(out ty);
return ty;
}
}
public void GetClass(out ICorDebugClass ppClass)
public ICorDebugClass Class
{
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClass(out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
get
{
ICorDebugClass ppClass;
Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
this.WrappedObject.GetClass(out out_ppClass);
ppClass = ICorDebugClass.Wrap(out_ppClass);
return ppClass;
}
}
public void EnumerateTypeParameters(out ICorDebugTypeEnum ppTyParEnum)
public ICorDebugTypeEnum EnumerateTypeParameters()
{
ICorDebugTypeEnum ppTyParEnum;
Debugger.Interop.CorDebug.ICorDebugTypeEnum out_ppTyParEnum;
this.WrappedObject.EnumerateTypeParameters(out out_ppTyParEnum);
ppTyParEnum = ICorDebugTypeEnum.Wrap(out_ppTyParEnum);
return ppTyParEnum;
}
public void GetFirstTypeParameter(out ICorDebugType value)
public ICorDebugType FirstTypeParameter
{
Debugger.Interop.CorDebug.ICorDebugType out_value;
this.WrappedObject.GetFirstTypeParameter(out out_value);
value = ICorDebugType.Wrap(out_value);
get
{
ICorDebugType value;
Debugger.Interop.CorDebug.ICorDebugType out_value;
this.WrappedObject.GetFirstTypeParameter(out out_value);
value = ICorDebugType.Wrap(out_value);
return value;
}
}
public void GetBase(out ICorDebugType pBase)
public ICorDebugType Base
{
Debugger.Interop.CorDebug.ICorDebugType out_pBase;
this.WrappedObject.GetBase(out out_pBase);
pBase = ICorDebugType.Wrap(out_pBase);
get
{
ICorDebugType pBase;
Debugger.Interop.CorDebug.ICorDebugType out_pBase;
this.WrappedObject.GetBase(out out_pBase);
pBase = ICorDebugType.Wrap(out_pBase);
return pBase;
}
}
public void GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
public ICorDebugValue GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame)
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetStaticFieldValue(fieldDef, pFrame.WrappedObject, out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
public void GetRank(out uint pnRank)
public uint Rank
{
this.WrappedObject.GetRank(out pnRank);
get
{
uint pnRank;
this.WrappedObject.GetRank(out pnRank);
return pnRank;
}
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugTypeEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr values)
{
uint pceltFetched;
this.WrappedObject.Next(celt, values, out pceltFetched);
return pceltFetched;
}
}
}

31
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue.cs

@ -80,26 +80,43 @@ namespace Debugger.Wrappers.CorDebug @@ -80,26 +80,43 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetType(out uint pType)
public uint Type
{
this.WrappedObject.GetType(out pType);
get
{
uint pType;
this.WrappedObject.GetType(out pType);
return pType;
}
}
public void GetSize(out uint pSize)
public uint Size
{
this.WrappedObject.GetSize(out pSize);
get
{
uint pSize;
this.WrappedObject.GetSize(out pSize);
return pSize;
}
}
public void GetAddress(out ulong pAddress)
public ulong Address
{
this.WrappedObject.GetAddress(out pAddress);
get
{
ulong pAddress;
this.WrappedObject.GetAddress(out pAddress);
return pAddress;
}
}
public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
public ICorDebugValueBreakpoint CreateBreakpoint()
{
ICorDebugValueBreakpoint ppBreakpoint;
Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
return ppBreakpoint;
}
}
}

13
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue2.cs

@ -80,11 +80,16 @@ namespace Debugger.Wrappers.CorDebug @@ -80,11 +80,16 @@ namespace Debugger.Wrappers.CorDebug
}
public void GetExactType(out ICorDebugType ppType)
public ICorDebugType ExactType
{
Debugger.Interop.CorDebug.ICorDebugType out_ppType;
this.WrappedObject.GetExactType(out out_ppType);
ppType = ICorDebugType.Wrap(out_ppType);
get
{
ICorDebugType ppType;
Debugger.Interop.CorDebug.ICorDebugType out_ppType;
this.WrappedObject.GetExactType(out out_ppType);
ppType = ICorDebugType.Wrap(out_ppType);
return ppType;
}
}
}
}

22
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueBreakpoint.cs

@ -85,16 +85,26 @@ namespace Debugger.Wrappers.CorDebug @@ -85,16 +85,26 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Activate(bActive);
}
public void IsActive(out int pbActive)
public int IsActive
{
this.WrappedObject.IsActive(out pbActive);
get
{
int pbActive;
this.WrappedObject.IsActive(out pbActive);
return pbActive;
}
}
public void GetValue(out ICorDebugValue ppValue)
public ICorDebugValue Value
{
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetValue(out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
get
{
ICorDebugValue ppValue;
Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
this.WrappedObject.GetValue(out out_ppValue);
ppValue = ICorDebugValue.Wrap(out_ppValue);
return ppValue;
}
}
}
}

17
src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueEnum.cs

@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug @@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Reset();
}
public void Clone(out ICorDebugEnum ppEnum)
public ICorDebugEnum Clone()
{
ICorDebugEnum ppEnum;
Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
this.WrappedObject.Clone(out out_ppEnum);
ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
return ppEnum;
}
public void GetCount(out uint pcelt)
public uint Count
{
this.WrappedObject.GetCount(out pcelt);
get
{
uint pcelt;
this.WrappedObject.GetCount(out pcelt);
return pcelt;
}
}
public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
public uint Next(uint celt, System.IntPtr values)
{
uint pceltFetched;
this.WrappedObject.Next(celt, values, out pceltFetched);
return pceltFetched;
}
}
}

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

@ -80,14 +80,18 @@ namespace Debugger.Wrappers.CorDebug @@ -80,14 +80,18 @@ namespace Debugger.Wrappers.CorDebug
}
public void RemoteRead(out byte pv, uint cb, out uint pcbRead)
public uint RemoteRead(out byte pv, uint cb)
{
uint pcbRead;
this.WrappedObject.RemoteRead(out pv, cb, out pcbRead);
return pcbRead;
}
public void RemoteWrite(ref byte pv, uint cb, out uint pcbWritten)
public uint RemoteWrite(ref byte pv, uint cb)
{
uint pcbWritten;
this.WrappedObject.RemoteWrite(ref pv, cb, out pcbWritten);
return pcbWritten;
}
}
}

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

@ -80,19 +80,25 @@ namespace Debugger.Wrappers.CorDebug @@ -80,19 +80,25 @@ namespace Debugger.Wrappers.CorDebug
}
public void RemoteRead(out byte pv, uint cb, out uint pcbRead)
public uint RemoteRead(out byte pv, uint cb)
{
uint pcbRead;
this.WrappedObject.RemoteRead(out pv, cb, out pcbRead);
return pcbRead;
}
public void RemoteWrite(ref byte pv, uint cb, out uint pcbWritten)
public uint RemoteWrite(ref byte pv, uint cb)
{
uint pcbWritten;
this.WrappedObject.RemoteWrite(ref pv, cb, out pcbWritten);
return pcbWritten;
}
public void RemoteSeek(Debugger.Interop.CorDebug._LARGE_INTEGER dlibMove, uint dwOrigin, out Debugger.Interop.CorDebug._ULARGE_INTEGER plibNewPosition)
public Debugger.Interop.CorDebug._ULARGE_INTEGER RemoteSeek(Debugger.Interop.CorDebug._LARGE_INTEGER dlibMove, uint dwOrigin)
{
Debugger.Interop.CorDebug._ULARGE_INTEGER plibNewPosition;
this.WrappedObject.RemoteSeek(dlibMove, dwOrigin, out plibNewPosition);
return plibNewPosition;
}
public void SetSize(Debugger.Interop.CorDebug._ULARGE_INTEGER libNewSize)
@ -100,9 +106,11 @@ namespace Debugger.Wrappers.CorDebug @@ -100,9 +106,11 @@ namespace Debugger.Wrappers.CorDebug
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)
public Debugger.Interop.CorDebug._ULARGE_INTEGER RemoteCopyTo(IStream pstm, Debugger.Interop.CorDebug._ULARGE_INTEGER cb, out Debugger.Interop.CorDebug._ULARGE_INTEGER pcbRead)
{
Debugger.Interop.CorDebug._ULARGE_INTEGER pcbWritten;
this.WrappedObject.RemoteCopyTo(pstm.WrappedObject, cb, out pcbRead, out pcbWritten);
return pcbWritten;
}
public void Commit(uint grfCommitFlags)
@ -130,11 +138,13 @@ namespace Debugger.Wrappers.CorDebug @@ -130,11 +138,13 @@ namespace Debugger.Wrappers.CorDebug
this.WrappedObject.Stat(out pstatstg, grfStatFlag);
}
public void Clone(out IStream ppstm)
public IStream Clone()
{
IStream ppstm;
Debugger.Interop.CorDebug.IStream out_ppstm;
this.WrappedObject.Clone(out out_ppstm);
ppstm = IStream.Wrap(out_ppstm);
return ppstm;
}
}
}

81
src/Tools/WrapperGenerator/CodeGenerator.cs

@ -319,8 +319,9 @@ namespace WrapperGenerator @@ -319,8 +319,9 @@ namespace WrapperGenerator
class MethodContext
{
CodeMemberMethod codeMemberMethod = new CodeMemberMethod();
public CodeTypeMember CodeMemberMethod = new CodeMemberMethod();
CodeGenerator generator;
MethodInfo method;
public string Name;
public bool IsReturnTypeWrapped;
@ -329,12 +330,14 @@ namespace WrapperGenerator @@ -329,12 +330,14 @@ namespace WrapperGenerator
public List<CodeParameterDeclarationExpression> WrapperParams = new List<CodeParameterDeclarationExpression>();
public List<CodeStatement> DoBeforeInvoke = new List<CodeStatement>();
CodeStatement doInvoke;
public List<CodeExpression> BaseMethodInvokeParams = new List<CodeExpression>();
public List<CodeStatement> DoAfterInvoke = new List<CodeStatement>();
public MethodContext(CodeGenerator generator, MethodInfo method)
{
this.generator = generator;
this.method = method;
Name = method.Name;
RawReturnType = method.ReturnType;
IsReturnTypeWrapped = generator.ShouldIncludeType(method.ReturnType);
@ -343,28 +346,22 @@ namespace WrapperGenerator @@ -343,28 +346,22 @@ namespace WrapperGenerator
} else {
WrappedReturnType = method.ReturnType.FullName;
}
codeMemberMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
codeMemberMethod.ReturnType = new CodeTypeReference(WrappedReturnType);
codeMemberMethod.Name = method.Name;
}
public CodeMemberMethod Emit()
void AddBaseInvokeCode()
{
CodeExpression baseInvoke =
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
generator.ExpressionForWrappedObjectProperty,
Name),
method.Name),
BaseMethodInvokeParams.ToArray());
if (IsReturnTypeWrapped) {
baseInvoke = generator.Wrap(RawReturnType, baseInvoke);
}
CodeStatement doInvoke;
if (WrappedReturnType != typeof(void).FullName) {
if (RawReturnType != typeof(void)) {
if (DoAfterInvoke.Count == 0) {
doInvoke = new CodeMethodReturnStatement(baseInvoke);
} else {
@ -381,13 +378,31 @@ namespace WrapperGenerator @@ -381,13 +378,31 @@ namespace WrapperGenerator
} else {
doInvoke = new CodeExpressionStatement(baseInvoke);
}
}
public CodeTypeMember Emit()
{
AddBaseInvokeCode();
List<CodeStatement> body = new List<CodeStatement>();
body.AddRange(DoBeforeInvoke);
body.Add(doInvoke);
body.AddRange(DoAfterInvoke);
codeMemberMethod.Statements.AddRange(DoBeforeInvoke.ToArray());
codeMemberMethod.Statements.Add(doInvoke);
codeMemberMethod.Statements.AddRange(DoAfterInvoke.ToArray());
codeMemberMethod.Parameters.AddRange(WrapperParams.ToArray());
CodeMemberMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeMemberMethod.Name = Name;
return codeMemberMethod;
if (CodeMemberMethod is CodeMemberMethod) {
((CodeMemberMethod)CodeMemberMethod).ReturnType = new CodeTypeReference(WrappedReturnType);
((CodeMemberMethod)CodeMemberMethod).Parameters.AddRange(WrapperParams.ToArray());
((CodeMemberMethod)CodeMemberMethod).Statements.AddRange(body.ToArray());
} else {
((CodeMemberProperty)CodeMemberMethod).Type = new CodeTypeReference(WrappedReturnType);
((CodeMemberProperty)CodeMemberMethod).HasGet = true;
((CodeMemberProperty)CodeMemberMethod).GetStatements.AddRange(body.ToArray());
}
return CodeMemberMethod;
}
}
@ -435,16 +450,17 @@ namespace WrapperGenerator @@ -435,16 +450,17 @@ namespace WrapperGenerator
}
}
CodeMemberMethod MakeMember(MethodInfo method)
CodeTypeMember MakeMember(MethodInfo method)
{
MethodContext methodContext = new MethodContext(this, method);
foreach(ParameterInfo par in method.GetParameters()) {
ParamContext parContext = new ParamContext(this, par);
ParameterInfo[] pars = method.GetParameters();
for(int i = 0; i < pars.Length; i++) {
ParamContext parContext = new ParamContext(this, pars[i]);
if (parContext.IsWrapped) {
if (parContext.Direction == FieldDirection.In) {
if (par.ParameterType.IsArray) {
if (pars[i].ParameterType.IsArray) {
UnwrapArrayArgument(methodContext, parContext);
} else {
UnwrapArgument(methodContext, parContext);
@ -455,6 +471,33 @@ namespace WrapperGenerator @@ -455,6 +471,33 @@ namespace WrapperGenerator
} else {
PassArgument(methodContext, parContext);
}
// If last parameter is 'out' and method returns void
if (i == pars.Length - 1 &&
parContext.Direction == FieldDirection.Out &&
methodContext.RawReturnType == typeof(void)) {
// Placeholder for the parameter
methodContext.DoBeforeInvoke.Insert(0,
new CodeVariableDeclarationStatement(parContext.WrappedType, parContext.Name));
// Remove the parameter
methodContext.WrapperParams.RemoveAt(methodContext.WrapperParams.Count - 1);
methodContext.WrappedReturnType = parContext.WrappedType;
methodContext.DoAfterInvoke.Add(
new CodeMethodReturnStatement(
new CodeVariableReferenceExpression(parContext.Name)));
}
}
if (methodContext.WrapperParams.Count == 0) {
if (methodContext.Name.StartsWith("Is")) {
methodContext.CodeMemberMethod = new CodeMemberProperty();
}
if (methodContext.Name.StartsWith("Get")) {
methodContext.CodeMemberMethod = new CodeMemberProperty();
methodContext.Name = methodContext.Name.Remove(0, 3);
}
}
return methodContext.Emit();

Loading…
Cancel
Save