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);
}
int
SwiftREPL::CompleteCode(const std::string ¤t_code,
lldb_private::StringList &matches)
{
//----------------------------------------------------------------------g
// If we use the target's SwiftASTContext for completion, it reaaallly
// slows down subsequent expressions. The compiler team doesn't have time
// to fix this issue currently, so we need to work around it by making
// our own copy of the AST and using this separate AST for completion.
//----------------------------------------------------------------------
Error error;
#define USE_SEPARATE_AST_FOR_COMPLETION
#if defined(USE_SEPARATE_AST_FOR_COMPLETION)
if (!m_swift_ast_sp)
{
SwiftASTContext *target_swift_ast = m_target.GetScratchSwiftASTContext(error);
if (target_swift_ast)
m_swift_ast_sp.reset (new SwiftASTContext(*target_swift_ast));
}
SwiftASTContext *swift_ast = m_swift_ast_sp.get();
#else
SwiftASTContext *swift_ast = m_target.GetScratchSwiftASTContext(error);
#endif
if (swift_ast)
{
swift::ASTContext *ast = swift_ast->GetASTContext();
swift::REPLCompletions completions;
static ConstString g_repl_module_name("repl");
swift::ModuleDecl *repl_module = swift_ast->GetModule (g_repl_module_name, error);
if (repl_module == NULL)
{
repl_module = swift_ast->CreateModule(g_repl_module_name, error);
const swift::SourceFile::ImplicitModuleImportKind implicit_import_kind = swift::SourceFile::ImplicitModuleImportKind::Stdlib;
llvm::Optional<unsigned> bufferID;
swift::SourceFile *repl_source_file = new (*ast) swift::SourceFile(*repl_module,
swift::SourceFileKind::REPL,
bufferID,
implicit_import_kind);
repl_module->addFile(*repl_source_file);
}
if (repl_module)
{
swift::SourceFile &repl_source_file = repl_module->getMainSourceFile(swift::SourceFileKind::REPL);
llvm::StringRef current_code_ref(current_code);
completions.populate(repl_source_file, current_code_ref);
llvm::StringRef root = completions.getRoot();
if (!root.empty())
{
matches.AppendString(root.data(), root.size());
return 1;
}
// llvm::StringRef prev_stem = completions.getPreviousStem();
// llvm::StringRef next_stem = completions.getNextStem();
// printf ("\nroot: '%*s'", (int)root.size(), root.data());
// printf ("\nprev_stem: '%*s'", (int)prev_stem.size(), prev_stem.data());
// printf ("\nnext_stem: '%*s'", (int)next_stem.size(), next_stem.data());
// printf ("\nvalid: %i", completions.isValid());
// printf ("\nempty: %i", completions.isEmpty());
// printf ("\nunique: %i", completions.isUnique());
// Otherwise, advance through the completion state machine.
const swift::CompletionState completion_state = completions.getState();
switch (completion_state)
{
case swift::CompletionState::CompletedRoot:
{
// We completed the root. Next step is to display the completion list.
matches.AppendString(""); // Empty string to indicate no completion,
// just display other strings that come after it
llvm::ArrayRef<llvm::StringRef> llvm_matches = completions.getCompletionList();
for (const auto &llvm_match : llvm_matches)
{
if (!llvm_match.empty())
matches.AppendString(llvm_match.data(), llvm_match.size());
}
// Don't include the empty string we appended above or we will display one
// too many we need to return the magical value of one less than our actual matches.
// TODO: modify all IOHandlerDelegate::IOHandlerComplete() to use a CompletionMatches
// class that wraps up the "StringList matches;" along with other smarts so we don't
// have to return magic values and incorrect sizes.
return matches.GetSize() - 1;
}
break;
case swift::CompletionState::DisplayedCompletionList:
{
// Complete the next completion stem in the cycle.
llvm::StringRef stem = completions.getPreviousStem().InsertableString;
matches.AppendString(stem.data(), stem.size());
}
break;
case swift::CompletionState::Empty:
case swift::CompletionState::Unique:
// We already provided a definitive completion--nothing else to do.
break;
case swift::CompletionState::Invalid:
llvm_unreachable("got an invalid completion set?!");
}
}
}
return matches.GetSize();
}
bool Options::HandleOptionCompletion(
Args &input, OptionElementVector &opt_element_vector, int cursor_index,
int char_pos, int match_start_point, int max_return_elements,
CommandInterpreter &interpreter, bool &word_complete,
lldb_private::StringList &matches) {
word_complete = true;
// For now we just scan the completions to see if the cursor position is in
// an option or its argument. Otherwise we'll call HandleArgumentCompletion.
// In the future we can use completion to validate options as well if we want.
auto opt_defs = GetDefinitions();
std::string cur_opt_std_str(input.GetArgumentAtIndex(cursor_index));
cur_opt_std_str.erase(char_pos);
const char *cur_opt_str = cur_opt_std_str.c_str();
for (size_t i = 0; i < opt_element_vector.size(); i++) {
int opt_pos = opt_element_vector[i].opt_pos;
int opt_arg_pos = opt_element_vector[i].opt_arg_pos;
int opt_defs_index = opt_element_vector[i].opt_defs_index;
if (opt_pos == cursor_index) {
// We're completing the option itself.
if (opt_defs_index == OptionArgElement::eBareDash) {
// We're completing a bare dash. That means all options are open.
// FIXME: We should scan the other options provided and only complete
// options
// within the option group they belong to.
char opt_str[3] = {'-', 'a', '\0'};
for (auto &def : opt_defs) {
if (!def.short_option)
continue;
opt_str[1] = def.short_option;
matches.AppendString(opt_str);
}
return true;
} else if (opt_defs_index == OptionArgElement::eBareDoubleDash) {
std::string full_name("--");
for (auto &def : opt_defs) {
if (!def.short_option)
continue;
full_name.erase(full_name.begin() + 2, full_name.end());
full_name.append(def.long_option);
matches.AppendString(full_name.c_str());
}
return true;
} else if (opt_defs_index != OptionArgElement::eUnrecognizedArg) {
// We recognized it, if it an incomplete long option, complete it anyway
// (getopt_long_only is
// happy with shortest unique string, but it's still a nice thing to
// do.) Otherwise return
// The string so the upper level code will know this is a full match and
// add the " ".
if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
cur_opt_str[1] == '-' &&
strcmp(opt_defs[opt_defs_index].long_option, cur_opt_str) != 0) {
std::string full_name("--");
full_name.append(opt_defs[opt_defs_index].long_option);
matches.AppendString(full_name.c_str());
return true;
} else {
matches.AppendString(input.GetArgumentAtIndex(cursor_index));
return true;
}
} else {
// FIXME - not handling wrong options yet:
// Check to see if they are writing a long option & complete it.
// I think we will only get in here if the long option table has two
// elements
// that are not unique up to this point. getopt_long_only does shortest
// unique match
// for long options already.
if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
cur_opt_str[1] == '-') {
for (auto &def : opt_defs) {
if (!def.long_option)
continue;
if (strstr(def.long_option, cur_opt_str + 2) == def.long_option) {
std::string full_name("--");
full_name.append(def.long_option);
// The options definitions table has duplicates because of the
// way the grouping information is stored, so only add once.
bool duplicate = false;
for (size_t k = 0; k < matches.GetSize(); k++) {
if (matches.GetStringAtIndex(k) == full_name) {
duplicate = true;
break;
}
}
if (!duplicate)
matches.AppendString(full_name.c_str());
}
}
}
return true;
}
} else if (opt_arg_pos == cursor_index) {
// Okay the cursor is on the completion of an argument.
// See if it has a completion, otherwise return no matches.
if (opt_defs_index != -1) {
HandleOptionArgumentCompletion(
input, cursor_index, strlen(input.GetArgumentAtIndex(cursor_index)),
opt_element_vector, i, match_start_point, max_return_elements,
interpreter, word_complete, matches);
return true;
} else {
// No completion callback means no completions...
return true;
}
} else {
// Not the last element, keep going.
continue;
}
}
return false;
}