diff options
Diffstat (limited to 'source/DataFormatters/TypeCategory.cpp')
| -rw-r--r-- | source/DataFormatters/TypeCategory.cpp | 382 |
1 files changed, 382 insertions, 0 deletions
diff --git a/source/DataFormatters/TypeCategory.cpp b/source/DataFormatters/TypeCategory.cpp new file mode 100644 index 000000000000..c887be5da496 --- /dev/null +++ b/source/DataFormatters/TypeCategory.cpp @@ -0,0 +1,382 @@ +//===-- TypeCategory.cpp -------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "lldb/lldb-python.h" + +#include "lldb/DataFormatters/TypeCategory.h" + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes + +using namespace lldb; +using namespace lldb_private; + +TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener* clist, + ConstString name) : +m_summary_nav(new SummaryNavigator("summary",clist)), +m_regex_summary_nav(new RegexSummaryNavigator("regex-summary",clist)), +m_filter_nav(new FilterNavigator("filter",clist)), +m_regex_filter_nav(new RegexFilterNavigator("regex-filter",clist)), +#ifndef LLDB_DISABLE_PYTHON +m_synth_nav(new SynthNavigator("synth",clist)), +m_regex_synth_nav(new RegexSynthNavigator("regex-synth",clist)), +#endif +m_enabled(false), +m_change_listener(clist), +m_mutex(Mutex::eMutexTypeRecursive), +m_name(name) +{} + +bool +TypeCategoryImpl::Get (ValueObject& valobj, + lldb::TypeSummaryImplSP& entry, + lldb::DynamicValueType use_dynamic, + uint32_t* reason) +{ + if (!IsEnabled()) + return false; + if (GetSummaryNavigator()->Get(valobj, entry, use_dynamic, reason)) + return true; + bool regex = GetRegexSummaryNavigator()->Get(valobj, entry, use_dynamic, reason); + if (regex && reason) + *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary; + return regex; +} + +bool +TypeCategoryImpl::Get(ValueObject& valobj, + lldb::SyntheticChildrenSP& entry_sp, + lldb::DynamicValueType use_dynamic, + uint32_t* reason) +{ + if (!IsEnabled()) + return false; + TypeFilterImpl::SharedPointer filter_sp; + uint32_t reason_filter = 0; + bool regex_filter = false; + // first find both Filter and Synth, and then check which is most recent + + if (!GetFilterNavigator()->Get(valobj, filter_sp, use_dynamic, &reason_filter)) + regex_filter = GetRegexFilterNavigator()->Get (valobj, filter_sp, use_dynamic, &reason_filter); + +#ifndef LLDB_DISABLE_PYTHON + bool regex_synth = false; + uint32_t reason_synth = 0; + bool pick_synth = false; + ScriptedSyntheticChildren::SharedPointer synth; + if (!GetSyntheticNavigator()->Get(valobj, synth, use_dynamic, &reason_synth)) + regex_synth = GetRegexSyntheticNavigator()->Get (valobj, synth, use_dynamic, &reason_synth); + if (!filter_sp.get() && !synth.get()) + return false; + else if (!filter_sp.get() && synth.get()) + pick_synth = true; + + else if (filter_sp.get() && !synth.get()) + pick_synth = false; + + else /*if (filter_sp.get() && synth.get())*/ + { + if (filter_sp->GetRevision() > synth->GetRevision()) + pick_synth = false; + else + pick_synth = true; + } + if (pick_synth) + { + if (regex_synth && reason) + *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter; + entry_sp = synth; + return true; + } + else + { + if (regex_filter && reason) + *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter; + entry_sp = filter_sp; + return true; + } + +#else + if (filter_sp) + { + entry_sp = filter_sp; + return true; + } +#endif + + return false; + +} + +void +TypeCategoryImpl::Clear (FormatCategoryItems items) +{ + if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary ) + m_summary_nav->Clear(); + if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary ) + m_regex_summary_nav->Clear(); + if ( (items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter ) + m_filter_nav->Clear(); + if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter ) + m_regex_filter_nav->Clear(); +#ifndef LLDB_DISABLE_PYTHON + if ( (items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth ) + m_synth_nav->Clear(); + if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth ) + m_regex_synth_nav->Clear(); +#endif +} + +bool +TypeCategoryImpl::Delete (ConstString name, + FormatCategoryItems items) +{ + bool success = false; + if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary ) + success = m_summary_nav->Delete(name) || success; + if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary ) + success = m_regex_summary_nav->Delete(name) || success; + if ( (items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter ) + success = m_filter_nav->Delete(name) || success; + if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter ) + success = m_regex_filter_nav->Delete(name) || success; +#ifndef LLDB_DISABLE_PYTHON + if ( (items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth ) + success = m_synth_nav->Delete(name) || success; + if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth ) + success = m_regex_synth_nav->Delete(name) || success; +#endif + return success; +} + +uint32_t +TypeCategoryImpl::GetCount (FormatCategoryItems items) +{ + uint32_t count = 0; + if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary ) + count += m_summary_nav->GetCount(); + if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary ) + count += m_regex_summary_nav->GetCount(); + if ( (items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter ) + count += m_filter_nav->GetCount(); + if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter ) + count += m_regex_filter_nav->GetCount(); +#ifndef LLDB_DISABLE_PYTHON + if ( (items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth ) + count += m_synth_nav->GetCount(); + if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth ) + count += m_regex_synth_nav->GetCount(); +#endif + return count; +} + +bool +TypeCategoryImpl::AnyMatches(ConstString type_name, + FormatCategoryItems items, + bool only_enabled, + const char** matching_category, + FormatCategoryItems* matching_type) +{ + if (!IsEnabled() && only_enabled) + return false; + + lldb::TypeSummaryImplSP summary; + TypeFilterImpl::SharedPointer filter; +#ifndef LLDB_DISABLE_PYTHON + ScriptedSyntheticChildren::SharedPointer synth; +#endif + + if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary ) + { + if (m_summary_nav->Get(type_name, summary)) + { + if (matching_category) + *matching_category = m_name.GetCString(); + if (matching_type) + *matching_type = eFormatCategoryItemSummary; + return true; + } + } + if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary ) + { + if (m_regex_summary_nav->Get(type_name, summary)) + { + if (matching_category) + *matching_category = m_name.GetCString(); + if (matching_type) + *matching_type = eFormatCategoryItemRegexSummary; + return true; + } + } + if ( (items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter ) + { + if (m_filter_nav->Get(type_name, filter)) + { + if (matching_category) + *matching_category = m_name.GetCString(); + if (matching_type) + *matching_type = eFormatCategoryItemFilter; + return true; + } + } + if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter ) + { + if (m_regex_filter_nav->Get(type_name, filter)) + { + if (matching_category) + *matching_category = m_name.GetCString(); + if (matching_type) + *matching_type = eFormatCategoryItemRegexFilter; + return true; + } + } +#ifndef LLDB_DISABLE_PYTHON + if ( (items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth ) + { + if (m_synth_nav->Get(type_name, synth)) + { + if (matching_category) + *matching_category = m_name.GetCString(); + if (matching_type) + *matching_type = eFormatCategoryItemSynth; + return true; + } + } + if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth ) + { + if (m_regex_synth_nav->Get(type_name, synth)) + { + if (matching_category) + *matching_category = m_name.GetCString(); + if (matching_type) + *matching_type = eFormatCategoryItemRegexSynth; + return true; + } + } +#endif + return false; +} + +TypeCategoryImpl::SummaryNavigator::MapValueType +TypeCategoryImpl::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp) +{ + SummaryNavigator::MapValueType retval; + + if (type_sp) + { + if (type_sp->IsRegex()) + m_regex_summary_nav->GetExact(ConstString(type_sp->GetName()),retval); + else + m_summary_nav->GetExact(ConstString(type_sp->GetName()),retval); + } + + return retval; +} + +TypeCategoryImpl::FilterNavigator::MapValueType +TypeCategoryImpl::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp) +{ + FilterNavigator::MapValueType retval; + + if (type_sp) + { + if (type_sp->IsRegex()) + m_regex_filter_nav->GetExact(ConstString(type_sp->GetName()),retval); + else + m_filter_nav->GetExact(ConstString(type_sp->GetName()),retval); + } + + return retval; +} + +#ifndef LLDB_DISABLE_PYTHON +TypeCategoryImpl::SynthNavigator::MapValueType +TypeCategoryImpl::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp) +{ + SynthNavigator::MapValueType retval; + + if (type_sp) + { + if (type_sp->IsRegex()) + m_regex_synth_nav->GetExact(ConstString(type_sp->GetName()),retval); + else + m_synth_nav->GetExact(ConstString(type_sp->GetName()),retval); + } + + return retval; +} +#endif + +lldb::TypeNameSpecifierImplSP +TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex (size_t index) +{ + if (index < m_summary_nav->GetCount()) + return m_summary_nav->GetTypeNameSpecifierAtIndex(index); + else + return m_regex_summary_nav->GetTypeNameSpecifierAtIndex(index-m_summary_nav->GetCount()); +} + +TypeCategoryImpl::SummaryNavigator::MapValueType +TypeCategoryImpl::GetSummaryAtIndex (size_t index) +{ + if (index < m_summary_nav->GetCount()) + return m_summary_nav->GetAtIndex(index); + else + return m_regex_summary_nav->GetAtIndex(index-m_summary_nav->GetCount()); +} + +TypeCategoryImpl::FilterNavigator::MapValueType +TypeCategoryImpl::GetFilterAtIndex (size_t index) +{ + if (index < m_filter_nav->GetCount()) + return m_filter_nav->GetAtIndex(index); + else + return m_regex_filter_nav->GetAtIndex(index-m_filter_nav->GetCount()); +} + +lldb::TypeNameSpecifierImplSP +TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex (size_t index) +{ + if (index < m_filter_nav->GetCount()) + return m_filter_nav->GetTypeNameSpecifierAtIndex(index); + else + return m_regex_filter_nav->GetTypeNameSpecifierAtIndex(index-m_filter_nav->GetCount()); +} + +#ifndef LLDB_DISABLE_PYTHON +TypeCategoryImpl::SynthNavigator::MapValueType +TypeCategoryImpl::GetSyntheticAtIndex (size_t index) +{ + if (index < m_synth_nav->GetCount()) + return m_synth_nav->GetAtIndex(index); + else + return m_regex_synth_nav->GetAtIndex(index-m_synth_nav->GetCount()); +} + +lldb::TypeNameSpecifierImplSP +TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex (size_t index) +{ + if (index < m_synth_nav->GetCount()) + return m_synth_nav->GetTypeNameSpecifierAtIndex(index); + else + return m_regex_synth_nav->GetTypeNameSpecifierAtIndex(index - m_synth_nav->GetCount()); +} +#endif + +void +TypeCategoryImpl::Enable (bool value, uint32_t position) +{ + Mutex::Locker locker(m_mutex); + m_enabled = value; + m_enabled_position = position; + if (m_change_listener) + m_change_listener->Changed(); +} |