Avoid update cycle when handling `=thread-selected` event When debugger receives `=thread-selected` event it updates the value of `selectedFrameHolder` (and `selectedThreadHolder`). This in turn may result in call to `updateAfterSelectedFrameHolderChanged` which isues `-thread-select` command (this is necessary to sync GDB user context when user clicks on frame in UI). However, `-thread=select` may result in another `=thread-selected` event and hence we cycle. To avoid this endless loop, temporarily suspend updates from holders when updating frame and thread holder from `=thread-selected` handler.

Clean up settings application and remove obsolete settings Apart of GDB executable itself, users may (should) use `$HOME/.vdbinit.st` file.

Update simple console implementation to use updated -complete command ...merged into GDB in commit 26648588294d03.

Add `VDBTerminalView` used on with PTYs The reason is that stock `TerminalView` closes streams when the view is closed (destoryed). This is *NOT* what we want - application provides opened stream and application is responsible for closing then. In this particular case, closing the PTY causes GDB to exit. This is not what we want - for example when reopening the UI or switching layout, old debugger console view is destoyed and ew one attached to the same PTY. Since there's no way to configure this behavior in `TerminalView`, we introduce new VDB-specific subclass with desired behavior.

Fix `VDBInstructionListApplication` update w.r.t running threads Instruction list invalidates itself in various places in order to always show up-to-date data, in particular currently executed instruction. To do so it updates thread's stack so frame objects have up-to-date PC. However, this fails when thread is running, so check for that before updating.

plugins/bee: add support for setting a breakpoint

plugins/bee: add symbol filter to quickly search through (possibly long) list of symbols.

plugins/bee: add menu item to disassemble given symbol Also, symbol list is auto-updated each time inferior stops. This may take time and has to be oprimized (later)

Generalize `VDBInstructionListView` ...so it can show any object that responds to `#disassemble`. In addition, a frame(Holder) can be set to highlight current PC like before.

UX: for all lists, automagically show `Updating...` message ...if updates take more than 200ms. The number is arbitrary and hard-coded - may need some tuning.

UX: display error message when a function cannot be disassembled ...tather than empty list.

API: add basic API to show (and hide) message in place of list contents This can be used to display error or "Updating..." message or alike.

Initial shot on Bee plugin

UI: set console width / height when a console view is resized This should improve behavior when pasting long lines and/or on multi-line outputs.

UX: diallow breakpoint "Enable" / "Disable" menu items when inferior is running ...since in that case, GDB cannot make changes to the breakpoint amd fails.

UX: fix skip in user message when there's no reference to a source file i.e., when debug info is missing.

UI: add a menu item to attach another debugger to cuurrent GDB This is only useful to debug crashing GDB (yes, even debugger crashes and has to be debugged)

Merge

Use standard `#enqueueMessage:` mechanism to enqueue delayed updates rather than baking our own `#enqueueDelayedUpdate:`. The former is "standard" API defined in `ApplicationModel`. We still need to specialize that behavior in (overridden) `#enqueueMessage:for:arguments:` but API-wise, we use the standard API.

UI: add support for multi-location breakpoints ...namely: * better textual description of multi-location breakpoints * make a breakpoint list actually a tree with individual locations as child of the breakpoint

UI: add status bar to debugger ...showing user the status (running / ready / busy) in order to provide a feedback to the user. It also shows a number of MI commands executed since last stop event. This is mainly useful for VDB hacking as rough information for optimization. Currently, the "ready" / "busy" indication does not work very well since most of the code executes MI commands within the UI eventloop and therefore status bas cannot update. This will be adressed later.

Performance: do not update contents of windows when not needed ...such as when the tab with it is not visible. This ought to make debugger feel more "snappy" for complex programs running on slow machines and / or during remote debugging sessions. Common code for this has been factored out to new abstract class `VDBAbstractContentsApplication`. `VDBSbstractListApplication` and subclasses have been adapted to use this feature.

Fix annoying flashing in simple console on Windows ...caused by different key names inder X11 and Windows. This fix adds few more to the list.

Show log output in simple console This needed because, for example, python errors and stacktrace is reported on log stream, not on output stream.

Workaround: assume native target when issuing `run` or `attach` commands using simple console Background command execution is not supported by some targets, most notably by Windows native target. However, at the point we have to decided whether use background execution or not, we don't know which target will get connected and therefore we cannot check target features. So, make a guess and assime we gonna use native target. This is so bad, this *absolutely* has to be fixed somehow.

UX: automatically refresh memory contents when inferior stops ...so memory contents is up-to-date.

Fix rendering of an instruction in instruction list The disassembly string comes from GDB which in some cases (e.g, RISC-V) uses tab to separate mnemonic from operands. This tab must be expanded before the string is handed over to the list view to render otherwise it would show replacement glyph ("cheese").

Oops, fixed bug introduced by previous commit (44f5e1c314b3) We *MUST NOT* check for async support because at the time we issue (say) `r` command, the real target is not yet connected, therefore check for async would return `false` even if in fact async is supported. So, just run all execution commands in background mode unconditionally.

Execute CLI execution commands in background mode ...if target supports async mode. This allows user to interrupt the program execution, at the very least.

A complete rewrite of simple console ..that is not using `TerminalView`. The original (previous) implementation had various problems that were hard to fix, namely loosing some stream output in some cases. New (current) implementation uses custom console view (1VDBSimpleDebuggerConsoleView`) based on `TextCollector` rather than `TerminalView`. The resulting code is much much simpler, it does not use internal pipes nor REPL / pipe reader processes. Whole REPL runs completely in UI process.