This is an archive of the discontinued LLVM Phabricator instance.

Differential D134244

[NFCI] Clean up enum FormatCategoryItem.
ClosedPublic

Authored by jgorbe on Sep 19 2022, 5:03 PM.

Details

Reviewers
labath
rupprecht
jingham
JDevlieghere
Commits
rGdce688733600: [NFCI] Clean up enum FormatCategoryItem.
Summary
  • Merge pairs like eFormatCategoryItemSummary and eFormatCategoryItemRegexSummary into a single value. See explanation below.
  • Rename eFormatCategoryItemValue to eFormatCategoryItemFormat. This makes the enum match the names used elsewhere for formatter kinds (format, summary, filter, synth).
  • Delete unused values eFormatCategoryItemValidator and eFormatCategoryItemRegexValidator.

This enum is only used to reuse some code in CommandObjectType.cpp. For
example, instead of having separate implementations for `type summary
delete`, type format delete, and so on, there's a single generic
implementation that takes an enum value, and then the specific commands
derive from it and set the right flags for the specific kind of
formatter.

Even though the enum distinguishes between regular and regex matches for
every kind of formatter, this distinction is never used: enum values are
always specified in pairs like
eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary.

This causes some ugly code duplication in TypeCategory.cpp. In order to
handle every flag combination some code appears 8 times:

{format, summary, synth, filter} x {exact, regex}

Diff Detail

Event Timeline

jgorbe created this revision.Sep 19 2022, 5:03 PM
Herald added a project: Restricted Project. · View Herald TranscriptSep 19 2022, 5:03 PM
Herald added a subscriber: JDevlieghere. · View Herald Transcript
jgorbe requested review of this revision.Sep 19 2022, 5:03 PM
Harbormaster completed remote builds in B187643: Diff 461418.Sep 19 2022, 5:08 PM
JDevlieghere accepted this revision.Sep 20 2022, 8:18 AM

Makes sense. LGTM modulo the enum values.

lldb/include/lldb/lldb-private-enumerations.h
130–134

As these are private we don't have to skip values I think. Also let's use left shift operators to make it more obvious that these are flags.

This revision is now accepted and ready to land.Sep 20 2022, 8:18 AM
Closed by commit rGdce688733600: [NFCI] Clean up enum FormatCategoryItem. (authored by jgorbe). · Explain WhySep 20 2022, 10:43 AM
This revision was automatically updated to reflect the committed changes.
jgorbe added a commit: rGdce688733600: [NFCI] Clean up enum FormatCategoryItem..
jgorbe marked an inline comment as done.Sep 20 2022, 10:45 AM
jgorbe added inline comments.
lldb/include/lldb/lldb-private-enumerations.h
130–134

Done, thanks! :)

Revision Contents

PathSize
lldb/
include/
lldb/
14 lines
source/
Commands/
67 lines
DataFormatters/
3 lines
116 lines

Diff 461613

lldb/include/lldb/lldb-private-enumerations.h

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Lines eInstructionTypePrologueEpilogue, // All prologue and epilogue instructions
// modify sp/fp // modify sp/fp
eInstructionTypePCModifying, // Any instruction that modifies the program eInstructionTypePCModifying, // Any instruction that modifies the program
// counter/instruction pointer // counter/instruction pointer
eInstructionTypeAll // All instructions of any kind eInstructionTypeAll // All instructions of any kind
}; };
/// Format category entry types /// Format category entry types
enum FormatCategoryItem { enum FormatCategoryItem {
eFormatCategoryItemSummary = 0x0001, eFormatCategoryItemSummary = 1,
eFormatCategoryItemRegexSummary = 0x0002, eFormatCategoryItemFilter = 1 << 1,
eFormatCategoryItemFilter = 0x0004, eFormatCategoryItemSynth = 1 << 2,
eFormatCategoryItemRegexFilter = 0x0008, eFormatCategoryItemFormat = 1 << 3,
JDevlieghereUnsubmitted
Not Done
ReplyInline Actions

As these are private we don't have to skip values I think. Also let's use left shift operators to make it more obvious that these are flags.

JDevlieghere: As these are private we don't have to skip values I think. Also let's use left shift operators…
jgorbeAuthorUnsubmitted
Done
ReplyInline Actions

Done, thanks! :)

jgorbe: Done, thanks! :)
eFormatCategoryItemSynth = 0x0010,
eFormatCategoryItemRegexSynth = 0x0020,
eFormatCategoryItemValue = 0x0040,
eFormatCategoryItemRegexValue = 0x0080,
eFormatCategoryItemValidator = 0x0100,
eFormatCategoryItemRegexValidator = 0x0200
}; };
/// Expression execution policies /// Expression execution policies
enum ExecutionPolicy { enum ExecutionPolicy {
eExecutionPolicyOnlyWhenNeeded, eExecutionPolicyOnlyWhenNeeded,
eExecutionPolicyNever, eExecutionPolicyNever,
eExecutionPolicyAlways, eExecutionPolicyAlways,
eExecutionPolicyTopLevel // used for top-level code eExecutionPolicyTopLevel // used for top-level code
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectType.cpp

Show First 20 Lines • Show All 777 Lines • ▼ Show 20 Linespublic:
void void
HandleArgumentCompletion(CompletionRequest &request, HandleArgumentCompletion(CompletionRequest &request,
OptionElementVector &opt_element_vector) override { OptionElementVector &opt_element_vector) override {
if (request.GetCursorIndex()) if (request.GetCursorIndex())
return; return;
DataVisualization::Categories::ForEach( DataVisualization::Categories::ForEach(
[this, &request](const lldb::TypeCategoryImplSP &category_sp) { [this, &request](const lldb::TypeCategoryImplSP &category_sp) {
if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemValue)) if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemFormat)) {
category_sp->GetTypeFormatsContainer()->AutoComplete(request); category_sp->GetTypeFormatsContainer()->AutoComplete(request);
if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexValue))
category_sp->GetRegexTypeFormatsContainer()->AutoComplete(request); category_sp->GetRegexTypeFormatsContainer()->AutoComplete(request);
}
if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemSummary)) if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemSummary)) {
category_sp->GetTypeSummariesContainer()->AutoComplete(request); category_sp->GetTypeSummariesContainer()->AutoComplete(request);
if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexSummary))
category_sp->GetRegexTypeSummariesContainer()->AutoComplete( category_sp->GetRegexTypeSummariesContainer()->AutoComplete(
request); request);
}
if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemFilter)) if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemFilter)) {
category_sp->GetTypeFiltersContainer()->AutoComplete(request); category_sp->GetTypeFiltersContainer()->AutoComplete(request);
if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexFilter))
category_sp->GetRegexTypeFiltersContainer()->AutoComplete(request); category_sp->GetRegexTypeFiltersContainer()->AutoComplete(request);
}
if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemSynth)) if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemSynth)) {
category_sp->GetTypeSyntheticsContainer()->AutoComplete(request); category_sp->GetTypeSyntheticsContainer()->AutoComplete(request);
if (CHECK_FORMATTER_KIND_MASK(eFormatCategoryItemRegexSynth))
category_sp->GetRegexTypeSyntheticsContainer()->AutoComplete( category_sp->GetRegexTypeSyntheticsContainer()->AutoComplete(
request); request);
}
return true; return true;
}); });
} }
protected: protected:
virtual bool FormatterSpecificDeletion(ConstString typeCS) { return false; } virtual bool FormatterSpecificDeletion(ConstString typeCS) { return false; }
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Lines
}; };
// CommandObjectTypeFormatDelete // CommandObjectTypeFormatDelete
class CommandObjectTypeFormatDelete : public CommandObjectTypeFormatterDelete { class CommandObjectTypeFormatDelete : public CommandObjectTypeFormatterDelete {
public: public:
CommandObjectTypeFormatDelete(CommandInterpreter &interpreter) CommandObjectTypeFormatDelete(CommandInterpreter &interpreter)
: CommandObjectTypeFormatterDelete( : CommandObjectTypeFormatterDelete(
interpreter, interpreter, eFormatCategoryItemFormat, "type format delete",
eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
"type format delete",
"Delete an existing formatting style for a type.") {} "Delete an existing formatting style for a type.") {}
~CommandObjectTypeFormatDelete() override = default; ~CommandObjectTypeFormatDelete() override = default;
}; };
// CommandObjectTypeFormatClear // CommandObjectTypeFormatClear
class CommandObjectTypeFormatClear : public CommandObjectTypeFormatterClear { class CommandObjectTypeFormatClear : public CommandObjectTypeFormatterClear {
public: public:
CommandObjectTypeFormatClear(CommandInterpreter &interpreter) CommandObjectTypeFormatClear(CommandInterpreter &interpreter)
: CommandObjectTypeFormatterClear( : CommandObjectTypeFormatterClear(interpreter, eFormatCategoryItemFormat,
interpreter, "type format clear",
eFormatCategoryItemValue | eFormatCategoryItemRegexValue, "Delete all existing format styles.") {}
"type format clear", "Delete all existing format styles.") {}
}; };
#define LLDB_OPTIONS_type_formatter_list #define LLDB_OPTIONS_type_formatter_list
#include "CommandOptions.inc" #include "CommandOptions.inc"
template <typename FormatterType> template <typename FormatterType>
class CommandObjectTypeFormatterList : public CommandObjectParsed { class CommandObjectTypeFormatterList : public CommandObjectParsed {
typedef typename FormatterType::SharedPointer FormatterSharedPointer; typedef typename FormatterType::SharedPointer FormatterSharedPointer;
▲ Show 20 Lines • Show All 638 Lines • ▼ Show 20 Lines
} }
// CommandObjectTypeSummaryDelete // CommandObjectTypeSummaryDelete
class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete { class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete {
public: public:
CommandObjectTypeSummaryDelete(CommandInterpreter &interpreter) CommandObjectTypeSummaryDelete(CommandInterpreter &interpreter)
: CommandObjectTypeFormatterDelete( : CommandObjectTypeFormatterDelete(
interpreter, interpreter, eFormatCategoryItemSummary, "type summary delete",
eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary, "Delete an existing summary for a type.") {}
"type summary delete", "Delete an existing summary for a type.") {}
~CommandObjectTypeSummaryDelete() override = default; ~CommandObjectTypeSummaryDelete() override = default;
protected: protected:
bool FormatterSpecificDeletion(ConstString typeCS) override { bool FormatterSpecificDeletion(ConstString typeCS) override {
if (m_options.m_language != lldb::eLanguageTypeUnknown) if (m_options.m_language != lldb::eLanguageTypeUnknown)
return false; return false;
return DataVisualization::NamedSummaryFormats::Delete(typeCS); return DataVisualization::NamedSummaryFormats::Delete(typeCS);
} }
}; };
class CommandObjectTypeSummaryClear : public CommandObjectTypeFormatterClear { class CommandObjectTypeSummaryClear : public CommandObjectTypeFormatterClear {
public: public:
CommandObjectTypeSummaryClear(CommandInterpreter &interpreter) CommandObjectTypeSummaryClear(CommandInterpreter &interpreter)
: CommandObjectTypeFormatterClear( : CommandObjectTypeFormatterClear(interpreter, eFormatCategoryItemSummary,
interpreter, "type summary clear",
eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary, "Delete all existing summaries.") {}
"type summary clear", "Delete all existing summaries.") {}
protected: protected:
void FormatterSpecificDeletion() override { void FormatterSpecificDeletion() override {
DataVisualization::NamedSummaryFormats::Clear(); DataVisualization::NamedSummaryFormats::Clear();
} }
}; };
// CommandObjectTypeSummaryList // CommandObjectTypeSummaryList
▲ Show 20 Lines • Show All 515 Lines • ▼ Show 20 Lines
#endif #endif
// CommandObjectTypeFilterDelete // CommandObjectTypeFilterDelete
class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete { class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete {
public: public:
CommandObjectTypeFilterDelete(CommandInterpreter &interpreter) CommandObjectTypeFilterDelete(CommandInterpreter &interpreter)
: CommandObjectTypeFormatterDelete( : CommandObjectTypeFormatterDelete(
interpreter, interpreter, eFormatCategoryItemFilter, "type filter delete",
eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter, "Delete an existing filter for a type.") {}
"type filter delete", "Delete an existing filter for a type.") {}
~CommandObjectTypeFilterDelete() override = default; ~CommandObjectTypeFilterDelete() override = default;
}; };
#if LLDB_ENABLE_PYTHON #if LLDB_ENABLE_PYTHON
// CommandObjectTypeSynthDelete // CommandObjectTypeSynthDelete
class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete { class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete {
public: public:
CommandObjectTypeSynthDelete(CommandInterpreter &interpreter) CommandObjectTypeSynthDelete(CommandInterpreter &interpreter)
: CommandObjectTypeFormatterDelete( : CommandObjectTypeFormatterDelete(
interpreter, interpreter, eFormatCategoryItemSynth, "type synthetic delete",
eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
"type synthetic delete",
"Delete an existing synthetic provider for a type.") {} "Delete an existing synthetic provider for a type.") {}
~CommandObjectTypeSynthDelete() override = default; ~CommandObjectTypeSynthDelete() override = default;
}; };
#endif #endif
// CommandObjectTypeFilterClear // CommandObjectTypeFilterClear
class CommandObjectTypeFilterClear : public CommandObjectTypeFormatterClear { class CommandObjectTypeFilterClear : public CommandObjectTypeFormatterClear {
public: public:
CommandObjectTypeFilterClear(CommandInterpreter &interpreter) CommandObjectTypeFilterClear(CommandInterpreter &interpreter)
: CommandObjectTypeFormatterClear( : CommandObjectTypeFormatterClear(interpreter, eFormatCategoryItemFilter,
interpreter, "type filter clear",
eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter, "Delete all existing filter.") {}
"type filter clear", "Delete all existing filter.") {}
}; };
#if LLDB_ENABLE_PYTHON #if LLDB_ENABLE_PYTHON
// CommandObjectTypeSynthClear // CommandObjectTypeSynthClear
class CommandObjectTypeSynthClear : public CommandObjectTypeFormatterClear { class CommandObjectTypeSynthClear : public CommandObjectTypeFormatterClear {
public: public:
CommandObjectTypeSynthClear(CommandInterpreter &interpreter) CommandObjectTypeSynthClear(CommandInterpreter &interpreter)
: CommandObjectTypeFormatterClear( : CommandObjectTypeFormatterClear(
interpreter, interpreter, eFormatCategoryItemSynth, "type synthetic clear",
eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
"type synthetic clear",
"Delete all existing synthetic providers.") {} "Delete all existing synthetic providers.") {}
}; };
bool CommandObjectTypeSynthAdd::Execute_HandwritePython( bool CommandObjectTypeSynthAdd::Execute_HandwritePython(
Args &command, CommandReturnObject &result) { Args &command, CommandReturnObject &result) {
auto options = std::make_unique<SynthAddOptions>( auto options = std::make_unique<SynthAddOptions>(
m_options.m_skip_pointers, m_options.m_skip_references, m_options.m_skip_pointers, m_options.m_skip_references,
m_options.m_cascade, m_options.m_regex, m_options.m_category); m_options.m_cascade, m_options.m_regex, m_options.m_category);
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Linesbool CommandObjectTypeSynthAdd::AddSynth(ConstString type_name,
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()), DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
category); category);
if (type == eRegularSynth) { if (type == eRegularSynth) {
if (FixArrayTypeNameWithRegex(type_name)) if (FixArrayTypeNameWithRegex(type_name))
type = eRegexSynth; type = eRegexSynth;
} }
if (category->AnyMatches( if (category->AnyMatches(type_name, eFormatCategoryItemFilter, false)) {
type_name, eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
false)) {
if (error) if (error)
error->SetErrorStringWithFormat("cannot add synthetic for type %s when " error->SetErrorStringWithFormat("cannot add synthetic for type %s when "
"filter is defined in same category!", "filter is defined in same category!",
type_name.AsCString()); type_name.AsCString());
return false; return false;
} }
if (type == eRegexSynth) { if (type == eRegexSynth) {
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines bool AddFilter(ConstString type_name, TypeFilterImplSP entry,
DataVisualization::Categories::GetCategory( DataVisualization::Categories::GetCategory(
ConstString(category_name.c_str()), category); ConstString(category_name.c_str()), category);
if (type == eRegularFilter) { if (type == eRegularFilter) {
if (FixArrayTypeNameWithRegex(type_name)) if (FixArrayTypeNameWithRegex(type_name))
type = eRegexFilter; type = eRegexFilter;
} }
if (category->AnyMatches( if (category->AnyMatches(type_name, eFormatCategoryItemSynth, false)) {
type_name, eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
false)) {
if (error) if (error)
error->SetErrorStringWithFormat("cannot add filter for type %s when " error->SetErrorStringWithFormat("cannot add filter for type %s when "
"synthetic is defined in same " "synthetic is defined in same "
"category!", "category!",
type_name.AsCString()); type_name.AsCString());
return false; return false;
} }
▲ Show 20 Lines • Show All 558 Lines • Show Last 20 Lines

lldb/source/DataFormatters/DataVisualization.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Linesbool DataVisualization::Categories::Delete(ConstString category) {
return GetFormatManager().DeleteCategory(category); return GetFormatManager().DeleteCategory(category);
} }
void DataVisualization::Categories::Clear() { void DataVisualization::Categories::Clear() {
GetFormatManager().ClearCategories(); GetFormatManager().ClearCategories();
} }
void DataVisualization::Categories::Clear(ConstString category) { void DataVisualization::Categories::Clear(ConstString category) {
GetFormatManager().GetCategory(category)->Clear( GetFormatManager().GetCategory(category)->Clear(eFormatCategoryItemSummary);
eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary);
} }
void DataVisualization::Categories::Enable(ConstString category, void DataVisualization::Categories::Enable(ConstString category,
TypeCategoryMap::Position pos) { TypeCategoryMap::Position pos) {
if (GetFormatManager().GetCategory(category)->IsEnabled()) if (GetFormatManager().GetCategory(category)->IsEnabled())
GetFormatManager().DisableCategory(category); GetFormatManager().DisableCategory(category);
GetFormatManager().EnableCategory(category, pos, {}); GetFormatManager().EnableCategory(category, pos, {});
} }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lldb/source/DataFormatters/TypeCategory.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Linesbool TypeCategoryImpl::Get(lldb::LanguageType lang,
} else { } else {
entry = filter_sp; entry = filter_sp;
return true; return true;
} }
return false; return false;
} }
void TypeCategoryImpl::Clear(FormatCategoryItems items) { void TypeCategoryImpl::Clear(FormatCategoryItems items) {
if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue) if (items & eFormatCategoryItemFormat) {
GetTypeFormatsContainer()->Clear(); GetTypeFormatsContainer()->Clear();
if ((items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue)
GetRegexTypeFormatsContainer()->Clear(); GetRegexTypeFormatsContainer()->Clear();
}
if ((items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary) if (items & eFormatCategoryItemSummary) {
GetTypeSummariesContainer()->Clear(); GetTypeSummariesContainer()->Clear();
if ((items & eFormatCategoryItemRegexSummary) ==
eFormatCategoryItemRegexSummary)
GetRegexTypeSummariesContainer()->Clear(); GetRegexTypeSummariesContainer()->Clear();
}
if ((items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter) if (items & eFormatCategoryItemFilter) {
GetTypeFiltersContainer()->Clear(); GetTypeFiltersContainer()->Clear();
if ((items & eFormatCategoryItemRegexFilter) ==
eFormatCategoryItemRegexFilter)
GetRegexTypeFiltersContainer()->Clear(); GetRegexTypeFiltersContainer()->Clear();
}
if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth) if (items & eFormatCategoryItemSynth) {
GetTypeSyntheticsContainer()->Clear(); GetTypeSyntheticsContainer()->Clear();
if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
GetRegexTypeSyntheticsContainer()->Clear(); GetRegexTypeSyntheticsContainer()->Clear();
} }
}
bool TypeCategoryImpl::Delete(ConstString name, FormatCategoryItems items) { bool TypeCategoryImpl::Delete(ConstString name, FormatCategoryItems items) {
bool success = false; bool success = false;
if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue) if (items & eFormatCategoryItemFormat) {
success = GetTypeFormatsContainer()->Delete(name) || success; success = GetTypeFormatsContainer()->Delete(name) || success;
if ((items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue)
success = GetRegexTypeFormatsContainer()->Delete(name) || success; success = GetRegexTypeFormatsContainer()->Delete(name) || success;
}
if ((items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary) if (items & eFormatCategoryItemSummary) {
success = GetTypeSummariesContainer()->Delete(name) || success; success = GetTypeSummariesContainer()->Delete(name) || success;
if ((items & eFormatCategoryItemRegexSummary) ==
eFormatCategoryItemRegexSummary)
success = GetRegexTypeSummariesContainer()->Delete(name) || success; success = GetRegexTypeSummariesContainer()->Delete(name) || success;
}
if ((items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter) if (items & eFormatCategoryItemFilter) {
success = GetTypeFiltersContainer()->Delete(name) || success; success = GetTypeFiltersContainer()->Delete(name) || success;
if ((items & eFormatCategoryItemRegexFilter) ==
eFormatCategoryItemRegexFilter)
success = GetRegexTypeFiltersContainer()->Delete(name) || success; success = GetRegexTypeFiltersContainer()->Delete(name) || success;
}
if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth) if (items & eFormatCategoryItemSynth) {
success = GetTypeSyntheticsContainer()->Delete(name) || success; success = GetTypeSyntheticsContainer()->Delete(name) || success;
if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
success = GetRegexTypeSyntheticsContainer()->Delete(name) || success; success = GetRegexTypeSyntheticsContainer()->Delete(name) || success;
}
return success; return success;
} }
uint32_t TypeCategoryImpl::GetCount(FormatCategoryItems items) { uint32_t TypeCategoryImpl::GetCount(FormatCategoryItems items) {
uint32_t count = 0; uint32_t count = 0;
if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue) if (items & eFormatCategoryItemFormat) {
count += GetTypeFormatsContainer()->GetCount(); count += GetTypeFormatsContainer()->GetCount();
if ((items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue)
count += GetRegexTypeFormatsContainer()->GetCount(); count += GetRegexTypeFormatsContainer()->GetCount();
}
if ((items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary) if (items & eFormatCategoryItemSummary) {
count += GetTypeSummariesContainer()->GetCount(); count += GetTypeSummariesContainer()->GetCount();
if ((items & eFormatCategoryItemRegexSummary) ==
eFormatCategoryItemRegexSummary)
count += GetRegexTypeSummariesContainer()->GetCount(); count += GetRegexTypeSummariesContainer()->GetCount();
}
if ((items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter) if (items & eFormatCategoryItemFilter) {
count += GetTypeFiltersContainer()->GetCount(); count += GetTypeFiltersContainer()->GetCount();
if ((items & eFormatCategoryItemRegexFilter) ==
eFormatCategoryItemRegexFilter)
count += GetRegexTypeFiltersContainer()->GetCount(); count += GetRegexTypeFiltersContainer()->GetCount();
}
if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth) if (items & eFormatCategoryItemSynth) {
count += GetTypeSyntheticsContainer()->GetCount(); count += GetTypeSyntheticsContainer()->GetCount();
if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
count += GetRegexTypeSyntheticsContainer()->GetCount(); count += GetRegexTypeSyntheticsContainer()->GetCount();
}
return count; return count;
} }
bool TypeCategoryImpl::AnyMatches(ConstString type_name, bool TypeCategoryImpl::AnyMatches(ConstString type_name,
FormatCategoryItems items, bool only_enabled, FormatCategoryItems items, bool only_enabled,
const char **matching_category, const char **matching_category,
FormatCategoryItems *matching_type) { FormatCategoryItems *matching_type) {
if (!IsEnabled() && only_enabled) if (!IsEnabled() && only_enabled)
return false; return false;
lldb::TypeFormatImplSP format_sp; lldb::TypeFormatImplSP format_sp;
lldb::TypeSummaryImplSP summary_sp; lldb::TypeSummaryImplSP summary_sp;
TypeFilterImpl::SharedPointer filter_sp; TypeFilterImpl::SharedPointer filter_sp;
ScriptedSyntheticChildren::SharedPointer synth_sp; ScriptedSyntheticChildren::SharedPointer synth_sp;
if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue) { if (items & eFormatCategoryItemFormat) {
if (GetTypeFormatsContainer()->Get(type_name, format_sp)) { if (GetTypeFormatsContainer()->Get(type_name, format_sp) ||
if (matching_category) GetRegexTypeFormatsContainer()->Get(type_name, format_sp)) {
*matching_category = m_name.GetCString();
if (matching_type)
*matching_type = eFormatCategoryItemValue;
return true;
}
}
if ((items & eFormatCategoryItemRegexValue) ==
eFormatCategoryItemRegexValue) {
if (GetRegexTypeFormatsContainer()->Get(type_name, format_sp)) {
if (matching_category) if (matching_category)
*matching_category = m_name.GetCString(); *matching_category = m_name.GetCString();
if (matching_type) if (matching_type)
*matching_type = eFormatCategoryItemRegexValue; *matching_type = eFormatCategoryItemFormat;
return true; return true;
} }
} }
if ((items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary) { if (items & eFormatCategoryItemSummary) {
if (GetTypeSummariesContainer()->Get(type_name, summary_sp)) { if (GetTypeSummariesContainer()->Get(type_name, summary_sp) ||
GetRegexTypeSummariesContainer()->Get(type_name, summary_sp)) {
if (matching_category) if (matching_category)
*matching_category = m_name.GetCString(); *matching_category = m_name.GetCString();
if (matching_type) if (matching_type)
*matching_type = eFormatCategoryItemSummary; *matching_type = eFormatCategoryItemSummary;
return true; return true;
} }
} }
if ((items & eFormatCategoryItemRegexSummary) ==
eFormatCategoryItemRegexSummary) {
if (GetRegexTypeSummariesContainer()->Get(type_name, summary_sp)) {
if (matching_category)
*matching_category = m_name.GetCString();
if (matching_type)
*matching_type = eFormatCategoryItemRegexSummary;
return true;
}
}
if ((items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter) { if (items & eFormatCategoryItemFilter) {
if (GetTypeFiltersContainer()->Get(type_name, filter_sp)) { if (GetTypeFiltersContainer()->Get(type_name, filter_sp) ||
GetRegexTypeFiltersContainer()->Get(type_name, filter_sp)) {
if (matching_category) if (matching_category)
*matching_category = m_name.GetCString(); *matching_category = m_name.GetCString();
if (matching_type) if (matching_type)
*matching_type = eFormatCategoryItemFilter; *matching_type = eFormatCategoryItemFilter;
return true; return true;
} }
} }
if ((items & eFormatCategoryItemRegexFilter) ==
eFormatCategoryItemRegexFilter) {
if (GetRegexTypeFiltersContainer()->Get(type_name, filter_sp)) {
if (matching_category)
*matching_category = m_name.GetCString();
if (matching_type)
*matching_type = eFormatCategoryItemRegexFilter;
return true;
}
}
if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth) { if (items & eFormatCategoryItemSynth) {
if (GetTypeSyntheticsContainer()->Get(type_name, synth_sp)) { if (GetTypeSyntheticsContainer()->Get(type_name, synth_sp) ||
GetRegexTypeSyntheticsContainer()->Get(type_name, synth_sp)) {
if (matching_category) if (matching_category)
*matching_category = m_name.GetCString(); *matching_category = m_name.GetCString();
if (matching_type) if (matching_type)
*matching_type = eFormatCategoryItemSynth; *matching_type = eFormatCategoryItemSynth;
return true; return true;
} }
} }
if ((items & eFormatCategoryItemRegexSynth) ==
eFormatCategoryItemRegexSynth) {
if (GetRegexTypeSyntheticsContainer()->Get(type_name, synth_sp)) {
if (matching_category)
*matching_category = m_name.GetCString();
if (matching_type)
*matching_type = eFormatCategoryItemRegexSynth;
return true;
}
}
return false; return false;
} }
TypeCategoryImpl::FormatContainer::MapValueType TypeCategoryImpl::FormatContainer::MapValueType
TypeCategoryImpl::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) { TypeCategoryImpl::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
FormatContainer::MapValueType retval; FormatContainer::MapValueType retval;
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines