1 //===-- TypeCategory.cpp -------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/lldb-python.h"
12 #include "lldb/DataFormatters/TypeCategory.h"
16 // Other libraries and framework includes
20 using namespace lldb_private;
22 TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener* clist,
24 m_summary_nav(new SummaryNavigator("summary",clist)),
25 m_regex_summary_nav(new RegexSummaryNavigator("regex-summary",clist)),
26 m_filter_nav(new FilterNavigator("filter",clist)),
27 m_regex_filter_nav(new RegexFilterNavigator("regex-filter",clist)),
28 #ifndef LLDB_DISABLE_PYTHON
29 m_synth_nav(new SynthNavigator("synth",clist)),
30 m_regex_synth_nav(new RegexSynthNavigator("regex-synth",clist)),
33 m_change_listener(clist),
34 m_mutex(Mutex::eMutexTypeRecursive),
39 TypeCategoryImpl::Get (ValueObject& valobj,
40 lldb::TypeSummaryImplSP& entry,
41 lldb::DynamicValueType use_dynamic,
46 if (GetSummaryNavigator()->Get(valobj, entry, use_dynamic, reason))
48 bool regex = GetRegexSummaryNavigator()->Get(valobj, entry, use_dynamic, reason);
50 *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
55 TypeCategoryImpl::Get(ValueObject& valobj,
56 lldb::SyntheticChildrenSP& entry_sp,
57 lldb::DynamicValueType use_dynamic,
62 TypeFilterImpl::SharedPointer filter_sp;
63 uint32_t reason_filter = 0;
64 bool regex_filter = false;
65 // first find both Filter and Synth, and then check which is most recent
67 if (!GetFilterNavigator()->Get(valobj, filter_sp, use_dynamic, &reason_filter))
68 regex_filter = GetRegexFilterNavigator()->Get (valobj, filter_sp, use_dynamic, &reason_filter);
70 #ifndef LLDB_DISABLE_PYTHON
71 bool regex_synth = false;
72 uint32_t reason_synth = 0;
73 bool pick_synth = false;
74 ScriptedSyntheticChildren::SharedPointer synth;
75 if (!GetSyntheticNavigator()->Get(valobj, synth, use_dynamic, &reason_synth))
76 regex_synth = GetRegexSyntheticNavigator()->Get (valobj, synth, use_dynamic, &reason_synth);
77 if (!filter_sp.get() && !synth.get())
79 else if (!filter_sp.get() && synth.get())
82 else if (filter_sp.get() && !synth.get())
85 else /*if (filter_sp.get() && synth.get())*/
87 if (filter_sp->GetRevision() > synth->GetRevision())
94 if (regex_synth && reason)
95 *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
101 if (regex_filter && reason)
102 *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
103 entry_sp = filter_sp;
110 entry_sp = filter_sp;
120 TypeCategoryImpl::Clear (FormatCategoryItems items)
122 if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
123 m_summary_nav->Clear();
124 if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
125 m_regex_summary_nav->Clear();
126 if ( (items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter )
127 m_filter_nav->Clear();
128 if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
129 m_regex_filter_nav->Clear();
130 #ifndef LLDB_DISABLE_PYTHON
131 if ( (items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth )
132 m_synth_nav->Clear();
133 if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
134 m_regex_synth_nav->Clear();
139 TypeCategoryImpl::Delete (ConstString name,
140 FormatCategoryItems items)
142 bool success = false;
143 if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
144 success = m_summary_nav->Delete(name) || success;
145 if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
146 success = m_regex_summary_nav->Delete(name) || success;
147 if ( (items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter )
148 success = m_filter_nav->Delete(name) || success;
149 if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
150 success = m_regex_filter_nav->Delete(name) || success;
151 #ifndef LLDB_DISABLE_PYTHON
152 if ( (items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth )
153 success = m_synth_nav->Delete(name) || success;
154 if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
155 success = m_regex_synth_nav->Delete(name) || success;
161 TypeCategoryImpl::GetCount (FormatCategoryItems items)
164 if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
165 count += m_summary_nav->GetCount();
166 if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
167 count += m_regex_summary_nav->GetCount();
168 if ( (items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter )
169 count += m_filter_nav->GetCount();
170 if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
171 count += m_regex_filter_nav->GetCount();
172 #ifndef LLDB_DISABLE_PYTHON
173 if ( (items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth )
174 count += m_synth_nav->GetCount();
175 if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
176 count += m_regex_synth_nav->GetCount();
182 TypeCategoryImpl::AnyMatches(ConstString type_name,
183 FormatCategoryItems items,
185 const char** matching_category,
186 FormatCategoryItems* matching_type)
188 if (!IsEnabled() && only_enabled)
191 lldb::TypeSummaryImplSP summary;
192 TypeFilterImpl::SharedPointer filter;
193 #ifndef LLDB_DISABLE_PYTHON
194 ScriptedSyntheticChildren::SharedPointer synth;
197 if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
199 if (m_summary_nav->Get(type_name, summary))
201 if (matching_category)
202 *matching_category = m_name.GetCString();
204 *matching_type = eFormatCategoryItemSummary;
208 if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
210 if (m_regex_summary_nav->Get(type_name, summary))
212 if (matching_category)
213 *matching_category = m_name.GetCString();
215 *matching_type = eFormatCategoryItemRegexSummary;
219 if ( (items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter )
221 if (m_filter_nav->Get(type_name, filter))
223 if (matching_category)
224 *matching_category = m_name.GetCString();
226 *matching_type = eFormatCategoryItemFilter;
230 if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
232 if (m_regex_filter_nav->Get(type_name, filter))
234 if (matching_category)
235 *matching_category = m_name.GetCString();
237 *matching_type = eFormatCategoryItemRegexFilter;
241 #ifndef LLDB_DISABLE_PYTHON
242 if ( (items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth )
244 if (m_synth_nav->Get(type_name, synth))
246 if (matching_category)
247 *matching_category = m_name.GetCString();
249 *matching_type = eFormatCategoryItemSynth;
253 if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
255 if (m_regex_synth_nav->Get(type_name, synth))
257 if (matching_category)
258 *matching_category = m_name.GetCString();
260 *matching_type = eFormatCategoryItemRegexSynth;
268 TypeCategoryImpl::SummaryNavigator::MapValueType
269 TypeCategoryImpl::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
271 SummaryNavigator::MapValueType retval;
275 if (type_sp->IsRegex())
276 m_regex_summary_nav->GetExact(ConstString(type_sp->GetName()),retval);
278 m_summary_nav->GetExact(ConstString(type_sp->GetName()),retval);
284 TypeCategoryImpl::FilterNavigator::MapValueType
285 TypeCategoryImpl::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
287 FilterNavigator::MapValueType retval;
291 if (type_sp->IsRegex())
292 m_regex_filter_nav->GetExact(ConstString(type_sp->GetName()),retval);
294 m_filter_nav->GetExact(ConstString(type_sp->GetName()),retval);
300 #ifndef LLDB_DISABLE_PYTHON
301 TypeCategoryImpl::SynthNavigator::MapValueType
302 TypeCategoryImpl::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
304 SynthNavigator::MapValueType retval;
308 if (type_sp->IsRegex())
309 m_regex_synth_nav->GetExact(ConstString(type_sp->GetName()),retval);
311 m_synth_nav->GetExact(ConstString(type_sp->GetName()),retval);
318 lldb::TypeNameSpecifierImplSP
319 TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex (size_t index)
321 if (index < m_summary_nav->GetCount())
322 return m_summary_nav->GetTypeNameSpecifierAtIndex(index);
324 return m_regex_summary_nav->GetTypeNameSpecifierAtIndex(index-m_summary_nav->GetCount());
327 TypeCategoryImpl::SummaryNavigator::MapValueType
328 TypeCategoryImpl::GetSummaryAtIndex (size_t index)
330 if (index < m_summary_nav->GetCount())
331 return m_summary_nav->GetAtIndex(index);
333 return m_regex_summary_nav->GetAtIndex(index-m_summary_nav->GetCount());
336 TypeCategoryImpl::FilterNavigator::MapValueType
337 TypeCategoryImpl::GetFilterAtIndex (size_t index)
339 if (index < m_filter_nav->GetCount())
340 return m_filter_nav->GetAtIndex(index);
342 return m_regex_filter_nav->GetAtIndex(index-m_filter_nav->GetCount());
345 lldb::TypeNameSpecifierImplSP
346 TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex (size_t index)
348 if (index < m_filter_nav->GetCount())
349 return m_filter_nav->GetTypeNameSpecifierAtIndex(index);
351 return m_regex_filter_nav->GetTypeNameSpecifierAtIndex(index-m_filter_nav->GetCount());
354 #ifndef LLDB_DISABLE_PYTHON
355 TypeCategoryImpl::SynthNavigator::MapValueType
356 TypeCategoryImpl::GetSyntheticAtIndex (size_t index)
358 if (index < m_synth_nav->GetCount())
359 return m_synth_nav->GetAtIndex(index);
361 return m_regex_synth_nav->GetAtIndex(index-m_synth_nav->GetCount());
364 lldb::TypeNameSpecifierImplSP
365 TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex (size_t index)
367 if (index < m_synth_nav->GetCount())
368 return m_synth_nav->GetTypeNameSpecifierAtIndex(index);
370 return m_regex_synth_nav->GetTypeNameSpecifierAtIndex(index - m_synth_nav->GetCount());
375 TypeCategoryImpl::Enable (bool value, uint32_t position)
377 Mutex::Locker locker(m_mutex);
379 m_enabled_position = position;
380 if (m_change_listener)
381 m_change_listener->Changed();