public void AttachToProcess(long pid, DebuggerSessionOptions sessionOptions)
{
Report.Initialize();
this.SessionOptions = sessionOptions;
DebuggerConfiguration config = new DebuggerConfiguration();
mdbAdaptor.Configuration = config;
mdbAdaptor.InitializeConfiguration();
config.LoadConfiguration();
debugger = new MD.Debugger(config);
DebuggerOptions options = DebuggerOptions.ParseCommandLine(new string[0]);
options.StopInMain = false;
session = new MD.DebuggerSession(config, options, "main", (IExpressionParser)null);
mdbAdaptor.Session = session;
Process proc = debugger.Attach(session, (int)pid);
OnInitialized(debugger, proc);
ST.ThreadPool.QueueUserWorkItem(delegate {
NotifyStarted();
});
}
public EmonicInterpreter(DebuggerConfiguration config,
DebuggerOptions options)
: base(true, config, options)
{
DebuggerEngine = new EmonicDebuggerEngine(this);
thisReference = this;
}
public async Task <AttachDebugUIResult> AttachAsync(char[] Password, DebuggerOptions Options)
{
var requestParameters = new RequestParameters("attachDebugUI");
var request = Context.NewSessionRequest <RDBGAttachDebugUIRequest>();
//if (password.length > 0)
//{
// var credentials = StringUtils.toByteArray(password);
// request.setCredentials(credentials);
//}
request.Options = Options;
var response = await Executor.ExecuteAsync <RDBGAttachDebugUIResponse>(request, requestParameters);
var result = response.Result;
//Logger.LogDebug("Debug attach result is {result}", Result);
lock (this)
{
Attached = result.Equals(AttachDebugUIResult.Registered);
if (Attached)
{
StartTimer();
}
}
return(result);
}
private DebuggerOptions CreateDebuggerOptions()
{
var opts = new DebuggerOptions(this);
opts.Load();
return(opts);
}
public ProjectOptions(DebuggerOptions debugger, VisualizerOptions visualizer, SliceVisualizerOptions slice, VisualizerAppearance appearance, DebugVisualizer.ColumnStylingOptions styling)
{
DebuggerOptions = debugger;
VisualizerOptions = visualizer;
SliceVisualizerOptions = slice;
VisualizerAppearance = appearance;
VisualizerColumnStyling = styling;
}
private static DebuggerOptions CreateOptions(string application, string[] args)
{
DebuggerOptions options = DebuggerOptions.ParseCommandLine(args);
options.IsScript = true;
options.File = application;
options.InferiorArgs = args;
return(options);
}
public void FromAgentOptionsThrows_Both()
{
var agentOptions = new AgentOptions
{
ApplicationId = _processId,
ApplicationStartCommand = _startCmd
};
Assert.Throws <ArgumentException>(() => DebuggerOptions.FromAgentOptions(agentOptions));
}
internal ProcessStart(DebuggerSession session, int pid)
{
this.session = session;
this.options = session.Options;
this.PID = pid;
stop_in_main = options.StopInMain;
IsNative = true;
}
internal PythonToolsService(IServiceContainer container)
{
_container = container;
var langService = new PythonLanguageInfo(container);
_container.AddService(langService.GetType(), langService, true);
IVsTextManager textMgr = (IVsTextManager)container.GetService(typeof(SVsTextManager));
if (textMgr != null)
{
var langPrefs = new LANGPREFERENCES[1];
langPrefs[0].guidLang = typeof(PythonLanguageInfo).GUID;
ErrorHandler.ThrowOnFailure(textMgr.GetUserPreferences(null, null, langPrefs, null));
_langPrefs = new LanguagePreferences(this, langPrefs[0]);
Guid guid = typeof(IVsTextManagerEvents2).GUID;
IConnectionPoint connectionPoint;
((IConnectionPointContainer)textMgr).FindConnectionPoint(ref guid, out connectionPoint);
connectionPoint.Advise(_langPrefs, out _langPrefsTextManagerCookie);
}
_optionsService = (IPythonToolsOptionsService)container.GetService(typeof(IPythonToolsOptionsService));
var compModel = (IComponentModel)container.GetService(typeof(SComponentModel));
_interpreterRegistry = compModel.GetService <IInterpreterRegistryService>();
if (_interpreterRegistry != null)
{
_interpreterRegistry.InterpretersChanged += InterpretersChanged;
}
_interpreterOptionsService = compModel.GetService <IInterpreterOptionsService>();
if (_interpreterOptionsService != null) // not available in some test cases...
{
_interpreterOptionsService.DefaultInterpreterChanged += UpdateDefaultAnalyzer;
LoadInterpreterOptions();
}
_idleManager = new IdleManager(container);
_advancedOptions = new AdvancedEditorOptions(this);
_debuggerOptions = new DebuggerOptions(this);
_generalOptions = new GeneralOptions(this);
_surveyNews = new SurveyNewsService(container);
_suppressDialogOptions = new SuppressDialogOptions(this);
_globalInterpreterOptions = new GlobalInterpreterOptions(this, _interpreterOptionsService, _interpreterRegistry);
_globalInterpreterOptions.Load();
_interactiveOptions = new PythonInteractiveOptions(this, "Interactive");
_interactiveOptions.Load();
_debugInteractiveOptions = new PythonInteractiveOptions(this, "Debug Interactive Window");
_debuggerOptions.Load();
_factoryProviders = ComponentModel.DefaultExportProvider.GetExports <IPythonInterpreterFactoryProvider, Dictionary <string, object> >();
_logger = new PythonToolsLogger(ComponentModel.GetExtensions <IPythonToolsLogger>().ToArray());
InitializeLogging();
}
internal CommandLineInterpreter(DebuggerOptions options, bool is_interactive)
{
if (options.HasDebugFlags)
{
Report.Initialize(options.DebugOutput, options.DebugFlags);
}
else
{
Report.Initialize();
}
Configuration = new DebuggerConfiguration();
#if HAVE_XSP
if (options.StartXSP)
{
Configuration.SetupXSP();
}
else
{
Configuration.LoadConfiguration();
}
#else
Configuration.LoadConfiguration();
#endif
Configuration.SetupCLI();
interpreter = new Interpreter(is_interactive, Configuration, options);
interpreter.CLI = this;
engine = interpreter.DebuggerEngine;
parser = new LineParser(engine);
if (!interpreter.IsScript)
{
line_editor = new LineEditor("mdb");
line_editor.AutoCompleteEvent += delegate(string text, int pos) {
return(engine.Completer.Complete(text, pos));
};
Console.CancelKeyPress += control_c_event;
}
interrupt_event = new ST.AutoResetEvent(false);
nested_break_state_event = new ST.AutoResetEvent(false);
main_loop_stack = new Stack <MainLoop> ();
main_loop_stack.Push(new MainLoop(interpreter));
main_thread = new ST.Thread(new ST.ThreadStart(main_thread_main));
main_thread.IsBackground = true;
}
public static void Main(string[] args)
{
DebuggerOptions options = DebuggerOptions.ParseCommandLine(args);
Console.WriteLine("Mono Debugger");
CommandLineInterpreter interpreter = new CommandLineInterpreter(options, true);
interpreter.RunMainLoop();
interpreter.Configuration.SaveConfiguration();
}
internal ProcessStart(ProcessStart parent, int pid)
{
this.PID = pid;
this.session = parent.session;
this.options = parent.options;
this.cwd = parent.cwd;
this.argv = parent.argv;
this.base_dir = parent.base_dir;
SetupEnvironment();
}
public void FromAgentOptions()
{
var agentOptions = new AgentOptions
{
ApplicationId = _processId,
};
var options = DebuggerOptions.FromAgentOptions(agentOptions);
Assert.False(options.PropertyEvaluation);
Assert.False(options.MethodEvaluation);
Assert.Null(options.ApplicationStartCommand);
Assert.Equal(_processId, options.ApplicationId);
Assert.StartsWith(Constants.PipeName, options.PipeName);
}
public void ToString_StartCommand()
{
var agentOptions = new AgentOptions
{
ApplicationStartCommand = _startCmd,
};
var options = DebuggerOptions.FromAgentOptions(agentOptions);
var optionsString = options.ToString();
Assert.Contains($"{DebuggerOptions.PipeNameOption}={Constants.PipeName}", optionsString);
Assert.Contains($"{DebuggerOptions.ApplicationStartCommandOption}=\"{_startCmd}\"", optionsString);
Assert.DoesNotContain(DebuggerOptions.PropertyEvaluationOption, optionsString);
Assert.DoesNotContain(DebuggerOptions.MethodEvaluationOption, optionsString);
Assert.DoesNotContain(DebuggerOptions.ApplicationIdOption, optionsString);
}
public void FromAgentOptions_ConditionEval()
{
var agentOptions = new AgentOptions
{
ApplicationStartCommand = _startCmd,
MethodEvaluation = true
};
var options = DebuggerOptions.FromAgentOptions(agentOptions);
Assert.False(options.PropertyEvaluation);
Assert.True(options.MethodEvaluation);
Assert.Null(options.ApplicationId);
Assert.Equal(_startCmd, options.ApplicationStartCommand);
Assert.StartsWith(Constants.PipeName, options.PipeName);
}
protected DebuggerTestFixture(string exe_file, string src_file, params string[] args)
{
ExeFileName = Path.GetFullPath(Path.Combine(BuildDirectory, exe_file));
FileName = Path.GetFullPath(Path.Combine(SourceDirectory, src_file));
config = new DebuggerConfiguration();
config.RedirectOutput = true;
config.SetupCLI();
options = CreateOptions(ExeFileName, args);
inferior_stdout = new LineReader();
inferior_stderr = new LineReader();
}
private DebuggerService(string[] args)
{
mono_debugger_server_static_init();
bool is_interactive = true;
DebuggerConfiguration config = new DebuggerConfiguration();
config.LoadConfiguration();
DebuggerOptions options = DebuggerOptions.ParseCommandLine(args);
if (options.HasDebugFlags)
{
Report.Initialize(options.DebugOutput, options.DebugFlags);
}
else
{
Report.Initialize();
}
// Redirect the Reporter output stream HACK: Using reflection
reporterOutput = new MemoryStream();
FieldInfo writerField = typeof(ReportWriter).GetField("writer", BindingFlags.NonPublic | BindingFlags.Instance);
StreamWriter writer = new StreamWriter(reporterOutput);
writer.AutoFlush = true;
writerField.SetValue(Report.ReportWriter, writer);
// Redirect the console
//Console.SetOut(writer);
//Console.SetError(writer);
interpreter = new GuiInterpreter(this, is_interactive, config, options);
engine = interpreter.DebuggerEngine;
parser = new LineParser(engine);
this.breakpointsStore = new BreakpointsStore(this, interpreter);
this.callstackStore = new CallstackStore(this, interpreter);
this.localsStore = new LocalsStore(this, interpreter);
this.threadsStore = new ThreadsStore(this, interpreter);
if (interpreter.Options.StartTarget)
{
interpreter.Start();
}
NotifyStateChange();
}
public void SetupApplication(string exe_file, string cwd, string[] cmdline_args)
{
this.cwd = cwd;
cmdline_args [0] = exe_file;
this.argv = cmdline_args;
base_dir = GetFullPath(Path.GetDirectoryName(argv [0]));
options = options.Clone();
options.File = exe_file;
options.InferiorArgs = cmdline_args;
options.WorkingDirectory = cwd;
SetupEnvironment();
}
public void StartMdb(string cmdLine)
{
string[] args = cmdLine.Split(' ');
DebuggerConfiguration config = new DebuggerConfiguration();
config.LoadConfiguration();
DebuggerOptions options = DebuggerOptions.ParseCommandLine(args);
System.Console.WriteLine("Mono Debugger");
EmonicLineInterpreter interpreter = new EmonicLineInterpreter(config, options);
interpreter.RunMainLoop();
// we don't want an automatic breakpoint in Main(), and we want to be able
// to set a breakpoint there, so we delete the automatic one
EmonicLineInterpreter.AddCmd("delete 1");
}
public void ToString_ApplicationId()
{
var agentOptions = new AgentOptions
{
ApplicationId = _processId,
PropertyEvaluation = true,
MethodEvaluation = true,
};
var options = DebuggerOptions.FromAgentOptions(agentOptions);
var optionsString = options.ToString();
Assert.Contains($"{DebuggerOptions.PipeNameOption}={Constants.PipeName}", optionsString);
Assert.Contains($"{DebuggerOptions.ApplicationIdOption}={_processId}", optionsString);
Assert.Contains($"{DebuggerOptions.PropertyEvaluationOption}", optionsString);
Assert.Contains($"{DebuggerOptions.MethodEvaluationOption}", optionsString);
Assert.DoesNotContain(DebuggerOptions.ApplicationStartCommandOption, optionsString);
}
internal PythonToolsService(IServiceContainer container)
{
_container = container;
var langService = new PythonLanguageInfo(container);
_container.AddService(langService.GetType(), langService, true);
_langPrefs = new Lazy <LanguagePreferences>(() => new LanguagePreferences(this, typeof(PythonLanguageInfo).GUID));
_optionsService = (IPythonToolsOptionsService)container.GetService(typeof(IPythonToolsOptionsService));
var compModel = (IComponentModel)container.GetService(typeof(SComponentModel));
_interpreterRegistry = compModel.GetService <IInterpreterRegistryService>();
if (_interpreterRegistry != null)
{
_interpreterRegistry.InterpretersChanged += InterpretersChanged;
}
_interpreterOptionsService = compModel.GetService <IInterpreterOptionsService>();
if (_interpreterOptionsService != null) // not available in some test cases...
{
_interpreterOptionsService.DefaultInterpreterChanged += UpdateDefaultAnalyzer;
LoadInterpreterOptions();
}
_idleManager = new IdleManager(container);
_advancedOptions = new AdvancedEditorOptions(this);
_debuggerOptions = new DebuggerOptions(this);
_generalOptions = new GeneralOptions(this);
_surveyNews = new SurveyNewsService(container);
_suppressDialogOptions = new SuppressDialogOptions(this);
_globalInterpreterOptions = new GlobalInterpreterOptions(this, _interpreterOptionsService, _interpreterRegistry);
_globalInterpreterOptions.Load();
_interactiveOptions = new PythonInteractiveOptions(this, "Interactive");
_interactiveOptions.Load();
_debugInteractiveOptions = new PythonInteractiveOptions(this, "Debug Interactive Window");
_debuggerOptions.Load();
_factoryProviders = ComponentModel.DefaultExportProvider.GetExports <IPythonInterpreterFactoryProvider, Dictionary <string, object> >();
_logger = new PythonToolsLogger(ComponentModel.GetExtensions <IPythonToolsLogger>().ToArray());
InitializeLogging();
}
public EmonicLineInterpreter(DebuggerConfiguration config, DebuggerOptions options)
{
if (options.HasDebugFlags)
{
Report.Initialize(options.DebugOutput, options.DebugFlags);
}
else
{
Report.Initialize();
}
interpreter = new EmonicInterpreter(config, options);
engine = interpreter.DebuggerEngine;
parser = new LineParser(engine);
main_thread = new ST.Thread(new System.Threading.ThreadStart(main_thread_main));
main_thread.IsBackground = true;
command_thread = new ST.Thread(new ST.ThreadStart(command_thread_main));
command_thread.IsBackground = true;
}
public Interpreter(bool is_interactive, DebuggerConfiguration config,
DebuggerOptions options)
{
this.config = config;
this.is_interactive = is_interactive;
this.is_script = options.IsScript;
this.parser = new ExpressionParser(this);
this.session = new DebuggerSession(config, options, "main", parser);
this.engine = new DebuggerEngine(this);
parser.Session = session;
source_factory = new SourceFileFactory();
interrupt_event = new ManualResetEvent(false);
process_event = new ManualResetEvent(false);
styles = new Hashtable();
styles.Add("cli", new StyleCLI(this));
styles.Add("emacs", new StyleEmacs(this));
current_style = (StyleBase)styles ["cli"];
}
internal NUnitInterpreter(DebuggerConfiguration config, DebuggerOptions options,
LineReader inferior_stdout, LineReader inferior_stderr)
: base(false, config, options)
{
this.inferior_stdout = inferior_stdout;
this.inferior_stderr = inferior_stderr;
config.FollowFork = true;
queue = Queue.Synchronized(new Queue());
wait_event = new ST.ManualResetEvent(false);
Style = style_nunit = new StyleNUnit(this);
style_nunit.TargetEventEvent += delegate(Thread thread, TargetEventArgs args) {
if (IgnoreThreadCreation && (args.Type == TargetEventType.TargetExited))
{
return;
}
AddEvent(new DebuggerEvent(DebuggerEventType.TargetEvent, thread, args));
};
ST.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
ObjectFormatter.WrapLines = false;
}
protected override void OnInitialized()
{
options = VolatileSettings.DebuggerOptions;
logger = VolatileSettings.DebuggerLog;
}
public void Run(MonoDebuggerStartInfo startInfo, DebuggerSessionOptions sessionOptions)
{
try {
if (startInfo == null)
{
throw new ArgumentNullException("startInfo");
}
Console.WriteLine("MDB version: " + mdbAdaptor.MdbVersion);
this.SessionOptions = sessionOptions;
mdbAdaptor.StartInfo = startInfo;
Report.Initialize();
DebuggerConfiguration config = new DebuggerConfiguration();
config.LoadConfiguration();
mdbAdaptor.Configuration = config;
mdbAdaptor.InitializeConfiguration();
debugger = new MD.Debugger(config);
debugger.ModuleLoadedEvent += OnModuleLoadedEvent;
debugger.ModuleUnLoadedEvent += OnModuleUnLoadedEvent;
debugger.ProcessReachedMainEvent += delegate(MD.Debugger deb, MD.Process proc) {
OnInitialized(deb, proc);
};
if (startInfo.IsXsp)
{
mdbAdaptor.SetupXsp();
config.FollowFork = false;
}
config.OpaqueFileNames = false;
DebuggerOptions options = DebuggerOptions.ParseCommandLine(new string[] { startInfo.Command });
options.WorkingDirectory = startInfo.WorkingDirectory;
Environment.CurrentDirectory = startInfo.WorkingDirectory;
options.StopInMain = false;
if (!string.IsNullOrEmpty(startInfo.Arguments))
{
options.InferiorArgs = ToArgsArray(startInfo.Arguments);
}
if (startInfo.EnvironmentVariables != null)
{
foreach (KeyValuePair <string, string> env in startInfo.EnvironmentVariables)
{
options.SetEnvironment(env.Key, env.Value);
}
}
session = new MD.DebuggerSession(config, options, "main", null);
mdbAdaptor.Session = session;
mdbAdaptor.InitializeSession();
ST.ThreadPool.QueueUserWorkItem(delegate {
// Run in a thread to avoid a deadlock, since NotifyStarted calls back to the client.
NotifyStarted();
debugger.Run(session);
});
} catch (Exception e) {
Console.WriteLine("error: " + e.ToString());
throw;
}
}
internal ProcessStart(DebuggerSession session)
{
if (session == null)
{
throw new ArgumentNullException();
}
this.session = session;
this.options = session.Options;
#if HAVE_XSP
if (options.StartXSP)
{
options.File = BuildInfo.xsp;
}
#endif
if ((options.File == null) || (options.File == ""))
{
throw new ArgumentException("options.File null or empty", "options");
}
if (options.InferiorArgs == null)
{
throw new ArgumentException("InferiorArgs null", "options");
}
stop_in_main = options.StopInMain;
redirect_output = session.Config.RedirectOutput;
cwd = options.WorkingDirectory;
if (cwd == null)
{
cwd = options.WorkingDirectory = System.Environment.CurrentDirectory;
}
string mono_path = options.MonoPath ?? MonoPath;
#if HAVE_XSP
if (options.StartXSP)
{
IsNative = false;
ArrayList start_argv = new ArrayList();
start_argv.Add(mono_path);
start_argv.Add("--inside-mdb");
if (options.JitOptimizations != null)
{
start_argv.Add("--optimize=" + options.JitOptimizations);
}
if (options.JitArguments != null)
{
start_argv.AddRange(options.JitArguments);
}
start_argv.Add(BuildInfo.xsp);
start_argv.Add("--nonstop");
if (options.XSP_Root != null)
{
start_argv.Add("--root");
start_argv.Add(options.XSP_Root);
}
this.argv = new string [options.InferiorArgs.Length + start_argv.Count];
start_argv.CopyTo(this.argv, 0);
if (options.InferiorArgs.Length > 0)
{
options.InferiorArgs.CopyTo(this.argv, start_argv.Count);
}
}
else
#endif
if (IsMonoAssembly(options.File))
{
IsNative = false;
ArrayList start_argv = new ArrayList();
start_argv.Add(mono_path);
start_argv.Add("--inside-mdb");
if (options.JitOptimizations != null)
{
start_argv.Add("--optimize=" + options.JitOptimizations);
}
if (options.JitArguments != null)
{
start_argv.AddRange(options.JitArguments);
}
this.argv = new string [options.InferiorArgs.Length + start_argv.Count + 1];
start_argv.CopyTo(this.argv, 0);
argv [start_argv.Count] = options.File;
options.InferiorArgs.CopyTo(this.argv, start_argv.Count + 1);
}
else
{
IsNative = true;
this.argv = new string [options.InferiorArgs.Length + 1];
argv [0] = options.File;
options.InferiorArgs.CopyTo(this.argv, 1);
}
if (!File.Exists(options.File))
{
throw new TargetException(TargetError.CannotStartTarget,
"No such file or directory: `{0}'",
options.File);
}
try {
base_dir = GetFullPath(Path.GetDirectoryName(options.File));
} catch {
throw new TargetException(TargetError.CannotStartTarget,
"Invalid directory: `{0}'", options.File);
}
SetupEnvironment();
}
public GuiInterpreter(DebuggerService debuggerService, bool is_interactive, DebuggerConfiguration config, DebuggerOptions options)
: base(is_interactive, config, options)
{
this.debuggerService = debuggerService;
}
public PythonDebugOptionsService(IServiceProvider serviceProvider)
{
debugOptions = ((PythonToolsService)serviceProvider
.GetService(typeof(PythonToolsService))).DebuggerOptions;
}
public void FromAgentOptionsThrows_None() => Assert.Throws <ArgumentException>(() => DebuggerOptions.FromAgentOptions(new AgentOptions()));
public GuiInterpreter(DebuggerService debuggerService, bool is_interactive, DebuggerConfiguration config, DebuggerOptions options)
:base(is_interactive, config, options)
{
this.debuggerService = debuggerService;
}
