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
LanguageCategory(lldb::LanguageType lang_type)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
Get(FormattersMatchData & match_data,lldb::TypeFormatImplSP & format_sp)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
Get(FormattersMatchData & match_data,lldb::TypeSummaryImplSP & format_sp)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
Get(FormattersMatchData & match_data,lldb::SyntheticChildrenSP & format_sp)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
Get(FormattersMatchData & match_data,lldb::TypeValidatorImplSP & format_sp)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
GetHardcoded(FormatManager & fmt_mgr,FormattersMatchData & match_data,lldb::TypeFormatImplSP & format_sp)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
GetHardcoded(FormatManager & fmt_mgr,FormattersMatchData & match_data,lldb::TypeSummaryImplSP & format_sp)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
GetHardcoded(FormatManager & fmt_mgr,FormattersMatchData & match_data,lldb::SyntheticChildrenSP & format_sp)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
GetHardcoded(FormatManager & fmt_mgr,FormattersMatchData & match_data,lldb::TypeValidatorImplSP & format_sp)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
GetCategory() const210 lldb::TypeCategoryImplSP LanguageCategory::GetCategory() const {
211 return m_category_sp;
212 }
213
GetFormatCache()214 FormatCache &LanguageCategory::GetFormatCache() { return m_format_cache; }
215
Enable()216 void LanguageCategory::Enable() {
217 if (m_category_sp)
218 m_category_sp->Enable(true, TypeCategoryMap::Default);
219 m_enabled = true;
220 }
221
Disable()222 void LanguageCategory::Disable() {
223 if (m_category_sp)
224 m_category_sp->Disable();
225 m_enabled = false;
226 }
227
IsEnabled()228 bool LanguageCategory::IsEnabled() { return m_enabled; }
229