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

   1 //===-- TypeCategoryMap.cpp ----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/lldb-python.h"
  11
  12 #include "lldb/DataFormatters/TypeCategoryMap.h"
  13
  14 #include "lldb/DataFormatters/FormatClasses.h"
  15 #include "lldb/DataFormatters/FormatManager.h"
  16
  17 // C Includes
  18 // C++ Includes
  19 // Other libraries and framework includes
  20 // Project includes
  21
  22 using namespace lldb;
  23 using namespace lldb_private;
  24
  25 TypeCategoryMap::TypeCategoryMap (IFormatChangeListener* lst) :
  26 m_map_mutex(Mutex::eMutexTypeRecursive),
  27 listener(lst),
  28 m_map(),
  29 m_active_categories()
  30 {
  31     ConstString default_cs("default");
  32     lldb::TypeCategoryImplSP default_sp = lldb::TypeCategoryImplSP(new TypeCategoryImpl(listener, default_cs));
  33     Add(default_cs,default_sp);
  34     Enable(default_cs,First);
  35 }
  36
  37 void
  38 TypeCategoryMap::Add (KeyType name, const ValueSP& entry)
  39 {
  40     Mutex::Locker locker(m_map_mutex);
  41     m_map[name] = entry;
  42     if (listener)
  43         listener->Changed();
  44 }
  45
  46 bool
  47 TypeCategoryMap::Delete (KeyType name)
  48 {
  49     Mutex::Locker locker(m_map_mutex);
  50     MapIterator iter = m_map.find(name);
  51     if (iter == m_map.end())
  52         return false;
  53     m_map.erase(name);
  54     Disable(name);
  55     if (listener)
  56         listener->Changed();
  57     return true;
  58 }
  59
  60 bool
  61 TypeCategoryMap::Enable (KeyType category_name, Position pos)
  62 {
  63     Mutex::Locker locker(m_map_mutex);
  64     ValueSP category;
  65     if (!Get(category_name,category))
  66         return false;
  67     return Enable(category, pos);
  68 }
  69
  70 bool
  71 TypeCategoryMap::Disable (KeyType category_name)
  72 {
  73     Mutex::Locker locker(m_map_mutex);
  74     ValueSP category;
  75     if (!Get(category_name,category))
  76         return false;
  77     return Disable(category);
  78 }
  79
  80 bool
  81 TypeCategoryMap::Enable (ValueSP category, Position pos)
  82 {
  83     Mutex::Locker locker(m_map_mutex);
  84     if (category.get())
  85     {
  86         Position pos_w = pos;
  87         if (pos == First || m_active_categories.size() == 0)
  88             m_active_categories.push_front(category);
  89         else if (pos == Last || pos == m_active_categories.size())
  90             m_active_categories.push_back(category);
  91         else if (pos < m_active_categories.size())
  92         {
  93             ActiveCategoriesList::iterator iter = m_active_categories.begin();
  94             while (pos_w)
  95             {
  96                 pos_w--,iter++;
  97             }
  98             m_active_categories.insert(iter,category);
  99         }
 100         else
 101             return false;
 102         category->Enable(true,
 103                          pos);
 104         return true;
 105     }
 106     return false;
 107 }
 108
 109 bool
 110 TypeCategoryMap::Disable (ValueSP category)
 111 {
 112     Mutex::Locker locker(m_map_mutex);
 113     if (category.get())
 114     {
 115         m_active_categories.remove_if(delete_matching_categories(category));
 116         category->Disable();
 117         return true;
 118     }
 119     return false;
 120 }
 121
 122 void
 123 TypeCategoryMap::EnableAllCategories ()
 124 {
 125     Mutex::Locker locker(m_map_mutex);
 126     std::vector<ValueSP> sorted_categories(m_map.size(), ValueSP());
 127     MapType::iterator iter = m_map.begin(), end = m_map.end();
 128     for (; iter != end; ++iter)
 129     {
 130         if (iter->second->IsEnabled())
 131             continue;
 132         auto pos = iter->second->GetLastEnabledPosition();
 133         if (pos >= sorted_categories.size())
 134         {
 135             auto iter = std::find_if(sorted_categories.begin(),
 136                                      sorted_categories.end(),
 137                                      [] (const ValueSP& sp) -> bool {
 138                                          return sp.get() == nullptr;
 139                                      });
 140             pos = std::distance(sorted_categories.begin(), iter);
 141         }
 142         sorted_categories.at(pos) = iter->second;
 143     }
 144     decltype(sorted_categories)::iterator viter = sorted_categories.begin(), vend = sorted_categories.end();
 145     for (; viter != vend; viter++)
 146         if (viter->get())
 147             Enable(*viter, Last);
 148 }
 149
 150 void
 151 TypeCategoryMap::DisableAllCategories ()
 152 {
 153     Mutex::Locker locker(m_map_mutex);
 154     Position p = First;
 155     for (; false == m_active_categories.empty(); p++)
 156     {
 157         m_active_categories.front()->SetEnabledPosition(p);
 158         Disable(m_active_categories.front());
 159     }
 160 }
 161
 162 void
 163 TypeCategoryMap::Clear ()
 164 {
 165     Mutex::Locker locker(m_map_mutex);
 166     m_map.clear();
 167     m_active_categories.clear();
 168     if (listener)
 169         listener->Changed();
 170 }
 171
 172 bool
 173 TypeCategoryMap::Get (KeyType name, ValueSP& entry)
 174 {
 175     Mutex::Locker locker(m_map_mutex);
 176     MapIterator iter = m_map.find(name);
 177     if (iter == m_map.end())
 178         return false;
 179     entry = iter->second;
 180     return true;
 181 }
 182
 183 bool
 184 TypeCategoryMap::Get (uint32_t pos, ValueSP& entry)
 185 {
 186     Mutex::Locker locker(m_map_mutex);
 187     MapIterator iter = m_map.begin();
 188     MapIterator end = m_map.end();
 189     while (pos > 0)
 190     {
 191         iter++;
 192         pos--;
 193         if (iter == end)
 194             return false;
 195     }
 196     entry = iter->second;
 197     return false;
 198 }
 199
 200 bool
 201 TypeCategoryMap::AnyMatches (ConstString type_name,
 202                              TypeCategoryImpl::FormatCategoryItems items,
 203                              bool only_enabled,
 204                              const char** matching_category,
 205                              TypeCategoryImpl::FormatCategoryItems* matching_type)
 206 {
 207     Mutex::Locker locker(m_map_mutex);
 208
 209     MapIterator pos, end = m_map.end();
 210     for (pos = m_map.begin(); pos != end; pos++)
 211     {
 212         if (pos->second->AnyMatches(type_name,
 213                                     items,
 214                                     only_enabled,
 215                                     matching_category,
 216                                     matching_type))
 217             return true;
 218     }
 219     return false;
 220 }
 221
 222 lldb::TypeFormatImplSP
 223 TypeCategoryMap::GetFormat (ValueObject& valobj,
 224                             lldb::DynamicValueType use_dynamic)
 225 {
 226     Mutex::Locker locker(m_map_mutex);
 227
 228     uint32_t reason_why;
 229     ActiveCategoriesIterator begin, end = m_active_categories.end();
 230
 231     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
 232
 233     FormattersMatchVector matches = FormatManager::GetPossibleMatches(valobj, use_dynamic);
 234
 235     for (begin = m_active_categories.begin(); begin != end; begin++)
 236     {
 237         lldb::TypeCategoryImplSP category_sp = *begin;
 238         lldb::TypeFormatImplSP current_format;
 239         if (log)
 240             log->Printf("\n[TypeCategoryMap::GetFormat] Trying to use category %s", category_sp->GetName());
 241         if (!category_sp->Get(valobj, matches, current_format, &reason_why))
 242             continue;
 243         return current_format;
 244     }
 245     if (log)
 246         log->Printf("[TypeCategoryMap::GetFormat] nothing found - returning empty SP");
 247     return lldb::TypeFormatImplSP();
 248 }
 249
 250 lldb::TypeSummaryImplSP
 251 TypeCategoryMap::GetSummaryFormat (ValueObject& valobj,
 252                                    lldb::DynamicValueType use_dynamic)
 253 {
 254     Mutex::Locker locker(m_map_mutex);
 255
 256     uint32_t reason_why;
 257     ActiveCategoriesIterator begin, end = m_active_categories.end();
 258
 259     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
 260
 261     FormattersMatchVector matches = FormatManager::GetPossibleMatches(valobj, use_dynamic);
 262
 263     for (begin = m_active_categories.begin(); begin != end; begin++)
 264     {
 265         lldb::TypeCategoryImplSP category_sp = *begin;
 266         lldb::TypeSummaryImplSP current_format;
 267         if (log)
 268             log->Printf("\n[CategoryMap::GetSummaryFormat] Trying to use category %s", category_sp->GetName());
 269         if (!category_sp->Get(valobj, matches, current_format, &reason_why))
 270             continue;
 271         return current_format;
 272     }
 273     if (log)
 274         log->Printf("[CategoryMap::GetSummaryFormat] nothing found - returning empty SP");
 275     return lldb::TypeSummaryImplSP();
 276 }
 277
 278 #ifndef LLDB_DISABLE_PYTHON
 279 lldb::SyntheticChildrenSP
 280 TypeCategoryMap::GetSyntheticChildren (ValueObject& valobj,
 281                                        lldb::DynamicValueType use_dynamic)
 282 {
 283     Mutex::Locker locker(m_map_mutex);
 284
 285     uint32_t reason_why;
 286
 287     ActiveCategoriesIterator begin, end = m_active_categories.end();
 288
 289     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
 290
 291     FormattersMatchVector matches = FormatManager::GetPossibleMatches(valobj, use_dynamic);
 292
 293     for (begin = m_active_categories.begin(); begin != end; begin++)
 294     {
 295         lldb::TypeCategoryImplSP category_sp = *begin;
 296         lldb::SyntheticChildrenSP current_format;
 297         if (log)
 298             log->Printf("\n[CategoryMap::GetSyntheticChildren] Trying to use category %s", category_sp->GetName());
 299         if (!category_sp->Get(valobj, matches, current_format, &reason_why))
 300             continue;
 301         return current_format;
 302     }
 303     if (log)
 304         log->Printf("[CategoryMap::GetSyntheticChildren] nothing found - returning empty SP");
 305     return lldb::SyntheticChildrenSP();
 306 }
 307 #endif
 308
 309 lldb::TypeValidatorImplSP
 310 TypeCategoryMap::GetValidator (ValueObject& valobj,
 311                                lldb::DynamicValueType use_dynamic)
 312 {
 313     Mutex::Locker locker(m_map_mutex);
 314
 315     uint32_t reason_why;
 316     ActiveCategoriesIterator begin, end = m_active_categories.end();
 317
 318     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
 319
 320     FormattersMatchVector matches = FormatManager::GetPossibleMatches(valobj, use_dynamic);
 321
 322     for (begin = m_active_categories.begin(); begin != end; begin++)
 323     {
 324         lldb::TypeCategoryImplSP category_sp = *begin;
 325         lldb::TypeValidatorImplSP current_format;
 326         if (log)
 327             log->Printf("\n[CategoryMap::GetValidator] Trying to use category %s", category_sp->GetName());
 328         if (!category_sp->Get(valobj, matches, current_format, &reason_why))
 329             continue;
 330         return current_format;
 331     }
 332     if (log)
 333         log->Printf("[CategoryMap::GetValidator] nothing found - returning empty SP");
 334     return lldb::TypeValidatorImplSP();
 335 }
 336
 337 void
 338 TypeCategoryMap::LoopThrough(CallbackType callback, void* param)
 339 {
 340     if (callback)
 341     {
 342         Mutex::Locker locker(m_map_mutex);
 343
 344         // loop through enabled categories in respective order
 345         {
 346             ActiveCategoriesIterator begin, end = m_active_categories.end();
 347             for (begin = m_active_categories.begin(); begin != end; begin++)
 348             {
 349                 lldb::TypeCategoryImplSP category = *begin;
 350                 ConstString type = ConstString(category->GetName());
 351                 if (!callback(param, category))
 352                     break;
 353             }
 354         }
 355
 356         // loop through disabled categories in just any order
 357         {
 358             MapIterator pos, end = m_map.end();
 359             for (pos = m_map.begin(); pos != end; pos++)
 360             {
 361                 if (pos->second->IsEnabled())
 362                     continue;
 363                 KeyType type = pos->first;
 364                 if (!callback(param, pos->second))
 365                     break;
 366             }
 367         }
 368     }
 369 }
 370
 371 TypeCategoryImplSP
 372 TypeCategoryMap::GetAtIndex (uint32_t index)
 373 {
 374     Mutex::Locker locker(m_map_mutex);
 375
 376     if (index < m_map.size())
 377     {
 378         MapIterator pos, end = m_map.end();
 379         for (pos = m_map.begin(); pos != end; pos++)
 380         {
 381             if (index == 0)
 382                 return pos->second;
 383             index--;
 384         }
 385     }
 386
 387     return TypeCategoryImplSP();
 388 }