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