#define liblldb_IOHandler_h_
#include "lldb/Core/ValueObjectList.h"
+#include "lldb/Utility/CompletionRequest.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Flags.h"
#include "lldb/Utility/Predicate.h"
virtual void IOHandlerDeactivated(IOHandler &io_handler) {}
- virtual int IOHandlerComplete(IOHandler &io_handler, const char *current_line,
- const char *cursor, const char *last_char,
- StringList &matches, StringList &descriptions);
+ virtual int IOHandlerComplete(IOHandler &io_handler,
+ CompletionRequest &request);
virtual const char *IOHandlerGetFixIndentationCharacters() { return nullptr; }
static int FixIndentationCallback(Editline *editline, const StringList &lines,
int cursor_position, void *baton);
- static int AutoCompleteCallback(const char *current_line, const char *cursor,
- const char *last_char,
- StringList &matches, StringList &descriptions,
- void *baton);
+ static int AutoCompleteCallback(CompletionRequest &request, void *baton);
#endif
protected:
bool GetResponse() const { return m_user_response; }
- int IOHandlerComplete(IOHandler &io_handler, const char *current_line,
- const char *cursor, const char *last_char,
- StringList &matches, StringList &descriptions) override;
+ int IOHandlerComplete(IOHandler &io_handler,
+ CompletionRequest &request) override;
void IOHandlerInputComplete(IOHandler &io_handler,
std::string &data) override;
void IOHandlerInputComplete(IOHandler &io_handler,
std::string &line) override;
- int IOHandlerComplete(IOHandler &io_handler, const char *current_line,
- const char *cursor, const char *last_char,
- StringList &matches, StringList &descriptions) override;
+ int IOHandlerComplete(IOHandler &io_handler,
+ CompletionRequest &request) override;
protected:
static int CalculateActualIndentation(const StringList &lines);
#include <vector>
#include "lldb/Host/ConnectionFileDescriptor.h"
+#include "lldb/Utility/CompletionRequest.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Predicate.h"
const StringList &lines,
int cursor_position, void *baton);
-typedef int (*CompleteCallbackType)(const char *current_line,
- const char *cursor, const char *last_char,
- StringList &matches,
- StringList &descriptions, void *baton);
+typedef int (*CompleteCallbackType)(CompletionRequest &request, void *baton);
/// Status used to decide when and how to start editing another line in
/// multi-line sessions
CommandObject *GetCommandObjectForCommand(llvm::StringRef &command_line);
- // This handles command line completion. You are given a pointer to the
- // command string buffer, to the current cursor, and to the end of the string
- // (in case it is not NULL terminated). You also passed in an StringList
- // object to fill with the returns. The first element of the array will be
- // filled with the string that you would need to insert at the cursor point
- // to complete the cursor point to the longest common matching prefix. If you
- // want to limit the number of elements returned, set max_return_elements to
- // the number of elements you want returned. Otherwise set
- // max_return_elements to -1. If you want to start some way into the match
- // list, then set match_start_point to the desired start point. Returns: -1
+ // This handles command line completion. Returns: -1
// if the completion character should be inserted -2 if the entire command
// line should be deleted and replaced with matches.GetStringAtIndex(0)
// INT_MAX if the number of matches is > max_return_elements, but it is
// expensive to compute. Otherwise, returns the number of matches.
//
// FIXME: Only max_return_elements == -1 is supported at present.
- int HandleCompletion(const char *current_line, const char *cursor,
- const char *last_char, StringList &matches,
- StringList &descriptions);
+ int HandleCompletion(CompletionRequest &request);
- // This version just returns matches, and doesn't compute the substring. It
- // is here so the Help command can call it for the first argument. It uses
- // a CompletionRequest for simplicity reasons.
+ // This version just returns matches, and doesn't compute the substring. It
+ // is here so the Help command can call it for the first argument.
int HandleCompletionMatches(CompletionRequest &request);
int GetCommandNamesMatchingPartialString(const char *cmd_cstr,
CompletionResult &result);
llvm::StringRef GetRawLine() const { return m_command; }
+ llvm::StringRef GetRawLineUntilCursor() const {
+ return m_command.substr(0, m_cursor_index);
+ }
unsigned GetRawCursorPos() const { return m_raw_cursor_pos; }
if (IsValid()) {
lldb_private::StringList lldb_matches, lldb_descriptions;
- num_completions = m_opaque_ptr->HandleCompletion(
- current_line, cursor, last_char, lldb_matches, lldb_descriptions);
+ CompletionResult result;
+ CompletionRequest request(current_line, cursor - current_line, result);
+ num_completions = m_opaque_ptr->HandleCompletion(request);
+ result.GetMatches(lldb_matches);
+ result.GetDescriptions(lldb_descriptions);
SBStringList temp_matches_list(&lldb_matches);
matches.AppendList(temp_matches_list);
IOHandlerConfirm::~IOHandlerConfirm() = default;
-int IOHandlerConfirm::IOHandlerComplete(
- IOHandler &io_handler, const char *current_line, const char *cursor,
- const char *last_char, StringList &matches, StringList &descriptions) {
- if (current_line == cursor) {
- if (m_default_response) {
- matches.AppendString("y");
- } else {
- matches.AppendString("n");
- }
+int IOHandlerConfirm::IOHandlerComplete(IOHandler &io_handler,
+ CompletionRequest &request) {
+ if (request.GetRawCursorPos() == 0) {
+ if (m_default_response)
+ request.AddCompletion("y");
+ else
+ request.AddCompletion("n");
}
- return matches.GetSize();
+ return request.GetNumberOfMatches();
}
void IOHandlerConfirm::IOHandlerInputComplete(IOHandler &io_handler,
}
}
-int IOHandlerDelegate::IOHandlerComplete(
- IOHandler &io_handler, const char *current_line, const char *cursor,
- const char *last_char, StringList &matches, StringList &descriptions) {
+int IOHandlerDelegate::IOHandlerComplete(IOHandler &io_handler,
+ CompletionRequest &request) {
switch (m_completion) {
case Completion::None:
break;
case Completion::LLDBCommand:
return io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(
- current_line, cursor, last_char, matches, descriptions);
+ request);
case Completion::Expression: {
CompletionResult result;
- CompletionRequest request(current_line, cursor - current_line, result);
+ CompletionRequest subrequest(request.GetRawLine(),
+ request.GetRawCursorPos(), result);
CommandCompletions::InvokeCommonCompletionCallbacks(
io_handler.GetDebugger().GetCommandInterpreter(),
- CommandCompletions::eVariablePathCompletion, request, nullptr);
+ CommandCompletions::eVariablePathCompletion, subrequest, nullptr);
+ StringList matches;
+ StringList descriptions;
result.GetMatches(matches);
result.GetDescriptions(descriptions);
- size_t num_matches = request.GetNumberOfMatches();
+ size_t num_matches = subrequest.GetNumberOfMatches();
if (num_matches > 0) {
std::string common_prefix = matches.LongestCommonPrefix();
- const size_t partial_name_len = request.GetCursorArgumentPrefix().size();
+ const size_t partial_name_len =
+ subrequest.GetCursorArgumentPrefix().size();
// If we matched a unique single command, add a space... Only do this if
// the completer told us this was a complete word, however...
- if (num_matches == 1 && request.GetWordComplete()) {
+ if (num_matches == 1 && subrequest.GetWordComplete()) {
common_prefix.push_back(' ');
}
common_prefix.erase(0, partial_name_len);
- matches.InsertStringAtIndex(0, std::move(common_prefix));
+ request.AddCompletion(common_prefix);
}
- return num_matches;
+ request.AddCompletions(matches, descriptions);
+ return request.GetNumberOfMatches();
} break;
}
*editline_reader, lines, cursor_position);
}
-int IOHandlerEditline::AutoCompleteCallback(
- const char *current_line, const char *cursor, const char *last_char,
- StringList &matches, StringList &descriptions, void *baton) {
+int IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request,
+ void *baton) {
IOHandlerEditline *editline_reader = (IOHandlerEditline *)baton;
if (editline_reader)
- return editline_reader->m_delegate.IOHandlerComplete(
- *editline_reader, current_line, cursor, last_char, matches,
- descriptions);
+ return editline_reader->m_delegate.IOHandlerComplete(*editline_reader,
+ request);
return 0;
}
#endif
}
}
-int REPL::IOHandlerComplete(IOHandler &io_handler, const char *current_line,
- const char *cursor, const char *last_char,
- StringList &matches, StringList &descriptions) {
- matches.Clear();
-
- llvm::StringRef line(current_line, cursor - current_line);
-
+int REPL::IOHandlerComplete(IOHandler &io_handler, CompletionRequest &request) {
// Complete an LLDB command if the first character is a colon...
- if (!line.empty() && line[0] == ':') {
+ if (request.GetRawLine().startswith(":")) {
Debugger &debugger = m_target.GetDebugger();
// auto complete LLDB commands
- const char *lldb_current_line = line.substr(1).data();
- return debugger.GetCommandInterpreter().HandleCompletion(
- lldb_current_line, cursor, last_char, matches, descriptions);
+ llvm::StringRef new_line = request.GetRawLine().drop_front();
+ CompletionResult sub_result;
+ CompletionRequest sub_request(new_line, request.GetRawCursorPos() - 1,
+ sub_result);
+ int result = debugger.GetCommandInterpreter().HandleCompletion(sub_request);
+ StringList matches, descriptions;
+ sub_result.GetMatches(matches);
+ sub_result.GetDescriptions(descriptions);
+ request.AddCompletions(matches, descriptions);
+ return result;
}
// Strip spaces from the line and see if we had only spaces
- line = line.ltrim();
- if (line.empty()) {
+ if (request.GetRawLineUntilCursor().trim().empty()) {
// Only spaces on this line, so just indent
- matches.AppendString(m_indent_str);
+ request.AddCompletion(m_indent_str);
return 1;
}
}
}
- if (cursor > current_line) {
- current_code.append("\n");
- current_code.append(current_line, cursor - current_line);
- }
+ current_code.append("\n");
+ current_code += request.GetRawLineUntilCursor();
- return CompleteCode(current_code, matches);
+ StringList matches;
+ int result = CompleteCode(current_code, matches);
+ request.AddCompletions(matches);
+ return result;
}
bool QuitCommandOverrideCallback(void *baton, const char **argv) {
#include "lldb/Host/Editline.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h"
+#include "lldb/Utility/CompletionRequest.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/SelectHelper.h"
StringList completions, descriptions;
int page_size = 40;
- const int num_completions = m_completion_callback(
- line_info->buffer, line_info->cursor, line_info->lastchar,
- completions, descriptions, m_completion_callback_baton);
+ llvm::StringRef line(line_info->buffer,
+ line_info->lastchar - line_info->buffer);
+ unsigned cursor_index = line_info->cursor - line_info->buffer;
+ CompletionResult result;
+ CompletionRequest request(line, cursor_index, result);
+
+ const int num_completions =
+ m_completion_callback(request, m_completion_callback_baton);
+
+ result.GetMatches(completions);
+ result.GetDescriptions(descriptions);
if (num_completions == 0)
return CC_ERROR;
return num_command_matches;
}
-int CommandInterpreter::HandleCompletion(const char *current_line,
- const char *cursor,
- const char *last_char,
- StringList &matches,
- StringList &descriptions) {
-
- llvm::StringRef command_line(current_line, last_char - current_line);
+int CommandInterpreter::HandleCompletion(CompletionRequest &orig_request) {
+ // Start a new subrequest we can modify.
CompletionResult result;
- CompletionRequest request(command_line, cursor - current_line, result);
+ CompletionRequest request(orig_request.GetRawLine(),
+ orig_request.GetRawCursorPos(), result);
// Don't complete comments, and if the line we are completing is just the
// history repeat character, substitute the appropriate history line.
const char *first_arg = request.GetParsedLine().GetArgumentAtIndex(0);
+ StringList matches, descriptions;
+
if (first_arg) {
if (first_arg[0] == m_comment_char)
return 0;
matches.InsertStringAtIndex(0, common_prefix.c_str());
descriptions.InsertStringAtIndex(0, "");
}
+ // Add completion to original request.
+ orig_request.AddCompletions(matches, descriptions);
return num_command_matches;
}