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 
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 
30 
31 SBTypeCategory::SBTypeCategory(const char *name) {
32  DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
33 }
34 
36  : m_opaque_sp(rhs.m_opaque_sp) {
37  LLDB_INSTRUMENT_VA(this, rhs);
38 }
39 
41 
43  LLDB_INSTRUMENT_VA(this);
44  return this->operator bool();
45 }
46 SBTypeCategory::operator bool() const {
47  LLDB_INSTRUMENT_VA(this);
48 
49  return (m_opaque_sp.get() != nullptr);
50 }
51 
53  LLDB_INSTRUMENT_VA(this);
54 
55  if (!IsValid())
56  return false;
57  return m_opaque_sp->IsEnabled();
58 }
59 
60 void SBTypeCategory::SetEnabled(bool enabled) {
61  LLDB_INSTRUMENT_VA(this, enabled);
62 
63  if (!IsValid())
64  return;
65  if (enabled)
66  DataVisualization::Categories::Enable(m_opaque_sp);
67  else
68  DataVisualization::Categories::Disable(m_opaque_sp);
69 }
70 
71 const char *SBTypeCategory::GetName() {
72  LLDB_INSTRUMENT_VA(this);
73 
74  if (!IsValid())
75  return nullptr;
76  return m_opaque_sp->GetName();
77 }
78 
80  LLDB_INSTRUMENT_VA(this, idx);
81 
82  if (IsValid())
83  return m_opaque_sp->GetLanguageAtIndex(idx);
85 }
86 
88  LLDB_INSTRUMENT_VA(this);
89 
90  if (IsValid())
91  return m_opaque_sp->GetNumLanguages();
92  return 0;
93 }
94 
96  LLDB_INSTRUMENT_VA(this, language);
97 
98  if (IsValid())
99  m_opaque_sp->AddLanguage(language);
100 }
101 
103  LLDB_INSTRUMENT_VA(this);
104 
105  if (!IsValid())
106  return 0;
107 
108  return m_opaque_sp->GetNumFormats();
109 }
110 
112  LLDB_INSTRUMENT_VA(this);
113 
114  if (!IsValid())
115  return 0;
116  return m_opaque_sp->GetNumSummaries();
117 }
118 
120  LLDB_INSTRUMENT_VA(this);
121 
122  if (!IsValid())
123  return 0;
124  return m_opaque_sp->GetNumFilters();
125 }
126 
128  LLDB_INSTRUMENT_VA(this);
129 
130  if (!IsValid())
131  return 0;
132  return m_opaque_sp->GetNumSynthetics();
133 }
134 
137  LLDB_INSTRUMENT_VA(this, index);
138 
139  if (!IsValid())
140  return SBTypeNameSpecifier();
141  return SBTypeNameSpecifier(
142  m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index));
143 }
144 
147  LLDB_INSTRUMENT_VA(this, index);
148 
149  if (!IsValid())
150  return SBTypeNameSpecifier();
151  return SBTypeNameSpecifier(
152  m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index));
153 }
154 
157  LLDB_INSTRUMENT_VA(this, index);
158 
159  if (!IsValid())
160  return SBTypeNameSpecifier();
161  return SBTypeNameSpecifier(
162  m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index));
163 }
164 
167  LLDB_INSTRUMENT_VA(this, index);
168 
169  if (!IsValid())
170  return SBTypeNameSpecifier();
171  return SBTypeNameSpecifier(
172  m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index));
173 }
174 
176  LLDB_INSTRUMENT_VA(this, spec);
177 
178  if (!IsValid())
179  return SBTypeFilter();
180 
181  if (!spec.IsValid())
182  return SBTypeFilter();
183 
184  lldb::TypeFilterImplSP children_sp =
185  m_opaque_sp->GetFilterForType(spec.GetSP());
186 
187  if (!children_sp)
188  return lldb::SBTypeFilter();
189 
190  TypeFilterImplSP filter_sp =
191  std::static_pointer_cast<TypeFilterImpl>(children_sp);
192 
193  return lldb::SBTypeFilter(filter_sp);
194 }
196  LLDB_INSTRUMENT_VA(this, spec);
197 
198  if (!IsValid())
199  return SBTypeFormat();
200 
201  if (!spec.IsValid())
202  return SBTypeFormat();
203 
204  lldb::TypeFormatImplSP format_sp =
205  m_opaque_sp->GetFormatForType(spec.GetSP());
206 
207  if (!format_sp)
208  return lldb::SBTypeFormat();
209 
210  return lldb::SBTypeFormat(format_sp);
211 }
212 
214  LLDB_INSTRUMENT_VA(this, spec);
215 
216  if (!IsValid())
217  return SBTypeSummary();
218 
219  if (!spec.IsValid())
220  return SBTypeSummary();
221 
222  lldb::TypeSummaryImplSP summary_sp =
223  m_opaque_sp->GetSummaryForType(spec.GetSP());
224 
225  if (!summary_sp)
226  return lldb::SBTypeSummary();
227 
228  return lldb::SBTypeSummary(summary_sp);
229 }
230 
232  LLDB_INSTRUMENT_VA(this, spec);
233 
234  if (!IsValid())
235  return SBTypeSynthetic();
236 
237  if (!spec.IsValid())
238  return SBTypeSynthetic();
239 
240  lldb::SyntheticChildrenSP children_sp =
241  m_opaque_sp->GetSyntheticForType(spec.GetSP());
242 
243  if (!children_sp)
244  return lldb::SBTypeSynthetic();
245 
246  ScriptedSyntheticChildrenSP synth_sp =
247  std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
248 
249  return lldb::SBTypeSynthetic(synth_sp);
250 }
251 
253  LLDB_INSTRUMENT_VA(this, index);
254 
255  if (!IsValid())
256  return SBTypeFilter();
257  lldb::SyntheticChildrenSP children_sp =
258  m_opaque_sp->GetSyntheticAtIndex((index));
259 
260  if (!children_sp.get())
261  return lldb::SBTypeFilter();
262 
263  TypeFilterImplSP filter_sp =
264  std::static_pointer_cast<TypeFilterImpl>(children_sp);
265 
266  return lldb::SBTypeFilter(filter_sp);
267 }
268 
270  LLDB_INSTRUMENT_VA(this, index);
271 
272  if (!IsValid())
273  return SBTypeFormat();
274  return SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index)));
275 }
276 
278  LLDB_INSTRUMENT_VA(this, index);
279 
280  if (!IsValid())
281  return SBTypeSummary();
282  return SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index)));
283 }
284 
286  LLDB_INSTRUMENT_VA(this, index);
287 
288  if (!IsValid())
289  return SBTypeSynthetic();
290  lldb::SyntheticChildrenSP children_sp =
291  m_opaque_sp->GetSyntheticAtIndex((index));
292 
293  if (!children_sp.get())
294  return lldb::SBTypeSynthetic();
295 
296  ScriptedSyntheticChildrenSP synth_sp =
297  std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
298 
299  return lldb::SBTypeSynthetic(synth_sp);
300 }
301 
303  SBTypeFormat format) {
304  LLDB_INSTRUMENT_VA(this, type_name, format);
305 
306  if (!IsValid())
307  return false;
308 
309  if (!type_name.IsValid())
310  return false;
311 
312  if (!format.IsValid())
313  return false;
314 
315  m_opaque_sp->AddTypeFormat(type_name.GetSP(), format.GetSP());
316  return true;
317 }
318 
320  LLDB_INSTRUMENT_VA(this, type_name);
321 
322  if (!IsValid())
323  return false;
324 
325  if (!type_name.IsValid())
326  return false;
327 
328  return m_opaque_sp->DeleteTypeFormat(type_name.GetSP());
329 }
330 
332  SBTypeSummary summary) {
333  LLDB_INSTRUMENT_VA(this, type_name, summary);
334 
335  if (!IsValid())
336  return false;
337 
338  if (!type_name.IsValid())
339  return false;
340 
341  if (!summary.IsValid())
342  return false;
343 
344  // FIXME: we need to iterate over all the Debugger objects and have each of
345  // them contain a copy of the function
346  // since we currently have formatters live in a global space, while Python
347  // code lives in a specific Debugger-related environment this should
348  // eventually be fixed by deciding a final location in the LLDB object space
349  // for formatters
350  if (summary.IsFunctionCode()) {
351  const void *name_token =
352  (const void *)ConstString(type_name.GetName()).GetCString();
353  const char *script = summary.GetData();
354  StringList input;
355  input.SplitIntoLines(script, strlen(script));
357  bool need_set = true;
358  for (uint32_t j = 0; j < num_debuggers; j++) {
359  DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
360  if (debugger_sp) {
361  ScriptInterpreter *interpreter_ptr =
362  debugger_sp->GetScriptInterpreter();
363  if (interpreter_ptr) {
364  std::string output;
365  if (interpreter_ptr->GenerateTypeScriptFunction(input, output,
366  name_token) &&
367  !output.empty()) {
368  if (need_set) {
369  need_set = false;
370  summary.SetFunctionName(output.c_str());
371  }
372  }
373  }
374  }
375  }
376  }
377 
378  m_opaque_sp->AddTypeSummary(type_name.GetSP(), summary.GetSP());
379  return true;
380 }
381 
383  LLDB_INSTRUMENT_VA(this, type_name);
384 
385  if (!IsValid())
386  return false;
387 
388  if (!type_name.IsValid())
389  return false;
390 
391  return m_opaque_sp->DeleteTypeSummary(type_name.GetSP());
392 }
393 
395  SBTypeFilter filter) {
396  LLDB_INSTRUMENT_VA(this, type_name, filter);
397 
398  if (!IsValid())
399  return false;
400 
401  if (!type_name.IsValid())
402  return false;
403 
404  if (!filter.IsValid())
405  return false;
406 
407  m_opaque_sp->AddTypeFilter(type_name.GetSP(), filter.GetSP());
408  return true;
409 }
410 
412  LLDB_INSTRUMENT_VA(this, type_name);
413 
414  if (!IsValid())
415  return false;
416 
417  if (!type_name.IsValid())
418  return false;
419 
420  return m_opaque_sp->DeleteTypeFilter(type_name.GetSP());
421 }
422 
424  SBTypeSynthetic synth) {
425  LLDB_INSTRUMENT_VA(this, type_name, synth);
426 
427  if (!IsValid())
428  return false;
429 
430  if (!type_name.IsValid())
431  return false;
432 
433  if (!synth.IsValid())
434  return false;
435 
436  // FIXME: we need to iterate over all the Debugger objects and have each of
437  // them contain a copy of the function
438  // since we currently have formatters live in a global space, while Python
439  // code lives in a specific Debugger-related environment this should
440  // eventually be fixed by deciding a final location in the LLDB object space
441  // for formatters
442  if (synth.IsClassCode()) {
443  const void *name_token =
444  (const void *)ConstString(type_name.GetName()).GetCString();
445  const char *script = synth.GetData();
446  StringList input;
447  input.SplitIntoLines(script, strlen(script));
449  bool need_set = true;
450  for (uint32_t j = 0; j < num_debuggers; j++) {
451  DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
452  if (debugger_sp) {
453  ScriptInterpreter *interpreter_ptr =
454  debugger_sp->GetScriptInterpreter();
455  if (interpreter_ptr) {
456  std::string output;
457  if (interpreter_ptr->GenerateTypeSynthClass(input, output,
458  name_token) &&
459  !output.empty()) {
460  if (need_set) {
461  need_set = false;
462  synth.SetClassName(output.c_str());
463  }
464  }
465  }
466  }
467  }
468  }
469 
470  m_opaque_sp->AddTypeSynthetic(type_name.GetSP(), synth.GetSP());
471  return true;
472 }
473 
475  LLDB_INSTRUMENT_VA(this, type_name);
476 
477  if (!IsValid())
478  return false;
479 
480  if (!type_name.IsValid())
481  return false;
482 
483  return m_opaque_sp->DeleteTypeSynthetic(type_name.GetSP());
484 }
485 
487  lldb::DescriptionLevel description_level) {
488  LLDB_INSTRUMENT_VA(this, description, description_level);
489 
490  if (!IsValid())
491  return false;
492  description.Printf("Category name: %s\n", GetName());
493  return true;
494 }
495 
498  LLDB_INSTRUMENT_VA(this, rhs);
499 
500  if (this != &rhs) {
501  m_opaque_sp = rhs.m_opaque_sp;
502  }
503  return *this;
504 }
505 
507  LLDB_INSTRUMENT_VA(this, rhs);
508 
509  if (!IsValid())
510  return !rhs.IsValid();
511 
512  return m_opaque_sp.get() == rhs.m_opaque_sp.get();
513 }
514 
516  LLDB_INSTRUMENT_VA(this, rhs);
517 
518  if (!IsValid())
519  return rhs.IsValid();
520 
521  return m_opaque_sp.get() != rhs.m_opaque_sp.get();
522 }
523 
524 lldb::TypeCategoryImplSP SBTypeCategory::GetSP() {
525  if (!IsValid())
526  return lldb::TypeCategoryImplSP();
527  return m_opaque_sp;
528 }
529 
531  const lldb::TypeCategoryImplSP &typecategory_impl_sp) {
532  m_opaque_sp = typecategory_impl_sp;
533 }
534 
536  const lldb::TypeCategoryImplSP &typecategory_impl_sp)
537  : m_opaque_sp(typecategory_impl_sp) {}
538 
540  if (!IsValid())
541  return false;
542 
543  return (strcmp(m_opaque_sp->GetName(), "default") == 0);
544 }
lldb::SBTypeSummary::GetSP
lldb::TypeSummaryImplSP GetSP()
Definition: SBTypeSummary.cpp:371
lldb::SBTypeCategory::DeleteTypeSynthetic
bool DeleteTypeSynthetic(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:474
lldb::SBTypeCategory::GetDescription
bool GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level)
Definition: SBTypeCategory.cpp:486
Instrumentation.h
SBTypeSynthetic.h
lldb::SBTypeSynthetic::GetSP
lldb::ScriptedSyntheticChildrenSP GetSP()
Definition: SBTypeSynthetic.cpp:171
lldb::SBTypeNameSpecifier
Definition: SBTypeNameSpecifier.h:17
lldb::SBTypeFilter
Definition: SBTypeFilter.h:17
lldb::SBStream::Printf
void Printf(const char *format,...) __attribute__((format(printf
Definition: SBStream.cpp:70
lldb::SBTypeCategory::GetFormatAtIndex
SBTypeFormat GetFormatAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:269
SBTypeSummary.h
lldb::SBTypeFilter::GetSP
lldb::TypeFilterImplSP GetSP()
Definition: SBTypeFilter.cpp:157
lldb::SBTypeCategory::SetSP
void SetSP(const lldb::TypeCategoryImplSP &typecategory_impl_sp)
Definition: SBTypeCategory.cpp:530
lldb_private::Debugger::GetDebuggerAtIndex
static lldb::DebuggerSP GetDebuggerAtIndex(size_t index)
Definition: Debugger.cpp:1190
lldb::SBTypeCategory::IsDefaultCategory
bool IsDefaultCategory()
Definition: SBTypeCategory.cpp:539
lldb::SBTypeSynthetic
class LLDB_API SBTypeSynthetic
Definition: SBDefines.h:102
lldb::SBTypeCategory::m_opaque_sp
TypeCategoryImplSP m_opaque_sp
Definition: SBTypeCategory.h:105
lldb::SBTypeCategory::DeleteTypeFilter
bool DeleteTypeFilter(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:411
lldb::SBTypeCategory::GetEnabled
bool GetEnabled()
Definition: SBTypeCategory.cpp:52
lldb::SBTypeSummary
class LLDB_API SBTypeSummary
Definition: SBDefines.h:100
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb::SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex
SBTypeNameSpecifier GetTypeNameSpecifierForSyntheticAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:166
lldb::SBTypeCategory::GetSummaryForType
SBTypeSummary GetSummaryForType(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:213
lldb::SBTypeCategory::GetSyntheticForType
SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:231
lldb_private::StringList::SplitIntoLines
size_t SplitIntoLines(const std::string &lines)
Definition: StringList.cpp:152
lldb::SBTypeSynthetic::SetClassName
void SetClassName(const char *data)
Definition: SBTypeSynthetic.cpp:86
Debugger.h
lldb::SBTypeCategory::GetNumSummaries
uint32_t GetNumSummaries()
Definition: SBTypeCategory.cpp:111
lldb::SBTypeSummary
Definition: SBTypeSummary.h:55
lldb::SBTypeSynthetic::IsValid
bool IsValid() const
Definition: SBTypeSynthetic.cpp:48
lldb::SBTypeCategory::AddTypeFormat
bool AddTypeFormat(SBTypeNameSpecifier, SBTypeFormat)
Definition: SBTypeCategory.cpp:302
SBStream.h
lldb::SBTypeCategory::GetFilterAtIndex
SBTypeFilter GetFilterAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:252
bool
lldb::SBTypeCategory::AddLanguage
void AddLanguage(lldb::LanguageType language)
Definition: SBTypeCategory.cpp:95
lldb::SBTypeCategory::GetSyntheticAtIndex
SBTypeSynthetic GetSyntheticAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:285
lldb::SBTypeSummary::GetData
const char * GetData()
Definition: SBTypeSummary.cpp:215
lldb::SBTypeSynthetic::GetData
const char * GetData()
Definition: SBTypeSynthetic.cpp:75
lldb::SBTypeCategory::GetFilterForType
SBTypeFilter GetFilterForType(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:175
lldb::SBTypeCategory::GetSP
lldb::TypeCategoryImplSP GetSP()
Definition: SBTypeCategory.cpp:524
lldb::SBTypeFormat
Definition: SBTypeFormat.h:17
lldb_private::StringList
Definition: StringList.h:26
lldb_private::ConstString
Definition: ConstString.h:39
lldb::SBTypeNameSpecifier
class LLDB_API SBTypeNameSpecifier
Definition: SBDefines.h:99
lldb::SBTypeCategory::AddTypeSummary
bool AddTypeSummary(SBTypeNameSpecifier, SBTypeSummary)
Definition: SBTypeCategory.cpp:331
lldb::SBTypeFilter::IsValid
bool IsValid() const
Definition: SBTypeFilter.cpp:33
lldb::SBTypeCategory::GetLanguageAtIndex
lldb::LanguageType GetLanguageAtIndex(uint32_t idx)
Definition: SBTypeCategory.cpp:79
lldb::SBTypeNameSpecifier::GetName
const char * GetName()
Definition: SBTypeNameSpecifier.cpp:62
lldb::SBTypeCategory::IsValid
bool IsValid() const
Definition: SBTypeCategory.cpp:42
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb::SBTypeCategory::DeleteTypeFormat
bool DeleteTypeFormat(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:319
lldb::SBTypeCategory::GetNumFilters
uint32_t GetNumFilters()
Definition: SBTypeCategory.cpp:119
SBTypeNameSpecifier.h
lldb::SBTypeCategory::GetFormatForType
SBTypeFormat GetFormatForType(SBTypeNameSpecifier)
Definition: SBTypeCategory.cpp:195
lldb::SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex
SBTypeNameSpecifier GetTypeNameSpecifierForFormatAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:146
lldb::SBTypeCategory::GetSummaryAtIndex
SBTypeSummary GetSummaryAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:277
lldb_private::ScriptInterpreter::GenerateTypeSynthClass
virtual bool GenerateTypeSynthClass(StringList &input, std::string &output, const void *name_token=nullptr)
Definition: ScriptInterpreter.h:215
lldb::SBTypeSummary::IsValid
bool IsValid() const
Definition: SBTypeSummary.cpp:170
lldb::SBTypeCategory::AddTypeSynthetic
bool AddTypeSynthetic(SBTypeNameSpecifier, SBTypeSynthetic)
Definition: SBTypeCategory.cpp:423
lldb_private::Debugger::GetNumDebuggers
static size_t GetNumDebuggers()
Definition: Debugger.cpp:1182
lldb::SBTypeCategory::GetNumLanguages
uint32_t GetNumLanguages()
Definition: SBTypeCategory.cpp:87
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:497
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb::SBTypeCategory::GetNumSynthetics
uint32_t GetNumSynthetics()
Definition: SBTypeCategory.cpp:127
uint32_t
lldb::SBTypeCategory::~SBTypeCategory
~SBTypeCategory()
lldb::SBTypeSummary::SetFunctionName
void SetFunctionName(const char *data)
Definition: SBTypeSummary.cpp:261
lldb::SBTypeFormat
class LLDB_API SBTypeFormat
Definition: SBDefines.h:97
lldb::SBTypeSynthetic
Definition: SBTypeSynthetic.h:17
SBTypeFilter.h
lldb_private::ScriptInterpreter
Definition: ScriptInterpreter.h:126
lldb::SBTypeCategory::GetName
const char * GetName()
Definition: SBTypeCategory.cpp:71
lldb::SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex
SBTypeNameSpecifier GetTypeNameSpecifierForSummaryAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:156
lldb::SBTypeSummary::IsFunctionCode
bool IsFunctionCode()
Definition: SBTypeSummary.cpp:180
lldb::SBTypeFormat::GetSP
lldb::TypeFormatImplSP GetSP()
Definition: SBTypeFormat.cpp:147
lldb::SBTypeCategory::AddTypeFilter
bool AddTypeFilter(SBTypeNameSpecifier, SBTypeFilter)
Definition: SBTypeCategory.cpp:394
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:198
lldb::SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex
SBTypeNameSpecifier GetTypeNameSpecifierForFilterAtIndex(uint32_t)
Definition: SBTypeCategory.cpp:136
lldb::SBTypeSynthetic::IsClassCode
bool IsClassCode()
Definition: SBTypeSynthetic.cpp:58
LLDB_INSTRUMENT_VA
#define LLDB_INSTRUMENT_VA(...)
Definition: Instrumentation.h:98
CommandInterpreter.h
lldb::SBTypeCategory::operator==
bool operator==(lldb::SBTypeCategory &rhs)
Definition: SBTypeCategory.cpp:506
lldb::SBTypeNameSpecifier::IsValid
bool IsValid() const
Definition: SBTypeNameSpecifier.cpp:52
lldb::SBTypeFilter
class LLDB_API SBTypeFilter
Definition: SBDefines.h:96
lldb::SBStream
Definition: SBStream.h:18
lldb::SBTypeFormat::IsValid
bool IsValid() const
Definition: SBTypeFormat.cpp:40
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:60
lldb
Definition: SBAddress.h:15
lldb::SBTypeCategory::GetNumFormats
uint32_t GetNumFormats()
Definition: SBTypeCategory.cpp:102
lldb::SBTypeNameSpecifier::GetSP
lldb::TypeNameSpecifierImplSP GetSP()
Definition: SBTypeNameSpecifier.cpp:149
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:382
SBTypeCategory.h
lldb::SBTypeCategory::operator!=
bool operator!=(lldb::SBTypeCategory &rhs)
Definition: SBTypeCategory.cpp:515