maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/source/Interpreter/CommandInterpreter.cpp

3314 lines
128 KiB
C++
Raw Normal View History

Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
//===-- CommandInterpreter.cpp ----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <string>
Fix some memory leaks. Add call to lldb.SBDebugger.Initialize() to lldb.py, so it automatically gets called when the lldb Python module gets loaded. llvm-svn: 116345
2010-10-13 05:57:09 +08:00
#include <vector>
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
#include <stdlib.h>
Committing type format code for Enrico Granata. This commit adds a new top level command named "type". Currently this command implements three commands: type format add <format> <typename1> [<typename2> ...] type format delete <typename1> [<typename2> ...] type format list [<typename1> [<typename2>] ...] This allows you to specify the default format that will be used to display types when you use "frame variable" or "expression", or the SBValue classes. Examples: // Format uint*_t as hex type format add x uint16_t uint32_t uint64_t // Format intptr_t as a pointer type format add p intptr_t The format characters are the same as "printf" for the most part with many additions. These format character specifiers are also used in many other commands ("frame variable" for one). The current list of format characters include: a - char buffer b - binary B - boolean c - char C - printable char d - signed decimal e - float f - float g - float i - signed decimal I - complex integer o - octal O - OSType p - pointer s - c-string u - unsigned decimal x - hex X - complex float y - bytes Y - bytes with ASCII llvm-svn: 133728
2011-06-24 01:59:56 +08:00
#include "CommandObjectScript.h"
Fix header paths llvm-svn: 133755
2011-06-24 04:37:26 +08:00
#include "lldb/Interpreter/CommandObjectRegexCommand.h"
Committing type format code for Enrico Granata. This commit adds a new top level command named "type". Currently this command implements three commands: type format add <format> <typename1> [<typename2> ...] type format delete <typename1> [<typename2> ...] type format list [<typename1> [<typename2>] ...] This allows you to specify the default format that will be used to display types when you use "frame variable" or "expression", or the SBValue classes. Examples: // Format uint*_t as hex type format add x uint16_t uint32_t uint64_t // Format intptr_t as a pointer type format add p intptr_t The format characters are the same as "printf" for the most part with many additions. These format character specifiers are also used in many other commands ("frame variable" for one). The current list of format characters include: a - char buffer b - binary B - boolean c - char C - printable char d - signed decimal e - float f - float g - float i - signed decimal I - complex integer o - octal O - OSType p - pointer s - c-string u - unsigned decimal x - hex X - complex float y - bytes Y - bytes with ASCII llvm-svn: 133728
2011-06-24 01:59:56 +08:00
Fix include paths; please check that this works on Mac. llvm-svn: 105906
2010-06-13 10:17:17 +08:00
#include "../Commands/CommandObjectApropos.h"
#include "../Commands/CommandObjectArgs.h"
#include "../Commands/CommandObjectBreakpoint.h"
Add new bugreport command to lldb The new command add functionality to print out domain specific information for reporting a bug. Currently the only supported domain is stack unwinding (with "bugreport unwind") but adding new domains is fairly easy. Differential revision: http://reviews.llvm.org/D10868 llvm-svn: 241252
2015-07-02 18:03:37 +08:00
#include "../Commands/CommandObjectBugreport.h"
Fix include paths; please check that this works on Mac. llvm-svn: 105906
2010-06-13 10:17:17 +08:00
#include "../Commands/CommandObjectDisassemble.h"
#include "../Commands/CommandObjectExpression.h"
#include "../Commands/CommandObjectFrame.h"
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
#include "../Commands/CommandObjectGUI.h"
Fix include paths; please check that this works on Mac. llvm-svn: 105906
2010-06-13 10:17:17 +08:00
#include "../Commands/CommandObjectHelp.h"
#include "../Commands/CommandObjectLog.h"
#include "../Commands/CommandObjectMemory.h"
Added more platform support. There are now some new commands: platform status -- gets status information for the selected platform platform create <platform-name> -- creates a new instance of a remote platform platform list -- list all available platforms platform select -- select a platform instance as the current platform (not working yet) When using "platform create" it will create a remote platform and make it the selected platform. For instances for iPhone OS debugging on Mac OS X one can do: (lldb) platform create remote-ios --sdk-version=4.0 Remote platform: iOS platform SDK version: 4.0 SDK path: "/Developer/Platforms/iPhoneOS.platform/DeviceSupport/4.0" Not connected to a remote device. (lldb) file ~/Documents/a.out Current executable set to '~/Documents/a.out' (armv6). (lldb) image list [ 0] /Volumes/work/gclayton/Documents/devb/attach/a.out [ 1] /Developer/Platforms/iPhoneOS.platform/DeviceSupport/4.0/Symbols/usr/lib/dyld [ 2] /Developer/Platforms/iPhoneOS.platform/DeviceSupport/4.0/Symbols/usr/lib/libSystem.B.dylib Note that this is all happening prior to running _or_ connecting to a remote platform. Once connected to a remote platform the OS version might change which means we will need to update our dependecies. Also once we run, we will need to match up the actualy binaries with the actualy UUID's to files in the SDK, or download and cache them locally. This is just the start of the remote platforms, but this modification is the first iteration in getting the platforms really doing something. llvm-svn: 127934
2011-03-19 09:12:21 +08:00
#include "../Commands/CommandObjectPlatform.h"
Implementing plugins that provide commands. This checkin adds the capability for LLDB to load plugins from external dylibs that can provide new commands It exports an SBCommand class from the public API layer, and a new SBCommandPluginInterface There is a minimal load-only plugin manager built into the debugger, which can be accessed via Debugger::LoadPlugin. Plugins are loaded from two locations at debugger startup (LLDB.framework/Resources/PlugIns and ~/Library/Application Support/LLDB/PlugIns) and more can be (re)loaded via the "plugin load" command For an example of how to make a plugin, refer to the fooplugin.cpp file in examples/plugins/commands Caveats: Currently, the new API objects and features are not exposed via Python. The new commands can only be "parsed" (i.e. not raw) and get their command line via a char** parameter (we do not expose our internal Args object) There is no unloading feature, which can potentially lead to leaks if you overwrite the commands by reloading the same or different plugins There is no API exposed for option parsing, which means you may need to use getopt or roll-your-own llvm-svn: 164865
2012-09-29 07:57:51 +08:00
#include "../Commands/CommandObjectPlugin.h"
Fix include paths; please check that this works on Mac. llvm-svn: 105906
2010-06-13 10:17:17 +08:00
#include "../Commands/CommandObjectProcess.h"
#include "../Commands/CommandObjectQuit.h"
#include "../Commands/CommandObjectRegister.h"
#include "../Commands/CommandObjectSettings.h"
#include "../Commands/CommandObjectSource.h"
Fix GetRepeatCommand so it works with multi-word commands. Move the "source", "alias", and "unalias" commands to "commands *". Move "source-file" to "source list". Added a "source info" command but it isn't implemented yet. llvm-svn: 107751
2010-07-07 11:36:20 +08:00
#include "../Commands/CommandObjectCommands.h"
Fix include paths; please check that this works on Mac. llvm-svn: 105906
2010-06-13 10:17:17 +08:00
#include "../Commands/CommandObjectSyntax.h"
#include "../Commands/CommandObjectTarget.h"
#include "../Commands/CommandObjectThread.h"
Committing type format code for Enrico Granata. This commit adds a new top level command named "type". Currently this command implements three commands: type format add <format> <typename1> [<typename2> ...] type format delete <typename1> [<typename2> ...] type format list [<typename1> [<typename2>] ...] This allows you to specify the default format that will be used to display types when you use "frame variable" or "expression", or the SBValue classes. Examples: // Format uint*_t as hex type format add x uint16_t uint32_t uint64_t // Format intptr_t as a pointer type format add p intptr_t The format characters are the same as "printf" for the most part with many additions. These format character specifiers are also used in many other commands ("frame variable" for one). The current list of format characters include: a - char buffer b - binary B - boolean c - char C - printable char d - signed decimal e - float f - float g - float i - signed decimal I - complex integer o - octal O - OSType p - pointer s - c-string u - unsigned decimal x - hex X - complex float y - bytes Y - bytes with ASCII llvm-svn: 133728
2011-06-24 01:59:56 +08:00
#include "../Commands/CommandObjectType.h"
Add a simple command: 'version' to the command interpreter, and an accompanying test case test_help_version(). llvm-svn: 122515
2010-12-24 04:21:44 +08:00
#include "../Commands/CommandObjectVersion.h"
Add initial implementation of watchpoint commands for list, enable, disable, and delete. Test cases to be added later. llvm-svn: 140322
2011-09-23 02:04:58 +08:00
#include "../Commands/CommandObjectWatchpoint.h"
Add language command and LanguageRuntime plugin changes to allow vending of command objects. Differential Revision: http://reviews.llvm.org/D9402 llvm-svn: 236443
2015-05-05 02:39:38 +08:00
#include "../Commands/CommandObjectLanguage.h"
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
#include "lldb/Core/Debugger.h"
<rdar://problem/11449953> Change Debugger::SetOutputFileHandle() so that it does not automatically initialize the script interpreter in order to transfer its output file handle to it This should delay initialization of Python until strictly necessary and speed-up debugger startup Also, convert formatters for SEL and BOOL ObjC data-types from Python to C++, in order to reap more performance benefits from the above changes llvm-svn: 166967
2012-10-30 05:18:03 +08:00
#include "lldb/Core/Log.h"
Convert the ScriptInterpreter system to a plugin-based one. Previously embedded interpreters were handled as ad-hoc source files compiled into source/Interpreter. This made it hard to disable a specific interpreter, or to add support for other interpreters and allow the developer to choose which interpreter(s) were enabled for a particular build. This patch converts script interpreters over to a plugin-based system. Script interpreters now live in source/Plugins/ScriptInterpreter, and the canonical LLDB interpreter, ScriptInterpreterPython, is moved there as well. Any new code interfacing with the Python C API must live in this location from here on out. Additionally, generic code should never need to reference or make assumptions about the presence of a specific interpreter going forward. Differential Revision: http://reviews.llvm.org/D11431 Reviewed By: Greg Clayton llvm-svn: 243681
2015-07-31 04:28:07 +08:00
#include "lldb/Core/PluginManager.h"
Fixed CTRL+C related issues: - CTRL+C wasn't clearing the command in lldb - CTRL+C doesn't work in python macros in lldb - Ctrl+C no longer interrupts the running process that you attach to <rdar://problem/15949205> <rdar://problem/16778652> <rdar://problem/16774411> llvm-svn: 207816
2014-05-02 08:45:31 +08:00
#include "lldb/Core/State.h"
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
#include "lldb/Core/Stream.h"
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
#include "lldb/Core/StreamFile.h"
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
#include "lldb/Core/Timer.h"
<rdar://problem/11449953> Change Debugger::SetOutputFileHandle() so that it does not automatically initialize the script interpreter in order to transfer its output file handle to it This should delay initialization of Python until strictly necessary and speed-up debugger startup Also, convert formatters for SEL and BOOL ObjC data-types from Python to C++, in order to reap more performance benefits from the above changes llvm-svn: 166967
2012-10-30 05:18:03 +08:00
Enable llgs to build against experimental Android AOSP lldb/llvm/clang/compiler-rt repos. See http://reviews.llvm.org/D5495 for more details. These are changes that are part of an effort to support building llgs, within the AOSP source tree, using the Android.mk build system, when using the llvm/clang/lldb git repos from AOSP replaced with the experimental ones currently in github.com/tfiala/aosp-{llvm,clang,lldb,compiler-rt}. llvm-svn: 218568
2014-09-28 00:54:22 +08:00
#ifndef LLDB_DISABLE_LIBEDIT
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
#include "lldb/Host/Editline.h"
Enable llgs to build against experimental Android AOSP lldb/llvm/clang/compiler-rt repos. See http://reviews.llvm.org/D5495 for more details. These are changes that are part of an effort to support building llgs, within the AOSP source tree, using the Android.mk build system, when using the llvm/clang/lldb git repos from AOSP replaced with the experimental ones currently in github.com/tfiala/aosp-{llvm,clang,lldb,compiler-rt}. llvm-svn: 218568
2014-09-28 00:54:22 +08:00
#endif
Endian patch from Kirk Beitz that allows better cross platform building. llvm-svn: 124643
2011-02-01 09:31:41 +08:00
#include "lldb/Host/Host.h"
Move the rest of the HostInfo functions over. This should bring HostInfo up to 99% completion. The remainder of code in Host will be split into instantiatable classes representing host processes, threads, dynamic libraries, and process launching strategies. llvm-svn: 216230
2014-08-22 05:49:24 +08:00
#include "lldb/Host/HostInfo.h"
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
<rdar://problem/11449953> Change Debugger::SetOutputFileHandle() so that it does not automatically initialize the script interpreter in order to transfer its output file handle to it This should delay initialization of Python until strictly necessary and speed-up debugger startup Also, convert formatters for SEL and BOOL ObjC data-types from Python to C++, in order to reap more performance benefits from the above changes llvm-svn: 166967
2012-10-30 05:18:03 +08:00
#include "lldb/Interpreter/Args.h"
<rdar://problem/12022060> Enable tab completion for regular expression commands. llvm-svn: 178348
2013-03-30 01:03:23 +08:00
#include "lldb/Interpreter/CommandCompletions.h"
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
#include "lldb/Interpreter/CommandInterpreter.h"
<rdar://problem/12022060> Enable tab completion for regular expression commands. llvm-svn: 178348
2013-03-30 01:03:23 +08:00
#include "lldb/Interpreter/CommandReturnObject.h"
<rdar://problem/11449953> Change Debugger::SetOutputFileHandle() so that it does not automatically initialize the script interpreter in order to transfer its output file handle to it This should delay initialization of Python until strictly necessary and speed-up debugger startup Also, convert formatters for SEL and BOOL ObjC data-types from Python to C++, in order to reap more performance benefits from the above changes llvm-svn: 166967
2012-10-30 05:18:03 +08:00
#include "lldb/Interpreter/Options.h"
Further reduce header footprint of Debugger.h. llvm-svn: 231202
2015-03-04 09:58:01 +08:00
#include "lldb/Interpreter/OptionValueProperties.h"
#include "lldb/Interpreter/Property.h"
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
<rdar://problem/11449953> Change Debugger::SetOutputFileHandle() so that it does not automatically initialize the script interpreter in order to transfer its output file handle to it This should delay initialization of Python until strictly necessary and speed-up debugger startup Also, convert formatters for SEL and BOOL ObjC data-types from Python to C++, in order to reap more performance benefits from the above changes llvm-svn: 166967
2012-10-30 05:18:03 +08:00
#include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/TargetList.h"
#include "lldb/Utility/CleanUp.h"
Move the rest of the HostInfo functions over. This should bring HostInfo up to 99% completion. The remainder of code in Host will be split into instantiatable classes representing host processes, threads, dynamic libraries, and process launching strategies. llvm-svn: 216230
2014-08-22 05:49:24 +08:00
#include "llvm/ADT/SmallString.h"
lldb: remove adhoc implementation of array_sizeof Replace adhoc inline implementation of llvm::array_lengthof in favour of the implementation in LLVM. This is simply a cleanup change, no functional change intended. llvm-svn: 211868
2014-06-27 13:17:41 +08:00
#include "llvm/ADT/STLExtras.h"
Move the rest of the HostInfo functions over. This should bring HostInfo up to 99% completion. The remainder of code in Host will be split into instantiatable classes representing host processes, threads, dynamic libraries, and process launching strategies. llvm-svn: 216230
2014-08-22 05:49:24 +08:00
#include "llvm/Support/Path.h"
lldb: remove adhoc implementation of array_sizeof Replace adhoc inline implementation of llvm::array_lengthof in favour of the implementation in LLVM. This is simply a cleanup change, no functional change intended. llvm-svn: 211868
2014-06-27 13:17:41 +08:00
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
using namespace lldb;
using namespace lldb_private;
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
static const char *k_white_space = " \t\v";
<rdar://problem/12022079> Added a new "interpreter" properties to encapsulate any properties for the command interpreter. Right now this contains only "expand-regex-aliases", so you can now enable (disabled by default) the echoing of the command that a regular expression alias expands to: (lldb) b main Breakpoint created: 1: name = 'main', locations = 1 Note that the expanded regular expression command wasn't shown by default. You can enable it if you want to: (lldb) settings set interpreter.expand-regex-aliases true (lldb) b main breakpoint set --name 'main' Breakpoint created: 1: name = 'main', locations = 1 Also enabled auto completion for enumeration option values (OptionValueEnumeration) and for boolean option values (OptionValueBoolean). Fixed auto completion for settings names when nothing has been type (it should show all settings). llvm-svn: 162418
2012-08-23 08:22:02 +08:00
static PropertyDefinition
g_properties[] =
{
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
{ "expand-regex-aliases", OptionValue::eTypeBoolean, true, false, nullptr, nullptr, "If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands." },
{ "prompt-on-quit", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, LLDB will prompt you before quitting if there are any live processes being debugged. If false, LLDB will quit without asking in any case." },
{ "stop-command-source-on-error", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, LLDB will stop running a 'command source' script upon encountering an error." },
Added the concept of a Read-Eval-Print-Loop to LLDB. A REPL takes over the command line and typically treats input as source code. REPLs can also do code completion. The REPL class allows its subclasses to implement the language-specific functionality without having to know about the IOHandler-specific internals. Also added a PluginManager-based way of getting to a REPL given a language and a target. Also brought in some utility code and expression options that are useful for REPLs, such as line offsets for expressions, ANSI terminal coloring of errors, and a few IOHandler convenience functions. llvm-svn: 250753
2015-10-20 07:11:07 +08:00
{ "space-repl-prompts", OptionValue::eTypeBoolean, true, false, nullptr, nullptr, "If true, blank lines will be printed between between REPL submissions." },
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
{ nullptr , OptionValue::eTypeInvalid, true, 0 , nullptr, nullptr, nullptr }
<rdar://problem/12022079> Added a new "interpreter" properties to encapsulate any properties for the command interpreter. Right now this contains only "expand-regex-aliases", so you can now enable (disabled by default) the echoing of the command that a regular expression alias expands to: (lldb) b main Breakpoint created: 1: name = 'main', locations = 1 Note that the expanded regular expression command wasn't shown by default. You can enable it if you want to: (lldb) settings set interpreter.expand-regex-aliases true (lldb) b main breakpoint set --name 'main' Breakpoint created: 1: name = 'main', locations = 1 Also enabled auto completion for enumeration option values (OptionValueEnumeration) and for boolean option values (OptionValueBoolean). Fixed auto completion for settings names when nothing has been type (it should show all settings). llvm-svn: 162418
2012-08-23 08:22:02 +08:00
};
enum
{
<rdar://problem/12786725> If there is any alive process being debugged, the user is asked for confirmation before quitting LLDB This should prevent situations where the user mistakenly types "q" and LLDB slaughters their process without any mercy whatsoever Since it can quickly get tedious, there is a new setting on the command interpreter to disable this and replicate the previous behavior llvm-svn: 172757
2013-01-18 05:36:19 +08:00
ePropertyExpandRegexAliases = 0,
<rdar://problem/12876503> Adding a new setting interpreter.stop-command-source-on-error that dictates a default behavior for whether command source should stop upon hitting an error You can still override the setting for each individual invocation with the usual -e setting llvm-svn: 183719
2013-06-11 09:26:35 +08:00
ePropertyPromptOnQuit = 1,
Added the concept of a Read-Eval-Print-Loop to LLDB. A REPL takes over the command line and typically treats input as source code. REPLs can also do code completion. The REPL class allows its subclasses to implement the language-specific functionality without having to know about the IOHandler-specific internals. Also added a PluginManager-based way of getting to a REPL given a language and a target. Also brought in some utility code and expression options that are useful for REPLs, such as line offsets for expressions, ANSI terminal coloring of errors, and a few IOHandler convenience functions. llvm-svn: 250753
2015-10-20 07:11:07 +08:00
ePropertyStopCmdSourceOnError = 2,
eSpaceReplPrompts = 3
<rdar://problem/12022079> Added a new "interpreter" properties to encapsulate any properties for the command interpreter. Right now this contains only "expand-regex-aliases", so you can now enable (disabled by default) the echoing of the command that a regular expression alias expands to: (lldb) b main Breakpoint created: 1: name = 'main', locations = 1 Note that the expanded regular expression command wasn't shown by default. You can enable it if you want to: (lldb) settings set interpreter.expand-regex-aliases true (lldb) b main breakpoint set --name 'main' Breakpoint created: 1: name = 'main', locations = 1 Also enabled auto completion for enumeration option values (OptionValueEnumeration) and for boolean option values (OptionValueBoolean). Fixed auto completion for settings names when nothing has been type (it should show all settings). llvm-svn: 162418
2012-08-23 08:22:02 +08:00
};
Add a general mechanism to wait on the debugger for Broadcasters of a given class/event bit set. Use this to allow the lldb Driver to emit notifications for breakpoint modifications. <rdar://problem/10619974> llvm-svn: 150665
2012-02-16 14:50:00 +08:00
ConstString &
CommandInterpreter::GetStaticBroadcasterClass ()
{
static ConstString class_name ("lldb.commandInterpreter");
return class_name;
}
Convert the ScriptInterpreter system to a plugin-based one. Previously embedded interpreters were handled as ad-hoc source files compiled into source/Interpreter. This made it hard to disable a specific interpreter, or to add support for other interpreters and allow the developer to choose which interpreter(s) were enabled for a particular build. This patch converts script interpreters over to a plugin-based system. Script interpreters now live in source/Plugins/ScriptInterpreter, and the canonical LLDB interpreter, ScriptInterpreterPython, is moved there as well. Any new code interfacing with the Python C API must live in this location from here on out. Additionally, generic code should never need to reference or make assumptions about the presence of a specific interpreter going forward. Differential Revision: http://reviews.llvm.org/D11431 Reviewed By: Greg Clayton llvm-svn: 243681
2015-07-31 04:28:07 +08:00
CommandInterpreter::CommandInterpreter(Debugger &debugger, ScriptLanguage script_language, bool synchronous_execution)
Change over the broadcaster/listener process to hold shared or weak pointers to each other. This should remove some infrequent teardown crashes when the listener is not the debugger's listener. Processes now need to take a ListenerSP, not a Listener&. This required changing over the Process plugin class constructors to take a ListenerSP, instead of a Listener&. Other than that there should be no functional change. <rdar://problem/24580184> CrashTracer: [USER] Xcode at …ework: lldb_private::Listener::BroadcasterWillDestruct + 39 llvm-svn: 262863
2016-03-08 05:50:25 +08:00
: Broadcaster(debugger.GetBroadcasterManager(), CommandInterpreter::GetStaticBroadcasterClass().AsCString()),
Convert the ScriptInterpreter system to a plugin-based one. Previously embedded interpreters were handled as ad-hoc source files compiled into source/Interpreter. This made it hard to disable a specific interpreter, or to add support for other interpreters and allow the developer to choose which interpreter(s) were enabled for a particular build. This patch converts script interpreters over to a plugin-based system. Script interpreters now live in source/Plugins/ScriptInterpreter, and the canonical LLDB interpreter, ScriptInterpreterPython, is moved there as well. Any new code interfacing with the Python C API must live in this location from here on out. Additionally, generic code should never need to reference or make assumptions about the presence of a specific interpreter going forward. Differential Revision: http://reviews.llvm.org/D11431 Reviewed By: Greg Clayton llvm-svn: 243681
2015-07-31 04:28:07 +08:00
Properties(OptionValuePropertiesSP(new OptionValueProperties(ConstString("interpreter")))),
IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand),
m_debugger(debugger),
m_synchronous_execution(synchronous_execution),
m_skip_lldbinit_files(false),
m_skip_app_init_files(false),
m_script_interpreter_sp(),
m_command_io_handler_sp(),
m_comment_char('#'),
m_batch_command_mode(false),
m_truncation_warning(eNoTruncation),
m_command_source_depth(0),
m_num_errors(0),
m_quit_requested(false),
m_stopped_for_crash(false)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Reimplemented the code that backed the "settings" in lldb. There were many issues with the previous implementation: - no setting auto completion - very manual and error prone way of getting/setting variables - tons of code duplication - useless instance names for processes, threads Now settings can easily be defined like option values. The new settings makes use of the "OptionValue" classes so we can re-use the option value code that we use to set settings in command options. No more instances, just "does the right thing". llvm-svn: 162366
2012-08-23 01:17:09 +08:00
debugger.SetScriptLanguage (script_language);
Cleaned up the API logging a lot more to reduce redundant information and keep the file size a bit smaller. Exposed SBValue::GetExpressionPath() so SBValue users can get an expression path for their values. llvm-svn: 117851
2010-10-31 11:01:06 +08:00
SetEventName (eBroadcastBitThreadShouldExit, "thread-should-exit");
SetEventName (eBroadcastBitResetPrompt, "reset-prompt");
Reimplemented the code that backed the "settings" in lldb. There were many issues with the previous implementation: - no setting auto completion - very manual and error prone way of getting/setting variables - tons of code duplication - useless instance names for processes, threads Now settings can easily be defined like option values. The new settings makes use of the "OptionValue" classes so we can re-use the option value code that we use to set settings in command options. No more instances, just "does the right thing". llvm-svn: 162366
2012-08-23 01:17:09 +08:00
SetEventName (eBroadcastBitQuitCommandReceived, "quit");
Add a general mechanism to wait on the debugger for Broadcasters of a given class/event bit set. Use this to allow the lldb Driver to emit notifications for breakpoint modifications. <rdar://problem/10619974> llvm-svn: 150665
2012-02-16 14:50:00 +08:00
CheckInWithManager ();
<rdar://problem/12022079> Added a new "interpreter" properties to encapsulate any properties for the command interpreter. Right now this contains only "expand-regex-aliases", so you can now enable (disabled by default) the echoing of the command that a regular expression alias expands to: (lldb) b main Breakpoint created: 1: name = 'main', locations = 1 Note that the expanded regular expression command wasn't shown by default. You can enable it if you want to: (lldb) settings set interpreter.expand-regex-aliases true (lldb) b main breakpoint set --name 'main' Breakpoint created: 1: name = 'main', locations = 1 Also enabled auto completion for enumeration option values (OptionValueEnumeration) and for boolean option values (OptionValueBoolean). Fixed auto completion for settings names when nothing has been type (it should show all settings). llvm-svn: 162418
2012-08-23 08:22:02 +08:00
m_collection_sp->Initialize (g_properties);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
<rdar://problem/12022079> Added a new "interpreter" properties to encapsulate any properties for the command interpreter. Right now this contains only "expand-regex-aliases", so you can now enable (disabled by default) the echoing of the command that a regular expression alias expands to: (lldb) b main Breakpoint created: 1: name = 'main', locations = 1 Note that the expanded regular expression command wasn't shown by default. You can enable it if you want to: (lldb) settings set interpreter.expand-regex-aliases true (lldb) b main breakpoint set --name 'main' Breakpoint created: 1: name = 'main', locations = 1 Also enabled auto completion for enumeration option values (OptionValueEnumeration) and for boolean option values (OptionValueBoolean). Fixed auto completion for settings names when nothing has been type (it should show all settings). llvm-svn: 162418
2012-08-23 08:22:02 +08:00
bool
CommandInterpreter::GetExpandRegexAliases () const
{
const uint32_t idx = ePropertyExpandRegexAliases;
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
return m_collection_sp->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
<rdar://problem/12022079> Added a new "interpreter" properties to encapsulate any properties for the command interpreter. Right now this contains only "expand-regex-aliases", so you can now enable (disabled by default) the echoing of the command that a regular expression alias expands to: (lldb) b main Breakpoint created: 1: name = 'main', locations = 1 Note that the expanded regular expression command wasn't shown by default. You can enable it if you want to: (lldb) settings set interpreter.expand-regex-aliases true (lldb) b main breakpoint set --name 'main' Breakpoint created: 1: name = 'main', locations = 1 Also enabled auto completion for enumeration option values (OptionValueEnumeration) and for boolean option values (OptionValueBoolean). Fixed auto completion for settings names when nothing has been type (it should show all settings). llvm-svn: 162418
2012-08-23 08:22:02 +08:00
}
<rdar://problem/12786725> If there is any alive process being debugged, the user is asked for confirmation before quitting LLDB This should prevent situations where the user mistakenly types "q" and LLDB slaughters their process without any mercy whatsoever Since it can quickly get tedious, there is a new setting on the command interpreter to disable this and replicate the previous behavior llvm-svn: 172757
2013-01-18 05:36:19 +08:00
bool
CommandInterpreter::GetPromptOnQuit () const
{
const uint32_t idx = ePropertyPromptOnQuit;
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
return m_collection_sp->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
<rdar://problem/12786725> If there is any alive process being debugged, the user is asked for confirmation before quitting LLDB This should prevent situations where the user mistakenly types "q" and LLDB slaughters their process without any mercy whatsoever Since it can quickly get tedious, there is a new setting on the command interpreter to disable this and replicate the previous behavior llvm-svn: 172757
2013-01-18 05:36:19 +08:00
}
<rdar://problem/12022079> Added a new "interpreter" properties to encapsulate any properties for the command interpreter. Right now this contains only "expand-regex-aliases", so you can now enable (disabled by default) the echoing of the command that a regular expression alias expands to: (lldb) b main Breakpoint created: 1: name = 'main', locations = 1 Note that the expanded regular expression command wasn't shown by default. You can enable it if you want to: (lldb) settings set interpreter.expand-regex-aliases true (lldb) b main breakpoint set --name 'main' Breakpoint created: 1: name = 'main', locations = 1 Also enabled auto completion for enumeration option values (OptionValueEnumeration) and for boolean option values (OptionValueBoolean). Fixed auto completion for settings names when nothing has been type (it should show all settings). llvm-svn: 162418
2012-08-23 08:22:02 +08:00
Turn off 'quit' confirmation in lldb-mi Summary: # Turn off interpreter.prompt-on-quit on startup (MI) # Add CommandInterpreter::SetPromptOnQuit # Add SBCommandInterpreter::GetPromptOnQuit/SetPromptOnQuit All tests pass on OS X. Test Plan: ``` -file-exec-and-symbols ~/p/hello -break-insert -f main -exec-run -interpreter-exec console quit ``` Reviewers: abidh, clayborg Reviewed By: abidh, clayborg Subscribers: lldb-commits, clayborg, abidh Differential Revision: http://reviews.llvm.org/D8444 llvm-svn: 233034
2015-03-24 06:45:13 +08:00
void
CommandInterpreter::SetPromptOnQuit (bool b)
{
const uint32_t idx = ePropertyPromptOnQuit;
m_collection_sp->SetPropertyAtIndexAsBoolean (nullptr, idx, b);
}
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
void
CommandInterpreter::ResolveCommand(const char *command_line, CommandReturnObject &result)
{
std::string command = command_line;
if (ResolveCommandImpl(command, result) != nullptr) {
result.AppendMessageWithFormat("%s", command.c_str());
result.SetStatus(eReturnStatusSuccessFinishResult);
}
}
<rdar://problem/12876503> Adding a new setting interpreter.stop-command-source-on-error that dictates a default behavior for whether command source should stop upon hitting an error You can still override the setting for each individual invocation with the usual -e setting llvm-svn: 183719
2013-06-11 09:26:35 +08:00
bool
CommandInterpreter::GetStopCmdSourceOnError () const
{
const uint32_t idx = ePropertyStopCmdSourceOnError;
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
return m_collection_sp->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
<rdar://problem/12876503> Adding a new setting interpreter.stop-command-source-on-error that dictates a default behavior for whether command source should stop upon hitting an error You can still override the setting for each individual invocation with the usual -e setting llvm-svn: 183719
2013-06-11 09:26:35 +08:00
}
Added the concept of a Read-Eval-Print-Loop to LLDB. A REPL takes over the command line and typically treats input as source code. REPLs can also do code completion. The REPL class allows its subclasses to implement the language-specific functionality without having to know about the IOHandler-specific internals. Also added a PluginManager-based way of getting to a REPL given a language and a target. Also brought in some utility code and expression options that are useful for REPLs, such as line offsets for expressions, ANSI terminal coloring of errors, and a few IOHandler convenience functions. llvm-svn: 250753
2015-10-20 07:11:07 +08:00
bool
CommandInterpreter::GetSpaceReplPrompts () const
{
const uint32_t idx = eSpaceReplPrompts;
return m_collection_sp->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
void
CommandInterpreter::Initialize ()
{
Delete Host/windows/win32.h It's always hard to remember when to include this file, and when you do include it it's hard to remember what preprocessor check it needs to be behind, and then you further have to remember whether it's windows.h or win32.h which you need to include. This patch changes the name to PosixApi.h, which is more appropriately named, and makes it independent of any preprocessor setting. There's still the issue of people not knowing when to include this, because there's not a well-defined set of things it exposes other than "whatever is missing on Windows", but at least this should make it less painful to fix when problems arise. This patch depends on LLVM revision r278170. llvm-svn: 278177
2016-08-10 07:06:08 +08:00
Timer scoped_timer (LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
CommandReturnObject result;
LoadCommandDictionary ();
Add the "block" keyword to "thread step-in -e", and an alias that uses it: "sif <target function>" - i.e. step-into-function to allow you to step through a complex calling sequence into a particular function that may span multiple lines. Also some test cases for this and the --step-target feature. llvm-svn: 261953
2016-02-26 09:37:30 +08:00
// An alias arguments vector to reuse - reset it before use...
OptionArgVectorSP alias_arguments_vector_sp (new OptionArgVector);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
// Set up some initial aliases.
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
CommandObjectSP cmd_obj_sp = GetCommandSPExact ("quit", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("q", cmd_obj_sp);
AddAlias ("exit", cmd_obj_sp);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
}
Added an "attach" alias as promised on the web page. llvm-svn: 156223
2012-05-05 07:15:02 +08:00
rdar://problem/11811338 Add 'attach <pid>|<process-name>' command to lldb, as well as 'detach' which is an alias of 'process detach'. Add two completion test cases for "attach" and "detach". llvm-svn: 162573
2012-08-25 02:15:45 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-attach",false);
Added an "attach" alias as promised on the web page. llvm-svn: 156223
2012-05-05 07:15:02 +08:00
if (cmd_obj_sp)
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("attach", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
rdar://problem/11811338 Add 'attach <pid>|<process-name>' command to lldb, as well as 'detach' which is an alias of 'process detach'. Add two completion test cases for "attach" and "detach". llvm-svn: 162573
2012-08-25 02:15:45 +08:00
cmd_obj_sp = GetCommandSPExact ("process detach",false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("detach", cmd_obj_sp);
rdar://problem/11811338 Add 'attach <pid>|<process-name>' command to lldb, as well as 'detach' which is an alias of 'process detach'. Add two completion test cases for "attach" and "detach". llvm-svn: 162573
2012-08-25 02:15:45 +08:00
}
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("process continue", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("c", cmd_obj_sp);
AddAlias ("continue", cmd_obj_sp);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
}
cmd_obj_sp = GetCommandSPExact ("_regexp-break",false);
if (cmd_obj_sp)
Workaround the fact that "b" is now a separate command object from "_regexp-break", and thus "help b" doesn't show the possible syntaxes It would be nice to have a longer-term plan for how to handle help for regular expression commands, since their syntax is highly irregular. I can see a few options (*), but for now this is a reasonable stop-gag measure for the most blatant regression. (*) the simplest is, of course, to detect a regex command and inherit the syntax for any aliases thereof; it would be nice if this also didn't show the underlying regex command name when the alias is used llvm-svn: 263523
2016-03-15 09:57:10 +08:00
AddAlias ("b", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-tbreak",false);
if (cmd_obj_sp)
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("tbreak", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("thread step-inst", false);
if (cmd_obj_sp)
Add "stepi" as an alias for thread step-inst in addition to "si". Add "nexti" an "ni" as aliases for thread step-inst-over. llvm-svn: 142707
2011-10-22 08:47:41 +08:00
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("stepi", cmd_obj_sp);
AddAlias ("si", cmd_obj_sp);
Add "stepi" as an alias for thread step-inst in addition to "si". Add "nexti" an "ni" as aliases for thread step-inst-over. llvm-svn: 142707
2011-10-22 08:47:41 +08:00
}
cmd_obj_sp = GetCommandSPExact ("thread step-inst-over", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("nexti", cmd_obj_sp);
AddAlias ("ni", cmd_obj_sp);
Add "stepi" as an alias for thread step-inst in addition to "si". Add "nexti" an "ni" as aliases for thread step-inst-over. llvm-svn: 142707
2011-10-22 08:47:41 +08:00
}
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("thread step-in", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("s", cmd_obj_sp);
AddAlias ("step", cmd_obj_sp);
Use Enrico's new CommandAlias to give better help to the "sif" command. llvm-svn: 263865
2016-03-19 08:53:20 +08:00
CommandAlias *sif_alias = AddAlias ("sif", cmd_obj_sp, "--end-linenumber block --step-in-target %1");
if (sif_alias)
{
sif_alias->SetHelp("Step through the current block, stopping if you step "
"directly into a function whose name matches the TargetFunctionName.");
sif_alias->SetSyntax("sif <TargetFunctionName>");
}
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
}
cmd_obj_sp = GetCommandSPExact ("thread step-over", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("n", cmd_obj_sp);
AddAlias ("next", cmd_obj_sp);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
}
cmd_obj_sp = GetCommandSPExact ("thread step-out", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("finish", cmd_obj_sp);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
}
"f" should be an alias for "frame select" not "finish" to match the gdb usage. llvm-svn: 145660
2011-12-02 09:12:59 +08:00
cmd_obj_sp = GetCommandSPExact ("frame select", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("f", cmd_obj_sp);
"f" should be an alias for "frame select" not "finish" to match the gdb usage. llvm-svn: 145660
2011-12-02 09:12:59 +08:00
}
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
cmd_obj_sp = GetCommandSPExact ("thread select", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("t", cmd_obj_sp);
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
}
Added a 'jump' command, similar to GDBs. This allows the PC to be directly changed to a different line. It's similar to the example python script in examples/python/jump.py, except implemented as a builtin. Also this version will track the current function correctly even if the target line resolves to multiple addresses. (e.g. debugging a templated function) llvm-svn: 190572
2013-09-12 10:20:34 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-jump",false);
if (cmd_obj_sp)
{
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("j", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
AddAlias ("jump", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Added a 'jump' command, similar to GDBs. This allows the PC to be directly changed to a different line. It's similar to the example python script in examples/python/jump.py, except implemented as a builtin. Also this version will track the current function correctly even if the target line resolves to multiple addresses. (e.g. debugging a templated function) llvm-svn: 190572
2013-09-12 10:20:34 +08:00
}
<rdar://problem/13050227> Added a regular expression command called "_regexp-list" which mimics the GDB "line" command in the following forms: LINENUM, to list around that line in current file, FILE:LINENUM, to list around that line in that file, FUNCTION, to list around beginning of that function, *ADDRESS, to list around the line containing that address. ADDRESS, same as above, but don't require a '*' as long as ADDRESS is hex llvm-svn: 174233
2013-02-02 07:33:03 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-list", false);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
if (cmd_obj_sp)
{
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("l", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
AddAlias ("list", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
}
<rdar://problem/13178743> Added a new "env" regular expression alias. If "env" is typed on its own "settings show target.env-vars" will be run. Otherwise it can be used to set and environment variable: "env FOO=BAR". llvm-svn: 174991
2013-02-13 02:52:24 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-env", false);
if (cmd_obj_sp)
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("env", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
<rdar://problem/13178743> Added a new "env" regular expression alias. If "env" is typed on its own "settings show target.env-vars" will be run. Otherwise it can be used to set and environment variable: "env FOO=BAR". llvm-svn: 174991
2013-02-13 02:52:24 +08:00
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("memory read", false);
if (cmd_obj_sp)
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("x", cmd_obj_sp);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-up", false);
if (cmd_obj_sp)
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("up", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-down", false);
if (cmd_obj_sp)
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("down", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
Prefix display/undisplay regexp command alises with "_regexp" as per the style of the other regexp command aliases. llvm-svn: 142902
2011-10-25 10:11:20 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-display", false);
Add "display" and "undisplay" aliases for target stop-hook add/delete. A patina of gdb's "display" command, intended mostly for simply monitoring a variable as you step through source code. Formatters do not work, e.g. display/x $pc does not work. llvm-svn: 142710
2011-10-22 09:30:52 +08:00
if (cmd_obj_sp)
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("display", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Add "di" and "dis" aliases to "disassemble" so they will win over "display". llvm-svn: 142834
2011-10-25 02:37:00 +08:00
cmd_obj_sp = GetCommandSPExact ("disassemble", false);
if (cmd_obj_sp)
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("dis", cmd_obj_sp);
Add "di" and "dis" aliases to "disassemble" so they will win over "display". llvm-svn: 142834
2011-10-25 02:37:00 +08:00
cmd_obj_sp = GetCommandSPExact ("disassemble", false);
if (cmd_obj_sp)
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("di", cmd_obj_sp);
Add "di" and "dis" aliases to "disassemble" so they will win over "display". llvm-svn: 142834
2011-10-25 02:37:00 +08:00
Add "display" and "undisplay" aliases for target stop-hook add/delete. A patina of gdb's "display" command, intended mostly for simply monitoring a variable as you step through source code. Formatters do not work, e.g. display/x $pc does not work. llvm-svn: 142710
2011-10-22 09:30:52 +08:00
Prefix display/undisplay regexp command alises with "_regexp" as per the style of the other regexp command aliases. llvm-svn: 142902
2011-10-25 10:11:20 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-undisplay", false);
Add "display" and "undisplay" aliases for target stop-hook add/delete. A patina of gdb's "display" command, intended mostly for simply monitoring a variable as you step through source code. Formatters do not work, e.g. display/x $pc does not work. llvm-svn: 142710
2011-10-22 09:30:52 +08:00
if (cmd_obj_sp)
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("undisplay", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Add "display" and "undisplay" aliases for target stop-hook add/delete. A patina of gdb's "display" command, intended mostly for simply monitoring a variable as you step through source code. Formatters do not work, e.g. display/x $pc does not work. llvm-svn: 142710
2011-10-22 09:30:52 +08:00
Don't make regexp commands as regular commands - they are "short cuts" and users should be able to override them with "unalias" but you can't unalias normal commands. llvm-svn: 165630
2012-10-11 00:51:31 +08:00
cmd_obj_sp = GetCommandSPExact ("_regexp-bt", false);
if (cmd_obj_sp)
Add help for our regular expression commands when aliased llvm-svn: 265819
2016-04-09 01:56:26 +08:00
AddAlias ("bt", cmd_obj_sp)->SetSyntax(cmd_obj_sp->GetSyntax());
Don't make regexp commands as regular commands - they are "short cuts" and users should be able to override them with "unalias" but you can't unalias normal commands. llvm-svn: 165630
2012-10-11 00:51:31 +08:00
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("target create", false);
if (cmd_obj_sp)
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("file", cmd_obj_sp);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("target modules", false);
if (cmd_obj_sp)
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("image", cmd_obj_sp);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
Clear alias argument vector for 'p' alias. Summary: This fixes the 'p' command which should be aliased to 'expresion --'. Reviewers: jingham Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D17634 llvm-svn: 261969
2016-02-26 11:36:27 +08:00
alias_arguments_vector_sp.reset(new OptionArgVector);
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("expression", false);
if (cmd_obj_sp)
Removed the "expr" alias for "expression," which is entirely unnecessary and confuses the command interpreter when the user types "exp". llvm-svn: 179691
2013-04-18 01:23:58 +08:00
{
Make it so that a command alias can actually remove the help/long help from its parent command by setting itself to an empty help string llvm-svn: 264108
2016-03-23 06:12:59 +08:00
AddAlias ("p", cmd_obj_sp, "--")->SetHelpLong("");
AddAlias ("print", cmd_obj_sp, "--")->SetHelpLong("");
AddAlias ("call", cmd_obj_sp, "--")->SetHelpLong("");
if (auto po = AddAlias ("po", cmd_obj_sp, "-O --"))
{
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
po->SetHelp("Evaluate an expression on the current thread. Displays any returned value with formatting "
"controlled by the type's author.");
Make it so that a command alias can actually remove the help/long help from its parent command by setting itself to an empty help string llvm-svn: 264108
2016-03-23 06:12:59 +08:00
po->SetHelpLong("");
}
Add a --element-count option to the expression command This option evaluates an expression and, if the result is of pointer type, treats it as if it was an array of that many elements and displays such elements This has a couple subtle points but is mostly as straightforward as it sounds Add a parray N <expr> alias for this new mode Also, extend the --object-description mode to do the moral equivalent of the above but display each element in --object-description mode Add a poarray N <expr> alias for this llvm-svn: 267372
2016-04-25 08:52:47 +08:00
AddAlias("parray", cmd_obj_sp, "--element-count %1 --")->SetHelpLong("");
AddAlias("poarray", cmd_obj_sp, "--object-description --element-count %1 --")->SetHelpLong("");
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
}
Added "kill" as an alias for "process kill". llvm-svn: 157856
2012-06-02 07:29:32 +08:00
cmd_obj_sp = GetCommandSPExact ("process kill", false);
if (cmd_obj_sp)
Added "k" as an alias to "process kill" since the new "kdb-remote" will now conflict with it. llvm-svn: 164737
2012-09-27 08:02:27 +08:00
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("kill", cmd_obj_sp);
Added "k" as an alias to "process kill" since the new "kdb-remote" will now conflict with it. llvm-svn: 164737
2012-09-27 08:02:27 +08:00
}
Added "kill" as an alias for "process kill". llvm-svn: 157856
2012-06-02 07:29:32 +08:00
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
cmd_obj_sp = GetCommandSPExact ("process launch", false);
if (cmd_obj_sp)
{
alias_arguments_vector_sp.reset (new OptionArgVector);
__arm64__ and __aarch64__ #ifdef adjustments Change by Paul Osmialowski See http://reviews.llvm.org/D4379 for details. llvm-svn: 212583
2014-07-09 09:29:05 +08:00
#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("r", cmd_obj_sp, "--");
AddAlias ("run", cmd_obj_sp, "--");
Change the "run" / "r" command alias to not use --shell for lldb running natively on arm - on iOS we have to do some extra work to track the inferior process if we launch with a shell intermediary. <rdar://problem/11719396> llvm-svn: 159803
2012-07-06 10:46:23 +08:00
#else
Move the "run" alias from process launch --shell to process launch --shell-expand-args when building on OS X The argdumper-based launching is more friendly to System Integrity Protection, and will work on older releases of OS X as well Leave non-Apple builds alone llvm-svn: 248338
2015-09-23 06:57:12 +08:00
#if defined(__APPLE__)
std::string shell_option;
shell_option.append("--shell-expand-args");
shell_option.append(" true");
shell_option.append(" --");
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("r", cmd_obj_sp, "--shell-expand-args true --");
AddAlias ("run", cmd_obj_sp, "--shell-expand-args true --");
Move the "run" alias from process launch --shell to process launch --shell-expand-args when building on OS X The argdumper-based launching is more friendly to System Integrity Protection, and will work on older releases of OS X as well Leave non-Apple builds alone llvm-svn: 248338
2015-09-23 06:57:12 +08:00
#else
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
StreamString defaultshell;
Use c_str() instead of GetCString() to fix build llvm-svn: 262920
2016-03-08 18:03:23 +08:00
defaultshell.Printf("--shell=%s --", HostInfo::GetDefaultShell().GetPath().c_str());
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("r", cmd_obj_sp, defaultshell.GetData());
AddAlias ("run", cmd_obj_sp, defaultshell.GetData());
Move the "run" alias from process launch --shell to process launch --shell-expand-args when building on OS X The argdumper-based launching is more friendly to System Integrity Protection, and will work on older releases of OS X as well Leave non-Apple builds alone llvm-svn: 248338
2015-09-23 06:57:12 +08:00
#endif
Change the "run" / "r" command alias to not use --shell for lldb running natively on arm - on iOS we have to do some extra work to track the inferior process if we launch with a shell intermediary. <rdar://problem/11719396> llvm-svn: 159803
2012-07-06 10:46:23 +08:00
#endif
Replace calls to HandleCommand in lldb core with more appropriate direct function calls. As part of this, collect code that processes arguments & options for aliases into a single function. llvm-svn: 131020
2011-05-07 05:37:15 +08:00
}
Added a "add-dsym" alias to "target symbols add" to keep gdb converts happy. llvm-svn: 153695
2012-03-30 05:47:51 +08:00
cmd_obj_sp = GetCommandSPExact ("target symbols add", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("add-dsym", cmd_obj_sp);
Added a "add-dsym" alias to "target symbols add" to keep gdb converts happy. llvm-svn: 153695
2012-03-30 05:47:51 +08:00
}
Added an "rb" alias that sets breakpoints by regular expression. llvm-svn: 157202
2012-05-22 02:25:19 +08:00
cmd_obj_sp = GetCommandSPExact ("breakpoint set", false);
if (cmd_obj_sp)
{
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
AddAlias ("rbreak", cmd_obj_sp, "--func-regex %1");
Added an "rb" alias that sets breakpoints by regular expression. llvm-svn: 157202
2012-05-22 02:25:19 +08:00
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Make sure that the CommandInterpreter::m_command_io_handler_sp gets reset when we quit. Currently if you run _any_ python, python has the "lldb.debugger" global variable and it has a strong reference to a lldb_private::Debugger since it is a lldb::SBDebugger object with a shared pointer. This makes sure that your LLDB command interpreter history is saved each time you quit command line LLDB. llvm-svn: 207164
2014-04-25 08:35:14 +08:00
void
CommandInterpreter::Clear()
{
m_command_io_handler_sp.reset();
Convert the ScriptInterpreter system to a plugin-based one. Previously embedded interpreters were handled as ad-hoc source files compiled into source/Interpreter. This made it hard to disable a specific interpreter, or to add support for other interpreters and allow the developer to choose which interpreter(s) were enabled for a particular build. This patch converts script interpreters over to a plugin-based system. Script interpreters now live in source/Plugins/ScriptInterpreter, and the canonical LLDB interpreter, ScriptInterpreterPython, is moved there as well. Any new code interfacing with the Python C API must live in this location from here on out. Additionally, generic code should never need to reference or make assumptions about the presence of a specific interpreter going forward. Differential Revision: http://reviews.llvm.org/D11431 Reviewed By: Greg Clayton llvm-svn: 243681
2015-07-31 04:28:07 +08:00
if (m_script_interpreter_sp)
m_script_interpreter_sp->Clear();
Make sure that the CommandInterpreter::m_command_io_handler_sp gets reset when we quit. Currently if you run _any_ python, python has the "lldb.debugger" global variable and it has a strong reference to a lldb_private::Debugger since it is a lldb::SBDebugger object with a shared pointer. This makes sure that your LLDB command interpreter history is saved each time you quit command line LLDB. llvm-svn: 207164
2014-04-25 08:35:14 +08:00
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
const char *
CommandInterpreter::ProcessEmbeddedScriptCommands (const char *arg)
{
// This function has not yet been implemented.
// Look for any embedded script command
// If found,
// get interpreter object from the command dictionary,
// call execute_one_command on it,
// get the results as a string,
// substitute that string for current stuff.
return arg;
}
void
CommandInterpreter::LoadCommandDictionary ()
{
Delete Host/windows/win32.h It's always hard to remember when to include this file, and when you do include it it's hard to remember what preprocessor check it needs to be behind, and then you further have to remember whether it's windows.h or win32.h which you need to include. This patch changes the name to PosixApi.h, which is more appropriately named, and makes it independent of any preprocessor setting. There's still the issue of people not knowing when to include this, because there's not a well-defined set of things it exposes other than "whatever is missing on Windows", but at least this should make it less painful to fix when problems arise. This patch depends on LLVM revision r278170. llvm-svn: 278177
2016-08-10 07:06:08 +08:00
Timer scoped_timer (LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
Add UserSettings to Target class, making Target settings the parent of Process settings; add 'default-arch' as a class-wide setting for Target. Replace lldb::GetDefaultArchitecture with Target::GetDefaultArchitecture & Target::SetDefaultArchitecture. Add 'use-external-editor' as user setting to Debugger class & update code appropriately. Add Error parameter to methods that get user settings, for easier reporting of bad requests. Fix various other minor related bugs. Fix test cases to work with new changes. llvm-svn: 114352
2010-09-21 04:44:43 +08:00
lldb::ScriptLanguage script_language = m_debugger.GetScriptLanguage();
This is a very large commit that completely re-does the way lldb handles user settable internal variables (the equivalent of set/show variables in gdb). In addition to the basic infrastructure (most of which is defined in UserSettingsController.{h,cpp}, there are examples of two classes that have been set up to contain user settable variables (the Debugger and Process classes). The 'settings' command has been modified to be a command-subcommand structure, and the 'set', 'show' and 'append' commands have been moved into this sub-commabnd structure. The old StateVariable class has been completely replaced by this, and the state variable dictionary has been removed from the Command Interpreter. Places that formerly accessed the state variable mechanism have been modified to access the variables in this new structure instead (checking the term-width; getting/checking the prompt; etc.) Variables are attached to classes; there are two basic "flavors" of variables that can be set: "global" variables (static/class-wide), and "instance" variables (one per instance of the class). The whole thing has been set up so that any global or instance variable can be set at any time (e.g. on start up, in your .lldbinit file), whether or not any instances actually exist (there's a whole pending and default values mechanism to help deal with that). llvm-svn: 113041
2010-09-04 08:03:46 +08:00
Fixed the way set/show variables were being accessed to being natively accessed by the objects that own the settings. The previous approach wasn't very usable and made for a lot of unnecessary code just to access variables that were already owned by the objects. While I fixed those things, I saw that CommandObject objects should really have a reference to their command interpreter so they can access the terminal with if they want to output usaage. Fixed up all CommandObjects to take an interpreter and cleaned up the API to not need the interpreter to be passed in. Fixed the disassemble command to output the usage if no options are passed down and arguments are passed (all disassebmle variants take options, there are no "args only"). llvm-svn: 114252
2010-09-18 09:14:36 +08:00
m_command_dict["apropos"] = CommandObjectSP (new CommandObjectApropos (*this));
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
m_command_dict["breakpoint"]= CommandObjectSP (new CommandObjectMultiwordBreakpoint (*this));
Add new bugreport command to lldb The new command add functionality to print out domain specific information for reporting a bug. Currently the only supported domain is stack unwinding (with "bugreport unwind") but adding new domains is fairly easy. Differential revision: http://reviews.llvm.org/D10868 llvm-svn: 241252
2015-07-02 18:03:37 +08:00
m_command_dict["bugreport"] = CommandObjectSP (new CommandObjectMultiwordBugreport (*this));
Fixed some more 'commands' to 'command' change. llvm-svn: 129897
2011-04-21 08:39:18 +08:00
m_command_dict["command"] = CommandObjectSP (new CommandObjectMultiwordCommands (*this));
Fixed the way set/show variables were being accessed to being natively accessed by the objects that own the settings. The previous approach wasn't very usable and made for a lot of unnecessary code just to access variables that were already owned by the objects. While I fixed those things, I saw that CommandObject objects should really have a reference to their command interpreter so they can access the terminal with if they want to output usaage. Fixed up all CommandObjects to take an interpreter and cleaned up the API to not need the interpreter to be passed in. Fixed the disassemble command to output the usage if no options are passed down and arguments are passed (all disassebmle variants take options, there are no "args only"). llvm-svn: 114252
2010-09-18 09:14:36 +08:00
m_command_dict["disassemble"] = CommandObjectSP (new CommandObjectDisassemble (*this));
m_command_dict["expression"]= CommandObjectSP (new CommandObjectExpression (*this));
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
m_command_dict["frame"] = CommandObjectSP (new CommandObjectMultiwordFrame (*this));
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
m_command_dict["gui"] = CommandObjectSP (new CommandObjectGUI (*this));
Fixed the way set/show variables were being accessed to being natively accessed by the objects that own the settings. The previous approach wasn't very usable and made for a lot of unnecessary code just to access variables that were already owned by the objects. While I fixed those things, I saw that CommandObject objects should really have a reference to their command interpreter so they can access the terminal with if they want to output usaage. Fixed up all CommandObjects to take an interpreter and cleaned up the API to not need the interpreter to be passed in. Fixed the disassemble command to output the usage if no options are passed down and arguments are passed (all disassebmle variants take options, there are no "args only"). llvm-svn: 114252
2010-09-18 09:14:36 +08:00
m_command_dict["help"] = CommandObjectSP (new CommandObjectHelp (*this));
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
m_command_dict["log"] = CommandObjectSP (new CommandObjectLog (*this));
m_command_dict["memory"] = CommandObjectSP (new CommandObjectMemory (*this));
Added more platform support. There are now some new commands: platform status -- gets status information for the selected platform platform create <platform-name> -- creates a new instance of a remote platform platform list -- list all available platforms platform select -- select a platform instance as the current platform (not working yet) When using "platform create" it will create a remote platform and make it the selected platform. For instances for iPhone OS debugging on Mac OS X one can do: (lldb) platform create remote-ios --sdk-version=4.0 Remote platform: iOS platform SDK version: 4.0 SDK path: "/Developer/Platforms/iPhoneOS.platform/DeviceSupport/4.0" Not connected to a remote device. (lldb) file ~/Documents/a.out Current executable set to '~/Documents/a.out' (armv6). (lldb) image list [ 0] /Volumes/work/gclayton/Documents/devb/attach/a.out [ 1] /Developer/Platforms/iPhoneOS.platform/DeviceSupport/4.0/Symbols/usr/lib/dyld [ 2] /Developer/Platforms/iPhoneOS.platform/DeviceSupport/4.0/Symbols/usr/lib/libSystem.B.dylib Note that this is all happening prior to running _or_ connecting to a remote platform. Once connected to a remote platform the OS version might change which means we will need to update our dependecies. Also once we run, we will need to match up the actualy binaries with the actualy UUID's to files in the SDK, or download and cache them locally. This is just the start of the remote platforms, but this modification is the first iteration in getting the platforms really doing something. llvm-svn: 127934
2011-03-19 09:12:21 +08:00
m_command_dict["platform"] = CommandObjectSP (new CommandObjectPlatform (*this));
Implementing plugins that provide commands. This checkin adds the capability for LLDB to load plugins from external dylibs that can provide new commands It exports an SBCommand class from the public API layer, and a new SBCommandPluginInterface There is a minimal load-only plugin manager built into the debugger, which can be accessed via Debugger::LoadPlugin. Plugins are loaded from two locations at debugger startup (LLDB.framework/Resources/PlugIns and ~/Library/Application Support/LLDB/PlugIns) and more can be (re)loaded via the "plugin load" command For an example of how to make a plugin, refer to the fooplugin.cpp file in examples/plugins/commands Caveats: Currently, the new API objects and features are not exposed via Python. The new commands can only be "parsed" (i.e. not raw) and get their command line via a char** parameter (we do not expose our internal Args object) There is no unloading feature, which can potentially lead to leaks if you overwrite the commands by reloading the same or different plugins There is no API exposed for option parsing, which means you may need to use getopt or roll-your-own llvm-svn: 164865
2012-09-29 07:57:51 +08:00
m_command_dict["plugin"] = CommandObjectSP (new CommandObjectPlugin (*this));
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
m_command_dict["process"] = CommandObjectSP (new CommandObjectMultiwordProcess (*this));
Fixed the way set/show variables were being accessed to being natively accessed by the objects that own the settings. The previous approach wasn't very usable and made for a lot of unnecessary code just to access variables that were already owned by the objects. While I fixed those things, I saw that CommandObject objects should really have a reference to their command interpreter so they can access the terminal with if they want to output usaage. Fixed up all CommandObjects to take an interpreter and cleaned up the API to not need the interpreter to be passed in. Fixed the disassemble command to output the usage if no options are passed down and arguments are passed (all disassebmle variants take options, there are no "args only"). llvm-svn: 114252
2010-09-18 09:14:36 +08:00
m_command_dict["quit"] = CommandObjectSP (new CommandObjectQuit (*this));
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
m_command_dict["register"] = CommandObjectSP (new CommandObjectRegister (*this));
Fixed the way set/show variables were being accessed to being natively accessed by the objects that own the settings. The previous approach wasn't very usable and made for a lot of unnecessary code just to access variables that were already owned by the objects. While I fixed those things, I saw that CommandObject objects should really have a reference to their command interpreter so they can access the terminal with if they want to output usaage. Fixed up all CommandObjects to take an interpreter and cleaned up the API to not need the interpreter to be passed in. Fixed the disassemble command to output the usage if no options are passed down and arguments are passed (all disassebmle variants take options, there are no "args only"). llvm-svn: 114252
2010-09-18 09:14:36 +08:00
m_command_dict["script"] = CommandObjectSP (new CommandObjectScript (*this, script_language));
This is a very large commit that completely re-does the way lldb handles user settable internal variables (the equivalent of set/show variables in gdb). In addition to the basic infrastructure (most of which is defined in UserSettingsController.{h,cpp}, there are examples of two classes that have been set up to contain user settable variables (the Debugger and Process classes). The 'settings' command has been modified to be a command-subcommand structure, and the 'set', 'show' and 'append' commands have been moved into this sub-commabnd structure. The old StateVariable class has been completely replaced by this, and the state variable dictionary has been removed from the Command Interpreter. Places that formerly accessed the state variable mechanism have been modified to access the variables in this new structure instead (checking the term-width; getting/checking the prompt; etc.) Variables are attached to classes; there are two basic "flavors" of variables that can be set: "global" variables (static/class-wide), and "instance" variables (one per instance of the class). The whole thing has been set up so that any global or instance variable can be set at any time (e.g. on start up, in your .lldbinit file), whether or not any instances actually exist (there's a whole pending and default values mechanism to help deal with that). llvm-svn: 113041
2010-09-04 08:03:46 +08:00
m_command_dict["settings"] = CommandObjectSP (new CommandObjectMultiwordSettings (*this));
Fix GetRepeatCommand so it works with multi-word commands. Move the "source", "alias", and "unalias" commands to "commands *". Move "source-file" to "source list". Added a "source info" command but it isn't implemented yet. llvm-svn: 107751
2010-07-07 11:36:20 +08:00
m_command_dict["source"] = CommandObjectSP (new CommandObjectMultiwordSource (*this));
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
m_command_dict["target"] = CommandObjectSP (new CommandObjectMultiwordTarget (*this));
m_command_dict["thread"] = CommandObjectSP (new CommandObjectMultiwordThread (*this));
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
m_command_dict["type"] = CommandObjectSP (new CommandObjectType (*this));
Add a simple command: 'version' to the command interpreter, and an accompanying test case test_help_version(). llvm-svn: 122515
2010-12-24 04:21:44 +08:00
m_command_dict["version"] = CommandObjectSP (new CommandObjectVersion (*this));
Add initial implementation of watchpoint commands for list, enable, disable, and delete. Test cases to be added later. llvm-svn: 140322
2011-09-23 02:04:58 +08:00
m_command_dict["watchpoint"]= CommandObjectSP (new CommandObjectMultiwordWatchpoint (*this));
Add language command and LanguageRuntime plugin changes to allow vending of command objects. Differential Revision: http://reviews.llvm.org/D9402 llvm-svn: 236443
2015-05-05 02:39:38 +08:00
m_command_dict["language"] = CommandObjectSP (new CommandObjectLanguage(*this));
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
const char *break_regexes[][2] = {{"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$", "breakpoint set --file '%1' --line %2"},
Added a new regular expression to the "_regexp-break" command ("b" by default): (lldb) b /break here/ This will set a source level regular expression breakpoint on any text between the first '/' and the last '/'. The equivalent command will be: (lldb) breakpoint set --source-pattern-regexp 'break here' llvm-svn: 223082
2014-12-02 06:34:03 +08:00
{"^/([^/]+)/$", "breakpoint set --source-pattern-regexp '%1'"},
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
{"^([[:digit:]]+)[[:space:]]*$", "breakpoint set --line %1"},
Added the ability to specify a breakpoint using the GDB '*ADDRESS' format: (lldb) b *0x1234 You can still of course just specify an address: (lldb) b 0x1234 Also now we accept the '&' before function names to indicate to not to skip the function prologue like GDB supports. To see how this works: (lldb) settings set interpreter.expand-regex-aliases 1 (lldb) b &main breakpoint set --name 'main' --skip-prologue=0 Breakpoint 1: where = a.out`main at main.c:20, address = 0x0000000100000b60 (lldb) b main breakpoint set --name 'main' Breakpoint 2: where = a.out`main + 54 at main.c:21, address = 0x0000000100000b96 llvm-svn: 174695
2013-02-08 10:54:24 +08:00
{"^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "breakpoint set --address %1"},
<rdar://problem/9141269> Cleaned up the objective C name parsing code to use a class. Now breakpoints that are set by name that are objective C methods without the leading '+' or '-' will resolve. We do this by expanding all the objective C names for a given string. For example: (lldb) b [MyString cStringUsingEncoding:] Will set a breakpoint with multiple possible names: -[MyString cStringUsingEncoding:] +[MyString cStringUsingEncoding:] Also if you have a category, it will strip the category and set a breakpoint in all variants: (lldb) [MyString(my_category) cStringUsingEncoding:] Will resolve to the following names: -[MyString(my_category) cStringUsingEncoding:] +[MyString(my_category) cStringUsingEncoding:] -[MyString cStringUsingEncoding:] +[MyString cStringUsingEncoding:] Likewise when we have: (lldb) b -[MyString(my_category) cStringUsingEncoding:] It will resolve to two names: -[MyString(my_category) cStringUsingEncoding:] -[MyString cStringUsingEncoding:] llvm-svn: 173858
2013-01-30 08:18:29 +08:00
{"^[\"']?([-+]?\\[.*\\])[\"']?[[:space:]]*$", "breakpoint set --name '%1'"},
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
{"^(-.*)$", "breakpoint set %1"},
{"^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%2' --shlib '%1'"},
Added the ability to specify a breakpoint using the GDB '*ADDRESS' format: (lldb) b *0x1234 You can still of course just specify an address: (lldb) b 0x1234 Also now we accept the '&' before function names to indicate to not to skip the function prologue like GDB supports. To see how this works: (lldb) settings set interpreter.expand-regex-aliases 1 (lldb) b &main breakpoint set --name 'main' --skip-prologue=0 Breakpoint 1: where = a.out`main at main.c:20, address = 0x0000000100000b60 (lldb) b main breakpoint set --name 'main' Breakpoint 2: where = a.out`main + 54 at main.c:21, address = 0x0000000100000b96 llvm-svn: 174695
2013-02-08 10:54:24 +08:00
{"^\\&(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%1' --skip-prologue=0"},
fix the _regexp-break command to allow quotes around the name: (lldb) b "Foo::Bar::Baz" <rdar://problem/11782098> llvm-svn: 215668
2014-08-15 01:58:33 +08:00
{"^[\"']?(.*[^[:space:]\"'])[\"']?[[:space:]]*$", "breakpoint set --name '%1'"}};
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
lldb: remove adhoc implementation of array_sizeof Replace adhoc inline implementation of llvm::array_lengthof in favour of the implementation in LLVM. This is simply a cleanup change, no functional change intended. llvm-svn: 211868
2014-06-27 13:17:41 +08:00
size_t num_regexes = llvm::array_lengthof(break_regexes);
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> break_regex_cmd_ap(new CommandObjectRegexCommand(
*this, "_regexp-break", "Set a breakpoint using one of several shorthand formats.\n",
"\n"
"_regexp-break <filename>:<linenum>\n"
" main.c:12 // Break at line 12 of main.c\n\n"
"_regexp-break <linenum>\n"
" 12 // Break at line 12 of current file\n\n"
"_regexp-break 0x<address>\n"
" 0x1234000 // Break at address 0x1234000\n\n"
"_regexp-break <name>\n"
" main // Break in 'main' after the prologue\n\n"
"_regexp-break &<name>\n"
" &main // Break at first instruction in 'main'\n\n"
"_regexp-break <module>`<name>\n"
" libc.so`malloc // Break in 'malloc' from 'libc.so'\n\n"
"_regexp-break /<source-regex>/\n"
" /break here/ // Break on source lines in current file\n"
" // containing text 'break here'.\n",
2, CommandCompletions::eSymbolCompletion | CommandCompletions::eSourceFileCompletion, false));
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (break_regex_cmd_ap.get())
{
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
bool success = true;
for (size_t i = 0; i < num_regexes; i++)
{
success = break_regex_cmd_ap->AddRegexCommand (break_regexes[i][0], break_regexes[i][1]);
if (!success)
break;
}
success = break_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full");
if (success)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
CommandObjectSP break_regex_cmd_sp(break_regex_cmd_ap.release());
m_command_dict[break_regex_cmd_sp->GetCommandName ()] = break_regex_cmd_sp;
}
}
Add "up" and "down" aliases. llvm-svn: 128066
2011-03-22 10:29:32 +08:00
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> tbreak_regex_cmd_ap(new CommandObjectRegexCommand(
*this, "_regexp-tbreak", "Set a one-shot breakpoint using one of several shorthand formats.\n",
"\n"
"_regexp-break <filename>:<linenum>\n"
" main.c:12 // Break at line 12 of main.c\n\n"
"_regexp-break <linenum>\n"
" 12 // Break at line 12 of current file\n\n"
"_regexp-break 0x<address>\n"
" 0x1234000 // Break at address 0x1234000\n\n"
"_regexp-break <name>\n"
" main // Break in 'main' after the prologue\n\n"
"_regexp-break &<name>\n"
" &main // Break at first instruction in 'main'\n\n"
"_regexp-break <module>`<name>\n"
" libc.so`malloc // Break in 'malloc' from 'libc.so'\n\n"
"_regexp-break /<source-regex>/\n"
" /break here/ // Break on source lines in current file\n"
" // containing text 'break here'.\n",
2, CommandCompletions::eSymbolCompletion | CommandCompletions::eSourceFileCompletion, false));
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
if (tbreak_regex_cmd_ap.get())
{
bool success = true;
for (size_t i = 0; i < num_regexes; i++)
{
// If you add a resultant command string longer than 1024 characters be sure to increase the size of this buffer.
char buffer[1024];
int num_printed = snprintf(buffer, 1024, "%s %s", break_regexes[i][1], "-o");
assert (num_printed < 1024);
Add UNUSED_IF_ASSERT_DISABLED and apply it. Summary: This replaces (void)x; usages where they x was subsequently involved in an assertion with this macro to make the intent more clear. Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D11451 llvm-svn: 243074
2015-07-24 08:23:29 +08:00
UNUSED_IF_ASSERT_DISABLED(num_printed);
Add one-shot breakpoints (-o option to "break set") and a tbreak alias for our gdb friends. llvm-svn: 165328
2012-10-06 03:16:31 +08:00
success = tbreak_regex_cmd_ap->AddRegexCommand (break_regexes[i][0], buffer);
if (!success)
break;
}
success = tbreak_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full");
if (success)
{
CommandObjectSP tbreak_regex_cmd_sp(tbreak_regex_cmd_ap.release());
m_command_dict[tbreak_regex_cmd_sp->GetCommandName ()] = tbreak_regex_cmd_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> attach_regex_cmd_ap(
new CommandObjectRegexCommand(*this, "_regexp-attach", "Attach to process by ID or name.",
"_regexp-attach <pid> | <process-name>", 2, 0, false));
rdar://problem/11811338 Add 'attach <pid>|<process-name>' command to lldb, as well as 'detach' which is an alias of 'process detach'. Add two completion test cases for "attach" and "detach". llvm-svn: 162573
2012-08-25 02:15:45 +08:00
if (attach_regex_cmd_ap.get())
{
<rdar://problem/12582041> _regexp_attach doesn't handle the case where no arguments are provided. It now also handles the case you were you pass options. llvm-svn: 170262
2012-12-15 09:19:07 +08:00
if (attach_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$", "process attach --pid %1") &&
attach_regex_cmd_ap->AddRegexCommand("^(-.*|.* -.*)$", "process attach %1") && // Any options that are specified get passed to 'process attach'
attach_regex_cmd_ap->AddRegexCommand("^(.+)$", "process attach --name '%1'") &&
attach_regex_cmd_ap->AddRegexCommand("^$", "process attach"))
rdar://problem/11811338 Add 'attach <pid>|<process-name>' command to lldb, as well as 'detach' which is an alias of 'process detach'. Add two completion test cases for "attach" and "detach". llvm-svn: 162573
2012-08-25 02:15:45 +08:00
{
CommandObjectSP attach_regex_cmd_sp(attach_regex_cmd_ap.release());
m_command_dict[attach_regex_cmd_sp->GetCommandName ()] = attach_regex_cmd_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> down_regex_cmd_ap(new CommandObjectRegexCommand(
*this, "_regexp-down", "Select a newer stack frame. Defaults to moving one frame, a numeric argument can "
"specify an arbitrary number.",
"_regexp-down [<count>]", 2, 0, false));
Add "up" and "down" aliases. llvm-svn: 128066
2011-03-22 10:29:32 +08:00
if (down_regex_cmd_ap.get())
{
if (down_regex_cmd_ap->AddRegexCommand("^$", "frame select -r -1") &&
down_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r -%1"))
{
CommandObjectSP down_regex_cmd_sp(down_regex_cmd_ap.release());
m_command_dict[down_regex_cmd_sp->GetCommandName ()] = down_regex_cmd_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> up_regex_cmd_ap(
new CommandObjectRegexCommand(*this, "_regexp-up", "Select an older stack frame. Defaults to moving one "
"frame, a numeric argument can specify an arbitrary number.",
"_regexp-up [<count>]", 2, 0, false));
Add "up" and "down" aliases. llvm-svn: 128066
2011-03-22 10:29:32 +08:00
if (up_regex_cmd_ap.get())
{
if (up_regex_cmd_ap->AddRegexCommand("^$", "frame select -r 1") &&
up_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r %1"))
{
CommandObjectSP up_regex_cmd_sp(up_regex_cmd_ap.release());
m_command_dict[up_regex_cmd_sp->GetCommandName ()] = up_regex_cmd_sp;
}
}
Add "display" and "undisplay" aliases for target stop-hook add/delete. A patina of gdb's "display" command, intended mostly for simply monitoring a variable as you step through source code. Formatters do not work, e.g. display/x $pc does not work. llvm-svn: 142710
2011-10-22 09:30:52 +08:00
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> display_regex_cmd_ap(new CommandObjectRegexCommand(
*this, "_regexp-display", "Evaluate an expression at every stop (see 'help target stop-hook'.)",
"_regexp-display expression", 2, 0, false));
Add "display" and "undisplay" aliases for target stop-hook add/delete. A patina of gdb's "display" command, intended mostly for simply monitoring a variable as you step through source code. Formatters do not work, e.g. display/x $pc does not work. llvm-svn: 142710
2011-10-22 09:30:52 +08:00
if (display_regex_cmd_ap.get())
{
if (display_regex_cmd_ap->AddRegexCommand("^(.+)$", "target stop-hook add -o \"expr -- %1\""))
{
CommandObjectSP display_regex_cmd_sp(display_regex_cmd_ap.release());
m_command_dict[display_regex_cmd_sp->GetCommandName ()] = display_regex_cmd_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> undisplay_regex_cmd_ap(new CommandObjectRegexCommand(
*this, "_regexp-undisplay", "Stop displaying expression at every stop (specified by stop-hook index.)",
"_regexp-undisplay stop-hook-number", 2, 0, false));
Add "display" and "undisplay" aliases for target stop-hook add/delete. A patina of gdb's "display" command, intended mostly for simply monitoring a variable as you step through source code. Formatters do not work, e.g. display/x $pc does not work. llvm-svn: 142710
2011-10-22 09:30:52 +08:00
if (undisplay_regex_cmd_ap.get())
{
if (undisplay_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "target stop-hook delete %1"))
{
CommandObjectSP undisplay_regex_cmd_sp(undisplay_regex_cmd_ap.release());
m_command_dict[undisplay_regex_cmd_sp->GetCommandName ()] = undisplay_regex_cmd_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> connect_gdb_remote_cmd_ap(new CommandObjectRegexCommand(
*this, "gdb-remote",
"Connect to a process via remote GDB server. If no host is specifed, localhost is assumed.",
"gdb-remote [<hostname>:]<portnum>", 2, 0, false));
Add convenience aliases to allow easy attaching to a remote gdb server or kdp (darwin kernel) server with the new "gdb-remote" regex alias and "kdp-remote" regex alias commands. llvm-svn: 164729
2012-09-27 06:26:47 +08:00
if (connect_gdb_remote_cmd_ap.get())
{
if (connect_gdb_remote_cmd_ap->AddRegexCommand("^([^:]+:[[:digit:]]+)$", "process connect --plugin gdb-remote connect://%1") &&
connect_gdb_remote_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", "process connect --plugin gdb-remote connect://localhost:%1"))
{
CommandObjectSP command_sp(connect_gdb_remote_cmd_ap.release());
m_command_dict[command_sp->GetCommandName ()] = command_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> connect_kdp_remote_cmd_ap(new CommandObjectRegexCommand(
*this, "kdp-remote",
"Connect to a process via remote KDP server. If no UDP port is specified, port 41139 is assumed.",
"kdp-remote <hostname>[:<portnum>]", 2, 0, false));
Add convenience aliases to allow easy attaching to a remote gdb server or kdp (darwin kernel) server with the new "gdb-remote" regex alias and "kdp-remote" regex alias commands. llvm-svn: 164729
2012-09-27 06:26:47 +08:00
if (connect_kdp_remote_cmd_ap.get())
{
if (connect_kdp_remote_cmd_ap->AddRegexCommand("^([^:]+:[[:digit:]]+)$", "process connect --plugin kdp-remote udp://%1") &&
Change the kdp-remote alias to require a hostname (instead of allowing a zero-length hostname to be specified). llvm-svn: 164752
2012-09-27 10:47:55 +08:00
connect_kdp_remote_cmd_ap->AddRegexCommand("^(.+)$", "process connect --plugin kdp-remote udp://%1:41139"))
Add convenience aliases to allow easy attaching to a remote gdb server or kdp (darwin kernel) server with the new "gdb-remote" regex alias and "kdp-remote" regex alias commands. llvm-svn: 164729
2012-09-27 06:26:47 +08:00
{
CommandObjectSP command_sp(connect_kdp_remote_cmd_ap.release());
m_command_dict[command_sp->GetCommandName ()] = command_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> bt_regex_cmd_ap(new CommandObjectRegexCommand(
*this, "_regexp-bt", "Show the current thread's call stack. Any numeric argument displays at most that many "
"frames. The argument 'all' displays all threads.",
"bt [<digit> | all]", 2, 0, false));
Change the "bt" command alias defined in CommandInterpreter::LoadCommandDictionary. It is now a regex command alias that more faithfully emulates gdb's behavior, most importantly, "bt 5" will backtrace 5 frames of the currently selected thread. "bt all" still backtraces all threads (unlike gdb) and for users who have learned to use "bt -c 5", that form is still accepted. llvm-svn: 165300
2012-10-05 13:29:32 +08:00
if (bt_regex_cmd_ap.get())
{
// accept but don't document "bt -c <number>" -- before bt was a regex command if you wanted to backtrace
// three frames you would do "bt -c 3" but the intention is to have this emulate the gdb "bt" command and
// so now "bt 3" is the preferred form, in line with gdb.
if (bt_regex_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", "thread backtrace -c %1") &&
bt_regex_cmd_ap->AddRegexCommand("^-c ([[:digit:]]+)$", "thread backtrace -c %1") &&
bt_regex_cmd_ap->AddRegexCommand("^all$", "thread backtrace all") &&
bt_regex_cmd_ap->AddRegexCommand("^$", "thread backtrace"))
{
CommandObjectSP command_sp(bt_regex_cmd_ap.release());
m_command_dict[command_sp->GetCommandName ()] = command_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> list_regex_cmd_ap(new CommandObjectRegexCommand(
*this, "_regexp-list", "List relevant source code using one of several shorthand formats.",
"\n"
"_regexp-list <file>:<line> // List around specific file/line\n"
"_regexp-list <line> // List current file around specified line\n"
"_regexp-list <function-name> // List specified function\n"
"_regexp-list 0x<address> // List around specified address\n"
"_regexp-list -[<count>] // List previous <count> lines\n"
"_regexp-list // List subsequent lines",
2, CommandCompletions::eSourceFileCompletion, false));
<rdar://problem/13050227> Added a regular expression command called "_regexp-list" which mimics the GDB "line" command in the following forms: LINENUM, to list around that line in current file, FILE:LINENUM, to list around that line in that file, FUNCTION, to list around beginning of that function, *ADDRESS, to list around the line containing that address. ADDRESS, same as above, but don't require a '*' as long as ADDRESS is hex llvm-svn: 174233
2013-02-02 07:33:03 +08:00
if (list_regex_cmd_ap.get())
{
if (list_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$", "source list --line %1") &&
list_regex_cmd_ap->AddRegexCommand("^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$", "source list --file '%1' --line %2") &&
list_regex_cmd_ap->AddRegexCommand("^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "source list --address %1") &&
<rdar://problem/13184389> _regexp-list needs to treat "list -" as "source list -r" llvm-svn: 174987
2013-02-13 02:42:05 +08:00
list_regex_cmd_ap->AddRegexCommand("^-[[:space:]]*$", "source list --reverse") &&
<rdar://problem/13404189> Made the "--reverse" option to "source list" also be able to use the "--count". This helps us implement support for regexp source list command: (lldb) l -10 Which gets turned into: (lldb) source list --reverse --count 10 Also simplified the code that is used to track showing more source from the last file and line. llvm-svn: 176961
2013-03-14 02:25:49 +08:00
list_regex_cmd_ap->AddRegexCommand("^-([[:digit:]]+)[[:space:]]*$", "source list --reverse --count %1") &&
<rdar://problem/13050227> Added a regular expression command called "_regexp-list" which mimics the GDB "line" command in the following forms: LINENUM, to list around that line in current file, FILE:LINENUM, to list around that line in that file, FUNCTION, to list around beginning of that function, *ADDRESS, to list around the line containing that address. ADDRESS, same as above, but don't require a '*' as long as ADDRESS is hex llvm-svn: 174233
2013-02-02 07:33:03 +08:00
list_regex_cmd_ap->AddRegexCommand("^(.+)$", "source list --name \"%1\"") &&
list_regex_cmd_ap->AddRegexCommand("^$", "source list"))
{
CommandObjectSP list_regex_cmd_sp(list_regex_cmd_ap.release());
m_command_dict[list_regex_cmd_sp->GetCommandName ()] = list_regex_cmd_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> env_regex_cmd_ap(
new CommandObjectRegexCommand(*this, "_regexp-env", "Shorthand for viewing and setting environment variables.",
"\n"
"_regexp-env // Show enrivonment\n"
"_regexp-env <name>=<value> // Set an environment variable",
2, 0, false));
<rdar://problem/13178743> Added a new "env" regular expression alias. If "env" is typed on its own "settings show target.env-vars" will be run. Otherwise it can be used to set and environment variable: "env FOO=BAR". llvm-svn: 174991
2013-02-13 02:52:24 +08:00
if (env_regex_cmd_ap.get())
{
if (env_regex_cmd_ap->AddRegexCommand("^$", "settings show target.env-vars") &&
env_regex_cmd_ap->AddRegexCommand("^([A-Za-z_][A-Za-z_0-9]*=.*)$", "settings set target.env-vars %1"))
{
CommandObjectSP env_regex_cmd_sp(env_regex_cmd_ap.release());
m_command_dict[env_regex_cmd_sp->GetCommandName ()] = env_regex_cmd_sp;
}
}
LLDB help content has accumulated over time without a recent attempt to review it for consistency, accuracy, and clarity. These changes attempt to address all of the above while keeping the text relatively terse. <rdar://problem/24868841> llvm-svn: 275485
2016-07-15 06:03:10 +08:00
std::unique_ptr<CommandObjectRegexCommand> jump_regex_cmd_ap(
new CommandObjectRegexCommand(*this, "_regexp-jump", "Set the program counter to a new address.",
"\n"
"_regexp-jump <line>\n"
"_regexp-jump +<line-offset> | -<line-offset>\n"
"_regexp-jump <file>:<line>\n"
"_regexp-jump *<addr>\n",
2, 0, false));
Added a 'jump' command, similar to GDBs. This allows the PC to be directly changed to a different line. It's similar to the example python script in examples/python/jump.py, except implemented as a builtin. Also this version will track the current function correctly even if the target line resolves to multiple addresses. (e.g. debugging a templated function) llvm-svn: 190572
2013-09-12 10:20:34 +08:00
if (jump_regex_cmd_ap.get())
{
if (jump_regex_cmd_ap->AddRegexCommand("^\\*(.*)$", "thread jump --addr %1") &&
jump_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "thread jump --line %1") &&
jump_regex_cmd_ap->AddRegexCommand("^([^:]+):([0-9]+)$", "thread jump --file %1 --line %2") &&
jump_regex_cmd_ap->AddRegexCommand("^([+\\-][0-9]+)$", "thread jump --by %1"))
{
CommandObjectSP jump_regex_cmd_sp(jump_regex_cmd_ap.release());
m_command_dict[jump_regex_cmd_sp->GetCommandName ()] = jump_regex_cmd_sp;
}
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
int
CommandInterpreter::GetCommandNamesMatchingPartialString (const char *cmd_str, bool include_aliases,
StringList &matches)
{
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
AddNamesMatchingPartialString (m_command_dict, cmd_str, matches);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (include_aliases)
{
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
AddNamesMatchingPartialString (m_alias_dict, cmd_str, matches);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
return matches.GetSize();
}
CommandObjectSP
CommandInterpreter::GetCommandSP (const char *cmd_cstr, bool include_aliases, bool exact, StringList *matches)
{
CommandObject::CommandMap::iterator pos;
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
CommandObjectSP command_sp;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
std::string cmd(cmd_cstr);
if (HasCommands())
{
pos = m_command_dict.find(cmd);
if (pos != m_command_dict.end())
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
command_sp = pos->second;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
if (include_aliases && HasAliases())
{
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
auto alias_pos = m_alias_dict.find(cmd);
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
if (alias_pos != m_alias_dict.end())
Lots of progress on the CommandAlias refactoring This cleans things up such CommandAlias essentially can work as its own object; the aliases still live in a separate map, but are now just full-fledged CommandObjectSPs This patch also cleans up help generation for aliases, allows aliases to vend their own help, and adds a tweak such that "dash-dash aliases", such as po, don't show the list of options for their underlying command, since those can't be provided anyway I plan to fix up a few more things here, and then add a test case and proclaim victory llvm-svn: 263499
2016-03-15 06:17:04 +08:00
command_sp = alias_pos->second;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
if (HasUserCommands())
{
pos = m_user_dict.find(cmd);
if (pos != m_user_dict.end())
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
command_sp = pos->second;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
if (!exact && !command_sp)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
// We will only get into here if we didn't find any exact matches.
CommandObjectSP user_match_sp, alias_match_sp, real_match_sp;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
StringList local_matches;
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (matches == nullptr)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
matches = &local_matches;
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
unsigned int num_cmd_matches = 0;
unsigned int num_alias_matches = 0;
unsigned int num_user_matches = 0;
// Look through the command dictionaries one by one, and if we get only one match from any of
// them in toto, then return that, otherwise return an empty CommandObjectSP and the list of matches.
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (HasCommands())
{
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
num_cmd_matches = AddNamesMatchingPartialString (m_command_dict, cmd_cstr, *matches);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
if (num_cmd_matches == 1)
{
cmd.assign(matches->GetStringAtIndex(0));
pos = m_command_dict.find(cmd);
if (pos != m_command_dict.end())
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
real_match_sp = pos->second;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Fix a bug in handling command resolution for non-exact matches. Now we will correctly give help options when there are both aliases & real commands matching the current input string. llvm-svn: 106782
2010-06-25 04:28:42 +08:00
if (include_aliases && HasAliases())
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
num_alias_matches = AddNamesMatchingPartialString (m_alias_dict, cmd_cstr, *matches);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
if (num_alias_matches == 1)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
cmd.assign(matches->GetStringAtIndex (num_cmd_matches));
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
auto alias_pos = m_alias_dict.find(cmd);
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
if (alias_pos != m_alias_dict.end())
Lots of progress on the CommandAlias refactoring This cleans things up such CommandAlias essentially can work as its own object; the aliases still live in a separate map, but are now just full-fledged CommandObjectSPs This patch also cleans up help generation for aliases, allows aliases to vend their own help, and adds a tweak such that "dash-dash aliases", such as po, don't show the list of options for their underlying command, since those can't be provided anyway I plan to fix up a few more things here, and then add a test case and proclaim victory llvm-svn: 263499
2016-03-15 06:17:04 +08:00
alias_match_sp = alias_pos->second;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Fix a bug in handling command resolution for non-exact matches. Now we will correctly give help options when there are both aliases & real commands matching the current input string. llvm-svn: 106782
2010-06-25 04:28:42 +08:00
if (HasUserCommands())
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
num_user_matches = AddNamesMatchingPartialString (m_user_dict, cmd_cstr, *matches);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
if (num_user_matches == 1)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
cmd.assign (matches->GetStringAtIndex (num_cmd_matches + num_alias_matches));
pos = m_user_dict.find (cmd);
if (pos != m_user_dict.end())
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
user_match_sp = pos->second;
}
// If we got exactly one match, return that, otherwise return the match list.
if (num_user_matches + num_cmd_matches + num_alias_matches == 1)
{
if (num_cmd_matches)
return real_match_sp;
else if (num_alias_matches)
return alias_match_sp;
else
return user_match_sp;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
}
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
else if (matches && command_sp)
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
{
matches->AppendString (cmd_cstr);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
return command_sp;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Added the ability for users to create new regex commands. To do this currently, it must be done in multi-line mode: (lldb) commands regex --help "Help text for command" --syntax "syntax for command" <cmd-name> Any example that would use "f" for "finish" when there are no arguments, and "f <num>" to do a "frame select <num>" would be: (lldb) commands regex f Enter multiple regular expressions in the form s/find/replace/ then terminate with an empty line: s/^$/finish/ s/([0-9]+)/frame select %1/ (lldb) f 11 frame select 12 ... (lldb) f finish ... Also added the string version of the OptionValue as OptionValueString. llvm-svn: 129855
2011-04-21 00:37:46 +08:00
bool
CommandInterpreter::AddCommand (const char *name, const lldb::CommandObjectSP &cmd_sp, bool can_replace)
{
Per Jim's suggestion, move checks that we're not mixing and matching Debuggers and Commands deeper in the bowels of LLDB NFC llvm-svn: 259972
2016-02-06 09:36:07 +08:00
if (cmd_sp.get())
assert((this == &cmd_sp->GetCommandInterpreter()) && "tried to add a CommandObject from a different interpreter");
Added the ability for users to create new regex commands. To do this currently, it must be done in multi-line mode: (lldb) commands regex --help "Help text for command" --syntax "syntax for command" <cmd-name> Any example that would use "f" for "finish" when there are no arguments, and "f <num>" to do a "frame select <num>" would be: (lldb) commands regex f Enter multiple regular expressions in the form s/find/replace/ then terminate with an empty line: s/^$/finish/ s/([0-9]+)/frame select %1/ (lldb) f 11 frame select 12 ... (lldb) f finish ... Also added the string version of the OptionValue as OptionValueString. llvm-svn: 129855
2011-04-21 00:37:46 +08:00
if (name && name[0])
{
std::string name_sstr(name);
<rdar://problem/12406088> Fixing a crasher with adding a regex command, due to accessing a shared pointer without first checking for NULL llvm-svn: 164950
2012-10-02 01:19:37 +08:00
bool found = (m_command_dict.find (name_sstr) != m_command_dict.end());
if (found && !can_replace)
return false;
if (found && m_command_dict[name_sstr]->IsRemovable() == false)
Implementing plugins that provide commands. This checkin adds the capability for LLDB to load plugins from external dylibs that can provide new commands It exports an SBCommand class from the public API layer, and a new SBCommandPluginInterface There is a minimal load-only plugin manager built into the debugger, which can be accessed via Debugger::LoadPlugin. Plugins are loaded from two locations at debugger startup (LLDB.framework/Resources/PlugIns and ~/Library/Application Support/LLDB/PlugIns) and more can be (re)loaded via the "plugin load" command For an example of how to make a plugin, refer to the fooplugin.cpp file in examples/plugins/commands Caveats: Currently, the new API objects and features are not exposed via Python. The new commands can only be "parsed" (i.e. not raw) and get their command line via a char** parameter (we do not expose our internal Args object) There is no unloading feature, which can potentially lead to leaks if you overwrite the commands by reloading the same or different plugins There is no API exposed for option parsing, which means you may need to use getopt or roll-your-own llvm-svn: 164865
2012-09-29 07:57:51 +08:00
return false;
Added the ability for users to create new regex commands. To do this currently, it must be done in multi-line mode: (lldb) commands regex --help "Help text for command" --syntax "syntax for command" <cmd-name> Any example that would use "f" for "finish" when there are no arguments, and "f <num>" to do a "frame select <num>" would be: (lldb) commands regex f Enter multiple regular expressions in the form s/find/replace/ then terminate with an empty line: s/^$/finish/ s/([0-9]+)/frame select %1/ (lldb) f 11 frame select 12 ... (lldb) f finish ... Also added the string version of the OptionValue as OptionValueString. llvm-svn: 129855
2011-04-21 00:37:46 +08:00
m_command_dict[name_sstr] = cmd_sp;
return true;
}
return false;
}
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
bool
this patch addresses several issues with "command script" subcommands: a) adds a new --synchronicity (-s) setting for "command script add" that allows the user to decide if scripted commands should run synchronously or asynchronously (which can make a difference in how events are handled) b) clears up several error messages c) adds a new --allow-reload (-r) setting for "command script import" that allows the user to reload a module even if it has already been imported before d) allows filename completion for "command script import" (much like what happens for "target create") e) prevents "command script add" from replacing built-in commands with scripted commands f) changes AddUserCommand() to take an std::string instead of a const char* (for performance reasons) plus, it fixes an issue in "type summary add" command handling which caused several test suite errors llvm-svn: 144035
2011-11-08 06:57:04 +08:00
CommandInterpreter::AddUserCommand (std::string name,
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
const lldb::CommandObjectSP &cmd_sp,
bool can_replace)
{
Per Jim's suggestion, move checks that we're not mixing and matching Debuggers and Commands deeper in the bowels of LLDB NFC llvm-svn: 259972
2016-02-06 09:36:07 +08:00
if (cmd_sp.get())
assert((this == &cmd_sp->GetCommandInterpreter()) && "tried to add a CommandObject from a different interpreter");
this patch addresses several issues with "command script" subcommands: a) adds a new --synchronicity (-s) setting for "command script add" that allows the user to decide if scripted commands should run synchronously or asynchronously (which can make a difference in how events are handled) b) clears up several error messages c) adds a new --allow-reload (-r) setting for "command script import" that allows the user to reload a module even if it has already been imported before d) allows filename completion for "command script import" (much like what happens for "target create") e) prevents "command script add" from replacing built-in commands with scripted commands f) changes AddUserCommand() to take an std::string instead of a const char* (for performance reasons) plus, it fixes an issue in "type summary add" command handling which caused several test suite errors llvm-svn: 144035
2011-11-08 06:57:04 +08:00
if (!name.empty())
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
{
this patch addresses several issues with "command script" subcommands: a) adds a new --synchronicity (-s) setting for "command script add" that allows the user to decide if scripted commands should run synchronously or asynchronously (which can make a difference in how events are handled) b) clears up several error messages c) adds a new --allow-reload (-r) setting for "command script import" that allows the user to reload a module even if it has already been imported before d) allows filename completion for "command script import" (much like what happens for "target create") e) prevents "command script add" from replacing built-in commands with scripted commands f) changes AddUserCommand() to take an std::string instead of a const char* (for performance reasons) plus, it fixes an issue in "type summary add" command handling which caused several test suite errors llvm-svn: 144035
2011-11-08 06:57:04 +08:00
const char* name_cstr = name.c_str();
// do not allow replacement of internal commands
if (CommandExists(name_cstr))
Implementing plugins that provide commands. This checkin adds the capability for LLDB to load plugins from external dylibs that can provide new commands It exports an SBCommand class from the public API layer, and a new SBCommandPluginInterface There is a minimal load-only plugin manager built into the debugger, which can be accessed via Debugger::LoadPlugin. Plugins are loaded from two locations at debugger startup (LLDB.framework/Resources/PlugIns and ~/Library/Application Support/LLDB/PlugIns) and more can be (re)loaded via the "plugin load" command For an example of how to make a plugin, refer to the fooplugin.cpp file in examples/plugins/commands Caveats: Currently, the new API objects and features are not exposed via Python. The new commands can only be "parsed" (i.e. not raw) and get their command line via a char** parameter (we do not expose our internal Args object) There is no unloading feature, which can potentially lead to leaks if you overwrite the commands by reloading the same or different plugins There is no API exposed for option parsing, which means you may need to use getopt or roll-your-own llvm-svn: 164865
2012-09-29 07:57:51 +08:00
{
if (can_replace == false)
return false;
if (m_command_dict[name]->IsRemovable() == false)
return false;
}
if (UserCommandExists(name_cstr))
{
if (can_replace == false)
return false;
if (m_user_dict[name]->IsRemovable() == false)
return false;
}
this patch addresses several issues with "command script" subcommands: a) adds a new --synchronicity (-s) setting for "command script add" that allows the user to decide if scripted commands should run synchronously or asynchronously (which can make a difference in how events are handled) b) clears up several error messages c) adds a new --allow-reload (-r) setting for "command script import" that allows the user to reload a module even if it has already been imported before d) allows filename completion for "command script import" (much like what happens for "target create") e) prevents "command script add" from replacing built-in commands with scripted commands f) changes AddUserCommand() to take an std::string instead of a const char* (for performance reasons) plus, it fixes an issue in "type summary add" command handling which caused several test suite errors llvm-svn: 144035
2011-11-08 06:57:04 +08:00
m_user_dict[name] = cmd_sp;
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
return true;
}
return false;
}
Added the ability for users to create new regex commands. To do this currently, it must be done in multi-line mode: (lldb) commands regex --help "Help text for command" --syntax "syntax for command" <cmd-name> Any example that would use "f" for "finish" when there are no arguments, and "f <num>" to do a "frame select <num>" would be: (lldb) commands regex f Enter multiple regular expressions in the form s/find/replace/ then terminate with an empty line: s/^$/finish/ s/([0-9]+)/frame select %1/ (lldb) f 11 frame select 12 ... (lldb) f finish ... Also added the string version of the OptionValue as OptionValueString. llvm-svn: 129855
2011-04-21 00:37:46 +08:00
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
CommandObjectSP
CommandInterpreter::GetCommandSPExact (const char *cmd_cstr, bool include_aliases)
{
Fix small bugs: - Make sure cmd_obj & cmd_obj_sp contain a valid objects before attempting to dereference, in CommandObjectCommandsAlias::Execute and CommandInterpreter::HandleCommand. - Modify CommandInterpreter::GetCommandSPExact to properly handle multi-word command inputs. llvm-svn: 121779
2010-12-15 02:51:39 +08:00
Args cmd_words (cmd_cstr); // Break up the command string into words, in case it's a multi-word command.
CommandObjectSP ret_val; // Possibly empty return value.
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (cmd_cstr == nullptr)
Fix small bugs: - Make sure cmd_obj & cmd_obj_sp contain a valid objects before attempting to dereference, in CommandObjectCommandsAlias::Execute and CommandInterpreter::HandleCommand. - Modify CommandInterpreter::GetCommandSPExact to properly handle multi-word command inputs. llvm-svn: 121779
2010-12-15 02:51:39 +08:00
return ret_val;
if (cmd_words.GetArgumentCount() == 1)
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
return GetCommandSP(cmd_cstr, include_aliases, true, nullptr);
Fix small bugs: - Make sure cmd_obj & cmd_obj_sp contain a valid objects before attempting to dereference, in CommandObjectCommandsAlias::Execute and CommandInterpreter::HandleCommand. - Modify CommandInterpreter::GetCommandSPExact to properly handle multi-word command inputs. llvm-svn: 121779
2010-12-15 02:51:39 +08:00
else
{
// We have a multi-word command (seemingly), so we need to do more work.
// First, get the cmd_obj_sp for the first word in the command.
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
CommandObjectSP cmd_obj_sp = GetCommandSP (cmd_words.GetArgumentAtIndex (0), include_aliases, true, nullptr);
if (cmd_obj_sp.get() != nullptr)
Fix small bugs: - Make sure cmd_obj & cmd_obj_sp contain a valid objects before attempting to dereference, in CommandObjectCommandsAlias::Execute and CommandInterpreter::HandleCommand. - Modify CommandInterpreter::GetCommandSPExact to properly handle multi-word command inputs. llvm-svn: 121779
2010-12-15 02:51:39 +08:00
{
// Loop through the rest of the words in the command (everything passed in was supposed to be part of a
// command name), and find the appropriate sub-command SP for each command word....
size_t end = cmd_words.GetArgumentCount();
for (size_t j= 1; j < end; ++j)
{
if (cmd_obj_sp->IsMultiwordObject())
{
<rdar://problem/12491387> I added the ability for a process plug-in to implement custom commands. All the lldb_private::Process plug-in has to do is override: virtual CommandObject * GetPluginCommandObject(); This object returned should be a multi-word command that vends LLDB commands. There is a sample implementation in ProcessGDBRemote that is hollowed out. It is intended to be used for sending a custom packet, though the body of the command execute function has yet to be implemented! llvm-svn: 165861
2012-10-13 10:07:45 +08:00
cmd_obj_sp = cmd_obj_sp->GetSubcommandSP (cmd_words.GetArgumentAtIndex (j));
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (cmd_obj_sp.get() == nullptr)
Fix small bugs: - Make sure cmd_obj & cmd_obj_sp contain a valid objects before attempting to dereference, in CommandObjectCommandsAlias::Execute and CommandInterpreter::HandleCommand. - Modify CommandInterpreter::GetCommandSPExact to properly handle multi-word command inputs. llvm-svn: 121779
2010-12-15 02:51:39 +08:00
// The sub-command name was invalid. Fail and return the empty 'ret_val'.
return ret_val;
}
else
// We have more words in the command name, but we don't have a multiword object. Fail and return
// empty 'ret_val'.
return ret_val;
}
// We successfully looped through all the command words and got valid command objects for them. Assign the
// last object retrieved to 'ret_val'.
ret_val = cmd_obj_sp;
}
}
return ret_val;
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
CommandObject *
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
CommandInterpreter::GetCommandObjectExact (const char *cmd_cstr, bool include_aliases)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
return GetCommandSPExact (cmd_cstr, include_aliases).get();
}
CommandObject *
CommandInterpreter::GetCommandObject (const char *cmd_cstr, StringList *matches)
{
CommandObject *command_obj = GetCommandSP (cmd_cstr, false, true, matches).get();
// If we didn't find an exact match to the command string in the commands, look in
// the aliases.
This patch fixes the issue where our command-line tab completer would sometimes replicate commands e.g. (lldb) pl<TAB> Available completions: platform plugin platform plugin Thanks to Matthew Sorrels for doing work and testing on this issue llvm-svn: 184212
2013-06-19 02:01:08 +08:00
if (command_obj)
return command_obj;
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
This patch fixes the issue where our command-line tab completer would sometimes replicate commands e.g. (lldb) pl<TAB> Available completions: platform plugin platform plugin Thanks to Matthew Sorrels for doing work and testing on this issue llvm-svn: 184212
2013-06-19 02:01:08 +08:00
command_obj = GetCommandSP (cmd_cstr, true, true, matches).get();
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
This patch fixes the issue where our command-line tab completer would sometimes replicate commands e.g. (lldb) pl<TAB> Available completions: platform plugin platform plugin Thanks to Matthew Sorrels for doing work and testing on this issue llvm-svn: 184212
2013-06-19 02:01:08 +08:00
if (command_obj)
return command_obj;
// If there wasn't an exact match then look for an inexact one in just the commands
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
command_obj = GetCommandSP(cmd_cstr, false, false, nullptr).get();
Look for an inexact match in just the commands before searching the alias commands as well. llvm-svn: 180117
2013-04-24 00:17:32 +08:00
// Finally, if there wasn't an inexact match among the commands, look for an inexact
// match in both the commands and aliases.
This patch fixes the issue where our command-line tab completer would sometimes replicate commands e.g. (lldb) pl<TAB> Available completions: platform plugin platform plugin Thanks to Matthew Sorrels for doing work and testing on this issue llvm-svn: 184212
2013-06-19 02:01:08 +08:00
if (command_obj)
{
if (matches)
matches->AppendString(command_obj->GetCommandName());
return command_obj;
}
return GetCommandSP(cmd_cstr, true, false, matches).get();
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
bool
CommandInterpreter::CommandExists (const char *cmd)
{
return m_command_dict.find(cmd) != m_command_dict.end();
}
Allow partial matching for alias commands as well as regular commands. <rdar://problem/13552724> llvm-svn: 178597
2013-04-03 08:25:49 +08:00
bool
CommandInterpreter::GetAliasFullName (const char *cmd, std::string &full_name)
{
bool exact_match = (m_alias_dict.find(cmd) != m_alias_dict.end());
if (exact_match)
{
full_name.assign(cmd);
return exact_match;
}
else
{
StringList matches;
size_t num_alias_matches;
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
num_alias_matches = AddNamesMatchingPartialString (m_alias_dict, cmd, matches);
Allow partial matching for alias commands as well as regular commands. <rdar://problem/13552724> llvm-svn: 178597
2013-04-03 08:25:49 +08:00
if (num_alias_matches == 1)
{
// Make sure this isn't shadowing a command in the regular command space:
StringList regular_matches;
const bool include_aliases = false;
const bool exact = false;
CommandObjectSP cmd_obj_sp(GetCommandSP (cmd, include_aliases, exact, &regular_matches));
if (cmd_obj_sp || regular_matches.GetSize() > 0)
return false;
else
{
full_name.assign (matches.GetStringAtIndex(0));
return true;
}
}
else
return false;
}
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
bool
CommandInterpreter::AliasExists (const char *cmd)
{
return m_alias_dict.find(cmd) != m_alias_dict.end();
}
bool
CommandInterpreter::UserCommandExists (const char *cmd)
{
return m_user_dict.find(cmd) != m_user_dict.end();
}
Workaround the fact that "b" is now a separate command object from "_regexp-break", and thus "help b" doesn't show the possible syntaxes It would be nice to have a longer-term plan for how to handle help for regular expression commands, since their syntax is highly irregular. I can see a few options (*), but for now this is a reasonable stop-gag measure for the most blatant regression. (*) the simplest is, of course, to detect a regex command and inherit the syntax for any aliases thereof; it would be nice if this also didn't show the underlying regex command name when the alias is used llvm-svn: 263523
2016-03-15 09:57:10 +08:00
CommandAlias*
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
CommandInterpreter::AddAlias (const char *alias_name,
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
lldb::CommandObjectSP& command_obj_sp,
const char *args_string)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Per Jim's suggestion, move checks that we're not mixing and matching Debuggers and Commands deeper in the bowels of LLDB NFC llvm-svn: 259972
2016-02-06 09:36:07 +08:00
if (command_obj_sp.get())
assert((this == &command_obj_sp->GetCommandInterpreter()) && "tried to add a CommandObject from a different interpreter");
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
More of the alias refactoring work! CommandAlias is now a CommandObject llvm-svn: 263468
2016-03-15 03:00:21 +08:00
std::unique_ptr<CommandAlias> command_alias_up(new CommandAlias(*this,
command_obj_sp,
args_string,
alias_name));
if (command_alias_up && command_alias_up->IsValid())
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
{
Workaround the fact that "b" is now a separate command object from "_regexp-break", and thus "help b" doesn't show the possible syntaxes It would be nice to have a longer-term plan for how to handle help for regular expression commands, since their syntax is highly irregular. I can see a few options (*), but for now this is a reasonable stop-gag measure for the most blatant regression. (*) the simplest is, of course, to detect a regex command and inherit the syntax for any aliases thereof; it would be nice if this also didn't show the underlying regex command name when the alias is used llvm-svn: 263523
2016-03-15 09:57:10 +08:00
m_alias_dict[alias_name] = CommandObjectSP(command_alias_up.get());
return command_alias_up.release();
A few more improvements on the way to the command alias refactoring - move alias help generation to CommandAlias, out of CommandInterpreter - make alias creation use argument strings instead of OptionArgVectorSP; the former is a more reasonable currency than the latter - remove m_is_alias from CommandObject, it wasn't actually being used llvm-svn: 262912
2016-03-08 13:37:15 +08:00
}
More of the alias refactoring work! CommandAlias is now a CommandObject llvm-svn: 263468
2016-03-15 03:00:21 +08:00
Workaround the fact that "b" is now a separate command object from "_regexp-break", and thus "help b" doesn't show the possible syntaxes It would be nice to have a longer-term plan for how to handle help for regular expression commands, since their syntax is highly irregular. I can see a few options (*), but for now this is a reasonable stop-gag measure for the most blatant regression. (*) the simplest is, of course, to detect a regex command and inherit the syntax for any aliases thereof; it would be nice if this also didn't show the underlying regex command name when the alias is used llvm-svn: 263523
2016-03-15 09:57:10 +08:00
return nullptr;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
bool
CommandInterpreter::RemoveAlias (const char *alias_name)
{
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
auto pos = m_alias_dict.find(alias_name);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (pos != m_alias_dict.end())
{
m_alias_dict.erase(pos);
return true;
}
return false;
}
Fixed an issue where you couldn't delete a user defined regex, python, or multi-word command by adding a new "command delete" command. This new command will delete user defined regular commands, but not aliases. We still have "command unalias" to remove aliases as they are currently in different buckets. Appropriate error messages are displayed to inform the user when "command unalias" is used on removable user defined commands that points users to the "command delete" command. Added a test to verify we can remove user defined commands and also verify that "command unalias" fails when used on a user defined command. <rdar://problem/18248300> llvm-svn: 225535
2015-01-10 03:08:20 +08:00
bool
CommandInterpreter::RemoveCommand (const char *cmd)
{
auto pos = m_command_dict.find(cmd);
if (pos != m_command_dict.end())
{
if (pos->second->IsRemovable())
{
// Only regular expression objects or python commands are removable
m_command_dict.erase(pos);
return true;
}
}
return false;
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
bool
CommandInterpreter::RemoveUser (const char *alias_name)
{
CommandObject::CommandMap::iterator pos = m_user_dict.find(alias_name);
if (pos != m_user_dict.end())
{
m_user_dict.erase(pos);
return true;
}
return false;
}
void
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
CommandInterpreter::GetHelp (CommandReturnObject &result,
Adding two new options to the 'help' command: --show-aliases (-a) shows aliases for commands, as well as built-in commands --hide-user-defined (-u) hides user defined commands by default 'help' without arguments does not show aliases anymore. to see them, add --show-aliases to have only built-in commands appear, use 'help --hide-user-defined' ; there is currently no way to hide built-in commands from the help output 'help command' is not changed by this commit, and help is shown even if command is an alias and -a is not specified llvm-svn: 139377
2011-09-10 01:49:36 +08:00
uint32_t cmd_types)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
const char * help_prologue = GetDebugger().GetIOHandlerHelpPrologue();
if (help_prologue != NULL)
{
OutputFormattedHelpText(result.GetOutputStream(), NULL, help_prologue);
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
CommandObject::CommandMap::const_iterator pos;
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
size_t max_len = FindLongestCommandWord (m_command_dict);
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
if ( (cmd_types & eCommandTypesBuiltin) == eCommandTypesBuiltin )
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
result.AppendMessage("Debugger commands:");
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
result.AppendMessage("");
for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos)
{
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
if (!(cmd_types & eCommandTypesHidden) && (pos->first.compare(0, 1, "_") == 0))
continue;
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", pos->second->GetHelp(),
max_len);
}
result.AppendMessage("");
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
if (!m_alias_dict.empty() && ( (cmd_types & eCommandTypesAliases) == eCommandTypesAliases ))
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
result.AppendMessageWithFormat("Current command abbreviations "
"(type '%shelp command alias' for more info):\n",
GetCommandPrefix());
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
result.AppendMessage("");
Changed the StackID to store its start PC address as a load address instead of a section offset address. Fixed up some very inefficient STL code. llvm-svn: 112230
2010-08-27 06:05:43 +08:00
max_len = FindLongestCommandWord (m_alias_dict);
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
for (auto alias_pos = m_alias_dict.begin(); alias_pos != m_alias_dict.end(); ++alias_pos)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
More of the alias refactoring work! CommandAlias is now a CommandObject llvm-svn: 263468
2016-03-15 03:00:21 +08:00
OutputFormattedHelpText (result.GetOutputStream(), alias_pos->first.c_str(), "--", alias_pos->second->GetHelp(),
max_len);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
result.AppendMessage("");
}
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
if (!m_user_dict.empty() && ( (cmd_types & eCommandTypesUserDef) == eCommandTypesUserDef ))
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
result.AppendMessage ("Current user-defined commands:");
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
result.AppendMessage("");
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
max_len = FindLongestCommandWord (m_user_dict);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos)
{
Changes to Python commands: - They now have an SBCommandReturnObject instead of an SBStream as third argument - The class CommandObjectPythonFunction has been merged into CommandObjectCommands.cpp - The command to manage them is now: command script with subcommands add, list, delete, clear command alias is returned to its previous functionality - Python commands are now part of an user dictionary, instead of being seen as aliases llvm-svn: 137785
2011-08-17 07:24:13 +08:00
OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", pos->second->GetHelp(),
max_len);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
result.AppendMessage("");
}
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
result.AppendMessageWithFormat("For more information on any command, type '%shelp <command-name>'.\n",
GetCommandPrefix());
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
CommandObject *
CommandInterpreter::GetCommandObjectForCommand (std::string &command_string)
{
// This function finds the final, lowest-level, alias-resolved command object whose 'Execute' function will
// eventually be invoked by the given command line.
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
CommandObject *cmd_obj = nullptr;
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
size_t start = command_string.find_first_not_of (k_white_space);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
size_t end = 0;
bool done = false;
while (!done)
{
if (start != std::string::npos)
{
// Get the next word from command_string.
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
end = command_string.find_first_of (k_white_space, start);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
if (end == std::string::npos)
end = command_string.size();
std::string cmd_word = command_string.substr (start, end - start);
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (cmd_obj == nullptr)
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
// Since cmd_obj is NULL we are on our first time through this loop. Check to see if cmd_word is a valid
// command or alias.
cmd_obj = GetCommandObject (cmd_word.c_str());
else if (cmd_obj->IsMultiwordObject ())
{
// Our current object is a multi-word object; see if the cmd_word is a valid sub-command for our object.
<rdar://problem/12491387> I added the ability for a process plug-in to implement custom commands. All the lldb_private::Process plug-in has to do is override: virtual CommandObject * GetPluginCommandObject(); This object returned should be a multi-word command that vends LLDB commands. There is a sample implementation in ProcessGDBRemote that is hollowed out. It is intended to be used for sending a custom packet, though the body of the command execute function has yet to be implemented! llvm-svn: 165861
2012-10-13 10:07:45 +08:00
CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject (cmd_word.c_str());
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
if (sub_cmd_obj)
cmd_obj = sub_cmd_obj;
Fix a variety of typos. No functional change. llvm-svn: 239995
2015-06-18 13:27:05 +08:00
else // cmd_word was not a valid sub-command word, so we are done
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
done = true;
}
else
// We have a cmd_obj and it is not a multi-word object, so we are done.
done = true;
// If we didn't find a valid command object, or our command object is not a multi-word object, or
// we are at the end of the command_string, then we are done. Otherwise, find the start of the
// next word.
if (!cmd_obj || !cmd_obj->IsMultiwordObject() || end >= command_string.size())
done = true;
else
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
start = command_string.find_first_not_of (k_white_space, end);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
else
// Unable to find any more words.
done = true;
}
if (end == command_string.size())
command_string.clear();
else
command_string = command_string.substr(end);
return cmd_obj;
}
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
static const char *k_valid_command_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
static void
StripLeadingSpaces (std::string &s)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
if (!s.empty())
{
size_t pos = s.find_first_not_of (k_white_space);
if (pos == std::string::npos)
s.clear();
else if (pos == 0)
return;
s.erase (0, pos);
}
}
<rdar://problem/10374840> Fixed an issue with the gdb format stuff for any aliases that expand to contain a "--". llvm-svn: 144240
2011-11-10 07:25:03 +08:00
static size_t
FindArgumentTerminator (const std::string &s)
{
const size_t s_len = s.size();
size_t offset = 0;
while (offset < s_len)
{
size_t pos = s.find ("--", offset);
if (pos == std::string::npos)
break;
if (pos > 0)
{
if (isspace(s[pos-1]))
{
// Check if the string ends "\s--" (where \s is a space character)
// or if we have "\s--\s".
if ((pos + 2 >= s_len) || isspace(s[pos+2]))
{
return pos;
}
}
}
offset = pos + 2;
}
return std::string::npos;
}
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
static bool
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
ExtractCommand (std::string &command_string, std::string &command, std::string &suffix, char &quote_char)
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
{
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
command.clear();
suffix.clear();
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
StripLeadingSpaces (command_string);
bool result = false;
quote_char = '\0';
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
if (!command_string.empty())
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
const char first_char = command_string[0];
if (first_char == '\'' || first_char == '"')
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
quote_char = first_char;
const size_t end_quote_pos = command_string.find (quote_char, 1);
if (end_quote_pos == std::string::npos)
Add ability to recognize/handle quotes around commands (e.g. '"target" create' works as well as 'target create'). llvm-svn: 131185
2011-05-12 00:07:06 +08:00
{
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
command.swap (command_string);
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
command_string.erase ();
Add ability to recognize/handle quotes around commands (e.g. '"target" create' works as well as 'target create'). llvm-svn: 131185
2011-05-12 00:07:06 +08:00
}
else
{
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
command.assign (command_string, 1, end_quote_pos - 1);
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
if (end_quote_pos + 1 < command_string.size())
command_string.erase (0, command_string.find_first_not_of (k_white_space, end_quote_pos + 1));
else
command_string.erase ();
Add ability to recognize/handle quotes around commands (e.g. '"target" create' works as well as 'target create'). llvm-svn: 131185
2011-05-12 00:07:06 +08:00
}
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
else
{
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
const size_t first_space_pos = command_string.find_first_of (k_white_space);
if (first_space_pos == std::string::npos)
Add ability to recognize/handle quotes around commands (e.g. '"target" create' works as well as 'target create'). llvm-svn: 131185
2011-05-12 00:07:06 +08:00
{
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
command.swap (command_string);
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
command_string.erase();
Add ability to recognize/handle quotes around commands (e.g. '"target" create' works as well as 'target create'). llvm-svn: 131185
2011-05-12 00:07:06 +08:00
}
else
{
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
command.assign (command_string, 0, first_space_pos);
command_string.erase(0, command_string.find_first_not_of (k_white_space, first_space_pos));
Add ability to recognize/handle quotes around commands (e.g. '"target" create' works as well as 'target create'). llvm-svn: 131185
2011-05-12 00:07:06 +08:00
}
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
result = true;
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
if (!command.empty())
{
// actual commands can't start with '-' or '_'
if (command[0] != '-' && command[0] != '_')
{
size_t pos = command.find_first_not_of(k_valid_command_chars);
if (pos > 0 && pos != std::string::npos)
{
suffix.assign (command.begin() + pos, command.end());
command.erase (pos);
}
}
}
Simplified the CommandInterpreter::StripFirstWord logic by making it a static function and having it not require both a bool and a quote char to fill in. We intend to get rid of this functionality when we rewrite the command interpreter for streams eventually, but not for now. llvm-svn: 142888
2011-10-25 08:36:27 +08:00
return result;
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
CommandObject *
CommandInterpreter::BuildAliasResult (const char *alias_name,
std::string &raw_input_string,
std::string &alias_result,
CommandReturnObject &result)
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
CommandObject *alias_cmd_obj = nullptr;
Fix handling of backslashes in Args parsing Summary: Presently Args::SetCommandString allows quotes to be escaped with backslash. However, the backslash itself is not removed from the argument, nor there is a way to escape the backslash itself. This leads to surprising results: "a b" c" -> 'a b', 'c' # Here we actually have an unterminated quote, but that is ignored "a b\" c" -> 'a b\" c' # We try to escape the quote. That works but the backslash is not removed. "a b\\" c" -> 'a b\\" c' # Escaping the backslash has no effect. This change changes quote handling to be more shell-like: - single quotes and backquotes are literal and there is no way to escape the closing quote or anything else inside; - inside double quotes you can use backslash to escape the closing quote and another backslash - outside any quotes, you can use backslash to escape quotes, spaces and itself. This makes the parsing more consistent with what the user is familiar and increases the probability that pasting the command line from shell to the "process launch" command "just work". Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D7855 llvm-svn: 230955
2015-03-02 20:46:22 +08:00
Args cmd_args (raw_input_string);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
alias_cmd_obj = GetCommandObject (alias_name);
StreamString result_str;
Lots of progress on the CommandAlias refactoring This cleans things up such CommandAlias essentially can work as its own object; the aliases still live in a separate map, but are now just full-fledged CommandObjectSPs This patch also cleans up help generation for aliases, allows aliases to vend their own help, and adds a tweak such that "dash-dash aliases", such as po, don't show the list of options for their underlying command, since those can't be provided anyway I plan to fix up a few more things here, and then add a test case and proclaim victory llvm-svn: 263499
2016-03-15 06:17:04 +08:00
if (alias_cmd_obj && alias_cmd_obj->IsAlias())
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
Fix a bug caused by my alias refactoring where, if an alias was defined in terms of another alias, trying to run the nested command would actually cause a crash in the command interpreter llvm-svn: 264096
2016-03-23 05:07:54 +08:00
std::pair<CommandObjectSP, OptionArgVectorSP> desugared = ((CommandAlias*)alias_cmd_obj)->Desugar();
OptionArgVectorSP option_arg_vector_sp = desugared.second;
alias_cmd_obj = desugared.first.get();
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
std::string alias_name_str = alias_name;
if ((cmd_args.GetArgumentCount() == 0)
|| (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0))
cmd_args.Unshift (alias_name);
result_str.Printf ("%s", alias_cmd_obj->GetCommandName ());
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
if (option_arg_vector_sp.get())
{
OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
Sort out a number of mismatched integer types in order to cut down the number of compiler warnings. llvm-svn: 184333
2013-06-20 03:04:53 +08:00
for (size_t i = 0; i < option_arg_vector->size(); ++i)
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
OptionArgPair option_pair = (*option_arg_vector)[i];
OptionArgValue value_pair = option_pair.second;
int value_type = value_pair.first;
std::string option = option_pair.first;
std::string value = value_pair.second;
if (option.compare ("<argument>") == 0)
result_str.Printf (" %s", value.c_str());
else
{
result_str.Printf (" %s", option.c_str());
Fix check for options in "command alias" Summary: "command alias" can add invalid options to the command. "command alias start process launch -s" will add an extra argument, "<no-argument>" to the alias, so it runs "process launch -s <no-argument>", which launches the process with args that include "<no-argument>". This patch changes the text compare of the variable value with "<OptionParser::eNoArgument>" to a compare of variable value_type with OptionParser::eNoArgument. It also moves the previous test inside the if, so it won't add a trailing space if there is no argument. Reviewers: clayborg Reviewed By: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D8844 llvm-svn: 234244
2015-04-07 05:55:14 +08:00
if (value_type != OptionParser::eNoArgument)
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
Fix check for options in "command alias" Summary: "command alias" can add invalid options to the command. "command alias start process launch -s" will add an extra argument, "<no-argument>" to the alias, so it runs "process launch -s <no-argument>", which launches the process with args that include "<no-argument>". This patch changes the text compare of the variable value with "<OptionParser::eNoArgument>" to a compare of variable value_type with OptionParser::eNoArgument. It also moves the previous test inside the if, so it won't add a trailing space if there is no argument. Reviewers: clayborg Reviewed By: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D8844 llvm-svn: 234244
2015-04-07 05:55:14 +08:00
if (value_type != OptionParser::eOptionalArgument)
result_str.Printf (" ");
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
int index = GetOptionArgumentPosition (value.c_str());
if (index == 0)
result_str.Printf ("%s", value.c_str());
sanitise sign comparisons This is a mechanical change addressing the various sign comparison warnings that are identified by both clang and gcc. This helps cleanup some of the warning spew that occurs during builds. llvm-svn: 205390
2014-04-02 11:51:35 +08:00
else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount())
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
result.AppendErrorWithFormat
("Not enough arguments provided; you need at least %d arguments to use this alias.\n",
index);
result.SetStatus (eReturnStatusFailed);
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
return nullptr;
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
else
{
size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index));
if (strpos != std::string::npos)
raw_input_string = raw_input_string.erase (strpos,
strlen (cmd_args.GetArgumentAtIndex (index)));
result_str.Printf ("%s", cmd_args.GetArgumentAtIndex (index));
}
}
}
}
}
alias_result = result_str.GetData();
}
Added the ability to have GDB formats appended to any command so you can do things like: (lldb) x/32xb 0x1000 "x" is an alias to "memory read", so this will actually turn into: (lldb) memory read --gdb-format=32xb 0x1000 This applies to all commands, so the GDB formats will work with "register read", "frame variable", "target variable" and others. All commands that can accept formats, counts and sizes have been modified to support the "--gdb-format" option. llvm-svn: 143230
2011-10-29 05:38:01 +08:00
return alias_cmd_obj;
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
Error
CommandInterpreter::PreprocessCommand (std::string &command)
{
// The command preprocessor needs to do things to the command
// line before any parsing of arguments or anything else is done.
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
// The only current stuff that gets preprocessed is anything enclosed
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
// in backtick ('`') characters is evaluated as an expression and
// the result of the expression must be a scalar that can be substituted
// into the command. An example would be:
// (lldb) memory read `$rsp + 20`
Error error; // Error for any expressions that might not evaluate
size_t start_backtick;
size_t pos = 0;
while ((start_backtick = command.find ('`', pos)) != std::string::npos)
{
if (start_backtick > 0 && command[start_backtick-1] == '\\')
{
Fix a variety of typos. No functional change. llvm-svn: 239995
2015-06-18 13:27:05 +08:00
// The backtick was preceded by a '\' character, remove the slash
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
// and don't treat the backtick as the start of an expression
command.erase(start_backtick-1, 1);
// No need to add one to start_backtick since we just deleted a char
pos = start_backtick;
}
else
{
const size_t expr_content_start = start_backtick + 1;
const size_t end_backtick = command.find ('`', expr_content_start);
if (end_backtick == std::string::npos)
return error;
else if (end_backtick == expr_content_start)
{
// Empty expression (two backticks in a row)
command.erase (start_backtick, 2);
}
else
{
std::string expr_str (command, expr_content_start, end_backtick - expr_content_start);
<rdar://problem/11791234> Fixed a case where the python interpreter could end up holding onto a previous lldb::SBProcess (probably in lldb.process) when run under Xcode. Prior to this fix, the lldb::SBProcess held onto a shared pointer to a lldb_private::Process. This in turn could cause the process to still have a thread list with stack frames. The stack frames would have module shared pointers in the lldb_private::SymbolContext objects. We also had issues with things staying in the shared module list too long when we found things by UUID (we didn't remove the out of date ModuleSP from the global module cache). Now all of this is fixed and everything goes away between runs. llvm-svn: 160140
2012-07-13 04:32:19 +08:00
ExecutionContext exe_ctx(GetExecutionContext());
Target *target = exe_ctx.GetTargetPtr();
Get a dummy target to allow for calculator mode while processing backticks. This also helps break the infinite loop caused when target is null. So that we can have: $ /Volumes/data/lldb/svn/trunk/build/Debug/lldb (lldb) itob `0x123 - 0x321` 32 v 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0] (lldb) llvm-svn: 143260
2011-10-29 08:21:50 +08:00
// Get a dummy target to allow for calculator mode while processing backticks.
// This also helps break the infinite loop caused when target is null.
if (!target)
This is the first step of making lldb able to create target-specific things (e.g. breakpoints, stop-hooks) before we have any targets - for instance in your ~/.lldbinit file. These will then get copied over to any new targets that get created. So far, you can only make stop-hooks. Breakpoints will have to learn to move themselves from target to target for us to get them from no-target to new-target. We should also make a command & SB API way to prime this ur-target. llvm-svn: 222600
2014-11-22 09:42:44 +08:00
target = m_debugger.GetDummyTarget();
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
if (target)
{
ValueObjectSP expr_result_valobj_sp;
Implementing an Options class for EvaluateExpression() in order to make the signature more compact and make it easy to 'just run an expression' llvm-svn: 163239
2012-09-06 04:41:26 +08:00
Add the ability to set timeout & "run all threads" options both from the "expr" command and from the SB API's that evaluate expressions. <rdar://problem/12457211> llvm-svn: 166062
2012-10-17 05:41:58 +08:00
EvaluateExpressionOptions options;
This patch does a couple of things. It completes the job of using EvaluateExpressionOptions consistently throughout the inferior function calling mechanism in lldb begun in Greg's patch r194009. It removes a handful of alternate calls into the ClangUserExpression/ClangFunction/ThreadPlanCallFunction which were there for convenience. Using the EvaluateExpressionOptions removes the need for them. Using that it gets the --debug option from Greg's patch to work cleanly. It also adds another EvaluateExpressionOption to not trap exceptions when running expressions. You shouldn't use this option unless you KNOW your expression can't throw beyond itself. This is: <rdar://problem/15374885> At present this is only available through the SB API's or python. It fixes a bug where function calls would unset the ObjC & C++ exception breakpoints without checking whether they were set by somebody else already. llvm-svn: 194182
2013-11-07 08:11:47 +08:00
options.SetCoerceToId(false);
options.SetUnwindOnError(true);
options.SetIgnoreBreakpoints(true);
options.SetKeepInMemory(false);
options.SetTryAllThreads(true);
options.SetTimeoutUsec(0);
Implementing an Options class for EvaluateExpression() in order to make the signature more compact and make it easy to 'just run an expression' llvm-svn: 163239
2012-09-06 04:41:26 +08:00
Make the Expression Execution result enum available to the SB API layer. Add a callback that will allow an expression to be cancelled between the expression evaluation stages (for the ClangUserExpressions.) <rdar://problem/16790467>, <rdar://problem/16573440> llvm-svn: 207944
2014-05-05 10:26:40 +08:00
ExpressionResults expr_result = target->EvaluateExpression (expr_str.c_str(),
In cases where you'd use an expression to get a value to insert in a command, be ready to use synthetic children if they are there. Those are now a source of values, so worth checking for llvm-svn: 219452
2014-10-10 07:09:40 +08:00
exe_ctx.GetFramePtr(),
expr_result_valobj_sp,
options);
Implementing an Options class for EvaluateExpression() in order to make the signature more compact and make it easy to 'just run an expression' llvm-svn: 163239
2012-09-06 04:41:26 +08:00
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
if (expr_result == eExpressionCompleted)
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
{
Scalar scalar;
In cases where you'd use an expression to get a value to insert in a command, be ready to use synthetic children if they are there. Those are now a source of values, so worth checking for llvm-svn: 219452
2014-10-10 07:09:40 +08:00
if (expr_result_valobj_sp)
expr_result_valobj_sp = expr_result_valobj_sp->GetQualifiedRepresentationIfAvailable(expr_result_valobj_sp->GetDynamicValueType(), true);
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
if (expr_result_valobj_sp->ResolveValue (scalar))
{
command.erase (start_backtick, end_backtick - start_backtick + 1);
StreamString value_strm;
const bool show_type = false;
scalar.GetValue (&value_strm, show_type);
size_t value_string_size = value_strm.GetSize();
if (value_string_size)
{
command.insert (start_backtick, value_strm.GetData(), value_string_size);
pos = start_backtick + value_string_size;
continue;
}
else
{
error.SetErrorStringWithFormat("expression value didn't result in a scalar value for the expression '%s'", expr_str.c_str());
}
}
else
{
error.SetErrorStringWithFormat("expression value didn't result in a scalar value for the expression '%s'", expr_str.c_str());
}
}
else
{
if (expr_result_valobj_sp)
error = expr_result_valobj_sp->GetError();
if (error.Success())
{
switch (expr_result)
{
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionSetupError:
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
error.SetErrorStringWithFormat("expression setup error for the expression '%s'", expr_str.c_str());
break;
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionParseError:
Make the Expression Execution result enum available to the SB API layer. Add a callback that will allow an expression to be cancelled between the expression evaluation stages (for the ClangUserExpressions.) <rdar://problem/16790467>, <rdar://problem/16573440> llvm-svn: 207944
2014-05-05 10:26:40 +08:00
error.SetErrorStringWithFormat ("expression parse error for the expression '%s'", expr_str.c_str());
break;
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionResultUnavailable:
Make the Expression Execution result enum available to the SB API layer. Add a callback that will allow an expression to be cancelled between the expression evaluation stages (for the ClangUserExpressions.) <rdar://problem/16790467>, <rdar://problem/16573440> llvm-svn: 207944
2014-05-05 10:26:40 +08:00
error.SetErrorStringWithFormat ("expression error fetching result for the expression '%s'", expr_str.c_str());
Fix all of the unannotated switch cases to annotate the fall through or do the right thing and break. llvm-svn: 261950
2016-02-26 09:20:20 +08:00
break;
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionCompleted:
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
break;
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionDiscarded:
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
error.SetErrorStringWithFormat("expression discarded for the expression '%s'", expr_str.c_str());
break;
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionInterrupted:
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
error.SetErrorStringWithFormat("expression interrupted for the expression '%s'", expr_str.c_str());
break;
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionHitBreakpoint:
Separated the "expr --unwind-on-error" behavior into two parts, actual errors (i.e. crashes) which continue to be controlled by the --unwind-on-error flag, and --ignore-breakpoint which separately controls behavior when a called function hits a breakpoint. For breakpoints, we don't unwind, we either stop, or ignore the breakpoint, which makes more sense. Also make both these behaviors globally settable through "settings set". Also handle the case where a breakpoint command calls code that ends up re-hitting the breakpoint. We were recursing and crashing. Now we just stop without calling the second command. <rdar://problem/12986644> <rdar://problem/9119325> llvm-svn: 172503
2013-01-15 10:47:48 +08:00
error.SetErrorStringWithFormat("expression hit breakpoint for the expression '%s'", expr_str.c_str());
break;
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionTimedOut:
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
error.SetErrorStringWithFormat("expression timed out for the expression '%s'", expr_str.c_str());
break;
Rename eExecution*** to eExpression*** to be consistent with the result type. llvm-svn: 207945
2014-05-05 10:47:44 +08:00
case eExpressionStoppedForDebug:
Fixed a build warning for a missing switch case. llvm-svn: 194295
2013-11-09 07:38:26 +08:00
error.SetErrorStringWithFormat("expression stop at entry point for debugging for the expression '%s'", expr_str.c_str());
break;
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
}
}
}
}
}
if (error.Fail())
break;
}
}
return error;
}
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
bool
CommandInterpreter::HandleCommand (const char *command_line,
<rdar://problem/11328896> Fixing a bug where regex commands were saved in the history even if they came from a 'command sourced' file - this fix introduces a command sourcing depth and disables history for all levels of depth > 0, which means no commands go into history when being sourced from a file. we need an integer depth because command files might themselves source other command files, ... llvm-svn: 157727
2012-05-31 09:09:06 +08:00
LazyBool lazy_add_to_history,
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
CommandReturnObject &result,
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
ExecutionContext *override_context,
Fix a problem where the stop-hook command 'frame variable g_val' produces nothing when newly created threads were subsequently stopped due to breakpoint hit. The stop-hook mechanism delegates to CommandInterpreter::HandleCommands() to execuet the commands. Make sure the execution context is switched only once at the beginning of HandleCommands() only and don't update the context while looping on each individual command to be executed. rdar://problem/10228156 llvm-svn: 141144
2011-10-05 08:42:59 +08:00
bool repeat_on_empty_command,
bool no_context_switching)
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
std::string command_string (command_line);
Added "command history" command to dump the command history. Also made: (lldb) !<NUM> (lldb) !-<NUM> (lldb) !! work with the history. For added benefit: (lldb) !<NUM><TAB> will insert the command at position <NUM> in the history into the command line to be edited. This is only partial, I still need to sync up editline's history list with the one kept by the interpreter. llvm-svn: 134955
2011-07-12 11:12:18 +08:00
std::string original_command_string (command_line);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_COMMANDS));
Modified lldb_private::SymboleFile to be able to override where its TypeList comes from by using a virtual function to provide it from the Module's SymbolVendor by default. This allows the DWARF parser, when being used to parse DWARF in .o files with a parent DWARF + debug map parser, to get its type list from the DWARF + debug map parser so when we go and find full definitions for types (that might come from other .o files), we can use the type list from the debug map parser. Otherwise we ended up mixing clang types from one .o file (say a const pointer to a forward declaration "class A") with the a full type from another .o file. This causes expression parsing, when copying the clang types from those parsed by the DWARF parser into the expression AST, to fail -- for good reason. Now all types are created in the same list. Also added host support for crash description strings that can be set before doing a piece of work. On MacOSX, this ties in with CrashReporter support that allows a string to be dispalyed when the app crashes and allows LLDB.framework to print a description string in the crash log. Right now this is hookup up the the CommandInterpreter::HandleCommand() where each command notes that it is about to be executed, so if we crash while trying to do this command, we should be able to see the command that caused LLDB to exit. For all other platforms, this is a nop. llvm-svn: 118672
2010-11-10 12:57:04 +08:00
Host::SetCrashDescriptionWithFormat ("HandleCommand(command = \"%s\")", command_line);
// Make a scoped cleanup object that will clear the crash description string
// on exit of this function.
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
lldb_utility::CleanUp <const char *> crash_description_cleanup(nullptr, Host::SetCrashDescription);
Modified lldb_private::SymboleFile to be able to override where its TypeList comes from by using a virtual function to provide it from the Module's SymbolVendor by default. This allows the DWARF parser, when being used to parse DWARF in .o files with a parent DWARF + debug map parser, to get its type list from the DWARF + debug map parser so when we go and find full definitions for types (that might come from other .o files), we can use the type list from the debug map parser. Otherwise we ended up mixing clang types from one .o file (say a const pointer to a forward declaration "class A") with the a full type from another .o file. This causes expression parsing, when copying the clang types from those parsed by the DWARF parser into the expression AST, to fail -- for good reason. Now all types are created in the same list. Also added host support for crash description strings that can be set before doing a piece of work. On MacOSX, this ties in with CrashReporter support that allows a string to be dispalyed when the app crashes and allows LLDB.framework to print a description string in the crash log. Right now this is hookup up the the CommandInterpreter::HandleCommand() where each command notes that it is about to be executed, so if we crash while trying to do this command, we should be able to see the command that caused LLDB to exit. For all other platforms, this is a nop. llvm-svn: 118672
2010-11-10 12:57:04 +08:00
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
if (log)
log->Printf ("Processing command: %s", command_line);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
Delete Host/windows/win32.h It's always hard to remember when to include this file, and when you do include it it's hard to remember what preprocessor check it needs to be behind, and then you further have to remember whether it's windows.h or win32.h which you need to include. This patch changes the name to PosixApi.h, which is more appropriately named, and makes it independent of any preprocessor setting. There's still the issue of people not knowing when to include this, because there's not a well-defined set of things it exposes other than "whatever is missing on Windows", but at least this should make it less painful to fix when problems arise. This patch depends on LLVM revision r278170. llvm-svn: 278177
2016-08-10 07:06:08 +08:00
Timer scoped_timer (LLVM_PRETTY_FUNCTION, "Handling command: %s.", command_line);
Added a top level Timer to the interpreter execute command. Also added an option to pass the depth to "log timer enable". That allows you to time just command execution with: log timer enable 1 <command> log timer dump llvm-svn: 118267
2010-11-05 07:08:45 +08:00
Fix a problem where the stop-hook command 'frame variable g_val' produces nothing when newly created threads were subsequently stopped due to breakpoint hit. The stop-hook mechanism delegates to CommandInterpreter::HandleCommands() to execuet the commands. Make sure the execution context is switched only once at the beginning of HandleCommands() only and don't update the context while looping on each individual command to be executed. rdar://problem/10228156 llvm-svn: 141144
2011-10-05 08:42:59 +08:00
if (!no_context_switching)
UpdateExecutionContext (override_context);
<rdar://problem/11328896> Fixing a bug where regex commands were saved in the history even if they came from a 'command sourced' file - this fix introduces a command sourcing depth and disables history for all levels of depth > 0, which means no commands go into history when being sourced from a file. we need an integer depth because command files might themselves source other command files, ... llvm-svn: 157727
2012-05-31 09:09:06 +08:00
bool add_to_history;
if (lazy_add_to_history == eLazyBoolCalculate)
add_to_history = (m_command_source_depth == 0);
else
add_to_history = (lazy_add_to_history == eLazyBoolYes);
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
bool empty_command = false;
bool comment_command = false;
if (command_string.empty())
empty_command = true;
else
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
const char *k_space_characters = "\t\n\v\f\r ";
size_t non_space = command_string.find_first_not_of (k_space_characters);
// Check for empty line or comment line (lines whose first
// non-space character is the comment character for this interpreter)
if (non_space == std::string::npos)
empty_command = true;
else if (command_string[non_space] == m_comment_char)
comment_command = true;
<rdar://problem/14134716> This is a rewrite of the command history facility of LLDB It takes the history management out of the CommandInterpreter into its own CommandHistory class It reimplements the command history command to allow more combinations of options to work correctly (e.g. com hist -c 1 -s 5) It adds a new --wipe (-w) option to command history to allow clearing the history on demand It extends the lldbtest runCmd: and expect: methods to allow adding commands to history if need be It adds a test case for the reimplemented facility llvm-svn: 184140
2013-06-18 06:51:50 +08:00
else if (command_string[non_space] == CommandHistory::g_repeat_char)
Added "command history" command to dump the command history. Also made: (lldb) !<NUM> (lldb) !-<NUM> (lldb) !! work with the history. For added benefit: (lldb) !<NUM><TAB> will insert the command at position <NUM> in the history into the command line to be edited. This is only partial, I still need to sync up editline's history list with the one kept by the interpreter. llvm-svn: 134955
2011-07-12 11:12:18 +08:00
{
<rdar://problem/14134716> This is a rewrite of the command history facility of LLDB It takes the history management out of the CommandInterpreter into its own CommandHistory class It reimplements the command history command to allow more combinations of options to work correctly (e.g. com hist -c 1 -s 5) It adds a new --wipe (-w) option to command history to allow clearing the history on demand It extends the lldbtest runCmd: and expect: methods to allow adding commands to history if need be It adds a test case for the reimplemented facility llvm-svn: 184140
2013-06-18 06:51:50 +08:00
const char *history_string = m_command_history.FindString(command_string.c_str() + non_space);
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (history_string == nullptr)
Added "command history" command to dump the command history. Also made: (lldb) !<NUM> (lldb) !-<NUM> (lldb) !! work with the history. For added benefit: (lldb) !<NUM><TAB> will insert the command at position <NUM> in the history into the command line to be edited. This is only partial, I still need to sync up editline's history list with the one kept by the interpreter. llvm-svn: 134955
2011-07-12 11:12:18 +08:00
{
result.AppendErrorWithFormat ("Could not find entry: %s in history", command_string.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
add_to_history = false;
command_string = history_string;
original_command_string = history_string;
}
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
}
if (empty_command)
{
if (repeat_on_empty_command)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
<rdar://problem/14134716> This is a rewrite of the command history facility of LLDB It takes the history management out of the CommandInterpreter into its own CommandHistory class It reimplements the command history command to allow more combinations of options to work correctly (e.g. com hist -c 1 -s 5) It adds a new --wipe (-w) option to command history to allow clearing the history on demand It extends the lldbtest runCmd: and expect: methods to allow adding commands to history if need be It adds a test case for the reimplemented facility llvm-svn: 184140
2013-06-18 06:51:50 +08:00
if (m_command_history.IsEmpty())
Added a "GetRepeatCommand" to the command object. The Interpreter uses this instead of the last history item to provide a command for the "empty" command. Use this in the source-file command to make <RETURN> continue the listing rather than relist the first listing... llvm-svn: 107736
2010-07-07 07:48:33 +08:00
{
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
result.AppendError ("empty command");
result.SetStatus(eReturnStatusFailed);
Added a "GetRepeatCommand" to the command object. The Interpreter uses this instead of the last history item to provide a command for the "empty" command. Use this in the source-file command to make <RETURN> continue the listing rather than relist the first listing... llvm-svn: 107736
2010-07-07 07:48:33 +08:00
return false;
}
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
else
{
command_line = m_repeat_command.c_str();
command_string = command_line;
Added "command history" command to dump the command history. Also made: (lldb) !<NUM> (lldb) !-<NUM> (lldb) !! work with the history. For added benefit: (lldb) !<NUM><TAB> will insert the command at position <NUM> in the history into the command line to be edited. This is only partial, I still need to sync up editline's history list with the one kept by the interpreter. llvm-svn: 134955
2011-07-12 11:12:18 +08:00
original_command_string = command_line;
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
if (m_repeat_command.empty())
{
result.AppendErrorWithFormat("No auto repeat.\n");
result.SetStatus (eReturnStatusFailed);
return false;
}
}
add_to_history = false;
}
else
{
result.SetStatus (eReturnStatusSuccessFinishNoResult);
return true;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
}
else if (comment_command)
{
result.SetStatus (eReturnStatusSuccessFinishNoResult);
return true;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Add ability to recognize/handle quotes around commands (e.g. '"target" create' works as well as 'target create'). llvm-svn: 131185
2011-05-12 00:07:06 +08:00
Added the ability to run expressions in any command. Expressions can be inserted in commands by using backticks: (lldb) memory read `$rsp-16` `$rsp+16` (lldb) memory read -c `(int)strlen(argv[0])` `argv[0]` The result of the expression will be inserted into the command as a sort of preprocess stage where this gets done first. We might need to tweak where this preprocess stage goes, but it is very functional already. Added ansi color support to the Debugger::FormatPrompt() so you can use things like "${ansi.fg.blue}" and "${ansi.bold}" many more. This helps in adding colors to your prompts without needing to know the ANSI color code strings. llvm-svn: 141948
2011-10-14 15:41:33 +08:00
Error error (PreprocessCommand (command_string));
if (error.Fail())
{
result.AppendError (error.AsCString());
result.SetStatus(eReturnStatusFailed);
return false;
}
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
// Phase 1.
<rdar://problem/10374840> Fixed an issue with the gdb format stuff for any aliases that expand to contain a "--". llvm-svn: 144240
2011-11-10 07:25:03 +08:00
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
// Before we do ANY kind of argument processing, we need to figure out what
// the real/final command object is for the specified command. This gets
// complicated by the fact that the user could have specified an alias, and,
// in translating the alias, there may also be command options and/or even
// data (including raw text strings) that need to be found and inserted into
// the command line as part of the translation. So this first step is plain
// look-up and replacement, resulting in:
// 1. the command object whose Execute method will actually be called
// 2. a revised command string, with all substitutions and replacements
// taken care of
// From 1 above, we can determine whether the Execute function wants raw
// input or not.
CommandObject *cmd_obj = ResolveCommandImpl(command_string, result);
// Although the user may have abbreviated the command, the command_string now
// has the command expanded to the full name. For example, if the input
// was "br s -n main", command_string is now "breakpoint set -n main".
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
if (log)
{
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
log->Printf("HandleCommand, cmd_obj : '%s'", cmd_obj ? cmd_obj->GetCommandName() : "<not found>");
log->Printf("HandleCommand, (revised) command_string: '%s'", command_string.c_str());
const bool wants_raw_input = (cmd_obj != NULL) ? cmd_obj->WantsRawCommandString() : false;
log->Printf("HandleCommand, wants_raw_input:'%s'", wants_raw_input ? "True" : "False");
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
// Phase 2.
// Take care of things like setting up the history command & calling the appropriate Execute method on the
// CommandObject, with the appropriate arguments.
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (cmd_obj != nullptr)
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
{
if (add_to_history)
{
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
Args command_args (command_string);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
const char *repeat_command = cmd_obj->GetRepeatCommand(command_args, 0);
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (repeat_command != nullptr)
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
m_repeat_command.assign(repeat_command);
else
Added "command history" command to dump the command history. Also made: (lldb) !<NUM> (lldb) !-<NUM> (lldb) !! work with the history. For added benefit: (lldb) !<NUM><TAB> will insert the command at position <NUM> in the history into the command line to be edited. This is only partial, I still need to sync up editline's history list with the one kept by the interpreter. llvm-svn: 134955
2011-07-12 11:12:18 +08:00
m_repeat_command.assign(original_command_string.c_str());
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
<rdar://problem/14134716> This is a rewrite of the command history facility of LLDB It takes the history management out of the CommandInterpreter into its own CommandHistory class It reimplements the command history command to allow more combinations of options to work correctly (e.g. com hist -c 1 -s 5) It adds a new --wipe (-w) option to command history to allow clearing the history on demand It extends the lldbtest runCmd: and expect: methods to allow adding commands to history if need be It adds a test case for the reimplemented facility llvm-svn: 184140
2013-06-18 06:51:50 +08:00
m_command_history.AppendString (original_command_string);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
Fix bug where using incomplete strings for command names causes lldb to crash (because of attempt to look for full names when full names were not used). llvm-svn: 121607
2010-12-11 16:16:56 +08:00
std::string remainder;
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
const std::size_t actual_cmd_name_len = strlen (cmd_obj->GetCommandName());
Fix bug where using incomplete strings for command names causes lldb to crash (because of attempt to look for full names when full names were not used). llvm-svn: 121607
2010-12-11 16:16:56 +08:00
if (actual_cmd_name_len < command_string.length())
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
remainder = command_string.substr (actual_cmd_name_len);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
// Remove any initial spaces
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
size_t pos = remainder.find_first_not_of (k_white_space);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
if (pos != 0 && pos != std::string::npos)
Erase from a string instead of using substr when you don't really need to. llvm-svn: 130013
2011-04-23 04:58:45 +08:00
remainder.erase(0, pos);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
if (log)
Include lldb/commands as a valid logging type in the 'log list' output. Remove an extraneous \n from one of the lldb/commands log line. Add an lldb/commands log indicating whether the command was successful or not. llvm-svn: 138530
2011-08-25 08:20:04 +08:00
log->Printf ("HandleCommand, command line after removing command name(s): '%s'", remainder.c_str());
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
Make raw & parsed commands subclasses of CommandObject rather than having the raw version implement an Execute which was never going to get run and another ExecuteRawCommandString. Took the knowledge of how to prepare raw & parsed commands out of CommandInterpreter and put it in CommandObject where it belongs. Also took all the cases where there were the subcommands of Multiword commands declared in the .h file for the overall command and moved them into the .cpp file. Made the CommandObject flags work for raw as well as parsed commands. Made "expr" use the flags so that it requires you to be paused to run "expr". llvm-svn: 158235
2012-06-09 05:56:10 +08:00
cmd_obj->Execute (remainder.c_str(), result);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
}
else
{
// We didn't find the first command object, so complete the first argument.
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
Args command_args (command_string);
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
StringList matches;
int num_matches;
int cursor_index = 0;
int cursor_char_position = strlen (command_args.GetArgumentAtIndex(0));
bool word_complete;
num_matches = HandleCompletionMatches (command_args,
cursor_index,
cursor_char_position,
0,
-1,
word_complete,
matches);
if (num_matches > 0)
{
std::string error_msg;
error_msg.assign ("ambiguous command '");
error_msg.append(command_args.GetArgumentAtIndex(0));
error_msg.append ("'.");
error_msg.append (" Possible completions:");
for (int i = 0; i < num_matches; i++)
{
error_msg.append ("\n\t");
error_msg.append (matches.GetStringAtIndex (i));
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
error_msg.append ("\n");
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
result.AppendRawError (error_msg.c_str());
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
else
result.AppendErrorWithFormat ("Unrecognized command '%s'.\n", command_args.GetArgumentAtIndex (0));
result.SetStatus (eReturnStatusFailed);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Modify HandleCommand to not do any argument processing until it has determined whether or not the command should take raw input, then handle & dispatch the arguments appropriately. Also change the 'alias' command to be a command that takes raw input. This is necessary to allow aliases to be created for other commands that take raw input and might want to include raw input in the alias itself. Fix a bug in the aliasing mechanism when creating aliases for commands with 3-or-more words. Raw input should now be properly handled by all the command and alias mechanisms. llvm-svn: 121423
2010-12-10 06:52:49 +08:00
Include lldb/commands as a valid logging type in the 'log list' output. Remove an extraneous \n from one of the lldb/commands log line. Add an lldb/commands log indicating whether the command was successful or not. llvm-svn: 138530
2011-08-25 08:20:04 +08:00
if (log)
log->Printf ("HandleCommand, command %s", (result.Succeeded() ? "succeeded" : "did not succeed"));
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
return result.Succeeded();
}
int
CommandInterpreter::HandleCompletionMatches (Args &parsed_line,
int &cursor_index,
int &cursor_char_position,
int match_start_point,
int max_return_elements,
Add a source file completer to the CommandCompleters. Add a way for the completers to say whether the completed argument should have a space inserted after is or not. Added the file name completer to the "file" command. llvm-svn: 107247
2010-06-30 13:02:46 +08:00
bool &word_complete,
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
StringList &matches)
{
int num_command_matches = 0;
bool look_for_subcommand = false;
Add a source file completer to the CommandCompleters. Add a way for the completers to say whether the completed argument should have a space inserted after is or not. Added the file name completer to the "file" command. llvm-svn: 107247
2010-06-30 13:02:46 +08:00
// For any of the command completions a unique match will be a complete word.
word_complete = true;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (cursor_index == -1)
{
// We got nothing on the command line, so return the list of commands
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
bool include_aliases = true;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
num_command_matches = GetCommandNamesMatchingPartialString ("", include_aliases, matches);
}
else if (cursor_index == 0)
{
// The cursor is in the first argument, so just do a lookup in the dictionary.
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
CommandObject *cmd_obj = GetCommandObject (parsed_line.GetArgumentAtIndex(0), &matches);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
num_command_matches = matches.GetSize();
if (num_command_matches == 1
&& cmd_obj && cmd_obj->IsMultiwordObject()
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
&& matches.GetStringAtIndex(0) != nullptr
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
&& strcmp (parsed_line.GetArgumentAtIndex(0), matches.GetStringAtIndex(0)) == 0)
{
Fix autocompletion for multi-word commands. <rdar://problem/14183288> llvm-svn: 196949
2013-12-11 03:14:04 +08:00
if (parsed_line.GetArgumentCount() == 1)
{
word_complete = true;
}
else
{
look_for_subcommand = true;
num_command_matches = 0;
matches.DeleteStringAtIndex(0);
parsed_line.AppendArgument ("");
cursor_index++;
cursor_char_position = 0;
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
}
if (cursor_index > 0 || look_for_subcommand)
{
// We are completing further on into a commands arguments, so find the command and tell it
// to complete the command.
// First see if there is a matching initial command:
Hide the logic for command resolution for commands, aliases & user commands behind a single interface so everybody does it the same way. Add an "exact" lookup for internal uses. Fix up a few little cases where we weren't reporting command lookup errors correctly. Added "b" as an alias for "breakpoint" so it doesn't collide with "bt". llvm-svn: 107718
2010-07-07 06:46:59 +08:00
CommandObject *command_object = GetCommandObject (parsed_line.GetArgumentAtIndex(0));
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (command_object == nullptr)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
return 0;
}
else
{
parsed_line.Shift();
cursor_index--;
Fixed the way set/show variables were being accessed to being natively accessed by the objects that own the settings. The previous approach wasn't very usable and made for a lot of unnecessary code just to access variables that were already owned by the objects. While I fixed those things, I saw that CommandObject objects should really have a reference to their command interpreter so they can access the terminal with if they want to output usaage. Fixed up all CommandObjects to take an interpreter and cleaned up the API to not need the interpreter to be passed in. Fixed the disassemble command to output the usage if no options are passed down and arguments are passed (all disassebmle variants take options, there are no "args only"). llvm-svn: 114252
2010-09-18 09:14:36 +08:00
num_command_matches = command_object->HandleCompletion (parsed_line,
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
cursor_index,
cursor_char_position,
match_start_point,
Add a source file completer to the CommandCompleters. Add a way for the completers to say whether the completed argument should have a space inserted after is or not. Added the file name completer to the "file" command. llvm-svn: 107247
2010-06-30 13:02:46 +08:00
max_return_elements,
word_complete,
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
matches);
}
}
return num_command_matches;
}
int
CommandInterpreter::HandleCompletion (const char *current_line,
const char *cursor,
const char *last_char,
int match_start_point,
int max_return_elements,
StringList &matches)
{
// We parse the argument up to the cursor, so the last argument in parsed_line is
// the one containing the cursor, and the cursor is after the last character.
Fix handling of backslashes in Args parsing Summary: Presently Args::SetCommandString allows quotes to be escaped with backslash. However, the backslash itself is not removed from the argument, nor there is a way to escape the backslash itself. This leads to surprising results: "a b" c" -> 'a b', 'c' # Here we actually have an unterminated quote, but that is ignored "a b\" c" -> 'a b\" c' # We try to escape the quote. That works but the backslash is not removed. "a b\\" c" -> 'a b\\" c' # Escaping the backslash has no effect. This change changes quote handling to be more shell-like: - single quotes and backquotes are literal and there is no way to escape the closing quote or anything else inside; - inside double quotes you can use backslash to escape the closing quote and another backslash - outside any quotes, you can use backslash to escape quotes, spaces and itself. This makes the parsing more consistent with what the user is familiar and increases the probability that pasting the command line from shell to the "process launch" command "just work". Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D7855 llvm-svn: 230955
2015-03-02 20:46:22 +08:00
Args parsed_line(llvm::StringRef(current_line, last_char - current_line));
Args partial_parsed_line(llvm::StringRef(current_line, cursor - current_line));
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
Added "command history" command to dump the command history. Also made: (lldb) !<NUM> (lldb) !-<NUM> (lldb) !! work with the history. For added benefit: (lldb) !<NUM><TAB> will insert the command at position <NUM> in the history into the command line to be edited. This is only partial, I still need to sync up editline's history list with the one kept by the interpreter. llvm-svn: 134955
2011-07-12 11:12:18 +08:00
// Don't complete comments, and if the line we are completing is just the history repeat character,
// substitute the appropriate history line.
const char *first_arg = parsed_line.GetArgumentAtIndex(0);
if (first_arg)
{
if (first_arg[0] == m_comment_char)
return 0;
<rdar://problem/14134716> This is a rewrite of the command history facility of LLDB It takes the history management out of the CommandInterpreter into its own CommandHistory class It reimplements the command history command to allow more combinations of options to work correctly (e.g. com hist -c 1 -s 5) It adds a new --wipe (-w) option to command history to allow clearing the history on demand It extends the lldbtest runCmd: and expect: methods to allow adding commands to history if need be It adds a test case for the reimplemented facility llvm-svn: 184140
2013-06-18 06:51:50 +08:00
else if (first_arg[0] == CommandHistory::g_repeat_char)
Added "command history" command to dump the command history. Also made: (lldb) !<NUM> (lldb) !-<NUM> (lldb) !! work with the history. For added benefit: (lldb) !<NUM><TAB> will insert the command at position <NUM> in the history into the command line to be edited. This is only partial, I still need to sync up editline's history list with the one kept by the interpreter. llvm-svn: 134955
2011-07-12 11:12:18 +08:00
{
<rdar://problem/14134716> This is a rewrite of the command history facility of LLDB It takes the history management out of the CommandInterpreter into its own CommandHistory class It reimplements the command history command to allow more combinations of options to work correctly (e.g. com hist -c 1 -s 5) It adds a new --wipe (-w) option to command history to allow clearing the history on demand It extends the lldbtest runCmd: and expect: methods to allow adding commands to history if need be It adds a test case for the reimplemented facility llvm-svn: 184140
2013-06-18 06:51:50 +08:00
const char *history_string = m_command_history.FindString (first_arg);
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (history_string != nullptr)
Added "command history" command to dump the command history. Also made: (lldb) !<NUM> (lldb) !-<NUM> (lldb) !! work with the history. For added benefit: (lldb) !<NUM><TAB> will insert the command at position <NUM> in the history into the command line to be edited. This is only partial, I still need to sync up editline's history list with the one kept by the interpreter. llvm-svn: 134955
2011-07-12 11:12:18 +08:00
{
matches.Clear();
matches.InsertStringAtIndex(0, history_string);
return -2;
}
else
return 0;
}
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
int num_args = partial_parsed_line.GetArgumentCount();
int cursor_index = partial_parsed_line.GetArgumentCount() - 1;
int cursor_char_position;
if (cursor_index == -1)
cursor_char_position = 0;
else
cursor_char_position = strlen (partial_parsed_line.GetArgumentAtIndex(cursor_index));
Fix the completion of "fr " and the like. llvm-svn: 121785
2010-12-15 03:56:01 +08:00
if (cursor > current_line && cursor[-1] == ' ')
{
// We are just after a space. If we are in an argument, then we will continue
// parsing, but if we are between arguments, then we have to complete whatever the next
// element would be.
// We can distinguish the two cases because if we are in an argument (e.g. because the space is
// protected by a quote) then the space will also be in the parsed argument...
const char *current_elem = partial_parsed_line.GetArgumentAtIndex(cursor_index);
if (cursor_char_position == 0 || current_elem[cursor_char_position - 1] != ' ')
{
Fix autocompletion for multi-word commands. <rdar://problem/14183288> llvm-svn: 196949
2013-12-11 03:14:04 +08:00
parsed_line.InsertArgumentAtIndex(cursor_index + 1, "", '\0');
Fix the completion of "fr " and the like. llvm-svn: 121785
2010-12-15 03:56:01 +08:00
cursor_index++;
cursor_char_position = 0;
}
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
int num_command_matches;
matches.Clear();
// Only max_return_elements == -1 is supported at present:
assert (max_return_elements == -1);
Add a source file completer to the CommandCompleters. Add a way for the completers to say whether the completed argument should have a space inserted after is or not. Added the file name completer to the "file" command. llvm-svn: 107247
2010-06-30 13:02:46 +08:00
bool word_complete;
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
num_command_matches = HandleCompletionMatches (parsed_line,
cursor_index,
cursor_char_position,
match_start_point,
Add a source file completer to the CommandCompleters. Add a way for the completers to say whether the completed argument should have a space inserted after is or not. Added the file name completer to the "file" command. llvm-svn: 107247
2010-06-30 13:02:46 +08:00
max_return_elements,
word_complete,
Very large changes that were needed in order to allow multiple connections to the debugger from GUI windows. Previously there was one global debugger instance that could be accessed that had its own command interpreter and current state (current target/process/thread/frame). When a GUI debugger was attached, if it opened more than one window that each had a console window, there were issues where the last one to setup the global debugger object won and got control of the debugger. To avoid this we now create instances of the lldb_private::Debugger that each has its own state: - target list for targets the debugger instance owns - current process/thread/frame - its own command interpreter - its own input, output and error file handles to avoid conflicts - its own input reader stack So now clients should call: SBDebugger::Initialize(); // (static function) SBDebugger debugger (SBDebugger::Create()); // Use which ever file handles you wish debugger.SetErrorFileHandle (stderr, false); debugger.SetOutputFileHandle (stdout, false); debugger.SetInputFileHandle (stdin, true); // main loop SBDebugger::Terminate(); // (static function) SBDebugger::Initialize() and SBDebugger::Terminate() are ref counted to ensure nothing gets destroyed too early when multiple clients might be attached. Cleaned up the command interpreter and the CommandObject and all subclasses to take more appropriate arguments. llvm-svn: 106615
2010-06-23 09:19:29 +08:00
matches);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (num_command_matches <= 0)
Fix tab completion for command arguments containing spaces If a command argument contains a space then it have to be escaped with backslash signs so the argument parsing logic can parse it properly. This CL fixes the tab completion code for the arguments to create complitions with correctly escaped strings. Differential revision: http://reviews.llvm.org/D12531 llvm-svn: 246639
2015-09-02 18:35:27 +08:00
return num_command_matches;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (num_args == 0)
{
// If we got an empty string, insert nothing.
matches.InsertStringAtIndex(0, "");
}
else
{
// Now figure out if there is a common substring, and if so put that in element 0, otherwise
// put an empty string in element 0.
std::string command_partial_str;
if (cursor_index >= 0)
Changed "run" to alias "process launch --". Added "po" alias for "expression -o --" llvm-svn: 117125
2010-10-23 02:47:16 +08:00
command_partial_str.assign(parsed_line.GetArgumentAtIndex(cursor_index),
parsed_line.GetArgumentAtIndex(cursor_index) + cursor_char_position);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
std::string common_prefix;
matches.LongestCommonPrefix (common_prefix);
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
const size_t partial_name_len = command_partial_str.size();
Fix tab completion for command arguments containing spaces If a command argument contains a space then it have to be escaped with backslash signs so the argument parsing logic can parse it properly. This CL fixes the tab completion code for the arguments to create complitions with correctly escaped strings. Differential revision: http://reviews.llvm.org/D12531 llvm-svn: 246639
2015-09-02 18:35:27 +08:00
common_prefix.erase (0, partial_name_len);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
// If we matched a unique single command, add a space...
Add a source file completer to the CommandCompleters. Add a way for the completers to say whether the completed argument should have a space inserted after is or not. Added the file name completer to the "file" command. llvm-svn: 107247
2010-06-30 13:02:46 +08:00
// Only do this if the completer told us this was a complete word, however...
if (num_command_matches == 1 && word_complete)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
char quote_char = parsed_line.GetArgumentQuoteCharAtIndex(cursor_index);
Fix tab completion for command arguments containing spaces If a command argument contains a space then it have to be escaped with backslash signs so the argument parsing logic can parse it properly. This CL fixes the tab completion code for the arguments to create complitions with correctly escaped strings. Differential revision: http://reviews.llvm.org/D12531 llvm-svn: 246639
2015-09-02 18:35:27 +08:00
common_prefix = Args::EscapeLLDBCommandArgument(common_prefix, quote_char);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (quote_char != '\0')
common_prefix.push_back(quote_char);
common_prefix.push_back(' ');
}
matches.InsertStringAtIndex(0, common_prefix.c_str());
}
return num_command_matches;
}
CommandInterpreter::~CommandInterpreter ()
{
}
void
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
CommandInterpreter::UpdatePrompt (const char *new_prompt)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
EventSP prompt_change_event_sp (new Event(eBroadcastBitResetPrompt, new EventDataBytes (new_prompt)));;
BroadcastEvent (prompt_change_event_sp);
if (m_command_io_handler_sp)
m_command_io_handler_sp->SetPrompt(new_prompt);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Add a "Confirm" function to the CommandInterpreter so you can confirm potentially dangerous operations in a generic way. llvm-svn: 115546
2010-10-05 03:49:29 +08:00
bool
CommandInterpreter::Confirm (const char *message, bool default_answer)
{
Add an "auto-confirm" setting to the debugger so you can turn off the confirmations if you want to. llvm-svn: 115572
2010-10-05 06:44:14 +08:00
// Check AutoConfirm first:
if (m_debugger.GetAutoConfirm())
return default_answer;
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
IOHandlerConfirm *confirm = new IOHandlerConfirm(m_debugger,
message,
default_answer);
IOHandlerSP io_handler_sp (confirm);
m_debugger.RunIOHandler (io_handler_sp);
return confirm->GetResponse();
Add a "Confirm" function to the CommandInterpreter so you can confirm potentially dangerous operations in a generic way. llvm-svn: 115546
2010-10-05 03:49:29 +08:00
}
Move CommandAlias to its own file; also Store std::unique_ptr<CommandAlias> instead of instances llvm-svn: 262958
2016-03-09 05:23:30 +08:00
CommandAlias*
Turn GetAliasOptions() into GetAlias() Eventually, there will be more things that CommandAlias contains, and I don't want accessors for each of them on the CommandIntepreter Eventually, we also won't pass around copies of CommandAlias, but that's for a later patch llvm-svn: 262909
2016-03-08 11:56:12 +08:00
CommandInterpreter::GetAlias (const char *alias_name)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
OptionArgVectorSP ret_val;
std::string alias (alias_name);
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
auto pos = m_alias_dict.find(alias);
if (pos != m_alias_dict.end())
More of the alias refactoring work! CommandAlias is now a CommandObject llvm-svn: 263468
2016-03-15 03:00:21 +08:00
return (CommandAlias*)pos->second.get();
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
Move CommandAlias to its own file; also Store std::unique_ptr<CommandAlias> instead of instances llvm-svn: 262958
2016-03-09 05:23:30 +08:00
return nullptr;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
bool
CommandInterpreter::HasCommands ()
{
return (!m_command_dict.empty());
}
bool
CommandInterpreter::HasAliases ()
{
return (!m_alias_dict.empty());
}
bool
CommandInterpreter::HasUserCommands ()
{
return (!m_user_dict.empty());
}
bool
CommandInterpreter::HasAliasOptions ()
{
Change the way command aliases are stored. Go from a model where a map holds the alias -> underlying command binding and another map holds the alias -> options, to a model where one single map holds the alias -> (all useful data) combination Right now, obviously, this is just the pair of (CommandObjectSP,OptionArgVectorSP), so NFC This is step one of a larger - and tricky - refactoring which will turn command aliases into interesting objects instead of passive storage that the command interpreter does smart things to This refactoring, in turn, will allow us to do interesting things with aliases, such as intelligent and customizable help llvm-svn: 262900
2016-03-08 10:49:15 +08:00
return HasAliases();
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
void
Fix some memory leaks. Add call to lldb.SBDebugger.Initialize() to lldb.py, so it automatically gets called when the lldb Python module gets loaded. llvm-svn: 116345
2010-10-13 05:57:09 +08:00
CommandInterpreter::BuildAliasCommandArgs (CommandObject *alias_cmd_obj,
const char *alias_name,
Args &cmd_args,
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
std::string &raw_input_string,
Fix some memory leaks. Add call to lldb.SBDebugger.Initialize() to lldb.py, so it automatically gets called when the lldb Python module gets loaded. llvm-svn: 116345
2010-10-13 05:57:09 +08:00
CommandReturnObject &result)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Move CommandAlias to its own file; also Store std::unique_ptr<CommandAlias> instead of instances llvm-svn: 262958
2016-03-09 05:23:30 +08:00
OptionArgVectorSP option_arg_vector_sp = GetAlias(alias_name)->GetOptionArguments();
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
bool wants_raw_input = alias_cmd_obj->WantsRawCommandString();
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
// Make sure that the alias name is the 0th element in cmd_args
std::string alias_name_str = alias_name;
if (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0)
cmd_args.Unshift (alias_name);
Args new_args (alias_cmd_obj->GetCommandName());
if (new_args.GetArgumentCount() == 2)
new_args.Shift();
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (option_arg_vector_sp.get())
{
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
if (wants_raw_input)
{
// We have a command that both has command options and takes raw input. Make *sure* it has a
// " -- " in the right place in the raw_input_string.
size_t pos = raw_input_string.find(" -- ");
if (pos == std::string::npos)
{
// None found; assume it goes at the beginning of the raw input string
raw_input_string.insert (0, " -- ");
}
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
<rdar://problem/13069948> Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary. So I defined a new "lldb::offset_t" which should be used for all file offsets. After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed. Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections. llvm-svn: 173463
2013-01-26 02:06:21 +08:00
const size_t old_size = cmd_args.GetArgumentCount();
Fix some memory leaks. Add call to lldb.SBDebugger.Initialize() to lldb.py, so it automatically gets called when the lldb Python module gets loaded. llvm-svn: 116345
2010-10-13 05:57:09 +08:00
std::vector<bool> used (old_size + 1, false);
used[0] = true;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
Sort out a number of mismatched integer types in order to cut down the number of compiler warnings. llvm-svn: 184333
2013-06-20 03:04:53 +08:00
for (size_t i = 0; i < option_arg_vector->size(); ++i)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
OptionArgPair option_pair = (*option_arg_vector)[i];
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
OptionArgValue value_pair = option_pair.second;
int value_type = value_pair.first;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
std::string option = option_pair.first;
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
std::string value = value_pair.second;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (option.compare ("<argument>") == 0)
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
{
if (!wants_raw_input
|| (value.compare("--") != 0)) // Since we inserted this above, make sure we don't insert it twice
new_args.AppendArgument (value.c_str());
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
else
{
Add OptionParser.h llvm-svn: 190063
2013-09-06 00:42:23 +08:00
if (value_type != OptionParser::eOptionalArgument)
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
new_args.AppendArgument (option.c_str());
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
if (value.compare ("<no-argument>") != 0)
{
int index = GetOptionArgumentPosition (value.c_str());
if (index == 0)
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
{
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
// value was NOT a positional argument; must be a real value
Add OptionParser.h llvm-svn: 190063
2013-09-06 00:42:23 +08:00
if (value_type != OptionParser::eOptionalArgument)
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
new_args.AppendArgument (value.c_str());
else
{
char buffer[255];
::snprintf (buffer, sizeof (buffer), "%s%s", option.c_str(), value.c_str());
new_args.AppendArgument (buffer);
}
}
sanitise sign comparisons This is a mechanical change addressing the various sign comparison warnings that are identified by both clang and gcc. This helps cleanup some of the warning spew that occurs during builds. llvm-svn: 205390
2014-04-02 11:51:35 +08:00
else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount())
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
result.AppendErrorWithFormat
("Not enough arguments provided; you need at least %d arguments to use this alias.\n",
index);
result.SetStatus (eReturnStatusFailed);
return;
}
else
{
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
// Find and remove cmd_args.GetArgumentAtIndex(i) from raw_input_string
size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index));
if (strpos != std::string::npos)
{
raw_input_string = raw_input_string.erase (strpos, strlen (cmd_args.GetArgumentAtIndex (index)));
}
Add OptionParser.h llvm-svn: 190063
2013-09-06 00:42:23 +08:00
if (value_type != OptionParser::eOptionalArgument)
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
new_args.AppendArgument (cmd_args.GetArgumentAtIndex (index));
else
{
char buffer[255];
::snprintf (buffer, sizeof(buffer), "%s%s", option.c_str(),
cmd_args.GetArgumentAtIndex (index));
new_args.AppendArgument (buffer);
}
Fix some memory leaks. Add call to lldb.SBDebugger.Initialize() to lldb.py, so it automatically gets called when the lldb Python module gets loaded. llvm-svn: 116345
2010-10-13 05:57:09 +08:00
used[index] = true;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
}
}
}
Sort out a number of mismatched integer types in order to cut down the number of compiler warnings. llvm-svn: 184333
2013-06-20 03:04:53 +08:00
for (size_t j = 0; j < cmd_args.GetArgumentCount(); ++j)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
if (!used[j] && !wants_raw_input)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
new_args.AppendArgument (cmd_args.GetArgumentAtIndex (j));
}
cmd_args.Clear();
Fixed a ton of gcc compile warnings Removed some unused variables, added some consts, changed some casts to const_cast. I don't think any of these changes are very controversial. Differential Revision: http://reviews.llvm.org/D9674 llvm-svn: 237218
2015-05-13 08:25:54 +08:00
cmd_args.SetArguments (new_args.GetArgumentCount(), new_args.GetConstArgumentVector());
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
else
{
result.SetStatus (eReturnStatusSuccessFinishNoResult);
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
// This alias was not created with any options; nothing further needs to be done, unless it is a command that
// wants raw input, in which case we need to clear the rest of the data from cmd_args, since its in the raw
// input string.
if (wants_raw_input)
{
cmd_args.Clear();
Fixed a ton of gcc compile warnings Removed some unused variables, added some consts, changed some casts to const_cast. I don't think any of these changes are very controversial. Differential Revision: http://reviews.llvm.org/D9674 llvm-svn: 237218
2015-05-13 08:25:54 +08:00
cmd_args.SetArguments (new_args.GetArgumentCount(), new_args.GetConstArgumentVector());
- Fix alias-building & resolving to properly handle optional arguments for command options. - Add logging for command resolution ('log enable lldb commands') - Fix alias resolution to properly handle commands that take raw input (resolve the alias, but don't muck up the raw arguments). Net result: Among other things, 'expr' command can now take strings with escaped characters and not have the command handling & alias resolution code muck up the escaped characters. E.g. 'expr printf ("\n\n\tHello there!")' should now work properly. Not working yet: Creating aliases with raw input for commands that take raw input. Working on that. e.g. 'command alias print_hi expr printf ("\n\tHi!")' does not work yet. llvm-svn: 121171
2010-12-08 03:58:26 +08:00
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
return;
}
result.SetStatus (eReturnStatusSuccessFinishNoResult);
return;
}
int
CommandInterpreter::GetOptionArgumentPosition (const char *in_string)
{
int position = 0; // Any string that isn't an argument position, i.e. '%' followed by an integer, gets a position
// of zero.
Fixed a ton of gcc compile warnings Removed some unused variables, added some consts, changed some casts to const_cast. I don't think any of these changes are very controversial. Differential Revision: http://reviews.llvm.org/D9674 llvm-svn: 237218
2015-05-13 08:25:54 +08:00
const char *cptr = in_string;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
// Does it start with '%'
if (cptr[0] == '%')
{
++cptr;
// Is the rest of it entirely digits?
if (isdigit (cptr[0]))
{
const char *start = cptr;
while (isdigit (cptr[0]))
++cptr;
// We've gotten to the end of the digits; are we at the end of the string?
if (cptr[0] == '\0')
position = atoi (start);
}
}
return position;
}
void
CommandInterpreter::SourceInitFile (bool in_cwd, CommandReturnObject &result)
{
Make ValueObject::SetValueFromCString work correctly. Also change the SourceInitFile to look for .lldb-<APPNAME> and source that preferentially if it exists. Also made the breakpoint site report its address as well as its breakpoint number when it gets hit and can't find any the associated locations (usually because the breakpoint got disabled or deleted programmatically between the time it was hit and reported.) Changed ThreadPlanCallFunction to initialize the ivar m_func in the initializers of the constructor, rather than waiting to initialize till later on in the function. Fixed a bug where if you make an SBError and the ask it Success, it returns false. Fixed ValueObject::ResolveValue so that it resolves a temporary value, rather than overwriting the one in the value object. llvm-svn: 137536
2011-08-13 07:34:31 +08:00
FileSpec init_file;
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
if (in_cwd)
Make ValueObject::SetValueFromCString work correctly. Also change the SourceInitFile to look for .lldb-<APPNAME> and source that preferentially if it exists. Also made the breakpoint site report its address as well as its breakpoint number when it gets hit and can't find any the associated locations (usually because the breakpoint got disabled or deleted programmatically between the time it was hit and reported.) Changed ThreadPlanCallFunction to initialize the ivar m_func in the initializers of the constructor, rather than waiting to initialize till later on in the function. Fixed a bug where if you make an SBError and the ask it Success, it returns false. Fixed ValueObject::ResolveValue so that it resolves a temporary value, rather than overwriting the one in the value object. llvm-svn: 137536
2011-08-13 07:34:31 +08:00
{
This patch stops lldb from loading a .lldbinit file from the current working directory by default -- a typical security problem that we need to be more conservative about. It adds a new target setting, target.load-cwd-lldbinit which may be true (always read $cwd/.lldbinit), false (never read $cwd/.lldbinit) or warn (warn if there is a $cwd/.lldbinit and don't read it). The default is set to warn. If this is met with unhappiness, we can look at changing the default to true (to match current behavior) on a different platform. This does not affect reading of ~/.lldbinit - that will still be read, as before. If you run lldb in your home directory, it will not warn about the presence of a .lldbinit file there. I had to add two SB API - SBHostOS::GetUserHomeDirectory and SBFileSpec::AppendPathComponent - for the lldb driver code to be able to get the home directory path in an OS neutral manner. The warning text is There is a .lldbinit file in the current directory which is not being read. To silence this warning without sourcing in the local .lldbinit, add the following to the lldbinit file in your home directory: settings set target.load-cwd-lldbinit false To allow lldb to source .lldbinit files in the current working directory, set the value of this variable to true. Only do so if you understand and accept the security risk. <rdar://problem/24199163> llvm-svn: 261280
2016-02-19 08:05:17 +08:00
ExecutionContext exe_ctx(GetExecutionContext());
Target *target = exe_ctx.GetTargetPtr();
if (target)
{
// In the current working directory we don't load any program specific
// .lldbinit files, we only look for a ".lldbinit" file.
if (m_skip_lldbinit_files)
return;
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
This patch stops lldb from loading a .lldbinit file from the current working directory by default -- a typical security problem that we need to be more conservative about. It adds a new target setting, target.load-cwd-lldbinit which may be true (always read $cwd/.lldbinit), false (never read $cwd/.lldbinit) or warn (warn if there is a $cwd/.lldbinit and don't read it). The default is set to warn. If this is met with unhappiness, we can look at changing the default to true (to match current behavior) on a different platform. This does not affect reading of ~/.lldbinit - that will still be read, as before. If you run lldb in your home directory, it will not warn about the presence of a .lldbinit file there. I had to add two SB API - SBHostOS::GetUserHomeDirectory and SBFileSpec::AppendPathComponent - for the lldb driver code to be able to get the home directory path in an OS neutral manner. The warning text is There is a .lldbinit file in the current directory which is not being read. To silence this warning without sourcing in the local .lldbinit, add the following to the lldbinit file in your home directory: settings set target.load-cwd-lldbinit false To allow lldb to source .lldbinit files in the current working directory, set the value of this variable to true. Only do so if you understand and accept the security risk. <rdar://problem/24199163> llvm-svn: 261280
2016-02-19 08:05:17 +08:00
LoadCWDlldbinitFile should_load = target->TargetProperties::GetLoadCWDlldbinitFile ();
if (should_load == eLoadCWDlldbinitWarn)
{
FileSpec dot_lldb (".lldbinit", true);
llvm::SmallString<64> home_dir_path;
llvm::sys::path::home_directory (home_dir_path);
FileSpec homedir_dot_lldb (home_dir_path.c_str(), false);
homedir_dot_lldb.AppendPathComponent (".lldbinit");
homedir_dot_lldb.ResolvePath ();
if (dot_lldb.Exists ()
&& dot_lldb.GetDirectory() != homedir_dot_lldb.GetDirectory())
{
result.AppendErrorWithFormat (
"There is a .lldbinit file in the current directory which is not being read.\n"
"To silence this warning without sourcing in the local .lldbinit,\n"
"add the following to the lldbinit file in your home directory:\n"
" settings set target.load-cwd-lldbinit false\n"
"To allow lldb to source .lldbinit files in the current working directory,\n"
"set the value of this variable to true. Only do so if you understand and\n"
"accept the security risk.");
result.SetStatus (eReturnStatusFailed);
return;
}
}
else if (should_load == eLoadCWDlldbinitTrue)
{
init_file.SetFile ("./.lldbinit", true);
}
}
Make ValueObject::SetValueFromCString work correctly. Also change the SourceInitFile to look for .lldb-<APPNAME> and source that preferentially if it exists. Also made the breakpoint site report its address as well as its breakpoint number when it gets hit and can't find any the associated locations (usually because the breakpoint got disabled or deleted programmatically between the time it was hit and reported.) Changed ThreadPlanCallFunction to initialize the ivar m_func in the initializers of the constructor, rather than waiting to initialize till later on in the function. Fixed a bug where if you make an SBError and the ask it Success, it returns false. Fixed ValueObject::ResolveValue so that it resolves a temporary value, rather than overwriting the one in the value object. llvm-svn: 137536
2011-08-13 07:34:31 +08:00
}
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
else
Make ValueObject::SetValueFromCString work correctly. Also change the SourceInitFile to look for .lldb-<APPNAME> and source that preferentially if it exists. Also made the breakpoint site report its address as well as its breakpoint number when it gets hit and can't find any the associated locations (usually because the breakpoint got disabled or deleted programmatically between the time it was hit and reported.) Changed ThreadPlanCallFunction to initialize the ivar m_func in the initializers of the constructor, rather than waiting to initialize till later on in the function. Fixed a bug where if you make an SBError and the ask it Success, it returns false. Fixed ValueObject::ResolveValue so that it resolves a temporary value, rather than overwriting the one in the value object. llvm-svn: 137536
2011-08-13 07:34:31 +08:00
{
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
// If we aren't looking in the current working directory we are looking
// in the home directory. We will first see if there is an application
// specific ".lldbinit" file whose name is "~/.lldbinit" followed by a
// "-" and the name of the program. If this file doesn't exist, we fall
// back to just the "~/.lldbinit" file. We also obey any requests to not
// load the init files.
Move the rest of the HostInfo functions over. This should bring HostInfo up to 99% completion. The remainder of code in Host will be split into instantiatable classes representing host processes, threads, dynamic libraries, and process launching strategies. llvm-svn: 216230
2014-08-22 05:49:24 +08:00
llvm::SmallString<64> home_dir_path;
llvm::sys::path::home_directory(home_dir_path);
FileSpec profilePath(home_dir_path.c_str(), false);
Use llvm Support functions to get the user's home directory. Assuming that the user's home directory is at ~ is incorrect on Windows. This patch delegates the request to LLVM's support library, which already provides a cross-platform implementation of this function. Differential Revision: http://reviews.llvm.org/D4674 llvm-svn: 214093
2014-07-29 00:45:05 +08:00
profilePath.AppendPathComponent(".lldbinit");
std::string init_file_path = profilePath.GetPath();
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
if (m_skip_app_init_files == false)
{
Move the rest of the HostInfo functions over. This should bring HostInfo up to 99% completion. The remainder of code in Host will be split into instantiatable classes representing host processes, threads, dynamic libraries, and process launching strategies. llvm-svn: 216230
2014-08-22 05:49:24 +08:00
FileSpec program_file_spec(HostInfo::GetProgramFileSpec());
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
const char *program_name = program_file_spec.GetFilename().AsCString();
Make ValueObject::SetValueFromCString work correctly. Also change the SourceInitFile to look for .lldb-<APPNAME> and source that preferentially if it exists. Also made the breakpoint site report its address as well as its breakpoint number when it gets hit and can't find any the associated locations (usually because the breakpoint got disabled or deleted programmatically between the time it was hit and reported.) Changed ThreadPlanCallFunction to initialize the ivar m_func in the initializers of the constructor, rather than waiting to initialize till later on in the function. Fixed a bug where if you make an SBError and the ask it Success, it returns false. Fixed ValueObject::ResolveValue so that it resolves a temporary value, rather than overwriting the one in the value object. llvm-svn: 137536
2011-08-13 07:34:31 +08:00
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
if (program_name)
{
char program_init_file_name[PATH_MAX];
Use llvm Support functions to get the user's home directory. Assuming that the user's home directory is at ~ is incorrect on Windows. This patch delegates the request to LLVM's support library, which already provides a cross-platform implementation of this function. Differential Revision: http://reviews.llvm.org/D4674 llvm-svn: 214093
2014-07-29 00:45:05 +08:00
::snprintf (program_init_file_name, sizeof(program_init_file_name), "%s-%s", init_file_path.c_str(), program_name);
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
init_file.SetFile (program_init_file_name, true);
if (!init_file.Exists())
init_file.Clear();
}
}
if (!init_file && !m_skip_lldbinit_files)
Use llvm Support functions to get the user's home directory. Assuming that the user's home directory is at ~ is incorrect on Windows. This patch delegates the request to LLVM's support library, which already provides a cross-platform implementation of this function. Differential Revision: http://reviews.llvm.org/D4674 llvm-svn: 214093
2014-07-29 00:45:05 +08:00
init_file.SetFile (init_file_path.c_str(), false);
Don't skip the application specific ~/.lldbinit file when the program name is "lldb". So currently when you startup any application and you have not specified that you would like to skip loading init files through the API or from "lldb" options, then LLDB will try and load: "~/.lldbinit-%s" where %s the basename of your program "~/.lldbinit" Then LLDB will load any program specified on the command line and then source the "./.llbinit" file for any temporary debug session specific commands. I want this feature because I have thread and frame formats that do ANSI color codes that I only want to load when running in a terminal which is when I am running the "lldb" command line program. llvm-svn: 139476
2011-09-11 08:01:44 +08:00
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
// If the file exists, tell HandleCommand to 'source' it; this will do the actual broadcasting
// of the commands back to any appropriate listener (see CommandObjectSource::Execute for more details).
if (init_file.Exists())
{
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
const bool saved_batch = SetBatchCommandMode (true);
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
CommandInterpreterRunOptions options;
options.SetSilent (true);
options.SetStopOnError (false);
options.SetStopOnContinue (true);
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
HandleCommandsFromFile (init_file,
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
nullptr, // Execution context
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
options,
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
result);
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
SetBatchCommandMode (saved_batch);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
else
{
// nothing to be done if the file doesn't exist
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
}
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
const char *
CommandInterpreter::GetCommandPrefix()
{
const char * prefix = GetDebugger().GetIOHandlerCommandPrefix();
return prefix == NULL ? "" : prefix;
}
Moved the execution context that was in the Debugger into the CommandInterpreter where it was always being used. Make sure that Modules can track their object file offsets correctly to allow opening of sub object files (like the "__commpage" on darwin). Modified the Platforms to be able to launch processes. The first part of this move is the platform soon will become the entity that launches your program and when it does, it uses a new ProcessLaunchInfo class which encapsulates all process launching settings. This simplifies the internal APIs needed for launching. I want to slowly phase out process launching from the process classes, so for now we can still launch just as we used to, but eventually the platform is the object that should do the launching. Modified the Host::LaunchProcess in the MacOSX Host.mm to correctly be able to launch processes with all of the new eLaunchFlag settings. Modified any code that was manually launching processes to use the Host::LaunchProcess functions. Fixed an issue where lldb_private::Args had implicitly defined copy constructors that could do the wrong thing. This has now been fixed by adding an appropriate copy constructor and assignment operator. Make sure we don't add empty ModuleSP entries to a module list. Fixed the commpage module creation on MacOSX, but we still need to train the MacOSX dynamic loader to not get rid of it when it doesn't have an entry in the all image infos. Abstracted many more calls from in ProcessGDBRemote down into the GDBRemoteCommunicationClient subclass to make the classes cleaner and more efficient. Fixed the default iOS ARM register context to be correct and also added support for targets that don't support the qThreadStopInfo packet by selecting the current thread (only if needed) and then sending a stop reply packet. Debugserver can now start up with a --unix-socket (-u for short) and can then bind to port zero and send the port it bound to to a listening process on the other end. This allows the GDB remote platform to spawn new GDB server instances (debugserver) to allow platform debugging. llvm-svn: 129351
2011-04-12 13:54:46 +08:00
PlatformSP
CommandInterpreter::GetPlatform (bool prefer_target_platform)
{
PlatformSP platform_sp;
Converted the lldb_private::Process over to use the intrusive shared pointers. Changed the ExecutionContext over to use shared pointers for the target, process, thread and frame since these objects can easily go away at any time and any object that was holding onto an ExecutionContext was running the risk of using a bad object. Now that the shared pointers for target, process, thread and frame are just a single pointer (they all use the instrusive shared pointers) the execution context is much safer and still the same size. Made the shared pointers in the the ExecutionContext class protected and made accessors for all of the various ways to get at the pointers, references, and shared pointers. llvm-svn: 140298
2011-09-22 12:58:26 +08:00
if (prefer_target_platform)
{
<rdar://problem/11791234> Fixed a case where the python interpreter could end up holding onto a previous lldb::SBProcess (probably in lldb.process) when run under Xcode. Prior to this fix, the lldb::SBProcess held onto a shared pointer to a lldb_private::Process. This in turn could cause the process to still have a thread list with stack frames. The stack frames would have module shared pointers in the lldb_private::SymbolContext objects. We also had issues with things staying in the shared module list too long when we found things by UUID (we didn't remove the out of date ModuleSP from the global module cache). Now all of this is fixed and everything goes away between runs. llvm-svn: 160140
2012-07-13 04:32:19 +08:00
ExecutionContext exe_ctx(GetExecutionContext());
Target *target = exe_ctx.GetTargetPtr();
Converted the lldb_private::Process over to use the intrusive shared pointers. Changed the ExecutionContext over to use shared pointers for the target, process, thread and frame since these objects can easily go away at any time and any object that was holding onto an ExecutionContext was running the risk of using a bad object. Now that the shared pointers for target, process, thread and frame are just a single pointer (they all use the instrusive shared pointers) the execution context is much safer and still the same size. Made the shared pointers in the the ExecutionContext class protected and made accessors for all of the various ways to get at the pointers, references, and shared pointers. llvm-svn: 140298
2011-09-22 12:58:26 +08:00
if (target)
platform_sp = target->GetPlatform();
}
Moved the execution context that was in the Debugger into the CommandInterpreter where it was always being used. Make sure that Modules can track their object file offsets correctly to allow opening of sub object files (like the "__commpage" on darwin). Modified the Platforms to be able to launch processes. The first part of this move is the platform soon will become the entity that launches your program and when it does, it uses a new ProcessLaunchInfo class which encapsulates all process launching settings. This simplifies the internal APIs needed for launching. I want to slowly phase out process launching from the process classes, so for now we can still launch just as we used to, but eventually the platform is the object that should do the launching. Modified the Host::LaunchProcess in the MacOSX Host.mm to correctly be able to launch processes with all of the new eLaunchFlag settings. Modified any code that was manually launching processes to use the Host::LaunchProcess functions. Fixed an issue where lldb_private::Args had implicitly defined copy constructors that could do the wrong thing. This has now been fixed by adding an appropriate copy constructor and assignment operator. Make sure we don't add empty ModuleSP entries to a module list. Fixed the commpage module creation on MacOSX, but we still need to train the MacOSX dynamic loader to not get rid of it when it doesn't have an entry in the all image infos. Abstracted many more calls from in ProcessGDBRemote down into the GDBRemoteCommunicationClient subclass to make the classes cleaner and more efficient. Fixed the default iOS ARM register context to be correct and also added support for targets that don't support the qThreadStopInfo packet by selecting the current thread (only if needed) and then sending a stop reply packet. Debugserver can now start up with a --unix-socket (-u for short) and can then bind to port zero and send the port it bound to to a listening process on the other end. This allows the GDB remote platform to spawn new GDB server instances (debugserver) to allow platform debugging. llvm-svn: 129351
2011-04-12 13:54:46 +08:00
if (!platform_sp)
platform_sp = m_debugger.GetPlatformList().GetSelectedPlatform();
return platform_sp;
}
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
void
CommandInterpreter::HandleCommands should take its commands as a "const StringList &" since it doesn't modify it... Also, don't turn on the immediate output in the temporary result, or you'll get doubled output. llvm-svn: 127452
2011-03-11 09:51:49 +08:00
CommandInterpreter::HandleCommands (const StringList &commands,
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
ExecutionContext *override_context,
CommandInterpreterRunOptions &options,
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
CommandReturnObject &result)
{
size_t num_lines = commands.GetSize();
// If we are going to continue past a "continue" then we need to run the commands synchronously.
// Make sure you reset this value anywhere you return from the function.
bool old_async_execution = m_debugger.GetAsyncExecution();
// If we've been given an execution context, set it at the start, but don't keep resetting it or we will
// cause series of commands that change the context, then do an operation that relies on that context to fail.
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (override_context != nullptr)
Moved the execution context that was in the Debugger into the CommandInterpreter where it was always being used. Make sure that Modules can track their object file offsets correctly to allow opening of sub object files (like the "__commpage" on darwin). Modified the Platforms to be able to launch processes. The first part of this move is the platform soon will become the entity that launches your program and when it does, it uses a new ProcessLaunchInfo class which encapsulates all process launching settings. This simplifies the internal APIs needed for launching. I want to slowly phase out process launching from the process classes, so for now we can still launch just as we used to, but eventually the platform is the object that should do the launching. Modified the Host::LaunchProcess in the MacOSX Host.mm to correctly be able to launch processes with all of the new eLaunchFlag settings. Modified any code that was manually launching processes to use the Host::LaunchProcess functions. Fixed an issue where lldb_private::Args had implicitly defined copy constructors that could do the wrong thing. This has now been fixed by adding an appropriate copy constructor and assignment operator. Make sure we don't add empty ModuleSP entries to a module list. Fixed the commpage module creation on MacOSX, but we still need to train the MacOSX dynamic loader to not get rid of it when it doesn't have an entry in the all image infos. Abstracted many more calls from in ProcessGDBRemote down into the GDBRemoteCommunicationClient subclass to make the classes cleaner and more efficient. Fixed the default iOS ARM register context to be correct and also added support for targets that don't support the qThreadStopInfo packet by selecting the current thread (only if needed) and then sending a stop reply packet. Debugserver can now start up with a --unix-socket (-u for short) and can then bind to port zero and send the port it bound to to a listening process on the other end. This allows the GDB remote platform to spawn new GDB server instances (debugserver) to allow platform debugging. llvm-svn: 129351
2011-04-12 13:54:46 +08:00
UpdateExecutionContext (override_context);
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (!options.GetStopOnContinue())
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
{
m_debugger.SetAsyncExecution (false);
}
Sort out a number of mismatched integer types in order to cut down the number of compiler warnings. llvm-svn: 184333
2013-06-20 03:04:53 +08:00
for (size_t idx = 0; idx < num_lines; idx++)
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
{
const char *cmd = commands.GetStringAtIndex(idx);
if (cmd[0] == '\0')
continue;
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (options.GetEchoCommands())
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
{
result.AppendMessageWithFormat ("%s %s\n",
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
m_debugger.GetPrompt(),
cmd);
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
}
Don't limit StreamTee to just two streams. It now can contain N streams by making the stream a vector of stream shared pointers that is protected by a mutex. Streams can be get/set by index which allows indexes to be defined as stream indentifiers. If a stream is set at index 3 and there are now streams in the collection, then empty stream objects are inserted to ensure that stream at index 3 has a valid stream. There is also an append method that allows a stream to be pushed onto the stack. This will allow our streams to be very flexible in where the output goes. Modified the CommandReturnObject to use the new StreamTee functionality. This class now defines two StreamTee indexes: 0 for the stream string stream, and 1 for the immediate stream. This is used both on the output and error streams. Added the ability to get argument types as strings or as descriptions. This is exported through the SBCommandInterpreter API to allow external access. Modified the Driver class to use the newly exported argument names from SBCommandInterpreter::GetArgumentTypeAsCString(). llvm-svn: 126067
2011-02-20 10:15:07 +08:00
CommandReturnObject tmp_result;
Fix a problem where the stop-hook command 'frame variable g_val' produces nothing when newly created threads were subsequently stopped due to breakpoint hit. The stop-hook mechanism delegates to CommandInterpreter::HandleCommands() to execuet the commands. Make sure the execution context is switched only once at the beginning of HandleCommands() only and don't update the context while looping on each individual command to be executed. rdar://problem/10228156 llvm-svn: 141144
2011-10-05 08:42:59 +08:00
// If override_context is not NULL, pass no_context_switching = true for
// HandleCommand() since we updated our context already.
If HandleCommands is called with add_to_history set to false, turn on the m_command_source_depth so that when we forget the value for regex & alias commands it still stays off. <rdar://problem/13795202> llvm-svn: 180971
2013-05-03 07:15:37 +08:00
// We might call into a regex or alias command, in which case the add_to_history will get lost. This
// m_command_source_depth dingus is the way we turn off adding to the history in that case, so set it up here.
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (!options.GetAddToHistory())
If HandleCommands is called with add_to_history set to false, turn on the m_command_source_depth so that when we forget the value for regex & alias commands it still stays off. <rdar://problem/13795202> llvm-svn: 180971
2013-05-03 07:15:37 +08:00
m_command_source_depth++;
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
bool success = HandleCommand(cmd, options.m_add_to_history, tmp_result,
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
nullptr, /* override_context */
Fix a problem where the stop-hook command 'frame variable g_val' produces nothing when newly created threads were subsequently stopped due to breakpoint hit. The stop-hook mechanism delegates to CommandInterpreter::HandleCommands() to execuet the commands. Make sure the execution context is switched only once at the beginning of HandleCommands() only and don't update the context while looping on each individual command to be executed. rdar://problem/10228156 llvm-svn: 141144
2011-10-05 08:42:59 +08:00
true, /* repeat_on_empty_command */
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
override_context != nullptr /* no_context_switching */);
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (!options.GetAddToHistory())
If HandleCommands is called with add_to_history set to false, turn on the m_command_source_depth so that when we forget the value for regex & alias commands it still stays off. <rdar://problem/13795202> llvm-svn: 180971
2013-05-03 07:15:37 +08:00
m_command_source_depth--;
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (options.GetPrintResults())
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
{
if (tmp_result.Succeeded())
- Changed all the places where CommandObjectReturn was exporting a StreamString to just exporting a Stream, and then added GetOutputData & GetErrorData to get the accumulated data. - Added a StreamTee that will tee output to two provided lldb::StreamSP's. - Made the CommandObjectReturn use this so you can Tee the results immediately to the debuggers output file, as well as saving up the results to return when the command is done executing. - HandleCommands now uses this so that if you have a set of commands that continue the target you will see the commands come out as they are processed. - The Driver now uses this to output the command results as you go, which makes the interface more reactive seeming. llvm-svn: 126015
2011-02-19 10:53:09 +08:00
result.AppendMessageWithFormat("%s", tmp_result.GetOutputData());
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
}
if (!success || !tmp_result.Succeeded())
{
Report the command error when we are in "stop on error mode." llvm-svn: 155422
2012-04-24 10:25:07 +08:00
const char *error_msg = tmp_result.GetErrorData();
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (error_msg == nullptr || error_msg[0] == '\0')
Report the command error when we are in "stop on error mode." llvm-svn: 155422
2012-04-24 10:25:07 +08:00
error_msg = "<unknown error>.\n";
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (options.GetStopOnError())
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
{
Fix Windows build using portable types for formatting the log outputs llvm-svn: 202723
2014-03-03 23:39:47 +08:00
result.AppendErrorWithFormat("Aborting reading of commands after command #%" PRIu64 ": '%s' failed with %s",
(uint64_t)idx, cmd, error_msg);
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
result.SetStatus (eReturnStatusFailed);
m_debugger.SetAsyncExecution (old_async_execution);
return;
}
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
else if (options.GetPrintResults())
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
{
Fix Windows build using portable types for formatting the log outputs llvm-svn: 202723
2014-03-03 23:39:47 +08:00
result.AppendMessageWithFormat ("Command #%" PRIu64 " '%s' failed with %s",
(uint64_t)idx + 1,
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
cmd,
Report the command error when we are in "stop on error mode." llvm-svn: 155422
2012-04-24 10:25:07 +08:00
error_msg);
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
}
}
This patch captures and serializes all output being written by the command line driver, including the lldb prompt being output by editline, the asynchronous process output & error messages, and asynchronous messages written by target stop-hooks. As part of this it introduces a new Stream class, StreamAsynchronousIO. A StreamAsynchronousIO object is created with a broadcaster, who will eventually broadcast the stream's data for a listener to handle, and an event type indicating what type of event the broadcaster will broadcast. When the Write method is called on a StreamAsynchronousIO object, the data is appended to an internal string. When the Flush method is called on a StreamAsynchronousIO object, it broadcasts it's data string and clears the string. Anything in lldb-core that needs to generate asynchronous output for the end-user should use the StreamAsynchronousIO objects. I have also added a new notification type for InputReaders, to let them know that a asynchronous output has been written. This is to allow the input readers to, for example, refresh their prompts and lines, if desired. I added the case statements to all the input readers to catch this notification, but I haven't added any code for handling them yet (except to the IOChannel input reader). llvm-svn: 130721
2011-05-03 04:41:46 +08:00
if (result.GetImmediateOutputStream())
result.GetImmediateOutputStream()->Flush();
if (result.GetImmediateErrorStream())
result.GetImmediateErrorStream()->Flush();
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
// N.B. Can't depend on DidChangeProcessState, because the state coming into the command execution
// could be running (for instance in Breakpoint Commands.
// So we check the return value to see if it is has running in it.
if ((tmp_result.GetStatus() == eReturnStatusSuccessContinuingNoResult)
|| (tmp_result.GetStatus() == eReturnStatusSuccessContinuingResult))
{
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (options.GetStopOnContinue())
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
{
// If we caused the target to proceed, and we're going to stop in that case, set the
// status in our real result before returning. This is an error if the continue was not the
// last command in the set of commands to be run.
if (idx != num_lines - 1)
Fix Windows build using portable types for formatting the log outputs llvm-svn: 202723
2014-03-03 23:39:47 +08:00
result.AppendErrorWithFormat("Aborting reading of commands after command #%" PRIu64 ": '%s' continued the target.\n",
(uint64_t)idx + 1, cmd);
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
else
Fix Windows build using portable types for formatting the log outputs llvm-svn: 202723
2014-03-03 23:39:47 +08:00
result.AppendMessageWithFormat("Command #%" PRIu64 " '%s' continued the target.\n", (uint64_t)idx + 1, cmd);
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
result.SetStatus(tmp_result.GetStatus());
m_debugger.SetAsyncExecution (old_async_execution);
return;
}
}
This adds a "batch mode" to lldb kinda like the gdb batch mode. It will quit the debugger after all the commands have been executed except if one of the commands was an execution control command that stopped because of a signal or exception. Also adds a variant of SBCommandInterpreter::HandleCommand that takes an SBExecutionContext. That way you can run an lldb command targeted at a particular target, thread or process w/o having to select same before running the command. Also exposes CommandInterpreter::HandleCommandsFromFile to the SBCommandInterpreter API, since that seemed generally useful. llvm-svn: 219654
2014-10-14 09:20:07 +08:00
// Also check for "stop on crash here:
bool should_stop = false;
if (tmp_result.GetDidChangeProcessState() && options.GetStopOnCrash())
{
TargetSP target_sp (m_debugger.GetTargetList().GetSelectedTarget());
if (target_sp)
{
ProcessSP process_sp (target_sp->GetProcessSP());
if (process_sp)
{
for (ThreadSP thread_sp : process_sp->GetThreadList().Threads())
{
StopReason reason = thread_sp->GetStopReason();
if (reason == eStopReasonSignal || reason == eStopReasonException || reason == eStopReasonInstrumentation)
{
should_stop = true;
break;
}
}
}
}
if (should_stop)
{
if (idx != num_lines - 1)
result.AppendErrorWithFormat("Aborting reading of commands after command #%" PRIu64 ": '%s' stopped with a signal or exception.\n",
(uint64_t)idx + 1, cmd);
else
result.AppendMessageWithFormat("Command #%" PRIu64 " '%s' stopped with a signal or exception.\n", (uint64_t)idx + 1, cmd);
result.SetStatus(tmp_result.GetStatus());
m_debugger.SetAsyncExecution (old_async_execution);
return;
}
}
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
}
result.SetStatus (eReturnStatusSuccessFinishResult);
m_debugger.SetAsyncExecution (old_async_execution);
return;
}
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
// Make flags that we can pass into the IOHandler so our delegates can do the right thing
enum {
eHandleCommandFlagStopOnContinue = (1u << 0),
eHandleCommandFlagStopOnError = (1u << 1),
eHandleCommandFlagEchoCommand = (1u << 2),
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
eHandleCommandFlagPrintResult = (1u << 3),
eHandleCommandFlagStopOnCrash = (1u << 4)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
};
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
void
CommandInterpreter::HandleCommandsFromFile (FileSpec &cmd_file,
ExecutionContext *context,
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
CommandInterpreterRunOptions &options,
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
CommandReturnObject &result)
{
if (cmd_file.Exists())
{
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
StreamFileSP input_file_sp (new StreamFile());
std::string cmd_file_path = cmd_file.GetPath();
Error error = input_file_sp->GetFile().Open(cmd_file_path.c_str(), File::eOpenOptionRead);
if (error.Success())
{
Debugger &debugger = GetDebugger();
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
uint32_t flags = 0;
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (options.m_stop_on_continue == eLazyBoolCalculate)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
if (m_command_source_flags.empty())
{
Fixed output to display correctly for "command source" by fixing the correct flags being set. Also emit the "Executing commands" message so it properly only comes out when desired and so it comes out in the right place. <rdar://problem/15992208> llvm-svn: 200875
2014-02-06 05:03:22 +08:00
// Stop on continue by default
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
flags |= eHandleCommandFlagStopOnContinue;
}
else if (m_command_source_flags.back() & eHandleCommandFlagStopOnContinue)
{
flags |= eHandleCommandFlagStopOnContinue;
}
}
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
else if (options.m_stop_on_continue == eLazyBoolYes)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
flags |= eHandleCommandFlagStopOnContinue;
}
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (options.m_stop_on_error == eLazyBoolCalculate)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
if (m_command_source_flags.empty())
{
if (GetStopCmdSourceOnError())
flags |= eHandleCommandFlagStopOnError;
}
else if (m_command_source_flags.back() & eHandleCommandFlagStopOnError)
{
flags |= eHandleCommandFlagStopOnError;
}
}
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
else if (options.m_stop_on_error == eLazyBoolYes)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
flags |= eHandleCommandFlagStopOnError;
}
This adds a "batch mode" to lldb kinda like the gdb batch mode. It will quit the debugger after all the commands have been executed except if one of the commands was an execution control command that stopped because of a signal or exception. Also adds a variant of SBCommandInterpreter::HandleCommand that takes an SBExecutionContext. That way you can run an lldb command targeted at a particular target, thread or process w/o having to select same before running the command. Also exposes CommandInterpreter::HandleCommandsFromFile to the SBCommandInterpreter API, since that seemed generally useful. llvm-svn: 219654
2014-10-14 09:20:07 +08:00
if (options.GetStopOnCrash())
{
if (m_command_source_flags.empty())
{
// Echo command by default
flags |= eHandleCommandFlagStopOnCrash;
}
else if (m_command_source_flags.back() & eHandleCommandFlagStopOnCrash)
{
flags |= eHandleCommandFlagStopOnCrash;
}
}
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (options.m_echo_commands == eLazyBoolCalculate)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
if (m_command_source_flags.empty())
{
// Echo command by default
flags |= eHandleCommandFlagEchoCommand;
}
else if (m_command_source_flags.back() & eHandleCommandFlagEchoCommand)
{
flags |= eHandleCommandFlagEchoCommand;
}
}
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
else if (options.m_echo_commands == eLazyBoolYes)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
flags |= eHandleCommandFlagEchoCommand;
}
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
if (options.m_print_results == eLazyBoolCalculate)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
if (m_command_source_flags.empty())
{
Fixed output to display correctly for "command source" by fixing the correct flags being set. Also emit the "Executing commands" message so it properly only comes out when desired and so it comes out in the right place. <rdar://problem/15992208> llvm-svn: 200875
2014-02-06 05:03:22 +08:00
// Print output by default
flags |= eHandleCommandFlagPrintResult;
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
}
Fixed output to display correctly for "command source" by fixing the correct flags being set. Also emit the "Executing commands" message so it properly only comes out when desired and so it comes out in the right place. <rdar://problem/15992208> llvm-svn: 200875
2014-02-06 05:03:22 +08:00
else if (m_command_source_flags.back() & eHandleCommandFlagPrintResult)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
Fixed output to display correctly for "command source" by fixing the correct flags being set. Also emit the "Executing commands" message so it properly only comes out when desired and so it comes out in the right place. <rdar://problem/15992208> llvm-svn: 200875
2014-02-06 05:03:22 +08:00
flags |= eHandleCommandFlagPrintResult;
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
}
}
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
else if (options.m_print_results == eLazyBoolYes)
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
{
Fixed output to display correctly for "command source" by fixing the correct flags being set. Also emit the "Executing commands" message so it properly only comes out when desired and so it comes out in the right place. <rdar://problem/15992208> llvm-svn: 200875
2014-02-06 05:03:22 +08:00
flags |= eHandleCommandFlagPrintResult;
}
if (flags & eHandleCommandFlagPrintResult)
{
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
debugger.GetOutputFile()->Printf("Executing commands in '%s'.\n", cmd_file_path.c_str());
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
}
// Used for inheriting the right settings when "command source" might have
// nested "command source" commands
Fixed output to display correctly for "command source" by fixing the correct flags being set. Also emit the "Executing commands" message so it properly only comes out when desired and so it comes out in the right place. <rdar://problem/15992208> llvm-svn: 200875
2014-02-06 05:03:22 +08:00
lldb::StreamFileSP empty_stream_sp;
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
m_command_source_flags.push_back(flags);
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger,
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
IOHandler::Type::CommandInterpreter,
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
input_file_sp,
Fixed output to display correctly for "command source" by fixing the correct flags being set. Also emit the "Executing commands" message so it properly only comes out when desired and so it comes out in the right place. <rdar://problem/15992208> llvm-svn: 200875
2014-02-06 05:03:22 +08:00
empty_stream_sp, // Pass in an empty stream so we inherit the top input reader output stream
empty_stream_sp, // Pass in an empty stream so we inherit the top input reader error stream
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
flags,
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
nullptr, // Pass in NULL for "editline_name" so no history is saved, or written
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
debugger.GetPrompt(),
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
NULL,
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
false, // Not multi-line
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
debugger.GetUseColor(),
Allow line numbers to be shown in multi-line expressions. llvm-svn: 203185
2014-03-07 08:53:24 +08:00
0,
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
*this));
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
const bool old_async_execution = debugger.GetAsyncExecution();
This adds a "batch mode" to lldb kinda like the gdb batch mode. It will quit the debugger after all the commands have been executed except if one of the commands was an execution control command that stopped because of a signal or exception. Also adds a variant of SBCommandInterpreter::HandleCommand that takes an SBExecutionContext. That way you can run an lldb command targeted at a particular target, thread or process w/o having to select same before running the command. Also exposes CommandInterpreter::HandleCommandsFromFile to the SBCommandInterpreter API, since that seemed generally useful. llvm-svn: 219654
2014-10-14 09:20:07 +08:00
// Set synchronous execution if we are not stopping on continue
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
if ((flags & eHandleCommandFlagStopOnContinue) == 0)
debugger.SetAsyncExecution (false);
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
m_command_source_depth++;
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
debugger.RunIOHandler(io_handler_sp);
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
if (!m_command_source_flags.empty())
m_command_source_flags.pop_back();
m_command_source_depth--;
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
result.SetStatus (eReturnStatusSuccessFinishNoResult);
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
debugger.SetAsyncExecution (old_async_execution);
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
}
else
{
result.AppendErrorWithFormat ("error: an error occurred read file '%s': %s\n", cmd_file_path.c_str(), error.AsCString());
result.SetStatus (eReturnStatusFailed);
}
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
}
else
{
result.AppendErrorWithFormat ("Error reading commands from file %s - file not found.\n",
Audit uses of ConstString::AsCString() to make sure they weren't assuming they would always get a non-NULL string back. <rdar://problem/19298575> llvm-svn: 224602
2014-12-20 03:20:44 +08:00
cmd_file.GetFilename().AsCString("<Unknown>"));
Factor all the code that does "Execute a list of lldb command interpreter commands" into a single function in the Interpreter, and then use that in all the places that used to do this by hand. llvm-svn: 125807
2011-02-18 08:54:25 +08:00
result.SetStatus (eReturnStatusFailed);
return;
}
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
ScriptInterpreter *
Convert the ScriptInterpreter system to a plugin-based one. Previously embedded interpreters were handled as ad-hoc source files compiled into source/Interpreter. This made it hard to disable a specific interpreter, or to add support for other interpreters and allow the developer to choose which interpreter(s) were enabled for a particular build. This patch converts script interpreters over to a plugin-based system. Script interpreters now live in source/Plugins/ScriptInterpreter, and the canonical LLDB interpreter, ScriptInterpreterPython, is moved there as well. Any new code interfacing with the Python C API must live in this location from here on out. Additionally, generic code should never need to reference or make assumptions about the presence of a specific interpreter going forward. Differential Revision: http://reviews.llvm.org/D11431 Reviewed By: Greg Clayton llvm-svn: 243681
2015-07-31 04:28:07 +08:00
CommandInterpreter::GetScriptInterpreter(bool can_create)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Convert the ScriptInterpreter system to a plugin-based one. Previously embedded interpreters were handled as ad-hoc source files compiled into source/Interpreter. This made it hard to disable a specific interpreter, or to add support for other interpreters and allow the developer to choose which interpreter(s) were enabled for a particular build. This patch converts script interpreters over to a plugin-based system. Script interpreters now live in source/Plugins/ScriptInterpreter, and the canonical LLDB interpreter, ScriptInterpreterPython, is moved there as well. Any new code interfacing with the Python C API must live in this location from here on out. Additionally, generic code should never need to reference or make assumptions about the presence of a specific interpreter going forward. Differential Revision: http://reviews.llvm.org/D11431 Reviewed By: Greg Clayton llvm-svn: 243681
2015-07-31 04:28:07 +08:00
if (m_script_interpreter_sp)
return m_script_interpreter_sp.get();
<rdar://problem/11449953> Change Debugger::SetOutputFileHandle() so that it does not automatically initialize the script interpreter in order to transfer its output file handle to it This should delay initialization of Python until strictly necessary and speed-up debugger startup Also, convert formatters for SEL and BOOL ObjC data-types from Python to C++, in order to reap more performance benefits from the above changes llvm-svn: 166967
2012-10-30 05:18:03 +08:00
if (!can_create)
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
return nullptr;
Convert the ScriptInterpreter system to a plugin-based one. Previously embedded interpreters were handled as ad-hoc source files compiled into source/Interpreter. This made it hard to disable a specific interpreter, or to add support for other interpreters and allow the developer to choose which interpreter(s) were enabled for a particular build. This patch converts script interpreters over to a plugin-based system. Script interpreters now live in source/Plugins/ScriptInterpreter, and the canonical LLDB interpreter, ScriptInterpreterPython, is moved there as well. Any new code interfacing with the Python C API must live in this location from here on out. Additionally, generic code should never need to reference or make assumptions about the presence of a specific interpreter going forward. Differential Revision: http://reviews.llvm.org/D11431 Reviewed By: Greg Clayton llvm-svn: 243681
2015-07-31 04:28:07 +08:00
Split up the Python script interpreter code to allow multiple script interpreter objects to exist within the same process (one script interpreter object per debugger object). The python script interpreter objects are all using the same global Python script interpreter; they use separate dictionaries to keep their data separate, and mutex's to prevent any object attempting to use the global Python interpreter when another object is already using it. llvm-svn: 123415
2011-01-14 08:29:16 +08:00
lldb::ScriptLanguage script_lang = GetDebugger().GetScriptLanguage();
Convert the ScriptInterpreter system to a plugin-based one. Previously embedded interpreters were handled as ad-hoc source files compiled into source/Interpreter. This made it hard to disable a specific interpreter, or to add support for other interpreters and allow the developer to choose which interpreter(s) were enabled for a particular build. This patch converts script interpreters over to a plugin-based system. Script interpreters now live in source/Plugins/ScriptInterpreter, and the canonical LLDB interpreter, ScriptInterpreterPython, is moved there as well. Any new code interfacing with the Python C API must live in this location from here on out. Additionally, generic code should never need to reference or make assumptions about the presence of a specific interpreter going forward. Differential Revision: http://reviews.llvm.org/D11431 Reviewed By: Greg Clayton llvm-svn: 243681
2015-07-31 04:28:07 +08:00
m_script_interpreter_sp = PluginManager::GetScriptInterpreterForLanguage(script_lang, *this);
return m_script_interpreter_sp.get();
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
bool
CommandInterpreter::GetSynchronous ()
{
return m_synchronous_execution;
}
void
CommandInterpreter::SetSynchronous (bool value)
{
Add an initial version of test that exercise the lldb commands: 'process signal' and 'process handle'. The test suite would like to control the asynch/sync execution of the interpreter during the middle of the test method, so the CommandInterpreter::SetSynchronous(bool value) is modified to allow the mode to be changed more than once. In practice, it would be advisable to control the process and to set the async/sync mode from a single thread, too. llvm-svn: 116467
2010-10-14 09:22:03 +08:00
m_synchronous_execution = value;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
void
CommandInterpreter::OutputFormattedHelpText (Stream &strm,
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
const char *prefix,
const char *help_text)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Fixed the way set/show variables were being accessed to being natively accessed by the objects that own the settings. The previous approach wasn't very usable and made for a lot of unnecessary code just to access variables that were already owned by the objects. While I fixed those things, I saw that CommandObject objects should really have a reference to their command interpreter so they can access the terminal with if they want to output usaage. Fixed up all CommandObjects to take an interpreter and cleaned up the API to not need the interpreter to be passed in. Fixed the disassemble command to output the usage if no options are passed down and arguments are passed (all disassebmle variants take options, there are no "args only"). llvm-svn: 114252
2010-09-18 09:14:36 +08:00
const uint32_t max_columns = m_debugger.GetTerminalWidth();
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
if (prefix == NULL)
prefix = "";
size_t prefix_width = strlen(prefix);
size_t line_width_max = max_columns - prefix_width;
const char *help_text_end = help_text + strlen(help_text);
const char *line_start = help_text;
if (line_width_max < 16)
line_width_max = help_text_end - help_text + prefix_width;
strm.IndentMore (prefix_width);
while (line_start < help_text_end)
{
// Break each line at the first newline or last space/tab before
// the maximum number of characters that fit on a line. Lines with no
// natural break are left unbroken to wrap.
const char *line_end = help_text_end;
const char *line_scan = line_start;
const char *line_scan_end = help_text_end;
while (line_scan < line_scan_end)
{
char next = *line_scan;
if (next == '\t' || next == ' ')
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
line_end = line_scan;
line_scan_end = line_start + line_width_max;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
else if (next == '\n' || next == '\0')
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
line_end = line_scan;
break;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
++line_scan;
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Three related changes to help: The default help display now shows the alias collection by default, and hides commands whose named begin with an underscore. Help is primarily useful to those unfamiliar with LLDB and should aim to answer typical questions while still being able to provide more esoteric answers when required. To that latter end an argument to include the hidden commands in help has been added, and instead of having a help flag to show aliases there is now one to hide them. This final change might be controversial as it repurposes the -a shorthand as the opposite of its original meaning. The previous implementation of OutputFormattedHelpText was easily confused by embedded newlines. The new algorithm correctly breaks on the FIRST newline or LAST space/tab before the target column count rather than treating all whitespace interchangeably. Command interpreters now have the ability to specify help prologue text and a command prefix string. Neither are used in the current LLDB sources but are required to support REPL-like extensions where LLDB commands must be prefixed and additional help text is required to explain how to access traditional debugging commands. <rdar://problem/17751929> <rdar://problem/16953815> <rdar://problem/16953841> <rdar://problem/16930173> <rdar://problem/16879028> llvm-svn: 226068
2015-01-15 08:52:41 +08:00
// Prefix the first line, indent subsequent lines to line up
if (line_start == help_text)
strm.Write (prefix, prefix_width);
else
strm.Indent();
strm.Write (line_start, line_end - line_start);
strm.EOL();
// When a line breaks at whitespace consume it before continuing
line_start = line_end;
char next = *line_start;
if (next == '\n')
++line_start;
else while (next == ' ' || next == '\t')
next = *(++line_start);
}
strm.IndentLess (prefix_width);
}
void
CommandInterpreter::OutputFormattedHelpText (Stream &strm,
const char *word_text,
const char *separator,
const char *help_text,
size_t max_word_len)
{
StreamString prefix_stream;
prefix_stream.Printf (" %-*s %s ", (int)max_word_len, word_text, separator);
OutputFormattedHelpText (strm, prefix_stream.GetData(), help_text);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
new detailed descriptions for type summary add and type format add some changes to the help system code for better display of long help text -p and -r flags now also work for type format add llvm-svn: 134574
2011-07-07 08:38:40 +08:00
void
CommandInterpreter::OutputHelpText (Stream &strm,
const char *word_text,
const char *separator,
const char *help_text,
uint32_t max_word_len)
{
int indent_size = max_word_len + strlen (separator) + 2;
strm.IndentMore (indent_size);
StreamString text_strm;
text_strm.Printf ("%-*s %s %s", max_word_len, word_text, separator, help_text);
const uint32_t max_columns = m_debugger.GetTerminalWidth();
size_t len = text_strm.GetSize();
const char *text = text_strm.GetData();
uint32_t chars_left = max_columns;
for (uint32_t i = 0; i < len; i++)
{
if ((text[i] == ' ' && ::strchr((text+i+1), ' ') && chars_left < ::strchr((text+i+1), ' ')-(text+i)) || text[i] == '\n')
{
chars_left = max_columns - indent_size;
strm.EOL();
strm.Indent();
}
else
{
strm.PutChar(text[i]);
chars_left--;
}
}
strm.EOL();
strm.IndentLess(indent_size);
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
void
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
CommandInterpreter::FindCommandsForApropos (const char *search_word,
StringList &commands_found,
StringList &commands_help,
CommandObject::CommandMap &command_map)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
CommandObject::CommandMap::const_iterator pos;
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
for (pos = command_map.begin(); pos != command_map.end(); ++pos)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
const char *command_name = pos->first.c_str();
CommandObject *cmd_obj = pos->second.get();
const bool search_short_help = true;
const bool search_long_help = false;
const bool search_syntax = false;
const bool search_options = false;
if (strcasestr(command_name, search_word) ||
cmd_obj->HelpTextContainsWord (search_word,
search_short_help,
search_long_help,
search_syntax,
search_options))
{
Fix an issue where the apropos command would not print fully qualified command names for nested command objects rdar://problem/26020072 llvm-svn: 268309
2016-05-03 05:28:40 +08:00
commands_found.AppendString (cmd_obj->GetCommandName());
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
commands_help.AppendString (cmd_obj->GetHelp());
}
if (cmd_obj->IsMultiwordObject())
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
Fix a bug where LLDB would crash if 'apropos <anything>' was used after spawning an inferior process llvm-svn: 266911
2016-04-21 04:48:05 +08:00
CommandObjectMultiword *cmd_multiword = cmd_obj->GetAsMultiwordCommand();
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
FindCommandsForApropos(search_word,
commands_found,
commands_help,
cmd_multiword->GetSubcommandDictionary());
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Apropos should search user commands as well as built-in commands. rdar://problem/13916722 llvm-svn: 182068
2013-05-17 09:30:37 +08:00
}
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
}
void
CommandInterpreter::FindCommandsForApropos (const char *search_word,
StringList &commands_found,
StringList &commands_help,
bool search_builtin_commands,
bool search_user_commands,
bool search_alias_commands)
{
CommandObject::CommandMap::const_iterator pos;
if (search_builtin_commands)
FindCommandsForApropos(search_word, commands_found, commands_help, m_command_dict);
Apropos should search user commands as well as built-in commands. rdar://problem/13916722 llvm-svn: 182068
2013-05-17 09:30:37 +08:00
if (search_user_commands)
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
FindCommandsForApropos(search_word, commands_found, commands_help, m_user_dict);
Apropos should search user commands as well as built-in commands. rdar://problem/13916722 llvm-svn: 182068
2013-05-17 09:30:37 +08:00
Change 'apropos' such that it doesn't look into the "long help/syntax" strings for commands This solves issues such as 'apropos foo' returning valid matches just because syntax examples happen to use 'foo' as a placeholder token Fixes rdar://9043025 llvm-svn: 264123
2016-03-23 09:21:55 +08:00
if (search_alias_commands)
FindCommandsForApropos(search_word, commands_found, commands_help, m_alias_dict);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
}
Moved the execution context that was in the Debugger into the CommandInterpreter where it was always being used. Make sure that Modules can track their object file offsets correctly to allow opening of sub object files (like the "__commpage" on darwin). Modified the Platforms to be able to launch processes. The first part of this move is the platform soon will become the entity that launches your program and when it does, it uses a new ProcessLaunchInfo class which encapsulates all process launching settings. This simplifies the internal APIs needed for launching. I want to slowly phase out process launching from the process classes, so for now we can still launch just as we used to, but eventually the platform is the object that should do the launching. Modified the Host::LaunchProcess in the MacOSX Host.mm to correctly be able to launch processes with all of the new eLaunchFlag settings. Modified any code that was manually launching processes to use the Host::LaunchProcess functions. Fixed an issue where lldb_private::Args had implicitly defined copy constructors that could do the wrong thing. This has now been fixed by adding an appropriate copy constructor and assignment operator. Make sure we don't add empty ModuleSP entries to a module list. Fixed the commpage module creation on MacOSX, but we still need to train the MacOSX dynamic loader to not get rid of it when it doesn't have an entry in the all image infos. Abstracted many more calls from in ProcessGDBRemote down into the GDBRemoteCommunicationClient subclass to make the classes cleaner and more efficient. Fixed the default iOS ARM register context to be correct and also added support for targets that don't support the qThreadStopInfo packet by selecting the current thread (only if needed) and then sending a stop reply packet. Debugserver can now start up with a --unix-socket (-u for short) and can then bind to port zero and send the port it bound to to a listening process on the other end. This allows the GDB remote platform to spawn new GDB server instances (debugserver) to allow platform debugging. llvm-svn: 129351
2011-04-12 13:54:46 +08:00
void
CommandInterpreter::UpdateExecutionContext (ExecutionContext *override_context)
{
Switch NULL to C++11 nullptr in source/Interpreter Patch by Robert Matusewicz llvm-svn: 206711
2014-04-20 08:31:37 +08:00
if (override_context != nullptr)
Moved the execution context that was in the Debugger into the CommandInterpreter where it was always being used. Make sure that Modules can track their object file offsets correctly to allow opening of sub object files (like the "__commpage" on darwin). Modified the Platforms to be able to launch processes. The first part of this move is the platform soon will become the entity that launches your program and when it does, it uses a new ProcessLaunchInfo class which encapsulates all process launching settings. This simplifies the internal APIs needed for launching. I want to slowly phase out process launching from the process classes, so for now we can still launch just as we used to, but eventually the platform is the object that should do the launching. Modified the Host::LaunchProcess in the MacOSX Host.mm to correctly be able to launch processes with all of the new eLaunchFlag settings. Modified any code that was manually launching processes to use the Host::LaunchProcess functions. Fixed an issue where lldb_private::Args had implicitly defined copy constructors that could do the wrong thing. This has now been fixed by adding an appropriate copy constructor and assignment operator. Make sure we don't add empty ModuleSP entries to a module list. Fixed the commpage module creation on MacOSX, but we still need to train the MacOSX dynamic loader to not get rid of it when it doesn't have an entry in the all image infos. Abstracted many more calls from in ProcessGDBRemote down into the GDBRemoteCommunicationClient subclass to make the classes cleaner and more efficient. Fixed the default iOS ARM register context to be correct and also added support for targets that don't support the qThreadStopInfo packet by selecting the current thread (only if needed) and then sending a stop reply packet. Debugserver can now start up with a --unix-socket (-u for short) and can then bind to port zero and send the port it bound to to a listening process on the other end. This allows the GDB remote platform to spawn new GDB server instances (debugserver) to allow platform debugging. llvm-svn: 129351
2011-04-12 13:54:46 +08:00
{
<rdar://problem/11791234> Fixed a case where the python interpreter could end up holding onto a previous lldb::SBProcess (probably in lldb.process) when run under Xcode. Prior to this fix, the lldb::SBProcess held onto a shared pointer to a lldb_private::Process. This in turn could cause the process to still have a thread list with stack frames. The stack frames would have module shared pointers in the lldb_private::SymbolContext objects. We also had issues with things staying in the shared module list too long when we found things by UUID (we didn't remove the out of date ModuleSP from the global module cache). Now all of this is fixed and everything goes away between runs. llvm-svn: 160140
2012-07-13 04:32:19 +08:00
m_exe_ctx_ref = *override_context;
Moved the execution context that was in the Debugger into the CommandInterpreter where it was always being used. Make sure that Modules can track their object file offsets correctly to allow opening of sub object files (like the "__commpage" on darwin). Modified the Platforms to be able to launch processes. The first part of this move is the platform soon will become the entity that launches your program and when it does, it uses a new ProcessLaunchInfo class which encapsulates all process launching settings. This simplifies the internal APIs needed for launching. I want to slowly phase out process launching from the process classes, so for now we can still launch just as we used to, but eventually the platform is the object that should do the launching. Modified the Host::LaunchProcess in the MacOSX Host.mm to correctly be able to launch processes with all of the new eLaunchFlag settings. Modified any code that was manually launching processes to use the Host::LaunchProcess functions. Fixed an issue where lldb_private::Args had implicitly defined copy constructors that could do the wrong thing. This has now been fixed by adding an appropriate copy constructor and assignment operator. Make sure we don't add empty ModuleSP entries to a module list. Fixed the commpage module creation on MacOSX, but we still need to train the MacOSX dynamic loader to not get rid of it when it doesn't have an entry in the all image infos. Abstracted many more calls from in ProcessGDBRemote down into the GDBRemoteCommunicationClient subclass to make the classes cleaner and more efficient. Fixed the default iOS ARM register context to be correct and also added support for targets that don't support the qThreadStopInfo packet by selecting the current thread (only if needed) and then sending a stop reply packet. Debugserver can now start up with a --unix-socket (-u for short) and can then bind to port zero and send the port it bound to to a listening process on the other end. This allows the GDB remote platform to spawn new GDB server instances (debugserver) to allow platform debugging. llvm-svn: 129351
2011-04-12 13:54:46 +08:00
}
else
{
<rdar://problem/11791234> Fixed a case where the python interpreter could end up holding onto a previous lldb::SBProcess (probably in lldb.process) when run under Xcode. Prior to this fix, the lldb::SBProcess held onto a shared pointer to a lldb_private::Process. This in turn could cause the process to still have a thread list with stack frames. The stack frames would have module shared pointers in the lldb_private::SymbolContext objects. We also had issues with things staying in the shared module list too long when we found things by UUID (we didn't remove the out of date ModuleSP from the global module cache). Now all of this is fixed and everything goes away between runs. llvm-svn: 160140
2012-07-13 04:32:19 +08:00
const bool adopt_selected = true;
m_exe_ctx_ref.SetTargetPtr (m_debugger.GetSelectedTarget().get(), adopt_selected);
Moved the execution context that was in the Debugger into the CommandInterpreter where it was always being used. Make sure that Modules can track their object file offsets correctly to allow opening of sub object files (like the "__commpage" on darwin). Modified the Platforms to be able to launch processes. The first part of this move is the platform soon will become the entity that launches your program and when it does, it uses a new ProcessLaunchInfo class which encapsulates all process launching settings. This simplifies the internal APIs needed for launching. I want to slowly phase out process launching from the process classes, so for now we can still launch just as we used to, but eventually the platform is the object that should do the launching. Modified the Host::LaunchProcess in the MacOSX Host.mm to correctly be able to launch processes with all of the new eLaunchFlag settings. Modified any code that was manually launching processes to use the Host::LaunchProcess functions. Fixed an issue where lldb_private::Args had implicitly defined copy constructors that could do the wrong thing. This has now been fixed by adding an appropriate copy constructor and assignment operator. Make sure we don't add empty ModuleSP entries to a module list. Fixed the commpage module creation on MacOSX, but we still need to train the MacOSX dynamic loader to not get rid of it when it doesn't have an entry in the all image infos. Abstracted many more calls from in ProcessGDBRemote down into the GDBRemoteCommunicationClient subclass to make the classes cleaner and more efficient. Fixed the default iOS ARM register context to be correct and also added support for targets that don't support the qThreadStopInfo packet by selecting the current thread (only if needed) and then sending a stop reply packet. Debugserver can now start up with a --unix-socket (-u for short) and can then bind to port zero and send the port it bound to to a listening process on the other end. This allows the GDB remote platform to spawn new GDB server instances (debugserver) to allow platform debugging. llvm-svn: 129351
2011-04-12 13:54:46 +08:00
}
}
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
size_t
CommandInterpreter::GetProcessOutput ()
{
// The process has stuff waiting for stderr; get it and write it out to the appropriate place.
char stdio_buffer[1024];
size_t len;
size_t total_bytes = 0;
Error error;
TargetSP target_sp (m_debugger.GetTargetList().GetSelectedTarget());
if (target_sp)
{
ProcessSP process_sp (target_sp->GetProcessSP());
if (process_sp)
{
while ((len = process_sp->GetSTDOUT (stdio_buffer, sizeof (stdio_buffer), error)) > 0)
{
size_t bytes_written = len;
m_debugger.GetOutputFile()->Write (stdio_buffer, bytes_written);
total_bytes += len;
}
while ((len = process_sp->GetSTDERR (stdio_buffer, sizeof (stdio_buffer), error)) > 0)
{
size_t bytes_written = len;
m_debugger.GetErrorFile()->Write (stdio_buffer, bytes_written);
total_bytes += len;
}
}
}
return total_bytes;
}
void
CommandInterpreter::IOHandlerInputComplete (IOHandler &io_handler, std::string &line)
{
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
const bool is_interactive = io_handler.GetIsInteractive();
if (is_interactive == false)
{
// When we are not interactive, don't execute blank lines. This will happen
// sourcing a commands file. We don't want blank lines to repeat the previous
// command and cause any errors to occur (like redefining an alias, get an error
// and stop parsing the commands file).
if (line.empty())
return;
// When using a non-interactive file handle (like when sourcing commands from a file)
// we need to echo the command out so we don't just see the command output and no
// command...
if (io_handler.GetFlags().Test(eHandleCommandFlagEchoCommand))
io_handler.GetOutputStreamFile()->Printf("%s%s\n", io_handler.GetPrompt(), line.c_str());
}
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
lldb_private::CommandReturnObject result;
HandleCommand(line.c_str(), eLazyBoolCalculate, result);
// Now emit the command output text from the command we just executed
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
if (io_handler.GetFlags().Test(eHandleCommandFlagPrintResult))
{
// Display any STDOUT/STDERR _prior_ to emitting the command result text
GetProcessOutput ();
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
if (!result.GetImmediateOutputStream())
{
const char *output = result.GetOutputData();
if (output && output[0])
io_handler.GetOutputStreamFile()->PutCString(output);
}
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
// Now emit the command error text from the command we just executed
Don't print out "script" results twice. We now properly detect when a result object has an immediate output stream and don't echo the results a second time. <rdar://problem/15954906> llvm-svn: 200882
2014-02-06 05:46:20 +08:00
if (!result.GetImmediateErrorStream())
{
const char *error = result.GetErrorData();
if (error && error[0])
io_handler.GetErrorStreamFile()->PutCString(error);
}
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
}
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
switch (result.GetStatus())
{
case eReturnStatusInvalid:
case eReturnStatusSuccessFinishNoResult:
case eReturnStatusSuccessFinishResult:
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
case eReturnStatusStarted:
break;
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
case eReturnStatusSuccessContinuingNoResult:
case eReturnStatusSuccessContinuingResult:
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnContinue))
io_handler.SetIsDone(true);
break;
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
case eReturnStatusFailed:
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
m_num_errors++;
Fixed an issue where "command source" would not do the right thing: - empty lines in init files would repeat previous command and cause errors to be displayed - all options to control showing the command, its output, if it should stop on error or continue, weren't being obeyed. llvm-svn: 200860
2014-02-06 01:57:57 +08:00
if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnError))
io_handler.SetIsDone(true);
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
break;
case eReturnStatusQuit:
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
m_quit_requested = true;
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
io_handler.SetIsDone(true);
break;
}
This adds a "batch mode" to lldb kinda like the gdb batch mode. It will quit the debugger after all the commands have been executed except if one of the commands was an execution control command that stopped because of a signal or exception. Also adds a variant of SBCommandInterpreter::HandleCommand that takes an SBExecutionContext. That way you can run an lldb command targeted at a particular target, thread or process w/o having to select same before running the command. Also exposes CommandInterpreter::HandleCommandsFromFile to the SBCommandInterpreter API, since that seemed generally useful. llvm-svn: 219654
2014-10-14 09:20:07 +08:00
// Finally, if we're going to stop on crash, check that here:
if (!m_quit_requested
&& result.GetDidChangeProcessState()
&& io_handler.GetFlags().Test(eHandleCommandFlagStopOnCrash))
{
bool should_stop = false;
TargetSP target_sp (m_debugger.GetTargetList().GetSelectedTarget());
if (target_sp)
{
ProcessSP process_sp (target_sp->GetProcessSP());
if (process_sp)
{
for (ThreadSP thread_sp : process_sp->GetThreadList().Threads())
{
StopReason reason = thread_sp->GetStopReason();
Fix a glitch in the Driver's batch mode when used with "attach". Batch mode is supposed to stop execution and return control to the user when an exceptional stop occurs (crash, signal or instrumentation). But attach always stops with a SIGSTOP on OSX (maybe on Linux too?) which would short circuit the rest of the commands given. This change allows a command result object to indicate that it expected to leave the process stopped with an exceptional stop reason, and it is okay for batch mode to keep going. <rdar://problem/22243143> llvm-svn: 257120
2016-01-08 08:20:47 +08:00
if ((reason == eStopReasonSignal
|| reason == eStopReasonException
|| reason == eStopReasonInstrumentation)
&& !result.GetAbnormalStopWasExpected())
This adds a "batch mode" to lldb kinda like the gdb batch mode. It will quit the debugger after all the commands have been executed except if one of the commands was an execution control command that stopped because of a signal or exception. Also adds a variant of SBCommandInterpreter::HandleCommand that takes an SBExecutionContext. That way you can run an lldb command targeted at a particular target, thread or process w/o having to select same before running the command. Also exposes CommandInterpreter::HandleCommandsFromFile to the SBCommandInterpreter API, since that seemed generally useful. llvm-svn: 219654
2014-10-14 09:20:07 +08:00
{
should_stop = true;
break;
}
}
}
}
if (should_stop)
{
io_handler.SetIsDone(true);
m_stopped_for_crash = true;
}
}
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
}
Fixed CTRL+C related issues: - CTRL+C wasn't clearing the command in lldb - CTRL+C doesn't work in python macros in lldb - Ctrl+C no longer interrupts the running process that you attach to <rdar://problem/15949205> <rdar://problem/16778652> <rdar://problem/16774411> llvm-svn: 207816
2014-05-02 08:45:31 +08:00
bool
CommandInterpreter::IOHandlerInterrupt (IOHandler &io_handler)
{
ExecutionContext exe_ctx (GetExecutionContext());
Process *process = exe_ctx.GetProcessPtr();
if (process)
{
StateType state = process->GetState();
if (StateIsRunningState(state))
{
process->Halt();
return true; // Don't do any updating when we are running
}
}
Allow python command interpreter commands to be interruptable via CTRL+C. <rdar://problem/17935601> llvm-svn: 227163
2015-01-27 09:58:22 +08:00
ScriptInterpreter *script_interpreter = GetScriptInterpreter (false);
if (script_interpreter)
{
if (script_interpreter->Interrupt())
return true;
}
Fixed CTRL+C related issues: - CTRL+C wasn't clearing the command in lldb - CTRL+C doesn't work in python macros in lldb - Ctrl+C no longer interrupts the running process that you attach to <rdar://problem/15949205> <rdar://problem/16778652> <rdar://problem/16774411> llvm-svn: 207816
2014-05-02 08:45:31 +08:00
return false;
}
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
void
CommandInterpreter::GetLLDBCommandsFromIOHandler (const char *prompt,
IOHandlerDelegate &delegate,
bool asynchronously,
void *baton)
{
Debugger &debugger = GetDebugger();
IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger,
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
IOHandler::Type::CommandList,
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
"lldb", // Name of input reader for history
prompt, // Prompt
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
NULL, // Continuation prompt
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
true, // Get multiple lines
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
debugger.GetUseColor(),
Allow line numbers to be shown in multi-line expressions. llvm-svn: 203185
2014-03-07 08:53:24 +08:00
0, // Don't show line numbers
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
delegate)); // IOHandlerDelegate
if (io_handler_sp)
{
io_handler_sp->SetUserData (baton);
if (asynchronously)
debugger.PushIOHandler(io_handler_sp);
else
debugger.RunIOHandler(io_handler_sp);
}
}
void
CommandInterpreter::GetPythonCommandsFromIOHandler (const char *prompt,
IOHandlerDelegate &delegate,
bool asynchronously,
void *baton)
{
Debugger &debugger = GetDebugger();
IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger,
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
IOHandler::Type::PythonCode,
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
"lldb-python", // Name of input reader for history
prompt, // Prompt
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
NULL, // Continuation prompt
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
true, // Get multiple lines
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
debugger.GetUseColor(),
Allow line numbers to be shown in multi-line expressions. llvm-svn: 203185
2014-03-07 08:53:24 +08:00
0, // Don't show line numbers
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
delegate)); // IOHandlerDelegate
if (io_handler_sp)
{
io_handler_sp->SetUserData (baton);
if (asynchronously)
debugger.PushIOHandler(io_handler_sp);
else
debugger.RunIOHandler(io_handler_sp);
}
}
bool
CommandInterpreter::IsActive ()
{
return m_debugger.IsTopIOHandler (m_command_io_handler_sp);
}
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
lldb::IOHandlerSP
CommandInterpreter::GetIOHandler(bool force_create, CommandInterpreterRunOptions *options)
{
// Always re-create the IOHandlerEditline in case the input
// changed. The old instance might have had a non-interactive
// input and now it does or vice versa.
if (force_create || !m_command_io_handler_sp)
{
// Always re-create the IOHandlerEditline in case the input
// changed. The old instance might have had a non-interactive
// input and now it does or vice versa.
uint32_t flags = 0;
if (options)
{
if (options->m_stop_on_continue == eLazyBoolYes)
flags |= eHandleCommandFlagStopOnContinue;
if (options->m_stop_on_error == eLazyBoolYes)
flags |= eHandleCommandFlagStopOnError;
if (options->m_stop_on_crash == eLazyBoolYes)
flags |= eHandleCommandFlagStopOnCrash;
if (options->m_echo_commands != eLazyBoolNo)
flags |= eHandleCommandFlagEchoCommand;
if (options->m_print_results != eLazyBoolNo)
flags |= eHandleCommandFlagPrintResult;
}
else
{
flags = eHandleCommandFlagEchoCommand | eHandleCommandFlagPrintResult;
}
m_command_io_handler_sp.reset(new IOHandlerEditline (m_debugger,
IOHandler::Type::CommandInterpreter,
m_debugger.GetInputFile(),
m_debugger.GetOutputFile(),
m_debugger.GetErrorFile(),
flags,
"lldb",
m_debugger.GetPrompt(),
NULL, // Continuation prompt
false, // Don't enable multiple line input, just single line commands
m_debugger.GetUseColor(),
0, // Don't show line numbers
*this));
}
return m_command_io_handler_sp;
}
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
void
CommandInterpreter::RunCommandInterpreter(bool auto_handle_events,
Rework the way we pass "run multiple command" options to the various API's that do that (RunCommandInterpreter, HandleCommands, HandleCommandsFromFile) to gather the options into an options class. Also expose that to the SB API's. Change the way the "-o" options to the lldb driver are processed so: 1) They are run synchronously - didn't really make any sense to run the asynchronously. 2) The stop on error 3) "quit" in one of the -o commands will not quit lldb - not the command interpreter that was running the -o commands. I added an entry to the run options to stop-on-crash, but I haven't implemented that yet. llvm-svn: 219553
2014-10-11 08:38:27 +08:00
bool spawn_thread,
CommandInterpreterRunOptions &options)
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
{
Fix a variety of typos. No functional change. llvm-svn: 239995
2015-06-18 13:27:05 +08:00
// Always re-create the command interpreter when we run it in case
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
// any file handles have changed.
bool force_create = true;
m_debugger.PushIOHandler(GetIOHandler(force_create, &options));
This adds a "batch mode" to lldb kinda like the gdb batch mode. It will quit the debugger after all the commands have been executed except if one of the commands was an execution control command that stopped because of a signal or exception. Also adds a variant of SBCommandInterpreter::HandleCommand that takes an SBExecutionContext. That way you can run an lldb command targeted at a particular target, thread or process w/o having to select same before running the command. Also exposes CommandInterpreter::HandleCommandsFromFile to the SBCommandInterpreter API, since that seemed generally useful. llvm-svn: 219654
2014-10-14 09:20:07 +08:00
m_stopped_for_crash = false;
Fixed an issue where the LLDB command prompt isn't interactive if you use -o -O -S -s or specify a file on the command line. This means TAB completion wasn't working and editline wasn't being used. <rdar://problem/17872824> llvm-svn: 214428
2014-08-01 03:46:19 +08:00
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
if (auto_handle_events)
m_debugger.StartEventHandlerThread();
if (spawn_thread)
{
m_debugger.StartIOHandlerThread();
}
else
{
Fix a typo Debugger::ExecuteIOHanders to Debugger::ExecuteIOHandlers. Test Plan: Build LLDB. Reviewers: zturner, vharron, clayborg Reviewed By: vharron, clayborg Subscribers: jingham, lldb-commits Differential Revision: http://reviews.llvm.org/D7894 llvm-svn: 230663
2015-02-27 03:26:36 +08:00
m_debugger.ExecuteIOHandlers();
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
if (auto_handle_events)
m_debugger.StopEventHandlerThread();
}
Complete rewrite of interactive editing support for single- and multi-line input. Improvements include: * Use of libedit's wide character support, which is imperfect but a distinct improvement over ASCII-only * Fallback for ASCII editing path * Support for a "faint" prompt clearly distinguished from input * Breaking lines and insert new lines in the middle of a batch by simply pressing return * Joining lines with forward and backward character deletion * Detection of paste to suppress automatic formatting and statement completion tests * Correctly reformatting when lines grow or shrink to occupy different numbers of rows * Saving multi-line history, and correctly preserving the "tip" of history during editing * Displaying visible ^C and ^D indications when interrupting input or sending EOF * Fledgling VI support for multi-line editing * General correctness and reliability improvements llvm-svn: 222163
2014-11-18 03:06:59 +08:00
Merging the iohandler branch back into main. The many many benefits include: 1 - Input/Output/Error streams are now handled as real streams not a push style input 2 - auto completion in python embedded interpreter 3 - multi-line input for "script" and "expression" commands now allow you to edit previous/next lines using up and down arrow keys and this makes multi-line input actually a viable thing to use 4 - it is now possible to use curses to drive LLDB (please try the "gui" command) We will need to deal with and fix any buildbot failures and tests and arise now that input/output and error are correctly hooked up in all cases. llvm-svn: 200263
2014-01-28 07:43:24 +08:00
}
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
CommandObject *
CommandInterpreter::ResolveCommandImpl(std::string &command_line, CommandReturnObject &result)
{
std::string scratch_command(command_line); // working copy so we don't modify command_line unless we succeed
CommandObject *cmd_obj = nullptr;
StreamString revised_command_line;
bool wants_raw_input = false;
size_t actual_cmd_name_len = 0;
std::string next_word;
StringList matches;
bool done = false;
while (!done)
{
char quote_char = '\0';
std::string suffix;
ExtractCommand(scratch_command, next_word, suffix, quote_char);
if (cmd_obj == nullptr)
{
std::string full_name;
Fix an issue where one could not define a Python command with the same name as an existing alias (or rather, one could but the results of invoking the command were far from satisfactory) llvm-svn: 275080
2016-07-12 01:36:55 +08:00
bool is_alias = GetAliasFullName(next_word.c_str(), full_name);
cmd_obj = GetCommandObject(next_word.c_str(), &matches);
bool is_real_command = (is_alias == false) || (cmd_obj != nullptr && cmd_obj->IsAlias() == false);
if (!is_real_command)
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
{
Fix an issue where one could not define a Python command with the same name as an existing alias (or rather, one could but the results of invoking the command were far from satisfactory) llvm-svn: 275080
2016-07-12 01:36:55 +08:00
matches.Clear();
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
std::string alias_result;
cmd_obj = BuildAliasResult(full_name.c_str(), scratch_command, alias_result, result);
revised_command_line.Printf("%s", alias_result.c_str());
if (cmd_obj)
{
wants_raw_input = cmd_obj->WantsRawCommandString();
actual_cmd_name_len = strlen(cmd_obj->GetCommandName());
}
}
else
{
Fix an issue where one could not define a Python command with the same name as an existing alias (or rather, one could but the results of invoking the command were far from satisfactory) llvm-svn: 275080
2016-07-12 01:36:55 +08:00
if (!cmd_obj)
cmd_obj = GetCommandObject(next_word.c_str(), &matches);
Factor resolution of abbreviations and aliases so that they can be tested directly. http://reviews.llvm.org/D9033 llvm-svn: 235633
2015-04-24 04:00:25 +08:00
if (cmd_obj)
{
actual_cmd_name_len += strlen(cmd_obj->GetCommandName());
revised_command_line.Printf("%s", cmd_obj->GetCommandName());
wants_raw_input = cmd_obj->WantsRawCommandString();
}
else
{
revised_command_line.Printf ("%s", next_word.c_str());
}
}
}
else
{
if (cmd_obj->IsMultiwordObject ())
{
CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject(next_word.c_str());
if (sub_cmd_obj)
{
// The subcommand's name includes the parent command's name,
// so restart rather than append to the revised_command_line.
actual_cmd_name_len = strlen(sub_cmd_obj->GetCommandName()) + 1;
revised_command_line.Clear();
revised_command_line.Printf("%s", sub_cmd_obj->GetCommandName());
cmd_obj = sub_cmd_obj;
wants_raw_input = cmd_obj->WantsRawCommandString();
}
else
{
if (quote_char)
revised_command_line.Printf(" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char);
else
revised_command_line.Printf(" %s%s", next_word.c_str(), suffix.c_str());
done = true;
}
}
else
{
if (quote_char)
revised_command_line.Printf(" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char);
else
revised_command_line.Printf(" %s%s", next_word.c_str(), suffix.c_str());
done = true;
}
}
if (cmd_obj == nullptr)
{
const size_t num_matches = matches.GetSize();
if (matches.GetSize() > 1) {
StreamString error_msg;
error_msg.Printf("Ambiguous command '%s'. Possible matches:\n", next_word.c_str());
for (uint32_t i = 0; i < num_matches; ++i) {
error_msg.Printf("\t%s\n", matches.GetStringAtIndex(i));
}
result.AppendRawError(error_msg.GetString().c_str());
} else {
// We didn't have only one match, otherwise we wouldn't get here.
assert(num_matches == 0);
result.AppendErrorWithFormat("'%s' is not a valid command.\n", next_word.c_str());
}
result.SetStatus(eReturnStatusFailed);
return nullptr;
}
if (cmd_obj->IsMultiwordObject())
{
if (!suffix.empty())
{
result.AppendErrorWithFormat("command '%s' did not recognize '%s%s%s' as valid (subcommand might be invalid).\n",
cmd_obj->GetCommandName(),
next_word.empty() ? "" : next_word.c_str(),
next_word.empty() ? " -- " : " ",
suffix.c_str());
result.SetStatus(eReturnStatusFailed);
return nullptr;
}
}
else
{
// If we found a normal command, we are done
done = true;
if (!suffix.empty())
{
switch (suffix[0])
{
case '/':
// GDB format suffixes
{
Options *command_options = cmd_obj->GetOptions();
if (command_options && command_options->SupportsLongOption("gdb-format"))
{
std::string gdb_format_option("--gdb-format=");
gdb_format_option += (suffix.c_str() + 1);
bool inserted = false;
std::string &cmd = revised_command_line.GetString();
size_t arg_terminator_idx = FindArgumentTerminator(cmd);
if (arg_terminator_idx != std::string::npos)
{
// Insert the gdb format option before the "--" that terminates options
gdb_format_option.append(1,' ');
cmd.insert(arg_terminator_idx, gdb_format_option);
inserted = true;
}
if (!inserted)
revised_command_line.Printf(" %s", gdb_format_option.c_str());
if (wants_raw_input && FindArgumentTerminator(cmd) == std::string::npos)
revised_command_line.PutCString(" --");
}
else
{
result.AppendErrorWithFormat("the '%s' command doesn't support the --gdb-format option\n",
cmd_obj->GetCommandName());
result.SetStatus(eReturnStatusFailed);
return nullptr;
}
}
break;
default:
result.AppendErrorWithFormat("unknown command shorthand suffix: '%s'\n",
suffix.c_str());
result.SetStatus(eReturnStatusFailed);
return nullptr;
}
}
}
if (scratch_command.empty())
done = true;
}
if (!scratch_command.empty())
revised_command_line.Printf(" %s", scratch_command.c_str());
if (cmd_obj != NULL)
command_line = revised_command_line.GetData();
return cmd_obj;
}