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

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