TEST(ArgsTest, AppendArguments) { Args args; const char *argv[] = {"1", "2", nullptr}; const char *argv2[] = {"3", "4", nullptr}; args.AppendArguments(argv); ASSERT_EQ(2u, args.GetArgumentCount()); EXPECT_STREQ("1", args.GetArgumentVector()[0]); EXPECT_STREQ("2", args.GetArgumentVector()[1]); EXPECT_EQ(nullptr, args.GetArgumentVector()[2]); EXPECT_STREQ("1", args.GetArgumentAtIndex(0)); EXPECT_STREQ("2", args.GetArgumentAtIndex(1)); args.AppendArguments(argv2); ASSERT_EQ(4u, args.GetArgumentCount()); EXPECT_STREQ("1", args.GetArgumentVector()[0]); EXPECT_STREQ("2", args.GetArgumentVector()[1]); EXPECT_STREQ("3", args.GetArgumentVector()[2]); EXPECT_STREQ("4", args.GetArgumentVector()[3]); EXPECT_EQ(nullptr, args.GetArgumentVector()[4]); EXPECT_STREQ("1", args.GetArgumentAtIndex(0)); EXPECT_STREQ("2", args.GetArgumentAtIndex(1)); EXPECT_STREQ("3", args.GetArgumentAtIndex(2)); EXPECT_STREQ("4", args.GetArgumentAtIndex(3)); }
virtual bool Execute ( Args& command, CommandReturnObject &result ) { DataExtractor reg_data; ExecutionContext exe_ctx(m_interpreter.GetDebugger().GetExecutionContext()); RegisterContext *reg_context = exe_ctx.GetRegisterContext (); if (reg_context) { if (command.GetArgumentCount() != 2) { result.AppendError ("register write takes exactly 2 arguments: <reg-name> <value>"); result.SetStatus (eReturnStatusFailed); } else { const char *reg_name = command.GetArgumentAtIndex(0); const char *value_str = command.GetArgumentAtIndex(1); const RegisterInfo *reg_info = reg_context->GetRegisterInfoByName(reg_name); if (reg_info) { Scalar scalar; Error error(scalar.SetValueFromCString (value_str, reg_info->encoding, reg_info->byte_size)); if (error.Success()) { if (reg_context->WriteRegisterValue(reg_info->kinds[eRegisterKindLLDB], scalar)) { result.SetStatus (eReturnStatusSuccessFinishNoResult); return true; } } else { result.AppendErrorWithFormat ("Failed to write register '%s' with value '%s': %s\n", reg_name, value_str, error.AsCString()); result.SetStatus (eReturnStatusFailed); } } else { result.AppendErrorWithFormat ("Register not found for '%s'.\n", reg_name); result.SetStatus (eReturnStatusFailed); } } } else { result.AppendError ("no current frame"); result.SetStatus (eReturnStatusFailed); } return result.Succeeded(); }
TEST(ArgsTest, TestMultipleArgs) { Args args; args.SetCommandString("this has multiple args"); EXPECT_EQ(4u, args.GetArgumentCount()); EXPECT_STREQ(args.GetArgumentAtIndex(0), "this"); EXPECT_STREQ(args.GetArgumentAtIndex(1), "has"); EXPECT_STREQ(args.GetArgumentAtIndex(2), "multiple"); EXPECT_STREQ(args.GetArgumentAtIndex(3), "args"); }
bool DoExecute(Args &command, CommandReturnObject &result) override { DataExtractor reg_data; RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext(); if (command.GetArgumentCount() != 2) { result.AppendError( "register write takes exactly 2 arguments: <reg-name> <value>"); result.SetStatus(eReturnStatusFailed); } else { const char *reg_name = command.GetArgumentAtIndex(0); const char *value_str = command.GetArgumentAtIndex(1); // in most LLDB commands we accept $rbx as the name for register RBX - and // here we would // reject it and non-existant. we should be more consistent towards the // user and allow them // to say reg write $rbx - internally, however, we should be strict and // not allow ourselves // to call our registers $rbx in our own API if (reg_name && *reg_name == '$') reg_name = reg_name + 1; const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name); if (reg_info) { RegisterValue reg_value; Error error(reg_value.SetValueFromCString(reg_info, value_str)); if (error.Success()) { if (reg_ctx->WriteRegister(reg_info, reg_value)) { // Toss all frames and anything else in the thread // after a register has been written. m_exe_ctx.GetThreadRef().Flush(); result.SetStatus(eReturnStatusSuccessFinishNoResult); return true; } } if (error.AsCString()) { result.AppendErrorWithFormat( "Failed to write register '%s' with value '%s': %s\n", reg_name, value_str, error.AsCString()); } else { result.AppendErrorWithFormat( "Failed to write register '%s' with value '%s'", reg_name, value_str); } result.SetStatus(eReturnStatusFailed); } else { result.AppendErrorWithFormat("Register not found for '%s'.\n", reg_name); result.SetStatus(eReturnStatusFailed); } } return result.Succeeded(); }
bool DoExecute(Args &args, CommandReturnObject &result) override { result.SetStatus(eReturnStatusFailed); if (args.GetArgumentCount() == 1) { llvm::StringRef sub_command = args.GetArgumentAtIndex(0); if (sub_command.equals_lower("enable")) { Timer::SetDisplayDepth(UINT32_MAX); result.SetStatus(eReturnStatusSuccessFinishNoResult); } else if (sub_command.equals_lower("disable")) { Timer::DumpCategoryTimes(&result.GetOutputStream()); Timer::SetDisplayDepth(0); result.SetStatus(eReturnStatusSuccessFinishResult); } else if (sub_command.equals_lower("dump")) { Timer::DumpCategoryTimes(&result.GetOutputStream()); result.SetStatus(eReturnStatusSuccessFinishResult); } else if (sub_command.equals_lower("reset")) { Timer::ResetCategoryTimes(); result.SetStatus(eReturnStatusSuccessFinishResult); } } else if (args.GetArgumentCount() == 2) { llvm::StringRef sub_command = args.GetArgumentAtIndex(0); llvm::StringRef param = args.GetArgumentAtIndex(1); if (sub_command.equals_lower("enable")) { uint32_t depth; if (param.consumeInteger(0, depth)) { result.AppendError( "Could not convert enable depth to an unsigned integer."); } else { Timer::SetDisplayDepth(depth); result.SetStatus(eReturnStatusSuccessFinishNoResult); } } else if (sub_command.equals_lower("increment")) { bool success; bool increment = Args::StringToBoolean(param, false, &success); if (success) { Timer::SetQuiet(!increment); result.SetStatus(eReturnStatusSuccessFinishNoResult); } else result.AppendError("Could not convert increment value to boolean."); } } if (!result.Succeeded()) { result.AppendError("Missing subcommand"); result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str()); } return result.Succeeded(); }
TEST(ArgsTest, TestInsertArg) { Args args; args.AppendArgument("1"); args.AppendArgument("2"); args.AppendArgument("3"); args.InsertArgumentAtIndex(1, "1.5"); args.InsertArgumentAtIndex(4, "3.5"); ASSERT_EQ(5u, args.GetArgumentCount()); EXPECT_STREQ("1", args.GetArgumentAtIndex(0)); EXPECT_STREQ("1.5", args.GetArgumentAtIndex(1)); EXPECT_STREQ("2", args.GetArgumentAtIndex(2)); EXPECT_STREQ("3", args.GetArgumentAtIndex(3)); EXPECT_STREQ("3.5", args.GetArgumentAtIndex(4)); }
bool DoExecute(Args &args, CommandReturnObject &result) override { if (args.empty()) { result.AppendErrorWithFormat( "%s takes a log channel and one or more log types.\n", m_cmd_name.c_str()); return false; } Log::Callbacks log_callbacks; const std::string channel = args.GetArgumentAtIndex(0); args.Shift(); // Shift off the channel if (Log::GetLogChannelCallbacks(ConstString(channel), log_callbacks)) { log_callbacks.disable(args.GetConstArgumentVector(), &result.GetErrorStream()); result.SetStatus(eReturnStatusSuccessFinishNoResult); } else if (channel == "all") { Log::DisableAllLogChannels(&result.GetErrorStream()); } else { LogChannelSP log_channel_sp(LogChannel::FindPlugin(channel.data())); if (log_channel_sp) { log_channel_sp->Disable(args.GetConstArgumentVector(), &result.GetErrorStream()); result.SetStatus(eReturnStatusSuccessFinishNoResult); } else result.AppendErrorWithFormat("Invalid log channel '%s'.\n", channel.data()); } return result.Succeeded(); }
void LogChannelDWARF::Disable (Args &categories, Stream *feedback_strm) { if (!m_log_sp) return; g_log_channel = this; uint32_t flag_bits = m_log_sp->GetMask().Get(); const size_t argc = categories.GetArgumentCount(); for (size_t i = 0; i < argc; ++i) { const char *arg = categories.GetArgumentAtIndex(i); if (::strcasecmp (arg, "all") == 0 ) flag_bits &= ~DWARF_LOG_ALL; else if (::strcasecmp (arg, "info") == 0 ) flag_bits &= ~DWARF_LOG_DEBUG_INFO; else if (::strcasecmp (arg, "line") == 0 ) flag_bits &= ~DWARF_LOG_DEBUG_LINE; else if (::strcasecmp (arg, "pubnames") == 0 ) flag_bits &= ~DWARF_LOG_DEBUG_PUBNAMES; else if (::strcasecmp (arg, "pubtypes") == 0 ) flag_bits &= ~DWARF_LOG_DEBUG_PUBTYPES; else if (::strcasecmp (arg, "default") == 0 ) flag_bits &= ~DWARF_LOG_DEFAULT; else { feedback_strm->Printf("error: unrecognized log category '%s'\n", arg); ListCategories (feedback_strm); } } if (flag_bits == 0) Delete (); else m_log_sp->GetMask().Reset (flag_bits); return; }
bool DoExecute (Args& command, CommandReturnObject &result) { typedef void (*LLDBCommandPluginInit) (lldb::SBDebugger debugger); size_t argc = command.GetArgumentCount(); if (argc != 1) { result.AppendError ("'plugin load' requires one argument"); result.SetStatus (eReturnStatusFailed); return false; } const char* path = command.GetArgumentAtIndex(0); Error error; FileSpec dylib_fspec(path,true); if (m_interpreter.GetDebugger().LoadPlugin(dylib_fspec, error)) result.SetStatus(eReturnStatusSuccessFinishResult); else { result.AppendError(error.AsCString()); result.SetStatus(eReturnStatusFailed); } return result.Succeeded(); }
virtual bool DoExecute (Args& args, CommandReturnObject &result) { if (args.GetArgumentCount() < 2) { result.AppendErrorWithFormat("%s takes a log channel and one or more log types.\n", m_cmd_name.c_str()); } else { std::string channel(args.GetArgumentAtIndex(0)); args.Shift (); // Shift off the channel char log_file[PATH_MAX]; if (m_options.log_file) m_options.log_file.GetPath(log_file, sizeof(log_file)); else log_file[0] = '\0'; bool success = m_interpreter.GetDebugger().EnableLog (channel.c_str(), args.GetConstArgumentVector(), log_file, m_options.log_options, result.GetErrorStream()); if (success) result.SetStatus (eReturnStatusSuccessFinishNoResult); else result.SetStatus (eReturnStatusFailed); } return result.Succeeded(); }
void Args::AppendArguments (const Args &rhs) { const size_t rhs_argc = rhs.GetArgumentCount(); for (size_t i=0; i<rhs_argc; ++i) AppendArgument(rhs.GetArgumentAtIndex(i)); }
Error PlatformAndroidRemoteGDBServer::ConnectRemote (Args& args) { m_device_id.clear(); if (args.GetArgumentCount() != 1) return Error("\"platform connect\" takes a single argument: <connect-url>"); int port; std::string scheme, host, path; const char *url = args.GetArgumentAtIndex (0); if (!url) return Error("URL is null."); if (!UriParser::Parse (url, scheme, host, port, path)) return Error("Invalid URL: %s", url); if (scheme == "adb") m_device_id = host; Error error = ForwardPortWithAdb(port, m_device_id); if (error.Fail()) return error; m_port_forwards[g_remote_platform_pid] = port; error = PlatformRemoteGDBServer::ConnectRemote(args); if (error.Fail ()) DeleteForwardPort (g_remote_platform_pid); return error; }
TEST(ArgsTest, DoubleQuotedItem) { Args args; args.SetCommandString("\"a b c\""); EXPECT_EQ(1u, args.GetArgumentCount()); EXPECT_STREQ("a b c", args.GetArgumentAtIndex(0)); }
Error PlatformAndroid::ConnectRemote(Args& args) { m_device_id.clear(); if (IsHost()) { return Error ("can't connect to the host platform '%s', always connected", GetPluginName().GetCString()); } if (!m_remote_platform_sp) m_remote_platform_sp = PlatformSP(new PlatformAndroidRemoteGDBServer()); int port; std::string scheme, host, path; const char *url = args.GetArgumentAtIndex(0); if (!url) return Error("URL is null."); if (!UriParser::Parse(url, scheme, host, port, path)) return Error("Invalid URL: %s", url); if (scheme == "adb") m_device_id = host; auto error = PlatformLinux::ConnectRemote(args); if (error.Success()) { AdbClient adb; error = AdbClient::CreateByDeviceID(m_device_id, adb); if (error.Fail()) return error; m_device_id = adb.GetDeviceID(); } return error; }
int CommandObjectFile::HandleArgumentCompletion (CommandInterpreter &interpreter, Args &input, int &cursor_index, int &cursor_char_position, OptionElementVector &opt_element_vector, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { std::string completion_str (input.GetArgumentAtIndex(cursor_index)); completion_str.erase (cursor_char_position); CommandCompletions::InvokeCommonCompletionCallbacks (interpreter, CommandCompletions::eDiskFileCompletion, completion_str.c_str(), match_start_point, max_return_elements, NULL, word_complete, matches); return matches.GetSize(); }
TEST(ArgsTest, BareSingleQuote) { Args args; args.SetCommandString("a\\'b"); EXPECT_EQ(1u, args.GetArgumentCount()); EXPECT_STREQ("a'b", args.GetArgumentAtIndex(0)); }
int CommandObjectRegexCommand::HandleCompletion (Args &input, int &cursor_index, int &cursor_char_position, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { if (m_completion_type_mask) { std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, m_completion_type_mask, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } else { matches.Clear(); word_complete = false; } return 0; }
TEST(ArgsTest, TestOverwriteArgs) { Args args; args.SetCommandString("this has multiple args"); EXPECT_EQ(4u, args.GetArgumentCount()); args.SetCommandString("arg"); EXPECT_EQ(1u, args.GetArgumentCount()); EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg"); }
LogSP ProcessPOSIXLog::EnableLog (StreamSP &log_stream_sp, uint32_t log_options, Args &args, Stream *feedback_strm) { // Try see if there already is a log - that way we can reuse its settings. // We could reuse the log in toto, but we don't know that the stream is the same. uint32_t flag_bits = 0; LogSP log(GetLog ()); if (log) flag_bits = log->GetMask().Get(); // Now make a new log with this stream if one was provided if (log_stream_sp) { log = make_shared<Log>(log_stream_sp); GetLog () = log; } if (log) { bool got_unknown_category = false; const size_t argc = args.GetArgumentCount(); for (size_t i=0; i<argc; ++i) { const char *arg = args.GetArgumentAtIndex(i); if (::strcasecmp (arg, "all") == 0 ) flag_bits |= POSIX_LOG_ALL; else if (::strcasecmp (arg, "async") == 0 ) flag_bits |= POSIX_LOG_ASYNC; else if (::strncasecmp (arg, "break", 5) == 0 ) flag_bits |= POSIX_LOG_BREAKPOINTS; else if (::strncasecmp (arg, "comm", 4) == 0 ) flag_bits |= POSIX_LOG_COMM; else if (::strcasecmp (arg, "default") == 0 ) flag_bits |= POSIX_LOG_DEFAULT; else if (::strcasecmp (arg, "packets") == 0 ) flag_bits |= POSIX_LOG_PACKETS; else if (::strcasecmp (arg, "memory") == 0 ) flag_bits |= POSIX_LOG_MEMORY; else if (::strcasecmp (arg, "data-short") == 0 ) flag_bits |= POSIX_LOG_MEMORY_DATA_SHORT; else if (::strcasecmp (arg, "data-long") == 0 ) flag_bits |= POSIX_LOG_MEMORY_DATA_LONG; else if (::strcasecmp (arg, "process") == 0 ) flag_bits |= POSIX_LOG_PROCESS; else if (::strcasecmp (arg, "ptrace") == 0 ) flag_bits |= POSIX_LOG_PTRACE; else if (::strcasecmp (arg, "registers") == 0 ) flag_bits |= POSIX_LOG_REGISTERS; else if (::strcasecmp (arg, "step") == 0 ) flag_bits |= POSIX_LOG_STEP; else if (::strcasecmp (arg, "thread") == 0 ) flag_bits |= POSIX_LOG_THREAD; else if (::strcasecmp (arg, "verbose") == 0 ) flag_bits |= POSIX_LOG_VERBOSE; else if (::strncasecmp (arg, "watch", 5) == 0 ) flag_bits |= POSIX_LOG_WATCHPOINTS; else { feedback_strm->Printf("error: unrecognized log category '%s'\n", arg); if (got_unknown_category == false) { got_unknown_category = true; ListLogCategories (feedback_strm); } } } if (flag_bits == 0) flag_bits = POSIX_LOG_DEFAULT; log->GetMask().Reset(flag_bits); log->GetOptions().Reset(log_options); } return log; }
TEST(ArgsTest, TestAppendArg) { Args args; args.SetCommandString("first_arg"); EXPECT_EQ(1u, args.GetArgumentCount()); args.AppendArgument(llvm::StringRef("second_arg")); EXPECT_EQ(2u, args.GetArgumentCount()); EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_arg"); EXPECT_STREQ(args.GetArgumentAtIndex(1), "second_arg"); }
virtual bool Execute (CommandInterpreter &interpreter, Args& args, CommandReturnObject &result) { const size_t argc = args.GetArgumentCount(); if (argc == 0) { Log::ListAllLogChannels (&result.GetOutputStream()); result.SetStatus(eReturnStatusSuccessFinishResult); } else { for (size_t i=0; i<argc; ++i) { Log::Callbacks log_callbacks; std::string channel(args.GetArgumentAtIndex(i)); if (Log::GetLogChannelCallbacks (channel.c_str(), log_callbacks)) { log_callbacks.list_categories (&result.GetOutputStream()); result.SetStatus(eReturnStatusSuccessFinishResult); } else if (channel == "all") { Log::ListAllLogChannels (&result.GetOutputStream()); result.SetStatus(eReturnStatusSuccessFinishResult); } else { LogChannelSP log_channel_sp (GetLogChannelPluginForChannel(channel.c_str())); if (log_channel_sp) { log_channel_sp->ListCategories(&result.GetOutputStream()); result.SetStatus(eReturnStatusSuccessFinishNoResult); } else result.AppendErrorWithFormat("Invalid log channel '%s'.\n", args.GetArgumentAtIndex(0)); } } } return result.Succeeded(); }
int CommandObjectHelp::HandleCompletion ( Args &input, int &cursor_index, int &cursor_char_position, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches ) { // Return the completions of the commands in the help system: if (cursor_index == 0) { return m_interpreter.HandleCompletionMatches (input, cursor_index, cursor_char_position, match_start_point, max_return_elements, word_complete, matches); } else { CommandObject *cmd_obj = m_interpreter.GetCommandObject (input.GetArgumentAtIndex(0)); // The command that they are getting help on might be ambiguous, in which case we should complete that, // otherwise complete with the command the user is getting help on... if (cmd_obj) { input.Shift(); cursor_index--; return cmd_obj->HandleCompletion (input, cursor_index, cursor_char_position, match_start_point, max_return_elements, word_complete, matches); } else { return m_interpreter.HandleCompletionMatches (input, cursor_index, cursor_char_position, match_start_point, max_return_elements, word_complete, matches); } } }
virtual bool Execute (Args& args, CommandReturnObject &result) { const size_t argc = args.GetArgumentCount(); if (argc == 0) { result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str()); } else { Log::Callbacks log_callbacks; std::string channel(args.GetArgumentAtIndex(0)); args.Shift (); // Shift off the channel if (Log::GetLogChannelCallbacks (channel.c_str(), log_callbacks)) { log_callbacks.disable (args, &result.GetErrorStream()); result.SetStatus(eReturnStatusSuccessFinishNoResult); } else if (channel == "all") { Log::DisableAllLogChannels(&result.GetErrorStream()); } else { LogChannelSP log_channel_sp (LogChannel::FindPlugin(channel.c_str())); if (log_channel_sp) { log_channel_sp->Disable(args, &result.GetErrorStream()); result.SetStatus(eReturnStatusSuccessFinishNoResult); } else result.AppendErrorWithFormat("Invalid log channel '%s'.\n", args.GetArgumentAtIndex(0)); } } return result.Succeeded(); }
void ProcessPOSIXLog::DisableLog (Args &args, Stream *feedback_strm) { LogSP log (GetLog ()); if (log) { uint32_t flag_bits = 0; const size_t argc = args.GetArgumentCount (); if (argc > 0) { flag_bits = log->GetMask().Get(); for (size_t i = 0; i < argc; ++i) { const char *arg = args.GetArgumentAtIndex (i); if (::strcasecmp (arg, "all") == 0 ) flag_bits &= ~POSIX_LOG_ALL; else if (::strcasecmp (arg, "async") == 0 ) flag_bits &= ~POSIX_LOG_ASYNC; else if (::strncasecmp (arg, "break", 5) == 0 ) flag_bits &= ~POSIX_LOG_BREAKPOINTS; else if (::strncasecmp (arg, "comm", 4) == 0 ) flag_bits &= ~POSIX_LOG_COMM; else if (::strcasecmp (arg, "default") == 0 ) flag_bits &= ~POSIX_LOG_DEFAULT; else if (::strcasecmp (arg, "packets") == 0 ) flag_bits &= ~POSIX_LOG_PACKETS; else if (::strcasecmp (arg, "memory") == 0 ) flag_bits &= ~POSIX_LOG_MEMORY; else if (::strcasecmp (arg, "data-short") == 0 ) flag_bits &= ~POSIX_LOG_MEMORY_DATA_SHORT; else if (::strcasecmp (arg, "data-long") == 0 ) flag_bits &= ~POSIX_LOG_MEMORY_DATA_LONG; else if (::strcasecmp (arg, "process") == 0 ) flag_bits &= ~POSIX_LOG_PROCESS; else if (::strcasecmp (arg, "ptrace") == 0 ) flag_bits &= ~POSIX_LOG_PTRACE; else if (::strcasecmp (arg, "registers") == 0 ) flag_bits &= ~POSIX_LOG_REGISTERS; else if (::strcasecmp (arg, "step") == 0 ) flag_bits &= ~POSIX_LOG_STEP; else if (::strcasecmp (arg, "thread") == 0 ) flag_bits &= ~POSIX_LOG_THREAD; else if (::strcasecmp (arg, "verbose") == 0 ) flag_bits &= ~POSIX_LOG_VERBOSE; else if (::strncasecmp (arg, "watch", 5) == 0 ) flag_bits &= ~POSIX_LOG_WATCHPOINTS; else { feedback_strm->Printf("error: unrecognized log category '%s'\n", arg); ListLogCategories (feedback_strm); } } } if (flag_bits == 0) GetLog ().reset(); else log->GetMask().Reset (flag_bits); } return; }
int CommandObjectMultiword::HandleCompletion(Args &input, int &cursor_index, int &cursor_char_position, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) { // Any of the command matches will provide a complete word, otherwise the // individual // completers will override this. word_complete = true; const char *arg0 = input.GetArgumentAtIndex(0); if (cursor_index == 0) { AddNamesMatchingPartialString(m_subcommand_dict, arg0, matches); if (matches.GetSize() == 1 && matches.GetStringAtIndex(0) != nullptr && strcmp(arg0, matches.GetStringAtIndex(0)) == 0) { StringList temp_matches; CommandObject *cmd_obj = GetSubcommandObject(arg0, &temp_matches); if (cmd_obj != nullptr) { if (input.GetArgumentCount() == 1) { word_complete = true; } else { matches.DeleteStringAtIndex(0); input.Shift(); cursor_char_position = 0; input.AppendArgument(""); return cmd_obj->HandleCompletion( input, cursor_index, cursor_char_position, match_start_point, max_return_elements, word_complete, matches); } } } return matches.GetSize(); } else { CommandObject *sub_command_object = GetSubcommandObject(arg0, &matches); if (sub_command_object == nullptr) { return matches.GetSize(); } else { // Remove the one match that we got from calling GetSubcommandObject. matches.DeleteStringAtIndex(0); input.Shift(); cursor_index--; return sub_command_object->HandleCompletion( input, cursor_index, cursor_char_position, match_start_point, max_return_elements, word_complete, matches); } } }
Error PlatformRemoteGDBServer::ConnectRemote (Args& args) { Error error; if (IsConnected()) { error.SetErrorStringWithFormat ("the platform is already connected to '%s', execute 'platform disconnect' to close the current connection", GetHostname()); } else { if (args.GetArgumentCount() == 1) { m_gdb_client.SetConnection(new ConnectionFileDescriptor()); // we're going to reuse the hostname when we connect to the debugserver int port; std::string path; const char *url = args.GetArgumentAtIndex(0); if (!url) return Error("URL is null."); if (!UriParser::Parse(url, m_platform_scheme, m_platform_hostname, port, path)) return Error("Invalid URL: %s", url); const ConnectionStatus status = m_gdb_client.Connect(url, &error); if (status == eConnectionStatusSuccess) { if (m_gdb_client.HandshakeWithServer(&error)) { m_gdb_client.GetHostInfo(); // If a working directory was set prior to connecting, send it down now if (m_working_dir) m_gdb_client.SetWorkingDir(m_working_dir); } else { m_gdb_client.Disconnect(); if (error.Success()) error.SetErrorString("handshake failed"); } } } else { error.SetErrorString ("\"platform connect\" takes a single argument: <connect-url>"); } } return error; }
int HandleArgumentCompletion(Args &input, int &cursor_index, int &cursor_char_position, OptionElementVector &opt_element_vector, int match_start_point, int max_return_elements, bool &word_complete, StringList &matches) override { // Arguments are the standard source file completer. std::string completion_str(input.GetArgumentAtIndex(cursor_index)); completion_str.erase(cursor_char_position); CommandCompletions::InvokeCommonCompletionCallbacks( GetCommandInterpreter(), CommandCompletions::eVariablePathCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); }
Status PlatformAndroidRemoteGDBServer::ConnectRemote(Args &args) { m_device_id.clear(); if (args.GetArgumentCount() != 1) return Status( "\"platform connect\" takes a single argument: <connect-url>"); int remote_port; llvm::StringRef scheme, host, path; const char *url = args.GetArgumentAtIndex(0); if (!url) return Status("URL is null."); if (!UriParser::Parse(url, scheme, host, remote_port, path)) return Status("Invalid URL: %s", url); if (host != "localhost") m_device_id = host; m_socket_namespace.reset(); if (scheme == ConnectionFileDescriptor::UNIX_CONNECT_SCHEME) m_socket_namespace = AdbClient::UnixSocketNamespaceFileSystem; else if (scheme == ConnectionFileDescriptor::UNIX_ABSTRACT_CONNECT_SCHEME) m_socket_namespace = AdbClient::UnixSocketNamespaceAbstract; std::string connect_url; auto error = MakeConnectURL(g_remote_platform_pid, (remote_port < 0) ? 0 : remote_port, path, connect_url); if (error.Fail()) return error; args.ReplaceArgumentAtIndex(0, connect_url); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM)); if (log) log->Printf("Rewritten platform connect URL: %s", connect_url.c_str()); error = PlatformRemoteGDBServer::ConnectRemote(args); if (error.Fail()) DeleteForwardPort(g_remote_platform_pid); return error; }
UnwindLLDB::UnwindLLDB (Thread &thread) : Unwind (thread), m_frames(), m_unwind_complete(false), m_user_supplied_trap_handler_functions() { ProcessSP process_sp(thread.GetProcess()); if (process_sp) { Args args; process_sp->GetTarget().GetUserSpecifiedTrapHandlerNames (args); size_t count = args.GetArgumentCount(); for (size_t i = 0; i < count; i++) { const char *func_name = args.GetArgumentAtIndex(i); m_user_supplied_trap_handler_functions.push_back (ConstString (func_name)); } } }
bool LogChannelDWARF::Enable ( StreamSP &log_stream_sp, uint32_t log_options, Stream *feedback_strm, // Feedback stream for argument errors etc const Args &categories // The categories to enable within this logging stream, if empty, enable default set ) { Delete (); m_log_sp.reset(new Log (log_stream_sp)); g_log_channel = this; uint32_t flag_bits = 0; bool got_unknown_category = false; const size_t argc = categories.GetArgumentCount(); for (size_t i=0; i<argc; ++i) { const char *arg = categories.GetArgumentAtIndex(i); if (::strcasecmp (arg, "all") == 0 ) flag_bits |= DWARF_LOG_ALL; else if (::strcasecmp (arg, "info") == 0 ) flag_bits |= DWARF_LOG_DEBUG_INFO; else if (::strcasecmp (arg, "line") == 0 ) flag_bits |= DWARF_LOG_DEBUG_LINE; else if (::strcasecmp (arg, "pubnames") == 0 ) flag_bits |= DWARF_LOG_DEBUG_PUBNAMES; else if (::strcasecmp (arg, "pubtypes") == 0 ) flag_bits |= DWARF_LOG_DEBUG_PUBTYPES; else if (::strcasecmp (arg, "default") == 0 ) flag_bits |= DWARF_LOG_DEFAULT; else { feedback_strm->Printf("error: unrecognized log category '%s'\n", arg); if (got_unknown_category == false) { got_unknown_category = true; ListCategories (feedback_strm); } } } if (flag_bits == 0) flag_bits = DWARF_LOG_DEFAULT; m_log_sp->GetMask().Reset(flag_bits); m_log_sp->GetOptions().Reset(log_options); return m_log_sp.get() != NULL; }