<rdar://problem/12978143>

Data formatters now cache themselves.
This commit provides a new formatter cache mechanism. Upon resolving a formatter (summary or synthetic), LLDB remembers the resolution for later faster retrieval.
Also moved the data formatters subsystem from the core to its own group and folder for easier management, and done some code reorganization.
The ObjC runtime v1 now returns a class name if asked for the dynamic type of an object. This is required for formatters caching to work with the v1 runtime.
Lastly, this commit disposes of the old hack where ValueObjects had to remember whether they were queried for formatters with their static or dynamic type.
Now the ValueObjectDynamicValue class works well enough that we can use its dynamic value setting for the same purpose.

llvm-svn: 173728

1 files changed, 1033 insertions, 0 deletions

diff --git a/lldb/source/DataFormatters/FormatManager.cpp b/lldb/source/DataFormatters/FormatManager.cpp
new file mode 100644
index 00000000000..7ea8fbb85b0
--- /dev/null
+++ b/lldb/source/DataFormatters/FormatManager.cpp
@@ -0,0 +1,1033 @@
+//===-- FormatManager.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/lldb-python.h"
+
+#include "lldb/DataFormatters/FormatManager.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+#include "lldb/Interpreter/ScriptInterpreterPython.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Platform.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+
+struct FormatInfo
+{
+    Format format;
+    const char format_char; // One or more format characters that can be used for this format.
+    const char *format_name;    // Long format name that can be used to specify the current format
+};
+
+static FormatInfo 
+g_format_infos[] = 
+{
+    { eFormatDefault        , '\0'  , "default"             },
+    { eFormatBoolean        , 'B'   , "boolean"             },
+    { eFormatBinary         , 'b'   , "binary"              },
+    { eFormatBytes          , 'y'   , "bytes"               },
+    { eFormatBytesWithASCII , 'Y'   , "bytes with ASCII"    },
+    { eFormatChar           , 'c'   , "character"           },
+    { eFormatCharPrintable  , 'C'   , "printable character" },
+    { eFormatComplexFloat   , 'F'   , "complex float"       },
+    { eFormatCString        , 's'   , "c-string"            },
+    { eFormatDecimal        , 'd'   , "decimal"             },
+    { eFormatEnum           , 'E'   , "enumeration"         },
+    { eFormatHex            , 'x'   , "hex"                 },
+    { eFormatHexUppercase   , 'X'   , "uppercase hex"       },
+    { eFormatFloat          , 'f'   , "float"               },
+    { eFormatOctal          , 'o'   , "octal"               },
+    { eFormatOSType         , 'O'   , "OSType"              },
+    { eFormatUnicode16      , 'U'   , "unicode16"           },
+    { eFormatUnicode32      , '\0'  , "unicode32"           },
+    { eFormatUnsigned       , 'u'   , "unsigned decimal"    },
+    { eFormatPointer        , 'p'   , "pointer"             },
+    { eFormatVectorOfChar   , '\0'  , "char[]"              },
+    { eFormatVectorOfSInt8  , '\0'  , "int8_t[]"            },
+    { eFormatVectorOfUInt8  , '\0'  , "uint8_t[]"           },
+    { eFormatVectorOfSInt16 , '\0'  , "int16_t[]"           },
+    { eFormatVectorOfUInt16 , '\0'  , "uint16_t[]"          },
+    { eFormatVectorOfSInt32 , '\0'  , "int32_t[]"           },
+    { eFormatVectorOfUInt32 , '\0'  , "uint32_t[]"          },
+    { eFormatVectorOfSInt64 , '\0'  , "int64_t[]"           },
+    { eFormatVectorOfUInt64 , '\0'  , "uint64_t[]"          },
+    { eFormatVectorOfFloat32, '\0'  , "float32[]"           },
+    { eFormatVectorOfFloat64, '\0'  , "float64[]"           },
+    { eFormatVectorOfUInt128, '\0'  , "uint128_t[]"         },
+    { eFormatComplexInteger , 'I'   , "complex integer"     },
+    { eFormatCharArray      , 'a'   , "character array"     },
+    { eFormatAddressInfo    , 'A'   , "address"             },
+    { eFormatHexFloat       , '\0'  , "hex float"           },
+    { eFormatInstruction    , 'i'   , "instruction"         },
+    { eFormatVoid           , 'v'   , "void"                }
+};
+
+static uint32_t 
+g_num_format_infos = sizeof(g_format_infos)/sizeof(FormatInfo);
+
+static bool
+GetFormatFromFormatChar (char format_char, Format &format)
+{
+    for (uint32_t i=0; i<g_num_format_infos; ++i)
+    {
+        if (g_format_infos[i].format_char == format_char)
+        {
+            format = g_format_infos[i].format;
+            return true;
+        }
+    }
+    format = eFormatInvalid;
+    return false;
+}
+
+static bool
+GetFormatFromFormatName (const char *format_name, bool partial_match_ok, Format &format)
+{
+    uint32_t i;
+    for (i=0; i<g_num_format_infos; ++i)
+    {
+        if (strcasecmp (g_format_infos[i].format_name, format_name) == 0)
+        {
+            format = g_format_infos[i].format;
+            return true;
+        }
+    }
+    
+    if (partial_match_ok)
+    {
+        for (i=0; i<g_num_format_infos; ++i)
+        {
+            if (strcasestr (g_format_infos[i].format_name, format_name) == g_format_infos[i].format_name)
+            {
+                format = g_format_infos[i].format;
+                return true;
+            }
+        }
+    }
+    format = eFormatInvalid;
+    return false;
+}
+
+bool
+FormatManager::GetFormatFromCString (const char *format_cstr,
+                                     bool partial_match_ok,
+                                     lldb::Format &format)
+{
+    bool success = false;
+    if (format_cstr && format_cstr[0])
+    {
+        if (format_cstr[1] == '\0')
+        {
+            success = GetFormatFromFormatChar (format_cstr[0], format);
+            if (success)
+                return true;
+        }
+        
+        success = GetFormatFromFormatName (format_cstr, partial_match_ok, format);
+    }
+    if (!success)
+        format = eFormatInvalid;
+    return success;
+}
+
+char
+FormatManager::GetFormatAsFormatChar (lldb::Format format)
+{
+    for (uint32_t i=0; i<g_num_format_infos; ++i)
+    {
+        if (g_format_infos[i].format == format)
+            return g_format_infos[i].format_char;
+    }
+    return '\0';
+}
+
+const char *
+FormatManager::GetFormatAsCString (Format format)
+{
+    if (format >= eFormatDefault && format < kNumFormats)
+        return g_format_infos[format].format_name;
+    return NULL;
+}
+
+lldb::TypeSummaryImplSP
+FormatManager::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    if (!type_sp)
+        return lldb::TypeSummaryImplSP();
+    lldb::TypeSummaryImplSP summary_chosen_sp;
+    uint32_t num_categories = m_categories_map.GetCount();
+    lldb::TypeCategoryImplSP category_sp;
+    uint32_t prio_category = UINT32_MAX;
+    for (uint32_t category_id = 0;
+         category_id < num_categories;
+         category_id++)
+    {
+        category_sp = GetCategoryAtIndex(category_id);
+        if (category_sp->IsEnabled() == false)
+            continue;
+        lldb::TypeSummaryImplSP summary_current_sp = category_sp->GetSummaryForType(type_sp);
+        if (summary_current_sp && (summary_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
+        {
+            prio_category = category_sp->GetEnabledPosition();
+            summary_chosen_sp = summary_current_sp;
+        }
+    }
+    return summary_chosen_sp;
+}
+
+lldb::TypeFilterImplSP
+FormatManager::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    if (!type_sp)
+        return lldb::TypeFilterImplSP();
+    lldb::TypeFilterImplSP filter_chosen_sp;
+    uint32_t num_categories = m_categories_map.GetCount();
+    lldb::TypeCategoryImplSP category_sp;
+    uint32_t prio_category = UINT32_MAX;
+    for (uint32_t category_id = 0;
+         category_id < num_categories;
+         category_id++)
+    {
+        category_sp = GetCategoryAtIndex(category_id);
+        if (category_sp->IsEnabled() == false)
+            continue;
+        lldb::TypeFilterImplSP filter_current_sp((TypeFilterImpl*)category_sp->GetFilterForType(type_sp).get());
+        if (filter_current_sp && (filter_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
+        {
+            prio_category = category_sp->GetEnabledPosition();
+            filter_chosen_sp = filter_current_sp;
+        }
+    }
+    return filter_chosen_sp;
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::ScriptedSyntheticChildrenSP
+FormatManager::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    if (!type_sp)
+        return lldb::ScriptedSyntheticChildrenSP();
+    lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
+    uint32_t num_categories = m_categories_map.GetCount();
+    lldb::TypeCategoryImplSP category_sp;
+    uint32_t prio_category = UINT32_MAX;
+    for (uint32_t category_id = 0;
+         category_id < num_categories;
+         category_id++)
+    {
+        category_sp = GetCategoryAtIndex(category_id);
+        if (category_sp->IsEnabled() == false)
+            continue;
+        lldb::ScriptedSyntheticChildrenSP synth_current_sp((ScriptedSyntheticChildren*)category_sp->GetSyntheticForType(type_sp).get());
+        if (synth_current_sp && (synth_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
+        {
+            prio_category = category_sp->GetEnabledPosition();
+            synth_chosen_sp = synth_current_sp;
+        }
+    }
+    return synth_chosen_sp;
+}
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::SyntheticChildrenSP
+FormatManager::GetSyntheticChildrenForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    if (!type_sp)
+        return lldb::SyntheticChildrenSP();
+    lldb::TypeFilterImplSP filter_sp = GetFilterForType(type_sp);
+    lldb::ScriptedSyntheticChildrenSP synth_sp = GetSyntheticForType(type_sp);
+    if (filter_sp->GetRevision() > synth_sp->GetRevision())
+        return lldb::SyntheticChildrenSP(filter_sp.get());
+    else
+        return lldb::SyntheticChildrenSP(synth_sp.get());
+}
+#endif
+
+lldb::TypeCategoryImplSP
+FormatManager::GetCategory (const ConstString& category_name,
+                         bool can_create)
+{
+    if (!category_name)
+        return GetCategory(m_default_category_name);
+    lldb::TypeCategoryImplSP category;
+    if (m_categories_map.Get(category_name, category))
+        return category;
+    
+    if (!can_create)
+        return lldb::TypeCategoryImplSP();
+    
+    m_categories_map.Add(category_name,lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
+    return GetCategory(category_name);
+}
+
+lldb::Format
+FormatManager::GetSingleItemFormat(lldb::Format vector_format)
+{
+    switch(vector_format)
+    {
+        case eFormatVectorOfChar:
+            return eFormatCharArray;
+            
+        case eFormatVectorOfSInt8:
+        case eFormatVectorOfSInt16:
+        case eFormatVectorOfSInt32:
+        case eFormatVectorOfSInt64:
+            return eFormatDecimal;
+            
+        case eFormatVectorOfUInt8:
+        case eFormatVectorOfUInt16:
+        case eFormatVectorOfUInt32:
+        case eFormatVectorOfUInt64:
+        case eFormatVectorOfUInt128:
+            return eFormatHex;
+            
+        case eFormatVectorOfFloat32:
+        case eFormatVectorOfFloat64:
+            return eFormatFloat;
+            
+        default:
+            return lldb::eFormatInvalid;
+    }
+}
+
+ConstString
+FormatManager::GetValidTypeName (const ConstString& type)
+{
+    return ::GetValidTypeName_Impl(type);
+}
+
+ConstString
+GetTypeForCache (ValueObject& valobj,
+                 lldb::DynamicValueType use_dynamic)
+{
+    if (use_dynamic == lldb::eNoDynamicValues)
+    {
+        if (valobj.IsDynamic())
+        {
+            if (valobj.GetStaticValue())
+                return valobj.GetStaticValue()->GetQualifiedTypeName();
+            else
+                return ConstString();
+        }
+        else
+            return valobj.GetQualifiedTypeName();
+    }
+    if (valobj.IsDynamic())
+        return valobj.GetQualifiedTypeName();
+    if (valobj.GetDynamicValue(use_dynamic))
+        return valobj.GetDynamicValue(use_dynamic)->GetQualifiedTypeName();
+    return ConstString();
+}
+
+#define USE_CACHE 1
+lldb::TypeSummaryImplSP
+FormatManager::GetSummaryFormat (ValueObject& valobj,
+                                 lldb::DynamicValueType use_dynamic)
+{
+    TypeSummaryImplSP retval;
+#if USE_CACHE
+    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
+    ConstString valobj_type(GetTypeForCache(valobj, use_dynamic));
+    if (valobj_type)
+    {
+        if (log)
+            log->Printf("[FormatManager::GetSummaryFormat] Looking into cache for type %s", valobj_type.AsCString("<invalid>"));
+        if (m_format_cache.GetSummary(valobj_type,retval))
+            return retval;
+        if (log)
+            log->Printf("[FormatManager::GetSummaryFormat] Cache search failed. Going normal route");
+    }
+#endif
+    retval = m_categories_map.GetSummaryFormat(valobj, use_dynamic);
+#if USE_CACHE
+    if (valobj_type)
+    {
+        if (log)
+            log->Printf("[FormatManager::GetSummaryFormat] Caching %p for type %s",retval.get(),valobj_type.AsCString("<invalid>"));
+        m_format_cache.SetSummary(valobj_type,retval);
+    }
+#ifdef LLDB_CONFIGURATION_DEBUG
+    if (log)
+        log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %llu - Cache Misses: %llu", m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+#endif
+#endif
+    return retval;
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::SyntheticChildrenSP
+FormatManager::GetSyntheticChildren (ValueObject& valobj,
+                      lldb::DynamicValueType use_dynamic)
+{
+    SyntheticChildrenSP retval;
+#if USE_CACHE
+    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
+    ConstString valobj_type(GetTypeForCache(valobj, use_dynamic));
+    if (valobj_type)
+    {
+        if (log)
+            log->Printf("[FormatManager::GetSyntheticChildren] Looking into cache for type %s\n", valobj_type.AsCString("<invalid>"));
+        if (m_format_cache.GetSynthetic(valobj_type,retval))
+            return retval;
+        if (log)
+            log->Printf("[FormatManager::GetSyntheticChildren] Cache search failed. Going normal route\n");
+    }
+#endif
+    retval = m_categories_map.GetSyntheticChildren(valobj, use_dynamic);
+#if USE_CACHE
+    if (valobj_type)
+    {
+        if (log)
+            log->Printf("[FormatManager::GetSyntheticChildren] Caching %p for type %s\n",retval.get(),valobj_type.AsCString("<invalid>"));
+        m_format_cache.SetSynthetic(valobj_type,retval);
+    }
+#ifdef LLDB_CONFIGURATION_DEBUG
+    if (log)
+        log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %llu - Cache Misses: %llu", m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+#endif
+#endif
+    return retval;
+}
+#endif
+#undef USE_CACHE
+
+FormatManager::FormatManager() :
+    m_format_cache(),
+    m_value_nav("format",this),
+    m_named_summaries_map(this),
+    m_last_revision(0),
+    m_categories_map(this),
+    m_default_category_name(ConstString("default")),
+    m_system_category_name(ConstString("system")), 
+    m_gnu_cpp_category_name(ConstString("gnu-libstdc++")),
+    m_libcxx_category_name(ConstString("libcxx")),
+    m_objc_category_name(ConstString("objc")),
+    m_corefoundation_category_name(ConstString("CoreFoundation")),
+    m_coregraphics_category_name(ConstString("CoreGraphics")),
+    m_coreservices_category_name(ConstString("CoreServices")),
+    m_vectortypes_category_name(ConstString("VectorTypes")),
+    m_appkit_category_name(ConstString("AppKit"))
+{
+    LoadSystemFormatters();
+    LoadLibStdcppFormatters();
+    LoadLibcxxFormatters();
+    LoadObjCFormatters();
+    
+    EnableCategory(m_objc_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_corefoundation_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_appkit_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_coreservices_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_coregraphics_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_gnu_cpp_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_libcxx_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_vectortypes_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_system_category_name,TypeCategoryMap::Last);
+}
+
+static void
+AddStringSummary(TypeCategoryImpl::SharedPointer category_sp,
+                 const char* string,
+                 ConstString type_name,
+                 TypeSummaryImpl::Flags flags)
+{
+    lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags,
+                                                               string));
+    category_sp->GetSummaryNavigator()->Add(type_name,
+                                            summary_sp);
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+static void
+AddScriptSummary(TypeCategoryImpl::SharedPointer category_sp,
+                 const char* funct_name,
+                 ConstString type_name,
+                 TypeSummaryImpl::Flags flags)
+{
+    
+    std::string code("     ");
+    code.append(funct_name).append("(valobj,internal_dict)");
+    
+    lldb::TypeSummaryImplSP summary_sp(new ScriptSummaryFormat(flags,
+                                                               funct_name,
+                                                               code.c_str()));
+    category_sp->GetSummaryNavigator()->Add(type_name,
+                                            summary_sp);
+}
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+static void
+AddCXXSummary (TypeCategoryImpl::SharedPointer category_sp,
+               CXXFunctionSummaryFormat::Callback funct,
+               const char* description,
+               ConstString type_name,
+               TypeSummaryImpl::Flags flags)
+{
+    lldb::TypeSummaryImplSP summary_sp(new CXXFunctionSummaryFormat(flags,funct,description));
+    category_sp->GetSummaryNavigator()->Add(type_name,
+                                            summary_sp);
+}
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+static void AddCXXSynthetic  (TypeCategoryImpl::SharedPointer category_sp,
+                              CXXSyntheticChildren::CreateFrontEndCallback generator,
+                              const char* description,
+                              ConstString type_name,
+                              ScriptedSyntheticChildren::Flags flags)
+{
+    lldb::SyntheticChildrenSP synth_sp(new CXXSyntheticChildren(flags,description,generator));
+    category_sp->GetSyntheticNavigator()->Add(type_name,synth_sp);
+}
+#endif
+
+void
+FormatManager::LoadLibStdcppFormatters()
+{
+    TypeSummaryImpl::Flags stl_summary_flags;
+    stl_summary_flags.SetCascades(true)
+    .SetSkipPointers(false)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(true)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+    
+    lldb::TypeSummaryImplSP std_string_summary_sp(new StringSummaryFormat(stl_summary_flags,
+                                                                          "${var._M_dataplus._M_p}"));
+    
+    TypeCategoryImpl::SharedPointer gnu_category_sp = GetCategory(m_gnu_cpp_category_name);
+    
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::string"),
+                                                std_string_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char>"),
+                                                std_string_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char,std::char_traits<char>,std::allocator<char> >"),
+                                                std_string_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
+                                                std_string_summary_sp);
+    
+    // making sure we force-pick the summary for printing wstring (_M_p is a wchar_t*)
+    lldb::TypeSummaryImplSP std_wstring_summary_sp(new StringSummaryFormat(stl_summary_flags,
+                                                                           "${var._M_dataplus._M_p%S}"));
+    
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::wstring"),
+                                                std_wstring_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t>"),
+                                                std_wstring_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >"),
+                                                std_wstring_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
+                                                std_wstring_summary_sp);
+    
+    
+#ifndef LLDB_DISABLE_PYTHON
+    
+    SyntheticChildren::Flags stl_synth_flags;
+    stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
+    
+    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
+    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
+    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
+    
+    stl_summary_flags.SetDontShowChildren(false);
+    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
+                                                     TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
+                                                                                               "size=${svar%#}")));
+    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
+                                                     TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
+                                                                                               "size=${svar%#}")));
+    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")),
+                                                     TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
+                                                                                               "size=${svar%#}")));
+#endif
+}
+
+void
+FormatManager::LoadLibcxxFormatters()
+{
+    TypeSummaryImpl::Flags stl_summary_flags;
+    stl_summary_flags.SetCascades(true)
+    .SetSkipPointers(false)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(true)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+    
+#ifndef LLDB_DISABLE_PYTHON
+    //std::string code("     lldb.formatters.cpp.libcxx.stdstring_SummaryProvider(valobj,internal_dict)");
+    //lldb::TypeSummaryImplSP std_string_summary_sp(new ScriptSummaryFormat(stl_summary_flags, "lldb.formatters.cpp.libcxx.stdstring_SummaryProvider",code.c_str()));
+    
+    lldb::TypeSummaryImplSP std_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxStringSummaryProvider, "std::string summary provider"));
+    lldb::TypeSummaryImplSP std_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxWStringSummaryProvider, "std::wstring summary provider"));
+
+    TypeCategoryImpl::SharedPointer libcxx_category_sp = GetCategory(m_libcxx_category_name);
+    
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::string"),
+                                                   std_string_summary_sp);
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >"),
+                                                   std_string_summary_sp);
+
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::wstring"),
+                                                   std_wstring_summary_sp);
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >"),
+                                                   std_wstring_summary_sp);
+    
+    SyntheticChildren::Flags stl_synth_flags;
+    stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
+    
+    libcxx_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::vector<.+>(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.libcxx.stdvector_SynthProvider")));
+    libcxx_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::list<.+>(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.libcxx.stdlist_SynthProvider")));
+    libcxx_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::map<.+> >(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.libcxx.stdmap_SynthProvider")));
+    libcxx_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")),
+                                                          SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                    "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
+    libcxx_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)shared_ptr<.+>(( )?&)?$")),
+                                                          SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                    "lldb.formatters.cpp.libcxx.stdsharedptr_SynthProvider")));
+    libcxx_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)weak_ptr<.+>(( )?&)?$")),
+                                                          SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                    "lldb.formatters.cpp.libcxx.stdsharedptr_SynthProvider")));
+    
+    stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(true);
+    libcxx_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::vector<.+>(( )?&)?$")),
+                                                        TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
+    libcxx_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::list<.+>(( )?&)?$")),
+                                                        TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
+    libcxx_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::map<.+> >(( )?&)?$")),
+                                                        TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
+    libcxx_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::deque<.+>(( )?&)?$")),
+                                                        TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
+    libcxx_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::shared_ptr<.+>(( )?&)?$")),
+                                                        TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "{${var.__ptr_%S}} (strong=${var.count} weak=${var.weak_count})")));
+    libcxx_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::__1::weak_ptr<.+>(( )?&)?$")),
+                                                        TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "{${var.__ptr_%S}} (strong=${var.count} weak=${var.weak_count})")));
+    
+    // this summary prevails on the regex std::vector<> because we do exact matches before regex ones
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::vector<std::__1::allocator<bool> >"),
+                                                   TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "size=${var.__size_}")));
+
+#endif
+}
+
+void
+FormatManager::LoadSystemFormatters()
+{
+    
+    TypeSummaryImpl::Flags string_flags;
+    string_flags.SetCascades(false)
+    .SetSkipPointers(true)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(false)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+    
+    lldb::TypeSummaryImplSP string_format(new StringSummaryFormat(string_flags, "${var%s}"));
+    
+    
+    lldb::TypeSummaryImplSP string_array_format(new StringSummaryFormat(TypeSummaryImpl::Flags().SetCascades(false)
+                                                                        .SetSkipPointers(true)
+                                                                        .SetSkipReferences(false)
+                                                                        .SetDontShowChildren(false)
+                                                                        .SetDontShowValue(true)
+                                                                        .SetShowMembersOneLiner(false)
+                                                                        .SetHideItemNames(false),
+                                                                        "${var%s}"));
+    
+    lldb::RegularExpressionSP any_size_char_arr(new RegularExpression("char \\[[0-9]+\\]"));
+    
+    TypeCategoryImpl::SharedPointer sys_category_sp = GetCategory(m_system_category_name);
+    
+    sys_category_sp->GetSummaryNavigator()->Add(ConstString("char *"), string_format);
+    sys_category_sp->GetSummaryNavigator()->Add(ConstString("const char *"), string_format);
+    sys_category_sp->GetRegexSummaryNavigator()->Add(any_size_char_arr, string_array_format);
+    
+    lldb::TypeSummaryImplSP ostype_summary(new StringSummaryFormat(TypeSummaryImpl::Flags().SetCascades(false)
+                                                                   .SetSkipPointers(true)
+                                                                   .SetSkipReferences(true)
+                                                                   .SetDontShowChildren(true)
+                                                                   .SetDontShowValue(false)
+                                                                   .SetShowMembersOneLiner(false)
+                                                                   .SetHideItemNames(false),
+                                                                   "${var%O}"));
+    
+    sys_category_sp->GetSummaryNavigator()->Add(ConstString("OSType"), ostype_summary);
+    
+#ifndef LLDB_DISABLE_PYTHON
+    // FIXME because of a bug in the FormatNavigator we need to add a summary for both X* and const X* (<rdar://problem/12717717>)
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("char16_t *"), string_flags);
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("const char16_t *"), string_flags);
+    
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("char32_t *"), string_flags);
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("const char32_t *"), string_flags);
+    
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("const wchar_t *"), string_flags);
+    
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "unichar * summary provider", ConstString("unichar *"), string_flags);
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "unichar * summary provider", ConstString("const unichar *"), string_flags);
+    
+    TypeSummaryImpl::Flags widechar_flags;
+    widechar_flags.SetDontShowValue(true)
+    .SetSkipPointers(true)
+    .SetSkipReferences(false)
+    .SetCascades(true)
+    .SetDontShowChildren(true)
+    .SetHideItemNames(true)
+    .SetShowMembersOneLiner(false);
+    
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16SummaryProvider, "char16_t summary provider", ConstString("char16_t"), widechar_flags);
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char32SummaryProvider, "char32_t summary provider", ConstString("char32_t"), widechar_flags);
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::WCharSummaryProvider, "wchar_t summary provider", ConstString("wchar_t"), widechar_flags);
+
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16SummaryProvider, "unichar summary provider", ConstString("unichar"), widechar_flags);
+    
+#endif
+}
+
+void
+FormatManager::LoadObjCFormatters()
+{
+    TypeSummaryImpl::Flags objc_flags;
+    objc_flags.SetCascades(false)
+    .SetSkipPointers(true)
+    .SetSkipReferences(true)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(true)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+
+    TypeCategoryImpl::SharedPointer objc_category_sp = GetCategory(m_objc_category_name);
+    
+    lldb::TypeSummaryImplSP ObjC_BOOL_summary(new CXXFunctionSummaryFormat(objc_flags, lldb_private::formatters::ObjCBOOLSummaryProvider,""));
+    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL"),
+                                                 ObjC_BOOL_summary);
+    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL &"),
+                                                 ObjC_BOOL_summary);
+    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL *"),
+                                                 ObjC_BOOL_summary);
+
+#ifndef LLDB_DISABLE_PYTHON
+    // we need to skip pointers here since we are special casing a SEL* when retrieving its value
+    objc_flags.SetSkipPointers(true);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("SEL"), objc_flags);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("struct objc_selector"), objc_flags);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("objc_selector"), objc_flags);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<true>, "SEL summary provider", ConstString("objc_selector *"), objc_flags);
+    
+    AddScriptSummary(objc_category_sp, "lldb.formatters.objc.Class.Class_Summary", ConstString("Class"), objc_flags);
+#endif // LLDB_DISABLE_PYTHON
+
+    objc_flags.SetSkipPointers(false);
+
+    TypeCategoryImpl::SharedPointer corefoundation_category_sp = GetCategory(m_corefoundation_category_name);
+
+    AddStringSummary(corefoundation_category_sp,
+                     "${var.years} years, ${var.months} months, ${var.days} days, ${var.hours} hours, ${var.minutes} minutes ${var.seconds} seconds",
+                     ConstString("CFGregorianUnits"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "location=${var.location} length=${var.length}",
+                     ConstString("CFRange"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "(x=${var.x}, y=${var.y})",
+                     ConstString("NSPoint"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "location=${var.location}, length=${var.length}",
+                     ConstString("NSRange"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "${var.origin}, ${var.size}",
+                     ConstString("NSRect"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "(${var.origin}, ${var.size}), ...",
+                     ConstString("NSRectArray"),
+                     objc_flags);
+    AddStringSummary(objc_category_sp,
+                     "(width=${var.width}, height=${var.height})",
+                     ConstString("NSSize"),
+                     objc_flags);
+    
+    TypeCategoryImpl::SharedPointer coregraphics_category_sp = GetCategory(m_coregraphics_category_name);
+    
+    AddStringSummary(coregraphics_category_sp,
+                     "(width=${var.width}, height=${var.height})",
+                     ConstString("CGSize"),
+                     objc_flags);
+    AddStringSummary(coregraphics_category_sp,
+                     "(x=${var.x}, y=${var.y})",
+                     ConstString("CGPoint"),
+                     objc_flags);
+    AddStringSummary(coregraphics_category_sp,
+                     "origin=${var.origin} size=${var.size}",
+                     ConstString("CGRect"),
+                     objc_flags);
+    
+    TypeCategoryImpl::SharedPointer coreservices_category_sp = GetCategory(m_coreservices_category_name);
+    
+    AddStringSummary(coreservices_category_sp,
+                     "red=${var.red} green=${var.green} blue=${var.blue}",
+                     ConstString("RGBColor"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "(t=${var.top}, l=${var.left}, b=${var.bottom}, r=${var.right})",
+                     ConstString("Rect"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "(v=${var.v}, h=${var.h})",
+                     ConstString("Point"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "${var.month}/${var.day}/${var.year}  ${var.hour} :${var.minute} :${var.second} dayOfWeek:${var.dayOfWeek}",
+                     ConstString("DateTimeRect *"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "${var.ld.month}/${var.ld.day}/${var.ld.year} ${var.ld.hour} :${var.ld.minute} :${var.ld.second} dayOfWeek:${var.ld.dayOfWeek}",
+                     ConstString("LongDateRect"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "(x=${var.x}, y=${var.y})",
+                     ConstString("HIPoint"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "origin=${var.origin} size=${var.size}",
+                     ConstString("HIRect"),
+                     objc_flags);
+    
+    TypeCategoryImpl::SharedPointer appkit_category_sp = GetCategory(m_appkit_category_name);
+    
+    TypeSummaryImpl::Flags appkit_flags;
+    appkit_flags.SetCascades(true)
+    .SetSkipPointers(false)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(false)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+
+    appkit_flags.SetDontShowChildren(false);
+    
+
+#ifndef LLDB_DISABLE_PYTHON
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSArray"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSMutableArray"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayI"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayM"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSCFArray"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFArrayRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFMutableArrayRef"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSDictionary"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSMutableDictionary"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSCFDictionary"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryI"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryM"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFDictionaryRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFMutableDictionaryRef"), appkit_flags);
+    
+    // AddSummary(appkit_category_sp, "${var.key%@} -> ${var.value%@}", ConstString("$_lldb_typegen_nspair"), appkit_flags);
+    
+    appkit_flags.SetDontShowChildren(true);
+    
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayM"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayI"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSArray"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSMutableArray"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSCFArray"), ScriptedSyntheticChildren::Flags());
+
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryM"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryI"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSDictionary"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSMutableDictionary"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("CFDictionaryRef"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("CFMutableDictionaryRef"), ScriptedSyntheticChildren::Flags());
+
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBag.CFBag_SummaryProvider", ConstString("CFBagRef"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBag.CFBag_SummaryProvider", ConstString("__CFBag"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBag.CFBag_SummaryProvider", ConstString("const struct __CFBag"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBag.CFBag_SummaryProvider", ConstString("CFMutableBagRef"), appkit_flags);
+    
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBinaryHeap.CFBinaryHeap_SummaryProvider", ConstString("CFBinaryHeapRef"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBinaryHeap.CFBinaryHeap_SummaryProvider", ConstString("__CFBinaryHeap"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("CFStringRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("CFMutableStringRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__NSCFConstantString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__NSCFString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFConstantString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSPathStore2"), appkit_flags);
+    
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFString.CFAttributedString_SummaryProvider", ConstString("NSAttributedString"), appkit_flags);
+    
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSBundle.NSBundle_SummaryProvider", ConstString("NSBundle"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSData"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteData"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteMutableData"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("__NSCFData"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>, "NSData summary provider", ConstString("CFDataRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>, "NSData summary provider", ConstString("CFMutableDataRef"), appkit_flags);
+
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSMachPort.NSMachPort_SummaryProvider", ConstString("NSMachPort"), appkit_flags);
+    
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSNotification.NSNotification_SummaryProvider", ConstString("NSNotification"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSNotification.NSNotification_SummaryProvider", ConstString("NSConcreteNotification"), appkit_flags);
+
+    AddStringSummary(appkit_category_sp, "domain: ${var._domain} - code: ${var._code}", ConstString("NSError"), appkit_flags);
+    AddStringSummary(appkit_category_sp,"name:${var.name%S} reason:${var.reason%S}",ConstString("NSException"),appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSNumber"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFBoolean"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFNumber"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFBoolean"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFNumber"), appkit_flags);
+    
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSDecimalNumber summary provider", ConstString("NSDecimalNumber"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSHost summary provider", ConstString("NSHost"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSTask summary provider", ConstString("NSTask"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSValue summary provider", ConstString("NSValue"), appkit_flags);
+
+
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSSet.NSSet_SummaryProvider", ConstString("NSSet"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSSet.NSSet_SummaryProvider2", ConstString("CFSetRef"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSSet.NSSet_SummaryProvider2", ConstString("CFMutableSetRef"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSSet.NSSet_SummaryProvider", ConstString("__NSCFSet"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSSet.NSSet_SummaryProvider", ConstString("__NSSetI"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSSet.NSSet_SummaryProvider", ConstString("__NSSetM"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSSet.NSSet_SummaryProvider", ConstString("NSCountedSet"), appkit_flags);
+
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSURL.NSURL_SummaryProvider", ConstString("NSURL"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSURL.NSURL_SummaryProvider", ConstString("CFURLRef"), appkit_flags);
+    
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSDate.NSDate_SummaryProvider", ConstString("NSDate"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSDate.NSDate_SummaryProvider", ConstString("__NSDate"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSDate.NSDate_SummaryProvider", ConstString("__NSTaggedDate"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSDate.NSDate_SummaryProvider", ConstString("NSCalendarDate"), appkit_flags);
+
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSDate.NSTimeZone_SummaryProvider", ConstString("NSTimeZone"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSDate.NSTimeZone_SummaryProvider", ConstString("CFTimeZoneRef"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSDate.NSTimeZone_SummaryProvider", ConstString("__NSTimeZone"), appkit_flags);
+
+    // CFAbsoluteTime is actually a double rather than a pointer to an object
+    // we do not care about the numeric value, since it is probably meaningless to users
+    appkit_flags.SetDontShowValue(true);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSDate.CFAbsoluteTime_SummaryProvider", ConstString("CFAbsoluteTime"), appkit_flags);
+    appkit_flags.SetDontShowValue(false);
+    
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSIndexSet.NSIndexSet_SummaryProvider", ConstString("NSIndexSet"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.NSIndexSet.NSIndexSet_SummaryProvider", ConstString("NSMutableIndexSet"), appkit_flags);
+
+    AddStringSummary(appkit_category_sp,
+                     "@\"${var.month%d}/${var.day%d}/${var.year%d} ${var.hour%d}:${var.minute%d}:${var.second}\"",
+                     ConstString("CFGregorianDate"),
+                     appkit_flags);
+    
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBitVector.CFBitVector_SummaryProvider", ConstString("CFBitVectorRef"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBitVector.CFBitVector_SummaryProvider", ConstString("CFMutableBitVectorRef"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBitVector.CFBitVector_SummaryProvider", ConstString("__CFBitVector"), appkit_flags);
+    AddScriptSummary(appkit_category_sp, "lldb.formatters.objc.CFBitVector.CFBitVector_SummaryProvider", ConstString("__CFMutableBitVector"), appkit_flags);
+#endif // LLDB_DISABLE_PYTHON
+    
+    TypeCategoryImpl::SharedPointer vectors_category_sp = GetCategory(m_vectortypes_category_name);
+
+    TypeSummaryImpl::Flags vector_flags;
+    vector_flags.SetCascades(true)
+    .SetSkipPointers(true)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(false)
+    .SetShowMembersOneLiner(true)
+    .SetHideItemNames(true);
+    
+    AddStringSummary(vectors_category_sp,
+                     "${var.uint128}",
+                     ConstString("builtin_type_vec128"),
+                     objc_flags);
+
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("float [4]"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("int32_t [4]"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("int16_t [8]"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vDouble"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vFloat"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vSInt8"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vSInt16"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vSInt32"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vUInt16"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vUInt8"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vUInt16"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vUInt32"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vBool32"),
+                     vector_flags);
+}