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::GetLanguageAtIndex (uint32_t idx)
86 return m_opaque_sp->GetLanguageAtIndex(idx);
87 return lldb::eLanguageTypeUnknown;
91 SBTypeCategory::GetNumLanguages ()
94 return m_opaque_sp->GetNumLanguages();
99 SBTypeCategory::AddLanguage (lldb::LanguageType language)
102 m_opaque_sp->AddLanguage(language);
106 SBTypeCategory::GetNumFormats ()
111 return m_opaque_sp->GetTypeFormatsContainer()->GetCount() + m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount();
115 SBTypeCategory::GetNumSummaries ()
119 return m_opaque_sp->GetTypeSummariesContainer()->GetCount() + m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount();
123 SBTypeCategory::GetNumFilters ()
127 return m_opaque_sp->GetTypeFiltersContainer()->GetCount() + m_opaque_sp->GetRegexTypeFiltersContainer()->GetCount();
130 #ifndef LLDB_DISABLE_PYTHON
132 SBTypeCategory::GetNumSynthetics ()
136 return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() + m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount();
140 lldb::SBTypeNameSpecifier
141 SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex (uint32_t index)
144 return SBTypeNameSpecifier();
145 return SBTypeNameSpecifier(m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index));
148 lldb::SBTypeNameSpecifier
149 SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex (uint32_t index)
152 return SBTypeNameSpecifier();
153 return SBTypeNameSpecifier(m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index));
156 lldb::SBTypeNameSpecifier
157 SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex (uint32_t index)
160 return SBTypeNameSpecifier();
161 return SBTypeNameSpecifier(m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index));
164 #ifndef LLDB_DISABLE_PYTHON
165 lldb::SBTypeNameSpecifier
166 SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex (uint32_t index)
169 return SBTypeNameSpecifier();
170 return SBTypeNameSpecifier(m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index));
175 SBTypeCategory::GetFilterForType (SBTypeNameSpecifier spec)
178 return SBTypeFilter();
181 return SBTypeFilter();
183 lldb::TypeFilterImplSP children_sp;
186 m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(ConstString(spec.GetName()), children_sp);
188 m_opaque_sp->GetTypeFiltersContainer()->GetExact(ConstString(spec.GetName()), children_sp);
191 return lldb::SBTypeFilter();
193 TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp);
195 return lldb::SBTypeFilter(filter_sp);
199 SBTypeCategory::GetFormatForType (SBTypeNameSpecifier spec)
202 return SBTypeFormat();
205 return SBTypeFormat();
207 lldb::TypeFormatImplSP format_sp;
210 m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact(ConstString(spec.GetName()), format_sp);
212 m_opaque_sp->GetTypeFormatsContainer()->GetExact(ConstString(spec.GetName()), format_sp);
215 return lldb::SBTypeFormat();
217 return lldb::SBTypeFormat(format_sp);
220 #ifndef LLDB_DISABLE_PYTHON
222 SBTypeCategory::GetSummaryForType (SBTypeNameSpecifier spec)
225 return SBTypeSummary();
228 return SBTypeSummary();
230 lldb::TypeSummaryImplSP summary_sp;
233 m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact(ConstString(spec.GetName()), summary_sp);
235 m_opaque_sp->GetTypeSummariesContainer()->GetExact(ConstString(spec.GetName()), summary_sp);
238 return lldb::SBTypeSummary();
240 return lldb::SBTypeSummary(summary_sp);
242 #endif // LLDB_DISABLE_PYTHON
244 #ifndef LLDB_DISABLE_PYTHON
246 SBTypeCategory::GetSyntheticForType (SBTypeNameSpecifier spec)
249 return SBTypeSynthetic();
252 return SBTypeSynthetic();
254 lldb::SyntheticChildrenSP children_sp;
257 m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetExact(ConstString(spec.GetName()), children_sp);
259 m_opaque_sp->GetTypeSyntheticsContainer()->GetExact(ConstString(spec.GetName()), children_sp);
262 return lldb::SBTypeSynthetic();
264 ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
266 return lldb::SBTypeSynthetic(synth_sp);
270 #ifndef LLDB_DISABLE_PYTHON
272 SBTypeCategory::GetFilterAtIndex (uint32_t index)
275 return SBTypeFilter();
276 lldb::SyntheticChildrenSP children_sp = m_opaque_sp->GetSyntheticAtIndex((index));
278 if (!children_sp.get())
279 return lldb::SBTypeFilter();
281 TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(children_sp);
283 return lldb::SBTypeFilter(filter_sp);
288 SBTypeCategory::GetFormatAtIndex (uint32_t index)
291 return SBTypeFormat();
292 return SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)));
295 #ifndef LLDB_DISABLE_PYTHON
297 SBTypeCategory::GetSummaryAtIndex (uint32_t index)
300 return SBTypeSummary();
301 return SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)));
305 #ifndef LLDB_DISABLE_PYTHON
307 SBTypeCategory::GetSyntheticAtIndex (uint32_t index)
310 return SBTypeSynthetic();
311 lldb::SyntheticChildrenSP children_sp = m_opaque_sp->GetSyntheticAtIndex((index));
313 if (!children_sp.get())
314 return lldb::SBTypeSynthetic();
316 ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
318 return lldb::SBTypeSynthetic(synth_sp);
323 SBTypeCategory::AddTypeFormat (SBTypeNameSpecifier type_name,
329 if (!type_name.IsValid())
332 if (!format.IsValid())
335 if (type_name.IsRegex())
336 m_opaque_sp->GetRegexTypeFormatsContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), format.GetSP());
338 m_opaque_sp->GetTypeFormatsContainer()->Add(ConstString(type_name.GetName()), format.GetSP());
344 SBTypeCategory::DeleteTypeFormat (SBTypeNameSpecifier type_name)
349 if (!type_name.IsValid())
352 if (type_name.IsRegex())
353 return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(ConstString(type_name.GetName()));
355 return m_opaque_sp->GetTypeFormatsContainer()->Delete(ConstString(type_name.GetName()));
358 #ifndef LLDB_DISABLE_PYTHON
360 SBTypeCategory::AddTypeSummary (SBTypeNameSpecifier type_name,
361 SBTypeSummary summary)
366 if (!type_name.IsValid())
369 if (!summary.IsValid())
372 // FIXME: we need to iterate over all the Debugger objects and have each of them contain a copy of the function
373 // since we currently have formatters live in a global space, while Python code lives in a specific Debugger-related environment
374 // this should eventually be fixed by deciding a final location in the LLDB object space for formatters
375 if (summary.IsFunctionCode())
377 const void *name_token = (const void*)ConstString(type_name.GetName()).GetCString();
378 const char* script = summary.GetData();
379 StringList input; input.SplitIntoLines(script, strlen(script));
380 uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
381 bool need_set = true;
386 DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
389 ScriptInterpreter* interpreter_ptr = debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
393 if (interpreter_ptr->GenerateTypeScriptFunction(input, output, name_token) && !output.empty())
398 summary.SetFunctionName(output.c_str());
406 if (type_name.IsRegex())
407 m_opaque_sp->GetRegexTypeSummariesContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), summary.GetSP());
409 m_opaque_sp->GetTypeSummariesContainer()->Add(ConstString(type_name.GetName()), summary.GetSP());
416 SBTypeCategory::DeleteTypeSummary (SBTypeNameSpecifier type_name)
421 if (!type_name.IsValid())
424 if (type_name.IsRegex())
425 return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(ConstString(type_name.GetName()));
427 return m_opaque_sp->GetTypeSummariesContainer()->Delete(ConstString(type_name.GetName()));
431 SBTypeCategory::AddTypeFilter (SBTypeNameSpecifier type_name,
437 if (!type_name.IsValid())
440 if (!filter.IsValid())
443 if (type_name.IsRegex())
444 m_opaque_sp->GetRegexTypeFiltersContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), filter.GetSP());
446 m_opaque_sp->GetTypeFiltersContainer()->Add(ConstString(type_name.GetName()), filter.GetSP());
452 SBTypeCategory::DeleteTypeFilter (SBTypeNameSpecifier type_name)
457 if (!type_name.IsValid())
460 if (type_name.IsRegex())
461 return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(ConstString(type_name.GetName()));
463 return m_opaque_sp->GetTypeFiltersContainer()->Delete(ConstString(type_name.GetName()));
466 #ifndef LLDB_DISABLE_PYTHON
468 SBTypeCategory::AddTypeSynthetic (SBTypeNameSpecifier type_name,
469 SBTypeSynthetic synth)
474 if (!type_name.IsValid())
477 if (!synth.IsValid())
480 // FIXME: we need to iterate over all the Debugger objects and have each of them contain a copy of the function
481 // since we currently have formatters live in a global space, while Python code lives in a specific Debugger-related environment
482 // this should eventually be fixed by deciding a final location in the LLDB object space for formatters
483 if (synth.IsClassCode())
485 const void *name_token = (const void*)ConstString(type_name.GetName()).GetCString();
486 const char* script = synth.GetData();
487 StringList input; input.SplitIntoLines(script, strlen(script));
488 uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
489 bool need_set = true;
494 DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
497 ScriptInterpreter* interpreter_ptr = debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
501 if (interpreter_ptr->GenerateTypeSynthClass(input, output, name_token) && !output.empty())
506 synth.SetClassName(output.c_str());
514 if (type_name.IsRegex())
515 m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(lldb::RegularExpressionSP(new RegularExpression(type_name.GetName())), synth.GetSP());
517 m_opaque_sp->GetTypeSyntheticsContainer()->Add(ConstString(type_name.GetName()), synth.GetSP());
523 SBTypeCategory::DeleteTypeSynthetic (SBTypeNameSpecifier type_name)
528 if (!type_name.IsValid())
531 if (type_name.IsRegex())
532 return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(ConstString(type_name.GetName()));
534 return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(ConstString(type_name.GetName()));
536 #endif // LLDB_DISABLE_PYTHON
539 SBTypeCategory::GetDescription (lldb::SBStream &description,
540 lldb::DescriptionLevel description_level)
544 description.Printf("Category name: %s\n",GetName());
548 lldb::SBTypeCategory &
549 SBTypeCategory::operator = (const lldb::SBTypeCategory &rhs)
553 m_opaque_sp = rhs.m_opaque_sp;
559 SBTypeCategory::operator == (lldb::SBTypeCategory &rhs)
561 if (IsValid() == false)
562 return !rhs.IsValid();
564 return m_opaque_sp.get() == rhs.m_opaque_sp.get();
569 SBTypeCategory::operator != (lldb::SBTypeCategory &rhs)
571 if (IsValid() == false)
572 return rhs.IsValid();
574 return m_opaque_sp.get() != rhs.m_opaque_sp.get();
577 lldb::TypeCategoryImplSP
578 SBTypeCategory::GetSP ()
581 return lldb::TypeCategoryImplSP();
586 SBTypeCategory::SetSP (const lldb::TypeCategoryImplSP &typecategory_impl_sp)
588 m_opaque_sp = typecategory_impl_sp;
591 SBTypeCategory::SBTypeCategory (const lldb::TypeCategoryImplSP &typecategory_impl_sp) :
592 m_opaque_sp(typecategory_impl_sp)
597 SBTypeCategory::IsDefaultCategory()
602 return (strcmp(m_opaque_sp->GetName(),"default") == 0);