+#include "../Commands/CommandObjectBugreport.h"

+#include "../Commands/CommandObjectLanguage.h"

+#include "lldb/Interpreter/OptionValueProperties.h"

+#include "lldb/Interpreter/Property.h"

+static const char *k_white_space = " \t\v";

+ Broadcaster (&debugger, CommandInterpreter::GetStaticBroadcasterClass().AsCString()),

+void

+CommandInterpreter::SetPromptOnQuit (bool b)

+{

+ const uint32_t idx = ePropertyPromptOnQuit;

+ m_collection_sp->SetPropertyAtIndexAsBoolean (nullptr, idx, b);

+}

+

+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);

+ }

+}

+

+

+ m_command_dict["bugreport"] = CommandObjectSP (new CommandObjectMultiwordBugreport (*this));

+ m_command_dict["language"] = CommandObjectSP (new CommandObjectLanguage(*this));

+ "Set a breakpoint using a regular expression to specify the location, where <linenum> is in decimal and <address> is in hex.\n",

+ "\n_regexp-break <filename>:<linenum> # _regexp-break main.c:12 // Break on line 12 of main.c\n"

+ "_regexp-break <linenum> # _regexp-break 12 // Break on line 12 of current file\n"

+ "_regexp-break <address> # _regexp-break 0x1234000 // Break on address 0x1234000\n"

+ "_regexp-break <name> # _regexp-break main // Break in 'main' after the prologue\n"

+ "_regexp-break &<name> # _regexp-break &main // Break on the first instruction in 'main'\n"

+ "_regexp-break <module>`<name> # _regexp-break libc.so`malloc // Break in 'malloc' only in the 'libc.so' shared library\n"

+ "_regexp-break /<source-regex>/ # _regexp-break /break here/ // Break on all lines that match the regular expression 'break here' in the current file.\n",

+ const char * help_prologue = GetDebugger().GetIOHandlerHelpPrologue();

+ if (help_prologue != NULL)

+ {

+ OutputFormattedHelpText(result.GetOutputStream(), NULL, help_prologue);

+ }

+

+ result.AppendMessage("Debugger commands:");

+ if (!(cmd_types & eCommandTypesHidden) && (pos->first.compare(0, 1, "_") == 0))

+ continue;

+

+ result.AppendMessageWithFormat("Current command abbreviations "

+ "(type '%shelp command alias' for more info):\n",

+ GetCommandPrefix());

+ result.AppendMessage ("Current user-defined commands:");

+ result.AppendMessageWithFormat("For more information on any command, type '%shelp <command-name>'.\n",

+ GetCommandPrefix());

+ size_t start = command_string.find_first_not_of (k_white_space);

+ end = command_string.find_first_of (k_white_space, start);

+ else // cmd_word was not a valid sub-command word, so we are done

+ start = command_string.find_first_not_of (k_white_space, end);

+ Args cmd_args (raw_input_string);

+ if (value_type != OptionParser::eNoArgument)

+ if (value_type != OptionParser::eOptionalArgument)

+ result_str.Printf (" ");

+ return nullptr;

+ // The only current stuff that gets preprocessed is anything enclosed

+ // The backtick was preceded by a '\' character, remove the slash

+ // Phase 1.

+ // 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".

+ 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");

+ Args command_args (command_string);

+ const std::size_t actual_cmd_name_len = strlen (cmd_obj->GetCommandName());

+ remainder = command_string.substr (actual_cmd_name_len);

+ size_t pos = remainder.find_first_not_of (k_white_space);

+ Args command_args (command_string);

+ Args parsed_line(llvm::StringRef(current_line, last_char - current_line));

+ Args partial_parsed_line(llvm::StringRef(current_line, cursor - current_line));

+ cmd_args.SetArguments (new_args.GetArgumentCount(), new_args.GetConstArgumentVector());

+ cmd_args.SetArguments (new_args.GetArgumentCount(), new_args.GetConstArgumentVector());

+ const char *cptr = in_string;

+const char *

+CommandInterpreter::GetCommandPrefix()

+{

+ const char * prefix = GetDebugger().GetIOHandlerCommandPrefix();

+ return prefix == NULL ? "" : prefix;

+}

+

+ const char *prefix,

+ const char *help_text)

+ 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 == ' ')

+ line_end = line_scan;

+ line_scan_end = line_start + line_width_max;

+ else if (next == '\n' || next == '\0')

+ line_end = line_scan;

+ break;

+ ++line_scan;

+

+ // 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);

+

+ ScriptInterpreter *script_interpreter = GetScriptInterpreter (false);

+ if (script_interpreter)

+ {

+ if (script_interpreter->Interrupt())

+ return true;

+ }

+ // Always re-create the command interpreter when we run it in case

+ m_debugger.ExecuteIOHandlers();

+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;

+ if (GetAliasFullName(next_word.c_str(), full_name))

+ {

+ 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

+ {

+ cmd_obj = GetCommandObject(next_word.c_str(), &matches);

+ 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;

+}