1 //===-- SBTypeCategory.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/API/SBTypeCategory.h"
12 #include "lldb/API/SBTypeFilter.h"
13 #include "lldb/API/SBTypeFormat.h"
14 #include "lldb/API/SBTypeSummary.h"
15 #include "lldb/API/SBTypeSynthetic.h"
16 #include "lldb/API/SBTypeNameSpecifier.h"
17 #include "lldb/API/SBStream.h"
19 #include "lldb/Core/Debugger.h"
20 #include "lldb/DataFormatters/DataVisualization.h"
21 #include "lldb/Interpreter/CommandInterpreter.h"
22 #include "lldb/Interpreter/ScriptInterpreter.h"
25 using namespace lldb_private;
27 typedef std::pair<lldb::TypeCategoryImplSP,user_id_t> ImplType;
29 SBTypeCategory::SBTypeCategory() :
34 SBTypeCategory::SBTypeCategory (const char* name) :
37 DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
40 SBTypeCategory::SBTypeCategory (const lldb::SBTypeCategory &rhs) :
41 m_opaque_sp(rhs.m_opaque_sp)
45 SBTypeCategory::~SBTypeCategory ()
50 SBTypeCategory::IsValid() const
52 return (m_opaque_sp.get() != NULL);
56 SBTypeCategory::GetEnabled ()
60 return m_opaque_sp->IsEnabled();
64 SBTypeCategory::SetEnabled (bool enabled)
69 DataVisualization::Categories::Enable(m_opaque_sp);
71 DataVisualization::Categories::Disable(m_opaque_sp);
75 SBTypeCategory::GetName()
79 return m_opaque_sp->GetName();
83 SBTypeCategory::GetNumFormats ()
88 return m_opaque_sp->GetTypeFormatsContainer()->GetCount() + m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount();
92 SBTypeCategory::GetNumSummaries ()
96 return m_opaque_sp->GetTypeSummariesContainer()->GetCount() + m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount();
100 SBTypeCategory::GetNumFilters ()
104 return m_opaque_sp->GetTypeFiltersContainer()->GetCount() + m_opaque_sp->GetRegexTypeFiltersContainer()->GetCount();
107 #ifndef LLDB_DISABLE_PYTHON
109 SBTypeCategory::GetNumSynthetics ()
113 return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() + m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount();
117 lldb::SBTypeNameSpecifier
118 SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex (uint32_t index)
121 return SBTypeNameSpecifier();
122 return SBTypeNameSpecifier(m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index));
125 lldb::SBTypeNameSpecifier
126 SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex (uint32_t index)
129 return SBTypeNameSpecifier();
130 return SBTypeNameSpecifier(m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index));
133 lldb::SBTypeNameSpecifier
134 SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex (uint32_t index)
137 return SBTypeNameSpecifier();
138 return SBTypeNameSpecifier(m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index));
141 #ifndef LLDB_DISABLE_PYTHON
142 lldb::SBTypeNameSpecifier
143 SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex (uint32_t index)
146 return SBTypeNameSpecifier();
147 return SBTypeNameSpecifier(m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index));
152 SBTypeCategory::GetFilterForType (SBTypeNameSpecifier spec)
155 return SBTypeFilter();
158 return SBTypeFilter();
160 lldb::SyntheticChildrenSP children_sp;
163 m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(ConstString(spec.GetName()), children_sp);
165 m_opaque_sp->GetTypeFiltersContainer()->GetExact(ConstString(spec.GetName()), children_sp);
168 return lldb::SBTypeFilter();
170 TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp);
172 return lldb::SBTypeFilter(filter_sp);
176 SBTypeCategory::GetFormatForType (SBTypeNameSpecifier spec)
179 return SBTypeFormat();
182 return SBTypeFormat();
184 lldb::TypeFormatImplSP format_sp;
187 m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact(ConstString(spec.GetName()), format_sp);
189 m_opaque_sp->GetTypeFormatsContainer()->GetExact(ConstString(spec.GetName()), format_sp);
192 return lldb::SBTypeFormat();
194 return lldb::SBTypeFormat(format_sp);
197 #ifndef LLDB_DISABLE_PYTHON
199 SBTypeCategory::GetSummaryForType (SBTypeNameSpecifier spec)
202 return SBTypeSummary();
205 return SBTypeSummary();
207 lldb::TypeSummaryImplSP summary_sp;
210 m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact(ConstString(spec.GetName()), summary_sp);
212 m_opaque_sp->GetTypeSummariesContainer()->GetExact(ConstString(spec.GetName()), summary_sp);
215 return lldb::SBTypeSummary();
217 return lldb::SBTypeSummary(summary_sp);
219 #endif // LLDB_DISABLE_PYTHON
221 #ifndef LLDB_DISABLE_PYTHON
223 SBTypeCategory::GetSyntheticForType (SBTypeNameSpecifier spec)
226 return SBTypeSynthetic();
229 return SBTypeSynthetic();
231 lldb::SyntheticChildrenSP children_sp;
234 m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetExact(ConstString(spec.GetName()), children_sp);
236 m_opaque_sp->GetTypeSyntheticsContainer()->GetExact(ConstString(spec.GetName()), children_sp);
239 return lldb::SBTypeSynthetic();
241 ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
243 return lldb::SBTypeSynthetic(synth_sp);
247 #ifndef LLDB_DISABLE_PYTHON
249 SBTypeCategory::GetFilterAtIndex (uint32_t index)
252 return SBTypeFilter();
253 lldb::SyntheticChildrenSP children_sp = m_opaque_sp->GetSyntheticAtIndex((index));
255 if (!children_sp.get())
256 return lldb::SBTypeFilter();
258 TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp);
260 return lldb::SBTypeFilter(filter_sp);
265 SBTypeCategory::GetFormatAtIndex (uint32_t index)
268 return SBTypeFormat();
269 return SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)));
272 #ifndef LLDB_DISABLE_PYTHON
274 SBTypeCategory::GetSummaryAtIndex (uint32_t index)
277 return SBTypeSummary();
278 return SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)));
282 #ifndef LLDB_DISABLE_PYTHON
284 SBTypeCategory::GetSyntheticAtIndex (uint32_t index)
287 return SBTypeSynthetic();
288 lldb::SyntheticChildrenSP children_sp = m_opaque_sp->GetSyntheticAtIndex((index));
290 if (!children_sp.get())
291 return lldb::SBTypeSynthetic();
293 ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
295 return lldb::SBTypeSynthetic(synth_sp);
300 SBTypeCategory::AddTypeFormat (SBTypeNameSpecifier type_name,
306 if (!type_name.IsValid())
309 if (!format.IsValid())
312 if (type_name.IsRegex())
313 m_opaque_sp->GetRegexTypeFormatsContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), format.GetSP());
315 m_opaque_sp->GetTypeFormatsContainer()->Add(ConstString(type_name.GetName()), format.GetSP());
321 SBTypeCategory::DeleteTypeFormat (SBTypeNameSpecifier type_name)
326 if (!type_name.IsValid())
329 if (type_name.IsRegex())
330 return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(ConstString(type_name.GetName()));
332 return m_opaque_sp->GetTypeFormatsContainer()->Delete(ConstString(type_name.GetName()));
335 #ifndef LLDB_DISABLE_PYTHON
337 SBTypeCategory::AddTypeSummary (SBTypeNameSpecifier type_name,
338 SBTypeSummary summary)
343 if (!type_name.IsValid())
346 if (!summary.IsValid())
349 // FIXME: we need to iterate over all the Debugger objects and have each of them contain a copy of the function
350 // since we currently have formatters live in a global space, while Python code lives in a specific Debugger-related environment
351 // this should eventually be fixed by deciding a final location in the LLDB object space for formatters
352 if (summary.IsFunctionCode())
354 const void *name_token = (const void*)ConstString(type_name.GetName()).GetCString();
355 const char* script = summary.GetData();
356 StringList input; input.SplitIntoLines(script, strlen(script));
357 uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
358 bool need_set = true;
363 DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
366 ScriptInterpreter* interpreter_ptr = debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
370 if (interpreter_ptr->GenerateTypeScriptFunction(input, output, name_token) && !output.empty())
375 summary.SetFunctionName(output.c_str());
383 if (type_name.IsRegex())
384 m_opaque_sp->GetRegexTypeSummariesContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), summary.GetSP());
386 m_opaque_sp->GetTypeSummariesContainer()->Add(ConstString(type_name.GetName()), summary.GetSP());
393 SBTypeCategory::DeleteTypeSummary (SBTypeNameSpecifier type_name)
398 if (!type_name.IsValid())
401 if (type_name.IsRegex())
402 return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(ConstString(type_name.GetName()));
404 return m_opaque_sp->GetTypeSummariesContainer()->Delete(ConstString(type_name.GetName()));
408 SBTypeCategory::AddTypeFilter (SBTypeNameSpecifier type_name,
414 if (!type_name.IsValid())
417 if (!filter.IsValid())
420 if (type_name.IsRegex())
421 m_opaque_sp->GetRegexTypeFiltersContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), filter.GetSP());
423 m_opaque_sp->GetTypeFiltersContainer()->Add(ConstString(type_name.GetName()), filter.GetSP());
429 SBTypeCategory::DeleteTypeFilter (SBTypeNameSpecifier type_name)
434 if (!type_name.IsValid())
437 if (type_name.IsRegex())
438 return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(ConstString(type_name.GetName()));
440 return m_opaque_sp->GetTypeFiltersContainer()->Delete(ConstString(type_name.GetName()));
443 #ifndef LLDB_DISABLE_PYTHON
445 SBTypeCategory::AddTypeSynthetic (SBTypeNameSpecifier type_name,
446 SBTypeSynthetic synth)
451 if (!type_name.IsValid())
454 if (!synth.IsValid())
457 // FIXME: we need to iterate over all the Debugger objects and have each of them contain a copy of the function
458 // since we currently have formatters live in a global space, while Python code lives in a specific Debugger-related environment
459 // this should eventually be fixed by deciding a final location in the LLDB object space for formatters
460 if (synth.IsClassCode())
462 const void *name_token = (const void*)ConstString(type_name.GetName()).GetCString();
463 const char* script = synth.GetData();
464 StringList input; input.SplitIntoLines(script, strlen(script));
465 uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
466 bool need_set = true;
471 DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
474 ScriptInterpreter* interpreter_ptr = debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
478 if (interpreter_ptr->GenerateTypeSynthClass(input, output, name_token) && !output.empty())
483 synth.SetClassName(output.c_str());
491 if (type_name.IsRegex())
492 m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), synth.GetSP());
494 m_opaque_sp->GetTypeSyntheticsContainer()->Add(ConstString(type_name.GetName()), synth.GetSP());
500 SBTypeCategory::DeleteTypeSynthetic (SBTypeNameSpecifier type_name)
505 if (!type_name.IsValid())
508 if (type_name.IsRegex())
509 return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(ConstString(type_name.GetName()));
511 return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(ConstString(type_name.GetName()));
513 #endif // LLDB_DISABLE_PYTHON
516 SBTypeCategory::GetDescription (lldb::SBStream &description,
517 lldb::DescriptionLevel description_level)
521 description.Printf("Category name: %s\n",GetName());
525 lldb::SBTypeCategory &
526 SBTypeCategory::operator = (const lldb::SBTypeCategory &rhs)
530 m_opaque_sp = rhs.m_opaque_sp;
536 SBTypeCategory::operator == (lldb::SBTypeCategory &rhs)
538 if (IsValid() == false)
539 return !rhs.IsValid();
541 return m_opaque_sp.get() == rhs.m_opaque_sp.get();
546 SBTypeCategory::operator != (lldb::SBTypeCategory &rhs)
548 if (IsValid() == false)
549 return rhs.IsValid();
551 return m_opaque_sp.get() != rhs.m_opaque_sp.get();
554 lldb::TypeCategoryImplSP
555 SBTypeCategory::GetSP ()
558 return lldb::TypeCategoryImplSP();
563 SBTypeCategory::SetSP (const lldb::TypeCategoryImplSP &typecategory_impl_sp)
565 m_opaque_sp = typecategory_impl_sp;
568 SBTypeCategory::SBTypeCategory (const lldb::TypeCategoryImplSP &typecategory_impl_sp) :
569 m_opaque_sp(typecategory_impl_sp)
574 SBTypeCategory::IsDefaultCategory()
579 return (strcmp(m_opaque_sp->GetName(),"default") == 0);