contrib/llvm-project/lldb/source/API/SBTypeCategory.cpp

   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(
 367             llvm::StringRef::withNullAsEmpty(type_name.GetName())),
 368         format.GetSP());
 369   else
 370     m_opaque_sp->GetTypeFormatsContainer()->Add(
 371         ConstString(type_name.GetName()), format.GetSP());
 372
 373   return true;
 374 }
 375
 376 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
 377   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
 378                      (lldb::SBTypeNameSpecifier), type_name);
 379
 380   if (!IsValid())
 381     return false;
 382
 383   if (!type_name.IsValid())
 384     return false;
 385
 386   if (type_name.IsRegex())
 387     return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(
 388         ConstString(type_name.GetName()));
 389   else
 390     return m_opaque_sp->GetTypeFormatsContainer()->Delete(
 391         ConstString(type_name.GetName()));
 392 }
 393
 394 bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
 395                                     SBTypeSummary summary) {
 396   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSummary,
 397                      (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary),
 398                      type_name, summary);
 399
 400   if (!IsValid())
 401     return false;
 402
 403   if (!type_name.IsValid())
 404     return false;
 405
 406   if (!summary.IsValid())
 407     return false;
 408
 409   // FIXME: we need to iterate over all the Debugger objects and have each of
 410   // them contain a copy of the function
 411   // since we currently have formatters live in a global space, while Python
 412   // code lives in a specific Debugger-related environment this should
 413   // eventually be fixed by deciding a final location in the LLDB object space
 414   // for formatters
 415   if (summary.IsFunctionCode()) {
 416     const void *name_token =
 417         (const void *)ConstString(type_name.GetName()).GetCString();
 418     const char *script = summary.GetData();
 419     StringList input;
 420     input.SplitIntoLines(script, strlen(script));
 421     uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
 422     bool need_set = true;
 423     for (uint32_t j = 0; j < num_debuggers; j++) {
 424       DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
 425       if (debugger_sp) {
 426         ScriptInterpreter *interpreter_ptr =
 427             debugger_sp->GetScriptInterpreter();
 428         if (interpreter_ptr) {
 429           std::string output;
 430           if (interpreter_ptr->GenerateTypeScriptFunction(input, output,
 431                                                           name_token) &&
 432               !output.empty()) {
 433             if (need_set) {
 434               need_set = false;
 435               summary.SetFunctionName(output.c_str());
 436             }
 437           }
 438         }
 439       }
 440     }
 441   }
 442
 443   if (type_name.IsRegex())
 444     m_opaque_sp->GetRegexTypeSummariesContainer()->Add(
 445         RegularExpression(
 446             llvm::StringRef::withNullAsEmpty(type_name.GetName())),
 447         summary.GetSP());
 448   else
 449     m_opaque_sp->GetTypeSummariesContainer()->Add(
 450         ConstString(type_name.GetName()), summary.GetSP());
 451
 452   return true;
 453 }
 454
 455 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
 456   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
 457                      (lldb::SBTypeNameSpecifier), type_name);
 458
 459   if (!IsValid())
 460     return false;
 461
 462   if (!type_name.IsValid())
 463     return false;
 464
 465   if (type_name.IsRegex())
 466     return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(
 467         ConstString(type_name.GetName()));
 468   else
 469     return m_opaque_sp->GetTypeSummariesContainer()->Delete(
 470         ConstString(type_name.GetName()));
 471 }
 472
 473 bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
 474                                    SBTypeFilter filter) {
 475   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeFilter,
 476                      (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter), type_name,
 477                      filter);
 478
 479   if (!IsValid())
 480     return false;
 481
 482   if (!type_name.IsValid())
 483     return false;
 484
 485   if (!filter.IsValid())
 486     return false;
 487
 488   if (type_name.IsRegex())
 489     m_opaque_sp->GetRegexTypeFiltersContainer()->Add(
 490         RegularExpression(
 491             llvm::StringRef::withNullAsEmpty(type_name.GetName())),
 492         filter.GetSP());
 493   else
 494     m_opaque_sp->GetTypeFiltersContainer()->Add(
 495         ConstString(type_name.GetName()), filter.GetSP());
 496
 497   return true;
 498 }
 499
 500 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
 501   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
 502                      (lldb::SBTypeNameSpecifier), type_name);
 503
 504   if (!IsValid())
 505     return false;
 506
 507   if (!type_name.IsValid())
 508     return false;
 509
 510   if (type_name.IsRegex())
 511     return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(
 512         ConstString(type_name.GetName()));
 513   else
 514     return m_opaque_sp->GetTypeFiltersContainer()->Delete(
 515         ConstString(type_name.GetName()));
 516 }
 517
 518 bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
 519                                       SBTypeSynthetic synth) {
 520   LLDB_RECORD_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
 521                      (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic),
 522                      type_name, synth);
 523
 524   if (!IsValid())
 525     return false;
 526
 527   if (!type_name.IsValid())
 528     return false;
 529
 530   if (!synth.IsValid())
 531     return false;
 532
 533   // FIXME: we need to iterate over all the Debugger objects and have each of
 534   // them contain a copy of the function
 535   // since we currently have formatters live in a global space, while Python
 536   // code lives in a specific Debugger-related environment this should
 537   // eventually be fixed by deciding a final location in the LLDB object space
 538   // for formatters
 539   if (synth.IsClassCode()) {
 540     const void *name_token =
 541         (const void *)ConstString(type_name.GetName()).GetCString();
 542     const char *script = synth.GetData();
 543     StringList input;
 544     input.SplitIntoLines(script, strlen(script));
 545     uint32_t num_debuggers = lldb_private::Debugger::GetNumDebuggers();
 546     bool need_set = true;
 547     for (uint32_t j = 0; j < num_debuggers; j++) {
 548       DebuggerSP debugger_sp = lldb_private::Debugger::GetDebuggerAtIndex(j);
 549       if (debugger_sp) {
 550         ScriptInterpreter *interpreter_ptr =
 551             debugger_sp->GetScriptInterpreter();
 552         if (interpreter_ptr) {
 553           std::string output;
 554           if (interpreter_ptr->GenerateTypeSynthClass(input, output,
 555                                                       name_token) &&
 556               !output.empty()) {
 557             if (need_set) {
 558               need_set = false;
 559               synth.SetClassName(output.c_str());
 560             }
 561           }
 562         }
 563       }
 564     }
 565   }
 566
 567   if (type_name.IsRegex())
 568     m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add(
 569         RegularExpression(
 570             llvm::StringRef::withNullAsEmpty(type_name.GetName())),
 571         synth.GetSP());
 572   else
 573     m_opaque_sp->GetTypeSyntheticsContainer()->Add(
 574         ConstString(type_name.GetName()), synth.GetSP());
 575
 576   return true;
 577 }
 578
 579 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
 580   LLDB_RECORD_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
 581                      (lldb::SBTypeNameSpecifier), type_name);
 582
 583   if (!IsValid())
 584     return false;
 585
 586   if (!type_name.IsValid())
 587     return false;
 588
 589   if (type_name.IsRegex())
 590     return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(
 591         ConstString(type_name.GetName()));
 592   else
 593     return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(
 594         ConstString(type_name.GetName()));
 595 }
 596
 597 bool SBTypeCategory::GetDescription(lldb::SBStream &description,
 598                                     lldb::DescriptionLevel description_level) {
 599   LLDB_RECORD_METHOD(bool, SBTypeCategory, GetDescription,
 600                      (lldb::SBStream &, lldb::DescriptionLevel), description,
 601                      description_level);
 602
 603   if (!IsValid())
 604     return false;
 605   description.Printf("Category name: %s\n", GetName());
 606   return true;
 607 }
 608
 609 lldb::SBTypeCategory &SBTypeCategory::
 610 operator=(const lldb::SBTypeCategory &rhs) {
 611   LLDB_RECORD_METHOD(lldb::SBTypeCategory &,
 612                      SBTypeCategory, operator=,(const lldb::SBTypeCategory &),
 613                      rhs);
 614
 615   if (this != &rhs) {
 616     m_opaque_sp = rhs.m_opaque_sp;
 617   }
 618   return LLDB_RECORD_RESULT(*this);
 619 }
 620
 621 bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
 622   LLDB_RECORD_METHOD(bool, SBTypeCategory, operator==,(lldb::SBTypeCategory &),
 623                      rhs);
 624
 625   if (!IsValid())
 626     return !rhs.IsValid();
 627
 628   return m_opaque_sp.get() == rhs.m_opaque_sp.get();
 629 }
 630
 631 bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
 632   LLDB_RECORD_METHOD(bool, SBTypeCategory, operator!=,(lldb::SBTypeCategory &),
 633                      rhs);
 634
 635   if (!IsValid())
 636     return rhs.IsValid();
 637
 638   return m_opaque_sp.get() != rhs.m_opaque_sp.get();
 639 }
 640
 641 lldb::TypeCategoryImplSP SBTypeCategory::GetSP() {
 642   if (!IsValid())
 643     return lldb::TypeCategoryImplSP();
 644   return m_opaque_sp;
 645 }
 646
 647 void SBTypeCategory::SetSP(
 648     const lldb::TypeCategoryImplSP &typecategory_impl_sp) {
 649   m_opaque_sp = typecategory_impl_sp;
 650 }
 651
 652 SBTypeCategory::SBTypeCategory(
 653     const lldb::TypeCategoryImplSP &typecategory_impl_sp)
 654     : m_opaque_sp(typecategory_impl_sp) {}
 655
 656 bool SBTypeCategory::IsDefaultCategory() {
 657   if (!IsValid())
 658     return false;
 659
 660   return (strcmp(m_opaque_sp->GetName(), "default") == 0);
 661 }
 662
 663 namespace lldb_private {
 664 namespace repro {
 665
 666 template <>
 667 void RegisterMethods<SBTypeCategory>(Registry &R) {
 668   LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
 669   LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
 670   LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
 671   LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ());
 672   LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
 673   LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
 674   LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
 675   LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
 676                        (uint32_t));
 677   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
 678   LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
 679                        (lldb::LanguageType));
 680   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFormats, ());
 681   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSummaries, ());
 682   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumFilters, ());
 683   LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumSynthetics, ());
 684   LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
 685                        GetTypeNameSpecifierForSyntheticAtIndex, (uint32_t));
 686   LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryForType,
 687                        (lldb::SBTypeNameSpecifier));
 688   LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
 689                        GetSyntheticForType, (lldb::SBTypeNameSpecifier));
 690   LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterAtIndex,
 691                        (uint32_t));
 692   LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBTypeCategory, GetSummaryAtIndex,
 693                        (uint32_t));
 694   LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBTypeCategory,
 695                        GetSyntheticAtIndex, (uint32_t));
 696   LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSummary,
 697                        (lldb::SBTypeNameSpecifier, lldb::SBTypeSummary));
 698   LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeSynthetic,
 699                        (lldb::SBTypeNameSpecifier, lldb::SBTypeSynthetic));
 700   LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSynthetic,
 701                        (lldb::SBTypeNameSpecifier));
 702   LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
 703                        GetTypeNameSpecifierForFilterAtIndex, (uint32_t));
 704   LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
 705                        GetTypeNameSpecifierForFormatAtIndex, (uint32_t));
 706   LLDB_REGISTER_METHOD(lldb::SBTypeNameSpecifier, SBTypeCategory,
 707                        GetTypeNameSpecifierForSummaryAtIndex, (uint32_t));
 708   LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBTypeCategory, GetFilterForType,
 709                        (lldb::SBTypeNameSpecifier));
 710   LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatForType,
 711                        (lldb::SBTypeNameSpecifier));
 712   LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBTypeCategory, GetFormatAtIndex,
 713                        (uint32_t));
 714   LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFormat,
 715                        (lldb::SBTypeNameSpecifier, lldb::SBTypeFormat));
 716   LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFormat,
 717                        (lldb::SBTypeNameSpecifier));
 718   LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeSummary,
 719                        (lldb::SBTypeNameSpecifier));
 720   LLDB_REGISTER_METHOD(bool, SBTypeCategory, AddTypeFilter,
 721                        (lldb::SBTypeNameSpecifier, lldb::SBTypeFilter));
 722   LLDB_REGISTER_METHOD(bool, SBTypeCategory, DeleteTypeFilter,
 723                        (lldb::SBTypeNameSpecifier));
 724   LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetDescription,
 725                        (lldb::SBStream &, lldb::DescriptionLevel));
 726   LLDB_REGISTER_METHOD(
 727       lldb::SBTypeCategory &,
 728       SBTypeCategory, operator=,(const lldb::SBTypeCategory &));
 729   LLDB_REGISTER_METHOD(bool,
 730                        SBTypeCategory, operator==,(lldb::SBTypeCategory &));
 731   LLDB_REGISTER_METHOD(bool,
 732                        SBTypeCategory, operator!=,(lldb::SBTypeCategory &));
 733 }
 734
 735 }
 736 }