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 
9 #include "lldb/API/SBTypeCategory.h"
10 #include "SBReproducerPrivate.h"
11 
12 #include "lldb/API/SBStream.h"
13 #include "lldb/API/SBTypeFilter.h"
14 #include "lldb/API/SBTypeFormat.h"
15 #include "lldb/API/SBTypeNameSpecifier.h"
16 #include "lldb/API/SBTypeSummary.h"
17 #include "lldb/API/SBTypeSynthetic.h"
18 
19 #include "lldb/Core/Debugger.h"
20 #include "lldb/DataFormatters/DataVisualization.h"
21 #include "lldb/Interpreter/CommandInterpreter.h"
22 #include "lldb/Interpreter/ScriptInterpreter.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() {
30  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeCategory);
31 }
32 
33 SBTypeCategory::SBTypeCategory(const char *name) : m_opaque_sp() {
34  DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
35 }
36 
37 SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
38  : m_opaque_sp(rhs.m_opaque_sp) {
39  LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs);
40 }
41 
42 SBTypeCategory::~SBTypeCategory() = default;
43 
44 bool SBTypeCategory::IsValid() const {
45  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid);
46  return this->operator bool();
47 }
48 SBTypeCategory::operator bool() const {
49  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool);
50 
51  return (m_opaque_sp.get() != nullptr);
52 }
53 
54 bool SBTypeCategory::GetEnabled() {
55  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled);
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() {
74  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeCategory, GetName);
75 
76  if (!IsValid())
77  return nullptr;
78  return m_opaque_sp->GetName();
79 }
80 
81 lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
82  LLDB_RECORD_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
83  (uint32_t), idx);
84 
85  if (IsValid())
86  return m_opaque_sp->GetLanguageAtIndex(idx);
87  return lldb::eLanguageTypeUnknown;
88 }
89 
90 uint32_t SBTypeCategory::GetNumLanguages() {
91  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumLanguages);
92 
93  if (IsValid())
94  return m_opaque_sp->GetNumLanguages();
95  return 0;
96 }
97 
98 void SBTypeCategory::AddLanguage(lldb::LanguageType language) {
99  LLDB_RECORD_METHOD(void, SBTypeCategory, AddLanguage, (lldb::LanguageType),
100  language);
101 
102  if (IsValid())
103  m_opaque_sp->AddLanguage(language);
104 }
105 
106 uint32_t SBTypeCategory::GetNumFormats() {
107  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFormats);
108 
109  if (!IsValid())
110  return 0;
111 
112  return m_opaque_sp->GetTypeFormatsContainer()->GetCount() +
113  m_opaque_sp->GetRegexTypeFormatsContainer()->GetCount();
114 }
115 
116 uint32_t SBTypeCategory::GetNumSummaries() {
117  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSummaries);
118 
119  if (!IsValid())
120  return 0;
121  return m_opaque_sp->GetTypeSummariesContainer()->GetCount() +
122  m_opaque_sp->GetRegexTypeSummariesContainer()->GetCount();
123 }
124 
125 uint32_t SBTypeCategory::GetNumFilters() {
126  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumFilters);
127 
128  if (!IsValid())
129  return 0;
130  return m_opaque_sp->GetTypeFiltersContainer()->GetCount() +
131  m_opaque_sp->GetRegexTypeFiltersContainer()->GetCount();
132 }
133 
134 uint32_t SBTypeCategory::GetNumSynthetics() {
135  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeCategory, GetNumSynthetics);
136 
137  if (!IsValid())
138  return 0;
139  return m_opaque_sp->GetTypeSyntheticsContainer()->GetCount() +
140  m_opaque_sp->GetRegexTypeSyntheticsContainer()->GetCount();
141 }
142 
143 lldb::SBTypeNameSpecifier
144 SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
145  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
146  GetTypeNameSpecifierForFilterAtIndex, (uint32_t), index);
147 
148  if (!IsValid())
149  return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
150  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
151  m_opaque_sp->GetTypeNameSpecifierForFilterAtIndex(index)));
152 }
153 
154 lldb::SBTypeNameSpecifier
155 SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
156  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
157  GetTypeNameSpecifierForFormatAtIndex, (uint32_t), index);
158 
159  if (!IsValid())
160  return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
161  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
162  m_opaque_sp->GetTypeNameSpecifierForFormatAtIndex(index)));
163 }
164 
165 lldb::SBTypeNameSpecifier
166 SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
167  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
168  GetTypeNameSpecifierForSummaryAtIndex, (uint32_t), index);
169 
170  if (!IsValid())
171  return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
172  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
173  m_opaque_sp->GetTypeNameSpecifierForSummaryAtIndex(index)));
174 }
175 
176 lldb::SBTypeNameSpecifier
177 SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
178  LLDB_RECORD_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
179  GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t),
180  index);
181 
182  if (!IsValid())
183  return LLDB_RECORD_RESULT(SBTypeNameSpecifier());
184  return LLDB_RECORD_RESULT(SBTypeNameSpecifier(
185  m_opaque_sp->GetTypeNameSpecifierForSyntheticAtIndex(index)));
186 }
187 
188 SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
189  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
190  (lldb::SBTypeNameSpecifier), spec);
191 
192  if (!IsValid())
193  return LLDB_RECORD_RESULT(SBTypeFilter());
194 
195  if (!spec.IsValid())
196  return LLDB_RECORD_RESULT(SBTypeFilter());
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)
208  return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
209 
210  TypeFilterImplSP filter_sp =
211  std::static_pointer_cast<TypeFilterImpl>(children_sp);
212 
213  return LLDB_RECORD_RESULT(lldb::SBTypeFilter(filter_sp));
214 }
215 SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
216  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
217  (lldb::SBTypeNameSpecifier), spec);
218 
219  if (!IsValid())
220  return LLDB_RECORD_RESULT(SBTypeFormat());
221 
222  if (!spec.IsValid())
223  return LLDB_RECORD_RESULT(SBTypeFormat());
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)
235  return LLDB_RECORD_RESULT(lldb::SBTypeFormat());
236 
237  return LLDB_RECORD_RESULT(lldb::SBTypeFormat(format_sp));
238 }
239 
240 SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
241  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
242  (lldb::SBTypeNameSpecifier), spec);
243 
244  if (!IsValid())
245  return LLDB_RECORD_RESULT(SBTypeSummary());
246 
247  if (!spec.IsValid())
248  return LLDB_RECORD_RESULT(SBTypeSummary());
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)
260  return LLDB_RECORD_RESULT(lldb::SBTypeSummary());
261 
262  return LLDB_RECORD_RESULT(lldb::SBTypeSummary(summary_sp));
263 }
264 
265 SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
266  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticForType,
267  (lldb::SBTypeNameSpecifier), spec);
268 
269  if (!IsValid())
270  return LLDB_RECORD_RESULT(SBTypeSynthetic());
271 
272  if (!spec.IsValid())
273  return LLDB_RECORD_RESULT(SBTypeSynthetic());
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)
285  return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
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 
293 SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
294  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
295  (uint32_t), index);
296 
297  if (!IsValid())
298  return LLDB_RECORD_RESULT(SBTypeFilter());
299  lldb::SyntheticChildrenSP children_sp =
300  m_opaque_sp->GetSyntheticAtIndex((index));
301 
302  if (!children_sp.get())
303  return LLDB_RECORD_RESULT(lldb::SBTypeFilter());
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 
311 SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
312  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
313  (uint32_t), index);
314 
315  if (!IsValid())
316  return LLDB_RECORD_RESULT(SBTypeFormat());
317  return LLDB_RECORD_RESULT(
318  SBTypeFormat(m_opaque_sp->GetFormatAtIndex((index))));
319 }
320 
321 SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
322  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
323  (uint32_t), index);
324 
325  if (!IsValid())
326  return LLDB_RECORD_RESULT(SBTypeSummary());
327  return LLDB_RECORD_RESULT(
328  SBTypeSummary(m_opaque_sp->GetSummaryAtIndex((index))));
329 }
330 
331 SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
332  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBTypeCategory, GetSyntheticAtIndex,
333  (uint32_t), index);
334 
335  if (!IsValid())
336  return LLDB_RECORD_RESULT(SBTypeSynthetic());
337  lldb::SyntheticChildrenSP children_sp =
338  m_opaque_sp->GetSyntheticAtIndex((index));
339 
340  if (!children_sp.get())
341  return LLDB_RECORD_RESULT(lldb::SBTypeSynthetic());
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 
349 bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
350  SBTypeFormat format) {
351  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFormat,
352  (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat), type_name,
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 
374 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
375  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
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 
392 bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
393  SBTypeSummary summary) {
394  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
395  (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary),
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));
419  uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
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 
451 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
452  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
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 
469 bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
470  SBTypeFilter filter) {
471  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
472  (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
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 
494 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
495  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
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 
512 bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
513  SBTypeSynthetic synth) {
514  LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
515  (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
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));
539  uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
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 
571 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
572  LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
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 
589 bool SBTypeCategory::GetDescription(lldb::SBStream &description,
590  lldb::DescriptionLevel description_level) {
591  LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
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 
601 lldb::SBTypeCategory &SBTypeCategory::
602 operator=(const lldb::SBTypeCategory &rhs) {
603  LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
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 
613 bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
614  LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
615  rhs);
616 
617  if (!IsValid())
618  return !rhs.IsValid();
619 
620  return m_opaque_sp.get() == rhs.m_opaque_sp.get();
621 }
622 
623 bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
624  LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
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 
639 void SBTypeCategory::SetSP(
640  const lldb::TypeCategoryImplSP &typecategory_impl_sp) {
641  m_opaque_sp = typecategory_impl_sp;
642 }
643 
644 SBTypeCategory::SBTypeCategory(
645  const lldb::TypeCategoryImplSP &typecategory_impl_sp)
646  : m_opaque_sp(typecategory_impl_sp) {}
647 
648 bool SBTypeCategory::IsDefaultCategory() {
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 <>
659 void RegisterMethods<SBTypeCategory>(Registry &R) {
660  LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
661  LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
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, ());
667  LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
668  (uint32_t));
669  LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
670  LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
671  (lldb::LanguageType));
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, ());
676  LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
677  GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
678  LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
679  (lldb::SBTypeNameSpecifier));
680  LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
681  GetSyntheticForType, (lldb::SBTypeNameSpecifier));
682  LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
683  (uint32_t));
684  LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
685  (uint32_t));
686  LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
687  GetSyntheticAtIndex, (uint32_t));
688  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
689  (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary));
690  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
691  (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic));
692  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
693  (lldb::SBTypeNameSpecifier));
694  LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
695  GetTypeNameSpecifierForFilterAtIndex, (uint32_t));
696  LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
697  GetTypeNameSpecifierForFormatAtIndex, (uint32_t));
698  LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
699  GetTypeNameSpecifierForSummaryAtIndex, (uint32_t));
700  LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
701  (lldb::SBTypeNameSpecifier));
702  LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
703  (lldb::SBTypeNameSpecifier));
704  LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
705  (uint32_t));
706  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
707  (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat));
708  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
709  (lldb::SBTypeNameSpecifier));
710  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
711  (lldb::SBTypeNameSpecifier));
712  LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
713  (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter));
714  LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
715  (lldb::SBTypeNameSpecifier));
716  LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
717  (lldb::SBStream &, lldb::DescriptionLevel));
718  LLDB_REGISTER_METHOD(
719  lldb::SBTypeCategory &,
720  SBTypeCategory, operator=,(const lldb::SBTypeCategory &));
721  LLDB_REGISTER_METHOD(bool,
722  SBTypeCategory, operator==,(lldb::SBTypeCategory &));
723  LLDB_REGISTER_METHOD(bool,
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
Generated on Fri Oct 22 2021 05:42:32 for LLDB by   doxygen 1.8.17