diff options
Diffstat (limited to 'source/API/SBType.cpp')
| -rw-r--r-- | source/API/SBType.cpp | 1219 |
1 files changed, 498 insertions, 721 deletions
diff --git a/source/API/SBType.cpp b/source/API/SBType.cpp index 4922b491a227..ca63a875292d 100644 --- a/source/API/SBType.cpp +++ b/source/API/SBType.cpp @@ -7,10 +7,10 @@ // //===----------------------------------------------------------------------===// -#include "lldb/API/SBDefines.h" #include "lldb/API/SBType.h" -#include "lldb/API/SBTypeEnumMember.h" +#include "lldb/API/SBDefines.h" #include "lldb/API/SBStream.h" +#include "lldb/API/SBTypeEnumMember.h" #include "lldb/Core/ConstString.h" #include "lldb/Core/Log.h" #include "lldb/Core/Mangled.h" @@ -24,869 +24,646 @@ using namespace lldb; using namespace lldb_private; -SBType::SBType() : - m_opaque_sp() -{ -} +SBType::SBType() : m_opaque_sp() {} -SBType::SBType (const CompilerType &type) : - m_opaque_sp(new TypeImpl(CompilerType(type.GetTypeSystem(), - type.GetOpaqueQualType()))) -{ -} +SBType::SBType(const CompilerType &type) + : m_opaque_sp(new TypeImpl( + CompilerType(type.GetTypeSystem(), type.GetOpaqueQualType()))) {} -SBType::SBType (const lldb::TypeSP &type_sp) : - m_opaque_sp(new TypeImpl(type_sp)) -{ -} +SBType::SBType(const lldb::TypeSP &type_sp) + : m_opaque_sp(new TypeImpl(type_sp)) {} -SBType::SBType (const lldb::TypeImplSP &type_impl_sp) : - m_opaque_sp(type_impl_sp) -{ -} - +SBType::SBType(const lldb::TypeImplSP &type_impl_sp) + : m_opaque_sp(type_impl_sp) {} -SBType::SBType (const SBType &rhs) : - m_opaque_sp() -{ - if (this != &rhs) - { - m_opaque_sp = rhs.m_opaque_sp; - } +SBType::SBType(const SBType &rhs) : m_opaque_sp() { + if (this != &rhs) { + m_opaque_sp = rhs.m_opaque_sp; + } } - -//SBType::SBType (TypeImpl* impl) : +// SBType::SBType (TypeImpl* impl) : // m_opaque_ap(impl) //{} // -bool -SBType::operator == (SBType &rhs) -{ - if (IsValid() == false) - return !rhs.IsValid(); - - if (rhs.IsValid() == false) - return false; - - return *m_opaque_sp.get() == *rhs.m_opaque_sp.get(); -} - -bool -SBType::operator != (SBType &rhs) -{ - if (IsValid() == false) - return rhs.IsValid(); - - if (rhs.IsValid() == false) - return true; - - return *m_opaque_sp.get() != *rhs.m_opaque_sp.get(); -} - -lldb::TypeImplSP -SBType::GetSP () -{ - return m_opaque_sp; -} - - -void -SBType::SetSP (const lldb::TypeImplSP &type_impl_sp) -{ - m_opaque_sp = type_impl_sp; -} - -SBType & -SBType::operator = (const SBType &rhs) -{ - if (this != &rhs) - { - m_opaque_sp = rhs.m_opaque_sp; - } - return *this; -} +bool SBType::operator==(SBType &rhs) { + if (IsValid() == false) + return !rhs.IsValid(); -SBType::~SBType () -{} + if (rhs.IsValid() == false) + return false; -TypeImpl & -SBType::ref () -{ - if (m_opaque_sp.get() == NULL) - m_opaque_sp.reset (new TypeImpl()); - return *m_opaque_sp; + return *m_opaque_sp.get() == *rhs.m_opaque_sp.get(); } -const TypeImpl & -SBType::ref () const -{ - // "const SBAddress &addr" should already have checked "addr.IsValid()" - // prior to calling this function. In case you didn't we will assert - // and die to let you know. - assert (m_opaque_sp.get()); - return *m_opaque_sp; +bool SBType::operator!=(SBType &rhs) { + if (IsValid() == false) + return rhs.IsValid(); + + if (rhs.IsValid() == false) + return true; + + return *m_opaque_sp.get() != *rhs.m_opaque_sp.get(); } -bool -SBType::IsValid() const -{ - if (m_opaque_sp.get() == NULL) - return false; - - return m_opaque_sp->IsValid(); -} - -uint64_t -SBType::GetByteSize() -{ - if (!IsValid()) - return 0; - - return m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr); - -} - -bool -SBType::IsPointerType() -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(true).IsPointerType(); -} - -bool -SBType::IsArrayType() -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr, nullptr); -} - -bool -SBType::IsVectorType() -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr); -} - -bool -SBType::IsReferenceType() -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(true).IsReferenceType(); -} - -SBType -SBType::GetPointerType() -{ - if (!IsValid()) - return SBType(); - - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType()))); -} - -SBType -SBType::GetPointeeType() -{ - if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType()))); -} - -SBType -SBType::GetReferenceType() -{ - if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType()))); -} - -SBType -SBType::GetTypedefedType() -{ - if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType()))); -} - -SBType -SBType::GetDereferencedType() -{ - if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType()))); -} - -SBType -SBType::GetArrayElementType() -{ - if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType()))); +lldb::TypeImplSP SBType::GetSP() { return m_opaque_sp; } + +void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) { + m_opaque_sp = type_impl_sp; } - -SBType -SBType::GetVectorElementType () -{ - SBType type_sb; - if (IsValid()) - { - CompilerType vector_element_type; - if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type, nullptr)) - type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type))); - } - return type_sb; + +SBType &SBType::operator=(const SBType &rhs) { + if (this != &rhs) { + m_opaque_sp = rhs.m_opaque_sp; + } + return *this; } -bool -SBType::IsFunctionType () -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(true).IsFunctionType(); +SBType::~SBType() {} + +TypeImpl &SBType::ref() { + if (m_opaque_sp.get() == NULL) + m_opaque_sp.reset(new TypeImpl()); + return *m_opaque_sp; } -bool -SBType::IsPolymorphicClass () -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass(); +const TypeImpl &SBType::ref() const { + // "const SBAddress &addr" should already have checked "addr.IsValid()" + // prior to calling this function. In case you didn't we will assert + // and die to let you know. + assert(m_opaque_sp.get()); + return *m_opaque_sp; } -bool -SBType::IsTypedefType () -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(true).IsTypedefType(); +bool SBType::IsValid() const { + if (m_opaque_sp.get() == NULL) + return false; + + return m_opaque_sp->IsValid(); } -bool -SBType::IsAnonymousType () -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(true).IsAnonymousType(); +uint64_t SBType::GetByteSize() { + if (!IsValid()) + return 0; + + return m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr); } -lldb::SBType -SBType::GetFunctionReturnType () -{ - if (IsValid()) - { - CompilerType return_type (m_opaque_sp->GetCompilerType(true).GetFunctionReturnType()); - if (return_type.IsValid()) - return SBType(return_type); - } - return lldb::SBType(); -} - -lldb::SBTypeList -SBType::GetFunctionArgumentTypes () -{ - SBTypeList sb_type_list; - if (IsValid()) - { - CompilerType func_type(m_opaque_sp->GetCompilerType(true)); - size_t count = func_type.GetNumberOfFunctionArguments(); - for (size_t i = 0; - i < count; - i++) - { - sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i))); - } - } - return sb_type_list; +bool SBType::IsPointerType() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsPointerType(); } -uint32_t -SBType::GetNumberOfMemberFunctions () -{ - if (IsValid()) - { - return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions(); - } - return 0; +bool SBType::IsArrayType() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr, + nullptr); } -lldb::SBTypeMemberFunction -SBType::GetMemberFunctionAtIndex (uint32_t idx) -{ - SBTypeMemberFunction sb_func_type; - if (IsValid()) - sb_func_type.reset(new TypeMemberFunctionImpl(m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx))); - return sb_func_type; +bool SBType::IsVectorType() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr); } -lldb::SBType -SBType::GetUnqualifiedType() -{ - if (!IsValid()) - return SBType(); - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))); +bool SBType::IsReferenceType() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsReferenceType(); } -lldb::SBType -SBType::GetCanonicalType() -{ - if (IsValid()) - return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))); +SBType SBType::GetPointerType() { + if (!IsValid()) return SBType(); + + return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType()))); } +SBType SBType::GetPointeeType() { + if (!IsValid()) + return SBType(); + return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType()))); +} -lldb::BasicType -SBType::GetBasicType() -{ - if (IsValid()) - return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration (); - return eBasicTypeInvalid; +SBType SBType::GetReferenceType() { + if (!IsValid()) + return SBType(); + return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType()))); } -SBType -SBType::GetBasicType(lldb::BasicType basic_type) -{ - if (IsValid() && m_opaque_sp->IsValid()) - return SBType(m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type)); +SBType SBType::GetTypedefedType() { + if (!IsValid()) return SBType(); + return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType()))); } -uint32_t -SBType::GetNumberOfDirectBaseClasses () -{ - if (IsValid()) - return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses(); - return 0; +SBType SBType::GetDereferencedType() { + if (!IsValid()) + return SBType(); + return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType()))); } -uint32_t -SBType::GetNumberOfVirtualBaseClasses () -{ - if (IsValid()) - return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses(); - return 0; +SBType SBType::GetArrayElementType() { + if (!IsValid()) + return SBType(); + return SBType(TypeImplSP( + new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType()))); } -uint32_t -SBType::GetNumberOfFields () -{ - if (IsValid()) - return m_opaque_sp->GetCompilerType(true).GetNumFields(); - return 0; +SBType SBType::GetArrayType(uint64_t size) { + if (!IsValid()) + return SBType(); + return SBType(TypeImplSP( + new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayType(size)))); } -bool -SBType::GetDescription (SBStream &description, lldb::DescriptionLevel description_level) -{ - Stream &strm = description.ref(); +SBType SBType::GetVectorElementType() { + SBType type_sb; + if (IsValid()) { + CompilerType vector_element_type; + if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type, + nullptr)) + type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type))); + } + return type_sb; +} - if (m_opaque_sp) - { - m_opaque_sp->GetDescription (strm, description_level); - } - else - strm.PutCString ("No value"); - - return true; +bool SBType::IsFunctionType() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsFunctionType(); } +bool SBType::IsPolymorphicClass() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass(); +} +bool SBType::IsTypedefType() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsTypedefType(); +} -SBTypeMember -SBType::GetDirectBaseClassAtIndex (uint32_t idx) -{ - SBTypeMember sb_type_member; - if (IsValid()) - { - uint32_t bit_offset = 0; - CompilerType base_class_type = m_opaque_sp->GetCompilerType (true).GetDirectBaseClassAtIndex(idx, &bit_offset); - if (base_class_type.IsValid()) - sb_type_member.reset (new TypeMemberImpl (TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); +bool SBType::IsAnonymousType() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(true).IsAnonymousType(); +} + +lldb::SBType SBType::GetFunctionReturnType() { + if (IsValid()) { + CompilerType return_type( + m_opaque_sp->GetCompilerType(true).GetFunctionReturnType()); + if (return_type.IsValid()) + return SBType(return_type); + } + return lldb::SBType(); +} + +lldb::SBTypeList SBType::GetFunctionArgumentTypes() { + SBTypeList sb_type_list; + if (IsValid()) { + CompilerType func_type(m_opaque_sp->GetCompilerType(true)); + size_t count = func_type.GetNumberOfFunctionArguments(); + for (size_t i = 0; i < count; i++) { + sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i))); } - return sb_type_member; - + } + return sb_type_list; } -SBTypeMember -SBType::GetVirtualBaseClassAtIndex (uint32_t idx) -{ - SBTypeMember sb_type_member; - if (IsValid()) - { - uint32_t bit_offset = 0; - CompilerType base_class_type = m_opaque_sp->GetCompilerType (true).GetVirtualBaseClassAtIndex(idx, &bit_offset); - if (base_class_type.IsValid()) - sb_type_member.reset (new TypeMemberImpl (TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); - } - return sb_type_member; -} - -SBTypeEnumMemberList -SBType::GetEnumMembers () -{ - SBTypeEnumMemberList sb_enum_member_list; - if (IsValid()) - { - CompilerType this_type (m_opaque_sp->GetCompilerType (true)); - if (this_type.IsValid()) - { - this_type.ForEachEnumerator([&sb_enum_member_list] (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value) -> bool { - SBTypeEnumMember enum_member (lldb::TypeEnumMemberImplSP (new TypeEnumMemberImpl(lldb::TypeImplSP(new TypeImpl(integer_type)), name, value))); - sb_enum_member_list.Append(enum_member); - return true; // Keep iterating - }); - } - } - return sb_enum_member_list; -} - -SBTypeMember -SBType::GetFieldAtIndex (uint32_t idx) -{ - SBTypeMember sb_type_member; - if (IsValid()) - { - CompilerType this_type (m_opaque_sp->GetCompilerType (false)); - if (this_type.IsValid()) - { - uint64_t bit_offset = 0; - uint32_t bitfield_bit_size = 0; - bool is_bitfield = false; - std::string name_sstr; - CompilerType field_type (this_type.GetFieldAtIndex (idx, - name_sstr, - &bit_offset, - &bitfield_bit_size, - &is_bitfield)); - if (field_type.IsValid()) - { - ConstString name; - if (!name_sstr.empty()) - name.SetCString(name_sstr.c_str()); - sb_type_member.reset (new TypeMemberImpl (TypeImplSP (new TypeImpl(field_type)), - bit_offset, - name, - bitfield_bit_size, - is_bitfield)); - } - } - } - return sb_type_member; +uint32_t SBType::GetNumberOfMemberFunctions() { + if (IsValid()) { + return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions(); + } + return 0; } -bool -SBType::IsTypeComplete() -{ - if (!IsValid()) - return false; - return m_opaque_sp->GetCompilerType(false).IsCompleteType(); +lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) { + SBTypeMemberFunction sb_func_type; + if (IsValid()) + sb_func_type.reset(new TypeMemberFunctionImpl( + m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx))); + return sb_func_type; } -uint32_t -SBType::GetTypeFlags () -{ - if (!IsValid()) - return 0; - return m_opaque_sp->GetCompilerType(true).GetTypeInfo(); +lldb::SBType SBType::GetUnqualifiedType() { + if (!IsValid()) + return SBType(); + return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType()))); +} + +lldb::SBType SBType::GetCanonicalType() { + if (IsValid()) + return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType()))); + return SBType(); +} + +lldb::BasicType SBType::GetBasicType() { + if (IsValid()) + return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration(); + return eBasicTypeInvalid; +} + +SBType SBType::GetBasicType(lldb::BasicType basic_type) { + if (IsValid() && m_opaque_sp->IsValid()) + return SBType( + m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type)); + return SBType(); +} + +uint32_t SBType::GetNumberOfDirectBaseClasses() { + if (IsValid()) + return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses(); + return 0; +} + +uint32_t SBType::GetNumberOfVirtualBaseClasses() { + if (IsValid()) + return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses(); + return 0; +} + +uint32_t SBType::GetNumberOfFields() { + if (IsValid()) + return m_opaque_sp->GetCompilerType(true).GetNumFields(); + return 0; +} + +bool SBType::GetDescription(SBStream &description, + lldb::DescriptionLevel description_level) { + Stream &strm = description.ref(); + + if (m_opaque_sp) { + m_opaque_sp->GetDescription(strm, description_level); + } else + strm.PutCString("No value"); + + return true; +} + +SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) { + SBTypeMember sb_type_member; + if (IsValid()) { + uint32_t bit_offset = 0; + CompilerType base_class_type = + m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex( + idx, &bit_offset); + if (base_class_type.IsValid()) + sb_type_member.reset(new TypeMemberImpl( + TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); + } + return sb_type_member; +} + +SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) { + SBTypeMember sb_type_member; + if (IsValid()) { + uint32_t bit_offset = 0; + CompilerType base_class_type = + m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex( + idx, &bit_offset); + if (base_class_type.IsValid()) + sb_type_member.reset(new TypeMemberImpl( + TypeImplSP(new TypeImpl(base_class_type)), bit_offset)); + } + return sb_type_member; +} + +SBTypeEnumMemberList SBType::GetEnumMembers() { + SBTypeEnumMemberList sb_enum_member_list; + if (IsValid()) { + CompilerType this_type(m_opaque_sp->GetCompilerType(true)); + if (this_type.IsValid()) { + this_type.ForEachEnumerator([&sb_enum_member_list]( + const CompilerType &integer_type, + const ConstString &name, + const llvm::APSInt &value) -> bool { + SBTypeEnumMember enum_member( + lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl( + lldb::TypeImplSP(new TypeImpl(integer_type)), name, value))); + sb_enum_member_list.Append(enum_member); + return true; // Keep iterating + }); + } + } + return sb_enum_member_list; +} + +SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) { + SBTypeMember sb_type_member; + if (IsValid()) { + CompilerType this_type(m_opaque_sp->GetCompilerType(false)); + if (this_type.IsValid()) { + uint64_t bit_offset = 0; + uint32_t bitfield_bit_size = 0; + bool is_bitfield = false; + std::string name_sstr; + CompilerType field_type(this_type.GetFieldAtIndex( + idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield)); + if (field_type.IsValid()) { + ConstString name; + if (!name_sstr.empty()) + name.SetCString(name_sstr.c_str()); + sb_type_member.reset( + new TypeMemberImpl(TypeImplSP(new TypeImpl(field_type)), bit_offset, + name, bitfield_bit_size, is_bitfield)); + } + } + } + return sb_type_member; } -const char* -SBType::GetName() -{ - if (!IsValid()) - return ""; - return m_opaque_sp->GetName().GetCString(); +bool SBType::IsTypeComplete() { + if (!IsValid()) + return false; + return m_opaque_sp->GetCompilerType(false).IsCompleteType(); } -const char * -SBType::GetDisplayTypeName () -{ - if (!IsValid()) - return ""; - return m_opaque_sp->GetDisplayTypeName().GetCString(); +uint32_t SBType::GetTypeFlags() { + if (!IsValid()) + return 0; + return m_opaque_sp->GetCompilerType(true).GetTypeInfo(); } -lldb::TypeClass -SBType::GetTypeClass () -{ - if (IsValid()) - return m_opaque_sp->GetCompilerType(true).GetTypeClass(); - return lldb::eTypeClassInvalid; +const char *SBType::GetName() { + if (!IsValid()) + return ""; + return m_opaque_sp->GetName().GetCString(); } -uint32_t -SBType::GetNumberOfTemplateArguments () -{ - if (IsValid()) - return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments(); - return 0; +const char *SBType::GetDisplayTypeName() { + if (!IsValid()) + return ""; + return m_opaque_sp->GetDisplayTypeName().GetCString(); } -lldb::SBType -SBType::GetTemplateArgumentType (uint32_t idx) -{ - if (IsValid()) - { - TemplateArgumentKind kind = eTemplateArgumentKindNull; - CompilerType template_arg_type = m_opaque_sp->GetCompilerType(false).GetTemplateArgument(idx, kind); - if (template_arg_type.IsValid()) - return SBType(template_arg_type); - } - return SBType(); +lldb::TypeClass SBType::GetTypeClass() { + if (IsValid()) + return m_opaque_sp->GetCompilerType(true).GetTypeClass(); + return lldb::eTypeClassInvalid; } +uint32_t SBType::GetNumberOfTemplateArguments() { + if (IsValid()) + return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments(); + return 0; +} -lldb::TemplateArgumentKind -SBType::GetTemplateArgumentKind (uint32_t idx) -{ +lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) { + if (IsValid()) { TemplateArgumentKind kind = eTemplateArgumentKindNull; - if (IsValid()) + CompilerType template_arg_type = m_opaque_sp->GetCompilerType(false).GetTemplateArgument(idx, kind); - return kind; + if (template_arg_type.IsValid()) + return SBType(template_arg_type); + } + return SBType(); } - -SBTypeList::SBTypeList() : - m_opaque_ap(new TypeListImpl()) -{ +lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { + TemplateArgumentKind kind = eTemplateArgumentKindNull; + if (IsValid()) + m_opaque_sp->GetCompilerType(false).GetTemplateArgument(idx, kind); + return kind; } -SBTypeList::SBTypeList(const SBTypeList& rhs) : - m_opaque_ap(new TypeListImpl()) -{ - for (uint32_t i = 0, rhs_size = const_cast<SBTypeList&>(rhs).GetSize(); i < rhs_size; i++) - Append(const_cast<SBTypeList&>(rhs).GetTypeAtIndex(i)); -} +SBTypeList::SBTypeList() : m_opaque_ap(new TypeListImpl()) {} -bool -SBTypeList::IsValid () -{ - return (m_opaque_ap.get() != NULL); +SBTypeList::SBTypeList(const SBTypeList &rhs) + : m_opaque_ap(new TypeListImpl()) { + for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); + i < rhs_size; i++) + Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); } -SBTypeList& -SBTypeList::operator = (const SBTypeList& rhs) -{ - if (this != &rhs) - { - m_opaque_ap.reset (new TypeListImpl()); - for (uint32_t i = 0, rhs_size = const_cast<SBTypeList&>(rhs).GetSize(); i < rhs_size; i++) - Append(const_cast<SBTypeList&>(rhs).GetTypeAtIndex(i)); - } - return *this; -} +bool SBTypeList::IsValid() { return (m_opaque_ap.get() != NULL); } -void -SBTypeList::Append (SBType type) -{ - if (type.IsValid()) - m_opaque_ap->Append (type.m_opaque_sp); +SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { + if (this != &rhs) { + m_opaque_ap.reset(new TypeListImpl()); + for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize(); + i < rhs_size; i++) + Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i)); + } + return *this; } -SBType -SBTypeList::GetTypeAtIndex(uint32_t index) -{ - if (m_opaque_ap.get()) - return SBType(m_opaque_ap->GetTypeAtIndex(index)); - return SBType(); +void SBTypeList::Append(SBType type) { + if (type.IsValid()) + m_opaque_ap->Append(type.m_opaque_sp); } -uint32_t -SBTypeList::GetSize() -{ - return m_opaque_ap->GetSize(); +SBType SBTypeList::GetTypeAtIndex(uint32_t index) { + if (m_opaque_ap.get()) + return SBType(m_opaque_ap->GetTypeAtIndex(index)); + return SBType(); } -SBTypeList::~SBTypeList() -{ -} +uint32_t SBTypeList::GetSize() { return m_opaque_ap->GetSize(); } -SBTypeMember::SBTypeMember() : - m_opaque_ap() -{ -} +SBTypeList::~SBTypeList() {} -SBTypeMember::~SBTypeMember() -{ -} +SBTypeMember::SBTypeMember() : m_opaque_ap() {} -SBTypeMember::SBTypeMember (const SBTypeMember& rhs) : - m_opaque_ap() -{ - if (this != &rhs) - { - if (rhs.IsValid()) - m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); - } -} +SBTypeMember::~SBTypeMember() {} -lldb::SBTypeMember& -SBTypeMember::operator = (const lldb::SBTypeMember& rhs) -{ - if (this != &rhs) - { - if (rhs.IsValid()) - m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); - } - return *this; +SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_ap() { + if (this != &rhs) { + if (rhs.IsValid()) + m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); + } } -bool -SBTypeMember::IsValid() const -{ - return m_opaque_ap.get(); +lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { + if (this != &rhs) { + if (rhs.IsValid()) + m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); + } + return *this; } -const char * -SBTypeMember::GetName () -{ - if (m_opaque_ap.get()) - return m_opaque_ap->GetName().GetCString(); - return NULL; -} +bool SBTypeMember::IsValid() const { return m_opaque_ap.get(); } -SBType -SBTypeMember::GetType () -{ - SBType sb_type; - if (m_opaque_ap.get()) - { - sb_type.SetSP (m_opaque_ap->GetTypeImpl()); - } - return sb_type; +const char *SBTypeMember::GetName() { + if (m_opaque_ap.get()) + return m_opaque_ap->GetName().GetCString(); + return NULL; +} +SBType SBTypeMember::GetType() { + SBType sb_type; + if (m_opaque_ap.get()) { + sb_type.SetSP(m_opaque_ap->GetTypeImpl()); + } + return sb_type; } -uint64_t -SBTypeMember::GetOffsetInBytes() -{ - if (m_opaque_ap.get()) - return m_opaque_ap->GetBitOffset() / 8u; - return 0; +uint64_t SBTypeMember::GetOffsetInBytes() { + if (m_opaque_ap.get()) + return m_opaque_ap->GetBitOffset() / 8u; + return 0; } -uint64_t -SBTypeMember::GetOffsetInBits() -{ - if (m_opaque_ap.get()) - return m_opaque_ap->GetBitOffset(); - return 0; +uint64_t SBTypeMember::GetOffsetInBits() { + if (m_opaque_ap.get()) + return m_opaque_ap->GetBitOffset(); + return 0; } -bool -SBTypeMember::IsBitfield() -{ - if (m_opaque_ap.get()) - return m_opaque_ap->GetIsBitfield(); - return false; +bool SBTypeMember::IsBitfield() { + if (m_opaque_ap.get()) + return m_opaque_ap->GetIsBitfield(); + return false; } -uint32_t -SBTypeMember::GetBitfieldSizeInBits() -{ - if (m_opaque_ap.get()) - return m_opaque_ap->GetBitfieldBitSize(); - return 0; +uint32_t SBTypeMember::GetBitfieldSizeInBits() { + if (m_opaque_ap.get()) + return m_opaque_ap->GetBitfieldBitSize(); + return 0; } +bool SBTypeMember::GetDescription(lldb::SBStream &description, + lldb::DescriptionLevel description_level) { + Stream &strm = description.ref(); -bool -SBTypeMember::GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level) -{ - Stream &strm = description.ref(); - - if (m_opaque_ap.get()) - { - const uint32_t bit_offset = m_opaque_ap->GetBitOffset(); - const uint32_t byte_offset = bit_offset / 8u; - const uint32_t byte_bit_offset = bit_offset % 8u; - const char *name = m_opaque_ap->GetName().GetCString(); - if (byte_bit_offset) - strm.Printf ("+%u + %u bits: (", byte_offset, byte_bit_offset); - else - strm.Printf ("+%u: (", byte_offset); - - TypeImplSP type_impl_sp (m_opaque_ap->GetTypeImpl()); - if (type_impl_sp) - type_impl_sp->GetDescription(strm, description_level); - - strm.Printf (") %s", name); - if (m_opaque_ap->GetIsBitfield()) - { - const uint32_t bitfield_bit_size = m_opaque_ap->GetBitfieldBitSize(); - strm.Printf (" : %u", bitfield_bit_size); - } - } + if (m_opaque_ap.get()) { + const uint32_t bit_offset = m_opaque_ap->GetBitOffset(); + const uint32_t byte_offset = bit_offset / 8u; + const uint32_t byte_bit_offset = bit_offset % 8u; + const char *name = m_opaque_ap->GetName().GetCString(); + if (byte_bit_offset) + strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset); else - { - strm.PutCString ("No value"); - } - return true; -} + strm.Printf("+%u: (", byte_offset); + TypeImplSP type_impl_sp(m_opaque_ap->GetTypeImpl()); + if (type_impl_sp) + type_impl_sp->GetDescription(strm, description_level); -void -SBTypeMember::reset(TypeMemberImpl *type_member_impl) -{ - m_opaque_ap.reset(type_member_impl); + strm.Printf(") %s", name); + if (m_opaque_ap->GetIsBitfield()) { + const uint32_t bitfield_bit_size = m_opaque_ap->GetBitfieldBitSize(); + strm.Printf(" : %u", bitfield_bit_size); + } + } else { + strm.PutCString("No value"); + } + return true; } -TypeMemberImpl & -SBTypeMember::ref () -{ - if (m_opaque_ap.get() == NULL) - m_opaque_ap.reset (new TypeMemberImpl()); - return *m_opaque_ap.get(); +void SBTypeMember::reset(TypeMemberImpl *type_member_impl) { + m_opaque_ap.reset(type_member_impl); } -const TypeMemberImpl & -SBTypeMember::ref () const -{ - return *m_opaque_ap.get(); +TypeMemberImpl &SBTypeMember::ref() { + if (m_opaque_ap.get() == NULL) + m_opaque_ap.reset(new TypeMemberImpl()); + return *m_opaque_ap.get(); } -SBTypeMemberFunction::SBTypeMemberFunction() : -m_opaque_sp() -{ -} +const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_ap.get(); } -SBTypeMemberFunction::~SBTypeMemberFunction() -{ -} +SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {} -SBTypeMemberFunction::SBTypeMemberFunction (const SBTypeMemberFunction& rhs) : - m_opaque_sp(rhs.m_opaque_sp) -{ -} +SBTypeMemberFunction::~SBTypeMemberFunction() {} -lldb::SBTypeMemberFunction& -SBTypeMemberFunction::operator = (const lldb::SBTypeMemberFunction& rhs) -{ - if (this != &rhs) - m_opaque_sp = rhs.m_opaque_sp; - return *this; -} +SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs) + : m_opaque_sp(rhs.m_opaque_sp) {} -bool -SBTypeMemberFunction::IsValid() const -{ - return m_opaque_sp.get(); +lldb::SBTypeMemberFunction &SBTypeMemberFunction:: +operator=(const lldb::SBTypeMemberFunction &rhs) { + if (this != &rhs) + m_opaque_sp = rhs.m_opaque_sp; + return *this; } -const char * -SBTypeMemberFunction::GetName () -{ - if (m_opaque_sp) - return m_opaque_sp->GetName().GetCString(); - return NULL; +bool SBTypeMemberFunction::IsValid() const { return m_opaque_sp.get(); } + +const char *SBTypeMemberFunction::GetName() { + if (m_opaque_sp) + return m_opaque_sp->GetName().GetCString(); + return NULL; } -const char * -SBTypeMemberFunction::GetDemangledName () -{ - if (m_opaque_sp) - { - ConstString mangled_str = m_opaque_sp->GetMangledName(); - if (mangled_str) - { - Mangled mangled(mangled_str, true); - return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString(); - } +const char *SBTypeMemberFunction::GetDemangledName() { + if (m_opaque_sp) { + ConstString mangled_str = m_opaque_sp->GetMangledName(); + if (mangled_str) { + Mangled mangled(mangled_str, true); + return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString(); } - return NULL; + } + return NULL; } -const char * -SBTypeMemberFunction::GetMangledName() -{ - if (m_opaque_sp) - return m_opaque_sp->GetMangledName().GetCString(); - return NULL; +const char *SBTypeMemberFunction::GetMangledName() { + if (m_opaque_sp) + return m_opaque_sp->GetMangledName().GetCString(); + return NULL; } +SBType SBTypeMemberFunction::GetType() { + SBType sb_type; + if (m_opaque_sp) { + sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType()))); + } + return sb_type; +} -SBType -SBTypeMemberFunction::GetType () -{ - SBType sb_type; - if (m_opaque_sp) - { - sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType()))); - } - return sb_type; +lldb::SBType SBTypeMemberFunction::GetReturnType() { + SBType sb_type; + if (m_opaque_sp) { + sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType()))); + } + return sb_type; } -lldb::SBType -SBTypeMemberFunction::GetReturnType () -{ - SBType sb_type; - if (m_opaque_sp) - { - sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType()))); - } - return sb_type; +uint32_t SBTypeMemberFunction::GetNumberOfArguments() { + if (m_opaque_sp) + return m_opaque_sp->GetNumArguments(); + return 0; } -uint32_t -SBTypeMemberFunction::GetNumberOfArguments () -{ - if (m_opaque_sp) - return m_opaque_sp->GetNumArguments(); - return 0; +lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) { + SBType sb_type; + if (m_opaque_sp) { + sb_type.SetSP( + lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i)))); + } + return sb_type; } -lldb::SBType -SBTypeMemberFunction::GetArgumentTypeAtIndex (uint32_t i) -{ - SBType sb_type; - if (m_opaque_sp) - { - sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i)))); - } - return sb_type; -} - -lldb::MemberFunctionKind -SBTypeMemberFunction::GetKind () -{ - if (m_opaque_sp) - return m_opaque_sp->GetKind(); - return lldb::eMemberFunctionKindUnknown; - -} - -bool -SBTypeMemberFunction::GetDescription (lldb::SBStream &description, - lldb::DescriptionLevel description_level) -{ - Stream &strm = description.ref(); - - if (m_opaque_sp) - return m_opaque_sp->GetDescription(strm); - - return false; +lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { + if (m_opaque_sp) + return m_opaque_sp->GetKind(); + return lldb::eMemberFunctionKindUnknown; +} + +bool SBTypeMemberFunction::GetDescription( + lldb::SBStream &description, lldb::DescriptionLevel description_level) { + Stream &strm = description.ref(); + + if (m_opaque_sp) + return m_opaque_sp->GetDescription(strm); + + return false; } -void -SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) -{ - m_opaque_sp.reset(type_member_impl); +void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) { + m_opaque_sp.reset(type_member_impl); } -TypeMemberFunctionImpl & -SBTypeMemberFunction::ref () -{ - if (!m_opaque_sp) - m_opaque_sp.reset (new TypeMemberFunctionImpl()); - return *m_opaque_sp.get(); +TypeMemberFunctionImpl &SBTypeMemberFunction::ref() { + if (!m_opaque_sp) + m_opaque_sp.reset(new TypeMemberFunctionImpl()); + return *m_opaque_sp.get(); } -const TypeMemberFunctionImpl & -SBTypeMemberFunction::ref () const -{ - return *m_opaque_sp.get(); +const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const { + return *m_opaque_sp.get(); } |