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

   1 //===-- FormattersHelpers.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 // C Includes
  11
  12 // C++ Includes
  13
  14 // Other libraries and framework includes
  15
  16 // Project includes
  17 #include "lldb/DataFormatters/FormattersHelpers.h"
  18
  19 #include "lldb/Core/ConstString.h"
  20 #include "lldb/Core/RegularExpression.h"
  21 #include "lldb/Target/StackFrame.h"
  22 #include "lldb/Target/Target.h"
  23 #include "lldb/Target/Thread.h"
  24
  25 using namespace lldb;
  26 using namespace lldb_private;
  27 using namespace lldb_private::formatters;
  28
  29 void
  30 lldb_private::formatters::AddFormat (TypeCategoryImpl::SharedPointer category_sp,
  31                                      lldb::Format format,
  32                                      ConstString type_name,
  33                                      TypeFormatImpl::Flags flags,
  34                                      bool regex)
  35 {
  36     lldb::TypeFormatImplSP format_sp(new TypeFormatImpl_Format(format, flags));
  37
  38     if (regex)
  39         category_sp->GetRegexTypeFormatsContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),format_sp);
  40     else
  41         category_sp->GetTypeFormatsContainer()->Add(type_name, format_sp);
  42 }
  43
  44 void
  45 lldb_private::formatters::AddSummary(TypeCategoryImpl::SharedPointer category_sp,
  46                                      TypeSummaryImplSP summary_sp,
  47                                      ConstString type_name,
  48                                      bool regex)
  49 {
  50     if (regex)
  51         category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
  52     else
  53         category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
  54 }
  55
  56 void
  57 lldb_private::formatters::AddStringSummary(TypeCategoryImpl::SharedPointer category_sp,
  58                                            const char* string,
  59                                            ConstString type_name,
  60                                            TypeSummaryImpl::Flags flags,
  61                                            bool regex)
  62 {
  63     lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags,
  64                                                                string));
  65
  66     if (regex)
  67         category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
  68     else
  69         category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
  70 }
  71
  72 void
  73 lldb_private::formatters::AddOneLineSummary (TypeCategoryImpl::SharedPointer category_sp,
  74                                              ConstString type_name,
  75                                              TypeSummaryImpl::Flags flags,
  76                                              bool regex)
  77 {
  78     flags.SetShowMembersOneLiner(true);
  79     lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags, ""));
  80
  81     if (regex)
  82         category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
  83     else
  84         category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
  85 }
  86
  87 #ifndef LLDB_DISABLE_PYTHON
  88 void
  89 lldb_private::formatters::AddCXXSummary (TypeCategoryImpl::SharedPointer category_sp,
  90                                          CXXFunctionSummaryFormat::Callback funct,
  91                                          const char* description,
  92                                          ConstString type_name,
  93                                          TypeSummaryImpl::Flags flags,
  94                                          bool regex)
  95 {
  96     lldb::TypeSummaryImplSP summary_sp(new CXXFunctionSummaryFormat(flags,funct,description));
  97     if (regex)
  98         category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
  99     else
 100         category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
 101 }
 102
 103 void
 104 lldb_private::formatters::AddCXXSynthetic  (TypeCategoryImpl::SharedPointer category_sp,
 105                                             CXXSyntheticChildren::CreateFrontEndCallback generator,
 106                                             const char* description,
 107                                             ConstString type_name,
 108                                             ScriptedSyntheticChildren::Flags flags,
 109                                             bool regex)
 110 {
 111     lldb::SyntheticChildrenSP synth_sp(new CXXSyntheticChildren(flags,description,generator));
 112     if (regex)
 113         category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())), synth_sp);
 114     else
 115         category_sp->GetTypeSyntheticsContainer()->Add(type_name,synth_sp);
 116 }
 117
 118 void
 119 lldb_private::formatters::AddFilter  (TypeCategoryImpl::SharedPointer category_sp,
 120                                       std::vector<std::string> children,
 121                                       const char* description,
 122                                       ConstString type_name,
 123                                       ScriptedSyntheticChildren::Flags flags,
 124                                       bool regex)
 125 {
 126     TypeFilterImplSP filter_sp(new TypeFilterImpl(flags));
 127     for (auto child : children)
 128         filter_sp->AddExpressionPath(child);
 129     if (regex)
 130         category_sp->GetRegexTypeFiltersContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())), filter_sp);
 131     else
 132         category_sp->GetTypeFiltersContainer()->Add(type_name,filter_sp);
 133 }
 134 #endif
 135
 136 size_t
 137 lldb_private::formatters::ExtractIndexFromString (const char* item_name)
 138 {
 139     if (!item_name || !*item_name)
 140         return UINT32_MAX;
 141     if (*item_name != '[')
 142         return UINT32_MAX;
 143     item_name++;
 144     char* endptr = NULL;
 145     unsigned long int idx = ::strtoul(item_name, &endptr, 0);
 146     if (idx == 0 && endptr == item_name)
 147         return UINT32_MAX;
 148     if (idx == ULONG_MAX)
 149         return UINT32_MAX;
 150     return idx;
 151 }
 152
 153 lldb::addr_t
 154 lldb_private::formatters::GetArrayAddressOrPointerValue (ValueObject& valobj)
 155 {
 156     lldb::addr_t data_addr = LLDB_INVALID_ADDRESS;
 157
 158     if (valobj.IsPointerType())
 159         data_addr = valobj.GetValueAsUnsigned(0);
 160     else if (valobj.IsArrayType())
 161         data_addr = valobj.GetAddressOf();
 162
 163     return data_addr;
 164 }