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 } 738