int CommandCompletions::SourceFiles(CommandInterpreter &interpreter, const char *partial_file_name, int match_start_point, int max_return_elements, SearchFilter *searcher, bool &word_complete, StringList &matches) { word_complete = true; // Find some way to switch "include support files..." SourceFileCompleter completer (interpreter, false, partial_file_name, match_start_point, max_return_elements, matches); if (searcher == nullptr) { lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget(); SearchFilterForUnconstrainedSearches null_searcher (target_sp); completer.DoCompletion (&null_searcher); } else { completer.DoCompletion (searcher); } return matches.GetSize(); }
int CommandCompletions::Symbols ( CommandInterpreter &interpreter, const char *partial_file_name, int match_start_point, int max_return_elements, SearchFilter *searcher, bool &word_complete, StringList &matches) { word_complete = true; SymbolCompleter completer (interpreter, partial_file_name, match_start_point, max_return_elements, matches); if (searcher == NULL) { lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget(); SearchFilterForUnconstrainedSearches null_searcher (target_sp); completer.DoCompletion (&null_searcher); } else { completer.DoCompletion (searcher); } return matches.GetSize(); }
int CommandCompletions::SettingsNames (CommandInterpreter &interpreter, const char *partial_setting_name, int match_start_point, int max_return_elements, SearchFilter *searcher, bool &word_complete, StringList &matches) { // Cache the full setting name list static StringList g_property_names; if (g_property_names.GetSize() == 0) { // Generate the full setting name list on demand lldb::OptionValuePropertiesSP properties_sp (interpreter.GetDebugger().GetValueProperties()); if (properties_sp) { StreamString strm; properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName); const std::string &str = strm.GetString(); g_property_names.SplitIntoLines(str.c_str(), str.size()); } } size_t exact_matches_idx = SIZE_MAX; const size_t num_matches = g_property_names.AutoComplete (partial_setting_name, matches, exact_matches_idx); word_complete = exact_matches_idx != SIZE_MAX; return num_matches; }
int CommandCompletions::SettingsNames(CommandInterpreter &interpreter, CompletionRequest &request, SearchFilter *searcher) { // Cache the full setting name list static StringList g_property_names; if (g_property_names.GetSize() == 0) { // Generate the full setting name list on demand lldb::OptionValuePropertiesSP properties_sp( interpreter.GetDebugger().GetValueProperties()); if (properties_sp) { StreamString strm; properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName); const std::string &str = strm.GetString(); g_property_names.SplitIntoLines(str.c_str(), str.size()); } } size_t exact_matches_idx = SIZE_MAX; StringList matches; g_property_names.AutoComplete(request.GetCursorArgumentPrefix(), matches, exact_matches_idx); request.SetWordComplete(exact_matches_idx != SIZE_MAX); request.AddCompletions(matches); return request.GetNumberOfMatches(); }
int CommandCompletions::Symbols(CommandInterpreter &interpreter, CompletionRequest &request, SearchFilter *searcher) { request.SetWordComplete(true); SymbolCompleter completer(interpreter, request); if (searcher == nullptr) { lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget(); SearchFilterForUnconstrainedSearches null_searcher(target_sp); completer.DoCompletion(&null_searcher); } else { completer.DoCompletion(searcher); } return request.GetNumberOfMatches(); }
PlatformSP OptionGroupPlatform::CreatePlatformWithOptions (CommandInterpreter &interpreter, const ArchSpec &arch, bool make_selected, Error& error, ArchSpec &platform_arch) const { PlatformSP platform_sp; if (!m_platform_name.empty()) { platform_sp = Platform::Create (ConstString(m_platform_name.c_str()), error); if (platform_sp) { if (platform_arch.IsValid() && !platform_sp->IsCompatibleArchitecture(arch, false, &platform_arch)) { error.SetErrorStringWithFormat ("platform '%s' doesn't support '%s'", platform_sp->GetName().GetCString(), arch.GetTriple().getTriple().c_str()); platform_sp.reset(); return platform_sp; } } } else if (arch.IsValid()) { platform_sp = Platform::Create (arch, &platform_arch, error); } if (platform_sp) { interpreter.GetDebugger().GetPlatformList().Append (platform_sp, make_selected); if (m_os_version_major != UINT32_MAX) { platform_sp->SetOSVersion (m_os_version_major, m_os_version_minor, m_os_version_update); } if (m_sdk_sysroot) platform_sp->SetSDKRootDirectory (m_sdk_sysroot); if (m_sdk_build) platform_sp->SetSDKBuild (m_sdk_build); } return platform_sp; }
int CommandCompletions::SourceFiles(CommandInterpreter &interpreter, CompletionRequest &request, SearchFilter *searcher) { request.SetWordComplete(true); // Find some way to switch "include support files..." SourceFileCompleter completer(interpreter, false, request); if (searcher == nullptr) { lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget(); SearchFilterForUnconstrainedSearches null_searcher(target_sp); completer.DoCompletion(&null_searcher); } else { completer.DoCompletion(searcher); } return request.GetNumberOfMatches(); }
bool CommandObjectFile::Execute ( CommandInterpreter &interpreter, Args& command, CommandReturnObject &result ) { const char *file_path = command.GetArgumentAtIndex(0); Timer scoped_timer(__PRETTY_FUNCTION__, "(dbg) file '%s'", file_path); const int argc = command.GetArgumentCount(); if (argc == 1) { FileSpec file_spec (file_path); if (! file_spec.Exists()) { result.AppendErrorWithFormat ("File '%s' does not exist.\n", file_path); result.SetStatus (eReturnStatusFailed); return result.Succeeded(); } TargetSP target_sp; ArchSpec arch; if (m_options.m_arch.IsValid()) arch = m_options.m_arch; else { arch = lldb_private::GetDefaultArchitecture (); if (!arch.IsValid()) arch = LLDB_ARCH_DEFAULT; } Debugger &debugger = interpreter.GetDebugger(); Error error = debugger.GetTargetList().CreateTarget (debugger, file_spec, arch, NULL, true, target_sp); if (error.Fail() && !m_options.m_arch.IsValid()) { if (arch == LLDB_ARCH_DEFAULT_32BIT) arch = LLDB_ARCH_DEFAULT_64BIT; else arch = LLDB_ARCH_DEFAULT_32BIT; error = debugger.GetTargetList().CreateTarget (debugger, file_spec, arch, NULL, true, target_sp); } if (target_sp) { debugger.GetTargetList().SetCurrentTarget(target_sp.get()); result.AppendMessageWithFormat ("Current executable set to '%s' (%s).\n", file_path, arch.AsCString()); result.SetStatus (eReturnStatusSuccessFinishNoResult); } else { result.AppendError(error.AsCString()); result.SetStatus (eReturnStatusFailed); } } else { result.AppendErrorWithFormat("'%s' takes exactly one executable path argument.\n", m_cmd_name.c_str()); result.SetStatus (eReturnStatusFailed); } return result.Succeeded(); }
bool CommandObjectDisassemble::Execute ( CommandInterpreter &interpreter, Args& command, CommandReturnObject &result ) { Target *target = interpreter.GetDebugger().GetCurrentTarget().get(); if (target == NULL) { result.AppendError ("invalid target, set executable file using 'file' command"); result.SetStatus (eReturnStatusFailed); return false; } ArchSpec arch(target->GetArchitecture()); if (!arch.IsValid()) { result.AppendError ("target needs valid architecure in order to be able to disassemble"); result.SetStatus (eReturnStatusFailed); return false; } Disassembler *disassembler = Disassembler::FindPlugin(arch); if (disassembler == NULL) { result.AppendErrorWithFormat ("Unable to find Disassembler plug-in for %s architecture.\n", arch.AsCString()); result.SetStatus (eReturnStatusFailed); return false; } result.SetStatus (eReturnStatusSuccessFinishResult); if (command.GetArgumentCount() != 0) { result.AppendErrorWithFormat ("\"disassemble\" doesn't take any arguments.\n"); result.SetStatus (eReturnStatusFailed); return false; } ExecutionContext exe_ctx(interpreter.GetDebugger().GetExecutionContext()); if (m_options.show_mixed && m_options.num_lines_context == 0) m_options.num_lines_context = 3; if (!m_options.m_func_name.empty()) { ConstString name(m_options.m_func_name.c_str()); if (Disassembler::Disassemble (interpreter.GetDebugger(), arch, exe_ctx, name, NULL, // Module * m_options.show_mixed ? m_options.num_lines_context : 0, m_options.show_bytes, result.GetOutputStream())) { result.SetStatus (eReturnStatusSuccessFinishResult); } else { result.AppendErrorWithFormat ("Unable to find symbol with name '%s'.\n", name.GetCString()); result.SetStatus (eReturnStatusFailed); } } else { AddressRange range; if (m_options.m_start_addr != LLDB_INVALID_ADDRESS) { range.GetBaseAddress().SetOffset (m_options.m_start_addr); if (m_options.m_end_addr != LLDB_INVALID_ADDRESS) { if (m_options.m_end_addr < m_options.m_start_addr) { result.AppendErrorWithFormat ("End address before start address.\n"); result.SetStatus (eReturnStatusFailed); return false; } range.SetByteSize (m_options.m_end_addr - m_options.m_start_addr); } else range.SetByteSize (DEFAULT_DISASM_BYTE_SIZE); } else { if (exe_ctx.frame) { SymbolContext sc(exe_ctx.frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); if (sc.function) range = sc.function->GetAddressRange(); else if (sc.symbol && sc.symbol->GetAddressRangePtr()) range = *sc.symbol->GetAddressRangePtr(); else range.GetBaseAddress() = exe_ctx.frame->GetPC(); } else { result.AppendError ("invalid frame"); result.SetStatus (eReturnStatusFailed); return false; } } if (range.GetByteSize() == 0) range.SetByteSize(DEFAULT_DISASM_BYTE_SIZE); if (Disassembler::Disassemble (interpreter.GetDebugger(), arch, exe_ctx, range, m_options.show_mixed ? m_options.num_lines_context : 0, m_options.show_bytes, result.GetOutputStream())) { result.SetStatus (eReturnStatusSuccessFinishResult); } else { result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8llx.\n", m_options.m_start_addr); result.SetStatus (eReturnStatusFailed); } } return result.Succeeded(); }
bool Options::HandleOptionArgumentCompletion( Args &input, int cursor_index, int char_pos, OptionElementVector &opt_element_vector, int opt_element_index, int match_start_point, int max_return_elements, CommandInterpreter &interpreter, bool &word_complete, lldb_private::StringList &matches) { auto opt_defs = GetDefinitions(); std::unique_ptr<SearchFilter> filter_ap; int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos; int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index; // See if this is an enumeration type option, and if so complete it here: OptionEnumValueElement *enum_values = opt_defs[opt_defs_index].enum_values; if (enum_values != nullptr) { bool return_value = false; std::string match_string(input.GetArgumentAtIndex(opt_arg_pos), input.GetArgumentAtIndex(opt_arg_pos) + char_pos); for (int i = 0; enum_values[i].string_value != nullptr; i++) { if (strstr(enum_values[i].string_value, match_string.c_str()) == enum_values[i].string_value) { matches.AppendString(enum_values[i].string_value); return_value = true; } } return return_value; } // If this is a source file or symbol type completion, and there is a // -shlib option somewhere in the supplied arguments, then make a search // filter // for that shared library. // FIXME: Do we want to also have an "OptionType" so we don't have to match // string names? uint32_t completion_mask = opt_defs[opt_defs_index].completion_type; if (completion_mask == 0) { lldb::CommandArgumentType option_arg_type = opt_defs[opt_defs_index].argument_type; if (option_arg_type != eArgTypeNone) { const CommandObject::ArgumentTableEntry *arg_entry = CommandObject::FindArgumentDataByType( opt_defs[opt_defs_index].argument_type); if (arg_entry) completion_mask = arg_entry->completion_type; } } if (completion_mask & CommandCompletions::eSourceFileCompletion || completion_mask & CommandCompletions::eSymbolCompletion) { for (size_t i = 0; i < opt_element_vector.size(); i++) { int cur_defs_index = opt_element_vector[i].opt_defs_index; // trying to use <0 indices will definitely cause problems if (cur_defs_index == OptionArgElement::eUnrecognizedArg || cur_defs_index == OptionArgElement::eBareDash || cur_defs_index == OptionArgElement::eBareDoubleDash) continue; int cur_arg_pos = opt_element_vector[i].opt_arg_pos; const char *cur_opt_name = opt_defs[cur_defs_index].long_option; // If this is the "shlib" option and there was an argument provided, // restrict it to that shared library. if (cur_opt_name && strcmp(cur_opt_name, "shlib") == 0 && cur_arg_pos != -1) { const char *module_name = input.GetArgumentAtIndex(cur_arg_pos); if (module_name) { FileSpec module_spec(module_name, false); lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget(); // Search filters require a target... if (target_sp) filter_ap.reset(new SearchFilterByModule(target_sp, module_spec)); } break; } } } return CommandCompletions::InvokeCommonCompletionCallbacks( interpreter, completion_mask, input.GetArgumentAtIndex(opt_arg_pos), match_start_point, max_return_elements, filter_ap.get(), word_complete, matches); }
bool CommandObject::ExecuteWithOptions ( CommandInterpreter &interpreter, Args& args, CommandReturnObject &result ) { for (size_t i = 0; i < args.GetArgumentCount(); ++i) { const char *tmp_str = args.GetArgumentAtIndex (i); if (tmp_str[0] == '`') // back-quote args.ReplaceArgumentAtIndex (i, interpreter.ProcessEmbeddedScriptCommands (tmp_str)); } Process *process = interpreter.GetDebugger().GetExecutionContext().process; if (process == NULL) { if (GetFlags().IsSet(CommandObject::eFlagProcessMustBeLaunched | CommandObject::eFlagProcessMustBePaused)) { result.AppendError ("Process must exist."); result.SetStatus (eReturnStatusFailed); return false; } } else { StateType state = process->GetState(); switch (state) { case eStateAttaching: case eStateLaunching: case eStateSuspended: case eStateCrashed: case eStateStopped: break; case eStateDetached: case eStateExited: case eStateUnloaded: if (GetFlags().IsSet(CommandObject::eFlagProcessMustBeLaunched)) { result.AppendError ("Process must be launched."); result.SetStatus (eReturnStatusFailed); return false; } break; case eStateRunning: case eStateStepping: if (GetFlags().IsSet(CommandObject::eFlagProcessMustBePaused)) { result.AppendError ("Process is running. Use 'process interrupt' to pause execution."); result.SetStatus (eReturnStatusFailed); return false; } } } if (!ParseOptions (interpreter, args, result)) return false; // Call the command-specific version of 'Execute', passing it the already processed arguments. return Execute (interpreter, args, result); }
virtual bool Execute (CommandInterpreter &interpreter, Args& args, CommandReturnObject &result) { if (args.GetArgumentCount() < 1) { result.GetErrorStream() << m_cmd_syntax.c_str(); } else { Log::Callbacks log_callbacks; std::string channel(args.GetArgumentAtIndex(0)); args.Shift (); // Shift off the channel StreamSP log_stream_sp; if (m_options.log_file.empty()) { log_stream_sp.reset(new StreamFile(interpreter.GetDebugger().GetOutputFileHandle())); } else { LogStreamMap::iterator pos = m_log_streams.find(m_options.log_file); if (pos == m_log_streams.end()) { log_stream_sp.reset (new StreamFile (m_options.log_file.c_str(), "w")); m_log_streams[m_options.log_file] = log_stream_sp; } else log_stream_sp = pos->second; } assert (log_stream_sp.get()); uint32_t log_options = m_options.log_options; if (log_options == 0) log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE; if (Log::GetLogChannelCallbacks (channel.c_str(), log_callbacks)) { log_callbacks.enable (log_stream_sp, log_options, args, &result.GetErrorStream()); result.SetStatus(eReturnStatusSuccessFinishNoResult); } else { LogChannelSP log_channel_sp (GetLogChannelPluginForChannel(channel.c_str())); if (log_channel_sp) { if (log_channel_sp->Enable (log_stream_sp, log_options, &result.GetErrorStream(), args)) { result.SetStatus (eReturnStatusSuccessFinishNoResult); } else { result.AppendErrorWithFormat("Invalid log channel '%s'.\n", channel.c_str()); result.SetStatus (eReturnStatusFailed); } } else { result.AppendErrorWithFormat("Invalid log channel '%s'.\n", channel.c_str()); result.SetStatus (eReturnStatusFailed); } } } return result.Succeeded(); }