-//===-- CPlusPlusLanguage.cpp --------------------------------------*- C++ -*-===//
+//===-- CPlusPlusLanguage.cpp -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
#include "CPlusPlusLanguage.h"
+// C Includes
+// C++ Includes
+#include <cstring>
+#include <cctype>
+#include <functional>
+#include <mutex>
+// Other libraries and framework includes
#include "llvm/ADT/StringRef.h"
+// Project includes
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegularExpression.h"
#include "LibCxxAtomic.h"
#include "LibStdcpp.h"
-#include <cstring>
-#include <cctype>
-#include <functional>
-#include <mutex>
-
using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::formatters;
return g_name;
}
-
//------------------------------------------------------------------
// PluginInterface protocol
//------------------------------------------------------------------
+
lldb_private::ConstString
CPlusPlusLanguage::GetPluginName()
{
//------------------------------------------------------------------
// Static Functions
//------------------------------------------------------------------
+
Language *
CPlusPlusLanguage::CreateInstance (lldb::LanguageType language)
{
// this is a C++ mangled name, but we can put that off till there is actually more than one
// we care about.
- if (name && name[0] == '_' && name[1] == 'Z')
- return true;
- else
- return false;
+ return (name != nullptr && name[0] == '_' && name[1] == 'Z');
}
bool
public:
CPPRuntimeEquivalents ()
{
-
m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("basic_string<char>"));
// these two (with a prefixed std::) occur when c++stdlib string class occurs as a template argument in some STL container
FindExactMatches (ConstString& type_name,
std::vector<ConstString>& equivalents)
{
-
uint32_t count = 0;
for (ImplData match = m_impl.FindFirstValueForName(type_name.AsCString());
- match != NULL;
+ match != nullptr;
match = m_impl.FindNextValueForName(match))
{
equivalents.push_back(match->value);
FindPartialMatches (ConstString& type_name,
std::vector<ConstString>& equivalents)
{
-
uint32_t count = 0;
const char* type_name_cstr = type_name.AsCString();
}
return count;
-
}
private:
-
std::string& replace (std::string& target,
std::string& pattern,
std::string& with)
const char *matching_key,
std::vector<ConstString>& equivalents)
{
-
std::string matching_key_str(matching_key);
ConstString original_const(original);
uint32_t count = 0;
for (ImplData match = m_impl.FindFirstValueForName(matching_key);
- match != NULL;
+ match != nullptr;
match = m_impl.FindNextValueForName(match))
{
std::string target(original);
return g_equivalents_map;
}
-
uint32_t
CPlusPlusLanguage::FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents)
{
bool might_have_partials=
( count == 0 ) // if we have a full name match just use it
- && (strchr(type_name.AsCString(), '<') != NULL // we should only have partial matches when templates are involved, check that we have
- && strchr(type_name.AsCString(), '>') != NULL); // angle brackets in the type_name before trying to scan for partial matches
+ && (strchr(type_name.AsCString(), '<') != nullptr // we should only have partial matches when templates are involved, check that we have
+ && strchr(type_name.AsCString(), '>') != nullptr); // angle brackets in the type_name before trying to scan for partial matches
if ( might_have_partials )
count = GetEquivalentsMap().FindPartialMatches(type_name, equivalents);
return g_formatters;
}
-
#include "LibCxx.h"
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
}
lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_bool_type(),
-m_exe_ctx_ref(),
-m_count(0),
-m_base_data_address(0),
-m_children()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_bool_type(),
+ m_exe_ctx_ref(),
+ m_count(0),
+ m_base_data_address(0),
+ m_children()
{
if (valobj_sp)
{
return ValueObjectSP();
}
bool bit_set = ((byte & mask) != 0);
- DataBufferSP buffer_sp(new DataBufferHeap(m_bool_type.GetByteSize(nullptr),0));
+ DataBufferSP buffer_sp(new DataBufferHeap(m_bool_type.GetByteSize(nullptr), 0));
if (bit_set && buffer_sp && buffer_sp->GetBytes())
*(buffer_sp->GetBytes()) = 1; // regardless of endianness, anything non-zero is true
StreamString name; name.Printf("[%" PRIu64 "]", (uint64_t)idx);
return idx;
}
-lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::~LibcxxVectorBoolSyntheticFrontEnd ()
-{}
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::~LibcxxVectorBoolSyntheticFrontEnd() = default;
SyntheticChildrenFrontEnd*
lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp) : nullptr);
}
/*
*/
lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_pair_ptr()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_pair_ptr()
{
if (valobj_sp)
Update();
// it if were a ValueObjectSP, we would end up with a loop (iterator -> synthetic -> child -> parent == iterator)
// and that would in turn leak memory by never allowing the ValueObjects to die and free their memory
m_pair_ptr = valobj_sp->GetValueForExpressionPath(".__i_.__ptr_->__value_",
- NULL,
- NULL,
- NULL,
- ValueObject::GetValueForExpressionPathOptions().DontCheckDotVsArrowSyntax().SetSyntheticChildrenTraversal(ValueObject::GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None),
- NULL).get();
+ nullptr,
+ nullptr,
+ nullptr,
+ ValueObject::GetValueForExpressionPathOptions().DontCheckDotVsArrowSyntax().SetSyntheticChildrenTraversal(ValueObject::GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None),
+ nullptr).get();
return false;
}
SyntheticChildrenFrontEnd*
lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp) : nullptr);
}
/*
static ConstString g_item_name;
if (!g_item_name)
g_item_name.SetCString("__i");
- if (!valobj_sp)
- return NULL;
- return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name));
+ return (valobj_sp ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name) : nullptr);
}
lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_cntrl(NULL),
-m_count_sp(),
-m_weak_count_sp(),
-m_ptr_size(0),
-m_byte_order(lldb::eByteOrderInvalid)
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_cntrl(nullptr),
+ m_count_sp(),
+ m_weak_count_sp(),
+ m_ptr_size(0),
+ m_byte_order(lldb::eByteOrderInvalid)
{
if (valobj_sp)
Update();
{
m_count_sp.reset();
m_weak_count_sp.reset();
- m_cntrl = NULL;
+ m_cntrl = nullptr;
ValueObjectSP valobj_sp = m_backend.GetSP();
if (!valobj_sp)
return UINT32_MAX;
}
-lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::~LibcxxSharedPtrSyntheticFrontEnd ()
-{}
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::~LibcxxSharedPtrSyntheticFrontEnd() = default;
SyntheticChildrenFrontEnd*
lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp) : nullptr);
}
bool
return false;
stream.Printf("0x%016" PRIx64 " ", value);
}
- return FormatEntity::FormatStringRef("size=${svar%#}", stream, NULL, NULL, NULL, &valobj, false, false);
+ return FormatEntity::FormatStringRef("size=${svar%#}", stream, nullptr, nullptr, nullptr, &valobj, false, false);
}
// the field layout in a libc++ string (cap, side, data or data, size, cap)
lldb_private::formatters::LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options)
{
uint64_t size = 0;
- ValueObjectSP location_sp((ValueObject*)nullptr);
+ ValueObjectSP location_sp;
if (!ExtractLibcxxStringInfo(valobj, location_sp, size))
return false;
if (size == 0)
lldb_private::formatters::LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options)
{
uint64_t size = 0;
- ValueObjectSP location_sp((ValueObject*)nullptr);
+ ValueObjectSP location_sp;
if (!ExtractLibcxxStringInfo(valobj, location_sp, size))
return false;
options.SetData(extractor);
options.SetStream(&stream);
- options.SetPrefixToken(0);
+ options.SetPrefixToken(nullptr);
options.SetQuote('"');
options.SetSourceSize(size);
options.SetBinaryZeroIsTerminator(false);
} // namespace lldb_private
lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::LibcxxInitializerListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_start(NULL),
-m_element_type(),
-m_element_size(0),
-m_num_elements(0),
-m_children()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_start(nullptr),
+ m_element_type(),
+ m_element_size(0),
+ m_num_elements(0),
+ m_children()
{
if (valobj_sp)
Update();
m_children.clear();
lldb::TemplateArgumentKind kind;
m_element_type = m_backend.GetCompilerType().GetTemplateArgument(0, kind);
- if (kind != lldb::eTemplateArgumentKindType || false == m_element_type.IsValid())
+ if (kind != lldb::eTemplateArgumentKindType || !m_element_type.IsValid())
return false;
m_element_size = m_element_type.GetByteSize(nullptr);
lldb_private::SyntheticChildrenFrontEnd*
lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibcxxInitializerListSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibcxxInitializerListSyntheticFrontEnd(valobj_sp) : nullptr);
}
public:
ListEntry() = default;
ListEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {}
- ListEntry (const ListEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {}
+ ListEntry(const ListEntry& rhs) = default;
ListEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
ListEntry
explicit operator bool ()
{
- return GetEntry().get() != nullptr && null() == false;
+ return GetEntry() && !null();
}
ValueObjectSP
ListIterator() = default;
ListIterator (ListEntry entry) : m_entry(entry) {}
ListIterator (ValueObjectSP entry) : m_entry(entry) {}
- ListIterator (const ListIterator& rhs) : m_entry(rhs.m_entry) {}
+ ListIterator(const ListIterator& rhs) = default;
ListIterator (ValueObject* entry) : m_entry(entry) {}
ValueObjectSP
} // namespace lldb_private
lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_list_capping_size(0),
-m_loop_detected(0),
-m_node_address(),
-m_head(NULL),
-m_tail(NULL),
-m_element_type(),
-m_count(UINT32_MAX),
-m_children(),
-m_iterators()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_list_capping_size(0),
+ m_loop_detected(0),
+ m_node_address(),
+ m_head(nullptr),
+ m_tail(nullptr),
+ m_element_type(),
+ m_count(UINT32_MAX),
+ m_children(),
+ m_iterators()
{
if (valobj_sp)
Update();
bool
lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::HasLoop(size_t count)
{
- if (g_use_loop_detect == false)
+ if (!g_use_loop_detect)
return false;
// don't bother checking for a loop if we won't actually need to jump nodes
if (m_count < 2)
{
m_children.clear();
m_iterators.clear();
- m_head = m_tail = NULL;
+ m_head = m_tail = nullptr;
m_node_address = 0;
m_count = UINT32_MAX;
m_loop_detected = 0;
m_list_capping_size = m_backend.GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
if (m_list_capping_size == 0)
m_list_capping_size = 255;
- if (err.Fail() || backend_addr.get() == NULL)
+ if (err.Fail() || !backend_addr)
return false;
m_node_address = backend_addr->GetValueAsUnsigned(0);
if (!m_node_address || m_node_address == LLDB_INVALID_ADDRESS)
SyntheticChildrenFrontEnd*
lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibcxxStdListSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibcxxStdListSyntheticFrontEnd(valobj_sp) : nullptr);
}
public:
MapEntry() = default;
explicit MapEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {}
- MapEntry (const MapEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {}
+ MapEntry(const MapEntry& rhs) = default;
explicit MapEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
ValueObjectSP
ValueObjectSP
advance (size_t count)
{
- ValueObjectSP fail(nullptr);
+ ValueObjectSP fail;
if (m_error)
return fail;
size_t steps = 0;
if (m_entry.null())
return;
MapEntry right(m_entry.right());
- if (right.null() == false)
+ if (!right.null())
{
m_entry = tree_min(std::move(right));
return;
return MapEntry();
MapEntry left(x.left());
size_t steps = 0;
- while (left.null() == false)
+ while (!left.null())
{
if (left.error())
{
} // namespace lldb_private
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_tree(NULL),
-m_root_node(NULL),
-m_element_type(),
-m_skip_size(UINT32_MAX),
-m_count(UINT32_MAX),
-m_children(),
-m_iterators()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_tree(nullptr),
+ m_root_node(nullptr),
+ m_element_type(),
+ m_skip_size(UINT32_MAX),
+ m_count(UINT32_MAX),
+ m_children(),
+ m_iterators()
{
if (valobj_sp)
Update();
if (m_count != UINT32_MAX)
return m_count;
- if (m_tree == NULL)
+ if (m_tree == nullptr)
return 0;
ValueObjectSP m_item(m_tree->GetChildMemberWithName(g___pair3_, true));
if (!m_item)
return;
CompilerType node_type(node->GetCompilerType());
uint64_t bit_offset;
- if (node_type.GetIndexOfFieldWithName("__value_", NULL, &bit_offset) == UINT32_MAX)
+ if (node_type.GetIndexOfFieldWithName("__value_", nullptr, &bit_offset) == UINT32_MAX)
return;
m_skip_size = bit_offset / 8u;
}
static ConstString g___nc("__nc");
static ConstString g___value_("__value_");
-
if (idx >= CalculateNumChildren())
return lldb::ValueObjectSP();
- if (m_tree == NULL || m_root_node == NULL)
+ if (m_tree == nullptr || m_root_node == nullptr)
return lldb::ValueObjectSP();
auto cached = m_children.find(idx);
}
ValueObjectSP iterated_sp(iterator.advance(actual_advancde));
- if (iterated_sp.get() == NULL)
+ if (!iterated_sp)
{
// this tree is garbage - stop
- m_tree = NULL; // this will stop all future searches until an Update() happens
+ m_tree = nullptr; // this will stop all future searches until an Update() happens
return iterated_sp;
}
if (GetDataType())
iterated_sp = iterated_sp->Dereference(error);
if (!iterated_sp || error.Fail())
{
- m_tree = NULL;
+ m_tree = nullptr;
return lldb::ValueObjectSP();
}
GetValueOffset(iterated_sp);
iterated_sp = iterated_sp->GetChildMemberWithName(g___value_, true);
if (!iterated_sp)
{
- m_tree = NULL;
+ m_tree = nullptr;
return lldb::ValueObjectSP();
}
}
GetChildAtIndex(0);
if (m_skip_size == UINT32_MAX)
{
- m_tree = NULL;
+ m_tree = nullptr;
return lldb::ValueObjectSP();
}
iterated_sp = iterated_sp->GetSyntheticChildAtOffset(m_skip_size, m_element_type, true);
if (!iterated_sp)
{
- m_tree = NULL;
+ m_tree = nullptr;
return lldb::ValueObjectSP();
}
}
}
else
{
- m_tree = NULL;
+ m_tree = nullptr;
return lldb::ValueObjectSP();
}
// at this point we have a valid
iterated_sp->GetData(data, error);
if (error.Fail())
{
- m_tree = NULL;
+ m_tree = nullptr;
return lldb::ValueObjectSP();
}
StreamString name;
static ConstString g___tree_("__tree_");
static ConstString g___begin_node_("__begin_node_");
m_count = UINT32_MAX;
- m_tree = m_root_node = NULL;
+ m_tree = m_root_node = nullptr;
m_children.clear();
m_iterators.clear();
m_tree = m_backend.GetChildMemberWithName(g___tree_, true).get();
SyntheticChildrenFrontEnd*
lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibcxxStdMapSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibcxxStdMapSyntheticFrontEnd(valobj_sp) : nullptr);
}
} // namespace lldb_private
lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::LibcxxStdUnorderedMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_tree(NULL),
-m_num_elements(0),
-m_next_element(nullptr),
-m_children(),
-m_elements_cache()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_tree(nullptr),
+ m_num_elements(0),
+ m_next_element(nullptr),
+ m_children(),
+ m_elements_cache()
{
if (valobj_sp)
Update();
{
if (idx >= CalculateNumChildren())
return lldb::ValueObjectSP();
- if (m_tree == NULL)
+ if (m_tree == nullptr)
return lldb::ValueObjectSP();
auto cached = m_children.find(idx);
SyntheticChildrenFrontEnd*
lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibcxxStdUnorderedMapSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibcxxStdUnorderedMapSyntheticFrontEnd(valobj_sp) : nullptr);
}
} // namespace lldb_private
lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_start(NULL),
-m_finish(NULL),
-m_element_type(),
-m_element_size(0),
-m_children()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_start(nullptr),
+ m_finish(nullptr),
+ m_element_type(),
+ m_element_size(0),
+ m_children()
{
if (valobj_sp)
Update();
bool
lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update()
{
- m_start = m_finish = NULL;
+ m_start = m_finish = nullptr;
m_children.clear();
ValueObjectSP data_type_finder_sp(m_backend.GetChildMemberWithName(ConstString("__end_cap_"),true));
if (!data_type_finder_sp)
lldb_private::SyntheticChildrenFrontEnd*
lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibcxxStdVectorSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibcxxStdVectorSyntheticFrontEnd(valobj_sp) : nullptr);
}
-//===-- LibStdcpp.cpp ---------------------------------------------*- C++ -*-===//
+//===-- LibStdcpp.cpp -------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
#include "LibStdcpp.h"
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Stream.h"
{
public:
LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-
+
+ ~LibstdcppMapIteratorSyntheticFrontEnd() override = default;
+
size_t
CalculateNumChildren() override;
size_t
GetIndexOfChildWithName (const ConstString &name) override;
- ~LibstdcppMapIteratorSyntheticFrontEnd() override;
-
private:
ExecutionContextRef m_exe_ctx_ref;
lldb::addr_t m_pair_address;
*/
LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
- SyntheticChildrenFrontEnd(*valobj_sp.get()),
+ SyntheticChildrenFrontEnd(*valobj_sp),
m_exe_ctx_ref(),
m_pair_address(0),
m_pair_type(),
return UINT32_MAX;
}
-LibstdcppMapIteratorSyntheticFrontEnd::~LibstdcppMapIteratorSyntheticFrontEnd ()
-{}
-
SyntheticChildrenFrontEnd*
lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
- if (!valobj_sp)
- return NULL;
- return (new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp));
+ return (valobj_sp ? new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp) : nullptr);
}
/*
static ConstString g_item_name;
if (!g_item_name)
g_item_name.SetCString("_M_current");
- if (!valobj_sp)
- return NULL;
- return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name));
+ return (valobj_sp ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name) : nullptr);
}
lldb_private::formatters::VectorIteratorSyntheticFrontEnd::VectorIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp,
ConstString item_name) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_exe_ctx_ref(),
-m_item_name(item_name),
-m_item_sp()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_exe_ctx_ref(),
+ m_item_name(item_name),
+ m_item_sp()
{
if (valobj_sp)
Update();
return UINT32_MAX;
}
-lldb_private::formatters::VectorIteratorSyntheticFrontEnd::~VectorIteratorSyntheticFrontEnd ()
-{
-}
+lldb_private::formatters::VectorIteratorSyntheticFrontEnd::~VectorIteratorSyntheticFrontEnd() = default;
bool
lldb_private::formatters::LibStdcppStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeObjCID), true));
StreamString summary_stream;
- bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options);
+ bool was_nsstring_ok = NSStringSummaryProvider(*text, summary_stream, options);
if (was_nsstring_ok && summary_stream.GetSize() > 0)
{
stream.Printf("%s",summary_stream.GetData());
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
uint64_t offset = ptr_size;
ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType(), true));
StreamString summary_stream;
- bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options);
+ bool was_nsstring_ok = NSStringSummaryProvider(*text, summary_stream, options);
if (was_nsstring_ok && summary_stream.GetSize() > 0)
{
stream.Printf("%s",summary_stream.GetData());
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
uint64_t offset = ptr_size;
ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetCompilerType(), true));
StreamString summary_stream;
- bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream, options);
+ bool was_nsstring_ok = NSStringSummaryProvider(*text, summary_stream, options);
if (was_nsstring_ok && summary_stream.GetSize() > 0)
{
stream.Printf("%s",summary_stream.GetData());
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
}
else
{
- if (ExtractValueFromObjCExpression(valobj, "NSTimeInterval", "ExtractValueFromObjCExpression", date_value_bits) == false)
+ if (!ExtractValueFromObjCExpression(valobj, "NSTimeInterval", "ExtractValueFromObjCExpression", date_value_bits))
return false;
date_value = *((double*)&date_value_bits);
}
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptorFromISA(valobj.GetValueAsUnsigned(0)));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
ConstString class_name = descriptor->GetClassName();
{
public:
ObjCClassSyntheticChildrenFrontEnd (lldb::ValueObjectSP valobj_sp) :
- SyntheticChildrenFrontEnd(*valobj_sp.get())
+ SyntheticChildrenFrontEnd(*valobj_sp)
{
}
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
bool is_64bit = (process_sp->GetAddressByteSize() == 8);
tm_epoch.tm_year = 2001-1900; // for some reason, we need to subtract 1900 from this field. not sure why.
tm_epoch.tm_isdst = -1;
tm_epoch.tm_gmtoff = 0;
- tm_epoch.tm_zone = NULL;
+ tm_epoch.tm_zone = nullptr;
epoch = timegm(&tm_epoch);
#endif
}
struct DataDescriptor_32
{
uint32_t _used;
- uint32_t _priv1 : 2 ;
+ uint32_t _priv1 : 2;
uint32_t _size : 30;
uint32_t _priv2 : 2;
uint32_t _offset : 30;
struct DataDescriptor_64
{
uint64_t _used;
- uint64_t _priv1 : 2 ;
+ uint64_t _priv1 : 2;
uint64_t _size : 62;
uint64_t _priv2 : 2;
uint64_t _offset : 62;
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
return false;
}
else
- return false;
+ return false;
std::string prefix,suffix;
if (Language* language = Language::FindPlugin(options.GetLanguage()))
}
lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::NSArrayMSyntheticFrontEnd_109 (lldb::ValueObjectSP valobj_sp) :
-NSArrayMSyntheticFrontEnd(valobj_sp),
-m_data_32(NULL),
-m_data_64(NULL)
+ NSArrayMSyntheticFrontEnd(valobj_sp),
+ m_data_32(nullptr),
+ m_data_64(nullptr)
{
}
lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::NSArrayMSyntheticFrontEnd_1010 (lldb::ValueObjectSP valobj_sp) :
-NSArrayMSyntheticFrontEnd(valobj_sp),
-m_data_32(NULL),
-m_data_64(NULL)
+ NSArrayMSyntheticFrontEnd(valobj_sp),
+ m_data_32(nullptr),
+ m_data_64(nullptr)
{
}
ValueObjectSP valobj_sp = m_backend.GetSP();
m_ptr_size = 0;
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
if (!valobj_sp)
return false;
m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
ValueObjectSP valobj_sp = m_backend.GetSP();
m_ptr_size = 0;
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
if (!valobj_sp)
return false;
m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::~NSArrayMSyntheticFrontEnd_109()
{
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
}
lldb::addr_t
lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::~NSArrayMSyntheticFrontEnd_1010()
{
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
}
lldb::addr_t
}
lldb_private::formatters::NSArrayISyntheticFrontEnd::NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd (*valobj_sp.get()),
-m_exe_ctx_ref (),
-m_ptr_size (8),
-m_items (0),
-m_data_ptr (0)
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_exe_ctx_ref(),
+ m_ptr_size(8),
+ m_items(0),
+ m_data_ptr(0)
{
if (valobj_sp)
{
}
lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd (*valobj_sp.get())
+ SyntheticChildrenFrontEnd(*valobj_sp)
{
}
lldb::ProcessSP process_sp (valobj_sp->GetProcessSP());
if (!process_sp)
- return NULL;
+ return nullptr;
AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(process_sp->GetObjCLanguageRuntime());
if (!runtime)
- return NULL;
+ return nullptr;
CompilerType valobj_type(valobj_sp->GetCompilerType());
Flags flags(valobj_type.GetTypeInfo());
Error error;
valobj_sp = valobj_sp->AddressOf(error);
if (error.Fail() || !valobj_sp)
- return NULL;
+ return nullptr;
}
- ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get()));
+ ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp));
- if (!descriptor.get() || !descriptor->IsValid())
- return NULL;
+ if (!descriptor || !descriptor->IsValid())
+ return nullptr;
const char* class_name = descriptor->GetClassName().GetCString();
if (!class_name || !*class_name)
- return NULL;
+ return nullptr;
if (!strcmp(class_name,"__NSArrayI"))
{
if (!compiler_type)
{
- compiler_type = target_ast_context->CreateRecordType(NULL, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC);
+ compiler_type = target_ast_context->CreateRecordType(nullptr, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC);
if (compiler_type)
{
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
{
lldb::ProcessSP process_sp (valobj_sp->GetProcessSP());
if (!process_sp)
- return NULL;
+ return nullptr;
ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
if (!runtime)
- return NULL;
+ return nullptr;
CompilerType valobj_type(valobj_sp->GetCompilerType());
Flags flags(valobj_type.GetTypeInfo());
Error error;
valobj_sp = valobj_sp->AddressOf(error);
if (error.Fail() || !valobj_sp)
- return NULL;
+ return nullptr;
}
- ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get()));
+ ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp));
- if (!descriptor.get() || !descriptor->IsValid())
- return NULL;
+ if (!descriptor || !descriptor->IsValid())
+ return nullptr;
ConstString class_name_cs = descriptor->GetClassName();
const char* class_name = class_name_cs.GetCString();
if (!class_name || !*class_name)
- return NULL;
+ return nullptr;
if (!strcmp(class_name,"__NSDictionaryI"))
{
}
lldb_private::formatters::NSDictionaryISyntheticFrontEnd::NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_exe_ctx_ref(),
-m_ptr_size(8),
-m_order(lldb::eByteOrderInvalid),
-m_data_32(NULL),
-m_data_64(NULL),
-m_pair_type()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_exe_ctx_ref(),
+ m_ptr_size(8),
+ m_order(lldb::eByteOrderInvalid),
+ m_data_32(nullptr),
+ m_data_64(nullptr),
+ m_pair_type()
{
}
lldb_private::formatters::NSDictionaryISyntheticFrontEnd::~NSDictionaryISyntheticFrontEnd ()
{
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
}
size_t
{
m_children.clear();
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
m_ptr_size = 0;
ValueObjectSP valobj_sp = m_backend.GetSP();
if (!valobj_sp)
}
lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_exe_ctx_ref(),
-m_ptr_size(8),
-m_order(lldb::eByteOrderInvalid),
-m_data_32(NULL),
-m_data_64(NULL),
-m_pair_type()
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_exe_ctx_ref(),
+ m_ptr_size(8),
+ m_order(lldb::eByteOrderInvalid),
+ m_data_32(nullptr),
+ m_data_64(nullptr),
+ m_pair_type()
{
}
lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd ()
{
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
}
size_t
ValueObjectSP valobj_sp = m_backend.GetSP();
m_ptr_size = 0;
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
if (!valobj_sp)
return false;
m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
- if (!descriptor.get() || !descriptor->IsValid())
+ if (!descriptor || !descriptor->IsValid())
return false;
uint32_t ptr_size = process_sp->GetAddressByteSize();
{
lldb::ProcessSP process_sp (valobj_sp->GetProcessSP());
if (!process_sp)
- return NULL;
+ return nullptr;
ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
if (!runtime)
- return NULL;
+ return nullptr;
CompilerType valobj_type(valobj_sp->GetCompilerType());
Flags flags(valobj_type.GetTypeInfo());
Error error;
valobj_sp = valobj_sp->AddressOf(error);
if (error.Fail() || !valobj_sp)
- return NULL;
+ return nullptr;
}
- ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get()));
+ ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp));
- if (!descriptor.get() || !descriptor->IsValid())
- return NULL;
+ if (!descriptor || !descriptor->IsValid())
+ return nullptr;
ConstString class_name_cs = descriptor->GetClassName();
const char* class_name = class_name_cs.GetCString();
if (!class_name || !*class_name)
- return NULL;
+ return nullptr;
if (!strcmp(class_name,"__NSSetI"))
{
}
lldb_private::formatters::NSSetISyntheticFrontEnd::NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_exe_ctx_ref(),
-m_ptr_size(8),
-m_data_32(NULL),
-m_data_64(NULL)
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_exe_ctx_ref(),
+ m_ptr_size(8),
+ m_data_32(nullptr),
+ m_data_64(nullptr)
{
if (valobj_sp)
Update();
lldb_private::formatters::NSSetISyntheticFrontEnd::~NSSetISyntheticFrontEnd ()
{
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
}
size_t
{
m_children.clear();
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
m_ptr_size = 0;
ValueObjectSP valobj_sp = m_backend.GetSP();
if (!valobj_sp)
}
lldb_private::formatters::NSSetMSyntheticFrontEnd::NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_exe_ctx_ref(),
-m_ptr_size(8),
-m_data_32(NULL),
-m_data_64(NULL)
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_exe_ctx_ref(),
+ m_ptr_size(8),
+ m_data_32(nullptr),
+ m_data_64(nullptr)
{
if (valobj_sp)
Update ();
lldb_private::formatters::NSSetMSyntheticFrontEnd::~NSSetMSyntheticFrontEnd ()
{
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
}
size_t
ValueObjectSP valobj_sp = m_backend.GetSP();
m_ptr_size = 0;
delete m_data_32;
- m_data_32 = NULL;
+ m_data_32 = nullptr;
delete m_data_64;
- m_data_64 = NULL;
+ m_data_64 = nullptr;
if (!valobj_sp)
return false;
if (!valobj_sp)
}
lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::NSOrderedSetSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-SyntheticChildrenFrontEnd(*valobj_sp.get()),
-m_count(UINT32_MAX),
-m_children()
-{}
+ SyntheticChildrenFrontEnd(*valobj_sp),
+ m_count(UINT32_MAX),
+ m_children()
+{
+}
size_t
lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::CalculateNumChildren ()
//------------------------------------------------------------------
// PluginInterface protocol
//------------------------------------------------------------------
+
lldb_private::ConstString
ObjCLanguage::GetPluginName()
{
//------------------------------------------------------------------
// Static Functions
//------------------------------------------------------------------
+
Language *
ObjCLanguage::CreateInstance (lldb::LanguageType language)
{
m_class_category.SetCStringWithLength (class_start, space_pos - class_start);
// If m_class hasn't been filled in and the class with category doesn't
// contain a '(', then we can also fill in the m_class
- if (!m_class && strchr (m_class_category.GetCString(), '(') == NULL)
+ if (!m_class && strchr(m_class_category.GetCString(), '(') == nullptr)
{
m_class = m_class_category;
// No '(' was found in the full name, we can definitively say
ConstString key_cs(key);
if (clang_modules_decl_vendor->FindDecls(key_cs, false, UINT32_MAX, decls) > 0 &&
- decls.size() > 0)
+ !decls.empty())
{
CompilerType module_type = ClangASTContext::GetTypeForDecl(decls.front());
result = true;
// C Includes
// C++ Includes
+#include <cstring>
#include <vector>
// Other libraries and framework includes
if (!name)
return false;
- if (strchr(name, ':') == NULL)
+ if (strchr(name, ':') == nullptr)
return true;
else if (name[strlen(name) - 1] == ':')
return true;