59#include "lldb/Host/Config.h"
60#if LLDB_ENABLE_LIBEDIT
83#include "llvm/ADT/STLExtras.h"
84#include "llvm/ADT/ScopeExit.h"
85#include "llvm/ADT/SmallString.h"
86#include "llvm/Support/FormatAdapters.h"
87#include "llvm/Support/Path.h"
88#include "llvm/Support/PrettyStackTrace.h"
89#include "llvm/Support/ScopedPrinter.h"
92#include <TargetConditionals.h>
101 "There is a .lldbinit file in the current directory which is not being "
103 "To silence this warning without sourcing in the local .lldbinit,\n"
104 "add the following to the lldbinit file in your home directory:\n"
105 " settings set target.load-cwd-lldbinit false\n"
106 "To allow lldb to source .lldbinit files in the current working "
108 "set the value of this variable to true. Only do so if you understand "
110 "accept the security risk.";
117#define LLDB_PROPERTIES_interpreter
118#include "InterpreterProperties.inc"
121#define LLDB_PROPERTIES_interpreter
122#include "InterpreterPropertiesEnum.inc"
126 static constexpr llvm::StringLiteral class_name(
"lldb.commandInterpreter");
131 bool synchronous_execution)
137 m_debugger(debugger), m_synchronous_execution(true),
138 m_skip_lldbinit_files(false), m_skip_app_init_files(false),
139 m_comment_char(
'#'), m_batch_command_mode(false),
140 m_truncation_warning(eNoOmission), m_max_depth_warning(eNoOmission),
141 m_command_source_depth(0) {
151 const uint32_t idx = ePropertyExpandRegexAliases;
152 return GetPropertyAtIndexAs<bool>(
153 idx, g_interpreter_properties[idx].default_uint_value != 0);
157 const uint32_t idx = ePropertyPromptOnQuit;
158 return GetPropertyAtIndexAs<bool>(
159 idx, g_interpreter_properties[idx].default_uint_value != 0);
163 const uint32_t idx = ePropertyPromptOnQuit;
168 const uint32_t idx = ePropertySaveTranscript;
169 return GetPropertyAtIndexAs<bool>(
170 idx, g_interpreter_properties[idx].default_uint_value != 0);
174 const uint32_t idx = ePropertySaveTranscript;
179 const uint32_t idx = ePropertySaveSessionOnQuit;
180 return GetPropertyAtIndexAs<bool>(
181 idx, g_interpreter_properties[idx].default_uint_value != 0);
185 const uint32_t idx = ePropertySaveSessionOnQuit;
190 const uint32_t idx = ePropertyOpenTranscriptInEditor;
191 return GetPropertyAtIndexAs<bool>(
192 idx, g_interpreter_properties[idx].default_uint_value != 0);
196 const uint32_t idx = ePropertyOpenTranscriptInEditor;
201 const uint32_t idx = ePropertySaveSessionDirectory;
202 return GetPropertyAtIndexAs<FileSpec>(idx, {});
206 const uint32_t idx = ePropertySaveSessionDirectory;
211 const uint32_t idx = ePropertyEchoCommands;
212 return GetPropertyAtIndexAs<bool>(
213 idx, g_interpreter_properties[idx].default_uint_value != 0);
217 const uint32_t idx = ePropertyEchoCommands;
222 const uint32_t idx = ePropertyEchoCommentCommands;
223 return GetPropertyAtIndexAs<bool>(
224 idx, g_interpreter_properties[idx].default_uint_value != 0);
228 const uint32_t idx = ePropertyEchoCommentCommands;
254 std::string command = command_line;
262 const uint32_t idx = ePropertyStopCmdSourceOnError;
263 return GetPropertyAtIndexAs<bool>(
264 idx, g_interpreter_properties[idx].default_uint_value != 0);
268 const uint32_t idx = ePropertySpaceReplPrompts;
269 return GetPropertyAtIndexAs<bool>(
270 idx, g_interpreter_properties[idx].default_uint_value != 0);
274 const uint32_t idx = ePropertyRepeatPreviousCommand;
275 return GetPropertyAtIndexAs<bool>(
276 idx, g_interpreter_properties[idx].default_uint_value != 0);
280 const uint32_t idx = ePropertyRequireCommandOverwrite;
281 return GetPropertyAtIndexAs<bool>(
282 idx, g_interpreter_properties[idx].default_uint_value != 0);
342 "sif", cmd_obj_sp,
"--end-linenumber block --step-in-target %1");
344 sif_alias->
SetHelp(
"Step through the current block, stopping if you step "
345 "directly into a function whose name matches the "
346 "TargetFunctionName.");
347 sif_alias->
SetSyntax(
"sif <TargetFunctionName>");
428 alias_arguments_vector_sp = std::make_shared<OptionArgVector>();
434 if (
auto *po =
AddAlias(
"po", cmd_obj_sp,
"-O --")) {
435 po->SetHelp(
"Evaluate an expression on the current thread. Displays any "
436 "returned value with formatting "
437 "controlled by the type's author.");
446 AddAlias(
"parray", cmd_obj_sp,
"--element-count %1 --");
449 (
"parray <COUNT> <EXPRESSION> -- lldb will evaluate EXPRESSION "
450 "to get a typed-pointer-to-an-array in memory, and will display "
451 "COUNT elements of that type from the array.");
455 "--object-description --element-count %1 --");
457 poarray_alias->
SetHelp(
"poarray <COUNT> <EXPRESSION> -- lldb will "
458 "evaluate EXPRESSION to get the address of an array of COUNT "
459 "objects in memory, and will call po on them.");
468 shell_alias->
SetHelp(
"Run a shell command on the host.");
470 shell_alias->
SetSyntax(
"shell <shell-command>");
481 alias_arguments_vector_sp = std::make_shared<OptionArgVector>();
482#if defined(__APPLE__)
487 AddAlias(
"r", cmd_obj_sp,
"--shell-expand-args true --");
488 AddAlias(
"run", cmd_obj_sp,
"--shell-expand-args true --");
492 defaultshell.
Printf(
"--shell=%s --",
493 HostInfo::GetDefaultShell().GetPath().c_str());
506 AddAlias(
"rbreak", cmd_obj_sp,
"--func-regex %1");
513 AddAlias(
"vo", cmd_obj_sp,
"--object-description");
558#define REGISTER_COMMAND_OBJECT(NAME, CLASS) \
559 m_command_dict[NAME] = std::make_shared<CLASS>(*this);
595 const char *break_regexes[][2] = {
596 {
"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$",
597 "breakpoint set --file '%1' --line %2 --column %3"},
598 {
"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$",
599 "breakpoint set --file '%1' --line %2"},
600 {
"^/([^/]+)/$",
"breakpoint set --source-pattern-regexp '%1'"},
601 {
"^([[:digit:]]+)[[:space:]]*$",
"breakpoint set --line %1"},
602 {
"^\\*?(0x[[:xdigit:]]+)[[:space:]]*$",
"breakpoint set --address %1"},
603 {
"^[\"']?([-+]?\\[.*\\])[\"']?[[:space:]]*$",
604 "breakpoint set --name '%1'"},
605 {
"^(-.*)$",
"breakpoint set %1"},
606 {
"^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$",
607 "breakpoint set --name '%2' --shlib '%1'"},
608 {
"^\\&(.*[^[:space:]])[[:space:]]*$",
609 "breakpoint set --name '%1' --skip-prologue=0"},
610 {
"^[\"']?(.*[^[:space:]\"'])[\"']?[[:space:]]*$",
611 "breakpoint set --name '%1'"}};
614 size_t num_regexes = std::size(break_regexes);
616 std::unique_ptr<CommandObjectRegexCommand> break_regex_cmd_up(
618 *
this,
"_regexp-break",
619 "Set a breakpoint using one of several shorthand formats.",
621 "_regexp-break <filename>:<linenum>:<colnum>\n"
622 " main.c:12:21 // Break at line 12 and column "
624 "_regexp-break <filename>:<linenum>\n"
625 " main.c:12 // Break at line 12 of "
627 "_regexp-break <linenum>\n"
628 " 12 // Break at line 12 of current "
630 "_regexp-break 0x<address>\n"
631 " 0x1234000 // Break at address "
633 "_regexp-break <name>\n"
634 " main // Break in 'main' after the "
636 "_regexp-break &<name>\n"
637 " &main // Break at first instruction "
639 "_regexp-break <module>`<name>\n"
640 " libc.so`malloc // Break in 'malloc' from "
642 "_regexp-break /<source-regex>/\n"
643 " /break here/ // Break on source lines in "
645 " // containing text 'break "
649 if (break_regex_cmd_up) {
651 for (
size_t i = 0; i < num_regexes; i++) {
652 success = break_regex_cmd_up->AddRegexCommand(break_regexes[i][0],
653 break_regexes[i][1]);
658 break_regex_cmd_up->AddRegexCommand(
"^$",
"breakpoint list --full");
662 m_command_dict[std::string(break_regex_cmd_sp->GetCommandName())] =
667 std::unique_ptr<CommandObjectRegexCommand> tbreak_regex_cmd_up(
669 *
this,
"_regexp-tbreak",
670 "Set a one-shot breakpoint using one of several shorthand formats.",
672 "_regexp-break <filename>:<linenum>:<colnum>\n"
673 " main.c:12:21 // Break at line 12 and column "
675 "_regexp-break <filename>:<linenum>\n"
676 " main.c:12 // Break at line 12 of "
678 "_regexp-break <linenum>\n"
679 " 12 // Break at line 12 of current "
681 "_regexp-break 0x<address>\n"
682 " 0x1234000 // Break at address "
684 "_regexp-break <name>\n"
685 " main // Break in 'main' after the "
687 "_regexp-break &<name>\n"
688 " &main // Break at first instruction "
690 "_regexp-break <module>`<name>\n"
691 " libc.so`malloc // Break in 'malloc' from "
693 "_regexp-break /<source-regex>/\n"
694 " /break here/ // Break on source lines in "
696 " // containing text 'break "
700 if (tbreak_regex_cmd_up) {
702 for (
size_t i = 0; i < num_regexes; i++) {
703 std::string command = break_regexes[i][1];
706 tbreak_regex_cmd_up->AddRegexCommand(break_regexes[i][0], command);
711 tbreak_regex_cmd_up->AddRegexCommand(
"^$",
"breakpoint list --full");
715 m_command_dict[std::string(tbreak_regex_cmd_sp->GetCommandName())] =
720 std::unique_ptr<CommandObjectRegexCommand> attach_regex_cmd_up(
722 *
this,
"_regexp-attach",
"Attach to process by ID or name.",
723 "_regexp-attach <pid> | <process-name>", 0,
false));
724 if (attach_regex_cmd_up) {
725 if (attach_regex_cmd_up->AddRegexCommand(
"^([0-9]+)[[:space:]]*$",
726 "process attach --pid %1") &&
727 attach_regex_cmd_up->AddRegexCommand(
728 "^(-.*|.* -.*)$",
"process attach %1") &&
731 attach_regex_cmd_up->AddRegexCommand(
"^(.+)$",
732 "process attach --name '%1'") &&
733 attach_regex_cmd_up->AddRegexCommand(
"^$",
"process attach")) {
735 m_command_dict[std::string(attach_regex_cmd_sp->GetCommandName())] =
740 std::unique_ptr<CommandObjectRegexCommand> down_regex_cmd_up(
742 "Select a newer stack frame. Defaults to "
743 "moving one frame, a numeric argument can "
744 "specify an arbitrary number.",
745 "_regexp-down [<count>]", 0,
false));
746 if (down_regex_cmd_up) {
747 if (down_regex_cmd_up->AddRegexCommand(
"^$",
"frame select -r -1") &&
748 down_regex_cmd_up->AddRegexCommand(
"^([0-9]+)$",
749 "frame select -r -%1")) {
751 m_command_dict[std::string(down_regex_cmd_sp->GetCommandName())] =
756 std::unique_ptr<CommandObjectRegexCommand> up_regex_cmd_up(
759 "Select an older stack frame. Defaults to moving one "
760 "frame, a numeric argument can specify an arbitrary number.",
761 "_regexp-up [<count>]", 0,
false));
762 if (up_regex_cmd_up) {
763 if (up_regex_cmd_up->AddRegexCommand(
"^$",
"frame select -r 1") &&
764 up_regex_cmd_up->AddRegexCommand(
"^([0-9]+)$",
"frame select -r %1")) {
771 std::unique_ptr<CommandObjectRegexCommand> display_regex_cmd_up(
773 *
this,
"_regexp-display",
774 "Evaluate an expression at every stop (see 'help target stop-hook'.)",
775 "_regexp-display expression", 0,
false));
776 if (display_regex_cmd_up) {
777 if (display_regex_cmd_up->AddRegexCommand(
778 "^(.+)$",
"target stop-hook add -o \"expr -- %1\"")) {
780 m_command_dict[std::string(display_regex_cmd_sp->GetCommandName())] =
781 display_regex_cmd_sp;
785 std::unique_ptr<CommandObjectRegexCommand> undisplay_regex_cmd_up(
787 "Stop displaying expression at every "
788 "stop (specified by stop-hook index.)",
789 "_regexp-undisplay stop-hook-number", 0,
791 if (undisplay_regex_cmd_up) {
792 if (undisplay_regex_cmd_up->AddRegexCommand(
"^([0-9]+)$",
793 "target stop-hook delete %1")) {
794 CommandObjectSP undisplay_regex_cmd_sp(undisplay_regex_cmd_up.release());
795 m_command_dict[std::string(undisplay_regex_cmd_sp->GetCommandName())] =
796 undisplay_regex_cmd_sp;
800 std::unique_ptr<CommandObjectRegexCommand> connect_gdb_remote_cmd_up(
803 "Connect to a process via remote GDB server.\n"
804 "If no host is specifed, localhost is assumed.\n"
805 "gdb-remote is an abbreviation for 'process connect --plugin "
806 "gdb-remote connect://<hostname>:<port>'\n",
807 "gdb-remote [<hostname>:]<portnum>", 0,
false));
808 if (connect_gdb_remote_cmd_up) {
809 if (connect_gdb_remote_cmd_up->AddRegexCommand(
810 "^([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)$",
811 "process connect --plugin gdb-remote connect://%1:%2") &&
812 connect_gdb_remote_cmd_up->AddRegexCommand(
814 "process connect --plugin gdb-remote connect://localhost:%1")) {
816 m_command_dict[std::string(command_sp->GetCommandName())] = command_sp;
820 std::unique_ptr<CommandObjectRegexCommand> connect_kdp_remote_cmd_up(
823 "Connect to a process via remote KDP server.\n"
824 "If no UDP port is specified, port 41139 is assumed.\n"
825 "kdp-remote is an abbreviation for 'process connect --plugin "
826 "kdp-remote udp://<hostname>:<port>'\n",
827 "kdp-remote <hostname>[:<portnum>]", 0,
false));
828 if (connect_kdp_remote_cmd_up) {
829 if (connect_kdp_remote_cmd_up->AddRegexCommand(
830 "^([^:]+:[[:digit:]]+)$",
831 "process connect --plugin kdp-remote udp://%1") &&
832 connect_kdp_remote_cmd_up->AddRegexCommand(
833 "^(.+)$",
"process connect --plugin kdp-remote udp://%1:41139")) {
835 m_command_dict[std::string(command_sp->GetCommandName())] = command_sp;
839 std::unique_ptr<CommandObjectRegexCommand> bt_regex_cmd_up(
842 "Show backtrace of the current thread's call stack. Any numeric "
843 "argument displays at most that many frames. The argument 'all' "
844 "displays all threads. Use 'settings set frame-format' to customize "
845 "the printing of individual frames and 'settings set thread-format' "
846 "to customize the thread header.",
847 "bt [<digit> | all]", 0,
false));
848 if (bt_regex_cmd_up) {
853 if (bt_regex_cmd_up->AddRegexCommand(
"^([[:digit:]]+)[[:space:]]*$",
854 "thread backtrace -c %1") &&
855 bt_regex_cmd_up->AddRegexCommand(
"^-c ([[:digit:]]+)[[:space:]]*$",
856 "thread backtrace -c %1") &&
857 bt_regex_cmd_up->AddRegexCommand(
"^all[[:space:]]*$",
"thread backtrace all") &&
858 bt_regex_cmd_up->AddRegexCommand(
"^[[:space:]]*$",
"thread backtrace")) {
860 m_command_dict[std::string(command_sp->GetCommandName())] = command_sp;
864 std::unique_ptr<CommandObjectRegexCommand> list_regex_cmd_up(
866 *
this,
"_regexp-list",
867 "List relevant source code using one of several shorthand formats.",
869 "_regexp-list <file>:<line> // List around specific file/line\n"
870 "_regexp-list <line> // List current file around specified "
872 "_regexp-list <function-name> // List specified function\n"
873 "_regexp-list 0x<address> // List around specified address\n"
874 "_regexp-list -[<count>] // List previous <count> lines\n"
875 "_regexp-list // List subsequent lines",
877 if (list_regex_cmd_up) {
878 if (list_regex_cmd_up->AddRegexCommand(
"^([0-9]+)[[:space:]]*$",
879 "source list --line %1") &&
880 list_regex_cmd_up->AddRegexCommand(
881 "^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]"
883 "source list --file '%1' --line %2") &&
884 list_regex_cmd_up->AddRegexCommand(
885 "^\\*?(0x[[:xdigit:]]+)[[:space:]]*$",
886 "source list --address %1") &&
887 list_regex_cmd_up->AddRegexCommand(
"^-[[:space:]]*$",
888 "source list --reverse") &&
889 list_regex_cmd_up->AddRegexCommand(
890 "^-([[:digit:]]+)[[:space:]]*$",
891 "source list --reverse --count %1") &&
892 list_regex_cmd_up->AddRegexCommand(
"^(.+)$",
893 "source list --name \"%1\"") &&
894 list_regex_cmd_up->AddRegexCommand(
"^$",
"source list")) {
896 m_command_dict[std::string(list_regex_cmd_sp->GetCommandName())] =
901 std::unique_ptr<CommandObjectRegexCommand> env_regex_cmd_up(
903 *
this,
"_regexp-env",
904 "Shorthand for viewing and setting environment variables.",
906 "_regexp-env // Show environment\n"
907 "_regexp-env <name>=<value> // Set an environment variable",
909 if (env_regex_cmd_up) {
910 if (env_regex_cmd_up->AddRegexCommand(
"^$",
911 "settings show target.env-vars") &&
912 env_regex_cmd_up->AddRegexCommand(
"^([A-Za-z_][A-Za-z_0-9]*=.*)$",
913 "settings set target.env-vars %1")) {
920 std::unique_ptr<CommandObjectRegexCommand> jump_regex_cmd_up(
922 *
this,
"_regexp-jump",
"Set the program counter to a new address.",
924 "_regexp-jump <line>\n"
925 "_regexp-jump +<line-offset> | -<line-offset>\n"
926 "_regexp-jump <file>:<line>\n"
927 "_regexp-jump *<addr>\n",
929 if (jump_regex_cmd_up) {
930 if (jump_regex_cmd_up->AddRegexCommand(
"^\\*(.*)$",
931 "thread jump --addr %1") &&
932 jump_regex_cmd_up->AddRegexCommand(
"^([0-9]+)$",
933 "thread jump --line %1") &&
934 jump_regex_cmd_up->AddRegexCommand(
"^([^:]+):([0-9]+)$",
935 "thread jump --file %1 --line %2") &&
936 jump_regex_cmd_up->AddRegexCommand(
"^([+\\-][0-9]+)$",
937 "thread jump --by %1")) {
939 m_command_dict[std::string(jump_regex_cmd_sp->GetCommandName())] =
946 const char *cmd_str,
bool include_aliases,
StringList &matches,
951 if (include_aliases) {
960 Args &path,
bool leaf_is_command,
Status &result) {
963 auto get_multi_or_report_error =
970 if (!cmd_sp->IsUserCommand()) {
992 if (num_args == 1 && leaf_is_command) {
1002 get_multi_or_report_error(cur_cmd_sp, cur_name);
1003 if (cur_as_multi ==
nullptr)
1006 size_t num_path_elements = num_args - (leaf_is_command ? 1 : 0);
1007 for (
size_t cursor = 1; cursor < num_path_elements && cur_as_multi !=
nullptr;
1011 cur_as_multi = get_multi_or_report_error(cur_cmd_sp, cur_name);
1013 return cur_as_multi;
1022 std::string cmd = std::string(cmd_str);
1027 command_sp = pos->second;
1033 command_sp = alias_pos->second;
1039 command_sp = pos->second;
1045 command_sp = pos->second;
1048 if (!exact && !command_sp) {
1055 if (matches ==
nullptr)
1056 matches = &local_matches;
1058 unsigned int num_cmd_matches = 0;
1059 unsigned int num_alias_matches = 0;
1060 unsigned int num_user_matches = 0;
1061 unsigned int num_user_mw_matches = 0;
1069 *matches, descriptions);
1072 if (num_cmd_matches == 1) {
1076 real_match_sp = pos->second;
1081 *matches, descriptions);
1084 if (num_alias_matches == 1) {
1088 alias_match_sp = alias_pos->second;
1093 *matches, descriptions);
1096 if (num_user_matches == 1) {
1102 user_match_sp = pos->second;
1110 if (num_user_mw_matches == 1) {
1116 user_mw_match_sp = pos->second;
1122 if (num_user_matches + num_user_mw_matches + num_cmd_matches +
1123 num_alias_matches ==
1125 if (num_cmd_matches)
1126 return real_match_sp;
1127 else if (num_alias_matches)
1128 return alias_match_sp;
1129 else if (num_user_mw_matches)
1130 return user_mw_match_sp;
1132 return user_match_sp;
1134 }
else if (matches && command_sp) {
1147 lldbassert((
this == &cmd_sp->GetCommandInterpreter()) &&
1148 "tried to add a CommandObject from a different interpreter");
1153 cmd_sp->SetIsUserCommand(
false);
1155 std::string name_sstr(name);
1158 if (!can_replace || !name_iter->second->IsRemovable())
1160 name_iter->second = cmd_sp;
1172 lldbassert((
this == &cmd_sp->GetCommandInterpreter()) &&
1173 "tried to add a CommandObject from a different interpreter");
1175 result.
SetErrorString(
"can't use the empty string for a command name");
1187 "user command \"{0}\" already exists and force replace was not set "
1188 "by --overwrite or 'settings set interpreter.require-overwrite "
1193 if (cmd_sp->IsMultiwordObject()) {
1196 "can't replace explicitly non-removable multi-word command");
1200 if (!
m_user_dict[std::string(name)]->IsRemovable()) {
1201 result.
SetErrorString(
"can't replace explicitly non-removable command");
1207 cmd_sp->SetIsUserCommand(
true);
1209 if (cmd_sp->IsMultiwordObject())
1218 bool include_aliases)
const {
1220 Args cmd_words(cmd_str);
1222 if (cmd_str.empty())
1239 for (
size_t i = 1; i < end; ++i) {
1240 if (!cmd_obj_sp->IsMultiwordObject()) {
1265 matches, descriptions)
1271 std::string cmd_str(cmd);
1273 auto found_elem = map.find(std::string(cmd));
1274 if (found_elem == map.end())
1297 StringList *matches_ptr = matches ? matches : &tmp_list;
1300 cmd_str, *matches_ptr);
1310 std::string &full_name)
const {
1314 full_name.assign(std::string(cmd));
1318 size_t num_alias_matches;
1321 if (num_alias_matches == 1) {
1324 const bool include_aliases =
false;
1325 const bool exact =
false;
1327 GetCommandSP(cmd, include_aliases, exact, ®ular_matches));
1328 if (cmd_obj_sp || regular_matches.
GetSize() > 0)
1354 llvm::StringRef args_string) {
1355 if (command_obj_sp.get())
1356 lldbassert((
this == &command_obj_sp->GetCommandInterpreter()) &&
1357 "tried to add a CommandObject from a different interpreter");
1359 std::unique_ptr<CommandAlias> command_alias_up(
1360 new CommandAlias(*
this, command_obj_sp, args_string, alias_name));
1362 if (command_alias_up && command_alias_up->IsValid()) {
1365 return command_alias_up.release();
1383 if (force || pos->second->IsRemovable()) {
1394 CommandObject::CommandMap::iterator pos =
1404 CommandObject::CommandMap::iterator pos =
1414 uint32_t cmd_types) {
1415 llvm::StringRef help_prologue(
GetDebugger().GetIOHandlerHelpPrologue());
1416 if (!help_prologue.empty()) {
1421 CommandObject::CommandMap::const_iterator pos;
1430 (pos->first.compare(0, 1,
"_") == 0))
1434 pos->second->GetHelp(), max_len);
1442 "Current command abbreviations "
1443 "(type '%shelp command alias' for more info):\n",
1451 alias_pos->second->GetHelp(), max_len);
1463 pos->second->GetHelp(), max_len);
1470 result.
AppendMessage(
"Current user-defined container commands:");
1475 pos->second->GetHelp(), max_len);
1481 "For more information on any command, type '%shelp <command-name>'.\n",
1486 llvm::StringRef &command_string) {
1492 size_t start = command_string.find_first_not_of(
k_white_space);
1496 if (start != std::string::npos) {
1499 if (end == std::string::npos)
1500 end = command_string.size();
1501 std::string cmd_word =
1502 std::string(command_string.substr(start, end - start));
1504 if (cmd_obj ==
nullptr)
1514 cmd_obj = sub_cmd_obj;
1526 end >= command_string.size())
1529 start = command_string.find_first_not_of(
k_white_space, end);
1535 command_string = command_string.substr(end);
1540 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
1544 if (pos == std::string::npos)
1553 const size_t s_len = s.size();
1555 while (offset < s_len) {
1556 size_t pos = s.find(
"--", offset);
1557 if (pos == std::string::npos)
1560 if (llvm::isSpace(s[pos - 1])) {
1563 if ((pos + 2 >= s_len) || llvm::isSpace(s[pos + 2])) {
1570 return std::string::npos;
1574 std::string &suffix,
char "e_char) {
1579 bool result =
false;
1582 if (!command_string.empty()) {
1583 const char first_char = command_string[0];
1584 if (first_char ==
'\'' || first_char ==
'"') {
1585 quote_char = first_char;
1586 const size_t end_quote_pos = command_string.find(quote_char, 1);
1587 if (end_quote_pos == std::string::npos) {
1588 command.swap(command_string);
1589 command_string.erase();
1591 command.assign(command_string, 1, end_quote_pos - 1);
1592 if (end_quote_pos + 1 < command_string.size())
1593 command_string.erase(0, command_string.find_first_not_of(
1596 command_string.erase();
1599 const size_t first_space_pos =
1601 if (first_space_pos == std::string::npos) {
1602 command.swap(command_string);
1603 command_string.erase();
1605 command.assign(command_string, 0, first_space_pos);
1606 command_string.erase(0, command_string.find_first_not_of(
1613 if (!command.empty()) {
1615 if (command[0] !=
'-' && command[0] !=
'_') {
1617 if (pos > 0 && pos != std::string::npos) {
1618 suffix.assign(command.begin() + pos, command.end());
1628 llvm::StringRef alias_name, std::string &raw_input_string,
1631 Args cmd_args(raw_input_string);
1635 if (!alias_cmd_obj || !alias_cmd_obj->
IsAlias()) {
1636 alias_result.clear();
1637 return alias_cmd_obj;
1639 std::pair<CommandObjectSP, OptionArgVectorSP> desugared =
1642 alias_cmd_obj = desugared.first.get();
1643 std::string alias_name_str = std::string(alias_name);
1646 cmd_args.
Unshift(alias_name_str);
1650 if (!option_arg_vector_sp.get()) {
1651 alias_result = std::string(result_str.
GetString());
1652 return alias_cmd_obj;
1659 for (
const auto &entry : *option_arg_vector) {
1660 std::tie(option, value_type, value) = entry;
1662 result_str.
Printf(
" %s", value.c_str());
1666 result_str.
Printf(
" %s", option.c_str());
1674 result_str.
Printf(
"%s", value.c_str());
1678 "need at least %d arguments to use "
1684 size_t strpos = raw_input_string.find(entry.
c_str());
1686 if (strpos != std::string::npos) {
1687 const size_t start_fudge = quote_char ==
'\0' ? 0 : 1;
1688 const size_t len_fudge = quote_char ==
'\0' ? 0 : 2;
1691 if (strpos < start_fudge) {
1692 result.
AppendError(
"Unmatched quote at command beginning.");
1695 llvm::StringRef arg_text = entry.
ref();
1696 if (strpos - start_fudge + arg_text.size() + len_fudge >
1697 raw_input_string.size()) {
1698 result.
AppendError(
"Unmatched quote at command end.");
1701 raw_input_string = raw_input_string.erase(
1702 strpos - start_fudge,
1705 if (quote_char ==
'\0')
1708 result_str.
Printf(
"%c%s%c", quote_char, entry.
c_str(), quote_char);
1712 alias_result = std::string(result_str.
GetString());
1713 return alias_cmd_obj;
1724 size_t start_backtick;
1726 while ((start_backtick = command.find(
'`', pos)) != std::string::npos) {
1731 if (start_backtick > 0 && command[start_backtick - 1] ==
'\\') {
1734 command.erase(start_backtick - 1, 1);
1736 pos = start_backtick;
1740 const size_t expr_content_start = start_backtick + 1;
1741 const size_t end_backtick = command.find(
'`', expr_content_start);
1743 if (end_backtick == std::string::npos) {
1748 if (end_backtick == expr_content_start) {
1750 command.erase(start_backtick, 2);
1754 std::string expr_str(command, expr_content_start,
1755 end_backtick - expr_content_start);
1761 command.erase(start_backtick, end_backtick - start_backtick + 1);
1762 command.insert(start_backtick, std::string(expr_str));
1763 pos = start_backtick + expr_str.size();
1791 expr_result_valobj_sp, options);
1795 if (expr_result_valobj_sp)
1796 expr_result_valobj_sp =
1797 expr_result_valobj_sp->GetQualifiedRepresentationIfAvailable(
1798 expr_result_valobj_sp->GetDynamicValueType(),
true);
1799 if (expr_result_valobj_sp->ResolveValue(scalar)) {
1802 const bool show_type =
false;
1803 scalar.
GetValue(value_strm, show_type);
1804 size_t value_string_size = value_strm.
GetSize();
1805 if (value_string_size) {
1806 expr_str = value_strm.
GetData();
1808 error.SetErrorStringWithFormat(
"expression value didn't result "
1809 "in a scalar value for the "
1814 error.SetErrorStringWithFormat(
"expression value didn't result "
1815 "in a scalar value for the "
1826 if (expr_result_valobj_sp)
1827 error = expr_result_valobj_sp->GetError();
1829 if (
error.Success()) {
1831 error.SetErrorString(result +
"for the expression '" + expr_str +
"'");
1842 bool status =
HandleCommand(command_line, lazy_add_to_history, result);
1850 bool force_repeat_command) {
1851 std::string command_string(command_line);
1852 std::string original_command_string(command_line);
1855 llvm::PrettyStackTraceFormat stack_trace(
"HandleCommand(command = \"%s\")",
1858 LLDB_LOGF(log,
"Processing command: %s", command_line);
1866 bool add_to_history;
1870 add_to_history = (lazy_add_to_history ==
eLazyBoolYes);
1878 transcript_item = std::make_shared<StructuredData::Dictionary>();
1879 transcript_item->AddStringItem(
"command", command_line);
1880 transcript_item->AddIntegerItem(
1881 "timestampInEpochSeconds",
1882 std::chrono::duration_cast<std::chrono::seconds>(
1883 std::chrono::system_clock::now().time_since_epoch())
1888 bool empty_command =
false;
1889 bool comment_command =
false;
1890 if (command_string.empty())
1891 empty_command =
true;
1893 const char *k_space_characters =
"\t\n\v\f\r ";
1895 size_t non_space = command_string.find_first_not_of(k_space_characters);
1898 if (non_space == std::string::npos)
1899 empty_command =
true;
1901 comment_command =
true;
1903 llvm::StringRef search_str(command_string);
1904 search_str = search_str.drop_front(non_space);
1906 add_to_history =
false;
1907 command_string = std::string(*hist_str);
1908 original_command_string = std::string(*hist_str);
1911 command_string.c_str());
1917 if (empty_command) {
1929 command_string = command_line;
1930 original_command_string = command_line;
1936 add_to_history =
false;
1937 }
else if (comment_command) {
1977 llvm::StringRef command_name = cmd_obj ? cmd_obj->
GetCommandName() :
"<not found>";
1978 LLDB_LOGF(log,
"HandleCommand, cmd_obj : '%s'", command_name.str().c_str());
1979 LLDB_LOGF(log,
"HandleCommand, (revised) command_string: '%s'",
1980 command_string.c_str());
1981 const bool wants_raw_input =
1983 LLDB_LOGF(log,
"HandleCommand, wants_raw_input:'%s'",
1984 wants_raw_input ?
"True" :
"False");
1992 if (cmd_obj !=
nullptr) {
1993 bool generate_repeat_command = add_to_history;
1997 generate_repeat_command |= empty_command;
2002 generate_repeat_command |= force_repeat_command;
2003 if (generate_repeat_command) {
2004 Args command_args(command_string);
2005 std::optional<std::string> repeat_command =
2007 if (repeat_command) {
2008 LLDB_LOGF(log,
"Repeat command: %s", repeat_command->data());
2018 std::string remainder;
2019 const std::size_t actual_cmd_name_len = cmd_obj->
GetCommandName().size();
2020 if (actual_cmd_name_len < command_string.length())
2021 remainder = command_string.substr(actual_cmd_name_len);
2025 if (pos != 0 && pos != std::string::npos)
2026 remainder.erase(0, pos);
2029 log,
"HandleCommand, command line after removing command name(s): '%s'",
2035 if (transcript_item) {
2036 transcript_item->AddStringItem(
"commandName", cmd_obj->
GetCommandName());
2037 transcript_item->AddStringItem(
"commandArguments", remainder);
2041 cmd_obj->
Execute(remainder.c_str(), result);
2044 LLDB_LOGF(log,
"HandleCommand, command %s",
2045 (result.
Succeeded() ?
"succeeded" :
"did not succeed"));
2050 if (transcript_item) {
2054 transcript_item->AddStringItem(
"output", result.
GetOutputData());
2055 transcript_item->AddStringItem(
"error", result.
GetErrorData());
2056 transcript_item->AddFloatItem(
"durationInSeconds",
2057 execute_time.
get().count());
2064 bool look_for_subcommand =
false;
2070 bool include_aliases =
true;
2081 &new_matches, &new_descriptions);
2088 look_for_subcommand =
true;
2103 if (command_object) {
2116 if (!first_arg.empty()) {
2121 request.
AddCompletion(*hist_str,
"Previous command history event",
2130std::optional<std::string>
2133 return std::nullopt;
2135 for (
int i = s - 1; i >= 0; --i) {
2137 if (entry.consume_front(line))
2140 return std::nullopt;
2144 EventSP prompt_change_event_sp(
2155 return default_answer;
2188 const char *alias_name,
2190 std::string &raw_input_string,
2198 std::string alias_name_str = alias_name;
2200 cmd_args.
Unshift(alias_name_str);
2206 if (option_arg_vector_sp.get()) {
2207 if (wants_raw_input) {
2211 size_t pos = raw_input_string.find(
" -- ");
2212 if (pos == std::string::npos) {
2214 raw_input_string.insert(0,
" -- ");
2220 std::vector<bool> used(old_size + 1,
false);
2227 for (
const auto &option_entry : *option_arg_vector) {
2228 std::tie(option, value_type, value) = option_entry;
2230 if (!wants_raw_input || (value !=
"--")) {
2254 "need at least %d arguments to use "
2262 if (strpos != std::string::npos) {
2263 raw_input_string = raw_input_string.erase(
2276 for (
auto entry : llvm::enumerate(cmd_args.
entries())) {
2277 if (!used[entry.index()] && !wants_raw_input)
2290 if (wants_raw_input) {
2306 const char *cptr = in_string;
2309 if (cptr[0] ==
'%') {
2313 if (isdigit(cptr[0])) {
2314 const char *start = cptr;
2315 while (isdigit(cptr[0]))
2320 if (cptr[0] ==
'\0')
2321 position = atoi(start);
2329 llvm::StringRef suffix = {}) {
2330 std::string init_file_name =
".lldbinit";
2331 if (!suffix.empty()) {
2332 init_file_name.append(
"-");
2333 init_file_name.append(suffix.str());
2337 llvm::sys::path::append(init_file, init_file_name);
2347 language = *main_repl_language;
2352 std::string init_file_name =
2353 (llvm::Twine(
".lldbinit-") +
2355 llvm::Twine(
"-repl"))
2358 llvm::sys::path::append(init_file, init_file_name);
2363 llvm::StringRef s =
".lldbinit";
2364 init_file.assign(s.begin(), s.end());
2396 llvm::SmallString<128> init_file;
2406 switch (should_load) {
2414 llvm::SmallString<128> home_init_file;
2416 if (llvm::sys::path::parent_path(init_file) ==
2417 llvm::sys::path::parent_path(home_init_file)) {
2437 llvm::SmallString<128> init_file;
2442 if (init_file.empty())
2446 llvm::StringRef program_name =
2447 HostInfo::GetProgramFileSpec().GetFilename().GetStringRef();
2448 llvm::SmallString<128> program_init_file;
2451 init_file = program_init_file;
2458#ifdef LLDB_GLOBAL_INIT_DIRECTORY
2460 FileSpec init_file(LLDB_GLOBAL_INIT_DIRECTORY);
2474 return prefix ==
nullptr ?
"" : prefix;
2479 if (prefer_target_platform) {
2493 TargetSP target_sp = exe_ctx.GetTargetSP();
2497 ProcessSP process_sp(target_sp->GetProcessSP());
2504 for (
const auto &thread_sp : process_sp->GetThreadList().Threads()) {
2505 StopInfoSP stop_info = thread_sp->GetStopInfo();
2513 const StopReason reason = stop_info->GetStopReason();
2520 const auto stop_signal =
static_cast<int32_t
>(stop_info->GetValue());
2522 if (!signals_sp || !signals_sp->SignalIsValid(stop_signal))
2526 const auto sigint_num = signals_sp->GetSignalNumberFromName(
"SIGINT");
2527 const auto sigstop_num = signals_sp->GetSignalNumberFromName(
"SIGSTOP");
2528 if ((stop_signal != sigint_num) && (stop_signal != sigstop_num))
2551 size_t num_lines = commands.
GetSize();
2563 for (
size_t idx = 0; idx < num_lines; idx++) {
2592 if (!success || !tmp_result.
Succeeded()) {
2594 if (error_msg.empty())
2595 error_msg =
"<unknown error>.\n";
2598 "Aborting reading of commands after command #%" PRIu64
2599 ": '%s' failed with %s",
2600 (uint64_t)idx, cmd, error_msg.str().c_str());
2605 "Command #%" PRIu64
" '%s' failed with %s", (uint64_t)idx + 1, cmd,
2606 error_msg.str().c_str());
2627 if (idx != num_lines - 1)
2629 "Aborting reading of commands after command #%" PRIu64
2630 ": '%s' continued the target.\n",
2631 (uint64_t)idx + 1, cmd);
2634 " '%s' continued the target.\n",
2635 (uint64_t)idx + 1, cmd);
2647 if (idx != num_lines - 1)
2649 "Aborting reading of commands after command #%" PRIu64
2650 ": '%s' stopped with a signal or exception.\n",
2651 (uint64_t)idx + 1, cmd);
2654 "Command #%" PRIu64
" '%s' stopped with a signal or exception.\n",
2655 (uint64_t)idx + 1, cmd);
2693 "Error reading commands from file %s - file not found.\n",
2698 std::string cmd_file_path = cmd_file.
GetPath();
2699 auto input_file_up =
2701 if (!input_file_up) {
2702 std::string
error = llvm::toString(input_file_up.takeError());
2704 "error: an error occurred read file '{0}': {1}\n", cmd_file_path,
2705 llvm::fmt_consume(input_file_up.takeError()));
2708 FileSP input_file_sp =
FileSP(std::move(input_file_up.get()));
2795 cmd_file_path.c_str());
2811 debugger.
GetPrompt(), llvm::StringRef(),
2841 llvm::StringRef prefix,
2842 llvm::StringRef help_text) {
2845 size_t line_width_max = max_columns - prefix.size();
2846 if (line_width_max < 16)
2847 line_width_max = help_text.size() + prefix.size();
2850 bool prefixed_yet =
false;
2852 if (help_text.empty())
2853 help_text =
"No help text";
2854 while (!help_text.empty()) {
2856 if (!prefixed_yet) {
2858 prefixed_yet =
true;
2863 llvm::StringRef this_line = help_text.substr(0, line_width_max);
2866 std::size_t first_newline = this_line.find_first_of(
"\n");
2869 std::size_t last_space = llvm::StringRef::npos;
2870 if (this_line.size() != help_text.size())
2871 last_space = this_line.find_last_of(
" \t");
2874 this_line = this_line.substr(0, std::min(first_newline, last_space));
2879 help_text = help_text.drop_front(this_line.size()).ltrim();
2885 llvm::StringRef word_text,
2886 llvm::StringRef separator,
2887 llvm::StringRef help_text,
2888 size_t max_word_len) {
2890 prefix_stream.
Printf(
" %-*s %*s ", (
int)max_word_len, word_text.data(),
2891 (
int)separator.size(), separator.data());
2896 llvm::StringRef separator,
2897 llvm::StringRef help_text,
2898 uint32_t max_word_len) {
2899 int indent_size = max_word_len + separator.size() + 2;
2904 text_strm.
Printf(
"%-*s ", (
int)max_word_len, word_text.data());
2905 text_strm << separator <<
" " << help_text;
2909 llvm::StringRef text = text_strm.
GetString();
2911 uint32_t chars_left = max_columns;
2913 auto nextWordLength = [](llvm::StringRef S) {
2914 size_t pos = S.find(
' ');
2915 return pos == llvm::StringRef::npos ? S.size() : pos;
2918 while (!text.empty()) {
2919 if (text.front() ==
'\n' ||
2920 (text.front() ==
' ' && nextWordLength(text.ltrim(
' ')) > chars_left)) {
2923 chars_left = max_columns - indent_size;
2924 if (text.front() ==
'\n')
2925 text = text.drop_front();
2927 text = text.ltrim(
' ');
2931 text = text.drop_front();
2940 llvm::StringRef search_word,
StringList &commands_found,
2942 for (
const auto &pair : command_map) {
2943 llvm::StringRef command_name = pair.first;
2946 const bool search_short_help =
true;
2947 const bool search_long_help =
false;
2948 const bool search_syntax =
false;
2949 const bool search_options =
false;
2950 if (command_name.contains_insensitive(search_word) ||
2952 search_long_help, search_syntax,
2961 multiword_cmd->GetSubcommandDictionary());
2962 for (
const auto &subcommand_name : subcommands_found) {
2963 std::string qualified_name =
2964 (command_name +
" " + subcommand_name).str();
2974 bool search_builtin_commands,
2975 bool search_user_commands,
2976 bool search_alias_commands,
2977 bool search_user_mw_commands) {
2978 CommandObject::CommandMap::const_iterator pos;
2980 if (search_builtin_commands)
2984 if (search_user_commands)
2988 if (search_user_mw_commands)
2992 if (search_alias_commands)
3047 bool was_interrupted =
3050 return was_interrupted;
3054 llvm::StringRef str,
3060 bool had_output = !str.empty();
3061 while (!str.empty()) {
3062 llvm::StringRef line;
3063 std::tie(line, str) = str.split(
'\n');
3065 std::lock_guard<std::recursive_mutex> guard(io_handler.
GetOutputMutex());
3066 stream->Write(line.data(), line.size());
3067 stream->Write(
"\n", 1);
3071 std::lock_guard<std::recursive_mutex> guard(io_handler.
GetOutputMutex());
3074 stream->Printf(
"\n... Interrupted.\n");
3079 llvm::StringRef line,
const Flags &io_handler_flags)
const {
3083 llvm::StringRef command = line.trim();
3084 if (command.empty())
3094 std::string &line) {
3100 const bool allow_repeats =
3103 if (!is_interactive && !allow_repeats) {
3112 if (!is_interactive) {
3117 std::lock_guard<std::recursive_mutex> guard(io_handler.
GetOutputMutex());
3119 "%s%s\n", io_handler.
GetPrompt(), line.c_str());
3126 bool pushed_exe_ctx =
false;
3129 pushed_exe_ctx =
true;
3131 auto finalize = llvm::make_scope_exit([
this, pushed_exe_ctx]() {
3140 if ((result.Succeeded() &&
3146 if (!result.GetImmediateOutputStream()) {
3147 llvm::StringRef output = result.GetOutputData();
3152 if (!result.GetImmediateErrorStream()) {
3153 llvm::StringRef
error = result.GetErrorData();
3160 switch (result.GetStatus()) {
3189 result.GetDidChangeProcessState() &&
3214 if (script_interpreter) {
3223 if (output_file == std::nullopt || output_file->empty()) {
3224 std::string now = llvm::to_string(std::chrono::system_clock::now());
3225 std::replace(now.begin(), now.end(),
' ',
'_');
3227 std::replace(now.begin(), now.end(),
':',
'-');
3228 const std::string file_name =
"lldb_session_" + now +
".log";
3233 save_location = HostInfo::GetGlobalTempDir();
3237 output_file = save_location.
GetPath();
3240 auto error_out = [&](llvm::StringRef error_message, std::string description) {
3242 output_file, description);
3244 "Failed to save session's transcripts to {0}!", *output_file);
3255 return error_out(
"Unable to create file",
3256 llvm::toString(opened_file.takeError()));
3258 FileUP file = std::move(opened_file.get());
3265 return error_out(
"Unable to write to destination file",
3266 "Bytes written do not match transcript size.");
3270 output_file->c_str());
3274 error = file->GetFileSpec(
const_cast<FileSpec &
>(file_spec));
3275 if (
error.Success()) {
3301 llvm::StringRef(prompt),
3308 if (io_handler_sp) {
3309 io_handler_sp->SetUserData(baton);
3320 llvm::StringRef(prompt),
3327 if (io_handler_sp) {
3328 io_handler_sp->SetUserData(baton);
3388 bool force_create =
true;
3416 std::string scratch_command(command_line);
3420 bool wants_raw_input =
false;
3421 std::string next_word;
3425 char quote_char =
'\0';
3428 if (cmd_obj ==
nullptr) {
3429 std::string full_name;
3432 bool is_real_command =
3433 (!is_alias) || (cmd_obj !=
nullptr && !cmd_obj->
IsAlias());
3434 if (!is_real_command) {
3436 std::string alias_result;
3439 revised_command_line.
Printf(
"%s", alias_result.c_str());
3446 revised_command_line.
Printf(
"%s", cmd_name.str().c_str());
3449 revised_command_line.
Printf(
"%s", next_word.c_str());
3460 revised_command_line.
Clear();
3461 revised_command_line.
Printf(
"%s", sub_cmd_name.str().c_str());
3462 cmd_obj = sub_cmd_obj;
3466 revised_command_line.
Printf(
" %c%s%s%c", quote_char,
3467 next_word.c_str(), suffix.c_str(),
3470 revised_command_line.
Printf(
" %s%s", next_word.c_str(),
3476 revised_command_line.
Printf(
" %c%s%s%c", quote_char,
3477 next_word.c_str(), suffix.c_str(),
3480 revised_command_line.
Printf(
" %s%s", next_word.c_str(),
3486 if (cmd_obj ==
nullptr) {
3487 const size_t num_matches = matches.
GetSize();
3490 error_msg.
Printf(
"Ambiguous command '%s'. Possible matches:\n",
3493 for (uint32_t i = 0; i < num_matches; ++i) {
3507 if (!suffix.empty()) {
3509 "command '%s' did not recognize '%s%s%s' as valid (subcommand "
3510 "might be invalid).\n",
3512 next_word.empty() ?
"" : next_word.c_str(),
3513 next_word.empty() ?
" -- " :
" ", suffix.c_str());
3519 if (!suffix.empty()) {
3520 switch (suffix[0]) {
3525 if (command_options &&
3527 std::string gdb_format_option(
"--gdb-format=");
3528 gdb_format_option += (suffix.c_str() + 1);
3530 std::string cmd = std::string(revised_command_line.
GetString());
3532 if (arg_terminator_idx != std::string::npos) {
3535 gdb_format_option.append(1,
' ');
3536 cmd.insert(arg_terminator_idx, gdb_format_option);
3537 revised_command_line.
Clear();
3540 revised_command_line.
Printf(
" %s", gdb_format_option.c_str());
3542 if (wants_raw_input &&
3547 "the '%s' command doesn't support the --gdb-format option\n",
3556 "unknown command shorthand suffix: '%s'\n", suffix.c_str());
3561 if (scratch_command.empty())
3565 if (!scratch_command.empty())
3566 revised_command_line.
Printf(
" %s", scratch_command.c_str());
3568 if (cmd_obj !=
nullptr)
3569 command_line = std::string(revised_command_line.
GetString());
3575 llvm::json::Object stats;
3577 stats.try_emplace(command_usage.getKey(), command_usage.getValue());
static const char * k_valid_command_chars
static constexpr const char * InitFileWarning
static size_t FindArgumentTerminator(const std::string &s)
#define REGISTER_COMMAND_OBJECT(NAME, CLASS)
static void StripLeadingSpaces(std::string &s)
static void GetHomeREPLInitFile(llvm::SmallVectorImpl< char > &init_file, LanguageType language)
static void GetCwdInitFile(llvm::SmallVectorImpl< char > &init_file)
static const char * k_white_space
static void GetHomeInitFile(llvm::SmallVectorImpl< char > &init_file, llvm::StringRef suffix={})
@ eHandleCommandFlagAllowRepeats
@ eHandleCommandFlagStopOnCrash
@ eHandleCommandFlagEchoCommentCommand
@ eHandleCommandFlagStopOnError
@ eHandleCommandFlagStopOnContinue
@ eHandleCommandFlagPrintErrors
@ eHandleCommandFlagEchoCommand
@ eHandleCommandFlagPrintResult
static bool ExtractCommand(std::string &command_string, std::string &command, std::string &suffix, char "e_char)
static llvm::raw_ostream & error(Stream &strm)
#define INTERRUPT_REQUESTED(debugger,...)
This handy define will keep you from having to generate a report for the interruption by hand.
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
#define LLDB_SCOPED_TIMER()
#define LLDB_SCOPED_TIMERF(...)
A command line argument class.
void Unshift(llvm::StringRef arg_str, char quote_char='\0')
Inserts a class owned copy of arg_str at the beginning of the argument vector.
void Shift()
Shifts the first argument C string value of the array off the argument array.
void SetArguments(size_t argc, const char **argv)
Sets the argument vector value, optionally copying all arguments into an internal buffer.
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
llvm::ArrayRef< ArgEntry > entries() const
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
const char ** GetConstArgumentVector() const
Gets the argument vector.
void Clear()
Clear the arguments.
An event broadcasting class.
void SetEventName(uint32_t event_mask, const char *name)
Set the name for an event bit.
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
void CheckInWithManager()
OptionArgVectorSP GetOptionArguments() const
void SetHelp(llvm::StringRef str) override
void SetHelpLong(llvm::StringRef str) override
std::optional< llvm::StringRef > FindString(llvm::StringRef input_str) const
static const char g_repeat_char
llvm::StringRef GetStringAtIndex(size_t idx) const
void AppendString(llvm::StringRef str, bool reject_if_dupe=true)
bool GetSpawnThread() const
void SetStopOnContinue(bool stop_on_continue)
void SetSilent(bool silent)
bool GetAutoHandleEvents() const
void SetPrintErrors(bool print_errors)
LazyBool m_add_to_history
bool GetStopOnCrash() const
bool GetAddToHistory() const
bool GetStopOnContinue() const
bool GetPrintResults() const
void SetStopOnError(bool stop_on_error)
bool GetStopOnError() const
bool GetEchoCommands() const
LazyBool m_echo_comment_commands
LazyBool m_stop_on_continue
bool IsResult(lldb::CommandInterpreterResult result)
void SetResult(lldb::CommandInterpreterResult result)
void IncrementNumberOfErrors()
CommandUsageMap m_command_usages
bool m_skip_lldbinit_files
bool GetSaveTranscript() const
bool EchoCommandNonInteractive(llvm::StringRef line, const Flags &io_handler_flags) const
void UpdatePrompt(llvm::StringRef prompt)
bool IOHandlerInterrupt(IOHandler &io_handler) override
lldb::IOHandlerSP m_command_io_handler_sp
void SetPromptOnQuit(bool enable)
void SourceInitFileHome(CommandReturnObject &result, bool is_repl)
We will first see if there is an application specific ".lldbinit" file whose name is "~/....
std::optional< std::string > GetAutoSuggestionForCommand(llvm::StringRef line)
Returns the auto-suggestion string that should be added to the given command line.
void IOHandlerInputComplete(IOHandler &io_handler, std::string &line) override
Called when a line or lines have been retrieved.
llvm::json::Value GetStatistics()
void LoadCommandDictionary()
std::stack< ExecutionContext > m_overriden_exe_contexts
bool GetStopCmdSourceOnError() const
void OutputFormattedHelpText(Stream &strm, llvm::StringRef prefix, llvm::StringRef help_text)
bool Confirm(llvm::StringRef message, bool default_answer)
bool UserMultiwordCommandExists(llvm::StringRef cmd) const
Determine whether a root-level user multiword command with this name exists.
static llvm::StringRef GetStaticBroadcasterClass()
static const char * g_no_argument
void SetEchoCommands(bool enable)
bool RemoveAlias(llvm::StringRef alias_name)
void SetSaveSessionDirectory(llvm::StringRef path)
bool HasAliasOptions() const
void SourceInitFile(FileSpec file, CommandReturnObject &result)
CommandAlias * AddAlias(llvm::StringRef alias_name, lldb::CommandObjectSP &command_obj_sp, llvm::StringRef args_string=llvm::StringRef())
int GetCommandNamesMatchingPartialString(const char *cmd_cstr, bool include_aliases, StringList &matches, StringList &descriptions)
void FindCommandsForApropos(llvm::StringRef word, StringList &commands_found, StringList &commands_help, bool search_builtin_commands, bool search_user_commands, bool search_alias_commands, bool search_user_mw_commands)
CommandObject * GetCommandObject(llvm::StringRef cmd, StringList *matches=nullptr, StringList *descriptions=nullptr) const
std::atomic< CommandHandlingState > m_command_state
Status PreprocessCommand(std::string &command)
CommandObject::CommandMap m_alias_dict
CommandObject * ResolveCommandImpl(std::string &command_line, CommandReturnObject &result)
CommandObject::CommandMap m_command_dict
void SetOpenTranscriptInEditor(bool enable)
void HandleCompletion(CompletionRequest &request)
CommandInterpreterRunResult m_result
bool GetSpaceReplPrompts() const
void ResolveCommand(const char *command_line, CommandReturnObject &result)
bool SetQuitExitCode(int exit_code)
Sets the exit code for the quit command.
CommandInterpreterRunResult RunCommandInterpreter(CommandInterpreterRunOptions &options)
bool HandleCommand(const char *command_line, LazyBool add_to_history, const ExecutionContext &override_context, CommandReturnObject &result)
bool DidProcessStopAbnormally() const
CommandObject::CommandMap m_user_dict
std::optional< int > m_quit_exit_code
ExecutionContext GetExecutionContext() const
const CommandObject::CommandMap & GetUserCommands() const
CommandObject * GetUserCommandObject(llvm::StringRef cmd, StringList *matches=nullptr, StringList *descriptions=nullptr) const
void SourceInitFileGlobal(CommandReturnObject &result)
@ eBroadcastBitQuitCommandReceived
@ eBroadcastBitResetPrompt
@ eBroadcastBitThreadShouldExit
bool GetAliasFullName(llvm::StringRef cmd, std::string &full_name) const
CommandObjectMultiword * VerifyUserMultiwordCmdPath(Args &path, bool leaf_is_command, Status &result)
Look up the command pointed to by path encoded in the arguments of the incoming command object.
bool GetEchoCommentCommands() const
bool WasInterrupted() const
void HandleCompletionMatches(CompletionRequest &request)
Status AddUserCommand(llvm::StringRef name, const lldb::CommandObjectSP &cmd_sp, bool can_replace)
bool AddCommand(llvm::StringRef name, const lldb::CommandObjectSP &cmd_sp, bool can_replace)
void PrintCommandOutput(IOHandler &io_handler, llvm::StringRef str, bool is_stdout)
int m_iohandler_nesting_level
bool GetOpenTranscriptInEditor() const
bool AliasExists(llvm::StringRef cmd) const
Determine whether an alias command with this name exists.
bool GetExpandRegexAliases() const
int GetOptionArgumentPosition(const char *in_string)
Picks the number out of a string of the form "%NNN", otherwise return 0.
bool HasUserMultiwordCommands() const
void StartHandlingCommand()
void GetHelp(CommandReturnObject &result, uint32_t types=eCommandTypesAllThem)
bool CommandExists(llvm::StringRef cmd) const
Determine whether a root level, built-in command with this name exists.
bool GetPromptOnQuit() const
std::string m_repeat_command
const char * GetCommandPrefix()
bool SaveTranscript(CommandReturnObject &result, std::optional< std::string > output_file=std::nullopt)
Save the current debugger session transcript to a file on disk.
int GetQuitExitCode(bool &exited) const
Returns the exit code that the user has specified when running the 'quit' command.
lldb::PlatformSP GetPlatform(bool prefer_target_platform)
bool GetRequireCommandOverwrite() const
void RestoreExecutionContext()
void GetPythonCommandsFromIOHandler(const char *prompt, IOHandlerDelegate &delegate, void *baton=nullptr)
lldb::CommandObjectSP GetCommandSPExact(llvm::StringRef cmd, bool include_aliases=false) const
CommandInterpreter(Debugger &debugger, bool synchronous_execution)
const CommandAlias * GetAlias(llvm::StringRef alias_name) const
void FinishHandlingCommand()
bool RemoveUser(llvm::StringRef alias_name)
void GetLLDBCommandsFromIOHandler(const char *prompt, IOHandlerDelegate &delegate, void *baton=nullptr)
lldb::CommandObjectSP GetCommandSP(llvm::StringRef cmd, bool include_aliases=true, bool exact=true, StringList *matches=nullptr, StringList *descriptions=nullptr) const
void OutputHelpText(Stream &stream, llvm::StringRef command_word, llvm::StringRef separator, llvm::StringRef help_text, uint32_t max_word_len)
CommandObject * GetCommandObjectForCommand(llvm::StringRef &command_line)
static const char * g_need_argument
bool m_skip_app_init_files
void SetSynchronous(bool value)
uint32_t m_command_source_depth
Status PreprocessToken(std::string &token)
bool RemoveUserMultiword(llvm::StringRef multiword_name)
bool GetSaveSessionOnQuit() const
FileSpec GetSaveSessionDirectory() const
bool UserCommandExists(llvm::StringRef cmd) const
Determine whether a root-level user command with this name exists.
bool GetRepeatPreviousCommand() const
lldb::IOHandlerSP GetIOHandler(bool force_create=false, CommandInterpreterRunOptions *options=nullptr)
bool HasUserCommands() const
const CommandObject::CommandMap & GetUserMultiwordCommands() const
void BuildAliasCommandArgs(CommandObject *alias_cmd_obj, const char *alias_name, Args &cmd_args, std::string &raw_input_string, CommandReturnObject &result)
std::vector< uint32_t > m_command_source_flags
CommandHistory m_command_history
CommandObject * BuildAliasResult(llvm::StringRef alias_name, std::string &raw_input_string, std::string &alias_result, CommandReturnObject &result)
void OverrideExecutionContext(const ExecutionContext &override_context)
bool SetBatchCommandMode(bool value)
const char * ProcessEmbeddedScriptCommands(const char *arg)
void AllowExitCodeOnQuit(bool allow)
Specify if the command interpreter should allow that the user can specify a custom exit code when cal...
CommandObject::CommandMap m_user_mw_dict
bool m_synchronous_execution
StreamString m_transcript_stream
Turn on settings interpreter.save-transcript for LLDB to populate this stream.
void HandleCommandsFromFile(FileSpec &file, const ExecutionContext &context, const CommandInterpreterRunOptions &options, CommandReturnObject &result)
Execute a list of commands from a file.
void SourceInitFileCwd(CommandReturnObject &result)
void SetSaveSessionOnQuit(bool enable)
static const char * g_argument
std::vector< FileSpec > m_command_source_dirs
A stack of directory paths.
void HandleCommands(const StringList &commands, const ExecutionContext &context, const CommandInterpreterRunOptions &options, CommandReturnObject &result)
Execute a list of commands in sequence.
void SetSaveTranscript(bool enable)
FileSpec GetCurrentSourceDir()
void SetEchoCommentCommands(bool enable)
StructuredData::Array m_transcript
Contains a list of handled commands and their details.
bool RemoveCommand(llvm::StringRef cmd, bool force=false)
Remove a command if it is removable (python or regex command).
const StructuredData::Array & GetTranscript() const
bool GetEchoCommands() const
Implements dwim-print, a printing command that chooses the most direct, efficient,...
lldb::CommandObjectSP GetSubcommandSPExact(llvm::StringRef sub_cmd) override
CommandObjectMultiword * GetAsMultiwordCommand() override
virtual bool WantsRawCommandString()=0
llvm::StringRef GetCommandName() const
bool HelpTextContainsWord(llvm::StringRef search_word, bool search_short_help=true, bool search_long_help=true, bool search_syntax=true, bool search_options=true)
virtual bool IsMultiwordObject()
virtual void Execute(const char *args_string, CommandReturnObject &result)=0
virtual std::optional< std::string > GetRepeatCommand(Args ¤t_command_args, uint32_t index)
Get the command that appropriate for a "repeat" of the current command.
virtual CommandObject * GetSubcommandObject(llvm::StringRef sub_cmd, StringList *matches=nullptr)
virtual CommandObjectMultiword * GetAsMultiwordCommand()
virtual Options * GetOptions()
void SetSyntax(llvm::StringRef str)
virtual void HandleCompletion(CompletionRequest &request)
This default version handles calling option argument completions and then calls HandleArgumentComplet...
std::map< std::string, lldb::CommandObjectSP > CommandMap
virtual llvm::StringRef GetHelp()
void AppendErrorWithFormatv(const char *format, Args &&... args)
void AppendMessage(llvm::StringRef in_string)
bool GetInteractive() const
void void AppendError(llvm::StringRef in_string)
lldb::StreamSP GetImmediateOutputStream()
bool GetDidChangeProcessState() const
void SetSuppressImmediateOutput(bool b)
llvm::StringRef GetErrorData()
void SetInteractive(bool b)
void AppendRawError(llvm::StringRef in_string)
llvm::StringRef GetOutputData()
void SetStatus(lldb::ReturnStatus status)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
lldb::StreamSP GetImmediateErrorStream()
lldb::ReturnStatus GetStatus() const
Stream & GetOutputStream()
"lldb/Utility/ArgCompletionRequest.h"
void AddCompletion(llvm::StringRef completion, llvm::StringRef description="", CompletionMode mode=CompletionMode::Normal)
Adds a possible completion string.
void AddCompletions(const StringList &completions)
Adds multiple possible completion strings.
const Args & GetParsedLine() const
void ShiftArguments()
Drops the first argument from the argument list.
void AppendEmptyArgument()
Adds an empty argument at the end of the argument list and moves the cursor to this new argument.
size_t GetCursorIndex() const
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
A class to manage flag bits.
ExecutionContext GetSelectedExecutionContext()
bool StartEventHandlerThread()
Manually start the global event handler thread.
void StopEventHandlerThread()
Manually stop the debugger's default event handler.
void SetAsyncExecution(bool async)
HostThread SetIOHandlerThread(HostThread &new_thread)
lldb::FileSP GetInputFileSP()
bool StartIOHandlerThread()
bool IsTopIOHandler(const lldb::IOHandlerSP &reader_sp)
bool IsIOHandlerThreadCurrentThread() const
uint64_t GetTerminalWidth() const
const char * GetIOHandlerCommandPrefix()
void RunIOHandlerAsync(const lldb::IOHandlerSP &reader_sp, bool cancel_top_handler=true)
Run the given IO handler and return immediately.
lldb::StreamFileSP GetErrorStreamSP()
bool GetAutoConfirm() const
PlatformList & GetPlatformList()
Target & GetDummyTarget()
void RunIOHandlerSync(const lldb::IOHandlerSP &reader_sp)
Run the given IO handler and block until it's complete.
lldb::StreamFileSP GetOutputStreamSP()
ScriptInterpreter * GetScriptInterpreter(bool can_create=true, std::optional< lldb::ScriptLanguage > language={})
llvm::StringRef GetExternalEditor() const
llvm::StringRef GetPrompt() const
void FlushProcessOutput(Process &process, bool flush_stdout, bool flush_stderr)
Force flushing the process's pending stdout and stderr to the debugger's asynchronous stdout and stde...
A class that measures elapsed time in an exception safe way.
void SetUnwindOnError(bool unwind=false)
void SetKeepInMemory(bool keep=true)
void SetCoerceToId(bool coerce=true)
void SetTryAllThreads(bool try_others=true)
void SetTimeout(const Timeout< std::micro > &timeout)
void SetIgnoreBreakpoints(bool ignore=false)
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Target * GetTargetPtr() const
Returns a pointer to the target object.
bool HasTargetScope() const
Returns true the ExecutionContext object contains a valid target.
Process * GetProcessPtr() const
Returns a pointer to the process object.
void AppendPathComponent(llvm::StringRef component)
const ConstString & GetFilename() const
Filename string const get accessor.
void MakeAbsolute(const FileSpec &dir)
Make the FileSpec absolute by treating it relative to dir.
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
FileSpec CopyByRemovingLastPathComponent() const
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
bool GetHomeDirectory(llvm::SmallVectorImpl< char > &path) const
Get the user home directory.
int Open(const char *path, int flags, int mode=0600)
Wraps ::open in a platform-independent way.
static FileSystem & Instance()
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
bool Test(ValueType bit) const
Test a single flag bit.
static lldb::thread_t GetCurrentThread()
Get the thread token (the one returned by ThreadCreate when the thread was created) for the calling t...
static bool IsInteractiveGraphicSession()
Check if we're running in an interactive graphical session.
static llvm::Error OpenFileInExternalEditor(llvm::StringRef editor, const FileSpec &file_spec, uint32_t line_no)
A delegate class for use with IOHandler subclasses.
lldb::StreamFileSP GetErrorStreamFileSP()
virtual const char * GetPrompt()
std::recursive_mutex & GetOutputMutex()
lldb::StreamFileSP GetOutputStreamFileSP()
bool GetIsInteractive()
Check if the input is being supplied interactively by a user.
static LanguageSet GetLanguagesSupportingREPLs()
static const char * GetNameForLanguageType(lldb::LanguageType language)
A command line option parsing protocol class.
bool SupportsLongOption(const char *long_option)
A plug-in interface definition class for debugging a process.
lldb::StateType GetState()
Get accessor for the current process state.
Status Halt(bool clear_thread_plans=false, bool use_run_lock=true)
Halts a running process.
lldb::OptionValuePropertiesSP m_collection_sp
bool SetPropertyAtIndex(uint32_t idx, T t, const ExecutionContext *exe_ctx=nullptr) const
void GetValue(Stream &s, bool show_type) const
void SetErrorStringWithFormatv(const char *format, Args &&... args)
void Clear()
Clear the object state.
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
const char * GetData() const
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
size_t EOL()
Output and End of Line character to the stream.
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
void IndentMore(unsigned amount=2)
Increment the current indentation level.
void AppendString(const std::string &s)
const char * GetStringAtIndex(size_t idx) const
void DeleteStringAtIndex(size_t id)
void AddItem(const ObjectSP &item)
std::shared_ptr< Dictionary > DictionarySP
LoadCWDlldbinitFile GetLoadCWDlldbinitFile() const
static TargetProperties & GetGlobalProperties()
lldb::PlatformSP GetPlatform()
lldb::ExpressionResults EvaluateExpression(llvm::StringRef expression, ExecutionContextScope *exe_scope, lldb::ValueObjectSP &result_valobj_sp, const EvaluateExpressionOptions &options=EvaluateExpressionOptions(), std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
int AddNamesMatchingPartialString(const std::map< std::string, ValueType > &in_map, llvm::StringRef cmd_str, StringList &matches, StringList *descriptions=nullptr)
std::shared_ptr< OptionArgVector > OptionArgVectorSP
bool StateIsRunningState(lldb::StateType state)
Check if a state represents a state where the process or thread is running.
size_t FindLongestCommandWord(std::map< std::string, ValueType > &dict)
@ RewriteLine
The full line has been rewritten by the completion.
const char * toString(AppleArm64ExceptionClass EC)
std::vector< std::tuple< std::string, int, std::string > > OptionArgVector
std::shared_ptr< lldb_private::OptionValueProperties > OptionValuePropertiesSP
std::shared_ptr< lldb_private::IOHandler > IOHandlerSP
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
std::unique_ptr< lldb_private::File > FileUP
@ eCommandInterpreterResultInferiorCrash
Stopped because the corresponding option was set and the inferior crashed.
@ eCommandInterpreterResultSuccess
Command interpreter finished successfully.
@ eCommandInterpreterResultCommandError
Stopped because the corresponding option was set and a command returned an error.
@ eCommandInterpreterResultQuitRequested
Stopped because quit was requested.
std::shared_ptr< lldb_private::UnixSignals > UnixSignalsSP
std::shared_ptr< lldb_private::Platform > PlatformSP
StateType
Process and Thread States.
@ eStateStopped
Process or thread is stopped and can be examined.
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
ExpressionResults
The results of expression evaluation.
std::shared_ptr< lldb_private::Process > ProcessSP
std::shared_ptr< lldb_private::Event > EventSP
@ eReturnStatusSuccessContinuingResult
@ eReturnStatusSuccessContinuingNoResult
@ eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishNoResult
std::shared_ptr< lldb_private::StreamFile > StreamFileSP
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
StopReason
Thread stop reasons.
@ eStopReasonInstrumentation
@ eStopReasonProcessorTrace
std::shared_ptr< lldb_private::Target > TargetSP
std::shared_ptr< lldb_private::File > FileSP
const char * c_str() const
llvm::StringRef ref() const
char GetQuoteChar() const
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
std::optional< lldb::LanguageType > GetSingularLanguage()
If the set contains a single language only, return it.