maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/source/Interpreter/Options.cpp

954 lines
32 KiB
C++
Raw Blame History

//===-- Options.cpp ---------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Interpreter/Options.h"
// C Includes
// C++ Includes
#include <algorithm>
#include <bitset>
#include <map>
#include <set>
// Other libraries and framework includes
// Project includes
#include "lldb/Host/OptionParser.h"
#include "lldb/Interpreter/CommandCompletions.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h"
using namespace lldb;
using namespace lldb_private;
//-------------------------------------------------------------------------
// Options
//-------------------------------------------------------------------------
Options::Options() : m_getopt_table() { BuildValidOptionSets(); }
Options::~Options() {}
void Options::NotifyOptionParsingStarting(ExecutionContext *execution_context) {
m_seen_options.clear();
// Let the subclass reset its option values
OptionParsingStarting(execution_context);
}
Status
Options::NotifyOptionParsingFinished(ExecutionContext *execution_context) {
return OptionParsingFinished(execution_context);
}
void Options::OptionSeen(int option_idx) { m_seen_options.insert(option_idx); }
// Returns true is set_a is a subset of set_b; Otherwise returns false.
bool Options::IsASubset(const OptionSet &set_a, const OptionSet &set_b) {
bool is_a_subset = true;
OptionSet::const_iterator pos_a;
OptionSet::const_iterator pos_b;
// set_a is a subset of set_b if every member of set_a is also a member of
// set_b
for (pos_a = set_a.begin(); pos_a != set_a.end() && is_a_subset; ++pos_a) {
pos_b = set_b.find(*pos_a);
if (pos_b == set_b.end())
is_a_subset = false;
}
return is_a_subset;
}
// Returns the set difference set_a - set_b, i.e. { x | ElementOf (x, set_a) &&
// !ElementOf (x, set_b) }
size_t Options::OptionsSetDiff(const OptionSet &set_a, const OptionSet &set_b,
OptionSet &diffs) {
size_t num_diffs = 0;
OptionSet::const_iterator pos_a;
OptionSet::const_iterator pos_b;
for (pos_a = set_a.begin(); pos_a != set_a.end(); ++pos_a) {
pos_b = set_b.find(*pos_a);
if (pos_b == set_b.end()) {
++num_diffs;
diffs.insert(*pos_a);
}
}
return num_diffs;
}
// Returns the union of set_a and set_b. Does not put duplicate members into
// the union.
void Options::OptionsSetUnion(const OptionSet &set_a, const OptionSet &set_b,
OptionSet &union_set) {
OptionSet::const_iterator pos;
OptionSet::iterator pos_union;
// Put all the elements of set_a into the union.
for (pos = set_a.begin(); pos != set_a.end(); ++pos)
union_set.insert(*pos);
// Put all the elements of set_b that are not already there into the union.
for (pos = set_b.begin(); pos != set_b.end(); ++pos) {
pos_union = union_set.find(*pos);
if (pos_union == union_set.end())
union_set.insert(*pos);
}
}
bool Options::VerifyOptions(CommandReturnObject &result) {
bool options_are_valid = false;
int num_levels = GetRequiredOptions().size();
if (num_levels) {
for (int i = 0; i < num_levels && !options_are_valid; ++i) {
// This is the correct set of options if: 1). m_seen_options contains all
// of m_required_options[i]
// (i.e. all the required options at this level are a subset of
// m_seen_options); AND
// 2). { m_seen_options - m_required_options[i] is a subset of
// m_options_options[i] (i.e. all the rest of
// m_seen_options are in the set of optional options at this level.
// Check to see if all of m_required_options[i] are a subset of
// m_seen_options
if (IsASubset(GetRequiredOptions()[i], m_seen_options)) {
// Construct the set difference: remaining_options = {m_seen_options} -
// {m_required_options[i]}
OptionSet remaining_options;
OptionsSetDiff(m_seen_options, GetRequiredOptions()[i],
remaining_options);
// Check to see if remaining_options is a subset of
// m_optional_options[i]
if (IsASubset(remaining_options, GetOptionalOptions()[i]))
options_are_valid = true;
}
}
} else {
options_are_valid = true;
}
if (options_are_valid) {
result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else {
result.AppendError("invalid combination of options for the given command");
result.SetStatus(eReturnStatusFailed);
}
return options_are_valid;
}
// This is called in the Options constructor, though we could call it lazily if
// that ends up being
// a performance problem.
void Options::BuildValidOptionSets() {
// Check to see if we already did this.
if (m_required_options.size() != 0)
return;
// Check to see if there are any options.
int num_options = NumCommandOptions();
if (num_options == 0)
return;
auto opt_defs = GetDefinitions();
m_required_options.resize(1);
m_optional_options.resize(1);
// First count the number of option sets we've got. Ignore
// LLDB_ALL_OPTION_SETS...
uint32_t num_option_sets = 0;
for (const auto &def : opt_defs) {
uint32_t this_usage_mask = def.usage_mask;
if (this_usage_mask == LLDB_OPT_SET_ALL) {
if (num_option_sets == 0)
num_option_sets = 1;
} else {
for (uint32_t j = 0; j < LLDB_MAX_NUM_OPTION_SETS; j++) {
if (this_usage_mask & (1 << j)) {
if (num_option_sets <= j)
num_option_sets = j + 1;
}
}
}
}
if (num_option_sets > 0) {
m_required_options.resize(num_option_sets);
m_optional_options.resize(num_option_sets);
for (const auto &def : opt_defs) {
for (uint32_t j = 0; j < num_option_sets; j++) {
if (def.usage_mask & 1 << j) {
if (def.required)
m_required_options[j].insert(def.short_option);
else
m_optional_options[j].insert(def.short_option);
}
}
}
}
}
uint32_t Options::NumCommandOptions() { return GetDefinitions().size(); }
Option *Options::GetLongOptions() {
// Check to see if this has already been done.
if (m_getopt_table.empty()) {
auto defs = GetDefinitions();
if (defs.empty())
return nullptr;
std::map<int, uint32_t> option_seen;
m_getopt_table.resize(defs.size() + 1);
for (size_t i = 0; i < defs.size(); ++i) {
const int short_opt = defs[i].short_option;
m_getopt_table[i].definition = &defs[i];
m_getopt_table[i].flag = nullptr;
m_getopt_table[i].val = short_opt;
if (option_seen.find(short_opt) == option_seen.end()) {
option_seen[short_opt] = i;
} else if (short_opt) {
m_getopt_table[i].val = 0;
std::map<int, uint32_t>::const_iterator pos =
option_seen.find(short_opt);
StreamString strm;
if (isprint8(short_opt))
Host::SystemLog(Host::eSystemLogError,
"option[%u] --%s has a short option -%c that "
"conflicts with option[%u] --%s, short option won't "
"be used for --%s\n",
(int)i, defs[i].long_option, short_opt, pos->second,
m_getopt_table[pos->second].definition->long_option,
defs[i].long_option);
else
Host::SystemLog(Host::eSystemLogError,
"option[%u] --%s has a short option 0x%x that "
"conflicts with option[%u] --%s, short option won't "
"be used for --%s\n",
(int)i, defs[i].long_option, short_opt, pos->second,
m_getopt_table[pos->second].definition->long_option,
defs[i].long_option);
}
}
// getopt_long_only requires a NULL final entry in the table:
m_getopt_table.back().definition = nullptr;
m_getopt_table.back().flag = nullptr;
m_getopt_table.back().val = 0;
}
if (m_getopt_table.empty())
return nullptr;
return &m_getopt_table.front();
}
// This function takes INDENT, which tells how many spaces to output at the
// front of each line; SPACES, which is
// a string containing 80 spaces; and TEXT, which is the text that is to be
// output. It outputs the text, on
// multiple lines if necessary, to RESULT, with INDENT spaces at the front of
// each line. It breaks lines on spaces,
// tabs or newlines, shortening the line if necessary to not break in the middle
// of a word. It assumes that each
// output line should contain a maximum of OUTPUT_MAX_COLUMNS characters.
void Options::OutputFormattedUsageText(Stream &strm,
const OptionDefinition &option_def,
uint32_t output_max_columns) {
std::string actual_text;
if (option_def.validator) {
const char *condition = option_def.validator->ShortConditionString();
if (condition) {
actual_text = "[";
actual_text.append(condition);
actual_text.append("] ");
}
}
actual_text.append(option_def.usage_text);
// Will it all fit on one line?
if (static_cast<uint32_t>(actual_text.length() + strm.GetIndentLevel()) <
output_max_columns) {
// Output it as a single line.
strm.Indent(actual_text.c_str());
strm.EOL();
} else {
// We need to break it up into multiple lines.
int text_width = output_max_columns - strm.GetIndentLevel() - 1;
int start = 0;
int end = start;
int final_end = actual_text.length();
int sub_len;
while (end < final_end) {
// Don't start the 'text' on a space, since we're already outputting the
// indentation.
while ((start < final_end) && (actual_text[start] == ' '))
start++;
end = start + text_width;
if (end > final_end)
end = final_end;
else {
// If we're not at the end of the text, make sure we break the line on
// white space.
while (end > start && actual_text[end] != ' ' &&
actual_text[end] != '\t' && actual_text[end] != '\n')
end--;
}
sub_len = end - start;
if (start != 0)
strm.EOL();
strm.Indent();
assert(start < final_end);
assert(start + sub_len <= final_end);
strm.Write(actual_text.c_str() + start, sub_len);
start = end + 1;
}
strm.EOL();
}
}
bool Options::SupportsLongOption(const char *long_option) {
if (!long_option || !long_option[0])
return false;
auto opt_defs = GetDefinitions();
if (opt_defs.empty())
return false;
const char *long_option_name = long_option;
if (long_option[0] == '-' && long_option[1] == '-')
long_option_name += 2;
for (auto &def : opt_defs) {
if (!def.long_option)
continue;
if (strcmp(def.long_option, long_option_name) == 0)
return true;
}
return false;
}
enum OptionDisplayType {
eDisplayBestOption,
eDisplayShortOption,
eDisplayLongOption
};
static bool PrintOption(const OptionDefinition &opt_def,
OptionDisplayType display_type, const char *header,
const char *footer, bool show_optional, Stream &strm) {
const bool has_short_option = isprint8(opt_def.short_option) != 0;
if (display_type == eDisplayShortOption && !has_short_option)
return false;
if (header && header[0])
strm.PutCString(header);
if (show_optional && !opt_def.required)
strm.PutChar('[');
const bool show_short_option =
has_short_option && display_type != eDisplayLongOption;
if (show_short_option)
strm.Printf("-%c", opt_def.short_option);
else
strm.Printf("--%s", opt_def.long_option);
switch (opt_def.option_has_arg) {
case OptionParser::eNoArgument:
break;
case OptionParser::eRequiredArgument:
strm.Printf(" <%s>", CommandObject::GetArgumentName(opt_def.argument_type));
break;
case OptionParser::eOptionalArgument:
strm.Printf("%s[<%s>]", show_short_option ? "" : "=",
CommandObject::GetArgumentName(opt_def.argument_type));
break;
}
if (show_optional && !opt_def.required)
strm.PutChar(']');
if (footer && footer[0])
strm.PutCString(footer);
return true;
}
void Options::GenerateOptionUsage(Stream &strm, CommandObject *cmd,
uint32_t screen_width) {
const bool only_print_args = cmd->IsDashDashCommand();
auto opt_defs = GetDefinitions();
const uint32_t save_indent_level = strm.GetIndentLevel();
llvm::StringRef name;
StreamString arguments_str;
if (cmd) {
name = cmd->GetCommandName();
cmd->GetFormattedCommandArguments(arguments_str);
} else
name = "";
strm.PutCString("\nCommand Options Usage:\n");
strm.IndentMore(2);
// First, show each usage level set of options, e.g. <cmd>
// [options-for-level-0]
// <cmd>
// [options-for-level-1]
// etc.
const uint32_t num_options = NumCommandOptions();
if (num_options == 0)
return;
uint32_t num_option_sets = GetRequiredOptions().size();
uint32_t i;
if (!only_print_args) {
for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
uint32_t opt_set_mask;
opt_set_mask = 1 << opt_set;
if (opt_set > 0)
strm.Printf("\n");
strm.Indent(name);
// Different option sets may require different args.
StreamString args_str;
if (cmd)
cmd->GetFormattedCommandArguments(args_str, opt_set_mask);
// First go through and print all options that take no arguments as
// a single string. If a command has "-a" "-b" and "-c", this will show
// up as [-abc]
std::set<int> options;
std::set<int>::const_iterator options_pos, options_end;
for (auto &def : opt_defs) {
if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
// Add current option to the end of out_stream.
if (def.required && def.option_has_arg == OptionParser::eNoArgument) {
options.insert(def.short_option);
}
}
}
if (options.empty() == false) {
// We have some required options with no arguments
strm.PutCString(" -");
for (i = 0; i < 2; ++i)
for (options_pos = options.begin(), options_end = options.end();
options_pos != options_end; ++options_pos) {
if (i == 0 && ::islower(*options_pos))
continue;
if (i == 1 && ::isupper(*options_pos))
continue;
strm << (char)*options_pos;
}
}
options.clear();
for (auto &def : opt_defs) {
if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
// Add current option to the end of out_stream.
if (def.required == false &&
def.option_has_arg == OptionParser::eNoArgument) {
options.insert(def.short_option);
}
}
}
if (options.empty() == false) {
// We have some required options with no arguments
strm.PutCString(" [-");
for (i = 0; i < 2; ++i)
for (options_pos = options.begin(), options_end = options.end();
options_pos != options_end; ++options_pos) {
if (i == 0 && ::islower(*options_pos))
continue;
if (i == 1 && ::isupper(*options_pos))
continue;
strm << (char)*options_pos;
}
strm.PutChar(']');
}
// First go through and print the required options (list them up front).
for (auto &def : opt_defs) {
if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
if (def.required && def.option_has_arg != OptionParser::eNoArgument)
PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
}
}
// Now go through again, and this time only print the optional options.
for (auto &def : opt_defs) {
if (def.usage_mask & opt_set_mask) {
// Add current option to the end of out_stream.
if (!def.required && def.option_has_arg != OptionParser::eNoArgument)
PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
}
}
if (args_str.GetSize() > 0) {
if (cmd->WantsRawCommandString() && !only_print_args)
strm.Printf(" --");
strm << " " << args_str.GetString();
if (only_print_args)
break;
}
}
}
if (cmd && (only_print_args || cmd->WantsRawCommandString()) &&
arguments_str.GetSize() > 0) {
if (!only_print_args)
strm.PutChar('\n');
strm.Indent(name);
strm << " " << arguments_str.GetString();
}
strm.Printf("\n\n");
if (!only_print_args) {
// Now print out all the detailed information about the various options:
// long form, short form and help text:
// -short <argument> ( --long_name <argument> )
// help text
// This variable is used to keep track of which options' info we've printed
// out, because some options can be in
// more than one usage level, but we only want to print the long form of its
// information once.
std::multimap<int, uint32_t> options_seen;
strm.IndentMore(5);
// Put the unique command options in a vector & sort it, so we can output
// them alphabetically (by short_option)
// when writing out detailed help for each option.
i = 0;
for (auto &def : opt_defs)
options_seen.insert(std::make_pair(def.short_option, i++));
// Go through the unique'd and alphabetically sorted vector of options, find
// the table entry for each option
// and write out the detailed help information for that option.
bool first_option_printed = false;
for (auto pos : options_seen) {
i = pos.second;
// Print out the help information for this option.
// Put a newline separation between arguments
if (first_option_printed)
strm.EOL();
else
first_option_printed = true;
CommandArgumentType arg_type = opt_defs[i].argument_type;
StreamString arg_name_str;
arg_name_str.Printf("<%s>", CommandObject::GetArgumentName(arg_type));
strm.Indent();
if (opt_defs[i].short_option && isprint8(opt_defs[i].short_option)) {
PrintOption(opt_defs[i], eDisplayShortOption, nullptr, nullptr, false,
strm);
PrintOption(opt_defs[i], eDisplayLongOption, " ( ", " )", false, strm);
} else {
// Short option is not printable, just print long option
PrintOption(opt_defs[i], eDisplayLongOption, nullptr, nullptr, false,
strm);
}
strm.EOL();
strm.IndentMore(5);
if (opt_defs[i].usage_text)
OutputFormattedUsageText(strm, opt_defs[i], screen_width);
if (opt_defs[i].enum_values != nullptr) {
strm.Indent();
strm.Printf("Values: ");
for (int k = 0; opt_defs[i].enum_values[k].string_value != nullptr;
k++) {
if (k == 0)
strm.Printf("%s", opt_defs[i].enum_values[k].string_value);
else
strm.Printf(" | %s", opt_defs[i].enum_values[k].string_value);
}
strm.EOL();
}
strm.IndentLess(5);
}
}
// Restore the indent level
strm.SetIndentLevel(save_indent_level);
}
// This function is called when we have been given a potentially incomplete set
// of
// options, such as when an alias has been defined (more options might be added
// at
// at the time the alias is invoked). We need to verify that the options in the
// set
// m_seen_options are all part of a set that may be used together, but
// m_seen_options
// may be missing some of the "required" options.
bool Options::VerifyPartialOptions(CommandReturnObject &result) {
bool options_are_valid = false;
int num_levels = GetRequiredOptions().size();
if (num_levels) {
for (int i = 0; i < num_levels && !options_are_valid; ++i) {
// In this case we are treating all options as optional rather than
// required.
// Therefore a set of options is correct if m_seen_options is a subset of
// the
// union of m_required_options and m_optional_options.
OptionSet union_set;
OptionsSetUnion(GetRequiredOptions()[i], GetOptionalOptions()[i],
union_set);
if (IsASubset(m_seen_options, union_set))
options_are_valid = true;
}
}
return options_are_valid;
}
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;
}
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);
}
void OptionGroupOptions::Append(OptionGroup *group) {
auto group_option_defs = group->GetDefinitions();
for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
m_option_infos.push_back(OptionInfo(group, i));
m_option_defs.push_back(group_option_defs[i]);
}
}
const OptionGroup *OptionGroupOptions::GetGroupWithOption(char short_opt) {
for (uint32_t i = 0; i < m_option_defs.size(); i++) {
OptionDefinition opt_def = m_option_defs[i];
if (opt_def.short_option == short_opt)
return m_option_infos[i].option_group;
}
return nullptr;
}
void OptionGroupOptions::Append(OptionGroup *group, uint32_t src_mask,
uint32_t dst_mask) {
auto group_option_defs = group->GetDefinitions();
for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
if (group_option_defs[i].usage_mask & src_mask) {
m_option_infos.push_back(OptionInfo(group, i));
m_option_defs.push_back(group_option_defs[i]);
m_option_defs.back().usage_mask = dst_mask;
}
}
}
void OptionGroupOptions::Finalize() {
m_did_finalize = true;
}
Status OptionGroupOptions::SetOptionValue(uint32_t option_idx,
llvm::StringRef option_value,
ExecutionContext *execution_context) {
// After calling OptionGroupOptions::Append(...), you must finalize the groups
// by calling OptionGroupOptions::Finlize()
assert(m_did_finalize);
Status error;
if (option_idx < m_option_infos.size()) {
error = m_option_infos[option_idx].option_group->SetOptionValue(
m_option_infos[option_idx].option_index, option_value,
execution_context);
} else {
error.SetErrorString("invalid option index"); // Shouldn't happen...
}
return error;
}
void OptionGroupOptions::OptionParsingStarting(
ExecutionContext *execution_context) {
std::set<OptionGroup *> group_set;
OptionInfos::iterator pos, end = m_option_infos.end();
for (pos = m_option_infos.begin(); pos != end; ++pos) {
OptionGroup *group = pos->option_group;
if (group_set.find(group) == group_set.end()) {
group->OptionParsingStarting(execution_context);
group_set.insert(group);
}
}
}
Status
OptionGroupOptions::OptionParsingFinished(ExecutionContext *execution_context) {
std::set<OptionGroup *> group_set;
Status error;
OptionInfos::iterator pos, end = m_option_infos.end();
for (pos = m_option_infos.begin(); pos != end; ++pos) {
OptionGroup *group = pos->option_group;
if (group_set.find(group) == group_set.end()) {
error = group->OptionParsingFinished(execution_context);
group_set.insert(group);
if (error.Fail())
return error;
}
}
return error;
}
Reference in New Issue View Git Blame Copy Permalink