////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int EnumModules (out IEnumDebugModules2 ppEnum)
{
//
// Enumerates the modules that this program has loaded and is executing.
//
LoggingUtils.PrintFunction ();
try
{
List<IDebugModule2> modules = new List<IDebugModule2> ();
foreach (DebuggeeModule module in m_debugModules.Values)
{
modules.Add (module as IDebugModule2);
}
ppEnum = new DebuggeeModule.Enumerator (modules);
if (ppEnum == null)
{
throw new InvalidOperationException ();
}
return Constants.S_OK;
}
catch (Exception e)
{
LoggingUtils.HandleException (e);
ppEnum = null;
return Constants.E_FAIL;
}
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
ppEnum = new AD7ModuleEnum(new[] { mModule });
return(VSConstants.S_OK);
}
// Token: 0x06000177 RID: 375 RVA: 0x00005FC8 File Offset: 0x000041C8
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
AssemblyMirror[] assemblies = this.Session.VirtualMachine.RootDomain.GetAssemblies();
ppEnum = new AD7ModuleEnum((from a in assemblies
select new AD7Module(a, this.startInfo)).ToArray <AD7Module>());
return(0);
}
/// <summary>
/// Retrieves a list of the modules that this program has loaded and is executing.
/// (http://msdn.microsoft.com/en-us/library/bb146980.aspx)
/// </summary>
/// <param name="ppEnum"> Returns an IEnumDebugModules2 object that contains a list of the modules. </param>
/// <returns> VSConstants.S_OK. </returns>
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
// Setting ppEnum to null because we are not adding/working with this feature now. It was causing an error
// when opening Threads Window and ppEnum = new AD7ModuleEnum(new[] { m_module }).
ppEnum = null;
return(VSConstants.S_OK);
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
DebugHelper.TraceEnteringMethod();
var assemblies = DebuggedProcess.GetLoadedAssemblies();
ppEnum = new AD7ModuleEnum(assemblies);
return(VSConstants.S_OK);
}
public int EnumModules(out IEnumDebugModules2 modulesEnum)
{
var sbModules = GetSbModules();
_debugModuleCache.RemoveAllExcept(sbModules);
var modules = sbModules.Select(m => _debugModuleCache.GetOrCreate(m, Self));
modulesEnum = _moduleEnumFactory.Create(modules);
return(VSConstants.S_OK);
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
DebuggedModule[] modules = _debuggedProcess.GetModules();
AD7Module[] moduleObjects = modules.Select(backendModule => backendModule.Client as AD7Module)
.Where(ad7Module => ad7Module != null) // Ignore any modules that we haven't quite sent the module load event for
.ToArray();
ppEnum = new Microsoft.MIDebugEngine.AD7ModuleEnum(moduleObjects);
return(Constants.S_OK);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
//
// Enumerates the modules that this program has loaded and is executing.
//
LoggingUtils.PrintFunction();
ppEnum = null;
try
{
List <IDebugModule2> modules = new List <IDebugModule2> ();
uint count;
{
LoggingUtils.RequireOk(AttachedEngine.NativeDebugger.NativeProgram.EnumModules(out ppEnum));
LoggingUtils.RequireOk(ppEnum.GetCount(out count));
IDebugModule2 [] moduleArray = new IDebugModule2 [count];
LoggingUtils.RequireOk(ppEnum.Next(count, moduleArray, ref count));
modules.AddRange(moduleArray);
}
{
LoggingUtils.RequireOk(AttachedEngine.JavaDebugger.JavaProgram.EnumModules(out ppEnum));
LoggingUtils.RequireOk(ppEnum.GetCount(out count));
IDebugModule2 [] moduleArray = new IDebugModule2 [count];
LoggingUtils.RequireOk(ppEnum.Next(count, moduleArray, ref count));
modules.AddRange(moduleArray);
}
ppEnum = new DebuggeeModule.Enumerator(modules);
return(Constants.S_OK);
}
catch (Exception e)
{
LoggingUtils.HandleException(e);
return(Constants.E_FAIL);
}
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
DebuggedModule[] modules = _debuggedProcess.GetModules();
AD7Module[] moduleObjects = new AD7Module[modules.Length];
for (int i = 0; i < modules.Length; i++)
{
moduleObjects[i] = new AD7Module(modules[i], _debuggedProcess);
}
ppEnum = new Microsoft.MIDebugEngine.AD7ModuleEnum(moduleObjects);
return(Constants.S_OK);
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
//Debug.Assert(Worker.MainThreadId == Worker.CurrentThreadId);
DebuggedModule[] modules = debuggedProcess.GetModules();
AD7Module[] moduleObjects = new AD7Module[modules.Length];
for (int i = 0; i < modules.Length; i++)
{
moduleObjects[i] = new AD7Module(modules[i]);
}
ppEnum = new VisualSquirrel.Debugger.Engine.AD7ModuleEnum(moduleObjects);
return(EngineConstants.S_OK);
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
var moduleObjects = new AD7Module[_modules.Count];
int i = 0;
foreach (var keyValue in _modules)
{
AD7Module adModule = keyValue.Value;
moduleObjects[i++] = adModule;
}
ppEnum = new AD7ModuleEnum(moduleObjects);
return(VSConstants.S_OK);
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
Debug.Assert(Worker.MainThreadId == Worker.CurrentThreadId);
DebuggedModule[] modules = m_debuggedProcess.GetModules();
AD7Module[] moduleObjects = new AD7Module[modules.Length];
for (int i = 0; i < modules.Length; i++)
{
moduleObjects[i] = new AD7Module(modules[i]);
}
ppEnum = new Microsoft.VisualStudio.Debugger.SampleEngine.AD7ModuleEnum(moduleObjects);
return(Constants.S_OK);
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
Log.Debug("Program: EnumModules");
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
// TODO: implement modules?
ppEnum = new EnumDebugModules(Enumerable.Empty <IDebugModule2>());
return(VSConstants.S_OK);
}
int IDebugProgram2.EnumModules(out IEnumDebugModules2 ppEnum)
{
Debug.WriteLine("AD7ProgramNode: Entering EnumModules");
throw new NotImplementedException();
}
int IDebugProgram2.EnumModules(out IEnumDebugModules2 ppEnum)
{
throw new NotImplementedException();
}
int IDebugProgram3.EnumModules(out IEnumDebugModules2 ppEnum) {
return IDebugProgram2.EnumModules(out ppEnum);
}
/// <summary>
/// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
/// </summary>
/// <param name="ppEnum"></param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = new MonoModuleEnumerator(new[] { Program.Module });
return(S_OK);
}
int Microsoft.VisualStudio.Debugger.Interop.IDebugProgram2.EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = null;
return Utility.COM_HResults.S_OK;
}
int IDebugProgram2.EnumModules(out IEnumDebugModules2 ppEnum)
{
Debug.WriteLine("AD7ProgramNode: Entering EnumModules");
throw new NotImplementedException();
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
//Debug.Assert(Worker.MainThreadId == Worker.CurrentThreadId);
ppEnum = new AD7ModuleEnum(m_debuggedProcess.GetModules().Select(m => new AD7Module(m)).ToArray());
return Constants.S_OK;
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
var moduleObjects = new AD7Module[_modules.Count];
int i = 0;
foreach (var keyValue in _modules)
{
AD7Module adModule = keyValue.Value;
moduleObjects[i++] = adModule;
}
ppEnum = new AD7ModuleEnum(moduleObjects);
return VSConstants.S_OK;
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
DLog.Debug(DContext.VSDebuggerComCall, "IDebugProgram2.EnumModules");
ppEnum = new ModuleEnum(MainModule);
return VSConstants.S_OK;
}
int Microsoft.VisualStudio.Debugger.Interop.IDebugProgram2.EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = null;
return(COM_HResults.S_OK);
}
public int /*IDebugProgram3*/ EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = ModuleEnum.Create(this);
return(VSConstants.S_OK);
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = new MonoModuleEnumerator(new IDebugModule2[] { _mainModule });
return(S_OK);
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum) {
DebugWriteCommand("EnumModules");
AssertMainThread();
var moduleObjects = new AD7Module[_modules.Count];
int i = 0;
foreach (var keyValue in _modules) {
var adModule = keyValue.Value;
moduleObjects[i++] = adModule;
}
ppEnum = new AD7ModuleEnum(moduleObjects);
return VSConstants.S_OK;
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
throw new NotImplementedException();
}
/// <summary>
/// Retrieves a list of the modules that this program has loaded and is executing.
/// (http://msdn.microsoft.com/en-us/library/bb146980.aspx)
/// </summary>
/// <param name="ppEnum"> Returns an IEnumDebugModules2 object that contains a list of the modules. </param>
/// <returns> VSConstants.S_OK. </returns>
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = new AD7ModuleEnum(new[] { m_module });
return VSConstants.S_OK;
}
int IDebugProgram2.EnumModules(out IEnumDebugModules2 ppEnum) {
// TODO
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
Log.Debug("Program: EnumModules");
ppEnum = null;
return(VSConstants.E_NOTIMPL);
}
int IDebugProgram3.EnumModules(out IEnumDebugModules2 ppEnum)
{
throw new NotImplementedException();
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = null;
return(VSConstants.E_NOTIMPL);
}
public int EnumModules(out IEnumDebugModules2 ppEnum) {
throw new NotImplementedException();
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
DebuggedModule[] modules = _debuggedProcess.GetModules();
AD7Module[] moduleObjects = new AD7Module[modules.Length];
for (int i = 0; i < modules.Length; i++)
{
moduleObjects[i] = new AD7Module(modules[i], _debuggedProcess);
}
ppEnum = new Microsoft.MIDebugEngine.AD7ModuleEnum(moduleObjects);
return Constants.S_OK;
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
if (_mixedMode) {
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
AssertMainThread();
AD7Module[] moduleObjects = new AD7Module[_modules.Count];
int i = 0;
foreach (var keyValue in _modules) {
var module = keyValue.Key;
var adModule = keyValue.Value;
moduleObjects[i++] = adModule;
}
ppEnum = new AD7ModuleEnum(moduleObjects);
return VSConstants.S_OK;
}
// EnumModules is called by the debugger when it needs to enumerate the modules in the program.
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
Debug.Assert(Worker.MainThreadId == Worker.CurrentThreadId);
DebuggedModule[] modules = m_debuggedProcess.GetModules();
AD7Module[] moduleObjects = new AD7Module[modules.Length];
for (int i = 0; i < modules.Length; i++)
{
moduleObjects[i] = new AD7Module(modules[i]);
}
ppEnum = new Microsoft.VisualStudio.Debugger.SampleEngine.AD7ModuleEnum(moduleObjects);
return Constants.S_OK;
}
int IDebugProgram2.EnumModules(out IEnumDebugModules2 ppEnum)
{
ppEnum = new MonoModuleEnum(new[] { new MonoModule(this) });
return(VSConstants.S_OK);
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
DLog.Debug(DContext.VSDebuggerComCall, "IDebugProgram2.EnumModules");
ppEnum = new ModuleEnum(MainModule);
return(VSConstants.S_OK);
}
/// <summary>
/// Retrieves a list of the modules that this program has loaded and is executing.
/// (http://msdn.microsoft.com/en-us/library/bb146980.aspx)
/// </summary>
/// <param name="ppEnum"> Returns an IEnumDebugModules2 object that contains a list of the modules. </param>
/// <returns> VSConstants.S_OK. </returns>
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
// Setting ppEnum to null because we are not adding/working with this feature now. It was causing an error
// when opening Threads Window and ppEnum = new AD7ModuleEnum(new[] { m_module }).
ppEnum = null;
return VSConstants.S_OK;
}
/// <summary>
/// Retrieves a list of the modules that this program has loaded and is executing.
/// </summary>
/// <param name="ppEnum">Returns an IEnumDebugModules2 object that contains a list of the modules.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>A module is a DLL or assembly and is typically listed in the Modules debug window.</remarks>
public virtual int EnumModules(out IEnumDebugModules2 ppEnum)
{
Logger.Debug(string.Empty);
ppEnum = null;
return(VSConstants.E_NOTIMPL);
}
public int EnumModules(out IEnumDebugModules2 ppEnum)
{
// TODO: implement modules?
ppEnum = new EnumDebugModules(Enumerable.Empty<IDebugModule2>());
return VSConstants.S_OK;
}
int IDebugProgram2.EnumModules(out IEnumDebugModules2 ppEnum)
{
// TODO
ppEnum = null;
return(VSConstants.E_NOTIMPL);
}
int IDebugProgram3.EnumModules(out IEnumDebugModules2 ppEnum)
{
return(IDebugProgram2.EnumModules(out ppEnum));
}
/// <summary>
/// Retrieves a list of the modules that this program has loaded and is executing.
/// </summary>
/// <param name="ppEnum">Returns an IEnumDebugModules2 object that contains a list of the modules.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>A module is a DLL or assembly and is typically listed in the Modules debug window.</remarks>
public virtual int EnumModules( out IEnumDebugModules2 ppEnum )
{
Logger.Debug( string.Empty );
ppEnum = null;
return VSConstants.E_NOTIMPL;
}
