SBTypeSynthetic
SBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name)
{
if (type_name.IsValid() == false)
return SBTypeSynthetic();
return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP()));
}
SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
(lldb::SBTypeNameSpecifier), spec);
if (!IsValid())
return LLDB_RECORD_RESULT(SBTypeFilter());
if (!spec.IsValid())
return LLDB_RECORD_RESULT(SBTypeFilter());
lldb::TypeFilterImplSP children_sp;
if (spec.IsRegex())
m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(
ConstString(spec.GetName()), children_sp);
else
m_opaque_sp->GetTypeFiltersContainer()->GetExact(
ConstString(spec.GetName()), children_sp);
if (!children_sp)
return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
TypeFilterImplSP filter_sp =
std::static_pointer_cast<TypeFilterImpl>(children_sp);
return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
}
bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
SBTypeSynthetic synth) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
(lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
type_name, synth);
if (!IsValid())
return false;
if (!type_name.IsValid())
return false;
if (!synth.IsValid())
return false;
// FIXME: we need to iterate over all the Debugger objects and have each of
// them contain a copy of the function
// since we currently have formatters live in a global space, while Python
// code lives in a specific Debugger-related environment this should
// eventually be fixed by deciding a final location in the LLDB object space
// for formatters
if (synth.IsClassCode()) {
const void *name_token =
(const void *)ConstString(type_name.GetName()).GetCString();
const char *script = synth.GetData();
StringList input;
input.SplitIntoLines(script, strlen(script));
uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
bool need_set = true;
for (uint32_t j = 0; j < num_debuggers; j++) {
DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
if (debugger_sp) {
ScriptInterpreter *interpreter_ptr =
debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
if (interpreter_ptr) {
std::string output;
if (interpreter_ptr->GenerateTypeSynthClass(input, output,
name_token) &&
!output.empty()) {
if (need_set) {
need_set = false;
synth.SetClassName(output.c_str());
}
}
}
}
}
}
if (type_name.IsRegex())
m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(
lldb::RegularExpressionSP(new RegularExpression(
llvm::StringRef::withNullAsEmpty(type_name.GetName()))),
synth.GetSP());
else
m_opaque_sp->GetTypeSyntheticsContainer()->Add(
ConstString(type_name.GetName()), synth.GetSP());
return true;
}
SBTypeSummary
SBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name)
{
if (type_name.IsValid() == false)
return SBTypeSummary();
return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
}
SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
(lldb::SBTypeNameSpecifier), spec);
if (!IsValid())
return LLDB_RECORD_RESULT(SBTypeSynthetic());
if (!spec.IsValid())
return LLDB_RECORD_RESULT(SBTypeSynthetic());
lldb::SyntheticChildrenSP children_sp;
if (spec.IsRegex())
m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetExact(
ConstString(spec.GetName()), children_sp);
else
m_opaque_sp->GetTypeSyntheticsContainer()->GetExact(
ConstString(spec.GetName()), children_sp);
if (!children_sp)
return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
ScriptedSyntheticChildrenSP synth_sp =
std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
}
bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
SBTypeFilter filter) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
(lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
filter);
if (!IsValid())
return false;
if (!type_name.IsValid())
return false;
if (!filter.IsValid())
return false;
if (type_name.IsRegex())
m_opaque_sp->GetRegexTypeFiltersContainer()->Add(
lldb::RegularExpressionSP(new RegularExpression(
llvm::StringRef::withNullAsEmpty(type_name.GetName()))),
filter.GetSP());
else
m_opaque_sp->GetTypeFiltersContainer()->Add(
ConstString(type_name.GetName()), filter.GetSP());
return true;
}
SBTypeFilter
SBDebugger::GetFilterForType (SBTypeNameSpecifier type_name)
{
if (type_name.IsValid() == false)
return SBTypeFilter();
return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
}
bool
SBTypeCategory::AddTypeSummary (SBTypeNameSpecifier type_name,
SBTypeSummary summary)
{
if (!IsValid())
return false;
if (!type_name.IsValid())
return false;
if (!summary.IsValid())
return false;
// FIXME: we need to iterate over all the Debugger objects and have each of them contain a copy of the function
// since we currently have formatters live in a global space, while Python code lives in a specific Debugger-related environment
// this should eventually be fixed by deciding a final location in the LLDB object space for formatters
if (summary.IsFunctionCode())
{
void *name_token = (void*)ConstString(type_name.GetName()).GetCString();
const char* script = summary.GetData();
StringList input; input.SplitIntoLines(script, strlen(script));
uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
bool need_set = true;
for (uint32_t j = 0;
j < num_debuggers;
j++)
{
DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
if (debugger_sp)
{
ScriptInterpreter* interpreter_ptr = debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
if (interpreter_ptr)
{
std::string output;
if (interpreter_ptr->GenerateTypeScriptFunction(input, output, name_token) && !output.empty())
{
if (need_set)
{
need_set = false;
summary.SetFunctionName(output.c_str());
}
}
}
}
}
}
if (type_name.IsRegex())
m_opaque_sp->GetRegexSummaryNavigator()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), summary.GetSP());
else
m_opaque_sp->GetSummaryNavigator()->Add(ConstString(type_name.GetName()), summary.GetSP());
return true;
}
bool
SBTypeCategory::DeleteTypeSynthetic (SBTypeNameSpecifier type_name)
{
if (!IsValid())
return false;
if (!type_name.IsValid())
return false;
if (type_name.IsRegex())
return m_opaque_sp->GetRegexSyntheticNavigator()->Delete(ConstString(type_name.GetName()));
else
return m_opaque_sp->GetSyntheticNavigator()->Delete(ConstString(type_name.GetName()));
}
bool
SBTypeCategory::DeleteTypeFilter (SBTypeNameSpecifier type_name)
{
if (!IsValid())
return false;
if (!type_name.IsValid())
return false;
if (type_name.IsRegex())
return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(ConstString(type_name.GetName()));
else
return m_opaque_sp->GetTypeFiltersContainer()->Delete(ConstString(type_name.GetName()));
}
bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
(lldb::SBTypeNameSpecifier), type_name);
if (!IsValid())
return false;
if (!type_name.IsValid())
return false;
if (type_name.IsRegex())
return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(
ConstString(type_name.GetName()));
else
return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(
ConstString(type_name.GetName()));
}
bool
SBTypeCategory::AddTypeFilter (SBTypeNameSpecifier type_name,
SBTypeFilter filter)
{
if (!IsValid())
return false;
if (!type_name.IsValid())
return false;
if (!filter.IsValid())
return false;
if (type_name.IsRegex())
m_opaque_sp->GetRegexFilterNavigator()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), filter.GetSP());
else
m_opaque_sp->GetFilterNavigator()->Add(ConstString(type_name.GetName()), filter.GetSP());
return true;
}
bool
SBTypeCategory::AddTypeFormat (SBTypeNameSpecifier type_name,
SBTypeFormat format)
{
if (!IsValid())
return false;
if (!type_name.IsValid())
return false;
if (!format.IsValid())
return false;
if (type_name.IsRegex())
m_opaque_sp->GetRegexTypeFormatsContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), format.GetSP());
else
m_opaque_sp->GetTypeFormatsContainer()->Add(ConstString(type_name.GetName()), format.GetSP());
return true;
}
SBTypeSummary
SBTypeCategory::GetSummaryForType (SBTypeNameSpecifier spec)
{
if (!IsValid())
return SBTypeSummary();
if (!spec.IsValid())
return SBTypeSummary();
lldb::TypeSummaryImplSP summary_sp;
if (spec.IsRegex())
m_opaque_sp->GetRegexSummaryNavigator()->GetExact(ConstString(spec.GetName()), summary_sp);
else
m_opaque_sp->GetSummaryNavigator()->GetExact(ConstString(spec.GetName()), summary_sp);
if (!summary_sp)
return lldb::SBTypeSummary();
return lldb::SBTypeSummary(summary_sp);
}
SBTypeFormat
SBTypeCategory::GetFormatForType (SBTypeNameSpecifier spec)
{
if (!IsValid())
return SBTypeFormat();
if (!spec.IsValid())
return SBTypeFormat();
lldb::TypeFormatImplSP format_sp;
if (spec.IsRegex())
m_opaque_sp->GetRegexValueNavigator()->GetExact(ConstString(spec.GetName()), format_sp);
else
m_opaque_sp->GetValueNavigator()->GetExact(ConstString(spec.GetName()), format_sp);
if (!format_sp)
return lldb::SBTypeFormat();
return lldb::SBTypeFormat(format_sp);
}
SBTypeSynthetic
SBTypeCategory::GetSyntheticForType (SBTypeNameSpecifier spec)
{
if (!IsValid())
return SBTypeSynthetic();
if (!spec.IsValid())
return SBTypeSynthetic();
lldb::SyntheticChildrenSP children_sp;
if (spec.IsRegex())
m_opaque_sp->GetRegexSyntheticNavigator()->GetExact(ConstString(spec.GetName()), children_sp);
else
m_opaque_sp->GetSyntheticNavigator()->GetExact(ConstString(spec.GetName()), children_sp);
if (!children_sp)
return lldb::SBTypeSynthetic();
ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
return lldb::SBTypeSynthetic(synth_sp);
}
SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
(lldb::SBTypeNameSpecifier), spec);
if (!IsValid())
return LLDB_RECORD_RESULT(SBTypeFormat());
if (!spec.IsValid())
return LLDB_RECORD_RESULT(SBTypeFormat());
lldb::TypeFormatImplSP format_sp;
if (spec.IsRegex())
m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact(
ConstString(spec.GetName()), format_sp);
else
m_opaque_sp->GetTypeFormatsContainer()->GetExact(
ConstString(spec.GetName()), format_sp);
if (!format_sp)
return LLDB_RECORD_RESULT(lldb::SBTypeFormat());
return LLDB_RECORD_RESULT(lldb::SBTypeFormat(format_sp));
}
SBTypeFilter
SBTypeCategory::GetFilterForType (SBTypeNameSpecifier spec)
{
if (!IsValid())
return SBTypeFilter();
if (!spec.IsValid())
return SBTypeFilter();
lldb::SyntheticChildrenSP children_sp;
if (spec.IsRegex())
m_opaque_sp->GetRegexFilterNavigator()->GetExact(ConstString(spec.GetName()), children_sp);
else
m_opaque_sp->GetFilterNavigator()->GetExact(ConstString(spec.GetName()), children_sp);
if (!children_sp)
return lldb::SBTypeFilter();
TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp);
return lldb::SBTypeFilter(filter_sp);
}
SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
(lldb::SBTypeNameSpecifier), spec);
if (!IsValid())
return LLDB_RECORD_RESULT(SBTypeSummary());
if (!spec.IsValid())
return LLDB_RECORD_RESULT(SBTypeSummary());
lldb::TypeSummaryImplSP summary_sp;
if (spec.IsRegex())
m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact(
ConstString(spec.GetName()), summary_sp);
else
m_opaque_sp->GetTypeSummariesContainer()->GetExact(
ConstString(spec.GetName()), summary_sp);
if (!summary_sp)
return LLDB_RECORD_RESULT(lldb::SBTypeSummary());
return LLDB_RECORD_RESULT(lldb::SBTypeSummary(summary_sp));
}