1 //===-- LanguageCategory.cpp ---------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/DataFormatters/LanguageCategory.h"
11 
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 #include "lldb/DataFormatters/FormatManager.h"
17 #include "lldb/DataFormatters/TypeCategory.h"
18 #include "lldb/DataFormatters/TypeFormat.h"
19 #include "lldb/DataFormatters/TypeSummary.h"
20 #include "lldb/DataFormatters/TypeSynthetic.h"
21 #include "lldb/DataFormatters/TypeValidator.h"
22 #include "lldb/Target/Language.h"
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 
27 LanguageCategory::LanguageCategory (lldb::LanguageType lang_type) :
28     m_category_sp(),
29     m_format_cache()
30 {
31     if (Language* language_plugin = Language::FindPlugin(lang_type))
32         m_category_sp = language_plugin->GetFormatters();
33     if (m_category_sp)
34         m_category_sp->Enable(true, 1);
35 }
36 
37 bool
38 LanguageCategory::Get (ValueObject& valobj,
39                        lldb::DynamicValueType dynamic,
40                        FormattersMatchVector matches,
41                        lldb::TypeFormatImplSP& format_sp)
42 {
43     if (!m_category_sp)
44         return false;
45 
46     if (!m_category_sp->IsEnabled())
47         return false;
48 
49     ConstString type_name = FormatManager::GetTypeForCache(valobj, dynamic);
50     if (type_name)
51     {
52         if (m_format_cache.GetFormat(type_name, format_sp))
53             return format_sp.get() != nullptr;
54     }
55     bool result = m_category_sp->Get(valobj, matches, format_sp);
56     if (type_name && (!format_sp || !format_sp->NonCacheable()))
57     {
58         m_format_cache.SetFormat(type_name, format_sp);
59     }
60     return result;
61 }
62 
63 bool
64 LanguageCategory::Get (ValueObject& valobj,
65                        lldb::DynamicValueType dynamic,
66                        FormattersMatchVector matches,
67                        lldb::TypeSummaryImplSP& format_sp)
68 {
69     if (!m_category_sp)
70         return false;
71 
72     if (!m_category_sp->IsEnabled())
73         return false;
74 
75     ConstString type_name = FormatManager::GetTypeForCache(valobj, dynamic);
76     if (type_name)
77     {
78         if (m_format_cache.GetSummary(type_name, format_sp))
79             return format_sp.get() != nullptr;
80     }
81     bool result = m_category_sp->Get(valobj, matches, format_sp);
82     if (type_name && (!format_sp || !format_sp->NonCacheable()))
83     {
84         m_format_cache.SetSummary(type_name, format_sp);
85     }
86     return result;
87 }
88 
89 bool
90 LanguageCategory::Get (ValueObject& valobj,
91                        lldb::DynamicValueType dynamic,
92                        FormattersMatchVector matches,
93                        lldb::SyntheticChildrenSP& format_sp)
94 {
95     if (!m_category_sp)
96         return false;
97 
98     if (!m_category_sp->IsEnabled())
99         return false;
100 
101     ConstString type_name = FormatManager::GetTypeForCache(valobj, dynamic);
102     if (type_name)
103     {
104         if (m_format_cache.GetSynthetic(type_name, format_sp))
105             return format_sp.get() != nullptr;
106     }
107     bool result = m_category_sp->Get(valobj, matches, format_sp);
108     if (type_name && (!format_sp || !format_sp->NonCacheable()))
109     {
110         m_format_cache.SetSynthetic(type_name, format_sp);
111     }
112     return result;
113 }
114 
115 bool
116 LanguageCategory::Get (ValueObject& valobj,
117                        lldb::DynamicValueType dynamic,
118                        FormattersMatchVector matches,
119                        lldb::TypeValidatorImplSP& format_sp)
120 {
121     if (!m_category_sp)
122         return false;
123 
124     if (!m_category_sp->IsEnabled())
125         return false;
126 
127     ConstString type_name = FormatManager::GetTypeForCache(valobj, dynamic);
128     if (type_name)
129     {
130         if (m_format_cache.GetValidator(type_name, format_sp))
131             return format_sp.get() != nullptr;
132     }
133     bool result = m_category_sp->Get(valobj, matches, format_sp);
134     if (type_name && (!format_sp || !format_sp->NonCacheable()))
135     {
136         m_format_cache.SetValidator(type_name, format_sp);
137     }
138     return result;
139 }
140 
141 lldb::TypeCategoryImplSP
142 LanguageCategory::GetCategory () const
143 {
144     return m_category_sp;
145 }
146 
147 void
148 LanguageCategory::Enable ()
149 {
150     if (m_category_sp)
151         m_category_sp->Enable(true, TypeCategoryMap::Default);
152 }
153 
154 void
155 LanguageCategory::Disable ()
156 {
157     if (m_category_sp)
158         m_category_sp->Disable();
159 }
160