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

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