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