contrib/llvm/tools/lldb/source/DataFormatters/LanguageCategory.cpp

   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; }