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