LLDB  mainline
SBTypeCategory.cpp
Go to the documentation of this file.
1 //===-- SBTypeCategory.cpp ------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 #include "SBReproducerPrivate.h"
11 
12 #include "lldb/API/SBStream.h"
13 #include "lldb/API/SBTypeFilter.h"
14 #include "lldb/API/SBTypeFormat.h"
16 #include "lldb/API/SBTypeSummary.h"
18 
19 #include "lldb/Core/Debugger.h"
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 
27 typedef std::pair<lldb::TypeCategoryImplSP, user_id_t> ImplType;
28 
29 SBTypeCategory::SBTypeCategory() : m_opaque_sp() {
31 }
32 
33 SBTypeCategory::SBTypeCategory(const char *name) : m_opaque_sp() {
34  DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
35 }
36 
38  : m_opaque_sp(rhs.m_opaque_sp) {
40 }
41 
43 
46  return this->operator bool();
47 }
48 SBTypeCategory::operator bool() const {
50 
51  return (m_opaque_sp.get() != nullptr);
52 }
53 
56 
57  if (!IsValid())
58  return false;
59  return m_opaque_sp->IsEnabled();
60 }
61 
62 void SBTypeCategory::SetEnabled(bool enabled) {
63  LLDB_RECORD_METHOD(void, SBTypeCategory, SetEnabled, (bool), enabled);
64 
65  if (!IsValid())
66  return;
67  if (enabled)
68  DataVisualization::Categories::Enable(m_opaque_sp);
69  else
70  DataVisualization::Categories::Disable(m_opaque_sp);
71 }
72 
73 const char *SBTypeCategory::GetName() {
75 
76  if (!IsValid())
77  return nullptr;
78  return m_opaque_sp->GetName();
79 }
80 
83  (uint32_t), idx);
84 
85  if (IsValid())
86  return m_opaque_sp->GetLanguageAtIndex(idx);
88 }
89 
92 
93  if (IsValid())
94  return m_opaque_sp->GetNumLanguages();
95  return 0;
96 }
97 
100  language);
101 
102  if (IsValid())
103  m_opaque_sp->AddLanguage(language);
104 }
105 
108 
109  if (!IsValid())
110  return 0;
111 
112  return m_opaque_sp->GetTypeFormatsContainer()->GetCount() +
113  m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount();
114 }
115 
118 
119  if (!IsValid())
120  return 0;
121  return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +
122  m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount();
123 }
124 
127 
128  if (!IsValid())
129  return 0;
130  return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +
131  m_opaque_sp->GetRegexTypeFiltersContainer()->GetCount();
132 }
133 
136 
137  if (!IsValid())
138  return 0;
139  return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() +
140  m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount();
141 }
142 
147 
148  if (!IsValid())
151  m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index)));
152 }
153 
158 
159  if (!IsValid())
162  m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index)));
163 }
164 
169 
170  if (!IsValid())
173  m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index)));
174 }
175 
180  index);
181 
182  if (!IsValid())
185  m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index)));
186 }
187 
190  (lldb::SBTypeNameSpecifier), spec);
191 
192  if (!IsValid())
194 
195  if (!spec.IsValid())
197 
198  lldb::TypeFilterImplSP children_sp;
199 
200  if (spec.IsRegex())
201  m_opaque_sp->GetRegexTypeFiltersContainer()->GetExact(
202  ConstString(spec.GetName()), children_sp);
203  else
204  m_opaque_sp->GetTypeFiltersContainer()->GetExact(
205  ConstString(spec.GetName()), children_sp);
206 
207  if (!children_sp)
209 
210  TypeFilterImplSP filter_sp =
211  std::static_pointer_cast<TypeFilterImpl>(children_sp);
212 
213  return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
214 }
217  (lldb::SBTypeNameSpecifier), spec);
218 
219  if (!IsValid())
221 
222  if (!spec.IsValid())
224 
225  lldb::TypeFormatImplSP format_sp;
226 
227  if (spec.IsRegex())
228  m_opaque_sp->GetRegexTypeFormatsContainer()->GetExact(
229  ConstString(spec.GetName()), format_sp);
230  else
231  m_opaque_sp->GetTypeFormatsContainer()->GetExact(
232  ConstString(spec.GetName()), format_sp);
233 
234  if (!format_sp)
236 
237  return LLDB_RECORD_RESULT(lldb::SBTypeFormat(format_sp));
238 }
239 
242  (lldb::SBTypeNameSpecifier), spec);
243 
244  if (!IsValid())
246 
247  if (!spec.IsValid())
249 
250  lldb::TypeSummaryImplSP summary_sp;
251 
252  if (spec.IsRegex())
253  m_opaque_sp->GetRegexTypeSummariesContainer()->GetExact(
254  ConstString(spec.GetName()), summary_sp);
255  else
256  m_opaque_sp->GetTypeSummariesContainer()->GetExact(
257  ConstString(spec.GetName()), summary_sp);
258 
259  if (!summary_sp)
261 
262  return LLDB_RECORD_RESULT(lldb::SBTypeSummary(summary_sp));
263 }
264 
267  (lldb::SBTypeNameSpecifier), spec);
268 
269  if (!IsValid())
271 
272  if (!spec.IsValid())
274 
275  lldb::SyntheticChildrenSP children_sp;
276 
277  if (spec.IsRegex())
278  m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetExact(
279  ConstString(spec.GetName()), children_sp);
280  else
281  m_opaque_sp->GetTypeSyntheticsContainer()->GetExact(
282  ConstString(spec.GetName()), children_sp);
283 
284  if (!children_sp)
286 
287  ScriptedSyntheticChildrenSP synth_sp =
288  std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
289 
290  return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
291 }
292 
295  (uint32_t), index);
296 
297  if (!IsValid())
299  lldb::SyntheticChildrenSP children_sp =
300  m_opaque_sp->GetSyntheticAtIndex((index));
301 
302  if (!children_sp.get())
304 
305  TypeFilterImplSP filter_sp =
306  std::static_pointer_cast<TypeFilterImpl>(children_sp);
307 
308  return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
309 }
310 
313  (uint32_t), index);
314 
315  if (!IsValid())
317  return LLDB_RECORD_RESULT(
318  SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index))));
319 }
320 
323  (uint32_t), index);
324 
325  if (!IsValid())
327  return LLDB_RECORD_RESULT(
328  SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index))));
329 }
330 
333  (uint32_t), index);
334 
335  if (!IsValid())
337  lldb::SyntheticChildrenSP children_sp =
338  m_opaque_sp->GetSyntheticAtIndex((index));
339 
340  if (!children_sp.get())
342 
343  ScriptedSyntheticChildrenSP synth_sp =
344  std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
345 
346  return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic(synth_sp));
347 }
348 
350  SBTypeFormat format) {
353  format);
354 
355  if (!IsValid())
356  return false;
357 
358  if (!type_name.IsValid())
359  return false;
360 
361  if (!format.IsValid())
362  return false;
363 
364  if (type_name.IsRegex())
365  m_opaque_sp->GetRegexTypeFormatsContainer()->Add(
366  RegularExpression(type_name.GetName()), format.GetSP());
367  else
368  m_opaque_sp->GetTypeFormatsContainer()->Add(
369  ConstString(type_name.GetName()), format.GetSP());
370 
371  return true;
372 }
373 
376  (lldb::SBTypeNameSpecifier), type_name);
377 
378  if (!IsValid())
379  return false;
380 
381  if (!type_name.IsValid())
382  return false;
383 
384  if (type_name.IsRegex())
385  return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(
386  ConstString(type_name.GetName()));
387  else
388  return m_opaque_sp->GetTypeFormatsContainer()->Delete(
389  ConstString(type_name.GetName()));
390 }
391 
393  SBTypeSummary summary) {
396  type_name, summary);
397 
398  if (!IsValid())
399  return false;
400 
401  if (!type_name.IsValid())
402  return false;
403 
404  if (!summary.IsValid())
405  return false;
406 
407  // FIXME: we need to iterate over all the Debugger objects and have each of
408  // them contain a copy of the function
409  // since we currently have formatters live in a global space, while Python
410  // code lives in a specific Debugger-related environment this should
411  // eventually be fixed by deciding a final location in the LLDB object space
412  // for formatters
413  if (summary.IsFunctionCode()) {
414  const void *name_token =
415  (const void *)ConstString(type_name.GetName()).GetCString();
416  const char *script = summary.GetData();
417  StringList input;
418  input.SplitIntoLines(script, strlen(script));
420  bool need_set = true;
421  for (uint32_t j = 0; j < num_debuggers; j++) {
422  DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
423  if (debugger_sp) {
424  ScriptInterpreter *interpreter_ptr =
425  debugger_sp->GetScriptInterpreter();
426  if (interpreter_ptr) {
427  std::string output;
428  if (interpreter_ptr->GenerateTypeScriptFunction(input, output,
429  name_token) &&
430  !output.empty()) {
431  if (need_set) {
432  need_set = false;
433  summary.SetFunctionName(output.c_str());
434  }
435  }
436  }
437  }
438  }
439  }
440 
441  if (type_name.IsRegex())
442  m_opaque_sp->GetRegexTypeSummariesContainer()->Add(
443  RegularExpression(type_name.GetName()), summary.GetSP());
444  else
445  m_opaque_sp->GetTypeSummariesContainer()->Add(
446  ConstString(type_name.GetName()), summary.GetSP());
447 
448  return true;
449 }
450 
453  (lldb::SBTypeNameSpecifier), type_name);
454 
455  if (!IsValid())
456  return false;
457 
458  if (!type_name.IsValid())
459  return false;
460 
461  if (type_name.IsRegex())
462  return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(
463  ConstString(type_name.GetName()));
464  else
465  return m_opaque_sp->GetTypeSummariesContainer()->Delete(
466  ConstString(type_name.GetName()));
467 }
468 
470  SBTypeFilter filter) {
473  filter);
474 
475  if (!IsValid())
476  return false;
477 
478  if (!type_name.IsValid())
479  return false;
480 
481  if (!filter.IsValid())
482  return false;
483 
484  if (type_name.IsRegex())
485  m_opaque_sp->GetRegexTypeFiltersContainer()->Add(
486  RegularExpression(type_name.GetName()), filter.GetSP());
487  else
488  m_opaque_sp->GetTypeFiltersContainer()->Add(
489  ConstString(type_name.GetName()), filter.GetSP());
490 
491  return true;
492 }
493 
496  (lldb::SBTypeNameSpecifier), type_name);
497 
498  if (!IsValid())
499  return false;
500 
501  if (!type_name.IsValid())
502  return false;
503 
504  if (type_name.IsRegex())
505  return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(
506  ConstString(type_name.GetName()));
507  else
508  return m_opaque_sp->GetTypeFiltersContainer()->Delete(
509  ConstString(type_name.GetName()));
510 }
511 
513  SBTypeSynthetic synth) {
516  type_name, synth);
517 
518  if (!IsValid())
519  return false;
520 
521  if (!type_name.IsValid())
522  return false;
523 
524  if (!synth.IsValid())
525  return false;
526 
527  // FIXME: we need to iterate over all the Debugger objects and have each of
528  // them contain a copy of the function
529  // since we currently have formatters live in a global space, while Python
530  // code lives in a specific Debugger-related environment this should
531  // eventually be fixed by deciding a final location in the LLDB object space
532  // for formatters
533  if (synth.IsClassCode()) {
534  const void *name_token =
535  (const void *)ConstString(type_name.GetName()).GetCString();
536  const char *script = synth.GetData();
537  StringList input;
538  input.SplitIntoLines(script, strlen(script));
540  bool need_set = true;
541  for (uint32_t j = 0; j < num_debuggers; j++) {
542  DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
543  if (debugger_sp) {
544  ScriptInterpreter *interpreter_ptr =
545  debugger_sp->GetScriptInterpreter();
546  if (interpreter_ptr) {
547  std::string output;
548  if (interpreter_ptr->GenerateTypeSynthClass(input, output,
549  name_token) &&
550  !output.empty()) {
551  if (need_set) {
552  need_set = false;
553  synth.SetClassName(output.c_str());
554  }
555  }
556  }
557  }
558  }
559  }
560 
561  if (type_name.IsRegex())
562  m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(
563  RegularExpression(type_name.GetName()), synth.GetSP());
564  else
565  m_opaque_sp->GetTypeSyntheticsContainer()->Add(
566  ConstString(type_name.GetName()), synth.GetSP());
567 
568  return true;
569 }
570 
573  (lldb::SBTypeNameSpecifier), type_name);
574 
575  if (!IsValid())
576  return false;
577 
578  if (!type_name.IsValid())
579  return false;
580 
581  if (type_name.IsRegex())
582  return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(
583  ConstString(type_name.GetName()));
584  else
585  return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(
586  ConstString(type_name.GetName()));
587 }
588 
590  lldb::DescriptionLevel description_level) {
592  (lldb::SBStream &, lldb::DescriptionLevel), description,
593  description_level);
594 
595  if (!IsValid())
596  return false;
597  description.Printf("Category name: %s\n", GetName());
598  return true;
599 }
600 
604  SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
605  rhs);
606 
607  if (this != &rhs) {
608  m_opaque_sp = rhs.m_opaque_sp;
609  }
610  return LLDB_RECORD_RESULT(*this);
611 }
612 
615  rhs);
616 
617  if (!IsValid())
618  return !rhs.IsValid();
619 
620  return m_opaque_sp.get() == rhs.m_opaque_sp.get();
621 }
622 
625  rhs);
626 
627  if (!IsValid())
628  return rhs.IsValid();
629 
630  return m_opaque_sp.get() != rhs.m_opaque_sp.get();
631 }
632 
633 lldb::TypeCategoryImplSP SBTypeCategory::GetSP() {
634  if (!IsValid())
635  return lldb::TypeCategoryImplSP();
636  return m_opaque_sp;
637 }
638 
640  const lldb::TypeCategoryImplSP &typecategory_impl_sp) {
641  m_opaque_sp = typecategory_impl_sp;
642 }
643 
645  const lldb::TypeCategoryImplSP &typecategory_impl_sp)
646  : m_opaque_sp(typecategory_impl_sp) {}
647 
649  if (!IsValid())
650  return false;
651 
652  return (strcmp(m_opaque_sp->GetName(), "default") == 0);
653 }
654 
655 namespace lldb_private {
656 namespace repro {
657 
658 template <>
662  LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
663  LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ());
664  LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
665  LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
666  LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
668  (uint32_t));
669  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
670  LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
672  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ());
673  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ());
674  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ());
675  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ());
677  GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
681  GetSyntheticForType, (lldb::SBTypeNameSpecifier));
683  (uint32_t));
685  (uint32_t));
687  GetSyntheticAtIndex, (uint32_t));
688  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
690  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
692  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
695  GetTypeNameSpecifierForFilterAtIndex, (uint32_t));
697  GetTypeNameSpecifierForFormatAtIndex, (uint32_t));
699  GetTypeNameSpecifierForSummaryAtIndex, (uint32_t));
705  (uint32_t));
706  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
708  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
710  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
712  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
714  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
716  LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
720  SBTypeCategory, operator=,(const lldb::SBTypeCategory &));
722  SBTypeCategory, operator==,(lldb::SBTypeCategory &));
724  SBTypeCategory, operator!=,(lldb::SBTypeCategory &));
725 }
726 
727 }
728 }
lldb::SBTypeSummary::GetSP
lldb::TypeSummaryImplSP GetSP()
Definition: SBTypeSummary.cpp:409
lldb::SBTypeCategory::DeleteTypeSynthetic
bool DeleteTypeSynthetic(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:571
lldb::SBTypeCategory::GetDescription
bool GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level)
Definition: SBTypeCategory.cpp:589
SBTypeSynthetic.h
lldb::SBTypeSynthetic::GetSP
lldb::ScriptedSyntheticChildrenSP GetSP()
Definition: SBTypeSynthetic.cpp:185
lldb::SBTypeNameSpecifier
Definition: SBTypeNameSpecifier.h:17
lldb_private::RegularExpression
Definition: RegularExpression.h:18
lldb::SBTypeFilter
Definition: SBTypeFilter.h:17
lldb::SBStream::Printf
void Printf(const char *format,...) __attribute__((format(printf
Definition: SBStream.cpp:69
lldb::SBTypeCategory::GetFormatAtIndex
SBTypeFormat GetFormatAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:311
SBTypeSummary.h
lldb::SBTypeFilter::GetSP
lldb::TypeFilterImplSP GetSP()
Definition: SBTypeFilter.cpp:169
lldb::SBTypeCategory::SetSP
void SetSP(const lldb::TypeCategoryImplSP &typecategory_impl_sp)
Definition: SBTypeCategory.cpp:639
LLDB_RECORD_RESULT
#define LLDB_RECORD_RESULT(Result)
Definition: ReproducerInstrumentation.h:211
lldb_private::Debugger::GetDebuggerAtIndex
static lldb::DebuggerSP GetDebuggerAtIndex(size_t index)
Definition: Debugger.cpp:1077
LLDB_RECORD_METHOD_CONST_NO_ARGS
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:168
lldb::SBTypeCategory::IsDefaultCategory
bool IsDefaultCategory()
Definition: SBTypeCategory.cpp:648
lldb::SBTypeSynthetic
class LLDB_API SBTypeSynthetic
Definition: SBDefines.h:89
lldb::SBTypeCategory::m_opaque_sp
TypeCategoryImplSP m_opaque_sp
Definition: SBTypeCategory.h:105
lldb::SBTypeCategory::DeleteTypeFilter
bool DeleteTypeFilter(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:494
LLDB_RECORD_METHOD_NO_ARGS
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:165
lldb::SBTypeCategory::GetEnabled
bool GetEnabled()
Definition: SBTypeCategory.cpp:54
lldb::SBTypeSummary
class LLDB_API SBTypeSummary
Definition: SBDefines.h:87
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
LLDB_RECORD_CONSTRUCTOR_NO_ARGS
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)
Definition: ReproducerInstrumentation.h:136
lldb::SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex
SBTypeNameSpecifier GetTypeNameSpecifierForSyntheticAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:177
lldb::SBTypeCategory::GetSummaryForType
SBTypeSummary GetSummaryForType(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:240
lldb::SBTypeCategory::GetSyntheticForType
SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:265
LLDB_REGISTER_METHOD_CONST
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:98
lldb_private::StringList::SplitIntoLines
size_t SplitIntoLines(const std::string &lines)
Definition: StringList.cpp:146
SBReproducerPrivate.h
LLDB_REGISTER_CONSTRUCTOR
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
Definition: ReproducerInstrumentation.h:89
lldb::SBTypeSynthetic::SetClassName
void SetClassName(const char *data)
Definition: SBTypeSynthetic.cpp:93
Debugger.h
lldb::SBTypeCategory::GetNumSummaries
uint32_t GetNumSummaries()
Definition: SBTypeCategory.cpp:116
lldb::SBTypeSummary
Definition: SBTypeSummary.h:57
lldb::SBTypeSynthetic::IsValid
bool IsValid() const
Definition: SBTypeSynthetic.cpp:55
lldb::SBTypeCategory::AddTypeFormat
bool AddTypeFormat(SBTypeNameSpecifier, SBTypeFormat)
Definition: SBTypeCategory.cpp:349
SBStream.h
lldb::SBTypeCategory::GetFilterAtIndex
SBTypeFilter GetFilterAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:293
lldb::SBTypeCategory::AddLanguage
void AddLanguage(lldb::LanguageType language)
Definition: SBTypeCategory.cpp:98
lldb::SBTypeCategory::GetSyntheticAtIndex
SBTypeSynthetic GetSyntheticAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:331
LLDB_RECORD_METHOD
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:158
lldb::SBTypeSummary::GetData
const char * GetData()
Definition: SBTypeSummary.cpp:242
lldb::SBTypeSynthetic::GetData
const char * GetData()
Definition: SBTypeSynthetic.cpp:82
lldb::SBTypeCategory::GetFilterForType
SBTypeFilter GetFilterForType(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:188
GetName
static llvm::StringRef GetName(XcodeSDK::Type type)
Definition: XcodeSDK.cpp:21
lldb::SBTypeCategory::GetSP
lldb::TypeCategoryImplSP GetSP()
Definition: SBTypeCategory.cpp:633
lldb::SBTypeFormat
Definition: SBTypeFormat.h:17
lldb_private::StringList
Definition: StringList.h:25
lldb_private::ConstString
Definition: ConstString.h:40
lldb::SBTypeNameSpecifier
class LLDB_API SBTypeNameSpecifier
Definition: SBDefines.h:86
lldb::SBTypeCategory::AddTypeSummary
bool AddTypeSummary(SBTypeNameSpecifier, SBTypeSummary)
Definition: SBTypeCategory.cpp:392
lldb::SBTypeNameSpecifier::IsRegex
bool IsRegex()
Definition: SBTypeNameSpecifier.cpp:79
lldb::SBTypeFilter::IsValid
bool IsValid() const
Definition: SBTypeFilter.cpp:35
lldb::SBTypeCategory::GetLanguageAtIndex
lldb::LanguageType GetLanguageAtIndex(uint32_t idx)
Definition: SBTypeCategory.cpp:81
lldb::SBTypeNameSpecifier::GetName
const char * GetName()
Definition: SBTypeNameSpecifier.cpp:59
lldb::SBTypeCategory::IsValid
bool IsValid() const
Definition: SBTypeCategory.cpp:44
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb::SBTypeCategory::DeleteTypeFormat
bool DeleteTypeFormat(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:374
lldb::SBTypeCategory::GetNumFilters
uint32_t GetNumFilters()
Definition: SBTypeCategory.cpp:125
SBTypeNameSpecifier.h
lldb::SBTypeCategory::GetFormatForType
SBTypeFormat GetFormatForType(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:215
lldb::SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex
SBTypeNameSpecifier GetTypeNameSpecifierForFormatAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:155
lldb::SBTypeCategory::GetSummaryAtIndex
SBTypeSummary GetSummaryAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:321
lldb_private::ScriptInterpreter::GenerateTypeSynthClass
virtual bool GenerateTypeSynthClass(StringList &input, std::string &output, const void *name_token=nullptr)
Definition: ScriptInterpreter.h:213
lldb::SBTypeSummary::IsValid
bool IsValid() const
Definition: SBTypeSummary.cpp:197
lldb::SBTypeCategory::AddTypeSynthetic
bool AddTypeSynthetic(SBTypeNameSpecifier, SBTypeSynthetic)
Definition: SBTypeCategory.cpp:512
LLDB_RECORD_CONSTRUCTOR
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
Definition: ReproducerInstrumentation.h:133
lldb_private::repro::Registry
The registry contains a unique mapping between functions and their ID.
Definition: ReproducerInstrumentation.h:517
lldb_private::Debugger::GetNumDebuggers
static size_t GetNumDebuggers()
Definition: Debugger.cpp:1069
lldb::SBTypeCategory::GetNumLanguages
uint32_t GetNumLanguages()
Definition: SBTypeCategory.cpp:90
DataVisualization.h
ImplType
std::pair< lldb::TypeCategoryImplSP, user_id_t > ImplType
Definition: SBTypeCategory.cpp:27
lldb::SBTypeCategory::operator=
lldb::SBTypeCategory & operator=(const lldb::SBTypeCategory &rhs)
Definition: SBTypeCategory.cpp:602
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb::SBTypeCategory::GetNumSynthetics
uint32_t GetNumSynthetics()
Definition: SBTypeCategory.cpp:134
uint32_t
lldb::SBTypeCategory::~SBTypeCategory
~SBTypeCategory()
lldb::SBTypeSummary::SetFunctionName
void SetFunctionName(const char *data)
Definition: SBTypeSummary.cpp:289
lldb::SBTypeFormat
class LLDB_API SBTypeFormat
Definition: SBDefines.h:84
lldb::SBTypeSynthetic
Definition: SBTypeSynthetic.h:17
SBTypeFilter.h
lldb_private::ScriptInterpreter
Definition: ScriptInterpreter.h:126
lldb_private::repro::RegisterMethods< SBTypeCategory >
void RegisterMethods< SBTypeCategory >(Registry &R)
Definition: SBTypeCategory.cpp:659
lldb::SBTypeCategory::GetName
const char * GetName()
Definition: SBTypeCategory.cpp:73
lldb::SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex
SBTypeNameSpecifier GetTypeNameSpecifierForSummaryAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:166
lldb::SBTypeSummary::IsFunctionCode
bool IsFunctionCode()
Definition: SBTypeSummary.cpp:207
lldb::SBTypeFormat::GetSP
lldb::TypeFormatImplSP GetSP()
Definition: SBTypeFormat.cpp:157
lldb::SBTypeCategory::AddTypeFilter
bool AddTypeFilter(SBTypeNameSpecifier, SBTypeFilter)
Definition: SBTypeCategory.cpp:469
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
SBTypeFormat.h
lldb_private::ScriptInterpreter::GenerateTypeScriptFunction
virtual bool GenerateTypeScriptFunction(const char *oneliner, std::string &output, const void *name_token=nullptr)
Definition: ScriptInterpreter.h:196
lldb::SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex
SBTypeNameSpecifier GetTypeNameSpecifierForFilterAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:144
lldb::SBTypeSynthetic::IsClassCode
bool IsClassCode()
Definition: SBTypeSynthetic.cpp:65
CommandInterpreter.h
lldb::SBTypeCategory::operator==
bool operator==(lldb::SBTypeCategory &rhs)
Definition: SBTypeCategory.cpp:613
lldb::SBTypeNameSpecifier::IsValid
bool IsValid() const
Definition: SBTypeNameSpecifier.cpp:49
lldb::SBTypeFilter
class LLDB_API SBTypeFilter
Definition: SBDefines.h:83
lldb::SBStream
Definition: SBStream.h:18
lldb::SBTypeFormat::IsValid
bool IsValid() const
Definition: SBTypeFormat.cpp:44
ScriptInterpreter.h
lldb::SBTypeCategory::SBTypeCategory
SBTypeCategory()
Definition: SBTypeCategory.cpp:29
lldb::SBTypeCategory
Definition: SBTypeCategory.h:17
lldb::SBTypeCategory::SetEnabled
void SetEnabled(bool)
Definition: SBTypeCategory.cpp:62
lldb
Definition: SBAddress.h:15
lldb::SBTypeCategory::GetNumFormats
uint32_t GetNumFormats()
Definition: SBTypeCategory.cpp:106
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb::SBTypeCategory::DeleteTypeSummary
bool DeleteTypeSummary(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:451
SBTypeCategory.h
lldb::SBTypeCategory::operator!=
bool operator!=(lldb::SBTypeCategory &rhs)
Definition: SBTypeCategory.cpp:623
LLDB_REGISTER_METHOD
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:93