diff options
Diffstat (limited to 'source/Commands/CommandObjectType.cpp')
| -rw-r--r-- | source/Commands/CommandObjectType.cpp | 2507 |
1 files changed, 868 insertions, 1639 deletions
diff --git a/source/Commands/CommandObjectType.cpp b/source/Commands/CommandObjectType.cpp index 584e94d..b57ac70 100644 --- a/source/Commands/CommandObjectType.cpp +++ b/source/Commands/CommandObjectType.cpp @@ -30,6 +30,10 @@ #include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/Options.h" #include "lldb/Interpreter/OptionGroupFormat.h" +#include "lldb/Interpreter/OptionValueBoolean.h" +#include "lldb/Interpreter/OptionValueLanguage.h" +#include "lldb/Interpreter/OptionValueString.h" +#include "lldb/Target/Language.h" #include "lldb/Target/Process.h" #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" @@ -144,17 +148,16 @@ private: { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg); + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override; void - OptionParsingStarting (); + OptionParsingStarting () override; const OptionDefinition* - GetDefinitions () + GetDefinitions () override { return g_option_table; } @@ -177,8 +180,8 @@ private: CommandOptions m_options; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_options; } @@ -200,12 +203,12 @@ public: CommandObjectTypeSummaryAdd (CommandInterpreter &interpreter); - ~CommandObjectTypeSummaryAdd () + ~CommandObjectTypeSummaryAdd () override { } - virtual void - IOHandlerActivated (IOHandler &io_handler) + void + IOHandlerActivated (IOHandler &io_handler) override { static const char *g_summary_addreader_instructions = "Enter your Python command(s). Type 'DONE' to end.\n" "def function (valobj,internal_dict):\n" @@ -221,8 +224,8 @@ public: } - virtual void - IOHandlerInputComplete (IOHandler &io_handler, std::string &data) + void + IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override { StreamFileSP error_sp = io_handler.GetErrorStreamFile(); @@ -353,7 +356,7 @@ public: Error* error = NULL); protected: bool - DoExecute (Args& command, CommandReturnObject &result); + DoExecute (Args& command, CommandReturnObject &result) override; }; @@ -383,11 +386,10 @@ private: { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override { Error error; const int short_option = m_getopt_table[option_idx].val; @@ -428,7 +430,7 @@ private: } void - OptionParsingStarting () + OptionParsingStarting () override { m_cascade = true; m_class_name = ""; @@ -441,7 +443,7 @@ private: } const OptionDefinition* - GetDefinitions () + GetDefinitions () override { return g_option_table; } @@ -469,8 +471,8 @@ private: CommandOptions m_options; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_options; } @@ -483,7 +485,7 @@ private: protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { WarnOnPotentialUnquotedUnsignedType(command, result); @@ -499,8 +501,8 @@ protected: } } - virtual void - IOHandlerActivated (IOHandler &io_handler) + void + IOHandlerActivated (IOHandler &io_handler) override { StreamFileSP output_sp(io_handler.GetOutputStreamFile()); if (output_sp) @@ -511,8 +513,8 @@ protected: } - virtual void - IOHandlerInputComplete (IOHandler &io_handler, std::string &data) + void + IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override { StreamFileSP error_sp = io_handler.GetErrorStreamFile(); @@ -626,7 +628,7 @@ public: CommandObjectTypeSynthAdd (CommandInterpreter &interpreter); - ~CommandObjectTypeSynthAdd () + ~CommandObjectTypeSynthAdd () override { } @@ -656,22 +658,21 @@ private: { } - virtual - ~CommandOptions () + ~CommandOptions () override { } - virtual uint32_t - GetNumDefinitions (); + uint32_t + GetNumDefinitions () override; - virtual const OptionDefinition* - GetDefinitions () + const OptionDefinition* + GetDefinitions () override { return g_option_table; } - virtual void - OptionParsingStarting (CommandInterpreter &interpreter) + void + OptionParsingStarting (CommandInterpreter &interpreter) override { m_cascade = true; m_skip_pointers = false; @@ -680,10 +681,10 @@ private: m_category.assign("default"); m_custom_type_name.clear(); } - virtual Error + Error SetOptionValue (CommandInterpreter &interpreter, uint32_t option_idx, - const char *option_value) + const char *option_value) override { Error error; const int short_option = g_option_table[option_idx].short_option; @@ -737,8 +738,8 @@ private: OptionGroupFormat m_format_options; CommandOptions m_command_options; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_option_group; } @@ -806,13 +807,13 @@ pointers to floats. Nor will it change the default display for Afloat and Bfloa } - ~CommandObjectTypeFormatAdd () + ~CommandObjectTypeFormatAdd () override { } protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { const size_t argc = command.GetArgumentCount(); @@ -906,14 +907,9 @@ CommandObjectTypeFormatAdd::CommandOptions::GetNumDefinitions () return sizeof(g_option_table) / sizeof (OptionDefinition); } - -//------------------------------------------------------------------------- -// CommandObjectTypeFormatDelete -//------------------------------------------------------------------------- - -class CommandObjectTypeFormatDelete : public CommandObjectParsed +class CommandObjectTypeFormatterDelete : public CommandObjectParsed { -private: +protected: class CommandOptions : public Options { public: @@ -923,11 +919,10 @@ private: { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override { Error error; const int short_option = m_getopt_table[option_idx].val; @@ -940,6 +935,9 @@ private: case 'w': m_category = std::string(option_arg); break; + case 'l': + m_language = Language::GetLanguageTypeFromString(option_arg); + break; default: error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); break; @@ -949,14 +947,15 @@ private: } void - OptionParsingStarting () + OptionParsingStarting () override { m_delete_all = false; m_category = "default"; + m_language = lldb::eLanguageTypeUnknown; } const OptionDefinition* - GetDefinitions () + GetDefinitions () override { return g_option_table; } @@ -969,33 +968,29 @@ private: bool m_delete_all; std::string m_category; - + lldb::LanguageType m_language; }; CommandOptions m_options; + uint32_t m_formatter_kind_mask; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_options; } - static bool - PerCategoryCallback(void* param, - const lldb::TypeCategoryImplSP& category_sp) - { - ConstString *name = (ConstString*)param; - category_sp->Delete(*name, eFormatCategoryItemValue | eFormatCategoryItemRegexValue); - return true; - } - public: - CommandObjectTypeFormatDelete (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type format delete", - "Delete an existing formatting style for a type.", - NULL), - m_options(interpreter) + CommandObjectTypeFormatterDelete (CommandInterpreter &interpreter, + uint32_t formatter_kind_mask, + const char* name, + const char* help) : + CommandObjectParsed (interpreter, + name, + help, + NULL), + m_options(interpreter), + m_formatter_kind_mask(formatter_kind_mask) { CommandArgumentEntry type_arg; CommandArgumentData type_style_arg; @@ -1009,13 +1004,17 @@ public: } - ~CommandObjectTypeFormatDelete () + ~CommandObjectTypeFormatterDelete () override = default; + +protected: + virtual bool + FormatterSpecificDeletion (ConstString typeCS) { + return false; } -protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { const size_t argc = command.GetArgumentCount(); @@ -1038,25 +1037,42 @@ protected: if (m_options.m_delete_all) { - DataVisualization::Categories::LoopThrough(PerCategoryCallback, &typeCS); + DataVisualization::Categories::ForEach( [this, typeCS] (const lldb::TypeCategoryImplSP& category_sp) -> bool { + category_sp->Delete(typeCS, m_formatter_kind_mask); + return true; + }); result.SetStatus(eReturnStatusSuccessFinishNoResult); return result.Succeeded(); } - lldb::TypeCategoryImplSP category; - DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); + bool delete_category = false; + bool extra_deletion = false; - bool delete_category = category->Delete(typeCS, - eFormatCategoryItemValue | eFormatCategoryItemRegexValue); + if (m_options.m_language != lldb::eLanguageTypeUnknown) + { + lldb::TypeCategoryImplSP category; + DataVisualization::Categories::GetCategory(m_options.m_language, category); + if (category) + delete_category = category->Delete(typeCS, m_formatter_kind_mask); + extra_deletion = FormatterSpecificDeletion(typeCS); + } + else + { + lldb::TypeCategoryImplSP category; + DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); + if (category) + delete_category = category->Delete(typeCS, m_formatter_kind_mask); + extra_deletion = FormatterSpecificDeletion(typeCS); + } - if (delete_category) + if (delete_category || extra_deletion) { result.SetStatus(eReturnStatusSuccessFinishNoResult); return result.Succeeded(); } else { - result.AppendErrorWithFormat ("no custom format for %s.\n", typeA); + result.AppendErrorWithFormat ("no custom formatter for %s.\n", typeA); result.SetStatus(eReturnStatusFailed); return false; } @@ -1066,18 +1082,15 @@ protected: }; OptionDefinition -CommandObjectTypeFormatDelete::CommandOptions::g_option_table[] = +CommandObjectTypeFormatterDelete::CommandOptions::g_option_table[] = { { LLDB_OPT_SET_1, false, "all", 'a', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Delete from every category."}, { LLDB_OPT_SET_2, false, "category", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Delete from given category."}, + { LLDB_OPT_SET_3, false, "language", 'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage, "Delete from given language's category."}, { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; -//------------------------------------------------------------------------- -// CommandObjectTypeFormatClear -//------------------------------------------------------------------------- - -class CommandObjectTypeFormatClear : public CommandObjectParsed +class CommandObjectTypeFormatterClear : public CommandObjectParsed { private: @@ -1090,11 +1103,10 @@ private: { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override { Error error; const int short_option = m_getopt_table[option_idx].val; @@ -1113,13 +1125,13 @@ private: } void - OptionParsingStarting () + OptionParsingStarting () override { m_delete_all = false; } const OptionDefinition* - GetDefinitions () + GetDefinitions () override { return g_option_table; } @@ -1129,50 +1141,52 @@ private: static OptionDefinition g_option_table[]; // Instance variables to hold the values for command options. - bool m_delete_all; - bool m_delete_named; }; CommandOptions m_options; - - virtual Options * - GetOptions () + uint32_t m_formatter_kind_mask; + + Options * + GetOptions () override { return &m_options; } - static bool - PerCategoryCallback(void* param, - const lldb::TypeCategoryImplSP& cate) +public: + CommandObjectTypeFormatterClear (CommandInterpreter &interpreter, + uint32_t formatter_kind_mask, + const char* name, + const char* help) : + CommandObjectParsed (interpreter, + name, + help, + NULL), + m_options(interpreter), + m_formatter_kind_mask(formatter_kind_mask) { - cate->GetTypeFormatsContainer()->Clear(); - cate->GetRegexTypeFormatsContainer()->Clear(); - return true; - } -public: - CommandObjectTypeFormatClear (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type format clear", - "Delete all existing format styles.", - NULL), - m_options(interpreter) + ~CommandObjectTypeFormatterClear () override { } - ~CommandObjectTypeFormatClear () +protected: + virtual void + FormatterSpecificDeletion () { } -protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { if (m_options.m_delete_all) - DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL); - + { + DataVisualization::Categories::ForEach( [this] (const TypeCategoryImplSP& category_sp) -> bool { + category_sp->Clear(m_formatter_kind_mask); + return true; + }); + } else { lldb::TypeCategoryImplSP category; @@ -1183,10 +1197,14 @@ protected: DataVisualization::Categories::GetCategory(cat_nameCS, category); } else + { DataVisualization::Categories::GetCategory(ConstString(NULL), category); - category->Clear(eFormatCategoryItemValue | eFormatCategoryItemRegexValue); + } + category->Clear(m_formatter_kind_mask); } + FormatterSpecificDeletion(); + result.SetStatus(eReturnStatusSuccessFinishResult); return result.Succeeded(); } @@ -1194,46 +1212,68 @@ protected: }; OptionDefinition -CommandObjectTypeFormatClear::CommandOptions::g_option_table[] = +CommandObjectTypeFormatterClear::CommandOptions::g_option_table[] = { { LLDB_OPT_SET_ALL, false, "all", 'a', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Clear every category."}, { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; //------------------------------------------------------------------------- -// CommandObjectTypeFormatList +// CommandObjectTypeFormatDelete //------------------------------------------------------------------------- -bool CommandObjectTypeFormatList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeFormatImplSP& entry); -bool CommandObjectTypeRXFormatList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const lldb::TypeFormatImplSP& entry); +class CommandObjectTypeFormatDelete : public CommandObjectTypeFormatterDelete +{ +public: + CommandObjectTypeFormatDelete (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterDelete (interpreter, + eFormatCategoryItemValue | eFormatCategoryItemRegexValue, + "type format delete", + "Delete an existing formatting style for a type.") + { + } + + ~CommandObjectTypeFormatDelete () override + { + } +}; -class CommandObjectTypeFormatList; +//------------------------------------------------------------------------- +// CommandObjectTypeFormatClear +//------------------------------------------------------------------------- -struct CommandObjectTypeFormatList_LoopCallbackParam { - CommandObjectTypeFormatList* self; - CommandReturnObject* result; - RegularExpression* regex; - RegularExpression* cate_regex; - CommandObjectTypeFormatList_LoopCallbackParam(CommandObjectTypeFormatList* S, CommandReturnObject* R, - RegularExpression* X = NULL, RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {} +class CommandObjectTypeFormatClear : public CommandObjectTypeFormatterClear +{ +public: + CommandObjectTypeFormatClear (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterClear (interpreter, + eFormatCategoryItemValue | eFormatCategoryItemRegexValue, + "type format clear", + "Delete all existing format styles.") + { + } }; -class CommandObjectTypeFormatList : public CommandObjectParsed +template <typename FormatterType> +class CommandObjectTypeFormatterList : public CommandObjectParsed { + typedef typename FormatterType::SharedPointer FormatterSharedPointer; + class CommandOptions : public Options { public: CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) + Options (interpreter), + m_category_regex("",""), + m_category_language(lldb::eLanguageTypeUnknown, lldb::eLanguageTypeUnknown) { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override { Error error; const int short_option = m_getopt_table[option_idx].val; @@ -1241,7 +1281,10 @@ class CommandObjectTypeFormatList : public CommandObjectParsed switch (short_option) { case 'w': - m_category_regex = std::string(option_arg); + m_category_regex.SetCurrentValue(option_arg); + break; + case 'l': + error = m_category_language.SetValueFromString(option_arg); break; default: error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); @@ -1252,14 +1295,22 @@ class CommandObjectTypeFormatList : public CommandObjectParsed } void - OptionParsingStarting () + OptionParsingStarting () override { - m_category_regex = ""; + m_category_regex.Clear(); + m_category_language.Clear(); } const OptionDefinition* - GetDefinitions () + GetDefinitions () override { + static OptionDefinition g_option_table[] = + { + { LLDB_OPT_SET_1, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Only show categories matching this filter."}, + { LLDB_OPT_SET_2, false, "language", 'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage, "Only show the category for a specific language."}, + { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } + }; + return g_option_table; } @@ -1269,23 +1320,25 @@ class CommandObjectTypeFormatList : public CommandObjectParsed // Instance variables to hold the values for command options. - std::string m_category_regex; - + OptionValueString m_category_regex; + OptionValueLanguage m_category_language; }; CommandOptions m_options; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_options; } public: - CommandObjectTypeFormatList (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterList (CommandInterpreter &interpreter, + const char* name, + const char* help) : CommandObjectParsed (interpreter, - "type format list", - "Show a list of current formatting styles.", + name, + help, NULL), m_options(interpreter) { @@ -1300,117 +1353,155 @@ public: m_arguments.push_back (type_arg); } - ~CommandObjectTypeFormatList () + ~CommandObjectTypeFormatterList () override { } protected: + virtual void + FormatterSpecificList (CommandReturnObject &result) + { + } + bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { const size_t argc = command.GetArgumentCount(); - CommandObjectTypeFormatList_LoopCallbackParam *param; - RegularExpression* cate_regex = - m_options.m_category_regex.empty() ? NULL : - new RegularExpression(m_options.m_category_regex.c_str()); + std::unique_ptr<RegularExpression> category_regex; + std::unique_ptr<RegularExpression> formatter_regex; - if (argc == 1) + if (m_options.m_category_regex.OptionWasSet()) { - RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); - regex->Compile(command.GetArgumentAtIndex(0)); - param = new CommandObjectTypeFormatList_LoopCallbackParam(this,&result,regex,cate_regex); + category_regex.reset(new RegularExpression()); + if (!category_regex->Compile(m_options.m_category_regex.GetCurrentValue())) + { + result.AppendErrorWithFormat("syntax error in category regular expression '%s'", m_options.m_category_regex.GetCurrentValue()); + result.SetStatus(eReturnStatusFailed); + return false; + } } - else - param = new CommandObjectTypeFormatList_LoopCallbackParam(this,&result,NULL,cate_regex); - - DataVisualization::Categories::LoopThrough(PerCategoryCallback,param); - delete param; - - if (cate_regex) - delete cate_regex; - result.SetStatus(eReturnStatusSuccessFinishResult); - return result.Succeeded(); - } - -private: - - static bool - PerCategoryCallback(void* param_vp, - const lldb::TypeCategoryImplSP& cate) - { - - CommandObjectTypeFormatList_LoopCallbackParam* param = - (CommandObjectTypeFormatList_LoopCallbackParam*)param_vp; - CommandReturnObject* result = param->result; - - const char* cate_name = cate->GetName(); - - // if the category is disabled or empty and there is no regex, just skip it - if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemValue | eFormatCategoryItemRegexValue) == 0) && param->cate_regex == NULL) - return true; - - // if we have a regex and this category does not match it, just skip it - if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false) - return true; - - result->GetOutputStream().Printf("-----------------------\nCategory: %s (%s)\n-----------------------\n", - cate_name, - (cate->IsEnabled() ? "enabled" : "disabled")); + if (argc == 1) + { + const char* arg = command.GetArgumentAtIndex(1); + formatter_regex.reset(new RegularExpression()); + if (!formatter_regex->Compile(arg)) + { + result.AppendErrorWithFormat("syntax error in regular expression '%s'", arg); + result.SetStatus(eReturnStatusFailed); + return false; + } + } - cate->GetTypeFormatsContainer()->LoopThrough(CommandObjectTypeFormatList_LoopCallback, param_vp); + auto category_closure = [&result, &formatter_regex] (const lldb::TypeCategoryImplSP& category) -> void { + result.GetOutputStream().Printf("-----------------------\nCategory: %s\n-----------------------\n", category->GetName()); + + typedef const std::shared_ptr<FormatterType> Bar; + typedef std::function<bool(ConstString,Bar)> Func1Type; + typedef std::function<bool(RegularExpressionSP,Bar)> Func2Type; + + TypeCategoryImpl::ForEachCallbacks<FormatterType> foreach; + foreach.SetExact([&result, &formatter_regex] (ConstString name, const FormatterSharedPointer& format_sp) -> bool { + if (formatter_regex) + { + bool escape = true; + if (0 == strcmp(name.AsCString(), formatter_regex->GetText())) + { + escape = false; + } + else if (formatter_regex->Execute(name.AsCString())) + { + escape = false; + } + + if (escape) + return true; + } + + result.GetOutputStream().Printf ("%s: %s\n", name.AsCString(), format_sp->GetDescription().c_str()); + + return true; + }); + + foreach.SetWithRegex( [&result, &formatter_regex] (RegularExpressionSP regex_sp, const FormatterSharedPointer& format_sp) -> bool { + if (formatter_regex) + { + bool escape = true; + if (0 == strcmp(regex_sp->GetText(), formatter_regex->GetText())) + { + escape = false; + } + else if (formatter_regex->Execute(regex_sp->GetText())) + { + escape = false; + } + + if (escape) + return true; + } + + result.GetOutputStream().Printf ("%s: %s\n", regex_sp->GetText(), format_sp->GetDescription().c_str()); + + return true; + }); + + category->ForEach(foreach); + }; - if (cate->GetRegexTypeSummariesContainer()->GetCount() > 0) + if (m_options.m_category_language.OptionWasSet()) { - result->GetOutputStream().Printf("Regex-based summaries (slower):\n"); - cate->GetRegexTypeFormatsContainer()->LoopThrough(CommandObjectTypeRXFormatList_LoopCallback, param_vp); + lldb::TypeCategoryImplSP category_sp; + DataVisualization::Categories::GetCategory(m_options.m_category_language.GetCurrentValue(), category_sp); + if (category_sp) + category_closure(category_sp); } - return true; - } - - - bool - LoopCallback (const char* type, - const lldb::TypeFormatImplSP& entry, - RegularExpression* regex, - CommandReturnObject *result) - { - if (regex == NULL || strcmp(type,regex->GetText()) == 0 || regex->Execute(type)) - result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str()); - return true; + else + { + DataVisualization::Categories::ForEach( [this, &command, &result, &category_regex, &formatter_regex, &category_closure] (const lldb::TypeCategoryImplSP& category) -> bool { + if (category_regex) + { + bool escape = true; + if (0 == strcmp(category->GetName(), category_regex->GetText())) + { + escape = false; + } + else if (category_regex->Execute(category->GetName())) + { + escape = false; + } + + if (escape) + return true; + } + + category_closure(category); + + return true; + }); + + FormatterSpecificList(result); + } + + result.SetStatus(eReturnStatusSuccessFinishResult); + return result.Succeeded(); } - - friend bool CommandObjectTypeFormatList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeFormatImplSP& entry); - friend bool CommandObjectTypeRXFormatList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const lldb::TypeFormatImplSP& entry); - }; -bool -CommandObjectTypeFormatList_LoopCallback ( - void* pt2self, - ConstString type, - const lldb::TypeFormatImplSP& entry) -{ - CommandObjectTypeFormatList_LoopCallbackParam* param = (CommandObjectTypeFormatList_LoopCallbackParam*)pt2self; - return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result); -} - -bool -CommandObjectTypeRXFormatList_LoopCallback ( - void* pt2self, - lldb::RegularExpressionSP regex, - const lldb::TypeFormatImplSP& entry) -{ - CommandObjectTypeFormatList_LoopCallbackParam* param = (CommandObjectTypeFormatList_LoopCallbackParam*)pt2self; - return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result); -} +//------------------------------------------------------------------------- +// CommandObjectTypeFormatList +//------------------------------------------------------------------------- -OptionDefinition -CommandObjectTypeFormatList::CommandOptions::g_option_table[] = +class CommandObjectTypeFormatList : public CommandObjectTypeFormatterList<TypeFormatImpl> { - { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Only show categories matching this filter."}, - { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } +public: + + CommandObjectTypeFormatList (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterList(interpreter, + "type format list", + "Show a list of current formats.") + { + } }; #ifndef LLDB_DISABLE_PYTHON @@ -1438,6 +1529,9 @@ CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue (uint32_t option_idx case 'e': m_flags.SetDontShowChildren(false); break; + case 'h': + m_flags.SetHideEmptyAggregates(true); + break; case 'v': m_flags.SetDontShowValue(true); break; @@ -1924,6 +2018,7 @@ CommandObjectTypeSummaryAdd::CommandOptions::g_option_table[] = { LLDB_OPT_SET_3, false, "python-function", 'F', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePythonFunction, "Give the name of a Python function to use for this type."}, { LLDB_OPT_SET_3, false, "input-python", 'P', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Input Python code to use for this type manually."}, { LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "expand", 'e', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Expand aggregate data types to show children on separate lines."}, + { LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "hide-empty", 'h', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Do not expand aggregate data types with no children."}, { LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "name", 'n', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "A name for this summary string."}, { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; @@ -1933,194 +2028,113 @@ CommandObjectTypeSummaryAdd::CommandOptions::g_option_table[] = // CommandObjectTypeSummaryDelete //------------------------------------------------------------------------- -class CommandObjectTypeSummaryDelete : public CommandObjectParsed +class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete { -private: - class CommandOptions : public Options +public: + CommandObjectTypeSummaryDelete (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterDelete (interpreter, + eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary, + "type summary delete", + "Delete an existing summary for a type.") { - public: - - CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) - { - } - - virtual - ~CommandOptions (){} - - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) - { - Error error; - const int short_option = m_getopt_table[option_idx].val; - - switch (short_option) - { - case 'a': - m_delete_all = true; - break; - case 'w': - m_category = std::string(option_arg); - break; - default: - error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); - break; - } - - return error; - } - - void - OptionParsingStarting () - { - m_delete_all = false; - m_category = "default"; - } - - const OptionDefinition* - GetDefinitions () - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // Instance variables to hold the values for command options. - - bool m_delete_all; - std::string m_category; - - }; - - CommandOptions m_options; + } - virtual Options * - GetOptions () + ~CommandObjectTypeSummaryDelete () override { - return &m_options; } - static bool - PerCategoryCallback(void* param, - const lldb::TypeCategoryImplSP& category_sp) +protected: + bool + FormatterSpecificDeletion (ConstString typeCS) override { - ConstString *name = (ConstString*)param; - category_sp->Delete(*name, eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary); - return true; + if (m_options.m_language != lldb::eLanguageTypeUnknown) + return false; + return DataVisualization::NamedSummaryFormats::Delete(typeCS); } +}; +class CommandObjectTypeSummaryClear : public CommandObjectTypeFormatterClear +{ public: - CommandObjectTypeSummaryDelete (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type summary delete", - "Delete an existing summary style for a type.", - NULL), - m_options(interpreter) + CommandObjectTypeSummaryClear (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterClear (interpreter, + eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary, + "type summary clear", + "Delete all existing summaries.") { - CommandArgumentEntry type_arg; - CommandArgumentData type_style_arg; - - type_style_arg.arg_type = eArgTypeName; - type_style_arg.arg_repetition = eArgRepeatPlain; - - type_arg.push_back (type_style_arg); - - m_arguments.push_back (type_arg); - } - ~CommandObjectTypeSummaryDelete () +protected: + void + FormatterSpecificDeletion () override + { + DataVisualization::NamedSummaryFormats::Clear(); + } +}; + +//------------------------------------------------------------------------- +// CommandObjectTypeSummaryList +//------------------------------------------------------------------------- + +class CommandObjectTypeSummaryList : public CommandObjectTypeFormatterList<TypeSummaryImpl> +{ +public: + + CommandObjectTypeSummaryList (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterList(interpreter, + "type summary list", + "Show a list of current summaries.") { } protected: - bool - DoExecute (Args& command, CommandReturnObject &result) + void + FormatterSpecificList (CommandReturnObject &result) override { - const size_t argc = command.GetArgumentCount(); - - if (argc != 1) - { - result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str()); - result.SetStatus(eReturnStatusFailed); - return false; - } - - const char* typeA = command.GetArgumentAtIndex(0); - ConstString typeCS(typeA); - - if (!typeCS) - { - result.AppendError("empty typenames not allowed"); - result.SetStatus(eReturnStatusFailed); - return false; - } - - if (m_options.m_delete_all) - { - DataVisualization::Categories::LoopThrough(PerCategoryCallback, &typeCS); - result.SetStatus(eReturnStatusSuccessFinishNoResult); - return result.Succeeded(); - } - - lldb::TypeCategoryImplSP category; - DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); - - bool delete_category = category->Delete(typeCS, - eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary); - bool delete_named = DataVisualization::NamedSummaryFormats::Delete(typeCS); - - if (delete_category || delete_named) - { - result.SetStatus(eReturnStatusSuccessFinishNoResult); - return result.Succeeded(); - } - else + if (DataVisualization::NamedSummaryFormats::GetCount() > 0) { - result.AppendErrorWithFormat ("no custom summary for %s.\n", typeA); - result.SetStatus(eReturnStatusFailed); - return false; + result.GetOutputStream().Printf("Named summaries:\n"); + DataVisualization::NamedSummaryFormats::ForEach( [&result] (ConstString name, const TypeSummaryImplSP& summary_sp) -> bool { + result.GetOutputStream().Printf ("%s: %s\n", name.AsCString(), summary_sp->GetDescription().c_str()); + return true; + }); } - } }; -OptionDefinition -CommandObjectTypeSummaryDelete::CommandOptions::g_option_table[] = -{ - { LLDB_OPT_SET_1, false, "all", 'a', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Delete from every category."}, - { LLDB_OPT_SET_2, false, "category", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Delete from given category."}, - { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } -}; +//------------------------------------------------------------------------- +// CommandObjectTypeCategoryDefine +//------------------------------------------------------------------------- -class CommandObjectTypeSummaryClear : public CommandObjectParsed +class CommandObjectTypeCategoryDefine : public CommandObjectParsed { -private: class CommandOptions : public Options { public: CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) + Options (interpreter), + m_define_enabled(false,false), + m_cate_language(eLanguageTypeUnknown,eLanguageTypeUnknown) { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override { Error error; const int short_option = m_getopt_table[option_idx].val; switch (short_option) { - case 'a': - m_delete_all = true; + case 'e': + m_define_enabled.SetValueFromString("true"); + break; + case 'l': + error = m_cate_language.SetValueFromString(option_arg); break; default: error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); @@ -2131,13 +2145,14 @@ private: } void - OptionParsingStarting () + OptionParsingStarting () override { - m_delete_all = false; + m_define_enabled.Clear(); + m_cate_language.Clear(); } const OptionDefinition* - GetDefinitions () + GetDefinitions () override { return g_option_table; } @@ -2148,66 +2163,69 @@ private: // Instance variables to hold the values for command options. - bool m_delete_all; - bool m_delete_named; + OptionValueBoolean m_define_enabled; + OptionValueLanguage m_cate_language; + + }; CommandOptions m_options; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_options; } - - static bool - PerCategoryCallback(void* param, - const lldb::TypeCategoryImplSP& cate) - { - cate->GetTypeSummariesContainer()->Clear(); - cate->GetRegexTypeSummariesContainer()->Clear(); - return true; - - } - + public: - CommandObjectTypeSummaryClear (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type summary clear", - "Delete all existing summary styles.", - NULL), - m_options(interpreter) + CommandObjectTypeCategoryDefine (CommandInterpreter &interpreter) : + CommandObjectParsed (interpreter, + "type category define", + "Define a new category as a source of formatters.", + NULL), + m_options(interpreter) { + CommandArgumentEntry type_arg; + CommandArgumentData type_style_arg; + + type_style_arg.arg_type = eArgTypeName; + type_style_arg.arg_repetition = eArgRepeatPlus; + + type_arg.push_back (type_style_arg); + + m_arguments.push_back (type_arg); + } - ~CommandObjectTypeSummaryClear () + ~CommandObjectTypeCategoryDefine () override { } protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { + const size_t argc = command.GetArgumentCount(); - if (m_options.m_delete_all) - DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL); + if (argc < 1) + { + result.AppendErrorWithFormat ("%s takes 1 or more args.\n", m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; + } - else - { - lldb::TypeCategoryImplSP category; - if (command.GetArgumentCount() > 0) + for (size_t i = 0; i < argc; i++) + { + const char* cateName = command.GetArgumentAtIndex(i); + TypeCategoryImplSP category_sp; + if (DataVisualization::Categories::GetCategory(ConstString(cateName), category_sp) && category_sp) { - const char* cat_name = command.GetArgumentAtIndex(0); - ConstString cat_nameCS(cat_name); - DataVisualization::Categories::GetCategory(cat_nameCS, category); + category_sp->AddLanguage(m_options.m_cate_language.GetCurrentValue()); + if (m_options.m_define_enabled.GetCurrentValue()) + DataVisualization::Categories::Enable(category_sp, TypeCategoryMap::Default); } - else - DataVisualization::Categories::GetCategory(ConstString(NULL), category); - category->Clear(eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary); } - DataVisualization::NamedSummaryFormats::Clear(); - result.SetStatus(eReturnStatusSuccessFinishResult); return result.Succeeded(); } @@ -2215,34 +2233,19 @@ protected: }; OptionDefinition -CommandObjectTypeSummaryClear::CommandOptions::g_option_table[] = +CommandObjectTypeCategoryDefine::CommandOptions::g_option_table[] = { - { LLDB_OPT_SET_ALL, false, "all", 'a', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Clear every category."}, + { LLDB_OPT_SET_ALL, false, "enabled", 'e', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "If specified, this category will be created enabled."}, + { LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage, "Specify the language that this category is supported for."}, { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; //------------------------------------------------------------------------- -// CommandObjectTypeSummaryList +// CommandObjectTypeCategoryEnable //------------------------------------------------------------------------- -bool CommandObjectTypeSummaryList_LoopCallback(void* pt2self, ConstString type, const StringSummaryFormat::SharedPointer& entry); -bool CommandObjectTypeRXSummaryList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const StringSummaryFormat::SharedPointer& entry); - -class CommandObjectTypeSummaryList; - -struct CommandObjectTypeSummaryList_LoopCallbackParam { - CommandObjectTypeSummaryList* self; - CommandReturnObject* result; - RegularExpression* regex; - RegularExpression* cate_regex; - CommandObjectTypeSummaryList_LoopCallbackParam(CommandObjectTypeSummaryList* S, CommandReturnObject* R, - RegularExpression* X = NULL, - RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {} -}; - -class CommandObjectTypeSummaryList : public CommandObjectParsed +class CommandObjectTypeCategoryEnable : public CommandObjectParsed { - class CommandOptions : public Options { public: @@ -2252,19 +2255,23 @@ class CommandObjectTypeSummaryList : public CommandObjectParsed { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override { Error error; const int short_option = m_getopt_table[option_idx].val; switch (short_option) { - case 'w': - m_category_regex = std::string(option_arg); + case 'l': + if (option_arg) + { + m_language = Language::GetLanguageTypeFromString(option_arg); + if (m_language == lldb::eLanguageTypeUnknown) + error.SetErrorStringWithFormat ("unrecognized language '%s'", option_arg); + } break; default: error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); @@ -2275,13 +2282,13 @@ class CommandObjectTypeSummaryList : public CommandObjectParsed } void - OptionParsingStarting () + OptionParsingStarting () override { - m_category_regex = ""; + m_language = lldb::eLanguageTypeUnknown; } const OptionDefinition* - GetDefinitions () + GetDefinitions () override { return g_option_table; } @@ -2292,176 +2299,25 @@ class CommandObjectTypeSummaryList : public CommandObjectParsed // Instance variables to hold the values for command options. - std::string m_category_regex; + lldb::LanguageType m_language; }; CommandOptions m_options; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_options; } public: - CommandObjectTypeSummaryList (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type summary list", - "Show a list of current summary styles.", - NULL), - m_options(interpreter) - { - CommandArgumentEntry type_arg; - CommandArgumentData type_style_arg; - - type_style_arg.arg_type = eArgTypeName; - type_style_arg.arg_repetition = eArgRepeatOptional; - - type_arg.push_back (type_style_arg); - - m_arguments.push_back (type_arg); - } - - ~CommandObjectTypeSummaryList () - { - } - -protected: - bool - DoExecute (Args& command, CommandReturnObject &result) - { - const size_t argc = command.GetArgumentCount(); - - CommandObjectTypeSummaryList_LoopCallbackParam *param; - RegularExpression* cate_regex = - m_options.m_category_regex.empty() ? NULL : - new RegularExpression(m_options.m_category_regex.c_str()); - - if (argc == 1) - { - RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); - regex->Compile(command.GetArgumentAtIndex(0)); - param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,regex,cate_regex); - } - else - param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,NULL,cate_regex); - - DataVisualization::Categories::LoopThrough(PerCategoryCallback,param); - delete param; - - if (DataVisualization::NamedSummaryFormats::GetCount() > 0) - { - result.GetOutputStream().Printf("Named summaries:\n"); - if (argc == 1) - { - RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); - regex->Compile(command.GetArgumentAtIndex(0)); - param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,regex); - } - else - param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result); - DataVisualization::NamedSummaryFormats::LoopThrough(CommandObjectTypeSummaryList_LoopCallback, param); - delete param; - } - - if (cate_regex) - delete cate_regex; - - result.SetStatus(eReturnStatusSuccessFinishResult); - return result.Succeeded(); - } - -private: - - static bool - PerCategoryCallback(void* param_vp, - const lldb::TypeCategoryImplSP& cate) - { - - CommandObjectTypeSummaryList_LoopCallbackParam* param = - (CommandObjectTypeSummaryList_LoopCallbackParam*)param_vp; - CommandReturnObject* result = param->result; - - const char* cate_name = cate->GetName(); - - // if the category is disabled or empty and there is no regex, just skip it - if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary) == 0) && param->cate_regex == NULL) - return true; - - // if we have a regex and this category does not match it, just skip it - if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false) - return true; - - result->GetOutputStream().Printf("-----------------------\nCategory: %s (%s)\n-----------------------\n", - cate_name, - (cate->IsEnabled() ? "enabled" : "disabled")); - - cate->GetTypeSummariesContainer()->LoopThrough(CommandObjectTypeSummaryList_LoopCallback, param_vp); - - if (cate->GetRegexTypeSummariesContainer()->GetCount() > 0) - { - result->GetOutputStream().Printf("Regex-based summaries (slower):\n"); - cate->GetRegexTypeSummariesContainer()->LoopThrough(CommandObjectTypeRXSummaryList_LoopCallback, param_vp); - } - return true; - } - - - bool - LoopCallback (const char* type, - const lldb::TypeSummaryImplSP& entry, - RegularExpression* regex, - CommandReturnObject *result) - { - if (regex == NULL || strcmp(type,regex->GetText()) == 0 || regex->Execute(type)) - result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str()); - return true; - } - - friend bool CommandObjectTypeSummaryList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeSummaryImplSP& entry); - friend bool CommandObjectTypeRXSummaryList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const lldb::TypeSummaryImplSP& entry); -}; - -bool -CommandObjectTypeSummaryList_LoopCallback ( - void* pt2self, - ConstString type, - const lldb::TypeSummaryImplSP& entry) -{ - CommandObjectTypeSummaryList_LoopCallbackParam* param = (CommandObjectTypeSummaryList_LoopCallbackParam*)pt2self; - return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result); -} - -bool -CommandObjectTypeRXSummaryList_LoopCallback ( - void* pt2self, - lldb::RegularExpressionSP regex, - const lldb::TypeSummaryImplSP& entry) -{ - CommandObjectTypeSummaryList_LoopCallbackParam* param = (CommandObjectTypeSummaryList_LoopCallbackParam*)pt2self; - return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result); -} - -OptionDefinition -CommandObjectTypeSummaryList::CommandOptions::g_option_table[] = -{ - { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Only show categories matching this filter."}, - { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } -}; - -//------------------------------------------------------------------------- -// CommandObjectTypeCategoryEnable -//------------------------------------------------------------------------- - -class CommandObjectTypeCategoryEnable : public CommandObjectParsed -{ -public: CommandObjectTypeCategoryEnable (CommandInterpreter &interpreter) : CommandObjectParsed (interpreter, "type category enable", "Enable a category as a source of formatters.", - NULL) + NULL), + m_options(interpreter) { CommandArgumentEntry type_arg; CommandArgumentData type_style_arg; @@ -2475,19 +2331,20 @@ public: } - ~CommandObjectTypeCategoryEnable () + ~CommandObjectTypeCategoryEnable () override { } protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { const size_t argc = command.GetArgumentCount(); - if (argc < 1) + if (argc < 1 && + m_options.m_language == lldb::eLanguageTypeUnknown) { - result.AppendErrorWithFormat ("%s takes 1 or more args.\n", m_cmd_name.c_str()); + result.AppendErrorWithFormat ("%s takes arguments and/or a language", m_cmd_name.c_str()); result.SetStatus(eReturnStatusFailed); return false; } @@ -2496,7 +2353,7 @@ protected: { DataVisualization::Categories::EnableStar(); } - else + else if (argc > 0) { for (int i = argc - 1; i >= 0; i--) { @@ -2521,12 +2378,22 @@ protected: } } + if (m_options.m_language != lldb::eLanguageTypeUnknown) + DataVisualization::Categories::Enable(m_options.m_language); + result.SetStatus(eReturnStatusSuccessFinishResult); return result.Succeeded(); } }; +OptionDefinition +CommandObjectTypeCategoryEnable::CommandOptions::g_option_table[] = +{ + { LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage, "Enable the category for this language."}, + { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } +}; + //------------------------------------------------------------------------- // CommandObjectTypeCategoryDelete //------------------------------------------------------------------------- @@ -2552,13 +2419,13 @@ public: } - ~CommandObjectTypeCategoryDelete () + ~CommandObjectTypeCategoryDelete () override { } protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { const size_t argc = command.GetArgumentCount(); @@ -2606,185 +2473,6 @@ protected: class CommandObjectTypeCategoryDisable : public CommandObjectParsed { -public: - CommandObjectTypeCategoryDisable (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type category disable", - "Disable a category as a source of formatters.", - NULL) - { - CommandArgumentEntry type_arg; - CommandArgumentData type_style_arg; - - type_style_arg.arg_type = eArgTypeName; - type_style_arg.arg_repetition = eArgRepeatPlus; - - type_arg.push_back (type_style_arg); - - m_arguments.push_back (type_arg); - - } - - ~CommandObjectTypeCategoryDisable () - { - } - -protected: - bool - DoExecute (Args& command, CommandReturnObject &result) - { - const size_t argc = command.GetArgumentCount(); - - if (argc < 1) - { - result.AppendErrorWithFormat ("%s takes 1 or more args.\n", m_cmd_name.c_str()); - result.SetStatus(eReturnStatusFailed); - return false; - } - - if (argc == 1 && strcmp(command.GetArgumentAtIndex(0),"*") == 0) - { - DataVisualization::Categories::DisableStar(); - } - else - { - // the order is not relevant here - for (int i = argc - 1; i >= 0; i--) - { - const char* typeA = command.GetArgumentAtIndex(i); - ConstString typeCS(typeA); - - if (!typeCS) - { - result.AppendError("empty category name not allowed"); - result.SetStatus(eReturnStatusFailed); - return false; - } - DataVisualization::Categories::Disable(typeCS); - } - } - - result.SetStatus(eReturnStatusSuccessFinishResult); - return result.Succeeded(); - } - -}; - -//------------------------------------------------------------------------- -// CommandObjectTypeCategoryList -//------------------------------------------------------------------------- - -class CommandObjectTypeCategoryList : public CommandObjectParsed -{ -private: - - struct CommandObjectTypeCategoryList_CallbackParam - { - CommandReturnObject* result; - RegularExpression* regex; - - CommandObjectTypeCategoryList_CallbackParam(CommandReturnObject* res, - RegularExpression* rex = NULL) : - result(res), - regex(rex) - { - } - - }; - - static bool - PerCategoryCallback(void* param_vp, - const lldb::TypeCategoryImplSP& cate) - { - CommandObjectTypeCategoryList_CallbackParam* param = - (CommandObjectTypeCategoryList_CallbackParam*)param_vp; - CommandReturnObject* result = param->result; - RegularExpression* regex = param->regex; - - const char* cate_name = cate->GetName(); - - if (regex == NULL || strcmp(cate_name, regex->GetText()) == 0 || regex->Execute(cate_name)) - result->GetOutputStream().Printf("Category %s is%s enabled\n", - cate_name, - (cate->IsEnabled() ? "" : " not")); - return true; - } -public: - CommandObjectTypeCategoryList (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type category list", - "Provide a list of all existing categories.", - NULL) - { - CommandArgumentEntry type_arg; - CommandArgumentData type_style_arg; - - type_style_arg.arg_type = eArgTypeName; - type_style_arg.arg_repetition = eArgRepeatOptional; - - type_arg.push_back (type_style_arg); - - m_arguments.push_back (type_arg); - } - - ~CommandObjectTypeCategoryList () - { - } - -protected: - bool - DoExecute (Args& command, CommandReturnObject &result) - { - const size_t argc = command.GetArgumentCount(); - RegularExpression* regex = NULL; - - if (argc == 0) - ; - else if (argc == 1) - regex = new RegularExpression(command.GetArgumentAtIndex(0)); - else - { - result.AppendErrorWithFormat ("%s takes 0 or one arg.\n", m_cmd_name.c_str()); - result.SetStatus(eReturnStatusFailed); - return false; - } - - CommandObjectTypeCategoryList_CallbackParam param(&result, - regex); - - DataVisualization::Categories::LoopThrough(PerCategoryCallback, ¶m); - - if (regex) - delete regex; - - result.SetStatus(eReturnStatusSuccessFinishResult); - return result.Succeeded(); - } - -}; - -//------------------------------------------------------------------------- -// CommandObjectTypeFilterList -//------------------------------------------------------------------------- - -bool CommandObjectTypeFilterList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry); -bool CommandObjectTypeFilterRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry); - -class CommandObjectTypeFilterList; - -struct CommandObjectTypeFilterList_LoopCallbackParam { - CommandObjectTypeFilterList* self; - CommandReturnObject* result; - RegularExpression* regex; - RegularExpression* cate_regex; - CommandObjectTypeFilterList_LoopCallbackParam(CommandObjectTypeFilterList* S, CommandReturnObject* R, - RegularExpression* X = NULL, - RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {} -}; - -class CommandObjectTypeFilterList : public CommandObjectParsed -{ - class CommandOptions : public Options { public: @@ -2794,19 +2482,23 @@ class CommandObjectTypeFilterList : public CommandObjectParsed { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override { Error error; const int short_option = m_getopt_table[option_idx].val; switch (short_option) { - case 'w': - m_category_regex = std::string(option_arg); + case 'l': + if (option_arg) + { + m_language = Language::GetLanguageTypeFromString(option_arg); + if (m_language == lldb::eLanguageTypeUnknown) + error.SetErrorStringWithFormat ("unrecognized language '%s'", option_arg); + } break; default: error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); @@ -2817,13 +2509,13 @@ class CommandObjectTypeFilterList : public CommandObjectParsed } void - OptionParsingStarting () + OptionParsingStarting () override { - m_category_regex = ""; + m_language = lldb::eLanguageTypeUnknown; } const OptionDefinition* - GetDefinitions () + GetDefinitions () override { return g_option_table; } @@ -2834,23 +2526,23 @@ class CommandObjectTypeFilterList : public CommandObjectParsed // Instance variables to hold the values for command options. - std::string m_category_regex; + lldb::LanguageType m_language; }; CommandOptions m_options; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_options; } - + public: - CommandObjectTypeFilterList (CommandInterpreter &interpreter) : + CommandObjectTypeCategoryDisable (CommandInterpreter &interpreter) : CommandObjectParsed (interpreter, - "type filter list", - "Show a list of current filters.", + "type category disable", + "Disable a category as a source of formatters.", NULL), m_options(interpreter) { @@ -2858,216 +2550,82 @@ public: CommandArgumentData type_style_arg; type_style_arg.arg_type = eArgTypeName; - type_style_arg.arg_repetition = eArgRepeatOptional; + type_style_arg.arg_repetition = eArgRepeatPlus; type_arg.push_back (type_style_arg); m_arguments.push_back (type_arg); + } - ~CommandObjectTypeFilterList () + ~CommandObjectTypeCategoryDisable () override { } protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { const size_t argc = command.GetArgumentCount(); - CommandObjectTypeFilterList_LoopCallbackParam *param; - RegularExpression* cate_regex = - m_options.m_category_regex.empty() ? NULL : - new RegularExpression(m_options.m_category_regex.c_str()); - - if (argc == 1) + if (argc < 1 && + m_options.m_language == lldb::eLanguageTypeUnknown) { - RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); - regex->Compile(command.GetArgumentAtIndex(0)); - param = new CommandObjectTypeFilterList_LoopCallbackParam(this,&result,regex,cate_regex); + result.AppendErrorWithFormat ("%s takes arguments and/or a language", m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; } - else - param = new CommandObjectTypeFilterList_LoopCallbackParam(this,&result,NULL,cate_regex); - - DataVisualization::Categories::LoopThrough(PerCategoryCallback,param); - delete param; - - if (cate_regex) - delete cate_regex; - - result.SetStatus(eReturnStatusSuccessFinishResult); - return result.Succeeded(); - } - -private: - - static bool - PerCategoryCallback(void* param_vp, - const lldb::TypeCategoryImplSP& cate) - { - const char* cate_name = cate->GetName(); - - CommandObjectTypeFilterList_LoopCallbackParam* param = - (CommandObjectTypeFilterList_LoopCallbackParam*)param_vp; - CommandReturnObject* result = param->result; - - // if the category is disabled or empty and there is no regex, just skip it - if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter) == 0) && param->cate_regex == NULL) - return true; - - // if we have a regex and this category does not match it, just skip it - if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false) - return true; - - result->GetOutputStream().Printf("-----------------------\nCategory: %s (%s)\n-----------------------\n", - cate_name, - (cate->IsEnabled() ? "enabled" : "disabled")); - - cate->GetTypeFiltersContainer()->LoopThrough(CommandObjectTypeFilterList_LoopCallback, param_vp); - - if (cate->GetRegexTypeFiltersContainer()->GetCount() > 0) + if (argc == 1 && strcmp(command.GetArgumentAtIndex(0),"*") == 0) + { + DataVisualization::Categories::DisableStar(); + } + else if (argc > 0) { - result->GetOutputStream().Printf("Regex-based filters (slower):\n"); - cate->GetRegexTypeFiltersContainer()->LoopThrough(CommandObjectTypeFilterRXList_LoopCallback, param_vp); + // the order is not relevant here + for (int i = argc - 1; i >= 0; i--) + { + const char* typeA = command.GetArgumentAtIndex(i); + ConstString typeCS(typeA); + + if (!typeCS) + { + result.AppendError("empty category name not allowed"); + result.SetStatus(eReturnStatusFailed); + return false; + } + DataVisualization::Categories::Disable(typeCS); + } } - return true; - } - - bool - LoopCallback (const char* type, - const SyntheticChildren::SharedPointer& entry, - RegularExpression* regex, - CommandReturnObject *result) - { - if (regex == NULL || regex->Execute(type)) - result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str()); - return true; + if (m_options.m_language != lldb::eLanguageTypeUnknown) + DataVisualization::Categories::Disable(m_options.m_language); + + result.SetStatus(eReturnStatusSuccessFinishResult); + return result.Succeeded(); } - friend bool CommandObjectTypeFilterList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry); - friend bool CommandObjectTypeFilterRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry); }; -bool -CommandObjectTypeFilterList_LoopCallback (void* pt2self, - ConstString type, - const SyntheticChildren::SharedPointer& entry) -{ - CommandObjectTypeFilterList_LoopCallbackParam* param = (CommandObjectTypeFilterList_LoopCallbackParam*)pt2self; - return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result); -} - -bool -CommandObjectTypeFilterRXList_LoopCallback (void* pt2self, - lldb::RegularExpressionSP regex, - const SyntheticChildren::SharedPointer& entry) -{ - CommandObjectTypeFilterList_LoopCallbackParam* param = (CommandObjectTypeFilterList_LoopCallbackParam*)pt2self; - return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result); -} - - OptionDefinition -CommandObjectTypeFilterList::CommandOptions::g_option_table[] = +CommandObjectTypeCategoryDisable::CommandOptions::g_option_table[] = { - { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Only show categories matching this filter."}, + { LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage, "Enable the category for this language."}, { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; -#ifndef LLDB_DISABLE_PYTHON - //------------------------------------------------------------------------- -// CommandObjectTypeSynthList +// CommandObjectTypeCategoryList //------------------------------------------------------------------------- -bool CommandObjectTypeSynthList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry); -bool CommandObjectTypeSynthRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry); - -class CommandObjectTypeSynthList; - -struct CommandObjectTypeSynthList_LoopCallbackParam { - CommandObjectTypeSynthList* self; - CommandReturnObject* result; - RegularExpression* regex; - RegularExpression* cate_regex; - CommandObjectTypeSynthList_LoopCallbackParam(CommandObjectTypeSynthList* S, CommandReturnObject* R, - RegularExpression* X = NULL, - RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {} -}; - -class CommandObjectTypeSynthList : public CommandObjectParsed +class CommandObjectTypeCategoryList : public CommandObjectParsed { - - class CommandOptions : public Options - { - public: - - CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) - { - } - - virtual - ~CommandOptions (){} - - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) - { - Error error; - const int short_option = m_getopt_table[option_idx].val; - - switch (short_option) - { - case 'w': - m_category_regex = std::string(option_arg); - break; - default: - error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); - break; - } - - return error; - } - - void - OptionParsingStarting () - { - m_category_regex = ""; - } - - const OptionDefinition* - GetDefinitions () - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // Instance variables to hold the values for command options. - - std::string m_category_regex; - - }; - - CommandOptions m_options; - - virtual Options * - GetOptions () - { - return &m_options; - } - public: - CommandObjectTypeSynthList (CommandInterpreter &interpreter) : + CommandObjectTypeCategoryList (CommandInterpreter &interpreter) : CommandObjectParsed (interpreter, - "type synthetic list", - "Show a list of current synthetic providers.", - NULL), - m_options(interpreter) + "type category list", + "Provide a list of all existing categories.", + NULL) { CommandArgumentEntry type_arg; CommandArgumentData type_style_arg; @@ -3080,115 +2638,96 @@ public: m_arguments.push_back (type_arg); } - ~CommandObjectTypeSynthList () + ~CommandObjectTypeCategoryList () override { } protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { const size_t argc = command.GetArgumentCount(); - - CommandObjectTypeSynthList_LoopCallbackParam *param; - RegularExpression* cate_regex = - m_options.m_category_regex.empty() ? NULL : - new RegularExpression(m_options.m_category_regex.c_str()); + + std::unique_ptr<RegularExpression> regex; if (argc == 1) { - RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); - regex->Compile(command.GetArgumentAtIndex(0)); - param = new CommandObjectTypeSynthList_LoopCallbackParam(this,&result,regex,cate_regex); + regex.reset(new RegularExpression()); + const char* arg = command.GetArgumentAtIndex(0); + if (!regex->Compile(arg)) + { + result.AppendErrorWithFormat("syntax error in category regular expression '%s'", arg); + result.SetStatus(eReturnStatusFailed); + return false; + } + } + else if (argc != 0) + { + result.AppendErrorWithFormat ("%s takes 0 or one arg.\n", m_cmd_name.c_str()); + result.SetStatus(eReturnStatusFailed); + return false; } - else - param = new CommandObjectTypeSynthList_LoopCallbackParam(this,&result,NULL,cate_regex); - DataVisualization::Categories::LoopThrough(PerCategoryCallback,param); - delete param; - - if (cate_regex) - delete cate_regex; + DataVisualization::Categories::ForEach( [®ex, &result] (const lldb::TypeCategoryImplSP& category_sp) -> bool { + if (regex) + { + bool escape = true; + if (0 == strcmp(category_sp->GetName(), regex->GetText())) + { + escape = false; + } + else if (regex->Execute(category_sp->GetName())) + { + escape = false; + } + + if (escape) + return true; + } + + result.GetOutputStream().Printf("Category: %s\n", category_sp->GetDescription().c_str()); + + return true; + }); result.SetStatus(eReturnStatusSuccessFinishResult); return result.Succeeded(); } -private: - - static bool - PerCategoryCallback(void* param_vp, - const lldb::TypeCategoryImplSP& cate) - { - - CommandObjectTypeSynthList_LoopCallbackParam* param = - (CommandObjectTypeSynthList_LoopCallbackParam*)param_vp; - CommandReturnObject* result = param->result; - - const char* cate_name = cate->GetName(); - - // if the category is disabled or empty and there is no regex, just skip it - if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth) == 0) && param->cate_regex == NULL) - return true; - - // if we have a regex and this category does not match it, just skip it - if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false) - return true; - - result->GetOutputStream().Printf("-----------------------\nCategory: %s (%s)\n-----------------------\n", - cate_name, - (cate->IsEnabled() ? "enabled" : "disabled")); - - cate->GetTypeSyntheticsContainer()->LoopThrough(CommandObjectTypeSynthList_LoopCallback, param_vp); - - if (cate->GetRegexTypeSyntheticsContainer()->GetCount() > 0) - { - result->GetOutputStream().Printf("Regex-based synthetic providers (slower):\n"); - cate->GetRegexTypeSyntheticsContainer()->LoopThrough(CommandObjectTypeSynthRXList_LoopCallback, param_vp); - } - - return true; - } +}; + +//------------------------------------------------------------------------- +// CommandObjectTypeFilterList +//------------------------------------------------------------------------- + +class CommandObjectTypeFilterList : public CommandObjectTypeFormatterList<TypeFilterImpl> +{ +public: - bool - LoopCallback (const char* type, - const SyntheticChildren::SharedPointer& entry, - RegularExpression* regex, - CommandReturnObject *result) + CommandObjectTypeFilterList (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterList(interpreter, + "type filter list", + "Show a list of current filters.") { - if (regex == NULL || regex->Execute(type)) - result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str()); - return true; } - - friend bool CommandObjectTypeSynthList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry); - friend bool CommandObjectTypeSynthRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry); }; -bool -CommandObjectTypeSynthList_LoopCallback (void* pt2self, - ConstString type, - const SyntheticChildren::SharedPointer& entry) -{ - CommandObjectTypeSynthList_LoopCallbackParam* param = (CommandObjectTypeSynthList_LoopCallbackParam*)pt2self; - return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result); -} - -bool -CommandObjectTypeSynthRXList_LoopCallback (void* pt2self, - lldb::RegularExpressionSP regex, - const SyntheticChildren::SharedPointer& entry) -{ - CommandObjectTypeSynthList_LoopCallbackParam* param = (CommandObjectTypeSynthList_LoopCallbackParam*)pt2self; - return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result); -} +#ifndef LLDB_DISABLE_PYTHON +//------------------------------------------------------------------------- +// CommandObjectTypeSynthList +//------------------------------------------------------------------------- -OptionDefinition -CommandObjectTypeSynthList::CommandOptions::g_option_table[] = +class CommandObjectTypeSynthList : public CommandObjectTypeFormatterList<SyntheticChildren> { - { LLDB_OPT_SET_ALL, false, "category-regex", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Only show categories matching this filter."}, - { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } +public: + + CommandObjectTypeSynthList (CommandInterpreter &interpreter) : + CommandObjectTypeFormatterList(interpreter, + "type synthetic list", + "Show a list of current synthetic providers.") + { + } }; #endif // #ifndef LLDB_DISABLE_PYTHON @@ -3196,164 +2735,20 @@ CommandObjectTypeSynthList::CommandOptions::g_option_table[] = // CommandObjectTypeFilterDelete //------------------------------------------------------------------------- -class CommandObjectTypeFilterDelete : public CommandObjectParsed +class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete { -private: - class CommandOptions : public Options - { - public: - - CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) - { - } - - virtual - ~CommandOptions (){} - - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) - { - Error error; - const int short_option = m_getopt_table[option_idx].val; - - switch (short_option) - { - case 'a': - m_delete_all = true; - break; - case 'w': - m_category = std::string(option_arg); - break; - default: - error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); - break; - } - - return error; - } - - void - OptionParsingStarting () - { - m_delete_all = false; - m_category = "default"; - } - - const OptionDefinition* - GetDefinitions () - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // Instance variables to hold the values for command options. - - bool m_delete_all; - std::string m_category; - - }; - - CommandOptions m_options; - - virtual Options * - GetOptions () - { - return &m_options; - } - - static bool - PerCategoryCallback(void* param, - const lldb::TypeCategoryImplSP& cate) - { - ConstString *name = (ConstString*)param; - return cate->Delete(*name, eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter); - } - public: CommandObjectTypeFilterDelete (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type filter delete", - "Delete an existing filter for a type.", - NULL), - m_options(interpreter) + CommandObjectTypeFormatterDelete (interpreter, + eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter, + "type filter delete", + "Delete an existing filter for a type.") { - CommandArgumentEntry type_arg; - CommandArgumentData type_style_arg; - - type_style_arg.arg_type = eArgTypeName; - type_style_arg.arg_repetition = eArgRepeatPlain; - - type_arg.push_back (type_style_arg); - - m_arguments.push_back (type_arg); - } - ~CommandObjectTypeFilterDelete () + ~CommandObjectTypeFilterDelete () override { } - -protected: - bool - DoExecute (Args& command, CommandReturnObject &result) - { - const size_t argc = command.GetArgumentCount(); - - if (argc != 1) - { - result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str()); - result.SetStatus(eReturnStatusFailed); - return false; - } - - const char* typeA = command.GetArgumentAtIndex(0); - ConstString typeCS(typeA); - - if (!typeCS) - { - result.AppendError("empty typenames not allowed"); - result.SetStatus(eReturnStatusFailed); - return false; - } - - if (m_options.m_delete_all) - { - DataVisualization::Categories::LoopThrough(PerCategoryCallback, (void*)&typeCS); - result.SetStatus(eReturnStatusSuccessFinishNoResult); - return result.Succeeded(); - } - - lldb::TypeCategoryImplSP category; - DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); - - bool delete_category = category->GetTypeFiltersContainer()->Delete(typeCS); - delete_category = category->GetRegexTypeFiltersContainer()->Delete(typeCS) || delete_category; - - if (delete_category) - { - result.SetStatus(eReturnStatusSuccessFinishNoResult); - return result.Succeeded(); - } - else - { - result.AppendErrorWithFormat ("no custom synthetic provider for %s.\n", typeA); - result.SetStatus(eReturnStatusFailed); - return false; - } - - } -}; - -OptionDefinition -CommandObjectTypeFilterDelete::CommandOptions::g_option_table[] = -{ - { LLDB_OPT_SET_1, false, "all", 'a', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Delete from every category."}, - { LLDB_OPT_SET_2, false, "category", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Delete from given category."}, - { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; #ifndef LLDB_DISABLE_PYTHON @@ -3362,164 +2757,20 @@ CommandObjectTypeFilterDelete::CommandOptions::g_option_table[] = // CommandObjectTypeSynthDelete //------------------------------------------------------------------------- -class CommandObjectTypeSynthDelete : public CommandObjectParsed +class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete { -private: - class CommandOptions : public Options - { - public: - - CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) - { - } - - virtual - ~CommandOptions (){} - - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) - { - Error error; - const int short_option = m_getopt_table[option_idx].val; - - switch (short_option) - { - case 'a': - m_delete_all = true; - break; - case 'w': - m_category = std::string(option_arg); - break; - default: - error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); - break; - } - - return error; - } - - void - OptionParsingStarting () - { - m_delete_all = false; - m_category = "default"; - } - - const OptionDefinition* - GetDefinitions () - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // Instance variables to hold the values for command options. - - bool m_delete_all; - std::string m_category; - - }; - - CommandOptions m_options; - - virtual Options * - GetOptions () - { - return &m_options; - } - - static bool - PerCategoryCallback(void* param, - const lldb::TypeCategoryImplSP& cate) - { - ConstString* name = (ConstString*)param; - return cate->Delete(*name, eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth); - } - public: CommandObjectTypeSynthDelete (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type synthetic delete", - "Delete an existing synthetic provider for a type.", - NULL), - m_options(interpreter) + CommandObjectTypeFormatterDelete (interpreter, + eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth, + "type synthetic delete", + "Delete an existing synthetic provider for a type.") { - CommandArgumentEntry type_arg; - CommandArgumentData type_style_arg; - - type_style_arg.arg_type = eArgTypeName; - type_style_arg.arg_repetition = eArgRepeatPlain; - - type_arg.push_back (type_style_arg); - - m_arguments.push_back (type_arg); - } - ~CommandObjectTypeSynthDelete () + ~CommandObjectTypeSynthDelete () override { } - -protected: - bool - DoExecute (Args& command, CommandReturnObject &result) - { - const size_t argc = command.GetArgumentCount(); - - if (argc != 1) - { - result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str()); - result.SetStatus(eReturnStatusFailed); - return false; - } - - const char* typeA = command.GetArgumentAtIndex(0); - ConstString typeCS(typeA); - - if (!typeCS) - { - result.AppendError("empty typenames not allowed"); - result.SetStatus(eReturnStatusFailed); - return false; - } - - if (m_options.m_delete_all) - { - DataVisualization::Categories::LoopThrough(PerCategoryCallback, (void*)&typeCS); - result.SetStatus(eReturnStatusSuccessFinishNoResult); - return result.Succeeded(); - } - - lldb::TypeCategoryImplSP category; - DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); - - bool delete_category = category->GetTypeSyntheticsContainer()->Delete(typeCS); - delete_category = category->GetRegexTypeSyntheticsContainer()->Delete(typeCS) || delete_category; - - if (delete_category) - { - result.SetStatus(eReturnStatusSuccessFinishNoResult); - return result.Succeeded(); - } - else - { - result.AppendErrorWithFormat ("no custom synthetic provider for %s.\n", typeA); - result.SetStatus(eReturnStatusFailed); - return false; - } - - } -}; - -OptionDefinition -CommandObjectTypeSynthDelete::CommandOptions::g_option_table[] = -{ - { LLDB_OPT_SET_1, false, "all", 'a', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Delete from every category."}, - { LLDB_OPT_SET_2, false, "category", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Delete from given category."}, - { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; #endif // #ifndef LLDB_DISABLE_PYTHON @@ -3528,128 +2779,16 @@ CommandObjectTypeSynthDelete::CommandOptions::g_option_table[] = // CommandObjectTypeFilterClear //------------------------------------------------------------------------- -class CommandObjectTypeFilterClear : public CommandObjectParsed +class CommandObjectTypeFilterClear : public CommandObjectTypeFormatterClear { -private: - - class CommandOptions : public Options - { - public: - - CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) - { - } - - virtual - ~CommandOptions (){} - - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) - { - Error error; - const int short_option = m_getopt_table[option_idx].val; - - switch (short_option) - { - case 'a': - m_delete_all = true; - break; - default: - error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); - break; - } - - return error; - } - - void - OptionParsingStarting () - { - m_delete_all = false; - } - - const OptionDefinition* - GetDefinitions () - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // Instance variables to hold the values for command options. - - bool m_delete_all; - bool m_delete_named; - }; - - CommandOptions m_options; - - virtual Options * - GetOptions () - { - return &m_options; - } - - static bool - PerCategoryCallback(void* param, - const lldb::TypeCategoryImplSP& cate) - { - cate->Clear(eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter); - return true; - - } - public: CommandObjectTypeFilterClear (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type filter clear", - "Delete all existing filters.", - NULL), - m_options(interpreter) + CommandObjectTypeFormatterClear (interpreter, + eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter, + "type filter clear", + "Delete all existing filter.") { } - - ~CommandObjectTypeFilterClear () - { - } - -protected: - bool - DoExecute (Args& command, CommandReturnObject &result) - { - - if (m_options.m_delete_all) - DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL); - - else - { - lldb::TypeCategoryImplSP category; - if (command.GetArgumentCount() > 0) - { - const char* cat_name = command.GetArgumentAtIndex(0); - ConstString cat_nameCS(cat_name); - DataVisualization::Categories::GetCategory(cat_nameCS, category); - } - else - DataVisualization::Categories::GetCategory(ConstString(NULL), category); - category->GetTypeFiltersContainer()->Clear(); - category->GetRegexTypeFiltersContainer()->Clear(); - } - - result.SetStatus(eReturnStatusSuccessFinishResult); - return result.Succeeded(); - } - -}; - -OptionDefinition -CommandObjectTypeFilterClear::CommandOptions::g_option_table[] = -{ - { LLDB_OPT_SET_ALL, false, "all", 'a', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Clear every category."}, - { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; #ifndef LLDB_DISABLE_PYTHON @@ -3657,131 +2796,18 @@ CommandObjectTypeFilterClear::CommandOptions::g_option_table[] = // CommandObjectTypeSynthClear //------------------------------------------------------------------------- -class CommandObjectTypeSynthClear : public CommandObjectParsed +class CommandObjectTypeSynthClear : public CommandObjectTypeFormatterClear { -private: - - class CommandOptions : public Options - { - public: - - CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) - { - } - - virtual - ~CommandOptions (){} - - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) - { - Error error; - const int short_option = m_getopt_table[option_idx].val; - - switch (short_option) - { - case 'a': - m_delete_all = true; - break; - default: - error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); - break; - } - - return error; - } - - void - OptionParsingStarting () - { - m_delete_all = false; - } - - const OptionDefinition* - GetDefinitions () - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // Instance variables to hold the values for command options. - - bool m_delete_all; - bool m_delete_named; - }; - - CommandOptions m_options; - - virtual Options * - GetOptions () - { - return &m_options; - } - - static bool - PerCategoryCallback(void* param, - const lldb::TypeCategoryImplSP& cate) - { - cate->Clear(eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth); - return true; - - } - public: CommandObjectTypeSynthClear (CommandInterpreter &interpreter) : - CommandObjectParsed (interpreter, - "type synthetic clear", - "Delete all existing synthetic providers.", - NULL), - m_options(interpreter) + CommandObjectTypeFormatterClear (interpreter, + eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth, + "type synthetic clear", + "Delete all existing synthetic providers.") { } - - ~CommandObjectTypeSynthClear () - { - } - -protected: - bool - DoExecute (Args& command, CommandReturnObject &result) - { - - if (m_options.m_delete_all) - DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL); - - else - { - lldb::TypeCategoryImplSP category; - if (command.GetArgumentCount() > 0) - { - const char* cat_name = command.GetArgumentAtIndex(0); - ConstString cat_nameCS(cat_name); - DataVisualization::Categories::GetCategory(cat_nameCS, category); - } - else - DataVisualization::Categories::GetCategory(ConstString(NULL), category); - category->GetTypeSyntheticsContainer()->Clear(); - category->GetRegexTypeSyntheticsContainer()->Clear(); - } - - result.SetStatus(eReturnStatusSuccessFinishResult); - return result.Succeeded(); - } - }; -OptionDefinition -CommandObjectTypeSynthClear::CommandOptions::g_option_table[] = -{ - { LLDB_OPT_SET_ALL, false, "all", 'a', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Clear every category."}, - { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } -}; - - bool CommandObjectTypeSynthAdd::Execute_HandwritePython (Args& command, CommandReturnObject &result) { @@ -3956,10 +2982,10 @@ CommandObjectTypeSynthAdd::CommandOptions::g_option_table[] = { { LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean, "If true, cascade through typedef chains."}, { LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."}, - { LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Don't use this format for references-to-tNULL, ype objects."}, + { LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Don't use this format for references-to-type objects."}, { LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName, "Add this to the given category instead of the default one."}, { LLDB_OPT_SET_2, false, "python-class", 'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePythonClass, "Use this Python class to produce synthetic children."}, - { LLDB_OPT_SET_3, false, "input-python", 'P', OptionParser::eNoArgument,NULL, NULL, 0, eArgTypeNone, "Type Python code to generate a class that NULL, provides synthetic children."}, + { LLDB_OPT_SET_3, false, "input-python", 'P', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Type Python code to generate a class that provides synthetic children."}, { LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Type names are actually regular expressions."}, { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; @@ -3981,11 +3007,10 @@ private: { } - virtual - ~CommandOptions (){} + ~CommandOptions () override {} - virtual Error - SetOptionValue (uint32_t option_idx, const char *option_arg) + Error + SetOptionValue (uint32_t option_idx, const char *option_arg) override { Error error; const int short_option = m_getopt_table[option_idx].val; @@ -4023,7 +3048,7 @@ private: } void - OptionParsingStarting () + OptionParsingStarting () override { m_cascade = true; m_skip_pointers = false; @@ -4035,7 +3060,7 @@ private: } const OptionDefinition* - GetDefinitions () + GetDefinitions () override { return g_option_table; } @@ -4062,8 +3087,8 @@ private: CommandOptions m_options; - virtual Options * - GetOptions () + Options * + GetOptions () override { return &m_options; } @@ -4076,7 +3101,7 @@ private: bool AddFilter(ConstString type_name, - SyntheticChildrenSP entry, + TypeFilterImplSP entry, FilterFormatType type, std::string category_name, Error* error) @@ -4175,13 +3200,13 @@ all children of my_foo as if no filter was defined:" R"( ); } - ~CommandObjectTypeFilterAdd () + ~CommandObjectTypeFilterAdd () override { } protected: bool - DoExecute (Args& command, CommandReturnObject &result) + DoExecute (Args& command, CommandReturnObject &result) override { const size_t argc = command.GetArgumentCount(); @@ -4199,19 +3224,15 @@ protected: return false; } - SyntheticChildrenSP entry; - - TypeFilterImpl* impl = new TypeFilterImpl(SyntheticChildren::Flags().SetCascades(m_options.m_cascade). - SetSkipPointers(m_options.m_skip_pointers). - SetSkipReferences(m_options.m_skip_references)); - - entry.reset(impl); + TypeFilterImplSP entry(new TypeFilterImpl(SyntheticChildren::Flags().SetCascades(m_options.m_cascade). + SetSkipPointers(m_options.m_skip_pointers). + SetSkipReferences(m_options.m_skip_references))); // go through the expression paths CommandOptions::ExpressionPathsIterator begin, end = m_options.m_expr_paths.end(); for (begin = m_options.m_expr_paths.begin(); begin != end; begin++) - impl->AddExpressionPath(*begin); + entry->AddExpressionPath(*begin); // now I have a valid provider, let's add it to every type @@ -4266,6 +3287,215 @@ CommandObjectTypeFilterAdd::CommandOptions::g_option_table[] = { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } }; +//---------------------------------------------------------------------- +// "type lookup" +//---------------------------------------------------------------------- +class CommandObjectTypeLookup : public CommandObjectRaw +{ +protected: + + class CommandOptions : public OptionGroup + { + public: + + CommandOptions () : + OptionGroup(), + m_show_help(false), + m_language(eLanguageTypeUnknown) + {} + + ~CommandOptions () override {} + + uint32_t + GetNumDefinitions () override + { + return 3; + } + + const OptionDefinition* + GetDefinitions () override + { + return g_option_table; + } + + Error + SetOptionValue (CommandInterpreter &interpreter, + uint32_t option_idx, + const char *option_value) override + { + Error error; + + const int short_option = g_option_table[option_idx].short_option; + + switch (short_option) + { + case 'h': + m_show_help = true; + break; + + case 'l': + m_language = Language::GetLanguageTypeFromString(option_value); + break; + + default: + error.SetErrorStringWithFormat("invalid short option character '%c'", short_option); + break; + } + + return error; + } + + void + OptionParsingStarting (CommandInterpreter &interpreter) override + { + m_show_help = false; + m_language = eLanguageTypeUnknown; + } + + // Options table: Required for subclasses of Options. + + static OptionDefinition g_option_table[]; + bool m_show_help; + lldb::LanguageType m_language; + }; + + OptionGroupOptions m_option_group; + CommandOptions m_command_options; + +public: + + CommandObjectTypeLookup (CommandInterpreter &interpreter) : + CommandObjectRaw (interpreter, + "type lookup", + "Lookup a type by name in the select target.", + "type lookup <typename>", + eCommandRequiresTarget), + m_option_group(interpreter), + m_command_options() + { + m_option_group.Append(&m_command_options); + m_option_group.Finalize(); + } + + ~CommandObjectTypeLookup () override + { + } + + Options * + GetOptions () override + { + return &m_option_group; + } + + bool + DoExecute (const char *raw_command_line, CommandReturnObject &result) override + { + if (!raw_command_line || !raw_command_line[0]) + { + result.SetError("type lookup cannot be invoked without a type name as argument"); + return false; + } + + m_option_group.NotifyOptionParsingStarting(); + + const char * name_of_type = NULL; + + if (raw_command_line[0] == '-') + { + // We have some options and these options MUST end with --. + const char *end_options = NULL; + const char *s = raw_command_line; + while (s && s[0]) + { + end_options = ::strstr (s, "--"); + if (end_options) + { + end_options += 2; // Get past the "--" + if (::isspace (end_options[0])) + { + name_of_type = end_options; + while (::isspace (*name_of_type)) + ++name_of_type; + break; + } + } + s = end_options; + } + + if (end_options) + { + Args args (llvm::StringRef(raw_command_line, end_options - raw_command_line)); + if (!ParseOptions (args, result)) + return false; + + Error error (m_option_group.NotifyOptionParsingFinished()); + if (error.Fail()) + { + result.AppendError (error.AsCString()); + result.SetStatus (eReturnStatusFailed); + return false; + } + } + } + if (nullptr == name_of_type) + name_of_type = raw_command_line; + + TargetSP target_sp(GetCommandInterpreter().GetDebugger().GetSelectedTarget()); + const bool fill_all_in = true; + ExecutionContext exe_ctx(target_sp.get(), fill_all_in); + ExecutionContextScope *best_scope = exe_ctx.GetBestExecutionContextScope(); + + bool any_found = false; + + std::vector<Language*> languages; + + if (m_command_options.m_language == eLanguageTypeUnknown) + { + // FIXME: hardcoding languages is not good + languages.push_back(Language::FindPlugin(eLanguageTypeObjC)); + languages.push_back(Language::FindPlugin(eLanguageTypeC_plus_plus)); + } + else + { + languages.push_back(Language::FindPlugin(m_command_options.m_language)); + } + + for (Language* language : languages) + { + if (!language) + continue; + + if (auto scavenger = language->GetTypeScavenger()) + { + Language::TypeScavenger::ResultSet search_results; + if (scavenger->Find(best_scope, name_of_type, search_results) > 0) + { + for (const auto& search_result : search_results) + { + if (search_result && search_result->IsValid()) + { + any_found = true; + search_result->DumpToStream(result.GetOutputStream(), this->m_command_options.m_show_help); + } + } + } + } + } + + result.SetStatus (any_found ? lldb::eReturnStatusSuccessFinishResult : lldb::eReturnStatusSuccessFinishNoResult); + return true; + } + +}; + +OptionDefinition +CommandObjectTypeLookup::CommandOptions::g_option_table[] = +{ + { LLDB_OPT_SET_ALL, false, "show-help", 'h', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Display available help for types"}, + { LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage, "Which language's types should the search scope be"}, + { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } +}; + template <typename FormatterType> class CommandObjectFormatterInfo : public CommandObjectRaw { @@ -4293,14 +3523,13 @@ public: SetSyntax(syntax.GetData()); } - virtual - ~CommandObjectFormatterInfo () + ~CommandObjectFormatterInfo () override { } protected: - virtual bool - DoExecute (const char *command, CommandReturnObject &result) + bool + DoExecute (const char *command, CommandReturnObject &result) override { auto target_sp = m_interpreter.GetDebugger().GetSelectedTarget(); auto frame_sp = target_sp->GetProcessSP()->GetThreadList().GetSelectedThread()->GetSelectedFrame(); @@ -4365,7 +3594,7 @@ public: } - ~CommandObjectTypeFormat () + ~CommandObjectTypeFormat () override { } }; @@ -4393,7 +3622,7 @@ public: } - ~CommandObjectTypeSynth () + ~CommandObjectTypeSynth () override { } }; @@ -4416,7 +3645,7 @@ public: } - ~CommandObjectTypeFilter () + ~CommandObjectTypeFilter () override { } }; @@ -4430,6 +3659,7 @@ public: "A set of commands for operating on categories", "type category [<sub-command-options>] ") { + LoadSubCommand ("define", CommandObjectSP (new CommandObjectTypeCategoryDefine (interpreter))); LoadSubCommand ("enable", CommandObjectSP (new CommandObjectTypeCategoryEnable (interpreter))); LoadSubCommand ("disable", CommandObjectSP (new CommandObjectTypeCategoryDisable (interpreter))); LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeCategoryDelete (interpreter))); @@ -4437,7 +3667,7 @@ public: } - ~CommandObjectTypeCategory () + ~CommandObjectTypeCategory () override { } }; @@ -4463,7 +3693,7 @@ public: } - ~CommandObjectTypeSummary () + ~CommandObjectTypeSummary () override { } }; @@ -4485,11 +3715,10 @@ CommandObjectType::CommandObjectType (CommandInterpreter &interpreter) : #ifndef LLDB_DISABLE_PYTHON LoadSubCommand ("synthetic", CommandObjectSP (new CommandObjectTypeSynth (interpreter))); #endif + LoadSubCommand ("lookup", CommandObjectSP (new CommandObjectTypeLookup (interpreter))); } CommandObjectType::~CommandObjectType () { } - - |
