1//===-- CPlusPlusLanguage.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 "CPlusPlusLanguage.h"
11
12
13#include "llvm/ADT/StringRef.h"
14
15#include "lldb/Core/ConstString.h"
16#include "lldb/Core/PluginManager.h"
17#include "lldb/Core/RegularExpression.h"
18#include "lldb/Core/UniqueCStringMap.h"
19#include "lldb/DataFormatters/CXXFunctionPointer.h"
20#include "lldb/DataFormatters/DataVisualization.h"
21#include "lldb/DataFormatters/FormattersHelpers.h"
22#include "lldb/DataFormatters/VectorType.h"
23
24#include "CxxStringTypes.h"
25#include "LibCxx.h"
26#include "LibStdcpp.h"
27
28#include <cstring>
29#include <cctype>
30#include <functional>
31#include <mutex>
32
33using namespace lldb;
34using namespace lldb_private;
35using namespace lldb_private::formatters;
36
37void
38CPlusPlusLanguage::Initialize()
39{
40    PluginManager::RegisterPlugin (GetPluginNameStatic(),
41                                   "C++ Language",
42                                   CreateInstance);
43}
44
45void
46CPlusPlusLanguage::Terminate()
47{
48    PluginManager::UnregisterPlugin (CreateInstance);
49}
50
51lldb_private::ConstString
52CPlusPlusLanguage::GetPluginNameStatic()
53{
54    static ConstString g_name("cplusplus");
55    return g_name;
56}
57
58
59//------------------------------------------------------------------
60// PluginInterface protocol
61//------------------------------------------------------------------
62lldb_private::ConstString
63CPlusPlusLanguage::GetPluginName()
64{
65    return GetPluginNameStatic();
66}
67
68uint32_t
69CPlusPlusLanguage::GetPluginVersion()
70{
71    return 1;
72}
73
74//------------------------------------------------------------------
75// Static Functions
76//------------------------------------------------------------------
77Language *
78CPlusPlusLanguage::CreateInstance (lldb::LanguageType language)
79{
80    if (Language::LanguageIsCPlusPlus(language))
81        return new CPlusPlusLanguage();
82    return nullptr;
83}
84
85void
86CPlusPlusLanguage::MethodName::Clear()
87{
88    m_full.Clear();
89    m_basename = llvm::StringRef();
90    m_context = llvm::StringRef();
91    m_arguments = llvm::StringRef();
92    m_qualifiers = llvm::StringRef();
93    m_type = eTypeInvalid;
94    m_parsed = false;
95    m_parse_error = false;
96}
97
98bool
99ReverseFindMatchingChars (const llvm::StringRef &s,
100                          const llvm::StringRef &left_right_chars,
101                          size_t &left_pos,
102                          size_t &right_pos,
103                          size_t pos = llvm::StringRef::npos)
104{
105    assert (left_right_chars.size() == 2);
106    left_pos = llvm::StringRef::npos;
107    const char left_char = left_right_chars[0];
108    const char right_char = left_right_chars[1];
109    pos = s.find_last_of(left_right_chars, pos);
110    if (pos == llvm::StringRef::npos || s[pos] == left_char)
111        return false;
112    right_pos = pos;
113    uint32_t depth = 1;
114    while (pos > 0 && depth > 0)
115    {
116        pos = s.find_last_of(left_right_chars, pos);
117        if (pos == llvm::StringRef::npos)
118            return false;
119        if (s[pos] == left_char)
120        {
121            if (--depth == 0)
122            {
123                left_pos = pos;
124                return left_pos < right_pos;
125            }
126        }
127        else if (s[pos] == right_char)
128        {
129            ++depth;
130        }
131    }
132    return false;
133}
134
135static bool
136IsValidBasename(const llvm::StringRef& basename)
137{
138    // Check that the basename matches with the following regular expression or is an operator name:
139    // "^~?([A-Za-z_][A-Za-z_0-9]*)(<.*>)?$"
140    // We are using a hand written implementation because it is significantly more efficient then
141    // using the general purpose regular expression library.
142    size_t idx = 0;
143    if (basename.size() > 0 && basename[0] == '~')
144        idx = 1;
145
146    if (basename.size() <= idx)
147        return false; // Empty string or "~"
148
149    if (!std::isalpha(basename[idx]) && basename[idx] != '_')
150        return false; // First charater (after removing the possible '~'') isn't in [A-Za-z_]
151
152    // Read all characters matching [A-Za-z_0-9]
153    ++idx;
154    while (idx < basename.size())
155    {
156        if (!std::isalnum(basename[idx]) && basename[idx] != '_')
157            break;
158        ++idx;
159    }
160
161    // We processed all characters. It is a vaild basename.
162    if (idx == basename.size())
163        return true;
164
165    // Check for basename with template arguments
166    // TODO: Improve the quality of the validation with validating the template arguments
167    if (basename[idx] == '<' && basename.back() == '>')
168        return true;
169
170    // Check if the basename is a vaild C++ operator name
171    if (!basename.startswith("operator"))
172        return false;
173
174    static RegularExpression g_operator_regex("^(operator)( ?)([A-Za-z_][A-Za-z_0-9]*|\\(\\)|\\[\\]|[\\^<>=!\\/*+-]+)(<.*>)?(\\[\\])?$");
175    std::string basename_str(basename.str());
176    return g_operator_regex.Execute(basename_str.c_str(), nullptr);
177}
178
179void
180CPlusPlusLanguage::MethodName::Parse()
181{
182    if (!m_parsed && m_full)
183    {
184//        ConstString mangled;
185//        m_full.GetMangledCounterpart(mangled);
186//        printf ("\n   parsing = '%s'\n", m_full.GetCString());
187//        if (mangled)
188//            printf ("   mangled = '%s'\n", mangled.GetCString());
189        m_parse_error = false;
190        m_parsed = true;
191        llvm::StringRef full (m_full.GetCString());
192
193        size_t arg_start, arg_end;
194        llvm::StringRef parens("()", 2);
195        if (ReverseFindMatchingChars (full, parens, arg_start, arg_end))
196        {
197            m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
198            if (arg_end + 1 < full.size())
199                m_qualifiers = full.substr(arg_end + 1);
200            if (arg_start > 0)
201            {
202                size_t basename_end = arg_start;
203                size_t context_start = 0;
204                size_t context_end = llvm::StringRef::npos;
205                if (basename_end > 0 && full[basename_end-1] == '>')
206                {
207                    // TODO: handle template junk...
208                    // Templated function
209                    size_t template_start, template_end;
210                    llvm::StringRef lt_gt("<>", 2);
211                    if (ReverseFindMatchingChars (full, lt_gt, template_start, template_end, basename_end))
212                    {
213                        // Check for templated functions that include return type like: 'void foo<Int>()'
214                        context_start = full.rfind(' ', template_start);
215                        if (context_start == llvm::StringRef::npos)
216                            context_start = 0;
217
218                        context_end = full.rfind(':', template_start);
219                        if (context_end == llvm::StringRef::npos || context_end < context_start)
220                            context_end = context_start;
221                    }
222                    else
223                    {
224                        context_end = full.rfind(':', basename_end);
225                    }
226                }
227                else if (context_end == llvm::StringRef::npos)
228                {
229                    context_end = full.rfind(':', basename_end);
230                }
231
232                if (context_end == llvm::StringRef::npos)
233                    m_basename = full.substr(0, basename_end);
234                else
235                {
236                    if (context_start < context_end)
237                        m_context = full.substr(context_start, context_end - 1);
238                    const size_t basename_begin = context_end + 1;
239                    m_basename = full.substr(basename_begin, basename_end - basename_begin);
240                }
241                m_type = eTypeUnknownMethod;
242            }
243            else
244            {
245                m_parse_error = true;
246                return;
247            }
248
249            if (!IsValidBasename(m_basename))
250            {
251                // The C++ basename doesn't match our regular expressions so this can't
252                // be a valid C++ method, clear everything out and indicate an error
253                m_context = llvm::StringRef();
254                m_basename = llvm::StringRef();
255                m_arguments = llvm::StringRef();
256                m_qualifiers = llvm::StringRef();
257                m_parse_error = true;
258            }
259        }
260        else
261        {
262            m_parse_error = true;
263        }
264    }
265}
266
267llvm::StringRef
268CPlusPlusLanguage::MethodName::GetBasename ()
269{
270    if (!m_parsed)
271        Parse();
272    return m_basename;
273}
274
275llvm::StringRef
276CPlusPlusLanguage::MethodName::GetContext ()
277{
278    if (!m_parsed)
279        Parse();
280    return m_context;
281}
282
283llvm::StringRef
284CPlusPlusLanguage::MethodName::GetArguments ()
285{
286    if (!m_parsed)
287        Parse();
288    return m_arguments;
289}
290
291llvm::StringRef
292CPlusPlusLanguage::MethodName::GetQualifiers ()
293{
294    if (!m_parsed)
295        Parse();
296    return m_qualifiers;
297}
298
299std::string
300CPlusPlusLanguage::MethodName::GetScopeQualifiedName ()
301{
302    if (!m_parsed)
303        Parse();
304    if (m_basename.empty() || m_context.empty())
305        return std::string();
306
307    std::string res;
308    res += m_context;
309    res += "::";
310    res += m_basename;
311
312    return res;
313}
314
315bool
316CPlusPlusLanguage::IsCPPMangledName (const char *name)
317{
318    // FIXME, we should really run through all the known C++ Language plugins and ask each one if
319    // this is a C++ mangled name, but we can put that off till there is actually more than one
320    // we care about.
321
322    if (name && name[0] == '_' && name[1] == 'Z')
323        return true;
324    else
325        return false;
326}
327
328bool
329CPlusPlusLanguage::ExtractContextAndIdentifier (const char *name, llvm::StringRef &context, llvm::StringRef &identifier)
330{
331    static RegularExpression g_basename_regex("^(([A-Za-z_][A-Za-z_0-9]*::)*)([A-Za-z_][A-Za-z_0-9]*)$");
332    RegularExpression::Match match(4);
333    if (g_basename_regex.Execute (name, &match))
334    {
335        match.GetMatchAtIndex(name, 1, context);
336        match.GetMatchAtIndex(name, 3, identifier);
337        return true;
338    }
339    return false;
340}
341
342class CPPRuntimeEquivalents
343{
344public:
345    CPPRuntimeEquivalents ()
346    {
347
348        m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("basic_string<char>"));
349
350        // these two (with a prefixed std::) occur when c++stdlib string class occurs as a template argument in some STL container
351        m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("std::basic_string<char>"));
352
353        m_impl.Sort();
354    }
355
356    void
357    Add (ConstString& type_name,
358         ConstString& type_equivalent)
359    {
360        m_impl.Insert(type_name.AsCString(), type_equivalent);
361    }
362
363    uint32_t
364    FindExactMatches (ConstString& type_name,
365                      std::vector<ConstString>& equivalents)
366    {
367
368        uint32_t count = 0;
369
370        for (ImplData match = m_impl.FindFirstValueForName(type_name.AsCString());
371             match != NULL;
372             match = m_impl.FindNextValueForName(match))
373        {
374            equivalents.push_back(match->value);
375            count++;
376        }
377
378        return count;
379    }
380
381    // partial matches can occur when a name with equivalents is a template argument.
382    // e.g. we may have "class Foo" be a match for "struct Bar". if we have a typename
383    // such as "class Templatized<class Foo, Anything>" we want this to be replaced with
384    // "class Templatized<struct Bar, Anything>". Since partial matching is time consuming
385    // once we get a partial match, we add it to the exact matches list for faster retrieval
386    uint32_t
387    FindPartialMatches (ConstString& type_name,
388                        std::vector<ConstString>& equivalents)
389    {
390
391        uint32_t count = 0;
392
393        const char* type_name_cstr = type_name.AsCString();
394
395        size_t items_count = m_impl.GetSize();
396
397        for (size_t item = 0; item < items_count; item++)
398        {
399            const char* key_cstr = m_impl.GetCStringAtIndex(item);
400            if ( strstr(type_name_cstr,key_cstr) )
401            {
402                count += AppendReplacements(type_name_cstr,
403                                            key_cstr,
404                                            equivalents);
405            }
406        }
407
408        return count;
409
410    }
411
412private:
413
414    std::string& replace (std::string& target,
415                          std::string& pattern,
416                          std::string& with)
417    {
418        size_t pos;
419        size_t pattern_len = pattern.size();
420
421        while ( (pos = target.find(pattern)) != std::string::npos )
422            target.replace(pos, pattern_len, with);
423
424        return target;
425    }
426
427    uint32_t
428    AppendReplacements (const char* original,
429                        const char *matching_key,
430                        std::vector<ConstString>& equivalents)
431    {
432
433        std::string matching_key_str(matching_key);
434        ConstString original_const(original);
435
436        uint32_t count = 0;
437
438        for (ImplData match = m_impl.FindFirstValueForName(matching_key);
439             match != NULL;
440             match = m_impl.FindNextValueForName(match))
441        {
442            std::string target(original);
443            std::string equiv_class(match->value.AsCString());
444
445            replace (target, matching_key_str, equiv_class);
446
447            ConstString target_const(target.c_str());
448
449// you will most probably want to leave this off since it might make this map grow indefinitely
450#ifdef ENABLE_CPP_EQUIVALENTS_MAP_TO_GROW
451            Add(original_const, target_const);
452#endif
453            equivalents.push_back(target_const);
454
455            count++;
456        }
457
458        return count;
459    }
460
461    typedef UniqueCStringMap<ConstString> Impl;
462    typedef const Impl::Entry* ImplData;
463    Impl m_impl;
464};
465
466static CPPRuntimeEquivalents&
467GetEquivalentsMap ()
468{
469    static CPPRuntimeEquivalents g_equivalents_map;
470    return g_equivalents_map;
471}
472
473
474uint32_t
475CPlusPlusLanguage::FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents)
476{
477    uint32_t count = GetEquivalentsMap().FindExactMatches(type_name, equivalents);
478
479    bool might_have_partials=
480        ( count == 0 )  // if we have a full name match just use it
481        && (strchr(type_name.AsCString(), '<') != NULL  // we should only have partial matches when templates are involved, check that we have
482            && strchr(type_name.AsCString(), '>') != NULL); // angle brackets in the type_name before trying to scan for partial matches
483
484    if ( might_have_partials )
485        count = GetEquivalentsMap().FindPartialMatches(type_name, equivalents);
486
487    return count;
488}
489
490static void
491LoadLibCxxFormatters (lldb::TypeCategoryImplSP cpp_category_sp)
492{
493    if (!cpp_category_sp)
494        return;
495
496    TypeSummaryImpl::Flags stl_summary_flags;
497    stl_summary_flags.SetCascades(true)
498    .SetSkipPointers(false)
499    .SetSkipReferences(false)
500    .SetDontShowChildren(true)
501    .SetDontShowValue(true)
502    .SetShowMembersOneLiner(false)
503    .SetHideItemNames(false);
504
505#ifndef LLDB_DISABLE_PYTHON
506    lldb::TypeSummaryImplSP std_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxStringSummaryProvider, "std::string summary provider"));
507    lldb::TypeSummaryImplSP std_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxWStringSummaryProvider, "std::wstring summary provider"));
508
509    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::string"),
510                                                         std_string_summary_sp);
511    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >"),
512                                                         std_string_summary_sp);
513
514    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::wstring"),
515                                                         std_wstring_summary_sp);
516    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >"),
517                                                         std_wstring_summary_sp);
518
519    SyntheticChildren::Flags stl_synth_flags;
520    stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
521
522    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, "libc++ std::vector synthetic children", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_synth_flags, true);
523    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, "libc++ std::list synthetic children", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_synth_flags, true);
524    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::map synthetic children", ConstString("^std::__1::map<.+> >(( )?&)?$"), stl_synth_flags, true);
525    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_synth_flags);
526    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags);
527    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::set synthetic children", ConstString("^std::__1::set<.+> >(( )?&)?$"), stl_synth_flags, true);
528    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multiset synthetic children", ConstString("^std::__1::multiset<.+> >(( )?&)?$"), stl_synth_flags, true);
529    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multimap synthetic children", ConstString("^std::__1::multimap<.+> >(( )?&)?$"), stl_synth_flags, true);
530    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, "libc++ std::unordered containers synthetic children", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_synth_flags, true);
531    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator, "libc++ std::initializer_list synthetic children", ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags, true);
532
533    cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")),
534                                                               SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
535                                                                                                                 "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
536
537    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "shared_ptr synthetic children", ConstString("^(std::__1::)shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
538    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "weak_ptr synthetic children", ConstString("^(std::__1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
539
540    stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(false);
541    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags);
542
543    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector summary provider", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_summary_flags, true);
544    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::list summary provider", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_summary_flags, true);
545    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::map summary provider", ConstString("^std::__1::map<.+>(( )?&)?$"), stl_summary_flags, true);
546    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::deque summary provider", ConstString("^std::__1::deque<.+>(( )?&)?$"), stl_summary_flags, true);
547    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_summary_flags);
548    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags);
549    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::set summary provider", ConstString("^std::__1::set<.+>(( )?&)?$"), stl_summary_flags, true);
550    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multiset summary provider", ConstString("^std::__1::multiset<.+>(( )?&)?$"), stl_summary_flags, true);
551    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multimap summary provider", ConstString("^std::__1::multimap<.+>(( )?&)?$"), stl_summary_flags, true);
552    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::unordered containers summary provider", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_summary_flags, true);
553
554    stl_summary_flags.SetSkipPointers(true);
555
556    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::shared_ptr summary provider", ConstString("^std::__1::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, true);
557    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::weak_ptr summary provider", ConstString("^std::__1::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, true);
558
559    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^std::__1::__wrap_iter<.+>$"), stl_synth_flags, true);
560
561    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags);
562    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::__1::__map_iterator<.+>$"), stl_synth_flags, true);
563
564    AddFilter(cpp_category_sp, {"__a_"}, "libc++ std::atomic filter", ConstString("^std::__1::atomic<.*>$"), stl_synth_flags, true);
565#endif
566}
567
568static void
569LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
570{
571    if (!cpp_category_sp)
572        return;
573
574    TypeSummaryImpl::Flags stl_summary_flags;
575    stl_summary_flags.SetCascades(true)
576    .SetSkipPointers(false)
577    .SetSkipReferences(false)
578    .SetDontShowChildren(true)
579    .SetDontShowValue(true)
580    .SetShowMembersOneLiner(false)
581    .SetHideItemNames(false);
582
583    lldb::TypeSummaryImplSP std_string_summary_sp(new StringSummaryFormat(stl_summary_flags,
584                                                                          "${var._M_dataplus._M_p}"));
585
586    lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags,
587                                                                                 LibStdcppStringSummaryProvider,
588                                                                                 "libstdc++ c++11 std::string summary provider"));
589    lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags,
590                                                                                 LibStdcppWStringSummaryProvider,
591                                                                                 "libstdc++ c++11 std::wstring summary provider"));
592
593    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
594                                                      std_string_summary_sp);
595    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char>"),
596                                                      std_string_summary_sp);
597    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char,std::char_traits<char>,std::allocator<char> >"),
598                                                      std_string_summary_sp);
599    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
600                                                      std_string_summary_sp);
601
602    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::string"),
603                                                      cxx11_string_summary_sp);
604    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
605                                                      cxx11_string_summary_sp);
606
607    // making sure we force-pick the summary for printing wstring (_M_p is a wchar_t*)
608    lldb::TypeSummaryImplSP std_wstring_summary_sp(new StringSummaryFormat(stl_summary_flags,
609                                                                           "${var._M_dataplus._M_p%S}"));
610
611    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
612                                                      std_wstring_summary_sp);
613    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t>"),
614                                                      std_wstring_summary_sp);
615    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >"),
616                                                      std_wstring_summary_sp);
617    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
618                                                      std_wstring_summary_sp);
619
620    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::wstring"),
621                                                      cxx11_wstring_summary_sp);
622    cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
623                                                      cxx11_wstring_summary_sp);
624
625#ifndef LLDB_DISABLE_PYTHON
626
627    SyntheticChildren::Flags stl_synth_flags;
628    stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
629
630    cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
631                                                            SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
632                                                                                                              "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
633    cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
634                                                            SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
635                                                                                                              "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
636    cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$")),
637                                                            SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
638                                                                                                              "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
639    stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(true);
640    cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
641                                                           TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
642                                                                                                     "size=${svar%#}")));
643    cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
644                                                           TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
645                                                                                                     "size=${svar%#}")));
646    cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$")),
647                                                           TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
648                                                                                                     "size=${svar%#}")));
649
650    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
651
652    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
653#endif
654}
655
656static void
657LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
658{
659    if (!cpp_category_sp)
660        return;
661
662    TypeSummaryImpl::Flags string_flags;
663    string_flags.SetCascades(true)
664    .SetSkipPointers(true)
665    .SetSkipReferences(false)
666    .SetDontShowChildren(true)
667    .SetDontShowValue(false)
668    .SetShowMembersOneLiner(false)
669    .SetHideItemNames(false);
670
671    TypeSummaryImpl::Flags string_array_flags;
672    string_array_flags.SetCascades(true)
673    .SetSkipPointers(true)
674    .SetSkipReferences(false)
675    .SetDontShowChildren(true)
676    .SetDontShowValue(true)
677    .SetShowMembersOneLiner(false)
678    .SetHideItemNames(false);
679
680#ifndef LLDB_DISABLE_PYTHON
681    // FIXME because of a bug in the FormattersContainer we need to add a summary for both X* and const X* (<rdar://problem/12717717>)
682    AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("char16_t *"), string_flags);
683    AddCXXSummary(cpp_category_sp,
684                  lldb_private::formatters::Char16StringSummaryProvider,
685                  "char16_t [] summary provider",
686                  ConstString("char16_t \\[[0-9]+\\]"),
687                  string_array_flags,
688                  true);
689
690    AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("char32_t *"), string_flags);
691    AddCXXSummary(cpp_category_sp,
692                  lldb_private::formatters::Char32StringSummaryProvider,
693                  "char32_t [] summary provider",
694                  ConstString("char32_t \\[[0-9]+\\]"),
695                  string_array_flags,
696                  true);
697
698    AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
699    AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true);
700
701    AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "unichar * summary provider", ConstString("unichar *"), string_flags);
702
703    TypeSummaryImpl::Flags widechar_flags;
704    widechar_flags.SetDontShowValue(true)
705    .SetSkipPointers(true)
706    .SetSkipReferences(false)
707    .SetCascades(true)
708    .SetDontShowChildren(true)
709    .SetHideItemNames(true)
710    .SetShowMembersOneLiner(false);
711
712    AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, "char16_t summary provider", ConstString("char16_t"), widechar_flags);
713    AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char32SummaryProvider, "char32_t summary provider", ConstString("char32_t"), widechar_flags);
714    AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider, "wchar_t summary provider", ConstString("wchar_t"), widechar_flags);
715
716    AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, "unichar summary provider", ConstString("unichar"), widechar_flags);
717#endif
718}
719
720lldb::TypeCategoryImplSP
721CPlusPlusLanguage::GetFormatters ()
722{
723    static std::once_flag g_initialize;
724    static TypeCategoryImplSP g_category;
725
726    std::call_once(g_initialize, [this] () -> void {
727        DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
728        if (g_category)
729        {
730            LoadLibCxxFormatters(g_category);
731            LoadLibStdcppFormatters(g_category);
732            LoadSystemFormatters(g_category);
733        }
734    });
735    return g_category;
736}
737
738HardcodedFormatters::HardcodedSummaryFinder
739CPlusPlusLanguage::GetHardcodedSummaries ()
740{
741    static std::once_flag g_initialize;
742    static ConstString g_vectortypes("VectorTypes");
743    static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
744
745    std::call_once(g_initialize, [] () -> void {
746        g_formatters.push_back(
747                                        [](lldb_private::ValueObject& valobj,
748                                           lldb::DynamicValueType,
749                                           FormatManager&) -> TypeSummaryImpl::SharedPointer {
750                                            static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat(TypeSummaryImpl::Flags(), lldb_private::formatters::CXXFunctionPointerSummaryProvider, "Function pointer summary provider"));
751                                            if (valobj.GetCompilerType().IsFunctionPointerType())
752                                            {
753                                                return formatter_sp;
754                                            }
755                                            return nullptr;
756                                        });
757        g_formatters.push_back(
758                                        [](lldb_private::ValueObject& valobj,
759                                           lldb::DynamicValueType,
760                                           FormatManager& fmt_mgr) -> TypeSummaryImpl::SharedPointer {
761                                            static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat(TypeSummaryImpl::Flags()
762                                                                                                                                     .SetCascades(true)
763                                                                                                                                     .SetDontShowChildren(true)
764                                                                                                                                     .SetHideItemNames(true)
765                                                                                                                                     .SetShowMembersOneLiner(true)
766                                                                                                                                     .SetSkipPointers(true)
767                                                                                                                                     .SetSkipReferences(false),
768                                                                                                                                     lldb_private::formatters::VectorTypeSummaryProvider,
769                                                                                                                                     "vector_type pointer summary provider"));
770                                            if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr))
771                                            {
772                                                if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
773                                                    return formatter_sp;
774                                            }
775                                            return nullptr;
776                                        });
777    });
778
779    return g_formatters;
780}
781
782HardcodedFormatters::HardcodedSyntheticFinder
783CPlusPlusLanguage::GetHardcodedSynthetics ()
784{
785    static std::once_flag g_initialize;
786    static ConstString g_vectortypes("VectorTypes");
787    static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
788
789    std::call_once(g_initialize, [] () -> void {
790        g_formatters.push_back(
791                                         [](lldb_private::ValueObject& valobj,
792                                            lldb::DynamicValueType,
793                                            FormatManager& fmt_mgr) -> SyntheticChildren::SharedPointer {
794                                             static CXXSyntheticChildren::SharedPointer formatter_sp(new CXXSyntheticChildren(SyntheticChildren::Flags().SetCascades(true).SetSkipPointers(true).SetSkipReferences(true).SetNonCacheable(true),
795                                                                                                                              "vector_type synthetic children",
796                                                                                                                              lldb_private::formatters::VectorTypeSyntheticFrontEndCreator));
797                                             if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr))
798                                             {
799                                                 if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
800                                                     return formatter_sp;
801                                             }
802                                             return nullptr;
803                                         });
804    });
805
806    return g_formatters;
807}
808
809