Google Git
Sign in
llvm / lldb / release_39 / . / source / Commands / CommandObjectType.cpp
blob: 6f1199de69ded2563910fa9f38b7a78433300b12 [file] [log] [blame]
//===-- CommandObjectType.cpp -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "CommandObjectType.h"
// C Includes
// C++ Includes
#include <algorithm>
#include <cctype>
#include <functional>
// Other libraries and framework includes
#include "llvm/ADT/StringRef.h"
// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/IOHandler.h"
#include "lldb/Core/RegularExpression.h"
#include "lldb/Core/State.h"
#include "lldb/Core/StringList.h"
#include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObject.h"
#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/Symbol/Symbol.h"
#include "lldb/Target/Language.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadList.h"
using namespace lldb;
using namespace lldb_private;
class ScriptAddOptions
{
public:
TypeSummaryImpl::Flags m_flags;
StringList m_target_types;
bool m_regex;
ConstString m_name;
std::string m_category;
ScriptAddOptions(const TypeSummaryImpl::Flags& flags,
bool regx,
const ConstString& name,
std::string catg) :
m_flags(flags),
m_regex(regx),
m_name(name),
m_category(catg)
{
}
typedef std::shared_ptr<ScriptAddOptions> SharedPointer;
};
class SynthAddOptions
{
public:
bool m_skip_pointers;
bool m_skip_references;
bool m_cascade;
bool m_regex;
StringList m_target_types;
std::string m_category;
SynthAddOptions(bool sptr,
bool sref,
bool casc,
bool regx,
std::string catg) :
m_skip_pointers(sptr),
m_skip_references(sref),
m_cascade(casc),
m_regex(regx),
m_target_types(),
m_category(catg)
{
}
typedef std::shared_ptr<SynthAddOptions> SharedPointer;
};
static bool
WarnOnPotentialUnquotedUnsignedType (Args& command, CommandReturnObject &result)
{
for (unsigned idx = 0; idx < command.GetArgumentCount(); idx++)
{
const char* arg = command.GetArgumentAtIndex(idx);
if (idx+1 < command.GetArgumentCount())
{
if (arg && 0 == strcmp(arg,"unsigned"))
{
const char* next = command.GetArgumentAtIndex(idx+1);
if (next &&
(0 == strcmp(next, "int") ||
0 == strcmp(next, "short") ||
0 == strcmp(next, "char") ||
0 == strcmp(next, "long")))
{
result.AppendWarningWithFormat("%s %s being treated as two types. if you meant the combined type name use quotes, as in \"%s %s\"\n",
arg,next,arg,next);
return true;
}
}
}
}
return false;
}
class CommandObjectTypeSummaryAdd :
public CommandObjectParsed,
public IOHandlerDelegateMultiline
{
private:
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter)
{
}
~CommandOptions() override = default;
Error
SetOptionValue (uint32_t option_idx, const char *option_arg) override;
void
OptionParsingStarting () override;
const OptionDefinition*
GetDefinitions () override
{
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.
TypeSummaryImpl::Flags m_flags;
bool m_regex;
std::string m_format_string;
ConstString m_name;
std::string m_python_script;
std::string m_python_function;
bool m_is_add_script;
std::string m_category;
};
CommandOptions m_options;
Options *
GetOptions () override
{
return &m_options;
}
bool
Execute_ScriptSummary (Args& command, CommandReturnObject &result);
bool
Execute_StringSummary (Args& command, CommandReturnObject &result);
public:
enum SummaryFormatType
{
eRegularSummary,
eRegexSummary,
eNamedSummary
};
CommandObjectTypeSummaryAdd (CommandInterpreter &interpreter);
~CommandObjectTypeSummaryAdd() override = default;
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"
" \"\"\"valobj: an SBValue which you want to provide a summary for\n"
" internal_dict: an LLDB support object not to be used\"\"\"\n";
StreamFileSP output_sp(io_handler.GetOutputStreamFile());
if (output_sp)
{
output_sp->PutCString(g_summary_addreader_instructions);
output_sp->Flush();
}
}
void
IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override
{
StreamFileSP error_sp = io_handler.GetErrorStreamFile();
#ifndef LLDB_DISABLE_PYTHON
ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
if (interpreter)
{
StringList lines;
lines.SplitIntoLines(data);
if (lines.GetSize() > 0)
{
ScriptAddOptions *options_ptr = ((ScriptAddOptions*)io_handler.GetUserData());
if (options_ptr)
{
ScriptAddOptions::SharedPointer options(options_ptr); // this will ensure that we get rid of the pointer when going out of scope
ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
if (interpreter)
{
std::string funct_name_str;
if (interpreter->GenerateTypeScriptFunction (lines, funct_name_str))
{
if (funct_name_str.empty())
{
error_sp->Printf ("unable to obtain a valid function name from the script interpreter.\n");
error_sp->Flush();
}
else
{
// now I have a valid function name, let's add this as script for every type in the list
TypeSummaryImplSP script_format;
script_format.reset(new ScriptSummaryFormat(options->m_flags,
funct_name_str.c_str(),
lines.CopyList(" ").c_str()));
Error error;
for (size_t i = 0; i < options->m_target_types.GetSize(); i++)
{
const char *type_name = options->m_target_types.GetStringAtIndex(i);
CommandObjectTypeSummaryAdd::AddSummary(ConstString(type_name),
script_format,
(options->m_regex ? CommandObjectTypeSummaryAdd::eRegexSummary : CommandObjectTypeSummaryAdd::eRegularSummary),
options->m_category,
&error);
if (error.Fail())
{
error_sp->Printf ("error: %s", error.AsCString());
error_sp->Flush();
}
}
if (options->m_name)
{
CommandObjectTypeSummaryAdd::AddSummary (options->m_name,
script_format,
CommandObjectTypeSummaryAdd::eNamedSummary,
options->m_category,
&error);
if (error.Fail())
{
CommandObjectTypeSummaryAdd::AddSummary (options->m_name,
script_format,
CommandObjectTypeSummaryAdd::eNamedSummary,
options->m_category,
&error);
if (error.Fail())
{
error_sp->Printf ("error: %s", error.AsCString());
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: %s", error.AsCString());
error_sp->Flush();
}
}
else
{
if (error.AsCString())
{
error_sp->Printf ("error: %s", error.AsCString());
error_sp->Flush();
}
}
}
}
else
{
error_sp->Printf ("error: unable to generate a function.\n");
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: no script interpreter.\n");
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: internal synchronization information missing or invalid.\n");
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: empty function, didn't add python command.\n");
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: script interpreter missing, didn't add python command.\n");
error_sp->Flush();
}
#endif // LLDB_DISABLE_PYTHON
io_handler.SetIsDone(true);
}
static bool
AddSummary(ConstString type_name,
lldb::TypeSummaryImplSP entry,
SummaryFormatType type,
std::string category,
Error* error = nullptr);
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override;
};
static const char *g_synth_addreader_instructions = "Enter your Python command(s). Type 'DONE' to end.\n"
"You must define a Python class with these methods:\n"
" def __init__(self, valobj, dict):\n"
" def num_children(self):\n"
" def get_child_at_index(self, index):\n"
" def get_child_index(self, name):\n"
" def update(self):\n"
" '''Optional'''\n"
"class synthProvider:\n";
class CommandObjectTypeSynthAdd :
public CommandObjectParsed,
public IOHandlerDelegateMultiline
{
private:
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter)
{
}
~CommandOptions() override = default;
Error
SetOptionValue (uint32_t option_idx, const char *option_arg) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
bool success;
switch (short_option)
{
case 'C':
m_cascade = Args::StringToBoolean(option_arg, true, &success);
if (!success)
error.SetErrorStringWithFormat("invalid value for cascade: %s", option_arg);
break;
case 'P':
handwrite_python = true;
break;
case 'l':
m_class_name = std::string(option_arg);
is_class_based = true;
break;
case 'p':
m_skip_pointers = true;
break;
case 'r':
m_skip_references = true;
break;
case 'w':
m_category = std::string(option_arg);
break;
case 'x':
m_regex = true;
break;
default:
error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
break;
}
return error;
}
void
OptionParsingStarting () override
{
m_cascade = true;
m_class_name = "";
m_skip_pointers = false;
m_skip_references = false;
m_category = "default";
is_class_based = false;
handwrite_python = false;
m_regex = false;
}
const OptionDefinition*
GetDefinitions () override
{
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_cascade;
bool m_skip_references;
bool m_skip_pointers;
std::string m_class_name;
bool m_input_python;
std::string m_category;
bool is_class_based;
bool handwrite_python;
bool m_regex;
};
CommandOptions m_options;
Options *
GetOptions () override
{
return &m_options;
}
bool
Execute_HandwritePython (Args& command, CommandReturnObject &result);
bool
Execute_PythonClass (Args& command, CommandReturnObject &result);
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
WarnOnPotentialUnquotedUnsignedType(command, result);
if (m_options.handwrite_python)
return Execute_HandwritePython(command, result);
else if (m_options.is_class_based)
return Execute_PythonClass(command, result);
else
{
result.AppendError("must either provide a children list, a Python class name, or use -P and type a Python class line-by-line");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
void
IOHandlerActivated (IOHandler &io_handler) override
{
StreamFileSP output_sp(io_handler.GetOutputStreamFile());
if (output_sp)
{
output_sp->PutCString(g_synth_addreader_instructions);
output_sp->Flush();
}
}
void
IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override
{
StreamFileSP error_sp = io_handler.GetErrorStreamFile();
#ifndef LLDB_DISABLE_PYTHON
ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
if (interpreter)
{
StringList lines;
lines.SplitIntoLines(data);
if (lines.GetSize() > 0)
{
SynthAddOptions *options_ptr = ((SynthAddOptions*)io_handler.GetUserData());
if (options_ptr)
{
SynthAddOptions::SharedPointer options(options_ptr); // this will ensure that we get rid of the pointer when going out of scope
ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
if (interpreter)
{
std::string class_name_str;
if (interpreter->GenerateTypeSynthClass (lines, class_name_str))
{
if (class_name_str.empty())
{
error_sp->Printf ("error: unable to obtain a proper name for the class.\n");
error_sp->Flush();
}
else
{
// everything should be fine now, let's add the synth provider class
SyntheticChildrenSP synth_provider;
synth_provider.reset(new ScriptedSyntheticChildren(SyntheticChildren::Flags().SetCascades(options->m_cascade).
SetSkipPointers(options->m_skip_pointers).
SetSkipReferences(options->m_skip_references),
class_name_str.c_str()));
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(options->m_category.c_str()), category);
Error error;
for (size_t i = 0; i < options->m_target_types.GetSize(); i++)
{
const char *type_name = options->m_target_types.GetStringAtIndex(i);
ConstString const_type_name(type_name);
if (const_type_name)
{
if (!CommandObjectTypeSynthAdd::AddSynth(const_type_name,
synth_provider,
options->m_regex ? CommandObjectTypeSynthAdd::eRegexSynth : CommandObjectTypeSynthAdd::eRegularSynth,
options->m_category,
&error))
{
error_sp->Printf("error: %s\n", error.AsCString());
error_sp->Flush();
break;
}
}
else
{
error_sp->Printf ("error: invalid type name.\n");
error_sp->Flush();
break;
}
}
}
}
else
{
error_sp->Printf ("error: unable to generate a class.\n");
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: no script interpreter.\n");
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: internal synchronization data missing.\n");
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: empty function, didn't add python command.\n");
error_sp->Flush();
}
}
else
{
error_sp->Printf ("error: script interpreter missing, didn't add python command.\n");
error_sp->Flush();
}
#endif // LLDB_DISABLE_PYTHON
io_handler.SetIsDone(true);
}
public:
enum SynthFormatType
{
eRegularSynth,
eRegexSynth
};
CommandObjectTypeSynthAdd (CommandInterpreter &interpreter);
~CommandObjectTypeSynthAdd() override = default;
static bool
AddSynth(ConstString type_name,
lldb::SyntheticChildrenSP entry,
SynthFormatType type,
std::string category_name,
Error* error);
};
//-------------------------------------------------------------------------
// CommandObjectTypeFormatAdd
//-------------------------------------------------------------------------
class CommandObjectTypeFormatAdd : public CommandObjectParsed
{
private:
class CommandOptions : public OptionGroup
{
public:
CommandOptions () :
OptionGroup()
{
}
~CommandOptions() override = default;
uint32_t
GetNumDefinitions () override;
const OptionDefinition*
GetDefinitions () override
{
return g_option_table;
}
void
OptionParsingStarting (CommandInterpreter &interpreter) override
{
m_cascade = true;
m_skip_pointers = false;
m_skip_references = false;
m_regex = false;
m_category.assign("default");
m_custom_type_name.clear();
}
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;
bool success;
switch (short_option)
{
case 'C':
m_cascade = Args::StringToBoolean(option_value, true, &success);
if (!success)
error.SetErrorStringWithFormat("invalid value for cascade: %s", option_value);
break;
case 'p':
m_skip_pointers = true;
break;
case 'w':
m_category.assign(option_value);
break;
case 'r':
m_skip_references = true;
break;
case 'x':
m_regex = true;
break;
case 't':
m_custom_type_name.assign(option_value);
break;
default:
error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
break;
}
return error;
}
// Options table: Required for subclasses of Options.
static OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
bool m_cascade;
bool m_skip_references;
bool m_skip_pointers;
bool m_regex;
std::string m_category;
std::string m_custom_type_name;
};
OptionGroupOptions m_option_group;
OptionGroupFormat m_format_options;
CommandOptions m_command_options;
Options *
GetOptions () override
{
return &m_option_group;
}
public:
CommandObjectTypeFormatAdd (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type format add",
"Add a new formatting style for a type.",
nullptr),
m_option_group (interpreter),
m_format_options (eFormatInvalid),
m_command_options ()
{
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);
SetHelpLong(
R"(
The following examples of 'type format add' refer to this code snippet for context:
typedef int Aint;
typedef float Afloat;
typedef Aint Bint;
typedef Afloat Bfloat;
Aint ix = 5;
Bint iy = 5;
Afloat fx = 3.14;
BFloat fy = 3.14;
Adding default formatting:
(lldb) type format add -f hex AInt
(lldb) frame variable iy
)" " Produces hexidecimal display of iy, because no formatter is available for Bint and \
the one for Aint is used instead." R"(
To prevent this use the cascade option '-C no' to prevent evaluation of typedef chains:
(lldb) type format add -f hex -C no AInt
Similar reasoning applies to this:
(lldb) type format add -f hex -C no float -p
)" " All float values and float references are now formatted as hexadecimal, but not \
pointers to floats. Nor will it change the default display for Afloat and Bfloat objects."
);
// Add the "--format" to all options groups
m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT, LLDB_OPT_SET_1);
m_option_group.Append (&m_command_options);
m_option_group.Finalize();
}
~CommandObjectTypeFormatAdd() override = default;
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
const size_t argc = command.GetArgumentCount();
if (argc < 1)
{
result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
const Format format = m_format_options.GetFormat();
if (format == eFormatInvalid && m_command_options.m_custom_type_name.empty())
{
result.AppendErrorWithFormat ("%s needs a valid format.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
TypeFormatImplSP entry;
if (m_command_options.m_custom_type_name.empty())
entry.reset(new TypeFormatImpl_Format(format,
TypeFormatImpl::Flags().SetCascades(m_command_options.m_cascade).
SetSkipPointers(m_command_options.m_skip_pointers).
SetSkipReferences(m_command_options.m_skip_references)));
else
entry.reset(new TypeFormatImpl_EnumType(ConstString(m_command_options.m_custom_type_name.c_str()),
TypeFormatImpl::Flags().SetCascades(m_command_options.m_cascade).
SetSkipPointers(m_command_options.m_skip_pointers).
SetSkipReferences(m_command_options.m_skip_references)));
// now I have a valid format, let's add it to every type
TypeCategoryImplSP category_sp;
DataVisualization::Categories::GetCategory(ConstString(m_command_options.m_category), category_sp);
if (!category_sp)
return false;
WarnOnPotentialUnquotedUnsignedType(command, result);
for (size_t i = 0; i < argc; i++)
{
const char* typeA = command.GetArgumentAtIndex(i);
ConstString typeCS(typeA);
if (typeCS)
{
if (m_command_options.m_regex)
{
RegularExpressionSP typeRX(new RegularExpression());
if (!typeRX->Compile(typeCS.GetCString()))
{
result.AppendError("regex format error (maybe this is not really a regex?)");
result.SetStatus(eReturnStatusFailed);
return false;
}
category_sp->GetRegexTypeSummariesContainer()->Delete(typeCS);
category_sp->GetRegexTypeFormatsContainer()->Add(typeRX, entry);
}
else
category_sp->GetTypeFormatsContainer()->Add(typeCS, entry);
}
else
{
result.AppendError("empty typenames not allowed");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
}
};
OptionDefinition
CommandObjectTypeFormatAdd::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName, "Add this to the given category instead of the default one."},
{ LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, cascade through typedef chains."},
{ LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."},
{ LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't use this format for references-to-type objects."},
{ LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Type names are actually regular expressions."},
{ LLDB_OPT_SET_2, false, "type", 't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName, "Format variables as if they were of this type."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
uint32_t
CommandObjectTypeFormatAdd::CommandOptions::GetNumDefinitions ()
{
return sizeof(g_option_table) / sizeof (OptionDefinition);
}
class CommandObjectTypeFormatterDelete : public CommandObjectParsed
{
protected:
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter)
{
}
~CommandOptions() override = default;
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;
break;
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;
}
return error;
}
void
OptionParsingStarting () override
{
m_delete_all = false;
m_category = "default";
m_language = lldb::eLanguageTypeUnknown;
}
const OptionDefinition*
GetDefinitions () override
{
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;
lldb::LanguageType m_language;
};
CommandOptions m_options;
uint32_t m_formatter_kind_mask;
Options *
GetOptions () override
{
return &m_options;
}
public:
CommandObjectTypeFormatterDelete (CommandInterpreter &interpreter,
uint32_t formatter_kind_mask,
const char* name,
const char* help) :
CommandObjectParsed(interpreter,
name,
help,
nullptr),
m_options(interpreter),
m_formatter_kind_mask(formatter_kind_mask)
{
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);
}
~CommandObjectTypeFormatterDelete() override = default;
protected:
virtual bool
FormatterSpecificDeletion (ConstString typeCS)
{
return false;
}
bool
DoExecute (Args& command, 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::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();
}
bool delete_category = false;
bool extra_deletion = false;
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 || extra_deletion)
{
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
}
else
{
result.AppendErrorWithFormat ("no custom formatter for %s.\n", typeA);
result.SetStatus(eReturnStatusFailed);
return false;
}
}
};
OptionDefinition
CommandObjectTypeFormatterDelete::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "all", 'a', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Delete from every category."},
{ LLDB_OPT_SET_2, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName, "Delete from given category."},
{ LLDB_OPT_SET_3, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Delete from given language's category."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
class CommandObjectTypeFormatterClear : public CommandObjectParsed
{
private:
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter)
{
}
~CommandOptions() override = default;
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;
break;
default:
error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
break;
}
return error;
}
void
OptionParsingStarting () override
{
m_delete_all = false;
}
const OptionDefinition*
GetDefinitions () override
{
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;
};
CommandOptions m_options;
uint32_t m_formatter_kind_mask;
Options *
GetOptions () override
{
return &m_options;
}
public:
CommandObjectTypeFormatterClear (CommandInterpreter &interpreter,
uint32_t formatter_kind_mask,
const char* name,
const char* help) :
CommandObjectParsed(interpreter,
name,
help,
nullptr),
m_options(interpreter),
m_formatter_kind_mask(formatter_kind_mask)
{
}
~CommandObjectTypeFormatterClear() override = default;
protected:
virtual void
FormatterSpecificDeletion ()
{
}
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
if (m_options.m_delete_all)
{
DataVisualization::Categories::ForEach( [this] (const TypeCategoryImplSP& category_sp) -> bool {
category_sp->Clear(m_formatter_kind_mask);
return true;
});
}
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(nullptr), category);
}
category->Clear(m_formatter_kind_mask);
}
FormatterSpecificDeletion();
result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded();
}
};
OptionDefinition
CommandObjectTypeFormatterClear::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "all", 'a', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Clear every category."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
//-------------------------------------------------------------------------
// CommandObjectTypeFormatDelete
//-------------------------------------------------------------------------
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 = default;
};
//-------------------------------------------------------------------------
// CommandObjectTypeFormatClear
//-------------------------------------------------------------------------
class CommandObjectTypeFormatClear : public CommandObjectTypeFormatterClear
{
public:
CommandObjectTypeFormatClear (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterClear (interpreter,
eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
"type format clear",
"Delete all existing format styles.")
{
}
};
template <typename FormatterType>
class CommandObjectTypeFormatterList : public CommandObjectParsed
{
typedef typename FormatterType::SharedPointer FormatterSharedPointer;
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter),
m_category_regex("",""),
m_category_language(lldb::eLanguageTypeUnknown, lldb::eLanguageTypeUnknown)
{
}
~CommandOptions() override = default;
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.SetCurrentValue(option_arg);
m_category_regex.SetOptionWasSet();
break;
case 'l':
error = m_category_language.SetValueFromString(option_arg);
if (error.Success())
m_category_language.SetOptionWasSet();
break;
default:
error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
break;
}
return error;
}
void
OptionParsingStarting () override
{
m_category_regex.Clear();
m_category_language.Clear();
}
const OptionDefinition*
GetDefinitions () override
{
static OptionDefinition g_option_table[] =
{
{ LLDB_OPT_SET_1, false, "category-regex", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName, "Only show categories matching this filter."},
{ LLDB_OPT_SET_2, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Only show the category for a specific language."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
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.
OptionValueString m_category_regex;
OptionValueLanguage m_category_language;
};
CommandOptions m_options;
Options *
GetOptions () override
{
return &m_options;
}
public:
CommandObjectTypeFormatterList (CommandInterpreter &interpreter,
const char* name,
const char* help) :
CommandObjectParsed(interpreter,
name,
help,
nullptr),
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);
}
~CommandObjectTypeFormatterList() override = default;
protected:
virtual bool
FormatterSpecificList (CommandReturnObject &result)
{
return false;
}
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
const size_t argc = command.GetArgumentCount();
std::unique_ptr<RegularExpression> category_regex;
std::unique_ptr<RegularExpression> formatter_regex;
if (m_options.m_category_regex.OptionWasSet())
{
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;
}
}
if (argc == 1)
{
const char* arg = command.GetArgumentAtIndex(0);
formatter_regex.reset(new RegularExpression());
if (!formatter_regex->Compile(arg))
{
result.AppendErrorWithFormat("syntax error in regular expression '%s'", arg);
result.SetStatus(eReturnStatusFailed);
return false;
}
}
bool any_printed = false;
auto category_closure = [&result, &formatter_regex, &any_printed] (const lldb::TypeCategoryImplSP& category) -> void {
result.GetOutputStream().Printf("-----------------------\nCategory: %s%s\n-----------------------\n",
category->GetName(),
category->IsEnabled() ? "" : " (disabled)");
TypeCategoryImpl::ForEachCallbacks<FormatterType> foreach;
foreach.SetExact([&result, &formatter_regex, &any_printed] (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;
}
any_printed = true;
result.GetOutputStream().Printf ("%s: %s\n", name.AsCString(), format_sp->GetDescription().c_str());
return true;
});
foreach.SetWithRegex([&result, &formatter_regex, &any_printed] (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;
}
any_printed = true;
result.GetOutputStream().Printf ("%s: %s\n", regex_sp->GetText(), format_sp->GetDescription().c_str());
return true;
});
category->ForEach(foreach);
};
if (m_options.m_category_language.OptionWasSet())
{
lldb::TypeCategoryImplSP category_sp;
DataVisualization::Categories::GetCategory(m_options.m_category_language.GetCurrentValue(), category_sp);
if (category_sp)
category_closure(category_sp);
}
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;
});
any_printed = FormatterSpecificList(result) | any_printed;
}
if (any_printed)
result.SetStatus(eReturnStatusSuccessFinishResult);
else
{
result.GetOutputStream().PutCString("no matching results found.\n");
result.SetStatus(eReturnStatusSuccessFinishNoResult);
}
return result.Succeeded();
}
};
//-------------------------------------------------------------------------
// CommandObjectTypeFormatList
//-------------------------------------------------------------------------
class CommandObjectTypeFormatList : public CommandObjectTypeFormatterList<TypeFormatImpl>
{
public:
CommandObjectTypeFormatList (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterList(interpreter,
"type format list",
"Show a list of current formats.")
{
}
};
#ifndef LLDB_DISABLE_PYTHON
//-------------------------------------------------------------------------
// CommandObjectTypeSummaryAdd
//-------------------------------------------------------------------------
#endif // LLDB_DISABLE_PYTHON
Error
CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
bool success;
switch (short_option)
{
case 'C':
m_flags.SetCascades(Args::StringToBoolean(option_arg, true, &success));
if (!success)
error.SetErrorStringWithFormat("invalid value for cascade: %s", option_arg);
break;
case 'e':
m_flags.SetDontShowChildren(false);
break;
case 'h':
m_flags.SetHideEmptyAggregates(true);
break;
case 'v':
m_flags.SetDontShowValue(true);
break;
case 'c':
m_flags.SetShowMembersOneLiner(true);
break;
case 's':
m_format_string = std::string(option_arg);
break;
case 'p':
m_flags.SetSkipPointers(true);
break;
case 'r':
m_flags.SetSkipReferences(true);
break;
case 'x':
m_regex = true;
break;
case 'n':
m_name.SetCString(option_arg);
break;
case 'o':
m_python_script = std::string(option_arg);
m_is_add_script = true;
break;
case 'F':
m_python_function = std::string(option_arg);
m_is_add_script = true;
break;
case 'P':
m_is_add_script = true;
break;
case 'w':
m_category = std::string(option_arg);
break;
case 'O':
m_flags.SetHideItemNames(true);
break;
default:
error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
break;
}
return error;
}
void
CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting ()
{
m_flags.Clear().SetCascades().SetDontShowChildren().SetDontShowValue(false);
m_flags.SetShowMembersOneLiner(false).SetSkipPointers(false).SetSkipReferences(false).SetHideItemNames(false);
m_regex = false;
m_name.Clear();
m_python_script = "";
m_python_function = "";
m_format_string = "";
m_is_add_script = false;
m_category = "default";
}
#ifndef LLDB_DISABLE_PYTHON
bool
CommandObjectTypeSummaryAdd::Execute_ScriptSummary (Args& command, CommandReturnObject &result)
{
const size_t argc = command.GetArgumentCount();
if (argc < 1 && !m_options.m_name)
{
result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
TypeSummaryImplSP script_format;
if (!m_options.m_python_function.empty()) // we have a Python function ready to use
{
const char *funct_name = m_options.m_python_function.c_str();
if (!funct_name || !funct_name[0])
{
result.AppendError ("function name empty.\n");
result.SetStatus (eReturnStatusFailed);
return false;
}
std::string code = (" " + m_options.m_python_function + "(valobj,internal_dict)");
script_format.reset(new ScriptSummaryFormat(m_options.m_flags,
funct_name,
code.c_str()));
ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
if (interpreter && !interpreter->CheckObjectExists(funct_name))
result.AppendWarningWithFormat("The provided function \"%s\" does not exist - "
"please define it before attempting to use this summary.\n",
funct_name);
}
else if (!m_options.m_python_script.empty()) // we have a quick 1-line script, just use it
{
ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
if (!interpreter)
{
result.AppendError ("script interpreter missing - unable to generate function wrapper.\n");
result.SetStatus (eReturnStatusFailed);
return false;
}
StringList funct_sl;
funct_sl << m_options.m_python_script.c_str();
std::string funct_name_str;
if (!interpreter->GenerateTypeScriptFunction (funct_sl,
funct_name_str))
{
result.AppendError ("unable to generate function wrapper.\n");
result.SetStatus (eReturnStatusFailed);
return false;
}
if (funct_name_str.empty())
{
result.AppendError ("script interpreter failed to generate a valid function name.\n");
result.SetStatus (eReturnStatusFailed);
return false;
}
std::string code = " " + m_options.m_python_script;
script_format.reset(new ScriptSummaryFormat(m_options.m_flags,
funct_name_str.c_str(),
code.c_str()));
}
else
{
// Use an IOHandler to grab Python code from the user
ScriptAddOptions *options = new ScriptAddOptions(m_options.m_flags,
m_options.m_regex,
m_options.m_name,
m_options.m_category);
for (size_t i = 0; i < argc; i++)
{
const char* typeA = command.GetArgumentAtIndex(i);
if (typeA && *typeA)
options->m_target_types << typeA;
else
{
result.AppendError("empty typenames not allowed");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
m_interpreter.GetPythonCommandsFromIOHandler (" ", // Prompt
*this, // IOHandlerDelegate
true, // Run IOHandler in async mode
options); // Baton for the "io_handler" that will be passed back into our IOHandlerDelegate functions
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
}
// if I am here, script_format must point to something good, so I can add that
// as a script summary to all interested parties
Error error;
for (size_t i = 0; i < command.GetArgumentCount(); i++)
{
const char *type_name = command.GetArgumentAtIndex(i);
CommandObjectTypeSummaryAdd::AddSummary(ConstString(type_name),
script_format,
(m_options.m_regex ? eRegexSummary : eRegularSummary),
m_options.m_category,
&error);
if (error.Fail())
{
result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed);
return false;
}
}
if (m_options.m_name)
{
AddSummary(m_options.m_name, script_format, eNamedSummary, m_options.m_category, &error);
if (error.Fail())
{
result.AppendError(error.AsCString());
result.AppendError("added to types, but not given a name");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
return result.Succeeded();
}
#endif // LLDB_DISABLE_PYTHON
bool
CommandObjectTypeSummaryAdd::Execute_StringSummary (Args& command, CommandReturnObject &result)
{
const size_t argc = command.GetArgumentCount();
if (argc < 1 && !m_options.m_name)
{
result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
if (!m_options.m_flags.GetShowMembersOneLiner() && m_options.m_format_string.empty())
{
result.AppendError("empty summary strings not allowed");
result.SetStatus(eReturnStatusFailed);
return false;
}
const char* format_cstr = (m_options.m_flags.GetShowMembersOneLiner() ? "" : m_options.m_format_string.c_str());
// ${var%S} is an endless recursion, prevent it
if (strcmp(format_cstr, "${var%S}") == 0)
{
result.AppendError("recursive summary not allowed");
result.SetStatus(eReturnStatusFailed);
return false;
}
std::unique_ptr<StringSummaryFormat> string_format(new StringSummaryFormat(m_options.m_flags, format_cstr));
if (!string_format)
{
result.AppendError("summary creation failed");
result.SetStatus(eReturnStatusFailed);
return false;
}
if (string_format->m_error.Fail())
{
result.AppendErrorWithFormat("syntax error: %s", string_format->m_error.AsCString("<unknown>"));
result.SetStatus(eReturnStatusFailed);
return false;
}
lldb::TypeSummaryImplSP entry(string_format.release());
// now I have a valid format, let's add it to every type
Error error;
for (size_t i = 0; i < argc; i++)
{
const char* typeA = command.GetArgumentAtIndex(i);
if (!typeA || typeA[0] == '\0')
{
result.AppendError("empty typenames not allowed");
result.SetStatus(eReturnStatusFailed);
return false;
}
ConstString typeCS(typeA);
AddSummary(typeCS,
entry,
(m_options.m_regex ? eRegexSummary : eRegularSummary),
m_options.m_category,
&error);
if (error.Fail())
{
result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed);
return false;
}
}
if (m_options.m_name)
{
AddSummary(m_options.m_name, entry, eNamedSummary, m_options.m_category, &error);
if (error.Fail())
{
result.AppendError(error.AsCString());
result.AppendError("added to types, but not given a name");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
}
CommandObjectTypeSummaryAdd::CommandObjectTypeSummaryAdd (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type summary add",
"Add a new summary style for a type.",
nullptr),
IOHandlerDelegateMultiline ("DONE"),
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);
SetHelpLong(
R"(
The following examples of 'type summary add' refer to this code snippet for context:
struct JustADemo
{
int* ptr;
float value;
JustADemo(int p = 1, float v = 0.1) : ptr(new int(p)), value(v) {}
};
JustADemo demo_instance(42, 3.14);
typedef JustADemo NewDemo;
NewDemo new_demo_instance(42, 3.14);
(lldb) type summary add --summary-string "the answer is ${*var.ptr}" JustADemo
Subsequently displaying demo_instance with 'frame variable' or 'expression' will display "the answer is 42"
(lldb) type summary add --summary-string "the answer is ${*var.ptr}, and the question is ${var.value}" JustADemo
Subsequently displaying demo_instance with 'frame variable' or 'expression' will display "the answer is 42 and the question is 3.14"
)" "Alternatively, you could define formatting for all pointers to integers and \
rely on that when formatting JustADemo to obtain the same result:" R"(
(lldb) type summary add --summary-string "${var%V} -> ${*var}" "int *"
(lldb) type summary add --summary-string "the answer is ${var.ptr}, and the question is ${var.value}" JustADemo
)" "Type summaries are automatically applied to derived typedefs, so the examples \
above apply to both JustADemo and NewDemo. The cascade option can be used to \
suppress this behavior:" R"(
(lldb) type summary add --summary-string "${var.ptr}, ${var.value},{${var.byte}}" JustADemo -C no
The summary will now be used for values of JustADemo but not NewDemo.
)" "By default summaries are shown for pointers and references to values of the \
specified type. To suppress formatting for pointers use the -p option, or apply \
the corresponding -r option to suppress formatting for references:" R"(
(lldb) type summary add -p -r --summary-string "${var.ptr}, ${var.value},{${var.byte}}" JustADemo
)" "One-line summaries including all fields in a type can be inferred without supplying an \
explicit summary string by passing the -c option:" R"(
(lldb) type summary add -c JustADemo
(lldb) frame variable demo_instance
(ptr=<address>, value=3.14)
)" "Type summaries normally suppress the nested display of individual fields. To \
supply a summary to supplement the default structure add the -e option:" R"(
(lldb) type summary add -e --summary-string "*ptr = ${*var.ptr}" JustADemo
)" "Now when displaying JustADemo values the int* is displayed, followed by the \
standard LLDB sequence of children, one per line:" R"(
*ptr = 42 {
ptr = <address>
value = 3.14
}
)" "You can also add summaries written in Python. These scripts use lldb public API to \
gather information from your variables and produce a meaningful summary. To start a \
multi-line script use the -P option. The function declaration will be displayed along with \
a comment describing the two arguments. End your script with the word 'DONE' on a line by \
itself:" R"(
(lldb) type summary add JustADemo -P
def function (valobj,internal_dict):
"""valobj: an SBValue which you want to provide a summary for
internal_dict: an LLDB support object not to be used"""
value = valobj.GetChildMemberWithName('value');
return 'My value is ' + value.GetValue();
DONE
Alternatively, the -o option can be used when providing a simple one-line Python script:
(lldb) type summary add JustADemo -o "value = valobj.GetChildMemberWithName('value'); return 'My value is ' + value.GetValue();")"
);
}
bool
CommandObjectTypeSummaryAdd::DoExecute (Args& command, CommandReturnObject &result)
{
WarnOnPotentialUnquotedUnsignedType(command, result);
if (m_options.m_is_add_script)
{
#ifndef LLDB_DISABLE_PYTHON
return Execute_ScriptSummary(command, result);
#else
result.AppendError ("python is disabled");
result.SetStatus(eReturnStatusFailed);
return false;
#endif // LLDB_DISABLE_PYTHON
}
return Execute_StringSummary(command, result);
}
static bool
FixArrayTypeNameWithRegex (ConstString &type_name)
{
llvm::StringRef type_name_ref(type_name.GetStringRef());
if (type_name_ref.endswith("[]"))
{
std::string type_name_str(type_name.GetCString());
type_name_str.resize(type_name_str.length()-2);
if (type_name_str.back() != ' ')
type_name_str.append(" \\[[0-9]+\\]");
else
type_name_str.append("\\[[0-9]+\\]");
type_name.SetCString(type_name_str.c_str());
return true;
}
return false;
}
bool
CommandObjectTypeSummaryAdd::AddSummary(ConstString type_name,
TypeSummaryImplSP entry,
SummaryFormatType type,
std::string category_name,
Error* error)
{
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()), category);
if (type == eRegularSummary)
{
if (FixArrayTypeNameWithRegex (type_name))
type = eRegexSummary;
}
if (type == eRegexSummary)
{
RegularExpressionSP typeRX(new RegularExpression());
if (!typeRX->Compile(type_name.GetCString()))
{
if (error)
error->SetErrorString("regex format error (maybe this is not really a regex?)");
return false;
}
category->GetRegexTypeSummariesContainer()->Delete(type_name);
category->GetRegexTypeSummariesContainer()->Add(typeRX, entry);
return true;
}
else if (type == eNamedSummary)
{
// system named summaries do not exist (yet?)
DataVisualization::NamedSummaryFormats::Add(type_name,entry);
return true;
}
else
{
category->GetTypeSummariesContainer()->Add(type_name, entry);
return true;
}
}
OptionDefinition
CommandObjectTypeSummaryAdd::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName, "Add this to the given category instead of the default one."},
{ LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, cascade through typedef chains."},
{ LLDB_OPT_SET_ALL, false, "no-value", 'v', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't show the value, just show the summary, for this type."},
{ LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."},
{ LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't use this format for references-to-type objects."},
{ LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Type names are actually regular expressions."},
{ LLDB_OPT_SET_1 , true, "inline-children", 'c', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "If true, inline all child values into summary string."},
{ LLDB_OPT_SET_1 , false, "omit-names", 'O', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "If true, omit value names in the summary display."},
{ LLDB_OPT_SET_2 , true, "summary-string", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeSummaryString, "Summary string used to display text and object contents."},
{ LLDB_OPT_SET_3, false, "python-script", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonScript, "Give a one-liner Python script as part of the command."},
{ LLDB_OPT_SET_3, false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonFunction, "Give the name of a Python function to use for this type."},
{ LLDB_OPT_SET_3, false, "input-python", 'P', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Input Python code to use for this type manually."},
{ LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "expand", 'e', OptionParser::eNoArgument, nullptr, nullptr, 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, nullptr, nullptr, 0, eArgTypeNone, "Do not expand aggregate data types with no children."},
{ LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName, "A name for this summary string."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
//-------------------------------------------------------------------------
// CommandObjectTypeSummaryDelete
//-------------------------------------------------------------------------
class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete
{
public:
CommandObjectTypeSummaryDelete (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterDelete (interpreter,
eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary,
"type summary delete",
"Delete an existing summary for a type.")
{
}
~CommandObjectTypeSummaryDelete() override = default;
protected:
bool
FormatterSpecificDeletion (ConstString typeCS) override
{
if (m_options.m_language != lldb::eLanguageTypeUnknown)
return false;
return DataVisualization::NamedSummaryFormats::Delete(typeCS);
}
};
class CommandObjectTypeSummaryClear : public CommandObjectTypeFormatterClear
{
public:
CommandObjectTypeSummaryClear (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterClear (interpreter,
eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary,
"type summary clear",
"Delete all existing summaries.")
{
}
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
FormatterSpecificList (CommandReturnObject &result) override
{
if (DataVisualization::NamedSummaryFormats::GetCount() > 0)
{
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;
});
return true;
}
return false;
}
};
//-------------------------------------------------------------------------
// CommandObjectTypeCategoryDefine
//-------------------------------------------------------------------------
class CommandObjectTypeCategoryDefine : public CommandObjectParsed
{
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter),
m_define_enabled(false,false),
m_cate_language(eLanguageTypeUnknown,eLanguageTypeUnknown)
{
}
~CommandOptions() override = default;
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 '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);
break;
}
return error;
}
void
OptionParsingStarting () override
{
m_define_enabled.Clear();
m_cate_language.Clear();
}
const OptionDefinition*
GetDefinitions () override
{
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.
OptionValueBoolean m_define_enabled;
OptionValueLanguage m_cate_language;
};
CommandOptions m_options;
Options *
GetOptions () override
{
return &m_options;
}
public:
CommandObjectTypeCategoryDefine (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type category define",
"Define a new category as a source of formatters.",
nullptr),
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);
}
~CommandObjectTypeCategoryDefine() override = default;
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
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;
}
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)
{
category_sp->AddLanguage(m_options.m_cate_language.GetCurrentValue());
if (m_options.m_define_enabled.GetCurrentValue())
DataVisualization::Categories::Enable(category_sp, TypeCategoryMap::Default);
}
}
result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded();
}
};
OptionDefinition
CommandObjectTypeCategoryDefine::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "enabled", 'e', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "If specified, this category will be created enabled."},
{ LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Specify the language that this category is supported for."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
//-------------------------------------------------------------------------
// CommandObjectTypeCategoryEnable
//-------------------------------------------------------------------------
class CommandObjectTypeCategoryEnable : public CommandObjectParsed
{
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter)
{
}
~CommandOptions() override = default;
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 '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);
break;
}
return error;
}
void
OptionParsingStarting () override
{
m_language = lldb::eLanguageTypeUnknown;
}
const OptionDefinition*
GetDefinitions () override
{
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.
lldb::LanguageType m_language;
};
CommandOptions m_options;
Options *
GetOptions () override
{
return &m_options;
}
public:
CommandObjectTypeCategoryEnable (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type category enable",
"Enable a category as a source of formatters.",
nullptr),
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);
}
~CommandObjectTypeCategoryEnable() override = default;
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
const size_t argc = command.GetArgumentCount();
if (argc < 1 &&
m_options.m_language == lldb::eLanguageTypeUnknown)
{
result.AppendErrorWithFormat ("%s takes arguments and/or a language", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
if (argc == 1 && strcmp(command.GetArgumentAtIndex(0),"*") == 0)
{
DataVisualization::Categories::EnableStar();
}
else if (argc > 0)
{
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::Enable(typeCS);
lldb::TypeCategoryImplSP cate;
if (DataVisualization::Categories::GetCategory(typeCS, cate) && cate)
{
if (cate->GetCount() == 0)
{
result.AppendWarning("empty category enabled (typo?)");
}
}
}
}
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, nullptr, nullptr, 0, eArgTypeLanguage, "Enable the category for this language."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
//-------------------------------------------------------------------------
// CommandObjectTypeCategoryDelete
//-------------------------------------------------------------------------
class CommandObjectTypeCategoryDelete : public CommandObjectParsed
{
public:
CommandObjectTypeCategoryDelete (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type category delete",
"Delete a category and all associated formatters.",
nullptr)
{
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);
}
~CommandObjectTypeCategoryDelete() override = default;
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
const size_t argc = command.GetArgumentCount();
if (argc < 1)
{
result.AppendErrorWithFormat ("%s takes 1 or more arg.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
bool success = true;
// 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;
}
if (!DataVisualization::Categories::Delete(typeCS))
success = false; // keep deleting even if we hit an error
}
if (success)
{
result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded();
}
else
{
result.AppendError("cannot delete one or more categories\n");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
};
//-------------------------------------------------------------------------
// CommandObjectTypeCategoryDisable
//-------------------------------------------------------------------------
class CommandObjectTypeCategoryDisable : public CommandObjectParsed
{
class CommandOptions : public Options
{
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter)
{
}
~CommandOptions() override = default;
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 '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);
break;
}
return error;
}
void
OptionParsingStarting () override
{
m_language = lldb::eLanguageTypeUnknown;
}
const OptionDefinition*
GetDefinitions () override
{
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.
lldb::LanguageType m_language;
};
CommandOptions m_options;
Options *
GetOptions () override
{
return &m_options;
}
public:
CommandObjectTypeCategoryDisable (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type category disable",
"Disable a category as a source of formatters.",
nullptr),
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);
}
~CommandObjectTypeCategoryDisable() override = default;
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
const size_t argc = command.GetArgumentCount();
if (argc < 1 &&
m_options.m_language == lldb::eLanguageTypeUnknown)
{
result.AppendErrorWithFormat ("%s takes arguments and/or a language", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
if (argc == 1 && strcmp(command.GetArgumentAtIndex(0),"*") == 0)
{
DataVisualization::Categories::DisableStar();
}
else if (argc > 0)
{
// 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);
}
}
if (m_options.m_language != lldb::eLanguageTypeUnknown)
DataVisualization::Categories::Disable(m_options.m_language);
result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded();
}
};
OptionDefinition
CommandObjectTypeCategoryDisable::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Enable the category for this language."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
//-------------------------------------------------------------------------
// CommandObjectTypeCategoryList
//-------------------------------------------------------------------------
class CommandObjectTypeCategoryList : public CommandObjectParsed
{
public:
CommandObjectTypeCategoryList (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type category list",
"Provide a list of all existing categories.",
nullptr)
{
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() override = default;
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
const size_t argc = command.GetArgumentCount();
std::unique_ptr<RegularExpression> regex;
if (argc == 1)
{
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;
}
DataVisualization::Categories::ForEach( [&regex, &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();
}
};
//-------------------------------------------------------------------------
// CommandObjectTypeFilterList
//-------------------------------------------------------------------------
class CommandObjectTypeFilterList : public CommandObjectTypeFormatterList<TypeFilterImpl>
{
public:
CommandObjectTypeFilterList (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterList(interpreter,
"type filter list",
"Show a list of current filters.")
{
}
};
#ifndef LLDB_DISABLE_PYTHON
//-------------------------------------------------------------------------
// CommandObjectTypeSynthList
//-------------------------------------------------------------------------
class CommandObjectTypeSynthList : public CommandObjectTypeFormatterList<SyntheticChildren>
{
public:
CommandObjectTypeSynthList (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterList(interpreter,
"type synthetic list",
"Show a list of current synthetic providers.")
{
}
};
#endif // LLDB_DISABLE_PYTHON
//-------------------------------------------------------------------------
// CommandObjectTypeFilterDelete
//-------------------------------------------------------------------------
class CommandObjectTypeFilterDelete : public CommandObjectTypeFormatterDelete
{
public:
CommandObjectTypeFilterDelete (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterDelete (interpreter,
eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
"type filter delete",
"Delete an existing filter for a type.")
{
}
~CommandObjectTypeFilterDelete() override = default;
};
#ifndef LLDB_DISABLE_PYTHON
//-------------------------------------------------------------------------
// CommandObjectTypeSynthDelete
//-------------------------------------------------------------------------
class CommandObjectTypeSynthDelete : public CommandObjectTypeFormatterDelete
{
public:
CommandObjectTypeSynthDelete (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterDelete (interpreter,
eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
"type synthetic delete",
"Delete an existing synthetic provider for a type.")
{
}
~CommandObjectTypeSynthDelete() override = default;
};
#endif // LLDB_DISABLE_PYTHON
//-------------------------------------------------------------------------
// CommandObjectTypeFilterClear
//-------------------------------------------------------------------------
class CommandObjectTypeFilterClear : public CommandObjectTypeFormatterClear
{
public:
CommandObjectTypeFilterClear (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterClear (interpreter,
eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
"type filter clear",
"Delete all existing filter.")
{
}
};
#ifndef LLDB_DISABLE_PYTHON
//-------------------------------------------------------------------------
// CommandObjectTypeSynthClear
//-------------------------------------------------------------------------
class CommandObjectTypeSynthClear : public CommandObjectTypeFormatterClear
{
public:
CommandObjectTypeSynthClear (CommandInterpreter &interpreter) :
CommandObjectTypeFormatterClear (interpreter,
eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
"type synthetic clear",
"Delete all existing synthetic providers.")
{
}
};
bool
CommandObjectTypeSynthAdd::Execute_HandwritePython (Args& command, CommandReturnObject &result)
{
SynthAddOptions *options = new SynthAddOptions ( m_options.m_skip_pointers,
m_options.m_skip_references,
m_options.m_cascade,
m_options.m_regex,
m_options.m_category);
const size_t argc = command.GetArgumentCount();
for (size_t i = 0; i < argc; i++)
{
const char* typeA = command.GetArgumentAtIndex(i);
if (typeA && *typeA)
options->m_target_types << typeA;
else
{
result.AppendError("empty typenames not allowed");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
m_interpreter.GetPythonCommandsFromIOHandler (" ", // Prompt
*this, // IOHandlerDelegate
true, // Run IOHandler in async mode
options); // Baton for the "io_handler" that will be passed back into our IOHandlerDelegate functions
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
}
bool
CommandObjectTypeSynthAdd::Execute_PythonClass (Args& command, CommandReturnObject &result)
{
const size_t argc = command.GetArgumentCount();
if (argc < 1)
{
result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
if (m_options.m_class_name.empty() && !m_options.m_input_python)
{
result.AppendErrorWithFormat ("%s needs either a Python class name or -P to directly input Python code.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
SyntheticChildrenSP entry;
ScriptedSyntheticChildren* impl = new ScriptedSyntheticChildren(SyntheticChildren::Flags().
SetCascades(m_options.m_cascade).
SetSkipPointers(m_options.m_skip_pointers).
SetSkipReferences(m_options.m_skip_references),
m_options.m_class_name.c_str());
entry.reset(impl);
ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
if (interpreter && !interpreter->CheckObjectExists(impl->GetPythonClassName()))
result.AppendWarning("The provided class does not exist - please define it before attempting to use this synthetic provider");
// now I have a valid provider, let's add it to every type
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category);
Error error;
for (size_t i = 0; i < argc; i++)
{
const char* typeA = command.GetArgumentAtIndex(i);
ConstString typeCS(typeA);
if (typeCS)
{
if (!AddSynth(typeCS,
entry,
m_options.m_regex ? eRegexSynth : eRegularSynth,
m_options.m_category,
&error))
{
result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed);
return false;
}
}
else
{
result.AppendError("empty typenames not allowed");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
}
CommandObjectTypeSynthAdd::CommandObjectTypeSynthAdd (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type synthetic add",
"Add a new synthetic provider for a type.",
nullptr),
IOHandlerDelegateMultiline ("DONE"),
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);
}
bool
CommandObjectTypeSynthAdd::AddSynth(ConstString type_name,
SyntheticChildrenSP entry,
SynthFormatType type,
std::string category_name,
Error* error)
{
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()), category);
if (type == eRegularSynth)
{
if (FixArrayTypeNameWithRegex (type_name))
type = eRegexSynth;
}
if (category->AnyMatches(type_name,
eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter,
false))
{
if (error)
error->SetErrorStringWithFormat("cannot add synthetic for type %s when filter is defined in same category!", type_name.AsCString());
return false;
}
if (type == eRegexSynth)
{
RegularExpressionSP typeRX(new RegularExpression());
if (!typeRX->Compile(type_name.GetCString()))
{
if (error)
error->SetErrorString("regex format error (maybe this is not really a regex?)");
return false;
}
category->GetRegexTypeSyntheticsContainer()->Delete(type_name);
category->GetRegexTypeSyntheticsContainer()->Add(typeRX, entry);
return true;
}
else
{
category->GetTypeSyntheticsContainer()->Add(type_name, entry);
return true;
}
}
OptionDefinition
CommandObjectTypeSynthAdd::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, cascade through typedef chains."},
{ LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."},
{ LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't use this format for references-to-type objects."},
{ LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName, "Add this to the given category instead of the default one."},
{ LLDB_OPT_SET_2, false, "python-class", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonClass, "Use this Python class to produce synthetic children."},
{ LLDB_OPT_SET_3, false, "input-python", 'P', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Type Python code to generate a class that provides synthetic children."},
{ LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Type names are actually regular expressions."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
#endif // LLDB_DISABLE_PYTHON
class CommandObjectTypeFilterAdd : public CommandObjectParsed
{
private:
class CommandOptions : public Options
{
typedef std::vector<std::string> option_vector;
public:
CommandOptions (CommandInterpreter &interpreter) :
Options (interpreter)
{
}
~CommandOptions() override = default;
Error
SetOptionValue (uint32_t option_idx, const char *option_arg) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
bool success;
switch (short_option)
{
case 'C':
m_cascade = Args::StringToBoolean(option_arg, true, &success);
if (!success)
error.SetErrorStringWithFormat("invalid value for cascade: %s", option_arg);
break;
case 'c':
m_expr_paths.push_back(option_arg);
has_child_list = true;
break;
case 'p':
m_skip_pointers = true;
break;
case 'r':
m_skip_references = true;
break;
case 'w':
m_category = std::string(option_arg);
break;
case 'x':
m_regex = true;
break;
default:
error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
break;
}
return error;
}
void
OptionParsingStarting () override
{
m_cascade = true;
m_skip_pointers = false;
m_skip_references = false;
m_category = "default";
m_expr_paths.clear();
has_child_list = false;
m_regex = false;
}
const OptionDefinition*
GetDefinitions () override
{
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_cascade;
bool m_skip_references;
bool m_skip_pointers;
bool m_input_python;
option_vector m_expr_paths;
std::string m_category;
bool has_child_list;
bool m_regex;
typedef option_vector::iterator ExpressionPathsIterator;
};
CommandOptions m_options;
Options *
GetOptions () override
{
return &m_options;
}
enum FilterFormatType
{
eRegularFilter,
eRegexFilter
};
bool
AddFilter(ConstString type_name,
TypeFilterImplSP entry,
FilterFormatType type,
std::string category_name,
Error* error)
{
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()), category);
if (type == eRegularFilter)
{
if (FixArrayTypeNameWithRegex (type_name))
type = eRegexFilter;
}
if (category->AnyMatches(type_name,
eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth,
false))
{
if (error)
error->SetErrorStringWithFormat("cannot add filter for type %s when synthetic is defined in same category!", type_name.AsCString());
return false;
}
if (type == eRegexFilter)
{
RegularExpressionSP typeRX(new RegularExpression());
if (!typeRX->Compile(type_name.GetCString()))
{
if (error)
error->SetErrorString("regex format error (maybe this is not really a regex?)");
return false;
}
category->GetRegexTypeFiltersContainer()->Delete(type_name);
category->GetRegexTypeFiltersContainer()->Add(typeRX, entry);
return true;
}
else
{
category->GetTypeFiltersContainer()->Add(type_name, entry);
return true;
}
}
public:
CommandObjectTypeFilterAdd (CommandInterpreter &interpreter) :
CommandObjectParsed(interpreter,
"type filter add",
"Add a new filter for a type.",
nullptr),
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);
SetHelpLong(
R"(
The following examples of 'type filter add' refer to this code snippet for context:
class Foo {
int a;
int b;
int c;
int d;
int e;
int f;
int g;
int h;
int i;
}
Foo my_foo;
Adding a simple filter:
(lldb) type filter add --child a --child g Foo
(lldb) frame variable my_foo
)" "Produces output where only a and g are displayed. Other children of my_foo \
(b, c, d, e, f, h and i) are available by asking for them explicitly:" R"(
(lldb) frame variable my_foo.b my_foo.c my_foo.i
)" "The formatting option --raw on frame variable bypasses the filter, showing \
all children of my_foo as if no filter was defined:" R"(
(lldb) frame variable my_foo --raw)"
);
}
~CommandObjectTypeFilterAdd() override = default;
protected:
bool
DoExecute (Args& command, CommandReturnObject &result) override
{
const size_t argc = command.GetArgumentCount();
if (argc < 1)
{
result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
if (m_options.m_expr_paths.empty())
{
result.AppendErrorWithFormat ("%s needs one or more children.\n", m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
}
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++)
entry->AddExpressionPath(*begin);
// now I have a valid provider, let's add it to every type
lldb::TypeCategoryImplSP category;
DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category);
Error error;
WarnOnPotentialUnquotedUnsignedType(command, result);
for (size_t i = 0; i < argc; i++)
{
const char* typeA = command.GetArgumentAtIndex(i);
ConstString typeCS(typeA);
if (typeCS)
{
if (!AddFilter(typeCS,
entry,
m_options.m_regex ? eRegexFilter : eRegularFilter,
m_options.m_category,
&error))
{
result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed);
return false;
}
}
else
{
result.AppendError("empty typenames not allowed");
result.SetStatus(eReturnStatusFailed);
return false;
}
}
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded();
}
};
OptionDefinition
CommandObjectTypeFilterAdd::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, cascade through typedef chains."},
{ LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."},
{ LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Don't use this format for references-to-type objects."},
{ LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName, "Add this to the given category instead of the default one."},
{ LLDB_OPT_SET_ALL, false, "child", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeExpressionPath, "Include this expression path in the synthetic view."},
{ LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Type names are actually regular expressions."},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
//----------------------------------------------------------------------
// "type lookup"
//----------------------------------------------------------------------
class CommandObjectTypeLookup : public CommandObjectRaw
{
protected:
// this function is allowed to do a more aggressive job at guessing languages than the expression parser
// is comfortable with - so leave the original call alone and add one that is specific to type lookup
lldb::LanguageType
GuessLanguage (StackFrame *frame)
{
lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;
if (!frame)
return lang_type;
lang_type = frame->GuessLanguage();
if (lang_type != lldb::eLanguageTypeUnknown)
return lang_type;
Symbol *s = frame->GetSymbolContext(eSymbolContextSymbol).symbol;
if (s)
lang_type = s->GetMangled().GuessLanguage();
return lang_type;
}
class CommandOptions : public OptionGroup
{
public:
CommandOptions () :
OptionGroup(),
m_show_help(false),
m_language(eLanguageTypeUnknown)
{}
~CommandOptions() override = default;
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 types and declarations in the current target, following language-specific naming conventions.",
"type lookup <type-specifier>",
eCommandRequiresTarget),
m_option_group(interpreter),
m_command_options()
{
m_option_group.Append(&m_command_options);
m_option_group.Finalize();
}
~CommandObjectTypeLookup() override = default;
Options *
GetOptions () override
{
return &m_option_group;
}
const char*
GetHelpLong () override
{
if (m_cmd_help_long.empty())
{
StreamString stream;
// FIXME: hardcoding languages is not good
lldb::LanguageType languages[] = {eLanguageTypeObjC,eLanguageTypeC_plus_plus};
for(const auto lang_type : languages)
{
if (auto language = Language::FindPlugin(lang_type))
{
if (const char* help = language->GetLanguageSpecificTypeLookupHelp())
{
stream.Printf("%s\n", help);
}
}
}
if (stream.GetData())
m_cmd_help_long.assign(stream.GetString());
}
return this->CommandObject::GetHelpLong();
}
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 = nullptr;
if (raw_command_line[0] == '-')
{
// We have some options and these options MUST end with --.
const char *end_options = nullptr;
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;
bool is_global_search = false;
if ( (is_global_search = (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));
}
// This is not the most efficient way to do this, but we support very few languages
// so the cost of the sort is going to be dwarfed by the actual lookup anyway
if (StackFrame* frame = m_exe_ctx.GetFramePtr())
{
LanguageType lang = GuessLanguage(frame);
if (lang != eLanguageTypeUnknown)
{
std::sort(languages.begin(),
languages.end(),
[lang] (Language* lang1,
Language* lang2) -> bool {
if (!lang1 || !lang2) return false;
LanguageType lt1 = lang1->GetLanguageType();
LanguageType lt2 = lang2->GetLanguageType();
if (lt1 == lang) return true; // make the selected frame's language come first
if (lt2 == lang) return false; // make the selected frame's language come first
return (lt1 < lt2); // normal comparison otherwise
});
}
}
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);
}
}
}
// this is "type lookup SomeName" and we did find a match, so get out
if (any_found && is_global_search)
break;
}
}
if (!any_found)
result.AppendMessageWithFormat("no type was found matching '%s'\n", name_of_type);
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, nullptr, nullptr, 0, eArgTypeNone, "Display available help for types"},
{ LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Which language's types should the search scope be"},
{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
};
template <typename FormatterType>
class CommandObjectFormatterInfo : public CommandObjectRaw
{
public:
typedef std::function<typename FormatterType::SharedPointer(ValueObject&)> DiscoveryFunction;
CommandObjectFormatterInfo (CommandInterpreter &interpreter,
const char* formatter_name,
DiscoveryFunction discovery_func) :
CommandObjectRaw(interpreter,
nullptr,
nullptr,
nullptr,
eCommandRequiresFrame),
m_formatter_name(formatter_name ? formatter_name : ""),
m_discovery_function(discovery_func)
{
StreamString name;
name.Printf("type %s info", formatter_name);
SetCommandName(name.GetData());
StreamString help;
help.Printf("This command evaluates the provided expression and shows which %s is applied to the resulting value (if any).", formatter_name);
SetHelp(help.GetData());
StreamString syntax;
syntax.Printf("type %s info <expr>", formatter_name);
SetSyntax(syntax.GetData());
}
~CommandObjectFormatterInfo() override = default;
protected:
bool
DoExecute (const char *command, CommandReturnObject &result) override
{
TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
Thread *thread = GetDefaultThread();
if (!thread)
{
result.AppendError("no default thread");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
StackFrameSP frame_sp = thread->GetSelectedFrame();
ValueObjectSP result_valobj_sp;
EvaluateExpressionOptions options;
lldb::ExpressionResults expr_result = target_sp->EvaluateExpression(command, frame_sp.get(), result_valobj_sp, options);
if (expr_result == eExpressionCompleted && result_valobj_sp)
{
result_valobj_sp = result_valobj_sp->GetQualifiedRepresentationIfAvailable(target_sp->GetPreferDynamicValue(), target_sp->GetEnableSyntheticValue());
typename FormatterType::SharedPointer formatter_sp = m_discovery_function(*result_valobj_sp);
if (formatter_sp)
{
std::string description(formatter_sp->GetDescription());
result.AppendMessageWithFormat("%s applied to (%s) %s is: %s\n",
m_formatter_name.c_str(),
result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>"),
command,
description.c_str());
result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
}
else
{
result.AppendMessageWithFormat("no %s applies to (%s) %s\n",
m_formatter_name.c_str(),
result_valobj_sp->GetDisplayTypeName().AsCString("<unknown>"),
command);
result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
}
return true;
}
else
{
result.AppendError("failed to evaluate expression");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
}
private:
std::string m_formatter_name;
DiscoveryFunction m_discovery_function;
};
class CommandObjectTypeFormat : public CommandObjectMultiword
{
public:
CommandObjectTypeFormat(CommandInterpreter &interpreter)
: CommandObjectMultiword(interpreter, "type format", "Commands for customizing value display formats.",
"type format [<sub-command-options>] ")
{
LoadSubCommand ("add", CommandObjectSP (new CommandObjectTypeFormatAdd (interpreter)));
LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTypeFormatClear (interpreter)));
LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeFormatDelete (interpreter)));
LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeFormatList (interpreter)));
LoadSubCommand ("info", CommandObjectSP (new CommandObjectFormatterInfo<TypeFormatImpl>(interpreter,
"format",
[](ValueObject& valobj) -> TypeFormatImpl::SharedPointer {
return valobj.GetValueFormat();
})));
}
~CommandObjectTypeFormat() override = default;
};
#ifndef LLDB_DISABLE_PYTHON
class CommandObjectTypeSynth : public CommandObjectMultiword
{
public:
CommandObjectTypeSynth(CommandInterpreter &interpreter)
: CommandObjectMultiword(interpreter, "type synthetic",
"Commands for operating on synthetic type representations.",
"type synthetic [<sub-command-options>] ")
{
LoadSubCommand ("add", CommandObjectSP (new CommandObjectTypeSynthAdd (interpreter)));
LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTypeSynthClear (interpreter)));
LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeSynthDelete (interpreter)));
LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeSynthList (interpreter)));
LoadSubCommand ("info", CommandObjectSP (new CommandObjectFormatterInfo<SyntheticChildren>(interpreter,
"synthetic",
[](ValueObject& valobj) -> SyntheticChildren::SharedPointer {
return valobj.GetSyntheticChildren();
})));
}
~CommandObjectTypeSynth() override = default;
};
#endif // LLDB_DISABLE_PYTHON
class CommandObjectTypeFilter : public CommandObjectMultiword
{
public:
CommandObjectTypeFilter(CommandInterpreter &interpreter)
: CommandObjectMultiword(interpreter, "type filter", "Commands for operating on type filters.",
"type synthetic [<sub-command-options>] ")
{
LoadSubCommand ("add", CommandObjectSP (new CommandObjectTypeFilterAdd (interpreter)));
LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTypeFilterClear (interpreter)));
LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeFilterDelete (interpreter)));
LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeFilterList (interpreter)));
}
~CommandObjectTypeFilter() override = default;
};
class CommandObjectTypeCategory : public CommandObjectMultiword
{
public:
CommandObjectTypeCategory(CommandInterpreter &interpreter)
: CommandObjectMultiword(interpreter, "type category", "Commands for operating on type 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)));
LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeCategoryList (interpreter)));
}
~CommandObjectTypeCategory() override = default;
};
class CommandObjectTypeSummary : public CommandObjectMultiword
{
public:
CommandObjectTypeSummary(CommandInterpreter &interpreter)
: CommandObjectMultiword(interpreter, "type summary", "Commands for editing variable summary display options.",
"type summary [<sub-command-options>] ")
{
LoadSubCommand ("add", CommandObjectSP (new CommandObjectTypeSummaryAdd (interpreter)));
LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTypeSummaryClear (interpreter)));
LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeSummaryDelete (interpreter)));
LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeSummaryList (interpreter)));
LoadSubCommand ("info", CommandObjectSP (new CommandObjectFormatterInfo<TypeSummaryImpl>(interpreter,
"summary",
[](ValueObject& valobj) -> TypeSummaryImpl::SharedPointer {
return valobj.GetSummaryFormat();
})));
}
~CommandObjectTypeSummary() override = default;
};
//-------------------------------------------------------------------------
// CommandObjectType
//-------------------------------------------------------------------------
CommandObjectType::CommandObjectType(CommandInterpreter &interpreter)
: CommandObjectMultiword(interpreter, "type", "Commands for operating on the type system.",
"type [<sub-command-options>]")
{
LoadSubCommand ("category", CommandObjectSP (new CommandObjectTypeCategory (interpreter)));
LoadSubCommand ("filter", CommandObjectSP (new CommandObjectTypeFilter (interpreter)));
LoadSubCommand ("format", CommandObjectSP (new CommandObjectTypeFormat (interpreter)));
LoadSubCommand ("summary", CommandObjectSP (new CommandObjectTypeSummary (interpreter)));
#ifndef LLDB_DISABLE_PYTHON
LoadSubCommand ("synthetic", CommandObjectSP (new CommandObjectTypeSynth (interpreter)));
#endif // LLDB_DISABLE_PYTHON
LoadSubCommand ("lookup", CommandObjectSP (new CommandObjectTypeLookup (interpreter)));
}
CommandObjectType::~CommandObjectType() = default;