contrib/llvm/tools/lldb/source/DataFormatters/FormatManager.cpp

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