1 //===-- SBTypeCategory.cpp ----------------------------------------*- C++
4 // The LLVM Compiler Infrastructure
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 #include "lldb/API/SBTypeCategory.h"
13 #include "lldb/API/SBStream.h"
14 #include "lldb/API/SBTypeFilter.h"
15 #include "lldb/API/SBTypeFormat.h"
16 #include "lldb/API/SBTypeNameSpecifier.h"
17 #include "lldb/API/SBTypeSummary.h"
18 #include "lldb/API/SBTypeSynthetic.h"
20 #include "lldb/Core/Debugger.h"
21 #include "lldb/DataFormatters/DataVisualization.h"
22 #include "lldb/Interpreter/CommandInterpreter.h"
23 #include "lldb/Interpreter/ScriptInterpreter.h"
26 using namespace lldb_private;
28 typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType;
30 SBTypeCategory::SBTypeCategory() : m_opaque_sp() {}
32 SBTypeCategory::SBTypeCategory(const char *name) : m_opaque_sp() {
33 DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
36 SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
37 : m_opaque_sp(rhs.m_opaque_sp) {}
39 SBTypeCategory::~SBTypeCategory() {}
41 bool SBTypeCategory::IsValid() const { return (m_opaque_sp.get() != NULL); }
43 bool SBTypeCategory::GetEnabled() {
46 return m_opaque_sp->IsEnabled();
49 void SBTypeCategory::SetEnabled(bool enabled) {
53 DataVisualization::Categories::Enable(m_opaque_sp);
55 DataVisualization::Categories::Disable(m_opaque_sp);
58 const char *SBTypeCategory::GetName() {
61 return m_opaque_sp->GetName();
64 lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
66 return m_opaque_sp->GetLanguageAtIndex(idx);
67 return lldb::eLanguageTypeUnknown;
70 uint32_t SBTypeCategory::GetNumLanguages() {
72 return m_opaque_sp->GetNumLanguages();
76 void SBTypeCategory::AddLanguage(lldb::LanguageType language) {
78 m_opaque_sp->AddLanguage(language);
81 uint32_t SBTypeCategory::GetNumFormats() {
85 return m_opaque_sp->GetTypeFormatsContainer()->GetCount() +
86 m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount();
89 uint32_t SBTypeCategory::GetNumSummaries() {
92 return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +
93 m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount();
96 uint32_t SBTypeCategory::GetNumFilters() {
99 return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +
100 m_opaque_sp->GetRegexTypeFiltersContainer()->GetCount();
103 #ifndef LLDB_DISABLE_PYTHON
104 uint32_t SBTypeCategory::GetNumSynthetics() {
107 return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() +
108 m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount();
112 lldb::SBTypeNameSpecifier
113 SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
115 return SBTypeNameSpecifier();
116 return SBTypeNameSpecifier(
117 m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index));
120 lldb::SBTypeNameSpecifier
121 SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
123 return SBTypeNameSpecifier();
124 return SBTypeNameSpecifier(
125 m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index));
128 lldb::SBTypeNameSpecifier
129 SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
131 return SBTypeNameSpecifier();
132 return SBTypeNameSpecifier(
133 m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index));
136 #ifndef LLDB_DISABLE_PYTHON
137 lldb::SBTypeNameSpecifier
138 SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
140 return SBTypeNameSpecifier();
141 return SBTypeNameSpecifier(
142 m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index));
146 SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
148 return SBTypeFilter();
151 return SBTypeFilter();
153 lldb::TypeFilterImplSP children_sp;
156 m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(
157 ConstString(spec.GetName()), children_sp);
159 m_opaque_sp->GetTypeFiltersContainer()->GetExact(
160 ConstString(spec.GetName()), children_sp);
163 return lldb::SBTypeFilter();
165 TypeFilterImplSP filter_sp =
166 std::static_pointer_cast<TypeFilterImpl>(children_sp);
168 return lldb::SBTypeFilter(filter_sp);
170 SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
172 return SBTypeFormat();
175 return SBTypeFormat();
177 lldb::TypeFormatImplSP format_sp;
180 m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact(
181 ConstString(spec.GetName()), format_sp);
183 m_opaque_sp->GetTypeFormatsContainer()->GetExact(
184 ConstString(spec.GetName()), format_sp);
187 return lldb::SBTypeFormat();
189 return lldb::SBTypeFormat(format_sp);
192 #ifndef LLDB_DISABLE_PYTHON
193 SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
195 return SBTypeSummary();
198 return SBTypeSummary();
200 lldb::TypeSummaryImplSP summary_sp;
203 m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact(
204 ConstString(spec.GetName()), summary_sp);
206 m_opaque_sp->GetTypeSummariesContainer()->GetExact(
207 ConstString(spec.GetName()), summary_sp);
210 return lldb::SBTypeSummary();
212 return lldb::SBTypeSummary(summary_sp);
214 #endif // LLDB_DISABLE_PYTHON
216 #ifndef LLDB_DISABLE_PYTHON
217 SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
219 return SBTypeSynthetic();
222 return SBTypeSynthetic();
224 lldb::SyntheticChildrenSP children_sp;
227 m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetExact(
228 ConstString(spec.GetName()), children_sp);
230 m_opaque_sp->GetTypeSyntheticsContainer()->GetExact(
231 ConstString(spec.GetName()), children_sp);
234 return lldb::SBTypeSynthetic();
236 ScriptedSyntheticChildrenSP synth_sp =
237 std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
239 return lldb::SBTypeSynthetic(synth_sp);
243 #ifndef LLDB_DISABLE_PYTHON
244 SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
246 return SBTypeFilter();
247 lldb::SyntheticChildrenSP children_sp =
248 m_opaque_sp->GetSyntheticAtIndex((index));
250 if (!children_sp.get())
251 return lldb::SBTypeFilter();
253 TypeFilterImplSP filter_sp =
254 std::static_pointer_cast<TypeFilterImpl>(children_sp);
256 return lldb::SBTypeFilter(filter_sp);
260 SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
262 return SBTypeFormat();
263 return SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)));
266 #ifndef LLDB_DISABLE_PYTHON
267 SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
269 return SBTypeSummary();
270 return SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)));
274 #ifndef LLDB_DISABLE_PYTHON
275 SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
277 return SBTypeSynthetic();
278 lldb::SyntheticChildrenSP children_sp =
279 m_opaque_sp->GetSyntheticAtIndex((index));
281 if (!children_sp.get())
282 return lldb::SBTypeSynthetic();
284 ScriptedSyntheticChildrenSP synth_sp =
285 std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
287 return lldb::SBTypeSynthetic(synth_sp);
291 bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
292 SBTypeFormat format) {
296 if (!type_name.IsValid())
299 if (!format.IsValid())
302 if (type_name.IsRegex())
303 m_opaque_sp->GetRegexTypeFormatsContainer()->Add(
304 lldb::RegularExpressionSP(new RegularExpression(
305 llvm::StringRef::withNullAsEmpty(type_name.GetName()))),
308 m_opaque_sp->GetTypeFormatsContainer()->Add(
309 ConstString(type_name.GetName()), format.GetSP());
314 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
318 if (!type_name.IsValid())
321 if (type_name.IsRegex())
322 return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(
323 ConstString(type_name.GetName()));
325 return m_opaque_sp->GetTypeFormatsContainer()->Delete(
326 ConstString(type_name.GetName()));
329 #ifndef LLDB_DISABLE_PYTHON
330 bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
331 SBTypeSummary summary) {
335 if (!type_name.IsValid())
338 if (!summary.IsValid())
341 // FIXME: we need to iterate over all the Debugger objects and have each of
342 // them contain a copy of the function
343 // since we currently have formatters live in a global space, while Python
344 // code lives in a specific Debugger-related environment
345 // this should eventually be fixed by deciding a final location in the LLDB
346 // object space for formatters
347 if (summary.IsFunctionCode()) {
348 const void *name_token =
349 (const void *)ConstString(type_name.GetName()).GetCString();
350 const char *script = summary.GetData();
352 input.SplitIntoLines(script, strlen(script));
353 uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
354 bool need_set = true;
355 for (uint32_t j = 0; j < num_debuggers; j++) {
356 DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
358 ScriptInterpreter *interpreter_ptr =
359 debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
360 if (interpreter_ptr) {
362 if (interpreter_ptr->GenerateTypeScriptFunction(input, output,
367 summary.SetFunctionName(output.c_str());
375 if (type_name.IsRegex())
376 m_opaque_sp->GetRegexTypeSummariesContainer()->Add(
377 lldb::RegularExpressionSP(new RegularExpression(
378 llvm::StringRef::withNullAsEmpty(type_name.GetName()))),
381 m_opaque_sp->GetTypeSummariesContainer()->Add(
382 ConstString(type_name.GetName()), summary.GetSP());
388 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
392 if (!type_name.IsValid())
395 if (type_name.IsRegex())
396 return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(
397 ConstString(type_name.GetName()));
399 return m_opaque_sp->GetTypeSummariesContainer()->Delete(
400 ConstString(type_name.GetName()));
403 bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
404 SBTypeFilter filter) {
408 if (!type_name.IsValid())
411 if (!filter.IsValid())
414 if (type_name.IsRegex())
415 m_opaque_sp->GetRegexTypeFiltersContainer()->Add(
416 lldb::RegularExpressionSP(new RegularExpression(
417 llvm::StringRef::withNullAsEmpty(type_name.GetName()))),
420 m_opaque_sp->GetTypeFiltersContainer()->Add(
421 ConstString(type_name.GetName()), filter.GetSP());
426 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
430 if (!type_name.IsValid())
433 if (type_name.IsRegex())
434 return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(
435 ConstString(type_name.GetName()));
437 return m_opaque_sp->GetTypeFiltersContainer()->Delete(
438 ConstString(type_name.GetName()));
441 #ifndef LLDB_DISABLE_PYTHON
442 bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
443 SBTypeSynthetic synth) {
447 if (!type_name.IsValid())
450 if (!synth.IsValid())
453 // FIXME: we need to iterate over all the Debugger objects and have each of
454 // them contain a copy of the function
455 // since we currently have formatters live in a global space, while Python
456 // code lives in a specific Debugger-related environment
457 // this should eventually be fixed by deciding a final location in the LLDB
458 // object space for formatters
459 if (synth.IsClassCode()) {
460 const void *name_token =
461 (const void *)ConstString(type_name.GetName()).GetCString();
462 const char *script = synth.GetData();
464 input.SplitIntoLines(script, strlen(script));
465 uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
466 bool need_set = true;
467 for (uint32_t j = 0; j < num_debuggers; j++) {
468 DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
470 ScriptInterpreter *interpreter_ptr =
471 debugger_sp->GetCommandInterpreter().GetScriptInterpreter();
472 if (interpreter_ptr) {
474 if (interpreter_ptr->GenerateTypeSynthClass(input, output,
479 synth.SetClassName(output.c_str());
487 if (type_name.IsRegex())
488 m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(
489 lldb::RegularExpressionSP(new RegularExpression(
490 llvm::StringRef::withNullAsEmpty(type_name.GetName()))),
493 m_opaque_sp->GetTypeSyntheticsContainer()->Add(
494 ConstString(type_name.GetName()), synth.GetSP());
499 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
503 if (!type_name.IsValid())
506 if (type_name.IsRegex())
507 return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(
508 ConstString(type_name.GetName()));
510 return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(
511 ConstString(type_name.GetName()));
513 #endif // LLDB_DISABLE_PYTHON
515 bool SBTypeCategory::GetDescription(lldb::SBStream &description,
516 lldb::DescriptionLevel description_level) {
519 description.Printf("Category name: %s\n", GetName());
523 lldb::SBTypeCategory &SBTypeCategory::
524 operator=(const lldb::SBTypeCategory &rhs) {
526 m_opaque_sp = rhs.m_opaque_sp;
531 bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
532 if (IsValid() == false)
533 return !rhs.IsValid();
535 return m_opaque_sp.get() == rhs.m_opaque_sp.get();
538 bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
539 if (IsValid() == false)
540 return rhs.IsValid();
542 return m_opaque_sp.get() != rhs.m_opaque_sp.get();
545 lldb::TypeCategoryImplSP SBTypeCategory::GetSP() {
547 return lldb::TypeCategoryImplSP();
551 void SBTypeCategory::SetSP(
552 const lldb::TypeCategoryImplSP &typecategory_impl_sp) {
553 m_opaque_sp = typecategory_impl_sp;
556 SBTypeCategory::SBTypeCategory(
557 const lldb::TypeCategoryImplSP &typecategory_impl_sp)
558 : m_opaque_sp(typecategory_impl_sp) {}
560 bool SBTypeCategory::IsDefaultCategory() {
564 return (strcmp(m_opaque_sp->GetName(), "default") == 0);