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