1 //===-- FormatManager.cpp -------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/DataFormatters/FormatManager.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 17 #include "lldb/Core/Debugger.h" 18 #include "lldb/DataFormatters/CXXFormatterFunctions.h" 19 #include "lldb/DataFormatters/FormattersHelpers.h" 20 #include "lldb/DataFormatters/LanguageCategory.h" 21 #include "lldb/Target/ExecutionContext.h" 22 #include "lldb/Target/Platform.h" 23 #include "llvm/ADT/STLExtras.h" 24 25 #include <initializer_list> 26 27 using namespace lldb; 28 using namespace lldb_private; 29 using namespace lldb_private::formatters; 30 31 struct FormatInfo 32 { 33 Format format; 34 const char format_char; // One or more format characters that can be used for this format. 35 const char *format_name; // Long format name that can be used to specify the current format 36 }; 37 38 static FormatInfo 39 g_format_infos[] = 40 { 41 { eFormatDefault , '\0' , "default" }, 42 { eFormatBoolean , 'B' , "boolean" }, 43 { eFormatBinary , 'b' , "binary" }, 44 { eFormatBytes , 'y' , "bytes" }, 45 { eFormatBytesWithASCII , 'Y' , "bytes with ASCII" }, 46 { eFormatChar , 'c' , "character" }, 47 { eFormatCharPrintable , 'C' , "printable character" }, 48 { eFormatComplexFloat , 'F' , "complex float" }, 49 { eFormatCString , 's' , "c-string" }, 50 { eFormatDecimal , 'd' , "decimal" }, 51 { eFormatEnum , 'E' , "enumeration" }, 52 { eFormatHex , 'x' , "hex" }, 53 { eFormatHexUppercase , 'X' , "uppercase hex" }, 54 { eFormatFloat , 'f' , "float" }, 55 { eFormatOctal , 'o' , "octal" }, 56 { eFormatOSType , 'O' , "OSType" }, 57 { eFormatUnicode16 , 'U' , "unicode16" }, 58 { eFormatUnicode32 , '\0' , "unicode32" }, 59 { eFormatUnsigned , 'u' , "unsigned decimal" }, 60 { eFormatPointer , 'p' , "pointer" }, 61 { eFormatVectorOfChar , '\0' , "char[]" }, 62 { eFormatVectorOfSInt8 , '\0' , "int8_t[]" }, 63 { eFormatVectorOfUInt8 , '\0' , "uint8_t[]" }, 64 { eFormatVectorOfSInt16 , '\0' , "int16_t[]" }, 65 { eFormatVectorOfUInt16 , '\0' , "uint16_t[]" }, 66 { eFormatVectorOfSInt32 , '\0' , "int32_t[]" }, 67 { eFormatVectorOfUInt32 , '\0' , "uint32_t[]" }, 68 { eFormatVectorOfSInt64 , '\0' , "int64_t[]" }, 69 { eFormatVectorOfUInt64 , '\0' , "uint64_t[]" }, 70 { eFormatVectorOfFloat32, '\0' , "float32[]" }, 71 { eFormatVectorOfFloat64, '\0' , "float64[]" }, 72 { eFormatVectorOfUInt128, '\0' , "uint128_t[]" }, 73 { eFormatComplexInteger , 'I' , "complex integer" }, 74 { eFormatCharArray , 'a' , "character array" }, 75 { eFormatAddressInfo , 'A' , "address" }, 76 { eFormatHexFloat , '\0' , "hex float" }, 77 { eFormatInstruction , 'i' , "instruction" }, 78 { eFormatVoid , 'v' , "void" } 79 }; 80 81 static uint32_t g_num_format_infos = llvm::array_lengthof(g_format_infos); 82 83 static bool 84 GetFormatFromFormatChar (char format_char, Format &format) 85 { 86 for (uint32_t i=0; i<g_num_format_infos; ++i) 87 { 88 if (g_format_infos[i].format_char == format_char) 89 { 90 format = g_format_infos[i].format; 91 return true; 92 } 93 } 94 format = eFormatInvalid; 95 return false; 96 } 97 98 static bool 99 GetFormatFromFormatName (const char *format_name, bool partial_match_ok, Format &format) 100 { 101 uint32_t i; 102 for (i=0; i<g_num_format_infos; ++i) 103 { 104 if (strcasecmp (g_format_infos[i].format_name, format_name) == 0) 105 { 106 format = g_format_infos[i].format; 107 return true; 108 } 109 } 110 111 if (partial_match_ok) 112 { 113 for (i=0; i<g_num_format_infos; ++i) 114 { 115 if (strcasestr (g_format_infos[i].format_name, format_name) == g_format_infos[i].format_name) 116 { 117 format = g_format_infos[i].format; 118 return true; 119 } 120 } 121 } 122 format = eFormatInvalid; 123 return false; 124 } 125 126 bool 127 FormatManager::GetFormatFromCString (const char *format_cstr, 128 bool partial_match_ok, 129 lldb::Format &format) 130 { 131 bool success = false; 132 if (format_cstr && format_cstr[0]) 133 { 134 if (format_cstr[1] == '\0') 135 { 136 success = GetFormatFromFormatChar (format_cstr[0], format); 137 if (success) 138 return true; 139 } 140 141 success = GetFormatFromFormatName (format_cstr, partial_match_ok, format); 142 } 143 if (!success) 144 format = eFormatInvalid; 145 return success; 146 } 147 148 char 149 FormatManager::GetFormatAsFormatChar (lldb::Format format) 150 { 151 for (uint32_t i=0; i<g_num_format_infos; ++i) 152 { 153 if (g_format_infos[i].format == format) 154 return g_format_infos[i].format_char; 155 } 156 return '\0'; 157 } 158 159 const char * 160 FormatManager::GetFormatAsCString (Format format) 161 { 162 if (format >= eFormatDefault && format < kNumFormats) 163 return g_format_infos[format].format_name; 164 return NULL; 165 } 166 167 void 168 FormatManager::GetPossibleMatches (ValueObject& valobj, 169 CompilerType clang_type, 170 uint32_t reason, 171 lldb::DynamicValueType use_dynamic, 172 FormattersMatchVector& entries, 173 bool did_strip_ptr, 174 bool did_strip_ref, 175 bool did_strip_typedef, 176 bool root_level) 177 { 178 clang_type = ClangASTContext::RemoveFastQualifiers(clang_type); 179 ConstString type_name(clang_type.GetConstTypeName()); 180 if (valobj.GetBitfieldBitSize() > 0) 181 { 182 StreamString sstring; 183 sstring.Printf("%s:%d",type_name.AsCString(),valobj.GetBitfieldBitSize()); 184 ConstString bitfieldname = ConstString(sstring.GetData()); 185 entries.push_back({bitfieldname,0,did_strip_ptr,did_strip_ref,did_strip_typedef}); 186 reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField; 187 } 188 entries.push_back({type_name,reason,did_strip_ptr,did_strip_ref,did_strip_typedef}); 189 190 ConstString display_type_name(clang_type.GetDisplayTypeName()); 191 if (display_type_name != type_name) 192 entries.push_back({display_type_name,reason,did_strip_ptr,did_strip_ref,did_strip_typedef}); 193 194 for (bool is_rvalue_ref = true, j = true; j && clang_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) 195 { 196 CompilerType non_ref_type = clang_type.GetNonReferenceType(); 197 GetPossibleMatches(valobj, 198 non_ref_type, 199 reason | lldb_private::eFormatterChoiceCriterionStrippedPointerReference, 200 use_dynamic, 201 entries, 202 did_strip_ptr, 203 true, 204 did_strip_typedef); 205 if (non_ref_type.IsTypedefType()) 206 { 207 CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType(); 208 deffed_referenced_type = is_rvalue_ref ? ClangASTContext::GetRValueReferenceType(deffed_referenced_type) : ClangASTContext::GetLValueReferenceType(deffed_referenced_type); 209 GetPossibleMatches(valobj, 210 deffed_referenced_type, 211 reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs, 212 use_dynamic, 213 entries, 214 did_strip_ptr, 215 did_strip_ref, 216 true); // this is not exactly the usual meaning of stripping typedefs 217 } 218 } 219 220 if (clang_type.IsPointerType()) 221 { 222 CompilerType non_ptr_type = clang_type.GetPointeeType(); 223 GetPossibleMatches(valobj, 224 non_ptr_type, 225 reason | lldb_private::eFormatterChoiceCriterionStrippedPointerReference, 226 use_dynamic, 227 entries, 228 true, 229 did_strip_ref, 230 did_strip_typedef); 231 if (non_ptr_type.IsTypedefType()) 232 { 233 CompilerType deffed_pointed_type = non_ptr_type.GetTypedefedType().GetPointerType(); 234 GetPossibleMatches(valobj, 235 deffed_pointed_type, 236 reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs, 237 use_dynamic, 238 entries, 239 did_strip_ptr, 240 did_strip_ref, 241 true); // this is not exactly the usual meaning of stripping typedefs 242 } 243 } 244 bool canBeObjCDynamic = clang_type.IsPossibleDynamicType (NULL, 245 false, // no C 246 true); // yes ObjC 247 248 if (canBeObjCDynamic) 249 { 250 if (use_dynamic != lldb::eNoDynamicValues) 251 { 252 do 253 { 254 lldb::ProcessSP process_sp = valobj.GetProcessSP(); 255 if (!process_sp) 256 break; 257 ObjCLanguageRuntime* runtime = process_sp->GetObjCLanguageRuntime(); 258 if (runtime == nullptr) 259 break; 260 ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp (runtime->GetClassDescriptor(valobj)); 261 if (!objc_class_sp) 262 break; 263 ConstString name (objc_class_sp->GetClassName()); 264 entries.push_back({name,reason | lldb_private::eFormatterChoiceCriterionDynamicObjCDiscovery,did_strip_ptr,did_strip_ref,did_strip_typedef}); 265 } while (false); 266 } 267 268 CompilerType non_ptr_type = clang_type.GetPointeeType(); 269 GetPossibleMatches(valobj, 270 non_ptr_type, 271 reason | lldb_private::eFormatterChoiceCriterionStrippedPointerReference, 272 use_dynamic, 273 entries, 274 true, 275 did_strip_ref, 276 did_strip_typedef); 277 } 278 279 // try to strip typedef chains 280 if (clang_type.IsTypedefType()) 281 { 282 CompilerType deffed_type = clang_type.GetTypedefedType(); 283 GetPossibleMatches(valobj, 284 deffed_type, 285 reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs, 286 use_dynamic, 287 entries, 288 did_strip_ptr, 289 did_strip_ref, 290 true); 291 } 292 293 if (root_level) 294 { 295 do { 296 if (!clang_type.IsValid()) 297 break; 298 299 CompilerType unqual_clang_ast_type = clang_type.GetFullyUnqualifiedType(); 300 if (!unqual_clang_ast_type.IsValid()) 301 break; 302 if (unqual_clang_ast_type.GetOpaqueQualType() != clang_type.GetOpaqueQualType()) 303 GetPossibleMatches (valobj, 304 unqual_clang_ast_type, 305 reason, 306 use_dynamic, 307 entries, 308 did_strip_ptr, 309 did_strip_ref, 310 did_strip_typedef); 311 } while(false); 312 313 314 // if all else fails, go to static type 315 if (valobj.IsDynamic()) 316 { 317 lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue()); 318 if (static_value_sp) 319 GetPossibleMatches(*static_value_sp.get(), 320 static_value_sp->GetCompilerType(), 321 reason | lldb_private::eFormatterChoiceCriterionWentToStaticValue, 322 use_dynamic, 323 entries, 324 did_strip_ptr, 325 did_strip_ref, 326 did_strip_typedef, 327 true); 328 } 329 } 330 } 331 332 lldb::TypeFormatImplSP 333 FormatManager::GetFormatForType (lldb::TypeNameSpecifierImplSP type_sp) 334 { 335 if (!type_sp) 336 return lldb::TypeFormatImplSP(); 337 lldb::TypeFormatImplSP format_chosen_sp; 338 uint32_t num_categories = m_categories_map.GetCount(); 339 lldb::TypeCategoryImplSP category_sp; 340 uint32_t prio_category = UINT32_MAX; 341 for (uint32_t category_id = 0; 342 category_id < num_categories; 343 category_id++) 344 { 345 category_sp = GetCategoryAtIndex(category_id); 346 if (category_sp->IsEnabled() == false) 347 continue; 348 lldb::TypeFormatImplSP format_current_sp = category_sp->GetFormatForType(type_sp); 349 if (format_current_sp && (format_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition()))) 350 { 351 prio_category = category_sp->GetEnabledPosition(); 352 format_chosen_sp = format_current_sp; 353 } 354 } 355 return format_chosen_sp; 356 } 357 358 lldb::TypeSummaryImplSP 359 FormatManager::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp) 360 { 361 if (!type_sp) 362 return lldb::TypeSummaryImplSP(); 363 lldb::TypeSummaryImplSP summary_chosen_sp; 364 uint32_t num_categories = m_categories_map.GetCount(); 365 lldb::TypeCategoryImplSP category_sp; 366 uint32_t prio_category = UINT32_MAX; 367 for (uint32_t category_id = 0; 368 category_id < num_categories; 369 category_id++) 370 { 371 category_sp = GetCategoryAtIndex(category_id); 372 if (category_sp->IsEnabled() == false) 373 continue; 374 lldb::TypeSummaryImplSP summary_current_sp = category_sp->GetSummaryForType(type_sp); 375 if (summary_current_sp && (summary_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition()))) 376 { 377 prio_category = category_sp->GetEnabledPosition(); 378 summary_chosen_sp = summary_current_sp; 379 } 380 } 381 return summary_chosen_sp; 382 } 383 384 lldb::TypeFilterImplSP 385 FormatManager::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp) 386 { 387 if (!type_sp) 388 return lldb::TypeFilterImplSP(); 389 lldb::TypeFilterImplSP filter_chosen_sp; 390 uint32_t num_categories = m_categories_map.GetCount(); 391 lldb::TypeCategoryImplSP category_sp; 392 uint32_t prio_category = UINT32_MAX; 393 for (uint32_t category_id = 0; 394 category_id < num_categories; 395 category_id++) 396 { 397 category_sp = GetCategoryAtIndex(category_id); 398 if (category_sp->IsEnabled() == false) 399 continue; 400 lldb::TypeFilterImplSP filter_current_sp((TypeFilterImpl*)category_sp->GetFilterForType(type_sp).get()); 401 if (filter_current_sp && (filter_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition()))) 402 { 403 prio_category = category_sp->GetEnabledPosition(); 404 filter_chosen_sp = filter_current_sp; 405 } 406 } 407 return filter_chosen_sp; 408 } 409 410 #ifndef LLDB_DISABLE_PYTHON 411 lldb::ScriptedSyntheticChildrenSP 412 FormatManager::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp) 413 { 414 if (!type_sp) 415 return lldb::ScriptedSyntheticChildrenSP(); 416 lldb::ScriptedSyntheticChildrenSP synth_chosen_sp; 417 uint32_t num_categories = m_categories_map.GetCount(); 418 lldb::TypeCategoryImplSP category_sp; 419 uint32_t prio_category = UINT32_MAX; 420 for (uint32_t category_id = 0; 421 category_id < num_categories; 422 category_id++) 423 { 424 category_sp = GetCategoryAtIndex(category_id); 425 if (category_sp->IsEnabled() == false) 426 continue; 427 lldb::ScriptedSyntheticChildrenSP synth_current_sp((ScriptedSyntheticChildren*)category_sp->GetSyntheticForType(type_sp).get()); 428 if (synth_current_sp && (synth_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition()))) 429 { 430 prio_category = category_sp->GetEnabledPosition(); 431 synth_chosen_sp = synth_current_sp; 432 } 433 } 434 return synth_chosen_sp; 435 } 436 #endif 437 438 #ifndef LLDB_DISABLE_PYTHON 439 lldb::SyntheticChildrenSP 440 FormatManager::GetSyntheticChildrenForType (lldb::TypeNameSpecifierImplSP type_sp) 441 { 442 if (!type_sp) 443 return lldb::SyntheticChildrenSP(); 444 lldb::TypeFilterImplSP filter_sp = GetFilterForType(type_sp); 445 lldb::ScriptedSyntheticChildrenSP synth_sp = GetSyntheticForType(type_sp); 446 if (filter_sp->GetRevision() > synth_sp->GetRevision()) 447 return lldb::SyntheticChildrenSP(filter_sp.get()); 448 else 449 return lldb::SyntheticChildrenSP(synth_sp.get()); 450 } 451 #endif 452 453 lldb::TypeValidatorImplSP 454 FormatManager::GetValidatorForType (lldb::TypeNameSpecifierImplSP type_sp) 455 { 456 if (!type_sp) 457 return lldb::TypeValidatorImplSP(); 458 lldb::TypeValidatorImplSP validator_chosen_sp; 459 uint32_t num_categories = m_categories_map.GetCount(); 460 lldb::TypeCategoryImplSP category_sp; 461 uint32_t prio_category = UINT32_MAX; 462 for (uint32_t category_id = 0; 463 category_id < num_categories; 464 category_id++) 465 { 466 category_sp = GetCategoryAtIndex(category_id); 467 if (category_sp->IsEnabled() == false) 468 continue; 469 lldb::TypeValidatorImplSP validator_current_sp(category_sp->GetValidatorForType(type_sp).get()); 470 if (validator_current_sp && (validator_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition()))) 471 { 472 prio_category = category_sp->GetEnabledPosition(); 473 validator_chosen_sp = validator_current_sp; 474 } 475 } 476 return validator_chosen_sp; 477 } 478 479 void 480 FormatManager::LoopThroughCategories (CategoryCallback callback, void* param) 481 { 482 m_categories_map.LoopThrough(callback, param); 483 Mutex::Locker locker(m_language_categories_mutex); 484 for (const auto& entry : m_language_categories_map) 485 { 486 if (auto category_sp = entry.second->GetCategory()) 487 { 488 if (!callback(param, category_sp)) 489 break; 490 } 491 } 492 } 493 494 lldb::TypeCategoryImplSP 495 FormatManager::GetCategory (const ConstString& category_name, 496 bool can_create) 497 { 498 if (!category_name) 499 return GetCategory(m_default_category_name); 500 lldb::TypeCategoryImplSP category; 501 if (m_categories_map.Get(category_name, category)) 502 return category; 503 504 if (!can_create) 505 return lldb::TypeCategoryImplSP(); 506 507 m_categories_map.Add(category_name,lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name))); 508 return GetCategory(category_name); 509 } 510 511 lldb::Format 512 FormatManager::GetSingleItemFormat(lldb::Format vector_format) 513 { 514 switch(vector_format) 515 { 516 case eFormatVectorOfChar: 517 return eFormatCharArray; 518 519 case eFormatVectorOfSInt8: 520 case eFormatVectorOfSInt16: 521 case eFormatVectorOfSInt32: 522 case eFormatVectorOfSInt64: 523 return eFormatDecimal; 524 525 case eFormatVectorOfUInt8: 526 case eFormatVectorOfUInt16: 527 case eFormatVectorOfUInt32: 528 case eFormatVectorOfUInt64: 529 case eFormatVectorOfUInt128: 530 return eFormatHex; 531 532 case eFormatVectorOfFloat32: 533 case eFormatVectorOfFloat64: 534 return eFormatFloat; 535 536 default: 537 return lldb::eFormatInvalid; 538 } 539 } 540 541 bool 542 FormatManager::ShouldPrintAsOneLiner (ValueObject& valobj) 543 { 544 // if settings say no oneline whatsoever 545 if (valobj.GetTargetSP().get() && valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries() == false) 546 return false; // then don't oneline 547 548 // if this object has a summary, then ask the summary 549 if (valobj.GetSummaryFormat().get() != nullptr) 550 return valobj.GetSummaryFormat()->IsOneLiner(); 551 552 // no children, no party 553 if (valobj.GetNumChildren() == 0) 554 return false; 555 556 size_t total_children_name_len = 0; 557 558 for (size_t idx = 0; 559 idx < valobj.GetNumChildren(); 560 idx++) 561 { 562 bool is_synth_val = false; 563 ValueObjectSP child_sp(valobj.GetChildAtIndex(idx, true)); 564 // something is wrong here - bail out 565 if (!child_sp) 566 return false; 567 // if we decided to define synthetic children for a type, we probably care enough 568 // to show them, but avoid nesting children in children 569 if (child_sp->GetSyntheticChildren().get() != nullptr) 570 { 571 ValueObjectSP synth_sp(child_sp->GetSyntheticValue()); 572 // wait.. wat? just get out of here.. 573 if (!synth_sp) 574 return false; 575 // but if we only have them to provide a value, keep going 576 if (synth_sp->MightHaveChildren() == false && synth_sp->DoesProvideSyntheticValue()) 577 is_synth_val = true; 578 else 579 return false; 580 } 581 582 total_children_name_len += child_sp->GetName().GetLength(); 583 584 // 50 itself is a "randomly" chosen number - the idea is that 585 // overly long structs should not get this treatment 586 // FIXME: maybe make this a user-tweakable setting? 587 if (total_children_name_len > 50) 588 return false; 589 590 // if a summary is there.. 591 if (child_sp->GetSummaryFormat()) 592 { 593 // and it wants children, then bail out 594 if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get())) 595 return false; 596 } 597 598 // if this child has children.. 599 if (child_sp->GetNumChildren()) 600 { 601 // ...and no summary... 602 // (if it had a summary and the summary wanted children, we would have bailed out anyway 603 // so this only makes us bail out if this has no summary and we would then print children) 604 if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do that if not a synthetic valued child 605 return false; // then bail out 606 } 607 } 608 return true; 609 } 610 611 ConstString 612 FormatManager::GetValidTypeName (const ConstString& type) 613 { 614 return ::GetValidTypeName_Impl(type); 615 } 616 617 ConstString 618 FormatManager::GetTypeForCache (ValueObject& valobj, 619 lldb::DynamicValueType use_dynamic) 620 { 621 if (use_dynamic == lldb::eNoDynamicValues) 622 { 623 if (valobj.IsDynamic()) 624 { 625 if (valobj.GetStaticValue()) 626 return valobj.GetStaticValue()->GetQualifiedTypeName(); 627 else 628 return ConstString(); 629 } 630 else 631 return valobj.GetQualifiedTypeName(); 632 } 633 if (valobj.IsDynamic()) 634 return valobj.GetQualifiedTypeName(); 635 if (valobj.GetDynamicValue(use_dynamic)) 636 return valobj.GetDynamicValue(use_dynamic)->GetQualifiedTypeName(); 637 return ConstString(); 638 } 639 640 static std::vector<lldb::LanguageType> 641 GetCandidateLanguages (ValueObject& valobj) 642 { 643 lldb::LanguageType lang_type = valobj.GetObjectRuntimeLanguage(); 644 switch (lang_type) 645 { 646 default: 647 return {lang_type}; 648 } 649 } 650 651 LanguageCategory* 652 FormatManager::GetCategoryForLanguage (lldb::LanguageType lang_type) 653 { 654 Mutex::Locker locker(m_language_categories_mutex); 655 auto iter = m_language_categories_map.find(lang_type), end = m_language_categories_map.end(); 656 if (iter != end) 657 return iter->second.get(); 658 LanguageCategory* lang_category = new LanguageCategory(lang_type); 659 m_language_categories_map[lang_type] = LanguageCategory::UniquePointer(lang_category); 660 return lang_category; 661 } 662 663 lldb::TypeFormatImplSP 664 FormatManager::GetHardcodedFormat (ValueObject& valobj, 665 lldb::DynamicValueType use_dynamic) 666 { 667 for (const auto& candidate: m_hardcoded_formats) 668 { 669 auto result = candidate(valobj,use_dynamic,*this); 670 if (result) 671 return result; 672 } 673 return nullptr; 674 } 675 676 lldb::TypeFormatImplSP 677 FormatManager::GetFormat (ValueObject& valobj, 678 lldb::DynamicValueType use_dynamic) 679 { 680 TypeFormatImplSP retval; 681 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 682 ConstString valobj_type(GetTypeForCache(valobj, use_dynamic)); 683 if (valobj_type) 684 { 685 if (log) 686 log->Printf("\n\n[FormatManager::GetFormat] Looking into cache for type %s", valobj_type.AsCString("<invalid>")); 687 if (m_format_cache.GetFormat(valobj_type,retval)) 688 { 689 if (log) 690 { 691 log->Printf("[FormatManager::GetFormat] Cache search success. Returning."); 692 if (log->GetDebug()) 693 log->Printf("[FormatManager::GetFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses()); 694 } 695 return retval; 696 } 697 if (log) 698 log->Printf("[FormatManager::GetFormat] Cache search failed. Going normal route"); 699 } 700 701 FormattersMatchVector matches = GetPossibleMatches(valobj, use_dynamic); 702 703 retval = m_categories_map.GetFormat(valobj, use_dynamic, matches); 704 if (!retval) 705 { 706 if (log) 707 log->Printf("[FormatManager::GetFormat] Search failed. Giving language a chance."); 708 for (lldb::LanguageType lang_type : GetCandidateLanguages(valobj)) 709 { 710 if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type)) 711 { 712 if (lang_category->Get(valobj, use_dynamic, matches, retval)) 713 break; 714 } 715 } 716 if (retval) 717 { 718 if (log) 719 log->Printf("[FormatManager::GetFormat] Language search success. Returning."); 720 return retval; 721 } 722 } 723 if (!retval) 724 { 725 if (log) 726 log->Printf("[FormatManager::GetFormat] Search failed. Giving hardcoded a chance."); 727 retval = GetHardcodedFormat(valobj, use_dynamic); 728 } 729 730 if (valobj_type && (!retval || !retval->NonCacheable())) 731 { 732 if (log) 733 log->Printf("[FormatManager::GetFormat] Caching %p for type %s", 734 static_cast<void*>(retval.get()), 735 valobj_type.AsCString("<invalid>")); 736 m_format_cache.SetFormat(valobj_type,retval); 737 } 738 if (log && log->GetDebug()) 739 log->Printf("[FormatManager::GetFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses()); 740 return retval; 741 } 742 743 lldb::TypeSummaryImplSP 744 FormatManager::GetHardcodedSummaryFormat (ValueObject& valobj, 745 lldb::DynamicValueType use_dynamic) 746 { 747 for (const auto& candidate: m_hardcoded_summaries) 748 { 749 auto result = candidate(valobj,use_dynamic,*this); 750 if (result) 751 return result; 752 } 753 return nullptr; 754 } 755 756 lldb::TypeSummaryImplSP 757 FormatManager::GetSummaryFormat (ValueObject& valobj, 758 lldb::DynamicValueType use_dynamic) 759 { 760 TypeSummaryImplSP retval; 761 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 762 ConstString valobj_type(GetTypeForCache(valobj, use_dynamic)); 763 if (valobj_type) 764 { 765 if (log) 766 log->Printf("\n\n[FormatManager::GetSummaryFormat] Looking into cache for type %s", valobj_type.AsCString("<invalid>")); 767 if (m_format_cache.GetSummary(valobj_type,retval)) 768 { 769 if (log) 770 { 771 log->Printf("[FormatManager::GetSummaryFormat] Cache search success. Returning."); 772 if (log->GetDebug()) 773 log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses()); 774 } 775 return retval; 776 } 777 if (log) 778 log->Printf("[FormatManager::GetSummaryFormat] Cache search failed. Going normal route"); 779 } 780 781 FormattersMatchVector matches = GetPossibleMatches(valobj, use_dynamic); 782 783 retval = m_categories_map.GetSummaryFormat(valobj, use_dynamic, matches); 784 if (!retval) 785 { 786 if (log) 787 log->Printf("[FormatManager::GetSummaryFormat] Search failed. Giving language a chance."); 788 for (lldb::LanguageType lang_type : GetCandidateLanguages(valobj)) 789 { 790 if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type)) 791 { 792 if (lang_category->Get(valobj, use_dynamic, matches, retval)) 793 break; 794 } 795 } 796 if (retval) 797 { 798 if (log) 799 log->Printf("[FormatManager::GetSummaryFormat] Language search success. Returning."); 800 return retval; 801 } 802 } 803 if (!retval) 804 { 805 if (log) 806 log->Printf("[FormatManager::GetSummaryFormat] Search failed. Giving hardcoded a chance."); 807 retval = GetHardcodedSummaryFormat(valobj, use_dynamic); 808 } 809 810 if (valobj_type && (!retval || !retval->NonCacheable())) 811 { 812 if (log) 813 log->Printf("[FormatManager::GetSummaryFormat] Caching %p for type %s", 814 static_cast<void*>(retval.get()), 815 valobj_type.AsCString("<invalid>")); 816 m_format_cache.SetSummary(valobj_type,retval); 817 } 818 if (log && log->GetDebug()) 819 log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses()); 820 return retval; 821 } 822 823 #ifndef LLDB_DISABLE_PYTHON 824 lldb::SyntheticChildrenSP 825 FormatManager::GetHardcodedSyntheticChildren (ValueObject& valobj, 826 lldb::DynamicValueType use_dynamic) 827 { 828 for (const auto& candidate: m_hardcoded_synthetics) 829 { 830 auto result = candidate(valobj,use_dynamic,*this); 831 if (result) 832 return result; 833 } 834 return nullptr; 835 } 836 837 lldb::SyntheticChildrenSP 838 FormatManager::GetSyntheticChildren (ValueObject& valobj, 839 lldb::DynamicValueType use_dynamic) 840 { 841 SyntheticChildrenSP retval; 842 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 843 ConstString valobj_type(GetTypeForCache(valobj, use_dynamic)); 844 if (valobj_type) 845 { 846 if (log) 847 log->Printf("\n\n[FormatManager::GetSyntheticChildren] Looking into cache for type %s", valobj_type.AsCString("<invalid>")); 848 if (m_format_cache.GetSynthetic(valobj_type,retval)) 849 { 850 if (log) 851 { 852 log->Printf("[FormatManager::GetSyntheticChildren] Cache search success. Returning."); 853 if (log->GetDebug()) 854 log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses()); 855 } 856 return retval; 857 } 858 if (log) 859 log->Printf("[FormatManager::GetSyntheticChildren] Cache search failed. Going normal route"); 860 } 861 862 FormattersMatchVector matches = GetPossibleMatches(valobj, use_dynamic); 863 864 retval = m_categories_map.GetSyntheticChildren(valobj, use_dynamic, matches); 865 if (!retval) 866 { 867 if (log) 868 log->Printf("[FormatManager::GetSyntheticChildren] Search failed. Giving language a chance."); 869 for (lldb::LanguageType lang_type : GetCandidateLanguages(valobj)) 870 { 871 if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type)) 872 { 873 if (lang_category->Get(valobj, use_dynamic, matches, retval)) 874 break; 875 } 876 } 877 if (retval) 878 { 879 if (log) 880 log->Printf("[FormatManager::GetSyntheticChildren] Language search success. Returning."); 881 return retval; 882 } 883 } 884 if (!retval) 885 { 886 if (log) 887 log->Printf("[FormatManager::GetSyntheticChildren] Search failed. Giving hardcoded a chance."); 888 retval = GetHardcodedSyntheticChildren(valobj, use_dynamic); 889 } 890 891 if (valobj_type && (!retval || !retval->NonCacheable())) 892 { 893 if (log) 894 log->Printf("[FormatManager::GetSyntheticChildren] Caching %p for type %s", 895 static_cast<void*>(retval.get()), 896 valobj_type.AsCString("<invalid>")); 897 m_format_cache.SetSynthetic(valobj_type,retval); 898 } 899 if (log && log->GetDebug()) 900 log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses()); 901 return retval; 902 } 903 #endif 904 905 lldb::TypeValidatorImplSP 906 FormatManager::GetValidator (ValueObject& valobj, 907 lldb::DynamicValueType use_dynamic) 908 { 909 TypeValidatorImplSP retval; 910 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); 911 ConstString valobj_type(GetTypeForCache(valobj, use_dynamic)); 912 if (valobj_type) 913 { 914 if (log) 915 log->Printf("\n\n[FormatManager::GetValidator] Looking into cache for type %s", valobj_type.AsCString("<invalid>")); 916 if (m_format_cache.GetValidator(valobj_type,retval)) 917 { 918 if (log) 919 { 920 log->Printf("[FormatManager::GetValidator] Cache search success. Returning."); 921 if (log->GetDebug()) 922 log->Printf("[FormatManager::GetValidator] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses()); 923 } 924 return retval; 925 } 926 if (log) 927 log->Printf("[FormatManager::GetValidator] Cache search failed. Going normal route"); 928 } 929 930 FormattersMatchVector matches = GetPossibleMatches(valobj, use_dynamic); 931 932 retval = m_categories_map.GetValidator(valobj, use_dynamic, matches); 933 if (!retval) 934 { 935 if (log) 936 log->Printf("[FormatManager::GetValidator] Search failed. Giving language a chance."); 937 for (lldb::LanguageType lang_type : GetCandidateLanguages(valobj)) 938 { 939 if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type)) 940 { 941 if (lang_category->Get(valobj, use_dynamic, matches, retval)) 942 break; 943 } 944 } 945 if (retval) 946 { 947 if (log) 948 log->Printf("[FormatManager::GetValidator] Language search success. Returning."); 949 return retval; 950 } 951 } 952 if (!retval) 953 { 954 if (log) 955 log->Printf("[FormatManager::GetValidator] Search failed. Giving hardcoded a chance."); 956 retval = GetHardcodedValidator(valobj, use_dynamic); 957 } 958 959 if (valobj_type && (!retval || !retval->NonCacheable())) 960 { 961 if (log) 962 log->Printf("[FormatManager::GetValidator] Caching %p for type %s", 963 static_cast<void*>(retval.get()), 964 valobj_type.AsCString("<invalid>")); 965 m_format_cache.SetValidator(valobj_type,retval); 966 } 967 if (log && log->GetDebug()) 968 log->Printf("[FormatManager::GetValidator] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses()); 969 return retval; 970 } 971 972 lldb::TypeValidatorImplSP 973 FormatManager::GetHardcodedValidator (ValueObject& valobj, 974 lldb::DynamicValueType use_dynamic) 975 { 976 for (const auto& candidate: m_hardcoded_validators) 977 { 978 auto result = candidate(valobj,use_dynamic,*this); 979 if (result) 980 return result; 981 } 982 return nullptr; 983 } 984 985 FormatManager::FormatManager() : 986 m_format_cache(), 987 m_named_summaries_map(this), 988 m_last_revision(0), 989 m_categories_map(this), 990 m_language_categories_map(), 991 m_language_categories_mutex(Mutex::eMutexTypeRecursive), 992 m_default_category_name(ConstString("default")), 993 m_system_category_name(ConstString("system")), 994 m_gnu_cpp_category_name(ConstString("gnu-libstdc++")), 995 m_libcxx_category_name(ConstString("libcxx")), 996 m_objc_category_name(ConstString("objc")), 997 m_corefoundation_category_name(ConstString("CoreFoundation")), 998 m_coregraphics_category_name(ConstString("CoreGraphics")), 999 m_coreservices_category_name(ConstString("CoreServices")), 1000 m_vectortypes_category_name(ConstString("VectorTypes")), 1001 m_appkit_category_name(ConstString("AppKit")), 1002 m_coremedia_category_name(ConstString("CoreMedia")), 1003 m_hardcoded_formats(), 1004 m_hardcoded_summaries(), 1005 m_hardcoded_synthetics(), 1006 m_hardcoded_validators() 1007 1008 { 1009 LoadSystemFormatters(); 1010 LoadLibStdcppFormatters(); 1011 LoadLibcxxFormatters(); 1012 LoadObjCFormatters(); 1013 LoadCoreMediaFormatters(); 1014 LoadHardcodedFormatters(); 1015 1016 EnableCategory(m_objc_category_name,TypeCategoryMap::Last); 1017 EnableCategory(m_corefoundation_category_name,TypeCategoryMap::Last); 1018 EnableCategory(m_appkit_category_name,TypeCategoryMap::Last); 1019 EnableCategory(m_coreservices_category_name,TypeCategoryMap::Last); 1020 EnableCategory(m_coregraphics_category_name,TypeCategoryMap::Last); 1021 EnableCategory(m_coremedia_category_name,TypeCategoryMap::Last); 1022 EnableCategory(m_gnu_cpp_category_name,TypeCategoryMap::Last); 1023 EnableCategory(m_libcxx_category_name,TypeCategoryMap::Last); 1024 EnableCategory(m_vectortypes_category_name,TypeCategoryMap::Last); 1025 EnableCategory(m_system_category_name,TypeCategoryMap::Last); 1026 } 1027 1028 void 1029 FormatManager::LoadLibStdcppFormatters() 1030 { 1031 TypeSummaryImpl::Flags stl_summary_flags; 1032 stl_summary_flags.SetCascades(true) 1033 .SetSkipPointers(false) 1034 .SetSkipReferences(false) 1035 .SetDontShowChildren(true) 1036 .SetDontShowValue(true) 1037 .SetShowMembersOneLiner(false) 1038 .SetHideItemNames(false); 1039 1040 lldb::TypeSummaryImplSP std_string_summary_sp(new StringSummaryFormat(stl_summary_flags, 1041 "${var._M_dataplus._M_p}")); 1042 1043 TypeCategoryImpl::SharedPointer gnu_category_sp = GetCategory(m_gnu_cpp_category_name); 1044 1045 gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"), 1046 std_string_summary_sp); 1047 gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char>"), 1048 std_string_summary_sp); 1049 gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char,std::char_traits<char>,std::allocator<char> >"), 1050 std_string_summary_sp); 1051 gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"), 1052 std_string_summary_sp); 1053 1054 // making sure we force-pick the summary for printing wstring (_M_p is a wchar_t*) 1055 lldb::TypeSummaryImplSP std_wstring_summary_sp(new StringSummaryFormat(stl_summary_flags, 1056 "${var._M_dataplus._M_p%S}")); 1057 1058 gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"), 1059 std_wstring_summary_sp); 1060 gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t>"), 1061 std_wstring_summary_sp); 1062 gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >"), 1063 std_wstring_summary_sp); 1064 gnu_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"), 1065 std_wstring_summary_sp); 1066 1067 1068 #ifndef LLDB_DISABLE_PYTHON 1069 1070 SyntheticChildren::Flags stl_synth_flags; 1071 stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false); 1072 1073 gnu_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")), 1074 SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags, 1075 "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider"))); 1076 gnu_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")), 1077 SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags, 1078 "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider"))); 1079 gnu_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")), 1080 SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags, 1081 "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider"))); 1082 1083 stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(true); 1084 gnu_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")), 1085 TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, 1086 "size=${svar%#}"))); 1087 gnu_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")), 1088 TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, 1089 "size=${svar%#}"))); 1090 gnu_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")), 1091 TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, 1092 "size=${svar%#}"))); 1093 1094 AddCXXSynthetic(gnu_category_sp, lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true); 1095 1096 AddCXXSynthetic(gnu_category_sp, lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true); 1097 #endif 1098 } 1099 1100 void 1101 FormatManager::LoadLibcxxFormatters() 1102 { 1103 TypeSummaryImpl::Flags stl_summary_flags; 1104 stl_summary_flags.SetCascades(true) 1105 .SetSkipPointers(false) 1106 .SetSkipReferences(false) 1107 .SetDontShowChildren(true) 1108 .SetDontShowValue(true) 1109 .SetShowMembersOneLiner(false) 1110 .SetHideItemNames(false); 1111 1112 #ifndef LLDB_DISABLE_PYTHON 1113 //std::string code(" lldb.formatters.cpp.libcxx.stdstring_SummaryProvider(valobj,internal_dict)"); 1114 //lldb::TypeSummaryImplSP std_string_summary_sp(new ScriptSummaryFormat(stl_summary_flags, "lldb.formatters.cpp.libcxx.stdstring_SummaryProvider",code.c_str())); 1115 1116 lldb::TypeSummaryImplSP std_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxStringSummaryProvider, "std::string summary provider")); 1117 lldb::TypeSummaryImplSP std_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxWStringSummaryProvider, "std::wstring summary provider")); 1118 1119 TypeCategoryImpl::SharedPointer libcxx_category_sp = GetCategory(m_libcxx_category_name); 1120 1121 libcxx_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::string"), 1122 std_string_summary_sp); 1123 libcxx_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >"), 1124 std_string_summary_sp); 1125 1126 libcxx_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::wstring"), 1127 std_wstring_summary_sp); 1128 libcxx_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >"), 1129 std_wstring_summary_sp); 1130 1131 SyntheticChildren::Flags stl_synth_flags; 1132 stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false); 1133 1134 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, "libc++ std::vector synthetic children", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_synth_flags, true); 1135 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, "libc++ std::list synthetic children", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_synth_flags, true); 1136 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::map synthetic children", ConstString("^std::__1::map<.+> >(( )?&)?$"), stl_synth_flags, true); 1137 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_synth_flags); 1138 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags); 1139 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::set synthetic children", ConstString("^std::__1::set<.+> >(( )?&)?$"), stl_synth_flags, true); 1140 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multiset synthetic children", ConstString("^std::__1::multiset<.+> >(( )?&)?$"), stl_synth_flags, true); 1141 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multimap synthetic children", ConstString("^std::__1::multimap<.+> >(( )?&)?$"), stl_synth_flags, true); 1142 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, "libc++ std::unordered containers synthetic children", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_synth_flags, true); 1143 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator, "libc++ std::initializer_list synthetic children", ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags, true); 1144 1145 libcxx_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")), 1146 SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags, 1147 "lldb.formatters.cpp.libcxx.stddeque_SynthProvider"))); 1148 1149 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "shared_ptr synthetic children", ConstString("^(std::__1::)shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true); 1150 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "weak_ptr synthetic children", ConstString("^(std::__1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true); 1151 1152 stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(false); 1153 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags); 1154 1155 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector summary provider", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_summary_flags, true); 1156 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::list summary provider", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_summary_flags, true); 1157 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::map summary provider", ConstString("^std::__1::map<.+>(( )?&)?$"), stl_summary_flags, true); 1158 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::deque summary provider", ConstString("^std::__1::deque<.+>(( )?&)?$"), stl_summary_flags, true); 1159 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_summary_flags); 1160 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags); 1161 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::set summary provider", ConstString("^std::__1::set<.+>(( )?&)?$"), stl_summary_flags, true); 1162 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multiset summary provider", ConstString("^std::__1::multiset<.+>(( )?&)?$"), stl_summary_flags, true); 1163 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multimap summary provider", ConstString("^std::__1::multimap<.+>(( )?&)?$"), stl_summary_flags, true); 1164 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::unordered containers summary provider", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_summary_flags, true); 1165 1166 stl_summary_flags.SetSkipPointers(true); 1167 1168 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::shared_ptr summary provider", ConstString("^std::__1::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, true); 1169 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::weak_ptr summary provider", ConstString("^std::__1::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, true); 1170 1171 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^std::__1::__wrap_iter<.+>$"), stl_synth_flags, true); 1172 1173 AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags); 1174 AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::__1::__map_iterator<.+>$"), stl_synth_flags, true); 1175 1176 AddFilter(libcxx_category_sp, {"__a_"}, "libc++ std::atomic filter", ConstString("^std::__1::atomic<.*>$"), stl_synth_flags, true); 1177 #endif 1178 } 1179 1180 void 1181 FormatManager::LoadSystemFormatters() 1182 { 1183 1184 TypeSummaryImpl::Flags string_flags; 1185 string_flags.SetCascades(true) 1186 .SetSkipPointers(true) 1187 .SetSkipReferences(false) 1188 .SetDontShowChildren(true) 1189 .SetDontShowValue(false) 1190 .SetShowMembersOneLiner(false) 1191 .SetHideItemNames(false); 1192 1193 TypeSummaryImpl::Flags string_array_flags; 1194 string_array_flags.SetCascades(true) 1195 .SetSkipPointers(true) 1196 .SetSkipReferences(false) 1197 .SetDontShowChildren(true) 1198 .SetDontShowValue(true) 1199 .SetShowMembersOneLiner(false) 1200 .SetHideItemNames(false); 1201 1202 lldb::TypeSummaryImplSP string_format(new StringSummaryFormat(string_flags, "${var%s}")); 1203 1204 1205 lldb::TypeSummaryImplSP string_array_format(new StringSummaryFormat(string_array_flags, 1206 "${var%s}")); 1207 1208 lldb::RegularExpressionSP any_size_char_arr(new RegularExpression("char \\[[0-9]+\\]")); 1209 lldb::RegularExpressionSP any_size_wchar_arr(new RegularExpression("wchar_t \\[[0-9]+\\]")); 1210 1211 TypeCategoryImpl::SharedPointer sys_category_sp = GetCategory(m_system_category_name); 1212 1213 sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"), string_format); 1214 sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("unsigned char *"), string_format); 1215 sys_category_sp->GetRegexTypeSummariesContainer()->Add(any_size_char_arr, string_array_format); 1216 1217 lldb::TypeSummaryImplSP ostype_summary(new StringSummaryFormat(TypeSummaryImpl::Flags().SetCascades(false) 1218 .SetSkipPointers(true) 1219 .SetSkipReferences(true) 1220 .SetDontShowChildren(true) 1221 .SetDontShowValue(false) 1222 .SetShowMembersOneLiner(false) 1223 .SetHideItemNames(false), 1224 "${var%O}")); 1225 1226 sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"), ostype_summary); 1227 1228 #ifndef LLDB_DISABLE_PYTHON 1229 // FIXME because of a bug in the FormattersContainer we need to add a summary for both X* and const X* (<rdar://problem/12717717>) 1230 AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("char16_t *"), string_flags); 1231 1232 AddCXXSummary(sys_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("char32_t *"), string_flags); 1233 1234 AddCXXSummary(sys_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t *"), string_flags); 1235 AddCXXSummary(sys_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true); 1236 1237 AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "unichar * summary provider", ConstString("unichar *"), string_flags); 1238 1239 TypeSummaryImpl::Flags widechar_flags; 1240 widechar_flags.SetDontShowValue(true) 1241 .SetSkipPointers(true) 1242 .SetSkipReferences(false) 1243 .SetCascades(true) 1244 .SetDontShowChildren(true) 1245 .SetHideItemNames(true) 1246 .SetShowMembersOneLiner(false); 1247 1248 AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16SummaryProvider, "char16_t summary provider", ConstString("char16_t"), widechar_flags); 1249 AddCXXSummary(sys_category_sp, lldb_private::formatters::Char32SummaryProvider, "char32_t summary provider", ConstString("char32_t"), widechar_flags); 1250 AddCXXSummary(sys_category_sp, lldb_private::formatters::WCharSummaryProvider, "wchar_t summary provider", ConstString("wchar_t"), widechar_flags); 1251 1252 AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16SummaryProvider, "unichar summary provider", ConstString("unichar"), widechar_flags); 1253 1254 TypeFormatImpl::Flags fourchar_flags; 1255 fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(true); 1256 1257 AddFormat(sys_category_sp, lldb::eFormatOSType, ConstString("FourCharCode"), fourchar_flags); 1258 #endif 1259 } 1260 1261 void 1262 FormatManager::LoadObjCFormatters() 1263 { 1264 TypeSummaryImpl::Flags objc_flags; 1265 objc_flags.SetCascades(false) 1266 .SetSkipPointers(true) 1267 .SetSkipReferences(true) 1268 .SetDontShowChildren(true) 1269 .SetDontShowValue(true) 1270 .SetShowMembersOneLiner(false) 1271 .SetHideItemNames(false); 1272 1273 TypeCategoryImpl::SharedPointer objc_category_sp = GetCategory(m_objc_category_name); 1274 TypeCategoryImpl::SharedPointer appkit_category_sp = GetCategory(m_appkit_category_name); 1275 TypeCategoryImpl::SharedPointer corefoundation_category_sp = GetCategory(m_corefoundation_category_name); 1276 TypeCategoryImpl::SharedPointer coregraphics_category_sp = GetCategory(m_coregraphics_category_name); 1277 TypeCategoryImpl::SharedPointer coreservices_category_sp = GetCategory(m_coreservices_category_name); 1278 1279 lldb::TypeSummaryImplSP ObjC_BOOL_summary(new CXXFunctionSummaryFormat(objc_flags, lldb_private::formatters::ObjCBOOLSummaryProvider,"")); 1280 objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL"), 1281 ObjC_BOOL_summary); 1282 objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL &"), 1283 ObjC_BOOL_summary); 1284 objc_category_sp->GetTypeSummariesContainer()->Add(ConstString("BOOL *"), 1285 ObjC_BOOL_summary); 1286 1287 #ifndef LLDB_DISABLE_PYTHON 1288 // we need to skip pointers here since we are special casing a SEL* when retrieving its value 1289 objc_flags.SetSkipPointers(true); 1290 AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("SEL"), objc_flags); 1291 AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("struct objc_selector"), objc_flags); 1292 AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("objc_selector"), objc_flags); 1293 AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<true>, "SEL summary provider", ConstString("objc_selector *"), objc_flags); 1294 AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<true>, "SEL summary provider", ConstString("SEL *"), objc_flags); 1295 1296 AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCClassSummaryProvider, "Class summary provider", ConstString("Class"), objc_flags); 1297 1298 SyntheticChildren::Flags class_synth_flags; 1299 class_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false); 1300 1301 AddCXXSynthetic(objc_category_sp, lldb_private::formatters::ObjCClassSyntheticFrontEndCreator, "Class synthetic children", ConstString("Class"), class_synth_flags); 1302 #endif // LLDB_DISABLE_PYTHON 1303 1304 objc_flags.SetSkipPointers(false); 1305 objc_flags.SetCascades(true); 1306 objc_flags.SetSkipReferences(false); 1307 1308 AddStringSummary (objc_category_sp, 1309 "${var.__FuncPtr%A}", 1310 ConstString("__block_literal_generic"), 1311 objc_flags); 1312 1313 AddStringSummary(corefoundation_category_sp, 1314 "${var.years} years, ${var.months} months, ${var.days} days, ${var.hours} hours, ${var.minutes} minutes ${var.seconds} seconds", 1315 ConstString("CFGregorianUnits"), 1316 objc_flags); 1317 AddStringSummary(corefoundation_category_sp, 1318 "location=${var.location} length=${var.length}", 1319 ConstString("CFRange"), 1320 objc_flags); 1321 1322 AddStringSummary(appkit_category_sp, 1323 "location=${var.location}, length=${var.length}", 1324 ConstString("NSRange"), 1325 objc_flags); 1326 AddStringSummary(appkit_category_sp, 1327 "(${var.origin}, ${var.size}), ...", 1328 ConstString("NSRectArray"), 1329 objc_flags); 1330 1331 AddOneLineSummary (appkit_category_sp, 1332 ConstString("NSPoint"), 1333 objc_flags); 1334 AddOneLineSummary (appkit_category_sp, 1335 ConstString("NSSize"), 1336 objc_flags); 1337 AddOneLineSummary (appkit_category_sp, 1338 ConstString("NSRect"), 1339 objc_flags); 1340 1341 AddOneLineSummary (coregraphics_category_sp, 1342 ConstString("CGSize"), 1343 objc_flags); 1344 AddOneLineSummary (coregraphics_category_sp, 1345 ConstString("CGPoint"), 1346 objc_flags); 1347 AddOneLineSummary (coregraphics_category_sp, 1348 ConstString("CGRect"), 1349 objc_flags); 1350 1351 AddStringSummary(coreservices_category_sp, 1352 "red=${var.red} green=${var.green} blue=${var.blue}", 1353 ConstString("RGBColor"), 1354 objc_flags); 1355 AddStringSummary(coreservices_category_sp, 1356 "(t=${var.top}, l=${var.left}, b=${var.bottom}, r=${var.right})", 1357 ConstString("Rect"), 1358 objc_flags); 1359 AddStringSummary(coreservices_category_sp, 1360 "(v=${var.v}, h=${var.h})", 1361 ConstString("Point"), 1362 objc_flags); 1363 AddStringSummary(coreservices_category_sp, 1364 "${var.month}/${var.day}/${var.year} ${var.hour} :${var.minute} :${var.second} dayOfWeek:${var.dayOfWeek}", 1365 ConstString("DateTimeRect *"), 1366 objc_flags); 1367 AddStringSummary(coreservices_category_sp, 1368 "${var.ld.month}/${var.ld.day}/${var.ld.year} ${var.ld.hour} :${var.ld.minute} :${var.ld.second} dayOfWeek:${var.ld.dayOfWeek}", 1369 ConstString("LongDateRect"), 1370 objc_flags); 1371 AddStringSummary(coreservices_category_sp, 1372 "(x=${var.x}, y=${var.y})", 1373 ConstString("HIPoint"), 1374 objc_flags); 1375 AddStringSummary(coreservices_category_sp, 1376 "origin=${var.origin} size=${var.size}", 1377 ConstString("HIRect"), 1378 objc_flags); 1379 1380 TypeSummaryImpl::Flags appkit_flags; 1381 appkit_flags.SetCascades(true) 1382 .SetSkipPointers(false) 1383 .SetSkipReferences(false) 1384 .SetDontShowChildren(true) 1385 .SetDontShowValue(false) 1386 .SetShowMembersOneLiner(false) 1387 .SetHideItemNames(false); 1388 1389 appkit_flags.SetDontShowChildren(false); 1390 1391 1392 #ifndef LLDB_DISABLE_PYTHON 1393 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSArray"), appkit_flags); 1394 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSMutableArray"), appkit_flags); 1395 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayI"), appkit_flags); 1396 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayM"), appkit_flags); 1397 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSCFArray"), appkit_flags); 1398 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFArrayRef"), appkit_flags); 1399 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFMutableArrayRef"), appkit_flags); 1400 1401 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSDictionary"), appkit_flags); 1402 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSMutableDictionary"), appkit_flags); 1403 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSCFDictionary"), appkit_flags); 1404 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryI"), appkit_flags); 1405 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryM"), appkit_flags); 1406 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFDictionaryRef"), appkit_flags); 1407 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFMutableDictionaryRef"), appkit_flags); 1408 1409 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSSet summary", ConstString("NSSet"), appkit_flags); 1410 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags); 1411 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSSetSummaryProvider<true>, "CFSetRef summary", ConstString("CFSetRef"), appkit_flags); 1412 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSSetSummaryProvider<true>, "CFMutableSetRef summary", ConstString("CFMutableSetRef"), appkit_flags); 1413 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSCFSet summary", ConstString("__NSCFSet"), appkit_flags); 1414 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSSetI summary", ConstString("__NSSetI"), appkit_flags); 1415 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSSetM summary", ConstString("__NSSetM"), appkit_flags); 1416 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSCountedSet summary", ConstString("NSCountedSet"), appkit_flags); 1417 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags); 1418 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSOrderedSet summary", ConstString("NSOrderedSet"), appkit_flags); 1419 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSOrderedSetI summary", ConstString("__NSOrderedSetI"), appkit_flags); 1420 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSOrderedSetM summary", ConstString("__NSOrderedSetM"), appkit_flags); 1421 1422 // AddSummary(appkit_category_sp, "${var.key%@} -> ${var.value%@}", ConstString("$_lldb_typegen_nspair"), appkit_flags); 1423 1424 appkit_flags.SetDontShowChildren(true); 1425 1426 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayM"), ScriptedSyntheticChildren::Flags()); 1427 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayI"), ScriptedSyntheticChildren::Flags()); 1428 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSArray"), ScriptedSyntheticChildren::Flags()); 1429 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSMutableArray"), ScriptedSyntheticChildren::Flags()); 1430 AddCXXSynthetic(corefoundation_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSCFArray"), ScriptedSyntheticChildren::Flags()); 1431 AddCXXSynthetic(corefoundation_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("CFMutableArrayRef"), ScriptedSyntheticChildren::Flags()); 1432 AddCXXSynthetic(corefoundation_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("CFArrayRef"), ScriptedSyntheticChildren::Flags()); 1433 1434 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryM"), ScriptedSyntheticChildren::Flags()); 1435 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryI"), ScriptedSyntheticChildren::Flags()); 1436 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSCFDictionary"), ScriptedSyntheticChildren::Flags()); 1437 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSDictionary"), ScriptedSyntheticChildren::Flags()); 1438 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSMutableDictionary"), ScriptedSyntheticChildren::Flags()); 1439 AddCXXSynthetic(corefoundation_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("CFDictionaryRef"), ScriptedSyntheticChildren::Flags()); 1440 AddCXXSynthetic(corefoundation_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("CFMutableDictionaryRef"), ScriptedSyntheticChildren::Flags()); 1441 1442 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSSet synthetic children", ConstString("NSSet"), ScriptedSyntheticChildren::Flags()); 1443 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSSetI synthetic children", ConstString("__NSSetI"), ScriptedSyntheticChildren::Flags()); 1444 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSSetM synthetic children", ConstString("__NSSetM"), ScriptedSyntheticChildren::Flags()); 1445 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSMutableSet synthetic children", ConstString("NSMutableSet"), ScriptedSyntheticChildren::Flags()); 1446 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSOrderedSet synthetic children", ConstString("NSOrderedSet"), ScriptedSyntheticChildren::Flags()); 1447 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSOrderedSetI synthetic children", ConstString("__NSOrderedSetI"), ScriptedSyntheticChildren::Flags()); 1448 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSOrderedSetM synthetic children", ConstString("__NSOrderedSetM"), ScriptedSyntheticChildren::Flags()); 1449 1450 AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSIndexPathSyntheticFrontEndCreator, "NSIndexPath synthetic children", ConstString("NSIndexPath"), ScriptedSyntheticChildren::Flags()); 1451 1452 AddCXXSummary(corefoundation_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("CFBagRef"), appkit_flags); 1453 AddCXXSummary(corefoundation_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("__CFBag"), appkit_flags); 1454 AddCXXSummary(corefoundation_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("const struct __CFBag"), appkit_flags); 1455 AddCXXSummary(corefoundation_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("CFMutableBagRef"), appkit_flags); 1456 1457 AddCXXSummary(corefoundation_category_sp,lldb_private::formatters::CFBinaryHeapSummaryProvider, "CFBinaryHeap summary provider", ConstString("CFBinaryHeapRef"), appkit_flags); 1458 AddCXXSummary(corefoundation_category_sp,lldb_private::formatters::CFBinaryHeapSummaryProvider, "CFBinaryHeap summary provider", ConstString("__CFBinaryHeap"), appkit_flags); 1459 1460 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSString"), appkit_flags); 1461 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("CFStringRef"), appkit_flags); 1462 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__CFString"), appkit_flags); 1463 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("CFMutableStringRef"), appkit_flags); 1464 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSMutableString"), appkit_flags); 1465 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__NSCFConstantString"), appkit_flags); 1466 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__NSCFString"), appkit_flags); 1467 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFConstantString"), appkit_flags); 1468 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFString"), appkit_flags); 1469 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSPathStore2"), appkit_flags); 1470 1471 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSAttributedStringSummaryProvider, "NSAttributedString summary provider", ConstString("NSAttributedString"), appkit_flags); 1472 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSMutableAttributedStringSummaryProvider, "NSMutableAttributedString summary provider", ConstString("NSMutableAttributedString"), appkit_flags); 1473 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSMutableAttributedStringSummaryProvider, "NSMutableAttributedString summary provider", ConstString("NSConcreteMutableAttributedString"), appkit_flags); 1474 1475 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSBundleSummaryProvider, "NSBundle summary provider", ConstString("NSBundle"), appkit_flags); 1476 1477 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSData"), appkit_flags); 1478 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteData"), appkit_flags); 1479 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteMutableData"), appkit_flags); 1480 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSMutableData"), appkit_flags); 1481 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("__NSCFData"), appkit_flags); 1482 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>, "NSData summary provider", ConstString("CFDataRef"), appkit_flags); 1483 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>, "NSData summary provider", ConstString("CFMutableDataRef"), appkit_flags); 1484 1485 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSMachPortSummaryProvider, "NSMachPort summary provider", ConstString("NSMachPort"), appkit_flags); 1486 1487 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNotificationSummaryProvider, "NSNotification summary provider", ConstString("NSNotification"), appkit_flags); 1488 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNotificationSummaryProvider, "NSNotification summary provider", ConstString("NSConcreteNotification"), appkit_flags); 1489 1490 AddStringSummary(appkit_category_sp, "domain: ${var._domain} - code: ${var._code}", ConstString("NSError"), appkit_flags); 1491 AddStringSummary(appkit_category_sp,"name:${var.name%S} reason:${var.reason%S}",ConstString("NSException"),appkit_flags); 1492 1493 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSNumber"), appkit_flags); 1494 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "CFNumberRef summary provider", ConstString("CFNumberRef"), appkit_flags); 1495 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFBoolean"), appkit_flags); 1496 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFNumber"), appkit_flags); 1497 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFBoolean"), appkit_flags); 1498 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFNumber"), appkit_flags); 1499 1500 AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSDecimalNumber summary provider", ConstString("NSDecimalNumber"), appkit_flags); 1501 AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSHost summary provider", ConstString("NSHost"), appkit_flags); 1502 AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSTask summary provider", ConstString("NSTask"), appkit_flags); 1503 AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSValue summary provider", ConstString("NSValue"), appkit_flags); 1504 1505 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSURLSummaryProvider, "NSURL summary provider", ConstString("NSURL"), appkit_flags); 1506 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSURLSummaryProvider, "NSURL summary provider", ConstString("CFURLRef"), appkit_flags); 1507 1508 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("NSDate"), appkit_flags); 1509 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("__NSDate"), appkit_flags); 1510 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("__NSTaggedDate"), appkit_flags); 1511 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("NSCalendarDate"), appkit_flags); 1512 1513 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("NSTimeZone"), appkit_flags); 1514 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("CFTimeZoneRef"), appkit_flags); 1515 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("__NSTimeZone"), appkit_flags); 1516 1517 // CFAbsoluteTime is actually a double rather than a pointer to an object 1518 // we do not care about the numeric value, since it is probably meaningless to users 1519 appkit_flags.SetDontShowValue(true); 1520 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::CFAbsoluteTimeSummaryProvider, "CFAbsoluteTime summary provider", ConstString("CFAbsoluteTime"), appkit_flags); 1521 appkit_flags.SetDontShowValue(false); 1522 1523 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSIndexSetSummaryProvider, "NSIndexSet summary provider", ConstString("NSIndexSet"), appkit_flags); 1524 AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSIndexSetSummaryProvider, "NSIndexSet summary provider", ConstString("NSMutableIndexSet"), appkit_flags); 1525 1526 AddStringSummary(corefoundation_category_sp, 1527 "@\"${var.month%d}/${var.day%d}/${var.year%d} ${var.hour%d}:${var.minute%d}:${var.second}\"", 1528 ConstString("CFGregorianDate"), 1529 appkit_flags); 1530 1531 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("CFBitVectorRef"), appkit_flags); 1532 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("CFMutableBitVectorRef"), appkit_flags); 1533 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("__CFBitVector"), appkit_flags); 1534 AddCXXSummary(corefoundation_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("__CFMutableBitVector"), appkit_flags); 1535 #endif // LLDB_DISABLE_PYTHON 1536 1537 TypeCategoryImpl::SharedPointer vectors_category_sp = GetCategory(m_vectortypes_category_name); 1538 1539 TypeSummaryImpl::Flags vector_flags; 1540 vector_flags.SetCascades(true) 1541 .SetSkipPointers(true) 1542 .SetSkipReferences(false) 1543 .SetDontShowChildren(true) 1544 .SetDontShowValue(false) 1545 .SetShowMembersOneLiner(true) 1546 .SetHideItemNames(true); 1547 1548 AddStringSummary(vectors_category_sp, 1549 "${var.uint128}", 1550 ConstString("builtin_type_vec128"), 1551 objc_flags); 1552 1553 AddStringSummary(vectors_category_sp, 1554 "", 1555 ConstString("float [4]"), 1556 vector_flags); 1557 AddStringSummary(vectors_category_sp, 1558 "", 1559 ConstString("int32_t [4]"), 1560 vector_flags); 1561 AddStringSummary(vectors_category_sp, 1562 "", 1563 ConstString("int16_t [8]"), 1564 vector_flags); 1565 AddStringSummary(vectors_category_sp, 1566 "", 1567 ConstString("vDouble"), 1568 vector_flags); 1569 AddStringSummary(vectors_category_sp, 1570 "", 1571 ConstString("vFloat"), 1572 vector_flags); 1573 AddStringSummary(vectors_category_sp, 1574 "", 1575 ConstString("vSInt8"), 1576 vector_flags); 1577 AddStringSummary(vectors_category_sp, 1578 "", 1579 ConstString("vSInt16"), 1580 vector_flags); 1581 AddStringSummary(vectors_category_sp, 1582 "", 1583 ConstString("vSInt32"), 1584 vector_flags); 1585 AddStringSummary(vectors_category_sp, 1586 "", 1587 ConstString("vUInt16"), 1588 vector_flags); 1589 AddStringSummary(vectors_category_sp, 1590 "", 1591 ConstString("vUInt8"), 1592 vector_flags); 1593 AddStringSummary(vectors_category_sp, 1594 "", 1595 ConstString("vUInt16"), 1596 vector_flags); 1597 AddStringSummary(vectors_category_sp, 1598 "", 1599 ConstString("vUInt32"), 1600 vector_flags); 1601 AddStringSummary(vectors_category_sp, 1602 "", 1603 ConstString("vBool32"), 1604 vector_flags); 1605 } 1606 1607 void 1608 FormatManager::LoadCoreMediaFormatters() 1609 { 1610 TypeSummaryImpl::Flags cm_flags; 1611 cm_flags.SetCascades(true) 1612 .SetDontShowChildren(false) 1613 .SetDontShowValue(false) 1614 .SetHideItemNames(false) 1615 .SetShowMembersOneLiner(false) 1616 .SetSkipPointers(false) 1617 .SetSkipReferences(false); 1618 1619 TypeCategoryImpl::SharedPointer cm_category_sp = GetCategory(m_coremedia_category_name); 1620 1621 #ifndef LLDB_DISABLE_PYTHON 1622 AddCXXSummary(cm_category_sp, lldb_private::formatters::CMTimeSummaryProvider, "CMTime summary provider", ConstString("CMTime"), cm_flags); 1623 #endif // LLDB_DISABLE_PYTHON 1624 } 1625 1626 void 1627 FormatManager::LoadHardcodedFormatters() 1628 { 1629 { 1630 // insert code to load formats here 1631 } 1632 { 1633 // insert code to load summaries here 1634 m_hardcoded_summaries.push_back( 1635 [](lldb_private::ValueObject& valobj, 1636 lldb::DynamicValueType, 1637 FormatManager&) -> TypeSummaryImpl::SharedPointer { 1638 static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat(TypeSummaryImpl::Flags(), lldb_private::formatters::FunctionPointerSummaryProvider, "Function pointer summary provider")); 1639 if (valobj.GetCompilerType().IsFunctionPointerType()) 1640 { 1641 return formatter_sp; 1642 } 1643 return nullptr; 1644 }); 1645 m_hardcoded_summaries.push_back( 1646 [](lldb_private::ValueObject& valobj, 1647 lldb::DynamicValueType, 1648 FormatManager& fmt_mgr) -> TypeSummaryImpl::SharedPointer { 1649 static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat(TypeSummaryImpl::Flags() 1650 .SetCascades(true) 1651 .SetDontShowChildren(true) 1652 .SetHideItemNames(true) 1653 .SetShowMembersOneLiner(true) 1654 .SetSkipPointers(true) 1655 .SetSkipReferences(false), 1656 lldb_private::formatters::VectorTypeSummaryProvider, 1657 "vector_type pointer summary provider")); 1658 if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) 1659 { 1660 if (fmt_mgr.GetCategory(fmt_mgr.m_vectortypes_category_name)->IsEnabled()) 1661 return formatter_sp; 1662 } 1663 return nullptr; 1664 }); 1665 } 1666 { 1667 // insert code to load synthetics here 1668 m_hardcoded_synthetics.push_back( 1669 [](lldb_private::ValueObject& valobj, 1670 lldb::DynamicValueType, 1671 FormatManager& fmt_mgr) -> SyntheticChildren::SharedPointer { 1672 static CXXSyntheticChildren::SharedPointer formatter_sp(new CXXSyntheticChildren(SyntheticChildren::Flags().SetCascades(true).SetSkipPointers(true).SetSkipReferences(true).SetNonCacheable(true), 1673 "vector_type synthetic children", 1674 lldb_private::formatters::VectorTypeSyntheticFrontEndCreator)); 1675 if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) 1676 { 1677 if (fmt_mgr.GetCategory(fmt_mgr.m_vectortypes_category_name)->IsEnabled()) 1678 return formatter_sp; 1679 } 1680 return nullptr; 1681 }); 1682 } 1683 { 1684 // insert code to load validators here 1685 } 1686 } 1687