PageRenderTime 88ms CodeModel.GetById 26ms app.highlight 52ms RepoModel.GetById 1ms app.codeStats 1ms

/Debugger/Debugger.Core/Interop/CorDebugExtensionMethods.generated.cs

http://github.com/icsharpcode/ILSpy
C# | 2257 lines | 1917 code | 338 blank | 2 comment | 0 complexity | 9ceed89b65ec25116bfe6815c2a8f6de MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
   2// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
   3
   4using System;
   5using System.Runtime.CompilerServices;
   6using System.Runtime.InteropServices;
   7
   8namespace Debugger.Interop.CorDebug
   9{
  10	public static partial class CorDebugExtensionMethods
  11	{
  12		public static void CanLaunchOrAttach(this CorDebugClass instance, uint dwProcessId, int win32DebuggingEnabled)
  13		{
  14			instance.__CanLaunchOrAttach(dwProcessId, win32DebuggingEnabled);
  15		}
  16		
  17		public static ICorDebugProcess CreateProcess(this CorDebugClass instance, string lpApplicationName, string lpCommandLine, ref _SECURITY_ATTRIBUTES lpProcessAttributes, ref _SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo,
  18		uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags)
  19		{
  20			ICorDebugProcess ppProcess;
  21			instance.__CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation,
  22			debuggingFlags, out ppProcess);
  23			ProcessOutParameter(lpProcessAttributes);
  24			ProcessOutParameter(lpThreadAttributes);
  25			ProcessOutParameter(ppProcess);
  26			return ppProcess;
  27		}
  28		
  29		public static ICorDebugProcess DebugActiveProcess(this CorDebugClass instance, uint id, int win32Attach)
  30		{
  31			ICorDebugProcess ppProcess;
  32			instance.__DebugActiveProcess(id, win32Attach, out ppProcess);
  33			ProcessOutParameter(ppProcess);
  34			return ppProcess;
  35		}
  36		
  37		public static ICorDebugProcessEnum EnumerateProcesses(this CorDebugClass instance)
  38		{
  39			ICorDebugProcessEnum ppProcess;
  40			instance.__EnumerateProcesses(out ppProcess);
  41			ProcessOutParameter(ppProcess);
  42			return ppProcess;
  43		}
  44		
  45		public static ICorDebugProcess GetProcess(this CorDebugClass instance, uint dwProcessId)
  46		{
  47			ICorDebugProcess ppProcess;
  48			instance.__GetProcess(dwProcessId, out ppProcess);
  49			ProcessOutParameter(ppProcess);
  50			return ppProcess;
  51		}
  52		
  53		public static void Initialize(this CorDebugClass instance)
  54		{
  55			instance.__Initialize();
  56		}
  57		
  58		public static void SetManagedHandler(this CorDebugClass instance, ICorDebugManagedCallback pCallback)
  59		{
  60			instance.__SetManagedHandler(pCallback);
  61		}
  62		
  63		public static void SetUnmanagedHandler(this CorDebugClass instance, ICorDebugUnmanagedCallback pCallback)
  64		{
  65			instance.__SetUnmanagedHandler(pCallback);
  66		}
  67		
  68		public static void Terminate(this CorDebugClass instance)
  69		{
  70			instance.__Terminate();
  71		}
  72		
  73		public static void CanLaunchOrAttach(this EmbeddedCLRCorDebugClass instance, uint dwProcessId, int win32DebuggingEnabled)
  74		{
  75			instance.__CanLaunchOrAttach(dwProcessId, win32DebuggingEnabled);
  76		}
  77		
  78		public static ICorDebugProcess CreateProcess(this EmbeddedCLRCorDebugClass instance, string lpApplicationName, string lpCommandLine, ref _SECURITY_ATTRIBUTES lpProcessAttributes, ref _SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo,
  79		uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags)
  80		{
  81			ICorDebugProcess ppProcess;
  82			instance.__CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation,
  83			debuggingFlags, out ppProcess);
  84			ProcessOutParameter(lpProcessAttributes);
  85			ProcessOutParameter(lpThreadAttributes);
  86			ProcessOutParameter(ppProcess);
  87			return ppProcess;
  88		}
  89		
  90		public static ICorDebugProcess DebugActiveProcess(this EmbeddedCLRCorDebugClass instance, uint id, int win32Attach)
  91		{
  92			ICorDebugProcess ppProcess;
  93			instance.__DebugActiveProcess(id, win32Attach, out ppProcess);
  94			ProcessOutParameter(ppProcess);
  95			return ppProcess;
  96		}
  97		
  98		public static ICorDebugProcessEnum EnumerateProcesses(this EmbeddedCLRCorDebugClass instance)
  99		{
 100			ICorDebugProcessEnum ppProcess;
 101			instance.__EnumerateProcesses(out ppProcess);
 102			ProcessOutParameter(ppProcess);
 103			return ppProcess;
 104		}
 105		
 106		public static ICorDebugProcess GetProcess(this EmbeddedCLRCorDebugClass instance, uint dwProcessId)
 107		{
 108			ICorDebugProcess ppProcess;
 109			instance.__GetProcess(dwProcessId, out ppProcess);
 110			ProcessOutParameter(ppProcess);
 111			return ppProcess;
 112		}
 113		
 114		public static void Initialize(this EmbeddedCLRCorDebugClass instance)
 115		{
 116			instance.__Initialize();
 117		}
 118		
 119		public static void SetManagedHandler(this EmbeddedCLRCorDebugClass instance, ICorDebugManagedCallback pCallback)
 120		{
 121			instance.__SetManagedHandler(pCallback);
 122		}
 123		
 124		public static void SetUnmanagedHandler(this EmbeddedCLRCorDebugClass instance, ICorDebugUnmanagedCallback pCallback)
 125		{
 126			instance.__SetUnmanagedHandler(pCallback);
 127		}
 128		
 129		public static void Terminate(this EmbeddedCLRCorDebugClass instance)
 130		{
 131			instance.__Terminate();
 132		}
 133		
 134		public static void Initialize(this ICorDebug instance)
 135		{
 136			instance.__Initialize();
 137		}
 138		
 139		public static void Terminate(this ICorDebug instance)
 140		{
 141			instance.__Terminate();
 142		}
 143		
 144		public static void SetManagedHandler(this ICorDebug instance, ICorDebugManagedCallback pCallback)
 145		{
 146			instance.__SetManagedHandler(pCallback);
 147		}
 148		
 149		public static void SetUnmanagedHandler(this ICorDebug instance, ICorDebugUnmanagedCallback pCallback)
 150		{
 151			instance.__SetUnmanagedHandler(pCallback);
 152		}
 153		
 154		public static ICorDebugProcess CreateProcess(this ICorDebug instance, string lpApplicationName, string lpCommandLine, ref _SECURITY_ATTRIBUTES lpProcessAttributes, ref _SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo,
 155		uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags)
 156		{
 157			ICorDebugProcess ppProcess;
 158			instance.__CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation,
 159			debuggingFlags, out ppProcess);
 160			ProcessOutParameter(lpProcessAttributes);
 161			ProcessOutParameter(lpThreadAttributes);
 162			ProcessOutParameter(ppProcess);
 163			return ppProcess;
 164		}
 165		
 166		public static ICorDebugProcess DebugActiveProcess(this ICorDebug instance, uint id, int win32Attach)
 167		{
 168			ICorDebugProcess ppProcess;
 169			instance.__DebugActiveProcess(id, win32Attach, out ppProcess);
 170			ProcessOutParameter(ppProcess);
 171			return ppProcess;
 172		}
 173		
 174		public static ICorDebugProcessEnum EnumerateProcesses(this ICorDebug instance)
 175		{
 176			ICorDebugProcessEnum ppProcess;
 177			instance.__EnumerateProcesses(out ppProcess);
 178			ProcessOutParameter(ppProcess);
 179			return ppProcess;
 180		}
 181		
 182		public static ICorDebugProcess GetProcess(this ICorDebug instance, uint dwProcessId)
 183		{
 184			ICorDebugProcess ppProcess;
 185			instance.__GetProcess(dwProcessId, out ppProcess);
 186			ProcessOutParameter(ppProcess);
 187			return ppProcess;
 188		}
 189		
 190		public static void CanLaunchOrAttach(this ICorDebug instance, uint dwProcessId, int win32DebuggingEnabled)
 191		{
 192			instance.__CanLaunchOrAttach(dwProcessId, win32DebuggingEnabled);
 193		}
 194		
 195		public static void Stop(this ICorDebugAppDomain instance, uint dwTimeoutIgnored)
 196		{
 197			instance.__Stop(dwTimeoutIgnored);
 198		}
 199		
 200		public static void Continue(this ICorDebugAppDomain instance, int fIsOutOfBand)
 201		{
 202			instance.__Continue(fIsOutOfBand);
 203		}
 204		
 205		public static int IsRunning(this ICorDebugAppDomain instance)
 206		{
 207			int pbRunning;
 208			instance.__IsRunning(out pbRunning);
 209			return pbRunning;
 210		}
 211		
 212		public static int HasQueuedCallbacks(this ICorDebugAppDomain instance, ICorDebugThread pThread)
 213		{
 214			int pbQueued;
 215			instance.__HasQueuedCallbacks(pThread, out pbQueued);
 216			return pbQueued;
 217		}
 218		
 219		public static ICorDebugThreadEnum EnumerateThreads(this ICorDebugAppDomain instance)
 220		{
 221			ICorDebugThreadEnum ppThreads;
 222			instance.__EnumerateThreads(out ppThreads);
 223			ProcessOutParameter(ppThreads);
 224			return ppThreads;
 225		}
 226		
 227		public static void SetAllThreadsDebugState(this ICorDebugAppDomain instance, CorDebugThreadState state, ICorDebugThread pExceptThisThread)
 228		{
 229			instance.__SetAllThreadsDebugState(state, pExceptThisThread);
 230		}
 231		
 232		public static void Detach(this ICorDebugAppDomain instance)
 233		{
 234			instance.__Detach();
 235		}
 236		
 237		public static void Terminate(this ICorDebugAppDomain instance, uint exitCode)
 238		{
 239			instance.__Terminate(exitCode);
 240		}
 241		
 242		public static ICorDebugErrorInfoEnum CanCommitChanges(this ICorDebugAppDomain instance, uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
 243		{
 244			ICorDebugErrorInfoEnum pError;
 245			instance.__CanCommitChanges(cSnapshots, ref pSnapshots, out pError);
 246			ProcessOutParameter(pSnapshots);
 247			ProcessOutParameter(pError);
 248			return pError;
 249		}
 250		
 251		public static ICorDebugErrorInfoEnum CommitChanges(this ICorDebugAppDomain instance, uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
 252		{
 253			ICorDebugErrorInfoEnum pError;
 254			instance.__CommitChanges(cSnapshots, ref pSnapshots, out pError);
 255			ProcessOutParameter(pSnapshots);
 256			ProcessOutParameter(pError);
 257			return pError;
 258		}
 259		
 260		public static ICorDebugProcess GetProcess(this ICorDebugAppDomain instance)
 261		{
 262			ICorDebugProcess ppProcess;
 263			instance.__GetProcess(out ppProcess);
 264			ProcessOutParameter(ppProcess);
 265			return ppProcess;
 266		}
 267		
 268		public static ICorDebugAssemblyEnum EnumerateAssemblies(this ICorDebugAppDomain instance)
 269		{
 270			ICorDebugAssemblyEnum ppAssemblies;
 271			instance.__EnumerateAssemblies(out ppAssemblies);
 272			ProcessOutParameter(ppAssemblies);
 273			return ppAssemblies;
 274		}
 275		
 276		public static ICorDebugModule GetModuleFromMetaDataInterface(this ICorDebugAppDomain instance, object pIMetaData)
 277		{
 278			ICorDebugModule ppModule;
 279			instance.__GetModuleFromMetaDataInterface(pIMetaData, out ppModule);
 280			ProcessOutParameter(ppModule);
 281			return ppModule;
 282		}
 283		
 284		public static ICorDebugBreakpointEnum EnumerateBreakpoints(this ICorDebugAppDomain instance)
 285		{
 286			ICorDebugBreakpointEnum ppBreakpoints;
 287			instance.__EnumerateBreakpoints(out ppBreakpoints);
 288			ProcessOutParameter(ppBreakpoints);
 289			return ppBreakpoints;
 290		}
 291		
 292		public static ICorDebugStepperEnum EnumerateSteppers(this ICorDebugAppDomain instance)
 293		{
 294			ICorDebugStepperEnum ppSteppers;
 295			instance.__EnumerateSteppers(out ppSteppers);
 296			ProcessOutParameter(ppSteppers);
 297			return ppSteppers;
 298		}
 299		
 300		public static int IsAttached(this ICorDebugAppDomain instance)
 301		{
 302			int pbAttached;
 303			instance.__IsAttached(out pbAttached);
 304			return pbAttached;
 305		}
 306		
 307		public static void GetName(this ICorDebugAppDomain instance, uint cchName, out uint pcchName, IntPtr szName)
 308		{
 309			instance.__GetName(cchName, out pcchName, szName);
 310		}
 311		
 312		public static ICorDebugValue GetObject(this ICorDebugAppDomain instance)
 313		{
 314			ICorDebugValue ppObject;
 315			instance.__GetObject(out ppObject);
 316			ProcessOutParameter(ppObject);
 317			return ppObject;
 318		}
 319		
 320		public static void Attach(this ICorDebugAppDomain instance)
 321		{
 322			instance.__Attach();
 323		}
 324		
 325		public static uint GetID(this ICorDebugAppDomain instance)
 326		{
 327			uint pId;
 328			instance.__GetID(out pId);
 329			return pId;
 330		}
 331		
 332		public static ICorDebugType GetArrayOrPointerType(this ICorDebugAppDomain2 instance, uint elementType, uint nRank, ICorDebugType pTypeArg)
 333		{
 334			ICorDebugType ppType;
 335			instance.__GetArrayOrPointerType(elementType, nRank, pTypeArg, out ppType);
 336			ProcessOutParameter(ppType);
 337			return ppType;
 338		}
 339		
 340		public static ICorDebugType GetFunctionPointerType(this ICorDebugAppDomain2 instance, uint nTypeArgs, ref ICorDebugType ppTypeArgs)
 341		{
 342			ICorDebugType ppType;
 343			instance.__GetFunctionPointerType(nTypeArgs, ref ppTypeArgs, out ppType);
 344			ProcessOutParameter(ppTypeArgs);
 345			ProcessOutParameter(ppType);
 346			return ppType;
 347		}
 348		
 349		public static void Skip(this ICorDebugAppDomainEnum instance, uint celt)
 350		{
 351			instance.__Skip(celt);
 352		}
 353		
 354		public static void Reset(this ICorDebugAppDomainEnum instance)
 355		{
 356			instance.__Reset();
 357		}
 358		
 359		public static ICorDebugEnum Clone(this ICorDebugAppDomainEnum instance)
 360		{
 361			ICorDebugEnum ppEnum;
 362			instance.__Clone(out ppEnum);
 363			ProcessOutParameter(ppEnum);
 364			return ppEnum;
 365		}
 366		
 367		public static uint GetCount(this ICorDebugAppDomainEnum instance)
 368		{
 369			uint pcelt;
 370			instance.__GetCount(out pcelt);
 371			return pcelt;
 372		}
 373		
 374		public static uint Next(this ICorDebugAppDomainEnum instance, uint celt, IntPtr values)
 375		{
 376			uint pceltFetched;
 377			instance.__Next(celt, values, out pceltFetched);
 378			return pceltFetched;
 379		}
 380		
 381		public static uint GetTheType(this ICorDebugArrayValue instance)
 382		{
 383			uint pType;
 384			instance.__GetType(out pType);
 385			return pType;
 386		}
 387		
 388		public static uint GetSize(this ICorDebugArrayValue instance)
 389		{
 390			uint pSize;
 391			instance.__GetSize(out pSize);
 392			return pSize;
 393		}
 394		
 395		public static ulong GetAddress(this ICorDebugArrayValue instance)
 396		{
 397			ulong pAddress;
 398			instance.__GetAddress(out pAddress);
 399			return pAddress;
 400		}
 401		
 402		public static ICorDebugValueBreakpoint CreateBreakpoint(this ICorDebugArrayValue instance)
 403		{
 404			ICorDebugValueBreakpoint ppBreakpoint;
 405			instance.__CreateBreakpoint(out ppBreakpoint);
 406			ProcessOutParameter(ppBreakpoint);
 407			return ppBreakpoint;
 408		}
 409		
 410		public static int IsValid(this ICorDebugArrayValue instance)
 411		{
 412			int pbValid;
 413			instance.__IsValid(out pbValid);
 414			return pbValid;
 415		}
 416		
 417		public static ICorDebugValueBreakpoint CreateRelocBreakpoint(this ICorDebugArrayValue instance)
 418		{
 419			ICorDebugValueBreakpoint ppBreakpoint;
 420			instance.__CreateRelocBreakpoint(out ppBreakpoint);
 421			ProcessOutParameter(ppBreakpoint);
 422			return ppBreakpoint;
 423		}
 424		
 425		public static uint GetElementType(this ICorDebugArrayValue instance)
 426		{
 427			uint pType;
 428			instance.__GetElementType(out pType);
 429			return pType;
 430		}
 431		
 432		public static uint GetRank(this ICorDebugArrayValue instance)
 433		{
 434			uint pnRank;
 435			instance.__GetRank(out pnRank);
 436			return pnRank;
 437		}
 438		
 439		public static uint GetCount(this ICorDebugArrayValue instance)
 440		{
 441			uint pnCount;
 442			instance.__GetCount(out pnCount);
 443			return pnCount;
 444		}
 445		
 446		public static void GetDimensions(this ICorDebugArrayValue instance, uint cdim, IntPtr dims)
 447		{
 448			instance.__GetDimensions(cdim, dims);
 449		}
 450		
 451		public static int HasBaseIndicies(this ICorDebugArrayValue instance)
 452		{
 453			int pbHasBaseIndicies;
 454			instance.__HasBaseIndicies(out pbHasBaseIndicies);
 455			return pbHasBaseIndicies;
 456		}
 457		
 458		public static void GetBaseIndicies(this ICorDebugArrayValue instance, uint cdim, IntPtr indicies)
 459		{
 460			instance.__GetBaseIndicies(cdim, indicies);
 461		}
 462		
 463		public static ICorDebugValue GetElement(this ICorDebugArrayValue instance, uint cdim, IntPtr indices)
 464		{
 465			ICorDebugValue ppValue;
 466			instance.__GetElement(cdim, indices, out ppValue);
 467			ProcessOutParameter(ppValue);
 468			return ppValue;
 469		}
 470		
 471		public static ICorDebugValue GetElementAtPosition(this ICorDebugArrayValue instance, uint nPosition)
 472		{
 473			ICorDebugValue ppValue;
 474			instance.__GetElementAtPosition(nPosition, out ppValue);
 475			ProcessOutParameter(ppValue);
 476			return ppValue;
 477		}
 478		
 479		public static ICorDebugProcess GetProcess(this ICorDebugAssembly instance)
 480		{
 481			ICorDebugProcess ppProcess;
 482			instance.__GetProcess(out ppProcess);
 483			ProcessOutParameter(ppProcess);
 484			return ppProcess;
 485		}
 486		
 487		public static ICorDebugAppDomain GetAppDomain(this ICorDebugAssembly instance)
 488		{
 489			ICorDebugAppDomain ppAppDomain;
 490			instance.__GetAppDomain(out ppAppDomain);
 491			ProcessOutParameter(ppAppDomain);
 492			return ppAppDomain;
 493		}
 494		
 495		public static ICorDebugModuleEnum EnumerateModules(this ICorDebugAssembly instance)
 496		{
 497			ICorDebugModuleEnum ppModules;
 498			instance.__EnumerateModules(out ppModules);
 499			ProcessOutParameter(ppModules);
 500			return ppModules;
 501		}
 502		
 503		public static void GetCodeBase(this ICorDebugAssembly instance, uint cchName, out uint pcchName, IntPtr szName)
 504		{
 505			instance.__GetCodeBase(cchName, out pcchName, szName);
 506		}
 507		
 508		public static void GetName(this ICorDebugAssembly instance, uint cchName, out uint pcchName, IntPtr szName)
 509		{
 510			instance.__GetName(cchName, out pcchName, szName);
 511		}
 512		
 513		public static int IsFullyTrusted(this ICorDebugAssembly2 instance)
 514		{
 515			int pbFullyTrusted;
 516			instance.__IsFullyTrusted(out pbFullyTrusted);
 517			return pbFullyTrusted;
 518		}
 519		
 520		public static void Skip(this ICorDebugAssemblyEnum instance, uint celt)
 521		{
 522			instance.__Skip(celt);
 523		}
 524		
 525		public static void Reset(this ICorDebugAssemblyEnum instance)
 526		{
 527			instance.__Reset();
 528		}
 529		
 530		public static ICorDebugEnum Clone(this ICorDebugAssemblyEnum instance)
 531		{
 532			ICorDebugEnum ppEnum;
 533			instance.__Clone(out ppEnum);
 534			ProcessOutParameter(ppEnum);
 535			return ppEnum;
 536		}
 537		
 538		public static uint GetCount(this ICorDebugAssemblyEnum instance)
 539		{
 540			uint pcelt;
 541			instance.__GetCount(out pcelt);
 542			return pcelt;
 543		}
 544		
 545		public static uint Next(this ICorDebugAssemblyEnum instance, uint celt, IntPtr values)
 546		{
 547			uint pceltFetched;
 548			instance.__Next(celt, values, out pceltFetched);
 549			return pceltFetched;
 550		}
 551		
 552		public static uint GetTheType(this ICorDebugBoxValue instance)
 553		{
 554			uint pType;
 555			instance.__GetType(out pType);
 556			return pType;
 557		}
 558		
 559		public static uint GetSize(this ICorDebugBoxValue instance)
 560		{
 561			uint pSize;
 562			instance.__GetSize(out pSize);
 563			return pSize;
 564		}
 565		
 566		public static ulong GetAddress(this ICorDebugBoxValue instance)
 567		{
 568			ulong pAddress;
 569			instance.__GetAddress(out pAddress);
 570			return pAddress;
 571		}
 572		
 573		public static ICorDebugValueBreakpoint CreateBreakpoint(this ICorDebugBoxValue instance)
 574		{
 575			ICorDebugValueBreakpoint ppBreakpoint;
 576			instance.__CreateBreakpoint(out ppBreakpoint);
 577			ProcessOutParameter(ppBreakpoint);
 578			return ppBreakpoint;
 579		}
 580		
 581		public static int IsValid(this ICorDebugBoxValue instance)
 582		{
 583			int pbValid;
 584			instance.__IsValid(out pbValid);
 585			return pbValid;
 586		}
 587		
 588		public static ICorDebugValueBreakpoint CreateRelocBreakpoint(this ICorDebugBoxValue instance)
 589		{
 590			ICorDebugValueBreakpoint ppBreakpoint;
 591			instance.__CreateRelocBreakpoint(out ppBreakpoint);
 592			ProcessOutParameter(ppBreakpoint);
 593			return ppBreakpoint;
 594		}
 595		
 596		public static ICorDebugObjectValue GetObject(this ICorDebugBoxValue instance)
 597		{
 598			ICorDebugObjectValue ppObject;
 599			instance.__GetObject(out ppObject);
 600			ProcessOutParameter(ppObject);
 601			return ppObject;
 602		}
 603		
 604		public static void Activate(this ICorDebugBreakpoint instance, int bActive)
 605		{
 606			instance.__Activate(bActive);
 607		}
 608		
 609		public static int IsActive(this ICorDebugBreakpoint instance)
 610		{
 611			int pbActive;
 612			instance.__IsActive(out pbActive);
 613			return pbActive;
 614		}
 615		
 616		public static void Skip(this ICorDebugBreakpointEnum instance, uint celt)
 617		{
 618			instance.__Skip(celt);
 619		}
 620		
 621		public static void Reset(this ICorDebugBreakpointEnum instance)
 622		{
 623			instance.__Reset();
 624		}
 625		
 626		public static ICorDebugEnum Clone(this ICorDebugBreakpointEnum instance)
 627		{
 628			ICorDebugEnum ppEnum;
 629			instance.__Clone(out ppEnum);
 630			ProcessOutParameter(ppEnum);
 631			return ppEnum;
 632		}
 633		
 634		public static uint GetCount(this ICorDebugBreakpointEnum instance)
 635		{
 636			uint pcelt;
 637			instance.__GetCount(out pcelt);
 638			return pcelt;
 639		}
 640		
 641		public static uint Next(this ICorDebugBreakpointEnum instance, uint celt, IntPtr breakpoints)
 642		{
 643			uint pceltFetched;
 644			instance.__Next(celt, breakpoints, out pceltFetched);
 645			return pceltFetched;
 646		}
 647		
 648		public static ICorDebugThread GetThread(this ICorDebugChain instance)
 649		{
 650			ICorDebugThread ppThread;
 651			instance.__GetThread(out ppThread);
 652			ProcessOutParameter(ppThread);
 653			return ppThread;
 654		}
 655		
 656		public static void GetStackRange(this ICorDebugChain instance, out ulong pStart, out ulong pEnd)
 657		{
 658			instance.__GetStackRange(out pStart, out pEnd);
 659		}
 660		
 661		public static ICorDebugContext GetContext(this ICorDebugChain instance)
 662		{
 663			ICorDebugContext ppContext;
 664			instance.__GetContext(out ppContext);
 665			ProcessOutParameter(ppContext);
 666			return ppContext;
 667		}
 668		
 669		public static ICorDebugChain GetCaller(this ICorDebugChain instance)
 670		{
 671			ICorDebugChain ppChain;
 672			instance.__GetCaller(out ppChain);
 673			ProcessOutParameter(ppChain);
 674			return ppChain;
 675		}
 676		
 677		public static ICorDebugChain GetCallee(this ICorDebugChain instance)
 678		{
 679			ICorDebugChain ppChain;
 680			instance.__GetCallee(out ppChain);
 681			ProcessOutParameter(ppChain);
 682			return ppChain;
 683		}
 684		
 685		public static ICorDebugChain GetPrevious(this ICorDebugChain instance)
 686		{
 687			ICorDebugChain ppChain;
 688			instance.__GetPrevious(out ppChain);
 689			ProcessOutParameter(ppChain);
 690			return ppChain;
 691		}
 692		
 693		public static ICorDebugChain GetNext(this ICorDebugChain instance)
 694		{
 695			ICorDebugChain ppChain;
 696			instance.__GetNext(out ppChain);
 697			ProcessOutParameter(ppChain);
 698			return ppChain;
 699		}
 700		
 701		public static int IsManaged(this ICorDebugChain instance)
 702		{
 703			int pManaged;
 704			instance.__IsManaged(out pManaged);
 705			return pManaged;
 706		}
 707		
 708		public static ICorDebugFrameEnum EnumerateFrames(this ICorDebugChain instance)
 709		{
 710			ICorDebugFrameEnum ppFrames;
 711			instance.__EnumerateFrames(out ppFrames);
 712			ProcessOutParameter(ppFrames);
 713			return ppFrames;
 714		}
 715		
 716		public static ICorDebugFrame GetActiveFrame(this ICorDebugChain instance)
 717		{
 718			ICorDebugFrame ppFrame;
 719			instance.__GetActiveFrame(out ppFrame);
 720			ProcessOutParameter(ppFrame);
 721			return ppFrame;
 722		}
 723		
 724		public static ICorDebugRegisterSet GetRegisterSet(this ICorDebugChain instance)
 725		{
 726			ICorDebugRegisterSet ppRegisters;
 727			instance.__GetRegisterSet(out ppRegisters);
 728			ProcessOutParameter(ppRegisters);
 729			return ppRegisters;
 730		}
 731		
 732		public static CorDebugChainReason GetReason(this ICorDebugChain instance)
 733		{
 734			CorDebugChainReason pReason;
 735			instance.__GetReason(out pReason);
 736			ProcessOutParameter(pReason);
 737			return pReason;
 738		}
 739		
 740		public static void Skip(this ICorDebugChainEnum instance, uint celt)
 741		{
 742			instance.__Skip(celt);
 743		}
 744		
 745		public static void Reset(this ICorDebugChainEnum instance)
 746		{
 747			instance.__Reset();
 748		}
 749		
 750		public static ICorDebugEnum Clone(this ICorDebugChainEnum instance)
 751		{
 752			ICorDebugEnum ppEnum;
 753			instance.__Clone(out ppEnum);
 754			ProcessOutParameter(ppEnum);
 755			return ppEnum;
 756		}
 757		
 758		public static uint GetCount(this ICorDebugChainEnum instance)
 759		{
 760			uint pcelt;
 761			instance.__GetCount(out pcelt);
 762			return pcelt;
 763		}
 764		
 765		public static uint Next(this ICorDebugChainEnum instance, uint celt, ICorDebugChain[] chains)
 766		{
 767			uint pceltFetched;
 768			instance.__Next(celt, chains, out pceltFetched);
 769			ProcessOutParameter(chains);
 770			return pceltFetched;
 771		}
 772		
 773		public static ICorDebugModule GetModule(this ICorDebugClass instance)
 774		{
 775			ICorDebugModule pModule;
 776			instance.__GetModule(out pModule);
 777			ProcessOutParameter(pModule);
 778			return pModule;
 779		}
 780		
 781		public static uint GetToken(this ICorDebugClass instance)
 782		{
 783			uint pTypeDef;
 784			instance.__GetToken(out pTypeDef);
 785			return pTypeDef;
 786		}
 787		
 788		public static ICorDebugValue GetStaticFieldValue(this ICorDebugClass instance, uint fieldDef, ICorDebugFrame pFrame)
 789		{
 790			ICorDebugValue ppValue;
 791			instance.__GetStaticFieldValue(fieldDef, pFrame, out ppValue);
 792			ProcessOutParameter(ppValue);
 793			return ppValue;
 794		}
 795		
 796		public static ICorDebugType GetParameterizedType(this ICorDebugClass2 instance, uint elementType, uint nTypeArgs, ICorDebugType[] ppTypeArgs)
 797		{
 798			ICorDebugType ppType;
 799			instance.__GetParameterizedType(elementType, nTypeArgs, ppTypeArgs, out ppType);
 800			ProcessOutParameter(ppTypeArgs);
 801			ProcessOutParameter(ppType);
 802			return ppType;
 803		}
 804		
 805		public static void SetJMCStatus(this ICorDebugClass2 instance, int bIsJustMyCode)
 806		{
 807			instance.__SetJMCStatus(bIsJustMyCode);
 808		}
 809		
 810		public static int IsIL(this ICorDebugCode instance)
 811		{
 812			int pbIL;
 813			instance.__IsIL(out pbIL);
 814			return pbIL;
 815		}
 816		
 817		public static ICorDebugFunction GetFunction(this ICorDebugCode instance)
 818		{
 819			ICorDebugFunction ppFunction;
 820			instance.__GetFunction(out ppFunction);
 821			ProcessOutParameter(ppFunction);
 822			return ppFunction;
 823		}
 824		
 825		public static ulong GetAddress(this ICorDebugCode instance)
 826		{
 827			ulong pStart;
 828			instance.__GetAddress(out pStart);
 829			return pStart;
 830		}
 831		
 832		public static uint GetSize(this ICorDebugCode instance)
 833		{
 834			uint pcBytes;
 835			instance.__GetSize(out pcBytes);
 836			return pcBytes;
 837		}
 838		
 839		public static ICorDebugFunctionBreakpoint CreateBreakpoint(this ICorDebugCode instance, uint offset)
 840		{
 841			ICorDebugFunctionBreakpoint ppBreakpoint;
 842			instance.__CreateBreakpoint(offset, out ppBreakpoint);
 843			ProcessOutParameter(ppBreakpoint);
 844			return ppBreakpoint;
 845		}
 846		
 847		public static uint GetCode(this ICorDebugCode instance, uint startOffset, uint endOffset, uint cBufferAlloc, IntPtr buffer)
 848		{
 849			uint pcBufferSize;
 850			instance.__GetCode(startOffset, endOffset, cBufferAlloc, buffer, out pcBufferSize);
 851			return pcBufferSize;
 852		}
 853		
 854		public static uint GetVersionNumber(this ICorDebugCode instance)
 855		{
 856			uint nVersion;
 857			instance.__GetVersionNumber(out nVersion);
 858			return nVersion;
 859		}
 860		
 861		public static void GetILToNativeMapping(this ICorDebugCode instance, uint cMap, out uint pcMap, IntPtr map)
 862		{
 863			instance.__GetILToNativeMapping(cMap, out pcMap, map);
 864		}
 865		
 866		public static void GetEnCRemapSequencePoints(this ICorDebugCode instance, uint cMap, out uint pcMap, IntPtr offsets)
 867		{
 868			instance.__GetEnCRemapSequencePoints(cMap, out pcMap, offsets);
 869		}
 870		
 871		public static void Skip(this ICorDebugCodeEnum instance, uint celt)
 872		{
 873			instance.__Skip(celt);
 874		}
 875		
 876		public static void Reset(this ICorDebugCodeEnum instance)
 877		{
 878			instance.__Reset();
 879		}
 880		
 881		public static ICorDebugEnum Clone(this ICorDebugCodeEnum instance)
 882		{
 883			ICorDebugEnum ppEnum;
 884			instance.__Clone(out ppEnum);
 885			ProcessOutParameter(ppEnum);
 886			return ppEnum;
 887		}
 888		
 889		public static uint GetCount(this ICorDebugCodeEnum instance)
 890		{
 891			uint pcelt;
 892			instance.__GetCount(out pcelt);
 893			return pcelt;
 894		}
 895		
 896		public static uint Next(this ICorDebugCodeEnum instance, uint celt, IntPtr values)
 897		{
 898			uint pceltFetched;
 899			instance.__Next(celt, values, out pceltFetched);
 900			return pceltFetched;
 901		}
 902		
 903		public static uint GetTheType(this ICorDebugContext instance)
 904		{
 905			uint pType;
 906			instance.__GetType(out pType);
 907			return pType;
 908		}
 909		
 910		public static uint GetSize(this ICorDebugContext instance)
 911		{
 912			uint pSize;
 913			instance.__GetSize(out pSize);
 914			return pSize;
 915		}
 916		
 917		public static ulong GetAddress(this ICorDebugContext instance)
 918		{
 919			ulong pAddress;
 920			instance.__GetAddress(out pAddress);
 921			return pAddress;
 922		}
 923		
 924		public static ICorDebugValueBreakpoint CreateBreakpoint(this ICorDebugContext instance)
 925		{
 926			ICorDebugValueBreakpoint ppBreakpoint;
 927			instance.__CreateBreakpoint(out ppBreakpoint);
 928			ProcessOutParameter(ppBreakpoint);
 929			return ppBreakpoint;
 930		}
 931		
 932		public static ICorDebugClass GetClass(this ICorDebugContext instance)
 933		{
 934			ICorDebugClass ppClass;
 935			instance.__GetClass(out ppClass);
 936			ProcessOutParameter(ppClass);
 937			return ppClass;
 938		}
 939		
 940		public static ICorDebugValue GetFieldValue(this ICorDebugContext instance, ICorDebugClass pClass, uint fieldDef)
 941		{
 942			ICorDebugValue ppValue;
 943			instance.__GetFieldValue(pClass, fieldDef, out ppValue);
 944			ProcessOutParameter(ppValue);
 945			return ppValue;
 946		}
 947		
 948		public static ICorDebugFunction GetVirtualMethod(this ICorDebugContext instance, uint memberRef)
 949		{
 950			ICorDebugFunction ppFunction;
 951			instance.__GetVirtualMethod(memberRef, out ppFunction);
 952			ProcessOutParameter(ppFunction);
 953			return ppFunction;
 954		}
 955		
 956		public static ICorDebugContext GetContext(this ICorDebugContext instance)
 957		{
 958			ICorDebugContext ppContext;
 959			instance.__GetContext(out ppContext);
 960			ProcessOutParameter(ppContext);
 961			return ppContext;
 962		}
 963		
 964		public static int IsValueClass(this ICorDebugContext instance)
 965		{
 966			int pbIsValueClass;
 967			instance.__IsValueClass(out pbIsValueClass);
 968			return pbIsValueClass;
 969		}
 970		
 971		public static object GetManagedCopy(this ICorDebugContext instance)
 972		{
 973			object ppObject;
 974			instance.__GetManagedCopy(out ppObject);
 975			ProcessOutParameter(ppObject);
 976			return ppObject;
 977		}
 978		
 979		public static void SetFromManagedCopy(this ICorDebugContext instance, object pObject)
 980		{
 981			instance.__SetFromManagedCopy(pObject);
 982		}
 983		
 984		public static void Stop(this ICorDebugController instance, uint dwTimeoutIgnored)
 985		{
 986			instance.__Stop(dwTimeoutIgnored);
 987		}
 988		
 989		public static void Continue(this ICorDebugController instance, int fIsOutOfBand)
 990		{
 991			instance.__Continue(fIsOutOfBand);
 992		}
 993		
 994		public static int IsRunning(this ICorDebugController instance)
 995		{
 996			int pbRunning;
 997			instance.__IsRunning(out pbRunning);
 998			return pbRunning;
 999		}
1000		
1001		public static int HasQueuedCallbacks(this ICorDebugController instance, ICorDebugThread pThread)
1002		{
1003			int pbQueued;
1004			instance.__HasQueuedCallbacks(pThread, out pbQueued);
1005			return pbQueued;
1006		}
1007		
1008		public static ICorDebugThreadEnum EnumerateThreads(this ICorDebugController instance)
1009		{
1010			ICorDebugThreadEnum ppThreads;
1011			instance.__EnumerateThreads(out ppThreads);
1012			ProcessOutParameter(ppThreads);
1013			return ppThreads;
1014		}
1015		
1016		public static void SetAllThreadsDebugState(this ICorDebugController instance, CorDebugThreadState state, ICorDebugThread pExceptThisThread)
1017		{
1018			instance.__SetAllThreadsDebugState(state, pExceptThisThread);
1019		}
1020		
1021		public static void Detach(this ICorDebugController instance)
1022		{
1023			instance.__Detach();
1024		}
1025		
1026		public static void Terminate(this ICorDebugController instance, uint exitCode)
1027		{
1028			instance.__Terminate(exitCode);
1029		}
1030		
1031		public static ICorDebugErrorInfoEnum CanCommitChanges(this ICorDebugController instance, uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
1032		{
1033			ICorDebugErrorInfoEnum pError;
1034			instance.__CanCommitChanges(cSnapshots, ref pSnapshots, out pError);
1035			ProcessOutParameter(pSnapshots);
1036			ProcessOutParameter(pError);
1037			return pError;
1038		}
1039		
1040		public static ICorDebugErrorInfoEnum CommitChanges(this ICorDebugController instance, uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
1041		{
1042			ICorDebugErrorInfoEnum pError;
1043			instance.__CommitChanges(cSnapshots, ref pSnapshots, out pError);
1044			ProcessOutParameter(pSnapshots);
1045			ProcessOutParameter(pError);
1046			return pError;
1047		}
1048		
1049		public static Guid CopyMetaData(this ICorDebugEditAndContinueSnapshot instance, IStream pIStream)
1050		{
1051			Guid pMvid;
1052			instance.__CopyMetaData(pIStream, out pMvid);
1053			return pMvid;
1054		}
1055		
1056		public static Guid GetMvid(this ICorDebugEditAndContinueSnapshot instance)
1057		{
1058			Guid pMvid;
1059			instance.__GetMvid(out pMvid);
1060			return pMvid;
1061		}
1062		
1063		public static uint GetRoDataRVA(this ICorDebugEditAndContinueSnapshot instance)
1064		{
1065			uint pRoDataRVA;
1066			instance.__GetRoDataRVA(out pRoDataRVA);
1067			return pRoDataRVA;
1068		}
1069		
1070		public static uint GetRwDataRVA(this ICorDebugEditAndContinueSnapshot instance)
1071		{
1072			uint pRwDataRVA;
1073			instance.__GetRwDataRVA(out pRwDataRVA);
1074			return pRwDataRVA;
1075		}
1076		
1077		public static void SetPEBytes(this ICorDebugEditAndContinueSnapshot instance, IStream pIStream)
1078		{
1079			instance.__SetPEBytes(pIStream);
1080		}
1081		
1082		public static void SetILMap(this ICorDebugEditAndContinueSnapshot instance, uint mdFunction, uint cMapSize, ref _COR_IL_MAP map)
1083		{
1084			instance.__SetILMap(mdFunction, cMapSize, ref map);
1085			ProcessOutParameter(map);
1086		}
1087		
1088		public static void SetPESymbolBytes(this ICorDebugEditAndContinueSnapshot instance, IStream pIStream)
1089		{
1090			instance.__SetPESymbolBytes(pIStream);
1091		}
1092		
1093		public static void Skip(this ICorDebugEnum instance, uint celt)
1094		{
1095			instance.__Skip(celt);
1096		}
1097		
1098		public static void Reset(this ICorDebugEnum instance)
1099		{
1100			instance.__Reset();
1101		}
1102		
1103		public static ICorDebugEnum Clone(this ICorDebugEnum instance)
1104		{
1105			ICorDebugEnum ppEnum;
1106			instance.__Clone(out ppEnum);
1107			ProcessOutParameter(ppEnum);
1108			return ppEnum;
1109		}
1110		
1111		public static uint GetCount(this ICorDebugEnum instance)
1112		{
1113			uint pcelt;
1114			instance.__GetCount(out pcelt);
1115			return pcelt;
1116		}
1117		
1118		public static void Skip(this ICorDebugErrorInfoEnum instance, uint celt)
1119		{
1120			instance.__Skip(celt);
1121		}
1122		
1123		public static void Reset(this ICorDebugErrorInfoEnum instance)
1124		{
1125			instance.__Reset();
1126		}
1127		
1128		public static ICorDebugEnum Clone(this ICorDebugErrorInfoEnum instance)
1129		{
1130			ICorDebugEnum ppEnum;
1131			instance.__Clone(out ppEnum);
1132			ProcessOutParameter(ppEnum);
1133			return ppEnum;
1134		}
1135		
1136		public static uint GetCount(this ICorDebugErrorInfoEnum instance)
1137		{
1138			uint pcelt;
1139			instance.__GetCount(out pcelt);
1140			return pcelt;
1141		}
1142		
1143		public static uint Next(this ICorDebugErrorInfoEnum instance, uint celt, IntPtr errors)
1144		{
1145			uint pceltFetched;
1146			instance.__Next(celt, errors, out pceltFetched);
1147			return pceltFetched;
1148		}
1149		
1150		public static void CallFunction(this ICorDebugEval instance, ICorDebugFunction pFunction, uint nArgs, ICorDebugValue[] ppArgs)
1151		{
1152			instance.__CallFunction(pFunction, nArgs, ppArgs);
1153			ProcessOutParameter(ppArgs);
1154		}
1155		
1156		public static void NewObject(this ICorDebugEval instance, ICorDebugFunction pConstructor, uint nArgs, ref ICorDebugValue ppArgs)
1157		{
1158			instance.__NewObject(pConstructor, nArgs, ref ppArgs);
1159			ProcessOutParameter(ppArgs);
1160		}
1161		
1162		public static void NewObjectNoConstructor(this ICorDebugEval instance, ICorDebugClass pClass)
1163		{
1164			instance.__NewObjectNoConstructor(pClass);
1165		}
1166		
1167		public static void NewString(this ICorDebugEval instance, string @string)
1168		{
1169			instance.__NewString(@string);
1170		}
1171		
1172		public static void NewArray(this ICorDebugEval instance, uint elementType, ICorDebugClass pElementClass, uint rank, ref uint dims, ref uint lowBounds)
1173		{
1174			instance.__NewArray(elementType, pElementClass, rank, ref dims, ref lowBounds);
1175		}
1176		
1177		public static int IsActive(this ICorDebugEval instance)
1178		{
1179			int pbActive;
1180			instance.__IsActive(out pbActive);
1181			return pbActive;
1182		}
1183		
1184		public static void Abort(this ICorDebugEval instance)
1185		{
1186			instance.__Abort();
1187		}
1188		
1189		public static ICorDebugValue GetResult(this ICorDebugEval instance)
1190		{
1191			ICorDebugValue ppResult;
1192			instance.__GetResult(out ppResult);
1193			ProcessOutParameter(ppResult);
1194			return ppResult;
1195		}
1196		
1197		public static ICorDebugThread GetThread(this ICorDebugEval instance)
1198		{
1199			ICorDebugThread ppThread;
1200			instance.__GetThread(out ppThread);
1201			ProcessOutParameter(ppThread);
1202			return ppThread;
1203		}
1204		
1205		public static ICorDebugValue CreateValue(this ICorDebugEval instance, uint elementType, ICorDebugClass pElementClass)
1206		{
1207			ICorDebugValue ppValue;
1208			instance.__CreateValue(elementType, pElementClass, out ppValue);
1209			ProcessOutParameter(ppValue);
1210			return ppValue;
1211		}
1212		
1213		public static void CallParameterizedFunction(this ICorDebugEval2 instance, ICorDebugFunction pFunction, uint nTypeArgs, ICorDebugType[] ppTypeArgs, uint nArgs, ICorDebugValue[] ppArgs)
1214		{
1215			instance.__CallParameterizedFunction(pFunction, nTypeArgs, ppTypeArgs, nArgs, ppArgs);
1216			ProcessOutParameter(ppTypeArgs);
1217			ProcessOutParameter(ppArgs);
1218		}
1219		
1220		public static ICorDebugValue CreateValueForType(this ICorDebugEval2 instance, ICorDebugType pType)
1221		{
1222			ICorDebugValue ppValue;
1223			instance.__CreateValueForType(pType, out ppValue);
1224			ProcessOutParameter(ppValue);
1225			return ppValue;
1226		}
1227		
1228		public static void NewParameterizedObject(this ICorDebugEval2 instance, ICorDebugFunction pConstructor, uint nTypeArgs, ICorDebugType[] ppTypeArgs, uint nArgs, ICorDebugValue[] ppArgs)
1229		{
1230			instance.__NewParameterizedObject(pConstructor, nTypeArgs, ppTypeArgs, nArgs, ppArgs);
1231			ProcessOutParameter(ppTypeArgs);
1232			ProcessOutParameter(ppArgs);
1233		}
1234		
1235		public static void NewParameterizedObjectNoConstructor(this ICorDebugEval2 instance, ICorDebugClass pClass, uint nTypeArgs, ICorDebugType[] ppTypeArgs)
1236		{
1237			instance.__NewParameterizedObjectNoConstructor(pClass, nTypeArgs, ppTypeArgs);
1238			ProcessOutParameter(ppTypeArgs);
1239		}
1240		
1241		public static void NewParameterizedArray(this ICorDebugEval2 instance, ICorDebugType pElementType, uint rank, uint[] dims, uint[] lowBounds)
1242		{
1243			instance.__NewParameterizedArray(pElementType, rank, dims, lowBounds);
1244		}
1245		
1246		public static void NewStringWithLength(this ICorDebugEval2 instance, string @string, uint uiLength)
1247		{
1248			instance.__NewStringWithLength(@string, uiLength);
1249		}
1250		
1251		public static void RudeAbort(this ICorDebugEval2 instance)
1252		{
1253			instance.__RudeAbort();
1254		}
1255		
1256		public static ICorDebugChain GetChain(this ICorDebugFrame instance)
1257		{
1258			ICorDebugChain ppChain;
1259			instance.__GetChain(out ppChain);
1260			ProcessOutParameter(ppChain);
1261			return ppChain;
1262		}
1263		
1264		public static ICorDebugCode GetCode(this ICorDebugFrame instance)
1265		{
1266			ICorDebugCode ppCode;
1267			instance.__GetCode(out ppCode);
1268			ProcessOutParameter(ppCode);
1269			return ppCode;
1270		}
1271		
1272		public static ICorDebugFunction GetFunction(this ICorDebugFrame instance)
1273		{
1274			ICorDebugFunction ppFunction;
1275			instance.__GetFunction(out ppFunction);
1276			ProcessOutParameter(ppFunction);
1277			return ppFunction;
1278		}
1279		
1280		public static uint GetFunctionToken(this ICorDebugFrame instance)
1281		{
1282			uint pToken;
1283			instance.__GetFunctionToken(out pToken);
1284			return pToken;
1285		}
1286		
1287		public static void GetStackRange(this ICorDebugFrame instance, out ulong pStart, out ulong pEnd)
1288		{
1289			instance.__GetStackRange(out pStart, out pEnd);
1290		}
1291		
1292		public static ICorDebugFrame GetCaller(this ICorDebugFrame instance)
1293		{
1294			ICorDebugFrame ppFrame;
1295			instance.__GetCaller(out ppFrame);
1296			ProcessOutParameter(ppFrame);
1297			return ppFrame;
1298		}
1299		
1300		public static ICorDebugFrame GetCallee(this ICorDebugFrame instance)
1301		{
1302			ICorDebugFrame ppFrame;
1303			instance.__GetCallee(out ppFrame);
1304			ProcessOutParameter(ppFrame);
1305			return ppFrame;
1306		}
1307		
1308		public static ICorDebugStepper CreateStepper(this ICorDebugFrame instance)
1309		{
1310			ICorDebugStepper ppStepper;
1311			instance.__CreateStepper(out ppStepper);
1312			ProcessOutParameter(ppStepper);
1313			return ppStepper;
1314		}
1315		
1316		public static void Skip(this ICorDebugFrameEnum instance, uint celt)
1317		{
1318			instance.__Skip(celt);
1319		}
1320		
1321		public static void Reset(this ICorDebugFrameEnum instance)
1322		{
1323			instance.__Reset();
1324		}
1325		
1326		public static ICorDebugEnum Clone(this ICorDebugFrameEnum instance)
1327		{
1328			ICorDebugEnum ppEnum;
1329			instance.__Clone(out ppEnum);
1330			ProcessOutParameter(ppEnum);
1331			return ppEnum;
1332		}
1333		
1334		public static uint GetCount(this ICorDebugFrameEnum instance)
1335		{
1336			uint pcelt;
1337			instance.__GetCount(out pcelt);
1338			return pcelt;
1339		}
1340		
1341		public static uint Next(this ICorDebugFrameEnum instance, uint celt, ICorDebugFrame[] frames)
1342		{
1343			uint pceltFetched;
1344			instance.__Next(celt, frames, out pceltFetched);
1345			ProcessOutParameter(frames);
1346			return pceltFetched;
1347		}
1348		
1349		public static ICorDebugModule GetModule(this ICorDebugFunction instance)
1350		{
1351			ICorDebugModule ppModule;
1352			instance.__GetModule(out ppModule);
1353			ProcessOutParameter(ppModule);
1354			return ppModule;
1355		}
1356		
1357		public static ICorDebugClass GetClass(this ICorDebugFunction instance)
1358		{
1359			ICorDebugClass ppClass;
1360			instance.__GetClass(out ppClass);
1361			ProcessOutParameter(ppClass);
1362			return ppClass;
1363		}
1364		
1365		public static uint GetToken(this ICorDebugFunction instance)
1366		{
1367			uint pMethodDef;
1368			instance.__GetToken(out pMethodDef);
1369			return pMethodDef;
1370		}
1371		
1372		public static ICorDebugCode GetILCode(this ICorDebugFunction instance)
1373		{
1374			ICorDebugCode ppCode;
1375			instance.__GetILCode(out ppCode);
1376			ProcessOutParameter(ppCode);
1377			return ppCode;
1378		}
1379		
1380		public static ICorDebugCode GetNativeCode(this ICorDebugFunction instance)
1381		{
1382			ICorDebugCode ppCode;
1383			instance.__GetNativeCode(out ppCode);
1384			ProcessOutParameter(ppCode);
1385			return ppCode;
1386		}
1387		
1388		public static ICorDebugFunctionBreakpoint CreateBreakpoint(this ICorDebugFunction instance)
1389		{
1390			ICorDebugFunctionBreakpoint ppBreakpoint;
1391			instance.__CreateBreakpoint(out ppBreakpoint);
1392			ProcessOutParameter(ppBreakpoint);
1393			return ppBreakpoint;
1394		}
1395		
1396		public static uint GetLocalVarSigToken(this ICorDebugFunction instance)
1397		{
1398			uint pmdSig;
1399			instance.__GetLocalVarSigToken(out pmdSig);
1400			return pmdSig;
1401		}
1402		
1403		public static uint GetCurrentVersionNumber(this ICorDebugFunction instance)
1404		{
1405			uint pnCurrentVersion;
1406			instance.__GetCurrentVersionNumber(out pnCurrentVersion);
1407			return pnCurrentVersion;
1408		}
1409		
1410		public static void SetJMCStatus(this ICorDebugFunction2 instance, int bIsJustMyCode)
1411		{
1412			instance.__SetJMCStatus(bIsJustMyCode);
1413		}
1414		
1415		public static int GetJMCStatus(this ICorDebugFunction2 instance)
1416		{
1417			int pbIsJustMyCode;
1418			instance.__GetJMCStatus(out pbIsJustMyCode);
1419			return pbIsJustMyCode;
1420		}
1421		
1422		public static ICorDebugCodeEnum EnumerateNativeCode(this ICorDebugFunction2 instance)
1423		{
1424			ICorDebugCodeEnum ppCodeEnum;
1425			instance.__EnumerateNativeCode(out ppCodeEnum);
1426			ProcessOutParameter(ppCodeEnum);
1427			return ppCodeEnum;
1428		}
1429		
1430		public static uint GetVersionNumber(this ICorDebugFunction2 instance)
1431		{
1432			uint pnVersion;
1433			instance.__GetVersionNumber(out pnVersion);
1434			return pnVersion;
1435		}
1436		
1437		public static void Activate(this ICorDebugFunctionBreakpoint instance, int bActive)
1438		{
1439			instance.__Activate(bActive);
1440		}
1441		
1442		public static int IsActive(this ICorDebugFunctionBreakpoint instance)
1443		{
1444			int pbActive;
1445			instance.__IsActive(out pbActive);
1446			return pbActive;
1447		}
1448		
1449		public static ICorDebugFunction GetFunction(this ICorDebugFunctionBreakpoint instance)
1450		{
1451			ICorDebugFunction ppFunction;
1452			instance.__GetFunction(out ppFunction);
1453			ProcessOutParameter(ppFunction);
1454			return ppFunction;
1455		}
1456		
1457		public static uint GetOffset(this ICorDebugFunctionBreakpoint instance)
1458		{
1459			uint pnOffset;
1460			instance.__GetOffset(out pnOffset);
1461			return pnOffset;
1462		}
1463		
1464		public static uint GetTheType(this ICorDebugGenericValue instance)
1465		{
1466			uint pType;
1467			instance.__GetType(out pType);
1468			return pType;
1469		}
1470		
1471		public static uint GetSize(this ICorDebugGenericValue instance)
1472		{
1473			uint pSize;
1474			instance.__GetSize(out pSize);
1475			return pSize;
1476		}
1477		
1478		public static ulong GetAddress(this ICorDebugGenericValue instance)
1479		{
1480			ulong pAddress;
1481			instance.__GetAddress(out pAddress);
1482			return pAddress;
1483		}
1484		
1485		public static ICorDebugValueBreakpoint CreateBreakpoint(this ICorDebugGenericValue instance)
1486		{
1487			ICorDebugValueBreakpoint ppBreakpoint;
1488			instance.__CreateBreakpoint(out ppBreakpoint);
1489			ProcessOutParameter(ppBreakpoint);
1490			return ppBreakpoint;
1491		}
1492		
1493		public static void GetValue(this ICorDebugGenericValue instance, IntPtr pTo)
1494		{
1495			instance.__GetValue(pTo);
1496		}
1497		
1498		public static void SetValue(this ICorDebugGenericValue instance, IntPtr pFrom)
1499		{
1500			instance.__SetValue(pFrom);
1501		}
1502		
1503		public static uint GetTheType(this ICorDebugHandleValue instance)
1504		{
1505			uint pType;
1506			instance.__GetType(out pType);
1507			return pType;
1508		}
1509		
1510		public static uint GetSize(this ICorDebugHandleValue instance)
1511		{
1512			uint pSize;
1513			instance.__GetSize(out pSize);
1514			return pSize;
1515		}
1516		
1517		public static ulong GetAddress(this ICorDebugHandleValue instance)
1518		{
1519			ulong pAddress;
1520			instance.__GetAddress(out pAddress);
1521			return pAddress;
1522		}
1523		
1524		public static ICorDebugValueBreakpoint CreateBreakpoint(this ICorDebugHandleValue instance)
1525		{
1526			ICorDebugValueBreakpoint ppBreakpoint;
1527			instance.__CreateBreakpoint(out ppBreakpoint);
1528			ProcessOutParameter(ppBreakpoint);
1529			return ppBreakpoint;
1530		}
1531		
1532		public static int IsNull(this ICorDebugHandleValue instance)
1533		{
1534			int pbNull;
1535			instance.__IsNull(out pbNull);
1536			return pbNull;
1537		}
1538		
1539		public static ulong GetValue(this ICorDebugHandleValue instance)
1540		{
1541			ulong pValue;
1542			instance.__GetValue(out pValue);
1543			return pValue;
1544		}
1545		
1546		public static void SetValue(this ICorDebugHandleValue instance, ulong value)
1547		{
1548			instance.__SetValue(value);
1549		}
1550		
1551		public static ICorDebugValue Dereference(this ICorDebugHandleValue instance)
1552		{
1553			ICorDebugValue ppValue;
1554			instance.__Dereference(out ppValue);
1555			ProcessOutParameter(ppValue);
1556			return ppValue;
1557		}
1558		
1559		public static ICorDebugValue DereferenceStrong(this ICorDebugHandleValue instance)
1560		{
1561			ICorDebugValue ppValue;
1562			instance.__DereferenceStrong(out ppValue);
1563			ProcessOutParameter(ppValue);
1564			return ppValue;
1565		}
1566		
1567		public static CorDebugHandleType GetHandleType(this ICorDebugHandleValue instance)
1568		{
1569			CorDebugHandleType pType;
1570			instance.__GetHandleType(out pType);
1571			ProcessOutParameter(pType);
1572			return pType;
1573		}
1574		
1575		public static void Dispose(this ICorDebugHandleValue instance)
1576		{
1577			instance.__Dispose();
1578		}
1579		
1580		public static uint GetTheType(this ICorDebugHeapValue instance)
1581		{
1582			uint pType;
1583			instance.__GetType(out pType);
1584			return pType;
1585		}
1586		
1587		public static uint GetSize(this ICorDebugHeapValue instance)
1588		{
1589			uint pSize;
1590			instance.__GetSize(out pSize);
1591			return pSize;
1592		}
1593		
1594		public static ulong GetAddress(this ICorDebugHeapValue instance)
1595		{
1596			ulong pAddress;
1597			instance.__GetAddress(out pAddress);
1598			return pAddress;
1599		}
1600		
1601		public static ICorDebugValueBreakpoint CreateBreakpoint(this ICorDebugHeapValue instance)
1602		{
1603			ICorDebugValueBreakpoint ppBreakpoint;
1604			instance.__CreateBreakpoint(out ppBreakpoint);
1605			ProcessOutParameter(ppBreakpoint);
1606			return ppBreakpoint;
1607		}
1608		
1609		public static int IsValid(this ICorDebugHeapValue instance)
1610		{
1611			int pbValid;
1612			instance.__IsValid(out pbValid);
1613			return pbValid;
1614		}
1615		
1616		public static ICorDebugValueBreakpoint CreateRelocBreakpoint(this ICorDebugHeapValue instance)
1617		{
1618			ICorDebugValueBreakpoint ppBreakpoint;
1619			instance.__CreateRelocBreakpoint(out ppBreakpoint);
1620			ProcessOutParameter(ppBreakpoint);
1621			return ppBreakpoint;
1622		}
1623		
1624		public static ICorDebugHandleValue CreateHandle(this ICorDebugHeapValue2 instance, CorDebugHandleType type)
1625		{
1626			ICorDebugHandleValue ppHandle;
1627			instance.__CreateHandle(type, out ppHandle);
1628			ProcessOutParameter(ppHandle);
1629			return ppHandle;
1630		}
1631		
1632		public static ICorDebugChain GetChain(this ICorDebugILFrame instance)
1633		{
1634			ICorDebugChain ppChain;
1635			instance.__GetChain(out ppChain);
1636			ProcessOutParameter(ppChain);
1637			return ppChain;
1638		}
1639		
1640		public static ICorDebugCode GetCode(this ICorDebugILFrame instance)
1641		{
1642			ICorDebugCode ppCode;
1643			instance.__GetCode(out ppCode);
1644			ProcessOutParameter(ppCode);
1645			return ppCode;
1646		}
1647		
1648		public static ICorDebugFunction GetFunction(this ICorDebugILFrame instance)
1649		{
1650			ICorDebugFunction ppFunction;
1651			instance.__GetFunction(out ppFunction);
1652			ProcessOutParameter(ppFunction);
1653			return ppFunction;
1654		}
1655		
1656		public static uint GetFunctionToken(this ICorDebugILFrame instance)
1657		{
1658			uint pToken;
1659			instance.__GetFunctionToken(out pToken);
1660			return pToken;
1661		}
1662		
1663		public static void GetStackRange(this ICorDebugILFrame instance, out ulong pStart, out ulong pEnd)
1664		{
1665			instance.__GetStackRange(out pStart, out pEnd);
1666		}
1667		
1668		public static ICorDebugFrame GetCaller(this ICorDebugILFrame instance)
1669		{
1670			ICorDebugFrame ppFrame;
1671			instance.__GetCaller(out ppFrame);
1672			ProcessOutParameter(ppFrame);
1673			return ppFrame;
1674		}
1675		
1676		public static ICorDebugFrame GetCallee(this ICorDebugILFrame instance)
1677		{
1678			ICorDebugFrame ppFrame;
1679			instance.__GetCallee(out ppFrame);
1680			ProcessOutParameter(ppFrame);
1681			return ppFrame;
1682		}
1683		
1684		public static ICorDebugStepper CreateStepper(this ICorDebugILFrame instance)
1685		{
1686			ICorDebugStepper ppStepper;
1687			instance.__CreateStepper(out ppStepper);
1688			ProcessOutParameter(ppStepper);
1689			return ppStepper;
1690		}
1691		
1692		public static void GetIP(this ICorDebugILFrame instance, out uint pnOffset, out CorDebugMappingResult pMappingResult)
1693		{
1694			instance.__GetIP(out pnOffset, out pMappingResult);
1695			ProcessOutParameter(pMappingResult);
1696		}
1697		
1698		public static void SetIP(this ICorDebugILFrame instance, uint nOffset)
1699		{
1700			instance.__SetIP(nOffset);
1701		}
1702		
1703		public static ICorDebugValueEnum EnumerateLocalVariables(this ICorDebugILFrame instance)
1704		{
1705			ICorDebugValueEnum ppValueEnum;
1706			instance.__EnumerateLocalVariables(out ppValueEnum);
1707			ProcessOutParameter(ppValueEnum);
1708			return ppValueEnum;
1709		}
1710		
1711		public static ICorDebugValue GetLocalVariable(this ICorDebugILFrame instance, uint dwIndex)
1712		{
1713			ICorDebugValue ppValue;
1714			instance.__GetLocalVariable(dwIndex, out ppValue);
1715			ProcessOutParameter(ppValue);
1716			return ppValue;
1717		}
1718		
1719		public static ICorDebugValueEnum EnumerateArguments(this ICorDebugILFrame instance)
1720		{
1721			ICorDebugValueEnum ppValueEnum;
1722			instance.__EnumerateArguments(out ppValueEnum);
1723			ProcessOutParameter(ppValueEnum);
1724			return ppValueEnum;
1725		}
1726		
1727		public static ICorDebugValue GetArgument(this ICorDebugILFrame instance, uint dwIndex)
1728		{
1729			ICorDebugValue ppValue;
1730			instance.__GetArgument(dwIndex, out ppValue);
1731			ProcessOutParameter(ppValue);
1732			return ppValue;
1733		}
1734		
1735		public static uint GetStackDepth(this ICorDebugILFrame instance)
1736		{
1737			uint pDepth;
1738			instance.__GetStackDepth(out pDepth);
1739			return pDepth;
1740		}
1741		
1742		public static ICorDebugValue GetStackValue(this ICorDebugILFrame instance, uint dwIndex)
1743		{
1744			ICorDebugValue ppValue;
1745			instance.__GetStackValue(dwIndex, out ppValue);
1746			ProcessOutParameter(ppValue);
1747			return ppValue;
1748		}
1749		
1750		public static void CanSetIP(this ICorDebugILFrame instance, uint nOffset)
1751		{
1752			instance.__CanSetIP(nOffset);
1753		}
1754		
1755		public static void RemapFunction(this ICorDebugILFrame2 instance, uint newILOffset)
1756		{
1757			instance.__RemapFunction(newILOffset);
1758		}
1759		
1760		public static ICorDebugTypeEnum EnumerateTypeParameters(this ICorDebugILFrame2 instance)
1761		{
1762			ICorDebugTypeEnum ppTyParEnum;
1763			instance.__EnumerateTypeParameters(out ppTyParEnum);
1764			ProcessOutParameter(ppTyParEnum);
1765			return ppTyParEnum;
1766		}
1767		
1768		public static ICorDebugChain GetChain(this ICorDebugInternalFrame instance)
1769		

Large files files are truncated, but you can click here to view the full file