1 //===-- LanguageCategory.cpp ---------------------------------------*- C++
2 //-*-===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10 
11 #include "lldb/DataFormatters/LanguageCategory.h"
12 
13 #include "lldb/DataFormatters/FormatManager.h"
14 #include "lldb/DataFormatters/TypeCategory.h"
15 #include "lldb/DataFormatters/TypeFormat.h"
16 #include "lldb/DataFormatters/TypeSummary.h"
17 #include "lldb/DataFormatters/TypeSynthetic.h"
18 #include "lldb/DataFormatters/TypeValidator.h"
19 #include "lldb/Target/Language.h"
20 
21 using namespace lldb;
22 using namespace lldb_private;
23 
24 LanguageCategory::LanguageCategory(lldb::LanguageType lang_type)
25     : m_category_sp(), m_hardcoded_formats(), m_hardcoded_summaries(),
26       m_hardcoded_synthetics(), m_hardcoded_validators(), m_format_cache(),
27       m_enabled(false) {
28   if (Language *language_plugin = Language::FindPlugin(lang_type)) {
29     m_category_sp = language_plugin->GetFormatters();
30     m_hardcoded_formats = language_plugin->GetHardcodedFormats();
31     m_hardcoded_summaries = language_plugin->GetHardcodedSummaries();
32     m_hardcoded_synthetics = language_plugin->GetHardcodedSynthetics();
33     m_hardcoded_validators = language_plugin->GetHardcodedValidators();
34   }
35   Enable();
36 }
37 
38 bool LanguageCategory::Get(FormattersMatchData &match_data,
39                            lldb::TypeFormatImplSP &format_sp) {
40   if (!m_category_sp)
41     return false;
42 
43   if (!IsEnabled())
44     return false;
45 
46   if (match_data.GetTypeForCache()) {
47     if (m_format_cache.GetFormat(match_data.GetTypeForCache(), format_sp))
48       return format_sp.get() != nullptr;
49   }
50 
51   ValueObject &valobj(match_data.GetValueObject());
52   bool result =
53       m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
54   if (match_data.GetTypeForCache() &&
55       (!format_sp || !format_sp->NonCacheable())) {
56     m_format_cache.SetFormat(match_data.GetTypeForCache(), format_sp);
57   }
58   return result;
59 }
60 
61 bool LanguageCategory::Get(FormattersMatchData &match_data,
62                            lldb::TypeSummaryImplSP &format_sp) {
63   if (!m_category_sp)
64     return false;
65 
66   if (!IsEnabled())
67     return false;
68 
69   if (match_data.GetTypeForCache()) {
70     if (m_format_cache.GetSummary(match_data.GetTypeForCache(), format_sp))
71       return format_sp.get() != nullptr;
72   }
73 
74   ValueObject &valobj(match_data.GetValueObject());
75   bool result =
76       m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
77   if (match_data.GetTypeForCache() &&
78       (!format_sp || !format_sp->NonCacheable())) {
79     m_format_cache.SetSummary(match_data.GetTypeForCache(), format_sp);
80   }
81   return result;
82 }
83 
84 bool LanguageCategory::Get(FormattersMatchData &match_data,
85                            lldb::SyntheticChildrenSP &format_sp) {
86   if (!m_category_sp)
87     return false;
88 
89   if (!IsEnabled())
90     return false;
91 
92   if (match_data.GetTypeForCache()) {
93     if (m_format_cache.GetSynthetic(match_data.GetTypeForCache(), format_sp))
94       return format_sp.get() != nullptr;
95   }
96 
97   ValueObject &valobj(match_data.GetValueObject());
98   bool result =
99       m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
100   if (match_data.GetTypeForCache() &&
101       (!format_sp || !format_sp->NonCacheable())) {
102     m_format_cache.SetSynthetic(match_data.GetTypeForCache(), format_sp);
103   }
104   return result;
105 }
106 
107 bool LanguageCategory::Get(FormattersMatchData &match_data,
108                            lldb::TypeValidatorImplSP &format_sp) {
109   if (!m_category_sp)
110     return false;
111 
112   if (!IsEnabled())
113     return false;
114 
115   if (match_data.GetTypeForCache()) {
116     if (m_format_cache.GetValidator(match_data.GetTypeForCache(), format_sp))
117       return format_sp.get() != nullptr;
118   }
119 
120   ValueObject &valobj(match_data.GetValueObject());
121   bool result =
122       m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
123   if (match_data.GetTypeForCache() &&
124       (!format_sp || !format_sp->NonCacheable())) {
125     m_format_cache.SetValidator(match_data.GetTypeForCache(), format_sp);
126   }
127   return result;
128 }
129 
130 bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
131                                     FormattersMatchData &match_data,
132                                     lldb::TypeFormatImplSP &format_sp) {
133   if (!IsEnabled())
134     return false;
135 
136   ValueObject &valobj(match_data.GetValueObject());
137   lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
138 
139   for (auto &candidate : m_hardcoded_formats) {
140     if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
141       break;
142   }
143   if (match_data.GetTypeForCache() &&
144       (!format_sp || !format_sp->NonCacheable())) {
145     m_format_cache.SetFormat(match_data.GetTypeForCache(), format_sp);
146   }
147   return format_sp.get() != nullptr;
148 }
149 
150 bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
151                                     FormattersMatchData &match_data,
152                                     lldb::TypeSummaryImplSP &format_sp) {
153   if (!IsEnabled())
154     return false;
155 
156   ValueObject &valobj(match_data.GetValueObject());
157   lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
158 
159   for (auto &candidate : m_hardcoded_summaries) {
160     if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
161       break;
162   }
163   if (match_data.GetTypeForCache() &&
164       (!format_sp || !format_sp->NonCacheable())) {
165     m_format_cache.SetSummary(match_data.GetTypeForCache(), format_sp);
166   }
167   return format_sp.get() != nullptr;
168 }
169 
170 bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
171                                     FormattersMatchData &match_data,
172                                     lldb::SyntheticChildrenSP &format_sp) {
173   if (!IsEnabled())
174     return false;
175 
176   ValueObject &valobj(match_data.GetValueObject());
177   lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
178 
179   for (auto &candidate : m_hardcoded_synthetics) {
180     if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
181       break;
182   }
183   if (match_data.GetTypeForCache() &&
184       (!format_sp || !format_sp->NonCacheable())) {
185     m_format_cache.SetSynthetic(match_data.GetTypeForCache(), format_sp);
186   }
187   return format_sp.get() != nullptr;
188 }
189 
190 bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
191                                     FormattersMatchData &match_data,
192                                     lldb::TypeValidatorImplSP &format_sp) {
193   if (!IsEnabled())
194     return false;
195 
196   ValueObject &valobj(match_data.GetValueObject());
197   lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
198 
199   for (auto &candidate : m_hardcoded_validators) {
200     if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
201       break;
202   }
203   if (match_data.GetTypeForCache() &&
204       (!format_sp || !format_sp->NonCacheable())) {
205     m_format_cache.SetValidator(match_data.GetTypeForCache(), format_sp);
206   }
207   return format_sp.get() != nullptr;
208 }
209 
210 lldb::TypeCategoryImplSP LanguageCategory::GetCategory() const {
211   return m_category_sp;
212 }
213 
214 FormatCache &LanguageCategory::GetFormatCache() { return m_format_cache; }
215 
216 void LanguageCategory::Enable() {
217   if (m_category_sp)
218     m_category_sp->Enable(true, TypeCategoryMap::Default);
219   m_enabled = true;
220 }
221 
222 void LanguageCategory::Disable() {
223   if (m_category_sp)
224     m_category_sp->Disable();
225   m_enabled = false;
226 }
227 
228 bool LanguageCategory::IsEnabled() { return m_enabled; }
229