diff options
Diffstat (limited to 'lldb/source/API')
25 files changed, 636 insertions, 636 deletions
diff --git a/lldb/source/API/SBAddress.cpp b/lldb/source/API/SBAddress.cpp index 0cad2b7fddf..2765a7f1439 100644 --- a/lldb/source/API/SBAddress.cpp +++ b/lldb/source/API/SBAddress.cpp @@ -20,25 +20,25 @@ using namespace lldb; using namespace lldb_private; -SBAddress::SBAddress() : m_opaque_ap(new Address()) {} +SBAddress::SBAddress() : m_opaque_up(new Address()) {} SBAddress::SBAddress(const Address *lldb_object_ptr) - : m_opaque_ap(new Address()) { + : m_opaque_up(new Address()) { if (lldb_object_ptr) ref() = *lldb_object_ptr; } -SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_ap(new Address()) { +SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) { if (rhs.IsValid()) ref() = rhs.ref(); } SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset) - : m_opaque_ap(new Address(section.GetSP(), offset)) {} + : m_opaque_up(new Address(section.GetSP(), offset)) {} // Create an address by resolving a load address using the supplied target SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target) - : m_opaque_ap(new Address()) { + : m_opaque_up(new Address()) { SetLoadAddress(load_addr, target); } @@ -49,7 +49,7 @@ const SBAddress &SBAddress::operator=(const SBAddress &rhs) { if (rhs.IsValid()) ref() = rhs.ref(); else - m_opaque_ap.reset(new Address()); + m_opaque_up.reset(new Address()); } return *this; } @@ -61,10 +61,10 @@ bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) { } bool SBAddress::IsValid() const { - return m_opaque_ap != NULL && m_opaque_ap->IsValid(); + return m_opaque_up != NULL && m_opaque_up->IsValid(); } -void SBAddress::Clear() { m_opaque_ap.reset(new Address()); } +void SBAddress::Clear() { m_opaque_up.reset(new Address()); } void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) { Address &addr = ref(); @@ -76,12 +76,12 @@ void SBAddress::SetAddress(const Address *lldb_object_ptr) { if (lldb_object_ptr) ref() = *lldb_object_ptr; else - m_opaque_ap.reset(new Address()); + m_opaque_up.reset(new Address()); } lldb::addr_t SBAddress::GetFileAddress() const { - if (m_opaque_ap->IsValid()) - return m_opaque_ap->GetFileAddress(); + if (m_opaque_up->IsValid()) + return m_opaque_up->GetFileAddress(); else return LLDB_INVALID_ADDRESS; } @@ -92,9 +92,9 @@ lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const { lldb::addr_t addr = LLDB_INVALID_ADDRESS; TargetSP target_sp(target.GetSP()); if (target_sp) { - if (m_opaque_ap->IsValid()) { + if (m_opaque_up->IsValid()) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); - addr = m_opaque_ap->GetLoadAddress(target_sp.get()); + addr = m_opaque_up->GetLoadAddress(target_sp.get()); } } @@ -117,20 +117,20 @@ void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) { if (target.IsValid()) *this = target.ResolveLoadAddress(load_addr); else - m_opaque_ap->Clear(); + m_opaque_up->Clear(); // Check if we weren't were able to resolve a section offset address. If we // weren't it is ok, the load address might be a location on the stack or // heap, so we should just have an address with no section and a valid offset - if (!m_opaque_ap->IsValid()) - m_opaque_ap->SetOffset(load_addr); + if (!m_opaque_up->IsValid()) + m_opaque_up->SetOffset(load_addr); } bool SBAddress::OffsetAddress(addr_t offset) { - if (m_opaque_ap->IsValid()) { - addr_t addr_offset = m_opaque_ap->GetOffset(); + if (m_opaque_up->IsValid()) { + addr_t addr_offset = m_opaque_up->GetOffset(); if (addr_offset != LLDB_INVALID_ADDRESS) { - m_opaque_ap->SetOffset(addr_offset + offset); + m_opaque_up->SetOffset(addr_offset + offset); return true; } } @@ -139,45 +139,45 @@ bool SBAddress::OffsetAddress(addr_t offset) { lldb::SBSection SBAddress::GetSection() { lldb::SBSection sb_section; - if (m_opaque_ap->IsValid()) - sb_section.SetSP(m_opaque_ap->GetSection()); + if (m_opaque_up->IsValid()) + sb_section.SetSP(m_opaque_up->GetSection()); return sb_section; } lldb::addr_t SBAddress::GetOffset() { - if (m_opaque_ap->IsValid()) - return m_opaque_ap->GetOffset(); + if (m_opaque_up->IsValid()) + return m_opaque_up->GetOffset(); return 0; } -Address *SBAddress::operator->() { return m_opaque_ap.get(); } +Address *SBAddress::operator->() { return m_opaque_up.get(); } -const Address *SBAddress::operator->() const { return m_opaque_ap.get(); } +const Address *SBAddress::operator->() const { return m_opaque_up.get(); } Address &SBAddress::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new Address()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new Address()); + return *m_opaque_up; } const Address &SBAddress::ref() const { // This object should already have checked with "IsValid()" prior to calling // this function. In case you didn't we will assert and die to let you know. - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } -Address *SBAddress::get() { return m_opaque_ap.get(); } +Address *SBAddress::get() { return m_opaque_up.get(); } bool SBAddress::GetDescription(SBStream &description) { // Call "ref()" on the stream to make sure it creates a backing stream in // case there isn't one already... Stream &strm = description.ref(); - if (m_opaque_ap->IsValid()) { - m_opaque_ap->Dump(&strm, NULL, Address::DumpStyleResolvedDescription, + if (m_opaque_up->IsValid()) { + m_opaque_up->Dump(&strm, NULL, Address::DumpStyleResolvedDescription, Address::DumpStyleModuleWithFileAddress, 4); StreamString sstrm; - // m_opaque_ap->Dump (&sstrm, NULL, + // m_opaque_up->Dump (&sstrm, NULL, // Address::DumpStyleResolvedDescription, Address::DumpStyleInvalid, // 4); // if (sstrm.GetData()) @@ -190,52 +190,52 @@ bool SBAddress::GetDescription(SBStream &description) { SBModule SBAddress::GetModule() { SBModule sb_module; - if (m_opaque_ap->IsValid()) - sb_module.SetSP(m_opaque_ap->GetModule()); + if (m_opaque_up->IsValid()) + sb_module.SetSP(m_opaque_up->GetModule()); return sb_module; } SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) { SBSymbolContext sb_sc; SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); - if (m_opaque_ap->IsValid()) - m_opaque_ap->CalculateSymbolContext(&sb_sc.ref(), scope); + if (m_opaque_up->IsValid()) + m_opaque_up->CalculateSymbolContext(&sb_sc.ref(), scope); return sb_sc; } SBCompileUnit SBAddress::GetCompileUnit() { SBCompileUnit sb_comp_unit; - if (m_opaque_ap->IsValid()) - sb_comp_unit.reset(m_opaque_ap->CalculateSymbolContextCompileUnit()); + if (m_opaque_up->IsValid()) + sb_comp_unit.reset(m_opaque_up->CalculateSymbolContextCompileUnit()); return sb_comp_unit; } SBFunction SBAddress::GetFunction() { SBFunction sb_function; - if (m_opaque_ap->IsValid()) - sb_function.reset(m_opaque_ap->CalculateSymbolContextFunction()); + if (m_opaque_up->IsValid()) + sb_function.reset(m_opaque_up->CalculateSymbolContextFunction()); return sb_function; } SBBlock SBAddress::GetBlock() { SBBlock sb_block; - if (m_opaque_ap->IsValid()) - sb_block.SetPtr(m_opaque_ap->CalculateSymbolContextBlock()); + if (m_opaque_up->IsValid()) + sb_block.SetPtr(m_opaque_up->CalculateSymbolContextBlock()); return sb_block; } SBSymbol SBAddress::GetSymbol() { SBSymbol sb_symbol; - if (m_opaque_ap->IsValid()) - sb_symbol.reset(m_opaque_ap->CalculateSymbolContextSymbol()); + if (m_opaque_up->IsValid()) + sb_symbol.reset(m_opaque_up->CalculateSymbolContextSymbol()); return sb_symbol; } SBLineEntry SBAddress::GetLineEntry() { SBLineEntry sb_line_entry; - if (m_opaque_ap->IsValid()) { + if (m_opaque_up->IsValid()) { LineEntry line_entry; - if (m_opaque_ap->CalculateSymbolContextLineEntry(line_entry)) + if (m_opaque_up->CalculateSymbolContextLineEntry(line_entry)) sb_line_entry.SetLineEntry(line_entry); } return sb_line_entry; diff --git a/lldb/source/API/SBCommandReturnObject.cpp b/lldb/source/API/SBCommandReturnObject.cpp index 6d7fae12e0e..4c28dc3d0ae 100644 --- a/lldb/source/API/SBCommandReturnObject.cpp +++ b/lldb/source/API/SBCommandReturnObject.cpp @@ -19,53 +19,53 @@ using namespace lldb; using namespace lldb_private; SBCommandReturnObject::SBCommandReturnObject() - : m_opaque_ap(new CommandReturnObject()) {} + : m_opaque_up(new CommandReturnObject()) {} SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs) - : m_opaque_ap() { - if (rhs.m_opaque_ap) - m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap)); + : m_opaque_up() { + if (rhs.m_opaque_up) + m_opaque_up.reset(new CommandReturnObject(*rhs.m_opaque_up)); } SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr) - : m_opaque_ap(ptr) {} + : m_opaque_up(ptr) {} SBCommandReturnObject::~SBCommandReturnObject() = default; CommandReturnObject *SBCommandReturnObject::Release() { - return m_opaque_ap.release(); + return m_opaque_up.release(); } const SBCommandReturnObject &SBCommandReturnObject:: operator=(const SBCommandReturnObject &rhs) { if (this != &rhs) { - if (rhs.m_opaque_ap) - m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap)); + if (rhs.m_opaque_up) + m_opaque_up.reset(new CommandReturnObject(*rhs.m_opaque_up)); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } -bool SBCommandReturnObject::IsValid() const { return m_opaque_ap != nullptr; } +bool SBCommandReturnObject::IsValid() const { return m_opaque_up != nullptr; } const char *SBCommandReturnObject::GetOutput() { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (m_opaque_ap) { - llvm::StringRef output = m_opaque_ap->GetOutputData(); + if (m_opaque_up) { + llvm::StringRef output = m_opaque_up->GetOutputData(); ConstString result(output.empty() ? llvm::StringRef("") : output); if (log) log->Printf("SBCommandReturnObject(%p)::GetOutput () => \"%s\"", - static_cast<void *>(m_opaque_ap.get()), result.AsCString()); + static_cast<void *>(m_opaque_up.get()), result.AsCString()); return result.AsCString(); } if (log) log->Printf("SBCommandReturnObject(%p)::GetOutput () => nullptr", - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); return nullptr; } @@ -73,29 +73,29 @@ const char *SBCommandReturnObject::GetOutput() { const char *SBCommandReturnObject::GetError() { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (m_opaque_ap) { - llvm::StringRef output = m_opaque_ap->GetErrorData(); + if (m_opaque_up) { + llvm::StringRef output = m_opaque_up->GetErrorData(); ConstString result(output.empty() ? llvm::StringRef("") : output); if (log) log->Printf("SBCommandReturnObject(%p)::GetError () => \"%s\"", - static_cast<void *>(m_opaque_ap.get()), result.AsCString()); + static_cast<void *>(m_opaque_up.get()), result.AsCString()); return result.AsCString(); } if (log) log->Printf("SBCommandReturnObject(%p)::GetError () => nullptr", - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); return nullptr; } size_t SBCommandReturnObject::GetOutputSize() { - return (m_opaque_ap ? m_opaque_ap->GetOutputData().size() : 0); + return (m_opaque_up ? m_opaque_up->GetOutputData().size() : 0); } size_t SBCommandReturnObject::GetErrorSize() { - return (m_opaque_ap ? m_opaque_ap->GetErrorData().size() : 0); + return (m_opaque_up ? m_opaque_up->GetErrorData().size() : 0); } size_t SBCommandReturnObject::PutOutput(FILE *fh) { @@ -117,71 +117,71 @@ size_t SBCommandReturnObject::PutError(FILE *fh) { } void SBCommandReturnObject::Clear() { - if (m_opaque_ap) - m_opaque_ap->Clear(); + if (m_opaque_up) + m_opaque_up->Clear(); } lldb::ReturnStatus SBCommandReturnObject::GetStatus() { - return (m_opaque_ap ? m_opaque_ap->GetStatus() : lldb::eReturnStatusInvalid); + return (m_opaque_up ? m_opaque_up->GetStatus() : lldb::eReturnStatusInvalid); } void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) { - if (m_opaque_ap) - m_opaque_ap->SetStatus(status); + if (m_opaque_up) + m_opaque_up->SetStatus(status); } bool SBCommandReturnObject::Succeeded() { - return (m_opaque_ap ? m_opaque_ap->Succeeded() : false); + return (m_opaque_up ? m_opaque_up->Succeeded() : false); } bool SBCommandReturnObject::HasResult() { - return (m_opaque_ap ? m_opaque_ap->HasResult() : false); + return (m_opaque_up ? m_opaque_up->HasResult() : false); } void SBCommandReturnObject::AppendMessage(const char *message) { - if (m_opaque_ap) - m_opaque_ap->AppendMessage(message); + if (m_opaque_up) + m_opaque_up->AppendMessage(message); } void SBCommandReturnObject::AppendWarning(const char *message) { - if (m_opaque_ap) - m_opaque_ap->AppendWarning(message); + if (m_opaque_up) + m_opaque_up->AppendWarning(message); } CommandReturnObject *SBCommandReturnObject::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } CommandReturnObject *SBCommandReturnObject::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } CommandReturnObject &SBCommandReturnObject::operator*() const { - assert(m_opaque_ap.get()); - return *(m_opaque_ap.get()); + assert(m_opaque_up.get()); + return *(m_opaque_up.get()); } CommandReturnObject &SBCommandReturnObject::ref() const { - assert(m_opaque_ap.get()); - return *(m_opaque_ap.get()); + assert(m_opaque_up.get()); + return *(m_opaque_up.get()); } void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) { - if (m_opaque_ap) - m_opaque_ap.reset(ptr); + if (m_opaque_up) + m_opaque_up.reset(ptr); } bool SBCommandReturnObject::GetDescription(SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) { + if (m_opaque_up) { description.Printf("Error: "); - lldb::ReturnStatus status = m_opaque_ap->GetStatus(); + lldb::ReturnStatus status = m_opaque_up->GetStatus(); if (status == lldb::eReturnStatusStarted) strm.PutCString("Started"); else if (status == lldb::eReturnStatusInvalid) strm.PutCString("Invalid"); - else if (m_opaque_ap->Succeeded()) + else if (m_opaque_up->Succeeded()) strm.PutCString("Success"); else strm.PutCString("Fail"); @@ -207,51 +207,51 @@ void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) { void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh, bool transfer_ownership) { - if (m_opaque_ap) - m_opaque_ap->SetImmediateOutputFile(fh, transfer_ownership); + if (m_opaque_up) + m_opaque_up->SetImmediateOutputFile(fh, transfer_ownership); } void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh, bool transfer_ownership) { - if (m_opaque_ap) - m_opaque_ap->SetImmediateErrorFile(fh, transfer_ownership); + if (m_opaque_up) + m_opaque_up->SetImmediateErrorFile(fh, transfer_ownership); } void SBCommandReturnObject::PutCString(const char *string, int len) { - if (m_opaque_ap) { + if (m_opaque_up) { if (len == 0 || string == nullptr || *string == 0) { return; } else if (len > 0) { std::string buffer(string, len); - m_opaque_ap->AppendMessage(buffer.c_str()); + m_opaque_up->AppendMessage(buffer.c_str()); } else - m_opaque_ap->AppendMessage(string); + m_opaque_up->AppendMessage(string); } } const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) { - if (!m_opaque_ap) + if (!m_opaque_up) return nullptr; if (!only_if_no_immediate || - m_opaque_ap->GetImmediateOutputStream().get() == nullptr) + m_opaque_up->GetImmediateOutputStream().get() == nullptr) return GetOutput(); return nullptr; } const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) { - if (!m_opaque_ap) + if (!m_opaque_up) return nullptr; if (!only_if_no_immediate || - m_opaque_ap->GetImmediateErrorStream().get() == nullptr) + m_opaque_up->GetImmediateErrorStream().get() == nullptr) return GetError(); return nullptr; } size_t SBCommandReturnObject::Printf(const char *format, ...) { - if (m_opaque_ap) { + if (m_opaque_up) { va_list args; va_start(args, format); - size_t result = m_opaque_ap->GetOutputStream().PrintfVarArg(format, args); + size_t result = m_opaque_up->GetOutputStream().PrintfVarArg(format, args); va_end(args); return result; } @@ -260,15 +260,15 @@ size_t SBCommandReturnObject::Printf(const char *format, ...) { void SBCommandReturnObject::SetError(lldb::SBError &error, const char *fallback_error_cstr) { - if (m_opaque_ap) { + if (m_opaque_up) { if (error.IsValid()) - m_opaque_ap->SetError(error.ref(), fallback_error_cstr); + m_opaque_up->SetError(error.ref(), fallback_error_cstr); else if (fallback_error_cstr) - m_opaque_ap->SetError(Status(), fallback_error_cstr); + m_opaque_up->SetError(Status(), fallback_error_cstr); } } void SBCommandReturnObject::SetError(const char *error_cstr) { - if (m_opaque_ap && error_cstr) - m_opaque_ap->SetError(error_cstr); + if (m_opaque_up && error_cstr) + m_opaque_up->SetError(error_cstr); } diff --git a/lldb/source/API/SBCompileUnit.cpp b/lldb/source/API/SBCompileUnit.cpp index 17623af09c4..ef7d4c1d39f 100644 --- a/lldb/source/API/SBCompileUnit.cpp +++ b/lldb/source/API/SBCompileUnit.cpp @@ -148,7 +148,7 @@ lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) { TypeClass type_class = static_cast<TypeClass>(type_mask); TypeList type_list; vendor->GetTypes(m_opaque_ptr, type_class, type_list); - sb_type_list.m_opaque_ap->Append(type_list); + sb_type_list.m_opaque_up->Append(type_list); return sb_type_list; } diff --git a/lldb/source/API/SBDeclaration.cpp b/lldb/source/API/SBDeclaration.cpp index a943c2cd8bb..db1ec5e55f6 100644 --- a/lldb/source/API/SBDeclaration.cpp +++ b/lldb/source/API/SBDeclaration.cpp @@ -18,15 +18,15 @@ using namespace lldb; using namespace lldb_private; -SBDeclaration::SBDeclaration() : m_opaque_ap() {} +SBDeclaration::SBDeclaration() : m_opaque_up() {} -SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_ap() { +SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_up() { if (rhs.IsValid()) ref() = rhs.ref(); } SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr) - : m_opaque_ap() { + : m_opaque_up() { if (lldb_object_ptr) ref() = *lldb_object_ptr; } @@ -36,7 +36,7 @@ const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) { if (rhs.IsValid()) ref() = rhs.ref(); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } @@ -49,21 +49,21 @@ void SBDeclaration::SetDeclaration( SBDeclaration::~SBDeclaration() {} bool SBDeclaration::IsValid() const { - return m_opaque_ap.get() && m_opaque_ap->IsValid(); + return m_opaque_up.get() && m_opaque_up->IsValid(); } SBFileSpec SBDeclaration::GetFileSpec() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec sb_file_spec; - if (m_opaque_ap.get() && m_opaque_ap->GetFile()) - sb_file_spec.SetFileSpec(m_opaque_ap->GetFile()); + if (m_opaque_up.get() && m_opaque_up->GetFile()) + sb_file_spec.SetFileSpec(m_opaque_up->GetFile()); if (log) { SBStream sstr; sb_file_spec.GetDescription(sstr); log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<const void *>(sb_file_spec.get()), sstr.GetData()); } @@ -74,19 +74,19 @@ uint32_t SBDeclaration::GetLine() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t line = 0; - if (m_opaque_ap) - line = m_opaque_ap->GetLine(); + if (m_opaque_up) + line = m_opaque_up->GetLine(); if (log) log->Printf("SBLineEntry(%p)::GetLine () => %u", - static_cast<void *>(m_opaque_ap.get()), line); + static_cast<void *>(m_opaque_up.get()), line); return line; } uint32_t SBDeclaration::GetColumn() const { - if (m_opaque_ap) - return m_opaque_ap->GetColumn(); + if (m_opaque_up) + return m_opaque_up->GetColumn(); return 0; } @@ -101,8 +101,8 @@ void SBDeclaration::SetLine(uint32_t line) { ref().SetLine(line); } void SBDeclaration::SetColumn(uint32_t column) { ref().SetColumn(column); } bool SBDeclaration::operator==(const SBDeclaration &rhs) const { - lldb_private::Declaration *lhs_ptr = m_opaque_ap.get(); - lldb_private::Declaration *rhs_ptr = rhs.m_opaque_ap.get(); + lldb_private::Declaration *lhs_ptr = m_opaque_up.get(); + lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get(); if (lhs_ptr && rhs_ptr) return lldb_private::Declaration::Compare(*lhs_ptr, *rhs_ptr) == 0; @@ -111,8 +111,8 @@ bool SBDeclaration::operator==(const SBDeclaration &rhs) const { } bool SBDeclaration::operator!=(const SBDeclaration &rhs) const { - lldb_private::Declaration *lhs_ptr = m_opaque_ap.get(); - lldb_private::Declaration *rhs_ptr = rhs.m_opaque_ap.get(); + lldb_private::Declaration *lhs_ptr = m_opaque_up.get(); + lldb_private::Declaration *rhs_ptr = rhs.m_opaque_up.get(); if (lhs_ptr && rhs_ptr) return lldb_private::Declaration::Compare(*lhs_ptr, *rhs_ptr) != 0; @@ -121,25 +121,25 @@ bool SBDeclaration::operator!=(const SBDeclaration &rhs) const { } const lldb_private::Declaration *SBDeclaration::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::Declaration &SBDeclaration::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new lldb_private::Declaration()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new lldb_private::Declaration()); + return *m_opaque_up; } const lldb_private::Declaration &SBDeclaration::ref() const { - return *m_opaque_ap; + return *m_opaque_up; } bool SBDeclaration::GetDescription(SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) { + if (m_opaque_up) { char file_path[PATH_MAX * 2]; - m_opaque_ap->GetFile().GetPath(file_path, sizeof(file_path)); + m_opaque_up->GetFile().GetPath(file_path, sizeof(file_path)); strm.Printf("%s:%u", file_path, GetLine()); if (GetColumn() > 0) strm.Printf(":%u", GetColumn()); @@ -149,4 +149,4 @@ bool SBDeclaration::GetDescription(SBStream &description) { return true; } -lldb_private::Declaration *SBDeclaration::get() { return m_opaque_ap.get(); } +lldb_private::Declaration *SBDeclaration::get() { return m_opaque_up.get(); } diff --git a/lldb/source/API/SBError.cpp b/lldb/source/API/SBError.cpp index 5220ac4d30b..2eca5463935 100644 --- a/lldb/source/API/SBError.cpp +++ b/lldb/source/API/SBError.cpp @@ -16,48 +16,48 @@ using namespace lldb; using namespace lldb_private; -SBError::SBError() : m_opaque_ap() {} +SBError::SBError() : m_opaque_up() {} -SBError::SBError(const SBError &rhs) : m_opaque_ap() { +SBError::SBError(const SBError &rhs) : m_opaque_up() { if (rhs.IsValid()) - m_opaque_ap.reset(new Status(*rhs)); + m_opaque_up.reset(new Status(*rhs)); } SBError::~SBError() {} const SBError &SBError::operator=(const SBError &rhs) { if (rhs.IsValid()) { - if (m_opaque_ap) - *m_opaque_ap = *rhs; + if (m_opaque_up) + *m_opaque_up = *rhs; else - m_opaque_ap.reset(new Status(*rhs)); + m_opaque_up.reset(new Status(*rhs)); } else - m_opaque_ap.reset(); + m_opaque_up.reset(); return *this; } const char *SBError::GetCString() const { - if (m_opaque_ap) - return m_opaque_ap->AsCString(); + if (m_opaque_up) + return m_opaque_up->AsCString(); return NULL; } void SBError::Clear() { - if (m_opaque_ap) - m_opaque_ap->Clear(); + if (m_opaque_up) + m_opaque_up->Clear(); } bool SBError::Fail() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_value = false; - if (m_opaque_ap) - ret_value = m_opaque_ap->Fail(); + if (m_opaque_up) + ret_value = m_opaque_up->Fail(); if (log) log->Printf("SBError(%p)::Fail () => %i", - static_cast<void *>(m_opaque_ap.get()), ret_value); + static_cast<void *>(m_opaque_up.get()), ret_value); return ret_value; } @@ -65,12 +65,12 @@ bool SBError::Fail() const { bool SBError::Success() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); bool ret_value = true; - if (m_opaque_ap) - ret_value = m_opaque_ap->Success(); + if (m_opaque_up) + ret_value = m_opaque_up->Success(); if (log) log->Printf("SBError(%p)::Success () => %i", - static_cast<void *>(m_opaque_ap.get()), ret_value); + static_cast<void *>(m_opaque_up.get()), ret_value); return ret_value; } @@ -79,12 +79,12 @@ uint32_t SBError::GetError() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t err = 0; - if (m_opaque_ap) - err = m_opaque_ap->GetError(); + if (m_opaque_up) + err = m_opaque_up->GetError(); if (log) log->Printf("SBError(%p)::GetError () => 0x%8.8x", - static_cast<void *>(m_opaque_ap.get()), err); + static_cast<void *>(m_opaque_up.get()), err); return err; } @@ -92,74 +92,74 @@ uint32_t SBError::GetError() const { ErrorType SBError::GetType() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); ErrorType err_type = eErrorTypeInvalid; - if (m_opaque_ap) - err_type = m_opaque_ap->GetType(); + if (m_opaque_up) + err_type = m_opaque_up->GetType(); if (log) log->Printf("SBError(%p)::GetType () => %i", - static_cast<void *>(m_opaque_ap.get()), err_type); + static_cast<void *>(m_opaque_up.get()), err_type); return err_type; } void SBError::SetError(uint32_t err, ErrorType type) { CreateIfNeeded(); - m_opaque_ap->SetError(err, type); + m_opaque_up->SetError(err, type); } void SBError::SetError(const Status &lldb_error) { CreateIfNeeded(); - *m_opaque_ap = lldb_error; + *m_opaque_up = lldb_error; } void SBError::SetErrorToErrno() { CreateIfNeeded(); - m_opaque_ap->SetErrorToErrno(); + m_opaque_up->SetErrorToErrno(); } void SBError::SetErrorToGenericError() { CreateIfNeeded(); - m_opaque_ap->SetErrorToErrno(); + m_opaque_up->SetErrorToErrno(); } void SBError::SetErrorString(const char *err_str) { CreateIfNeeded(); - m_opaque_ap->SetErrorString(err_str); + m_opaque_up->SetErrorString(err_str); } int SBError::SetErrorStringWithFormat(const char *format, ...) { CreateIfNeeded(); va_list args; va_start(args, format); - int num_chars = m_opaque_ap->SetErrorStringWithVarArg(format, args); + int num_chars = m_opaque_up->SetErrorStringWithVarArg(format, args); va_end(args); return num_chars; } -bool SBError::IsValid() const { return m_opaque_ap != NULL; } +bool SBError::IsValid() const { return m_opaque_up != NULL; } void SBError::CreateIfNeeded() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new Status()); + if (m_opaque_up == NULL) + m_opaque_up.reset(new Status()); } -lldb_private::Status *SBError::operator->() { return m_opaque_ap.get(); } +lldb_private::Status *SBError::operator->() { return m_opaque_up.get(); } -lldb_private::Status *SBError::get() { return m_opaque_ap.get(); } +lldb_private::Status *SBError::get() { return m_opaque_up.get(); } lldb_private::Status &SBError::ref() { CreateIfNeeded(); - return *m_opaque_ap; + return *m_opaque_up; } const lldb_private::Status &SBError::operator*() const { // Be sure to call "IsValid()" before calling this function or it will crash - return *m_opaque_ap; + return *m_opaque_up; } bool SBError::GetDescription(SBStream &description) { - if (m_opaque_ap) { - if (m_opaque_ap->Success()) + if (m_opaque_up) { + if (m_opaque_up->Success()) description.Printf("success"); else { const char *err_string = GetCString(); diff --git a/lldb/source/API/SBExpressionOptions.cpp b/lldb/source/API/SBExpressionOptions.cpp index eabf23bb49f..1b83713af5a 100644 --- a/lldb/source/API/SBExpressionOptions.cpp +++ b/lldb/source/API/SBExpressionOptions.cpp @@ -16,11 +16,11 @@ using namespace lldb; using namespace lldb_private; SBExpressionOptions::SBExpressionOptions() - : m_opaque_ap(new EvaluateExpressionOptions()) {} + : m_opaque_up(new EvaluateExpressionOptions()) {} SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) { - m_opaque_ap.reset(new EvaluateExpressionOptions()); - *(m_opaque_ap.get()) = rhs.ref(); + m_opaque_up.reset(new EvaluateExpressionOptions()); + *(m_opaque_up.get()) = rhs.ref(); } const SBExpressionOptions &SBExpressionOptions:: @@ -34,143 +34,145 @@ operator=(const SBExpressionOptions &rhs) { SBExpressionOptions::~SBExpressionOptions() {} bool SBExpressionOptions::GetCoerceResultToId() const { - return m_opaque_ap->DoesCoerceToId(); + return m_opaque_up->DoesCoerceToId(); } void SBExpressionOptions::SetCoerceResultToId(bool coerce) { - m_opaque_ap->SetCoerceToId(coerce); + m_opaque_up->SetCoerceToId(coerce); } bool SBExpressionOptions::GetUnwindOnError() const { - return m_opaque_ap->DoesUnwindOnError(); + return m_opaque_up->DoesUnwindOnError(); } void SBExpressionOptions::SetUnwindOnError(bool unwind) { - m_opaque_ap->SetUnwindOnError(unwind); + m_opaque_up->SetUnwindOnError(unwind); } bool SBExpressionOptions::GetIgnoreBreakpoints() const { - return m_opaque_ap->DoesIgnoreBreakpoints(); + return m_opaque_up->DoesIgnoreBreakpoints(); } void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) { - m_opaque_ap->SetIgnoreBreakpoints(ignore); + m_opaque_up->SetIgnoreBreakpoints(ignore); } lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const { - return m_opaque_ap->GetUseDynamic(); + return m_opaque_up->GetUseDynamic(); } void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) { - m_opaque_ap->SetUseDynamic(dynamic); + m_opaque_up->SetUseDynamic(dynamic); } uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const { - return m_opaque_ap->GetTimeout() ? m_opaque_ap->GetTimeout()->count() : 0; + return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0; } void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) { - m_opaque_ap->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) + m_opaque_up->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) : std::chrono::microseconds(timeout)); } uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const { - return m_opaque_ap->GetOneThreadTimeout() ? m_opaque_ap->GetOneThreadTimeout()->count() : 0; + return m_opaque_up->GetOneThreadTimeout() + ? m_opaque_up->GetOneThreadTimeout()->count() + : 0; } void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) { - m_opaque_ap->SetOneThreadTimeout(timeout == 0 + m_opaque_up->SetOneThreadTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) : std::chrono::microseconds(timeout)); } bool SBExpressionOptions::GetTryAllThreads() const { - return m_opaque_ap->GetTryAllThreads(); + return m_opaque_up->GetTryAllThreads(); } void SBExpressionOptions::SetTryAllThreads(bool run_others) { - m_opaque_ap->SetTryAllThreads(run_others); + m_opaque_up->SetTryAllThreads(run_others); } bool SBExpressionOptions::GetStopOthers() const { - return m_opaque_ap->GetStopOthers(); + return m_opaque_up->GetStopOthers(); } void SBExpressionOptions::SetStopOthers(bool run_others) { - m_opaque_ap->SetStopOthers(run_others); + m_opaque_up->SetStopOthers(run_others); } bool SBExpressionOptions::GetTrapExceptions() const { - return m_opaque_ap->GetTrapExceptions(); + return m_opaque_up->GetTrapExceptions(); } void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) { - m_opaque_ap->SetTrapExceptions(trap_exceptions); + m_opaque_up->SetTrapExceptions(trap_exceptions); } void SBExpressionOptions::SetLanguage(lldb::LanguageType language) { - m_opaque_ap->SetLanguage(language); + m_opaque_up->SetLanguage(language); } void SBExpressionOptions::SetCancelCallback( lldb::ExpressionCancelCallback callback, void *baton) { - m_opaque_ap->SetCancelCallback(callback, baton); + m_opaque_up->SetCancelCallback(callback, baton); } bool SBExpressionOptions::GetGenerateDebugInfo() { - return m_opaque_ap->GetGenerateDebugInfo(); + return m_opaque_up->GetGenerateDebugInfo(); } void SBExpressionOptions::SetGenerateDebugInfo(bool b) { - return m_opaque_ap->SetGenerateDebugInfo(b); + return m_opaque_up->SetGenerateDebugInfo(b); } bool SBExpressionOptions::GetSuppressPersistentResult() { - return m_opaque_ap->GetResultIsInternal(); + return m_opaque_up->GetResultIsInternal(); } void SBExpressionOptions::SetSuppressPersistentResult(bool b) { - return m_opaque_ap->SetResultIsInternal(b); + return m_opaque_up->SetResultIsInternal(b); } const char *SBExpressionOptions::GetPrefix() const { - return m_opaque_ap->GetPrefix(); + return m_opaque_up->GetPrefix(); } void SBExpressionOptions::SetPrefix(const char *prefix) { - return m_opaque_ap->SetPrefix(prefix); + return m_opaque_up->SetPrefix(prefix); } bool SBExpressionOptions::GetAutoApplyFixIts() { - return m_opaque_ap->GetAutoApplyFixIts(); + return m_opaque_up->GetAutoApplyFixIts(); } void SBExpressionOptions::SetAutoApplyFixIts(bool b) { - return m_opaque_ap->SetAutoApplyFixIts(b); + return m_opaque_up->SetAutoApplyFixIts(b); } bool SBExpressionOptions::GetTopLevel() { - return m_opaque_ap->GetExecutionPolicy() == eExecutionPolicyTopLevel; + return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel; } void SBExpressionOptions::SetTopLevel(bool b) { - m_opaque_ap->SetExecutionPolicy(b ? eExecutionPolicyTopLevel - : m_opaque_ap->default_execution_policy); + m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel + : m_opaque_up->default_execution_policy); } bool SBExpressionOptions::GetAllowJIT() { - return m_opaque_ap->GetExecutionPolicy() != eExecutionPolicyNever; + return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever; } void SBExpressionOptions::SetAllowJIT(bool allow) { - m_opaque_ap->SetExecutionPolicy(allow ? m_opaque_ap->default_execution_policy - : eExecutionPolicyNever); + m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy + : eExecutionPolicyNever); } EvaluateExpressionOptions *SBExpressionOptions::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } EvaluateExpressionOptions &SBExpressionOptions::ref() const { - return *(m_opaque_ap.get()); + return *(m_opaque_up.get()); } diff --git a/lldb/source/API/SBFileSpec.cpp b/lldb/source/API/SBFileSpec.cpp index 6ce105d4264..e606d6f7b62 100644 --- a/lldb/source/API/SBFileSpec.cpp +++ b/lldb/source/API/SBFileSpec.cpp @@ -22,50 +22,50 @@ using namespace lldb; using namespace lldb_private; -SBFileSpec::SBFileSpec() : m_opaque_ap(new lldb_private::FileSpec()) {} +SBFileSpec::SBFileSpec() : m_opaque_up(new lldb_private::FileSpec()) {} SBFileSpec::SBFileSpec(const SBFileSpec &rhs) - : m_opaque_ap(new lldb_private::FileSpec(*rhs.m_opaque_ap)) {} + : m_opaque_up(new lldb_private::FileSpec(*rhs.m_opaque_up)) {} SBFileSpec::SBFileSpec(const lldb_private::FileSpec &fspec) - : m_opaque_ap(new lldb_private::FileSpec(fspec)) {} + : m_opaque_up(new lldb_private::FileSpec(fspec)) {} // Deprecated!!! -SBFileSpec::SBFileSpec(const char *path) : m_opaque_ap(new FileSpec(path)) { - FileSystem::Instance().Resolve(*m_opaque_ap); +SBFileSpec::SBFileSpec(const char *path) : m_opaque_up(new FileSpec(path)) { + FileSystem::Instance().Resolve(*m_opaque_up); } SBFileSpec::SBFileSpec(const char *path, bool resolve) - : m_opaque_ap(new FileSpec(path)) { + : m_opaque_up(new FileSpec(path)) { if (resolve) - FileSystem::Instance().Resolve(*m_opaque_ap); + FileSystem::Instance().Resolve(*m_opaque_up); } SBFileSpec::~SBFileSpec() {} const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) { if (this != &rhs) - *m_opaque_ap = *rhs.m_opaque_ap; + *m_opaque_up = *rhs.m_opaque_up; return *this; } -bool SBFileSpec::IsValid() const { return m_opaque_ap->operator bool(); } +bool SBFileSpec::IsValid() const { return m_opaque_up->operator bool(); } bool SBFileSpec::Exists() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - bool result = FileSystem::Instance().Exists(*m_opaque_ap); + bool result = FileSystem::Instance().Exists(*m_opaque_up); if (log) log->Printf("SBFileSpec(%p)::Exists () => %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), (result ? "true" : "false")); return result; } bool SBFileSpec::ResolveExecutableLocation() { - return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_ap); + return FileSystem::Instance().ResolveExecutableLocation(*m_opaque_up); } int SBFileSpec::ResolvePath(const char *src_path, char *dst_path, @@ -77,60 +77,60 @@ int SBFileSpec::ResolvePath(const char *src_path, char *dst_path, } const char *SBFileSpec::GetFilename() const { - const char *s = m_opaque_ap->GetFilename().AsCString(); + const char *s = m_opaque_up->GetFilename().AsCString(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { if (s) log->Printf("SBFileSpec(%p)::GetFilename () => \"%s\"", - static_cast<void *>(m_opaque_ap.get()), s); + static_cast<void *>(m_opaque_up.get()), s); else log->Printf("SBFileSpec(%p)::GetFilename () => NULL", - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); } return s; } const char *SBFileSpec::GetDirectory() const { - FileSpec directory{*m_opaque_ap}; + FileSpec directory{*m_opaque_up}; directory.GetFilename().Clear(); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { if (directory) log->Printf("SBFileSpec(%p)::GetDirectory () => \"%s\"", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), directory.GetCString()); else log->Printf("SBFileSpec(%p)::GetDirectory () => NULL", - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); } return directory.GetCString(); } void SBFileSpec::SetFilename(const char *filename) { if (filename && filename[0]) - m_opaque_ap->GetFilename().SetCString(filename); + m_opaque_up->GetFilename().SetCString(filename); else - m_opaque_ap->GetFilename().Clear(); + m_opaque_up->GetFilename().Clear(); } void SBFileSpec::SetDirectory(const char *directory) { if (directory && directory[0]) - m_opaque_ap->GetDirectory().SetCString(directory); + m_opaque_up->GetDirectory().SetCString(directory); else - m_opaque_ap->GetDirectory().Clear(); + m_opaque_up->GetDirectory().Clear(); } uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - uint32_t result = m_opaque_ap->GetPath(dst_path, dst_len); + uint32_t result = m_opaque_up->GetPath(dst_path, dst_len); if (log) log->Printf("SBFileSpec(%p)::GetPath (dst_path=\"%.*s\", dst_len=%" PRIu64 ") => %u", - static_cast<void *>(m_opaque_ap.get()), result, dst_path, + static_cast<void *>(m_opaque_up.get()), result, dst_path, static_cast<uint64_t>(dst_len), result); if (result == 0 && dst_path && dst_len > 0) @@ -139,31 +139,31 @@ uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const { } const lldb_private::FileSpec *SBFileSpec::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::FileSpec *SBFileSpec::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::FileSpec &SBFileSpec::operator*() const { - return *m_opaque_ap; + return *m_opaque_up; } -const lldb_private::FileSpec &SBFileSpec::ref() const { return *m_opaque_ap; } +const lldb_private::FileSpec &SBFileSpec::ref() const { return *m_opaque_up; } void SBFileSpec::SetFileSpec(const lldb_private::FileSpec &fs) { - *m_opaque_ap = fs; + *m_opaque_up = fs; } bool SBFileSpec::GetDescription(SBStream &description) const { Stream &strm = description.ref(); char path[PATH_MAX]; - if (m_opaque_ap->GetPath(path, sizeof(path))) + if (m_opaque_up->GetPath(path, sizeof(path))) strm.PutCString(path); return true; } void SBFileSpec::AppendPathComponent(const char *fn) { - m_opaque_ap->AppendPathComponent(fn); + m_opaque_up->AppendPathComponent(fn); } diff --git a/lldb/source/API/SBFileSpecList.cpp b/lldb/source/API/SBFileSpecList.cpp index 4717f888335..35304fe1747 100644 --- a/lldb/source/API/SBFileSpecList.cpp +++ b/lldb/source/API/SBFileSpecList.cpp @@ -20,19 +20,19 @@ using namespace lldb; using namespace lldb_private; -SBFileSpecList::SBFileSpecList() : m_opaque_ap(new FileSpecList()) {} +SBFileSpecList::SBFileSpecList() : m_opaque_up(new FileSpecList()) {} -SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_ap() { +SBFileSpecList::SBFileSpecList(const SBFileSpecList &rhs) : m_opaque_up() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (rhs.m_opaque_ap) - m_opaque_ap.reset(new FileSpecList(*(rhs.get()))); + if (rhs.m_opaque_up) + m_opaque_up.reset(new FileSpecList(*(rhs.get()))); if (log) { log->Printf("SBFileSpecList::SBFileSpecList (const SBFileSpecList " "rhs.ap=%p) => SBFileSpecList(%p)", - static_cast<void *>(rhs.m_opaque_ap.get()), - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(rhs.m_opaque_up.get()), + static_cast<void *>(m_opaque_up.get())); } } @@ -40,59 +40,59 @@ SBFileSpecList::~SBFileSpecList() {} const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) { if (this != &rhs) { - m_opaque_ap.reset(new lldb_private::FileSpecList(*(rhs.get()))); + m_opaque_up.reset(new lldb_private::FileSpecList(*(rhs.get()))); } return *this; } -uint32_t SBFileSpecList::GetSize() const { return m_opaque_ap->GetSize(); } +uint32_t SBFileSpecList::GetSize() const { return m_opaque_up->GetSize(); } void SBFileSpecList::Append(const SBFileSpec &sb_file) { - m_opaque_ap->Append(sb_file.ref()); + m_opaque_up->Append(sb_file.ref()); } bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) { - return m_opaque_ap->AppendIfUnique(sb_file.ref()); + return m_opaque_up->AppendIfUnique(sb_file.ref()); } -void SBFileSpecList::Clear() { m_opaque_ap->Clear(); } +void SBFileSpecList::Clear() { m_opaque_up->Clear(); } uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file, bool full) { - return m_opaque_ap->FindFileIndex(idx, sb_file.ref(), full); + return m_opaque_up->FindFileIndex(idx, sb_file.ref(), full); } const SBFileSpec SBFileSpecList::GetFileSpecAtIndex(uint32_t idx) const { SBFileSpec new_spec; - new_spec.SetFileSpec(m_opaque_ap->GetFileSpecAtIndex(idx)); + new_spec.SetFileSpec(m_opaque_up->GetFileSpecAtIndex(idx)); return new_spec; } const lldb_private::FileSpecList *SBFileSpecList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::FileSpecList *SBFileSpecList::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::FileSpecList &SBFileSpecList::operator*() const { - return *m_opaque_ap; + return *m_opaque_up; } const lldb_private::FileSpecList &SBFileSpecList::ref() const { - return *m_opaque_ap; + return *m_opaque_up; } bool SBFileSpecList::GetDescription(SBStream &description) const { Stream &strm = description.ref(); - if (m_opaque_ap) { - uint32_t num_files = m_opaque_ap->GetSize(); + if (m_opaque_up) { + uint32_t num_files = m_opaque_up->GetSize(); strm.Printf("%d files: ", num_files); for (uint32_t i = 0; i < num_files; i++) { char path[PATH_MAX]; - if (m_opaque_ap->GetFileSpecAtIndex(i).GetPath(path, sizeof(path))) + if (m_opaque_up->GetFileSpecAtIndex(i).GetPath(path, sizeof(path))) strm.Printf("\n %s", path); } } else diff --git a/lldb/source/API/SBLineEntry.cpp b/lldb/source/API/SBLineEntry.cpp index 66cc9cc6ee1..17cdf231600 100644 --- a/lldb/source/API/SBLineEntry.cpp +++ b/lldb/source/API/SBLineEntry.cpp @@ -18,15 +18,15 @@ using namespace lldb; using namespace lldb_private; -SBLineEntry::SBLineEntry() : m_opaque_ap() {} +SBLineEntry::SBLineEntry() : m_opaque_up() {} -SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_ap() { +SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_up() { if (rhs.IsValid()) ref() = rhs.ref(); } SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr) - : m_opaque_ap() { + : m_opaque_up() { if (lldb_object_ptr) ref() = *lldb_object_ptr; } @@ -36,7 +36,7 @@ const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) { if (rhs.IsValid()) ref() = rhs.ref(); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } @@ -49,8 +49,8 @@ SBLineEntry::~SBLineEntry() {} SBAddress SBLineEntry::GetStartAddress() const { SBAddress sb_address; - if (m_opaque_ap) - sb_address.SetAddress(&m_opaque_ap->range.GetBaseAddress()); + if (m_opaque_up) + sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress()); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -60,7 +60,7 @@ SBAddress SBLineEntry::GetStartAddress() const { addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress, Address::DumpStyleInvalid, 4); log->Printf("SBLineEntry(%p)::GetStartAddress () => SBAddress (%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(sb_address.get()), sstr.GetData()); } @@ -69,9 +69,9 @@ SBAddress SBLineEntry::GetStartAddress() const { SBAddress SBLineEntry::GetEndAddress() const { SBAddress sb_address; - if (m_opaque_ap) { - sb_address.SetAddress(&m_opaque_ap->range.GetBaseAddress()); - sb_address.OffsetAddress(m_opaque_ap->range.GetByteSize()); + if (m_opaque_up) { + sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress()); + sb_address.OffsetAddress(m_opaque_up->range.GetByteSize()); } Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (log) { @@ -81,28 +81,28 @@ SBAddress SBLineEntry::GetEndAddress() const { addr->Dump(&sstr, NULL, Address::DumpStyleModuleWithFileAddress, Address::DumpStyleInvalid, 4); log->Printf("SBLineEntry(%p)::GetEndAddress () => SBAddress (%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(sb_address.get()), sstr.GetData()); } return sb_address; } bool SBLineEntry::IsValid() const { - return m_opaque_ap.get() && m_opaque_ap->IsValid(); + return m_opaque_up.get() && m_opaque_up->IsValid(); } SBFileSpec SBLineEntry::GetFileSpec() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBFileSpec sb_file_spec; - if (m_opaque_ap.get() && m_opaque_ap->file) - sb_file_spec.SetFileSpec(m_opaque_ap->file); + if (m_opaque_up.get() && m_opaque_up->file) + sb_file_spec.SetFileSpec(m_opaque_up->file); if (log) { SBStream sstr; sb_file_spec.GetDescription(sstr); log->Printf("SBLineEntry(%p)::GetFileSpec () => SBFileSpec(%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<const void *>(sb_file_spec.get()), sstr.GetData()); } @@ -113,19 +113,19 @@ uint32_t SBLineEntry::GetLine() const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); uint32_t line = 0; - if (m_opaque_ap) - line = m_opaque_ap->line; + if (m_opaque_up) + line = m_opaque_up->line; if (log) log->Printf("SBLineEntry(%p)::GetLine () => %u", - static_cast<void *>(m_opaque_ap.get()), line); + static_cast<void *>(m_opaque_up.get()), line); return line; } uint32_t SBLineEntry::GetColumn() const { - if (m_opaque_ap) - return m_opaque_ap->column; + if (m_opaque_up) + return m_opaque_up->column; return 0; } @@ -140,8 +140,8 @@ void SBLineEntry::SetLine(uint32_t line) { ref().line = line; } void SBLineEntry::SetColumn(uint32_t column) { ref().line = column; } bool SBLineEntry::operator==(const SBLineEntry &rhs) const { - lldb_private::LineEntry *lhs_ptr = m_opaque_ap.get(); - lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_ap.get(); + lldb_private::LineEntry *lhs_ptr = m_opaque_up.get(); + lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get(); if (lhs_ptr && rhs_ptr) return lldb_private::LineEntry::Compare(*lhs_ptr, *rhs_ptr) == 0; @@ -150,8 +150,8 @@ bool SBLineEntry::operator==(const SBLineEntry &rhs) const { } bool SBLineEntry::operator!=(const SBLineEntry &rhs) const { - lldb_private::LineEntry *lhs_ptr = m_opaque_ap.get(); - lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_ap.get(); + lldb_private::LineEntry *lhs_ptr = m_opaque_up.get(); + lldb_private::LineEntry *rhs_ptr = rhs.m_opaque_up.get(); if (lhs_ptr && rhs_ptr) return lldb_private::LineEntry::Compare(*lhs_ptr, *rhs_ptr) != 0; @@ -160,23 +160,23 @@ bool SBLineEntry::operator!=(const SBLineEntry &rhs) const { } const lldb_private::LineEntry *SBLineEntry::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::LineEntry &SBLineEntry::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new lldb_private::LineEntry()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new lldb_private::LineEntry()); + return *m_opaque_up; } -const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_ap; } +const lldb_private::LineEntry &SBLineEntry::ref() const { return *m_opaque_up; } bool SBLineEntry::GetDescription(SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) { + if (m_opaque_up) { char file_path[PATH_MAX * 2]; - m_opaque_ap->file.GetPath(file_path, sizeof(file_path)); + m_opaque_up->file.GetPath(file_path, sizeof(file_path)); strm.Printf("%s:%u", file_path, GetLine()); if (GetColumn() > 0) strm.Printf(":%u", GetColumn()); @@ -186,4 +186,4 @@ bool SBLineEntry::GetDescription(SBStream &description) { return true; } -lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_ap.get(); } +lldb_private::LineEntry *SBLineEntry::get() { return m_opaque_up.get(); } diff --git a/lldb/source/API/SBMemoryRegionInfo.cpp b/lldb/source/API/SBMemoryRegionInfo.cpp index 26778d973bb..2a3f7c7c479 100644 --- a/lldb/source/API/SBMemoryRegionInfo.cpp +++ b/lldb/source/API/SBMemoryRegionInfo.cpp @@ -17,16 +17,16 @@ using namespace lldb; using namespace lldb_private; SBMemoryRegionInfo::SBMemoryRegionInfo() - : m_opaque_ap(new MemoryRegionInfo()) {} + : m_opaque_up(new MemoryRegionInfo()) {} SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr) - : m_opaque_ap(new MemoryRegionInfo()) { + : m_opaque_up(new MemoryRegionInfo()) { if (lldb_object_ptr) ref() = *lldb_object_ptr; } SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs) - : m_opaque_ap(new MemoryRegionInfo()) { + : m_opaque_up(new MemoryRegionInfo()) { ref() = rhs.ref(); } @@ -40,7 +40,7 @@ operator=(const SBMemoryRegionInfo &rhs) { SBMemoryRegionInfo::~SBMemoryRegionInfo() {} -void SBMemoryRegionInfo::Clear() { m_opaque_ap->Clear(); } +void SBMemoryRegionInfo::Clear() { m_opaque_up->Clear(); } bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const { return ref() == rhs.ref(); @@ -50,47 +50,47 @@ bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const { return ref() != rhs.ref(); } -MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_ap; } +MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; } -const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_ap; } +const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; } lldb::addr_t SBMemoryRegionInfo::GetRegionBase() { - return m_opaque_ap->GetRange().GetRangeBase(); + return m_opaque_up->GetRange().GetRangeBase(); } lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() { - return m_opaque_ap->GetRange().GetRangeEnd(); + return m_opaque_up->GetRange().GetRangeEnd(); } bool SBMemoryRegionInfo::IsReadable() { - return m_opaque_ap->GetReadable() == MemoryRegionInfo::eYes; + return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsWritable() { - return m_opaque_ap->GetWritable() == MemoryRegionInfo::eYes; + return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsExecutable() { - return m_opaque_ap->GetExecutable() == MemoryRegionInfo::eYes; + return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes; } bool SBMemoryRegionInfo::IsMapped() { - return m_opaque_ap->GetMapped() == MemoryRegionInfo::eYes; + return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes; } const char *SBMemoryRegionInfo::GetName() { - return m_opaque_ap->GetName().AsCString(); + return m_opaque_up->GetName().AsCString(); } bool SBMemoryRegionInfo::GetDescription(SBStream &description) { Stream &strm = description.ref(); - const addr_t load_addr = m_opaque_ap->GetRange().base; + const addr_t load_addr = m_opaque_up->GetRange().base; strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr, - load_addr + m_opaque_ap->GetRange().size); - strm.Printf(m_opaque_ap->GetReadable() ? "R" : "-"); - strm.Printf(m_opaque_ap->GetWritable() ? "W" : "-"); - strm.Printf(m_opaque_ap->GetExecutable() ? "X" : "-"); + load_addr + m_opaque_up->GetRange().size); + strm.Printf(m_opaque_up->GetReadable() ? "R" : "-"); + strm.Printf(m_opaque_up->GetWritable() ? "W" : "-"); + strm.Printf(m_opaque_up->GetExecutable() ? "X" : "-"); strm.Printf("]"); return true; diff --git a/lldb/source/API/SBMemoryRegionInfoList.cpp b/lldb/source/API/SBMemoryRegionInfoList.cpp index 290804a9cd6..a0104b98ed7 100644 --- a/lldb/source/API/SBMemoryRegionInfoList.cpp +++ b/lldb/source/API/SBMemoryRegionInfoList.cpp @@ -64,69 +64,67 @@ private: MemoryRegionInfos m_regions; }; -MemoryRegionInfos &SBMemoryRegionInfoList::ref() { - return m_opaque_ap->Ref(); -} +MemoryRegionInfos &SBMemoryRegionInfoList::ref() { return m_opaque_up->Ref(); } const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const { - return m_opaque_ap->Ref(); + return m_opaque_up->Ref(); } SBMemoryRegionInfoList::SBMemoryRegionInfoList() - : m_opaque_ap(new MemoryRegionInfoListImpl()) {} + : m_opaque_up(new MemoryRegionInfoListImpl()) {} SBMemoryRegionInfoList::SBMemoryRegionInfoList( const SBMemoryRegionInfoList &rhs) - : m_opaque_ap(new MemoryRegionInfoListImpl(*rhs.m_opaque_ap)) {} + : m_opaque_up(new MemoryRegionInfoListImpl(*rhs.m_opaque_up)) {} SBMemoryRegionInfoList::~SBMemoryRegionInfoList() {} const SBMemoryRegionInfoList &SBMemoryRegionInfoList:: operator=(const SBMemoryRegionInfoList &rhs) { if (this != &rhs) { - *m_opaque_ap = *rhs.m_opaque_ap; + *m_opaque_up = *rhs.m_opaque_up; } return *this; } uint32_t SBMemoryRegionInfoList::GetSize() const { - return m_opaque_ap->GetSize(); + return m_opaque_up->GetSize(); } bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex( uint32_t idx, SBMemoryRegionInfo ®ion_info) { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - bool result = m_opaque_ap->GetMemoryRegionInfoAtIndex(idx, region_info.ref()); + bool result = m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref()); if (log) { SBStream sstr; region_info.GetDescription(sstr); log->Printf("SBMemoryRegionInfoList::GetMemoryRegionAtIndex (this.ap=%p, " "idx=%d) => SBMemoryRegionInfo (this.ap=%p, '%s')", - static_cast<void *>(m_opaque_ap.get()), idx, - static_cast<void *>(region_info.m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), idx, + static_cast<void *>(region_info.m_opaque_up.get()), sstr.GetData()); } return result; } -void SBMemoryRegionInfoList::Clear() { m_opaque_ap->Clear(); } +void SBMemoryRegionInfoList::Clear() { m_opaque_up->Clear(); } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) { - m_opaque_ap->Append(sb_region.ref()); + m_opaque_up->Append(sb_region.ref()); } void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) { - m_opaque_ap->Append(*sb_region_list); + m_opaque_up->Append(*sb_region_list); } const MemoryRegionInfoListImpl *SBMemoryRegionInfoList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const MemoryRegionInfoListImpl &SBMemoryRegionInfoList::operator*() const { - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } diff --git a/lldb/source/API/SBModule.cpp b/lldb/source/API/SBModule.cpp index b7385d6f61d..a7886b034bd 100644 --- a/lldb/source/API/SBModule.cpp +++ b/lldb/source/API/SBModule.cpp @@ -36,7 +36,7 @@ SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {} SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() { ModuleSP module_sp; - Status error = ModuleList::GetSharedModule(*module_spec.m_opaque_ap, + Status error = ModuleList::GetSharedModule(*module_spec.m_opaque_up, module_sp, NULL, NULL, NULL); if (module_sp) SetSP(module_sp); @@ -492,7 +492,7 @@ lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) { TypeClass type_class = static_cast<TypeClass>(type_mask); TypeList type_list; vendor->GetTypes(NULL, type_class, type_list); - sb_type_list.m_opaque_ap->Append(type_list); + sb_type_list.m_opaque_up->Append(type_list); return sb_type_list; } diff --git a/lldb/source/API/SBModuleSpec.cpp b/lldb/source/API/SBModuleSpec.cpp index 882b312e4aa..a4d62665c36 100644 --- a/lldb/source/API/SBModuleSpec.cpp +++ b/lldb/source/API/SBModuleSpec.cpp @@ -17,58 +17,58 @@ using namespace lldb; using namespace lldb_private; -SBModuleSpec::SBModuleSpec() : m_opaque_ap(new lldb_private::ModuleSpec()) {} +SBModuleSpec::SBModuleSpec() : m_opaque_up(new lldb_private::ModuleSpec()) {} SBModuleSpec::SBModuleSpec(const SBModuleSpec &rhs) - : m_opaque_ap(new lldb_private::ModuleSpec(*rhs.m_opaque_ap)) {} + : m_opaque_up(new lldb_private::ModuleSpec(*rhs.m_opaque_up)) {} const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) { if (this != &rhs) - *m_opaque_ap = *(rhs.m_opaque_ap); + *m_opaque_up = *(rhs.m_opaque_up); return *this; } SBModuleSpec::~SBModuleSpec() {} -bool SBModuleSpec::IsValid() const { return m_opaque_ap->operator bool(); } +bool SBModuleSpec::IsValid() const { return m_opaque_up->operator bool(); } -void SBModuleSpec::Clear() { m_opaque_ap->Clear(); } +void SBModuleSpec::Clear() { m_opaque_up->Clear(); } SBFileSpec SBModuleSpec::GetFileSpec() { - SBFileSpec sb_spec(m_opaque_ap->GetFileSpec()); + SBFileSpec sb_spec(m_opaque_up->GetFileSpec()); return sb_spec; } void SBModuleSpec::SetFileSpec(const lldb::SBFileSpec &sb_spec) { - m_opaque_ap->GetFileSpec() = *sb_spec; + m_opaque_up->GetFileSpec() = *sb_spec; } lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() { - return SBFileSpec(m_opaque_ap->GetPlatformFileSpec()); + return SBFileSpec(m_opaque_up->GetPlatformFileSpec()); } void SBModuleSpec::SetPlatformFileSpec(const lldb::SBFileSpec &sb_spec) { - m_opaque_ap->GetPlatformFileSpec() = *sb_spec; + m_opaque_up->GetPlatformFileSpec() = *sb_spec; } lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() { - return SBFileSpec(m_opaque_ap->GetSymbolFileSpec()); + return SBFileSpec(m_opaque_up->GetSymbolFileSpec()); } void SBModuleSpec::SetSymbolFileSpec(const lldb::SBFileSpec &sb_spec) { - m_opaque_ap->GetSymbolFileSpec() = *sb_spec; + m_opaque_up->GetSymbolFileSpec() = *sb_spec; } const char *SBModuleSpec::GetObjectName() { - return m_opaque_ap->GetObjectName().GetCString(); + return m_opaque_up->GetObjectName().GetCString(); } void SBModuleSpec::SetObjectName(const char *name) { - m_opaque_ap->GetObjectName().SetCString(name); + m_opaque_up->GetObjectName().SetCString(name); } const char *SBModuleSpec::GetTriple() { - std::string triple(m_opaque_ap->GetArchitecture().GetTriple().str()); + std::string triple(m_opaque_up->GetArchitecture().GetTriple().str()); // Unique the string so we don't run into ownership issues since the const // strings put the string into the string pool once and the strings never // comes out @@ -77,35 +77,35 @@ const char *SBModuleSpec::GetTriple() { } void SBModuleSpec::SetTriple(const char *triple) { - m_opaque_ap->GetArchitecture().SetTriple(triple); + m_opaque_up->GetArchitecture().SetTriple(triple); } const uint8_t *SBModuleSpec::GetUUIDBytes() { - return m_opaque_ap->GetUUID().GetBytes().data(); + return m_opaque_up->GetUUID().GetBytes().data(); } size_t SBModuleSpec::GetUUIDLength() { - return m_opaque_ap->GetUUID().GetBytes().size(); + return m_opaque_up->GetUUID().GetBytes().size(); } bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) { - m_opaque_ap->GetUUID() = UUID::fromOptionalData(uuid, uuid_len); - return m_opaque_ap->GetUUID().IsValid(); + m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len); + return m_opaque_up->GetUUID().IsValid(); } bool SBModuleSpec::GetDescription(lldb::SBStream &description) { - m_opaque_ap->Dump(description.ref()); + m_opaque_up->Dump(description.ref()); return true; } -SBModuleSpecList::SBModuleSpecList() : m_opaque_ap(new ModuleSpecList()) {} +SBModuleSpecList::SBModuleSpecList() : m_opaque_up(new ModuleSpecList()) {} SBModuleSpecList::SBModuleSpecList(const SBModuleSpecList &rhs) - : m_opaque_ap(new ModuleSpecList(*rhs.m_opaque_ap)) {} + : m_opaque_up(new ModuleSpecList(*rhs.m_opaque_up)) {} SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) { if (this != &rhs) - *m_opaque_ap = *rhs.m_opaque_ap; + *m_opaque_up = *rhs.m_opaque_up; return *this; } @@ -116,43 +116,43 @@ SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path) { FileSpec file_spec(path); FileSystem::Instance().Resolve(file_spec); Host::ResolveExecutableInBundle(file_spec); - ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_ap); + ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_up); return specs; } void SBModuleSpecList::Append(const SBModuleSpec &spec) { - m_opaque_ap->Append(*spec.m_opaque_ap); + m_opaque_up->Append(*spec.m_opaque_up); } void SBModuleSpecList::Append(const SBModuleSpecList &spec_list) { - m_opaque_ap->Append(*spec_list.m_opaque_ap); + m_opaque_up->Append(*spec_list.m_opaque_up); } -size_t SBModuleSpecList::GetSize() { return m_opaque_ap->GetSize(); } +size_t SBModuleSpecList::GetSize() { return m_opaque_up->GetSize(); } SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) { SBModuleSpec sb_module_spec; - m_opaque_ap->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_ap); + m_opaque_up->GetModuleSpecAtIndex(i, *sb_module_spec.m_opaque_up); return sb_module_spec; } SBModuleSpec SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) { SBModuleSpec sb_module_spec; - m_opaque_ap->FindMatchingModuleSpec(*match_spec.m_opaque_ap, - *sb_module_spec.m_opaque_ap); + m_opaque_up->FindMatchingModuleSpec(*match_spec.m_opaque_up, + *sb_module_spec.m_opaque_up); return sb_module_spec; } SBModuleSpecList SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) { SBModuleSpecList specs; - m_opaque_ap->FindMatchingModuleSpecs(*match_spec.m_opaque_ap, - *specs.m_opaque_ap); + m_opaque_up->FindMatchingModuleSpecs(*match_spec.m_opaque_up, + *specs.m_opaque_up); return specs; } bool SBModuleSpecList::GetDescription(lldb::SBStream &description) { - m_opaque_ap->Dump(description.ref()); + m_opaque_up->Dump(description.ref()); return true; } diff --git a/lldb/source/API/SBProcessInfo.cpp b/lldb/source/API/SBProcessInfo.cpp index a786a5e0d49..80eaebe4127 100644 --- a/lldb/source/API/SBProcessInfo.cpp +++ b/lldb/source/API/SBProcessInfo.cpp @@ -14,11 +14,11 @@ using namespace lldb; using namespace lldb_private; -SBProcessInfo::SBProcessInfo() : m_opaque_ap() {} +SBProcessInfo::SBProcessInfo() : m_opaque_up() {} -SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_ap() { +SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() { if (rhs.IsValid()) { - ref() = *rhs.m_opaque_ap; + ref() = *rhs.m_opaque_up; } } @@ -27,118 +27,118 @@ SBProcessInfo::~SBProcessInfo() {} SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) { if (this != &rhs) { if (rhs.IsValid()) - ref() = *rhs.m_opaque_ap; + ref() = *rhs.m_opaque_up; else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } ProcessInstanceInfo &SBProcessInfo::ref() { - if (m_opaque_ap == nullptr) { - m_opaque_ap.reset(new ProcessInstanceInfo()); + if (m_opaque_up == nullptr) { + m_opaque_up.reset(new ProcessInstanceInfo()); } - return *m_opaque_ap; + return *m_opaque_up; } void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) { ref() = proc_info_ref; } -bool SBProcessInfo::IsValid() const { return m_opaque_ap != nullptr; } +bool SBProcessInfo::IsValid() const { return m_opaque_up != nullptr; } const char *SBProcessInfo::GetName() { const char *name = nullptr; - if (m_opaque_ap) { - name = m_opaque_ap->GetName(); + if (m_opaque_up) { + name = m_opaque_up->GetName(); } return name; } SBFileSpec SBProcessInfo::GetExecutableFile() { SBFileSpec file_spec; - if (m_opaque_ap) { - file_spec.SetFileSpec(m_opaque_ap->GetExecutableFile()); + if (m_opaque_up) { + file_spec.SetFileSpec(m_opaque_up->GetExecutableFile()); } return file_spec; } lldb::pid_t SBProcessInfo::GetProcessID() { lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; - if (m_opaque_ap) { - proc_id = m_opaque_ap->GetProcessID(); + if (m_opaque_up) { + proc_id = m_opaque_up->GetProcessID(); } return proc_id; } uint32_t SBProcessInfo::GetUserID() { uint32_t user_id = UINT32_MAX; - if (m_opaque_ap) { - user_id = m_opaque_ap->GetUserID(); + if (m_opaque_up) { + user_id = m_opaque_up->GetUserID(); } return user_id; } uint32_t SBProcessInfo::GetGroupID() { uint32_t group_id = UINT32_MAX; - if (m_opaque_ap) { - group_id = m_opaque_ap->GetGroupID(); + if (m_opaque_up) { + group_id = m_opaque_up->GetGroupID(); } return group_id; } bool SBProcessInfo::UserIDIsValid() { bool is_valid = false; - if (m_opaque_ap) { - is_valid = m_opaque_ap->UserIDIsValid(); + if (m_opaque_up) { + is_valid = m_opaque_up->UserIDIsValid(); } return is_valid; } bool SBProcessInfo::GroupIDIsValid() { bool is_valid = false; - if (m_opaque_ap) { - is_valid = m_opaque_ap->GroupIDIsValid(); + if (m_opaque_up) { + is_valid = m_opaque_up->GroupIDIsValid(); } return is_valid; } uint32_t SBProcessInfo::GetEffectiveUserID() { uint32_t user_id = UINT32_MAX; - if (m_opaque_ap) { - user_id = m_opaque_ap->GetEffectiveUserID(); + if (m_opaque_up) { + user_id = m_opaque_up->GetEffectiveUserID(); } return user_id; } uint32_t SBProcessInfo::GetEffectiveGroupID() { uint32_t group_id = UINT32_MAX; - if (m_opaque_ap) { - group_id = m_opaque_ap->GetEffectiveGroupID(); + if (m_opaque_up) { + group_id = m_opaque_up->GetEffectiveGroupID(); } return group_id; } bool SBProcessInfo::EffectiveUserIDIsValid() { bool is_valid = false; - if (m_opaque_ap) { - is_valid = m_opaque_ap->EffectiveUserIDIsValid(); + if (m_opaque_up) { + is_valid = m_opaque_up->EffectiveUserIDIsValid(); } return is_valid; } bool SBProcessInfo::EffectiveGroupIDIsValid() { bool is_valid = false; - if (m_opaque_ap) { - is_valid = m_opaque_ap->EffectiveGroupIDIsValid(); + if (m_opaque_up) { + is_valid = m_opaque_up->EffectiveGroupIDIsValid(); } return is_valid; } lldb::pid_t SBProcessInfo::GetParentProcessID() { lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID; - if (m_opaque_ap) { - proc_id = m_opaque_ap->GetParentProcessID(); + if (m_opaque_up) { + proc_id = m_opaque_up->GetParentProcessID(); } return proc_id; } diff --git a/lldb/source/API/SBSourceManager.cpp b/lldb/source/API/SBSourceManager.cpp index 9a469b1e453..85eba4f8887 100644 --- a/lldb/source/API/SBSourceManager.cpp +++ b/lldb/source/API/SBSourceManager.cpp @@ -71,23 +71,23 @@ using namespace lldb; using namespace lldb_private; SBSourceManager::SBSourceManager(const SBDebugger &debugger) { - m_opaque_ap.reset(new SourceManagerImpl(debugger.get_sp())); + m_opaque_up.reset(new SourceManagerImpl(debugger.get_sp())); } SBSourceManager::SBSourceManager(const SBTarget &target) { - m_opaque_ap.reset(new SourceManagerImpl(target.GetSP())); + m_opaque_up.reset(new SourceManagerImpl(target.GetSP())); } SBSourceManager::SBSourceManager(const SBSourceManager &rhs) { if (&rhs == this) return; - m_opaque_ap.reset(new SourceManagerImpl(*(rhs.m_opaque_ap.get()))); + m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get()))); } const lldb::SBSourceManager &SBSourceManager:: operator=(const lldb::SBSourceManager &rhs) { - m_opaque_ap.reset(new SourceManagerImpl(*(rhs.m_opaque_ap.get()))); + m_opaque_up.reset(new SourceManagerImpl(*(rhs.m_opaque_up.get()))); return *this; } @@ -106,10 +106,10 @@ size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn( const SBFileSpec &file, uint32_t line, uint32_t column, uint32_t context_before, uint32_t context_after, const char *current_line_cstr, SBStream &s) { - if (m_opaque_ap == NULL) + if (m_opaque_up == NULL) return 0; - return m_opaque_ap->DisplaySourceLinesWithLineNumbers( + return m_opaque_up->DisplaySourceLinesWithLineNumbers( file.ref(), line, column, context_before, context_after, current_line_cstr, s.get()); } diff --git a/lldb/source/API/SBStream.cpp b/lldb/source/API/SBStream.cpp index 2e7098511a6..11479d521bb 100644 --- a/lldb/source/API/SBStream.cpp +++ b/lldb/source/API/SBStream.cpp @@ -17,31 +17,31 @@ using namespace lldb; using namespace lldb_private; -SBStream::SBStream() : m_opaque_ap(new StreamString()), m_is_file(false) {} +SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {} SBStream::SBStream(SBStream &&rhs) - : m_opaque_ap(std::move(rhs.m_opaque_ap)), m_is_file(rhs.m_is_file) {} + : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {} SBStream::~SBStream() {} -bool SBStream::IsValid() const { return (m_opaque_ap != NULL); } +bool SBStream::IsValid() const { return (m_opaque_up != NULL); } // If this stream is not redirected to a file, it will maintain a local cache // for the stream data which can be accessed using this accessor. const char *SBStream::GetData() { - if (m_is_file || m_opaque_ap == NULL) + if (m_is_file || m_opaque_up == NULL) return NULL; - return static_cast<StreamString *>(m_opaque_ap.get())->GetData(); + return static_cast<StreamString *>(m_opaque_up.get())->GetData(); } // If this stream is not redirected to a file, it will maintain a local cache // for the stream output whose length can be accessed using this accessor. size_t SBStream::GetSize() { - if (m_is_file || m_opaque_ap == NULL) + if (m_is_file || m_opaque_up == NULL) return 0; - return static_cast<StreamString *>(m_opaque_ap.get())->GetSize(); + return static_cast<StreamString *>(m_opaque_up.get())->GetSize(); } void SBStream::Printf(const char *format, ...) { @@ -58,11 +58,11 @@ void SBStream::RedirectToFile(const char *path, bool append) { return; std::string local_data; - if (m_opaque_ap) { + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data if (!m_is_file) - local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString(); + local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString(); } StreamFile *stream_file = new StreamFile; uint32_t open_options = File::eOpenOptionWrite | File::eOpenOptionCanCreate; @@ -73,15 +73,15 @@ void SBStream::RedirectToFile(const char *path, bool append) { FileSystem::Instance().Open(stream_file->GetFile(), FileSpec(path), open_options); - m_opaque_ap.reset(stream_file); + m_opaque_up.reset(stream_file); - if (m_opaque_ap) { + if (m_opaque_up) { m_is_file = true; // If we had any data locally in our StreamString, then pass that along to // the to new file we are redirecting to. if (!local_data.empty()) - m_opaque_ap->Write(&local_data[0], local_data.size()); + m_opaque_up->Write(&local_data[0], local_data.size()); } else m_is_file = false; } @@ -91,63 +91,63 @@ void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) { return; std::string local_data; - if (m_opaque_ap) { + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data if (!m_is_file) - local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString(); + local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString(); } - m_opaque_ap.reset(new StreamFile(fh, transfer_fh_ownership)); + m_opaque_up.reset(new StreamFile(fh, transfer_fh_ownership)); - if (m_opaque_ap) { + if (m_opaque_up) { m_is_file = true; // If we had any data locally in our StreamString, then pass that along to // the to new file we are redirecting to. if (!local_data.empty()) - m_opaque_ap->Write(&local_data[0], local_data.size()); + m_opaque_up->Write(&local_data[0], local_data.size()); } else m_is_file = false; } void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) { std::string local_data; - if (m_opaque_ap) { + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data if (!m_is_file) - local_data = static_cast<StreamString *>(m_opaque_ap.get())->GetString(); + local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString(); } - m_opaque_ap.reset(new StreamFile(::fdopen(fd, "w"), transfer_fh_ownership)); - if (m_opaque_ap) { + m_opaque_up.reset(new StreamFile(::fdopen(fd, "w"), transfer_fh_ownership)); + if (m_opaque_up) { m_is_file = true; // If we had any data locally in our StreamString, then pass that along to // the to new file we are redirecting to. if (!local_data.empty()) - m_opaque_ap->Write(&local_data[0], local_data.size()); + m_opaque_up->Write(&local_data[0], local_data.size()); } else m_is_file = false; } -lldb_private::Stream *SBStream::operator->() { return m_opaque_ap.get(); } +lldb_private::Stream *SBStream::operator->() { return m_opaque_up.get(); } -lldb_private::Stream *SBStream::get() { return m_opaque_ap.get(); } +lldb_private::Stream *SBStream::get() { return m_opaque_up.get(); } lldb_private::Stream &SBStream::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new StreamString()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new StreamString()); + return *m_opaque_up; } void SBStream::Clear() { - if (m_opaque_ap) { + if (m_opaque_up) { // See if we have any locally backed data. If so, copy it so we can then // redirect it to the file so we don't lose the data if (m_is_file) - m_opaque_ap.reset(); + m_opaque_up.reset(); else - static_cast<StreamString *>(m_opaque_ap.get())->Clear(); + static_cast<StreamString *>(m_opaque_up.get())->Clear(); } } diff --git a/lldb/source/API/SBStringList.cpp b/lldb/source/API/SBStringList.cpp index 8a4cc0419c7..312a9dab959 100644 --- a/lldb/source/API/SBStringList.cpp +++ b/lldb/source/API/SBStringList.cpp @@ -13,25 +13,25 @@ using namespace lldb; using namespace lldb_private; -SBStringList::SBStringList() : m_opaque_ap() {} +SBStringList::SBStringList() : m_opaque_up() {} SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr) - : m_opaque_ap() { + : m_opaque_up() { if (lldb_strings_ptr) - m_opaque_ap.reset(new lldb_private::StringList(*lldb_strings_ptr)); + m_opaque_up.reset(new lldb_private::StringList(*lldb_strings_ptr)); } -SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_ap() { +SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() { if (rhs.IsValid()) - m_opaque_ap.reset(new lldb_private::StringList(*rhs)); + m_opaque_up.reset(new lldb_private::StringList(*rhs)); } const SBStringList &SBStringList::operator=(const SBStringList &rhs) { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new lldb_private::StringList(*rhs)); + m_opaque_up.reset(new lldb_private::StringList(*rhs)); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } @@ -39,70 +39,70 @@ const SBStringList &SBStringList::operator=(const SBStringList &rhs) { SBStringList::~SBStringList() {} const lldb_private::StringList *SBStringList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::StringList &SBStringList::operator*() const { - return *m_opaque_ap; + return *m_opaque_up; } -bool SBStringList::IsValid() const { return (m_opaque_ap != NULL); } +bool SBStringList::IsValid() const { return (m_opaque_up != NULL); } void SBStringList::AppendString(const char *str) { if (str != NULL) { if (IsValid()) - m_opaque_ap->AppendString(str); + m_opaque_up->AppendString(str); else - m_opaque_ap.reset(new lldb_private::StringList(str)); + m_opaque_up.reset(new lldb_private::StringList(str)); } } void SBStringList::AppendList(const char **strv, int strc) { if ((strv != NULL) && (strc > 0)) { if (IsValid()) - m_opaque_ap->AppendList(strv, strc); + m_opaque_up->AppendList(strv, strc); else - m_opaque_ap.reset(new lldb_private::StringList(strv, strc)); + m_opaque_up.reset(new lldb_private::StringList(strv, strc)); } } void SBStringList::AppendList(const SBStringList &strings) { if (strings.IsValid()) { if (!IsValid()) - m_opaque_ap.reset(new lldb_private::StringList()); - m_opaque_ap->AppendList(*(strings.m_opaque_ap)); + m_opaque_up.reset(new lldb_private::StringList()); + m_opaque_up->AppendList(*(strings.m_opaque_up)); } } void SBStringList::AppendList(const StringList &strings) { if (!IsValid()) - m_opaque_ap.reset(new lldb_private::StringList()); - m_opaque_ap->AppendList(strings); + m_opaque_up.reset(new lldb_private::StringList()); + m_opaque_up->AppendList(strings); } uint32_t SBStringList::GetSize() const { if (IsValid()) { - return m_opaque_ap->GetSize(); + return m_opaque_up->GetSize(); } return 0; } const char *SBStringList::GetStringAtIndex(size_t idx) { if (IsValid()) { - return m_opaque_ap->GetStringAtIndex(idx); + return m_opaque_up->GetStringAtIndex(idx); } return NULL; } const char *SBStringList::GetStringAtIndex(size_t idx) const { if (IsValid()) { - return m_opaque_ap->GetStringAtIndex(idx); + return m_opaque_up->GetStringAtIndex(idx); } return NULL; } void SBStringList::Clear() { if (IsValid()) { - m_opaque_ap->Clear(); + m_opaque_up->Clear(); } } diff --git a/lldb/source/API/SBSymbolContext.cpp b/lldb/source/API/SBSymbolContext.cpp index e64c0610a95..0260d1dc0db 100644 --- a/lldb/source/API/SBSymbolContext.cpp +++ b/lldb/source/API/SBSymbolContext.cpp @@ -17,19 +17,19 @@ using namespace lldb; using namespace lldb_private; -SBSymbolContext::SBSymbolContext() : m_opaque_ap() {} +SBSymbolContext::SBSymbolContext() : m_opaque_up() {} -SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_ap() { +SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() { if (sc_ptr) - m_opaque_ap.reset(new SymbolContext(*sc_ptr)); + m_opaque_up.reset(new SymbolContext(*sc_ptr)); } -SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_ap() { +SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() { if (rhs.IsValid()) { - if (m_opaque_ap) - *m_opaque_ap = *rhs.m_opaque_ap; + if (m_opaque_up) + *m_opaque_up = *rhs.m_opaque_up; else - ref() = *rhs.m_opaque_ap; + ref() = *rhs.m_opaque_up; } } @@ -38,32 +38,32 @@ SBSymbolContext::~SBSymbolContext() {} const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new lldb_private::SymbolContext(*rhs.m_opaque_ap)); + m_opaque_up.reset(new lldb_private::SymbolContext(*rhs.m_opaque_up)); } return *this; } void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) { if (sc_ptr) { - if (m_opaque_ap) - *m_opaque_ap = *sc_ptr; + if (m_opaque_up) + *m_opaque_up = *sc_ptr; else - m_opaque_ap.reset(new SymbolContext(*sc_ptr)); + m_opaque_up.reset(new SymbolContext(*sc_ptr)); } else { - if (m_opaque_ap) - m_opaque_ap->Clear(true); + if (m_opaque_up) + m_opaque_up->Clear(true); } } -bool SBSymbolContext::IsValid() const { return m_opaque_ap != NULL; } +bool SBSymbolContext::IsValid() const { return m_opaque_up != NULL; } SBModule SBSymbolContext::GetModule() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBModule sb_module; ModuleSP module_sp; - if (m_opaque_ap) { - module_sp = m_opaque_ap->module_sp; + if (m_opaque_up) { + module_sp = m_opaque_up->module_sp; sb_module.SetSP(module_sp); } @@ -71,7 +71,7 @@ SBModule SBSymbolContext::GetModule() { SBStream sstr; sb_module.GetDescription(sstr); log->Printf("SBSymbolContext(%p)::GetModule () => SBModule(%p): %s", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(module_sp.get()), sstr.GetData()); } @@ -79,7 +79,7 @@ SBModule SBSymbolContext::GetModule() { } SBCompileUnit SBSymbolContext::GetCompileUnit() { - return SBCompileUnit(m_opaque_ap ? m_opaque_ap->comp_unit : NULL); + return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : NULL); } SBFunction SBSymbolContext::GetFunction() { @@ -87,33 +87,33 @@ SBFunction SBSymbolContext::GetFunction() { Function *function = NULL; - if (m_opaque_ap) - function = m_opaque_ap->function; + if (m_opaque_up) + function = m_opaque_up->function; SBFunction sb_function(function); if (log) log->Printf("SBSymbolContext(%p)::GetFunction () => SBFunction(%p)", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(function)); return sb_function; } SBBlock SBSymbolContext::GetBlock() { - return SBBlock(m_opaque_ap ? m_opaque_ap->block : NULL); + return SBBlock(m_opaque_up ? m_opaque_up->block : NULL); } SBLineEntry SBSymbolContext::GetLineEntry() { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); SBLineEntry sb_line_entry; - if (m_opaque_ap) - sb_line_entry.SetLineEntry(m_opaque_ap->line_entry); + if (m_opaque_up) + sb_line_entry.SetLineEntry(m_opaque_up->line_entry); if (log) { log->Printf("SBSymbolContext(%p)::GetLineEntry () => SBLineEntry(%p)", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(sb_line_entry.get())); } @@ -125,14 +125,14 @@ SBSymbol SBSymbolContext::GetSymbol() { Symbol *symbol = NULL; - if (m_opaque_ap) - symbol = m_opaque_ap->symbol; + if (m_opaque_up) + symbol = m_opaque_up->symbol; SBSymbol sb_symbol(symbol); if (log) log->Printf("SBSymbolContext(%p)::GetSymbol () => SBSymbol(%p)", - static_cast<void *>(m_opaque_ap.get()), + static_cast<void *>(m_opaque_up.get()), static_cast<void *>(symbol)); return sb_symbol; @@ -166,35 +166,35 @@ void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) { } lldb_private::SymbolContext *SBSymbolContext::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::SymbolContext &SBSymbolContext::operator*() const { - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } lldb_private::SymbolContext &SBSymbolContext::operator*() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new SymbolContext); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new SymbolContext); + return *m_opaque_up; } lldb_private::SymbolContext &SBSymbolContext::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new SymbolContext); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new SymbolContext); + return *m_opaque_up; } lldb_private::SymbolContext *SBSymbolContext::get() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } bool SBSymbolContext::GetDescription(SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) { - m_opaque_ap->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); + if (m_opaque_up) { + m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); } else strm.PutCString("No value"); @@ -205,8 +205,8 @@ SBSymbolContext SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc, SBAddress &parent_frame_addr) const { SBSymbolContext sb_sc; - if (m_opaque_ap.get() && curr_frame_pc.IsValid()) { - if (m_opaque_ap->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(), + if (m_opaque_up.get() && curr_frame_pc.IsValid()) { + if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(), parent_frame_addr.ref())) return sb_sc; } diff --git a/lldb/source/API/SBSymbolContextList.cpp b/lldb/source/API/SBSymbolContextList.cpp index b078aab10ee..da344c4d585 100644 --- a/lldb/source/API/SBSymbolContextList.cpp +++ b/lldb/source/API/SBSymbolContextList.cpp @@ -14,32 +14,32 @@ using namespace lldb; using namespace lldb_private; SBSymbolContextList::SBSymbolContextList() - : m_opaque_ap(new SymbolContextList()) {} + : m_opaque_up(new SymbolContextList()) {} SBSymbolContextList::SBSymbolContextList(const SBSymbolContextList &rhs) - : m_opaque_ap(new SymbolContextList(*rhs.m_opaque_ap)) {} + : m_opaque_up(new SymbolContextList(*rhs.m_opaque_up)) {} SBSymbolContextList::~SBSymbolContextList() {} const SBSymbolContextList &SBSymbolContextList:: operator=(const SBSymbolContextList &rhs) { if (this != &rhs) { - *m_opaque_ap = *rhs.m_opaque_ap; + *m_opaque_up = *rhs.m_opaque_up; } return *this; } uint32_t SBSymbolContextList::GetSize() const { - if (m_opaque_ap) - return m_opaque_ap->GetSize(); + if (m_opaque_up) + return m_opaque_up->GetSize(); return 0; } SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) { SBSymbolContext sb_sc; - if (m_opaque_ap) { + if (m_opaque_up) { SymbolContext sc; - if (m_opaque_ap->GetContextAtIndex(idx, sc)) { + if (m_opaque_up->GetContextAtIndex(idx, sc)) { sb_sc.SetSymbolContext(&sc); } } @@ -47,34 +47,34 @@ SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) { } void SBSymbolContextList::Clear() { - if (m_opaque_ap) - m_opaque_ap->Clear(); + if (m_opaque_up) + m_opaque_up->Clear(); } void SBSymbolContextList::Append(SBSymbolContext &sc) { - if (sc.IsValid() && m_opaque_ap.get()) - m_opaque_ap->Append(*sc); + if (sc.IsValid() && m_opaque_up.get()) + m_opaque_up->Append(*sc); } void SBSymbolContextList::Append(SBSymbolContextList &sc_list) { - if (sc_list.IsValid() && m_opaque_ap.get()) - m_opaque_ap->Append(*sc_list); + if (sc_list.IsValid() && m_opaque_up.get()) + m_opaque_up->Append(*sc_list); } -bool SBSymbolContextList::IsValid() const { return m_opaque_ap != NULL; } +bool SBSymbolContextList::IsValid() const { return m_opaque_up != NULL; } lldb_private::SymbolContextList *SBSymbolContextList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::SymbolContextList &SBSymbolContextList::operator*() const { - assert(m_opaque_ap.get()); - return *m_opaque_ap; + assert(m_opaque_up.get()); + return *m_opaque_up; } bool SBSymbolContextList::GetDescription(lldb::SBStream &description) { Stream &strm = description.ref(); - if (m_opaque_ap) - m_opaque_ap->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); + if (m_opaque_up) + m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, NULL); return true; } diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp index c7dee634319..b863b3d3b05 100644 --- a/lldb/source/API/SBTarget.cpp +++ b/lldb/source/API/SBTarget.cpp @@ -1570,7 +1570,7 @@ lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { lldb::SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp) - sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_ap)); + sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_up)); return sb_module; } diff --git a/lldb/source/API/SBType.cpp b/lldb/source/API/SBType.cpp index b67f9bc8404..25a56dea745 100644 --- a/lldb/source/API/SBType.cpp +++ b/lldb/source/API/SBType.cpp @@ -44,7 +44,7 @@ SBType::SBType(const SBType &rhs) : m_opaque_sp() { } // SBType::SBType (TypeImpl* impl) : -// m_opaque_ap(impl) +// m_opaque_up(impl) //{} // bool SBType::operator==(SBType &rhs) { @@ -444,20 +444,20 @@ lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { return eTemplateArgumentKindNull; } -SBTypeList::SBTypeList() : m_opaque_ap(new TypeListImpl()) {} +SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {} SBTypeList::SBTypeList(const SBTypeList &rhs) - : m_opaque_ap(new TypeListImpl()) { + : m_opaque_up(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)); } -bool SBTypeList::IsValid() { return (m_opaque_ap != NULL); } +bool SBTypeList::IsValid() { return (m_opaque_up != NULL); } SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { if (this != &rhs) { - m_opaque_ap.reset(new TypeListImpl()); + m_opaque_up.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)); @@ -467,75 +467,75 @@ SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { void SBTypeList::Append(SBType type) { if (type.IsValid()) - m_opaque_ap->Append(type.m_opaque_sp); + m_opaque_up->Append(type.m_opaque_sp); } SBType SBTypeList::GetTypeAtIndex(uint32_t index) { - if (m_opaque_ap) - return SBType(m_opaque_ap->GetTypeAtIndex(index)); + if (m_opaque_up) + return SBType(m_opaque_up->GetTypeAtIndex(index)); return SBType(); } -uint32_t SBTypeList::GetSize() { return m_opaque_ap->GetSize(); } +uint32_t SBTypeList::GetSize() { return m_opaque_up->GetSize(); } SBTypeList::~SBTypeList() {} -SBTypeMember::SBTypeMember() : m_opaque_ap() {} +SBTypeMember::SBTypeMember() : m_opaque_up() {} SBTypeMember::~SBTypeMember() {} -SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_ap() { +SBTypeMember::SBTypeMember(const SBTypeMember &rhs) : m_opaque_up() { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); + m_opaque_up.reset(new TypeMemberImpl(rhs.ref())); } } lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); + m_opaque_up.reset(new TypeMemberImpl(rhs.ref())); } return *this; } -bool SBTypeMember::IsValid() const { return m_opaque_ap.get(); } +bool SBTypeMember::IsValid() const { return m_opaque_up.get(); } const char *SBTypeMember::GetName() { - if (m_opaque_ap) - return m_opaque_ap->GetName().GetCString(); + if (m_opaque_up) + return m_opaque_up->GetName().GetCString(); return NULL; } SBType SBTypeMember::GetType() { SBType sb_type; - if (m_opaque_ap) { - sb_type.SetSP(m_opaque_ap->GetTypeImpl()); + if (m_opaque_up) { + sb_type.SetSP(m_opaque_up->GetTypeImpl()); } return sb_type; } uint64_t SBTypeMember::GetOffsetInBytes() { - if (m_opaque_ap) - return m_opaque_ap->GetBitOffset() / 8u; + if (m_opaque_up) + return m_opaque_up->GetBitOffset() / 8u; return 0; } uint64_t SBTypeMember::GetOffsetInBits() { - if (m_opaque_ap) - return m_opaque_ap->GetBitOffset(); + if (m_opaque_up) + return m_opaque_up->GetBitOffset(); return 0; } bool SBTypeMember::IsBitfield() { - if (m_opaque_ap) - return m_opaque_ap->GetIsBitfield(); + if (m_opaque_up) + return m_opaque_up->GetIsBitfield(); return false; } uint32_t SBTypeMember::GetBitfieldSizeInBits() { - if (m_opaque_ap) - return m_opaque_ap->GetBitfieldBitSize(); + if (m_opaque_up) + return m_opaque_up->GetBitfieldBitSize(); return 0; } @@ -543,23 +543,23 @@ bool SBTypeMember::GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level) { Stream &strm = description.ref(); - if (m_opaque_ap) { - const uint32_t bit_offset = m_opaque_ap->GetBitOffset(); + if (m_opaque_up) { + const uint32_t bit_offset = m_opaque_up->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(); + const char *name = m_opaque_up->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()); + TypeImplSP type_impl_sp(m_opaque_up->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(); + if (m_opaque_up->GetIsBitfield()) { + const uint32_t bitfield_bit_size = m_opaque_up->GetBitfieldBitSize(); strm.Printf(" : %u", bitfield_bit_size); } } else { @@ -569,16 +569,16 @@ bool SBTypeMember::GetDescription(lldb::SBStream &description, } void SBTypeMember::reset(TypeMemberImpl *type_member_impl) { - m_opaque_ap.reset(type_member_impl); + m_opaque_up.reset(type_member_impl); } TypeMemberImpl &SBTypeMember::ref() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new TypeMemberImpl()); - return *m_opaque_ap; + if (m_opaque_up == NULL) + m_opaque_up.reset(new TypeMemberImpl()); + return *m_opaque_up; } -const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_ap; } +const TypeMemberImpl &SBTypeMember::ref() const { return *m_opaque_up; } SBTypeMemberFunction::SBTypeMemberFunction() : m_opaque_sp() {} diff --git a/lldb/source/API/SBTypeEnumMember.cpp b/lldb/source/API/SBTypeEnumMember.cpp index d8b70a43142..5ea28e40e67 100644 --- a/lldb/source/API/SBTypeEnumMember.cpp +++ b/lldb/source/API/SBTypeEnumMember.cpp @@ -85,22 +85,22 @@ const TypeEnumMemberImpl &SBTypeEnumMember::ref() const { } SBTypeEnumMemberList::SBTypeEnumMemberList() - : m_opaque_ap(new TypeEnumMemberListImpl()) {} + : m_opaque_up(new TypeEnumMemberListImpl()) {} SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs) - : m_opaque_ap(new TypeEnumMemberListImpl()) { + : m_opaque_up(new TypeEnumMemberListImpl()) { for (uint32_t i = 0, rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); i < rhs_size; i++) Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i)); } -bool SBTypeEnumMemberList::IsValid() { return (m_opaque_ap != NULL); } +bool SBTypeEnumMemberList::IsValid() { return (m_opaque_up != NULL); } SBTypeEnumMemberList &SBTypeEnumMemberList:: operator=(const SBTypeEnumMemberList &rhs) { if (this != &rhs) { - m_opaque_ap.reset(new TypeEnumMemberListImpl()); + m_opaque_up.reset(new TypeEnumMemberListImpl()); for (uint32_t i = 0, rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); i < rhs_size; i++) @@ -112,17 +112,17 @@ operator=(const SBTypeEnumMemberList &rhs) { void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) { if (enum_member.IsValid()) - m_opaque_ap->Append(enum_member.m_opaque_sp); + m_opaque_up->Append(enum_member.m_opaque_sp); } SBTypeEnumMember SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) { - if (m_opaque_ap) - return SBTypeEnumMember(m_opaque_ap->GetTypeEnumMemberAtIndex(index)); + if (m_opaque_up) + return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)); return SBTypeEnumMember(); } -uint32_t SBTypeEnumMemberList::GetSize() { return m_opaque_ap->GetSize(); } +uint32_t SBTypeEnumMemberList::GetSize() { return m_opaque_up->GetSize(); } SBTypeEnumMemberList::~SBTypeEnumMemberList() {} diff --git a/lldb/source/API/SBTypeSummary.cpp b/lldb/source/API/SBTypeSummary.cpp index 23c2781b79a..5c01522095f 100644 --- a/lldb/source/API/SBTypeSummary.cpp +++ b/lldb/source/API/SBTypeSummary.cpp @@ -18,62 +18,62 @@ using namespace lldb; using namespace lldb_private; SBTypeSummaryOptions::SBTypeSummaryOptions() { - m_opaque_ap.reset(new TypeSummaryOptions()); + m_opaque_up.reset(new TypeSummaryOptions()); } SBTypeSummaryOptions::SBTypeSummaryOptions( const lldb::SBTypeSummaryOptions &rhs) { - if (rhs.m_opaque_ap) - m_opaque_ap.reset(new TypeSummaryOptions(*rhs.m_opaque_ap)); + if (rhs.m_opaque_up) + m_opaque_up.reset(new TypeSummaryOptions(*rhs.m_opaque_up)); else - m_opaque_ap.reset(new TypeSummaryOptions()); + m_opaque_up.reset(new TypeSummaryOptions()); } SBTypeSummaryOptions::~SBTypeSummaryOptions() {} -bool SBTypeSummaryOptions::IsValid() { return m_opaque_ap.get(); } +bool SBTypeSummaryOptions::IsValid() { return m_opaque_up.get(); } lldb::LanguageType SBTypeSummaryOptions::GetLanguage() { if (IsValid()) - return m_opaque_ap->GetLanguage(); + return m_opaque_up->GetLanguage(); return lldb::eLanguageTypeUnknown; } lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() { if (IsValid()) - return m_opaque_ap->GetCapping(); + return m_opaque_up->GetCapping(); return eTypeSummaryCapped; } void SBTypeSummaryOptions::SetLanguage(lldb::LanguageType l) { if (IsValid()) - m_opaque_ap->SetLanguage(l); + m_opaque_up->SetLanguage(l); } void SBTypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping c) { if (IsValid()) - m_opaque_ap->SetCapping(c); + m_opaque_up->SetCapping(c); } lldb_private::TypeSummaryOptions *SBTypeSummaryOptions::operator->() { - return m_opaque_ap.get(); + return m_opaque_up.get(); } const lldb_private::TypeSummaryOptions *SBTypeSummaryOptions:: operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::TypeSummaryOptions *SBTypeSummaryOptions::get() { - return m_opaque_ap.get(); + return m_opaque_up.get(); } lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() { - return *m_opaque_ap; + return *m_opaque_up; } const lldb_private::TypeSummaryOptions &SBTypeSummaryOptions::ref() const { - return *m_opaque_ap; + return *m_opaque_up; } SBTypeSummaryOptions::SBTypeSummaryOptions( @@ -84,9 +84,9 @@ SBTypeSummaryOptions::SBTypeSummaryOptions( void SBTypeSummaryOptions::SetOptions( const lldb_private::TypeSummaryOptions *lldb_object_ptr) { if (lldb_object_ptr) - m_opaque_ap.reset(new TypeSummaryOptions(*lldb_object_ptr)); + m_opaque_up.reset(new TypeSummaryOptions(*lldb_object_ptr)); else - m_opaque_ap.reset(new TypeSummaryOptions()); + m_opaque_up.reset(new TypeSummaryOptions()); } SBTypeSummary::SBTypeSummary() : m_opaque_sp() {} diff --git a/lldb/source/API/SBValueList.cpp b/lldb/source/API/SBValueList.cpp index b03b86e415b..69af083b1bb 100644 --- a/lldb/source/API/SBValueList.cpp +++ b/lldb/source/API/SBValueList.cpp @@ -67,77 +67,77 @@ private: std::vector<lldb::SBValue> m_values; }; -SBValueList::SBValueList() : m_opaque_ap() {} +SBValueList::SBValueList() : m_opaque_up() {} -SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_ap() { +SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (rhs.IsValid()) - m_opaque_ap.reset(new ValueListImpl(*rhs)); + m_opaque_up.reset(new ValueListImpl(*rhs)); if (log) { log->Printf( "SBValueList::SBValueList (rhs.ap=%p) => this.ap = %p", - static_cast<void *>(rhs.IsValid() ? rhs.m_opaque_ap.get() : NULL), - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(rhs.IsValid() ? rhs.m_opaque_up.get() : NULL), + static_cast<void *>(m_opaque_up.get())); } } -SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_ap() { +SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); if (lldb_object_ptr) - m_opaque_ap.reset(new ValueListImpl(*lldb_object_ptr)); + m_opaque_up.reset(new ValueListImpl(*lldb_object_ptr)); if (log) { log->Printf("SBValueList::SBValueList (lldb_object_ptr=%p) => this.ap = %p", static_cast<const void *>(lldb_object_ptr), - static_cast<void *>(m_opaque_ap.get())); + static_cast<void *>(m_opaque_up.get())); } } SBValueList::~SBValueList() {} -bool SBValueList::IsValid() const { return (m_opaque_ap != NULL); } +bool SBValueList::IsValid() const { return (m_opaque_up != NULL); } -void SBValueList::Clear() { m_opaque_ap.reset(); } +void SBValueList::Clear() { m_opaque_up.reset(); } const SBValueList &SBValueList::operator=(const SBValueList &rhs) { if (this != &rhs) { if (rhs.IsValid()) - m_opaque_ap.reset(new ValueListImpl(*rhs)); + m_opaque_up.reset(new ValueListImpl(*rhs)); else - m_opaque_ap.reset(); + m_opaque_up.reset(); } return *this; } -ValueListImpl *SBValueList::operator->() { return m_opaque_ap.get(); } +ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); } -ValueListImpl &SBValueList::operator*() { return *m_opaque_ap; } +ValueListImpl &SBValueList::operator*() { return *m_opaque_up; } const ValueListImpl *SBValueList::operator->() const { - return m_opaque_ap.get(); + return m_opaque_up.get(); } -const ValueListImpl &SBValueList::operator*() const { return *m_opaque_ap; } +const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; } void SBValueList::Append(const SBValue &val_obj) { CreateIfNeeded(); - m_opaque_ap->Append(val_obj); + m_opaque_up->Append(val_obj); } void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) { if (val_obj_sp) { CreateIfNeeded(); - m_opaque_ap->Append(SBValue(val_obj_sp)); + m_opaque_up->Append(SBValue(val_obj_sp)); } } void SBValueList::Append(const lldb::SBValueList &value_list) { if (value_list.IsValid()) { CreateIfNeeded(); - m_opaque_ap->Append(*value_list); + m_opaque_up->Append(*value_list); } } @@ -149,15 +149,15 @@ SBValue SBValueList::GetValueAtIndex(uint32_t idx) const { // idx); SBValue sb_value; - if (m_opaque_ap) - sb_value = m_opaque_ap->GetValueAtIndex(idx); + if (m_opaque_up) + sb_value = m_opaque_up->GetValueAtIndex(idx); if (log) { SBStream sstr; sb_value.GetDescription(sstr); log->Printf("SBValueList::GetValueAtIndex (this.ap=%p, idx=%d) => SBValue " "(this.sp = %p, '%s')", - static_cast<void *>(m_opaque_ap.get()), idx, + static_cast<void *>(m_opaque_up.get()), idx, static_cast<void *>(sb_value.GetSP().get()), sstr.GetData()); } @@ -171,38 +171,38 @@ uint32_t SBValueList::GetSize() const { // log->Printf ("SBValueList::GetSize ()"); uint32_t size = 0; - if (m_opaque_ap) - size = m_opaque_ap->GetSize(); + if (m_opaque_up) + size = m_opaque_up->GetSize(); if (log) log->Printf("SBValueList::GetSize (this.ap=%p) => %d", - static_cast<void *>(m_opaque_ap.get()), size); + static_cast<void *>(m_opaque_up.get()), size); return size; } void SBValueList::CreateIfNeeded() { - if (m_opaque_ap == NULL) - m_opaque_ap.reset(new ValueListImpl()); + if (m_opaque_up == NULL) + m_opaque_up.reset(new ValueListImpl()); } SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) { SBValue sb_value; - if (m_opaque_ap) - sb_value = m_opaque_ap->FindValueByUID(uid); + if (m_opaque_up) + sb_value = m_opaque_up->FindValueByUID(uid); return sb_value; } SBValue SBValueList::GetFirstValueByName(const char *name) const { SBValue sb_value; - if (m_opaque_ap) - sb_value = m_opaque_ap->GetFirstValueByName(name); + if (m_opaque_up) + sb_value = m_opaque_up->GetFirstValueByName(name); return sb_value; } -void *SBValueList::opaque_ptr() { return m_opaque_ap.get(); } +void *SBValueList::opaque_ptr() { return m_opaque_up.get(); } ValueListImpl &SBValueList::ref() { CreateIfNeeded(); - return *m_opaque_ap; + return *m_opaque_up; } diff --git a/lldb/source/API/SBVariablesOptions.cpp b/lldb/source/API/SBVariablesOptions.cpp index 42eafaa8cd9..69c684d9962 100644 --- a/lldb/source/API/SBVariablesOptions.cpp +++ b/lldb/source/API/SBVariablesOptions.cpp @@ -80,98 +80,98 @@ private: }; SBVariablesOptions::SBVariablesOptions() - : m_opaque_ap(new VariablesOptionsImpl()) {} + : m_opaque_up(new VariablesOptionsImpl()) {} SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options) - : m_opaque_ap(new VariablesOptionsImpl(options.ref())) {} + : m_opaque_up(new VariablesOptionsImpl(options.ref())) {} SBVariablesOptions &SBVariablesOptions:: operator=(const SBVariablesOptions &options) { - m_opaque_ap.reset(new VariablesOptionsImpl(options.ref())); + m_opaque_up.reset(new VariablesOptionsImpl(options.ref())); return *this; } SBVariablesOptions::~SBVariablesOptions() = default; -bool SBVariablesOptions::IsValid() const { return m_opaque_ap != nullptr; } +bool SBVariablesOptions::IsValid() const { return m_opaque_up != nullptr; } bool SBVariablesOptions::GetIncludeArguments() const { - return m_opaque_ap->GetIncludeArguments(); + return m_opaque_up->GetIncludeArguments(); } void SBVariablesOptions::SetIncludeArguments(bool arguments) { - m_opaque_ap->SetIncludeArguments(arguments); + m_opaque_up->SetIncludeArguments(arguments); } bool SBVariablesOptions::GetIncludeRecognizedArguments( const lldb::SBTarget &target) const { - return m_opaque_ap->GetIncludeRecognizedArguments(target.GetSP()); + return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP()); } void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) { - m_opaque_ap->SetIncludeRecognizedArguments(arguments); + m_opaque_up->SetIncludeRecognizedArguments(arguments); } bool SBVariablesOptions::GetIncludeLocals() const { - return m_opaque_ap->GetIncludeLocals(); + return m_opaque_up->GetIncludeLocals(); } void SBVariablesOptions::SetIncludeLocals(bool locals) { - m_opaque_ap->SetIncludeLocals(locals); + m_opaque_up->SetIncludeLocals(locals); } bool SBVariablesOptions::GetIncludeStatics() const { - return m_opaque_ap->GetIncludeStatics(); + return m_opaque_up->GetIncludeStatics(); } void SBVariablesOptions::SetIncludeStatics(bool statics) { - m_opaque_ap->SetIncludeStatics(statics); + m_opaque_up->SetIncludeStatics(statics); } bool SBVariablesOptions::GetInScopeOnly() const { - return m_opaque_ap->GetInScopeOnly(); + return m_opaque_up->GetInScopeOnly(); } void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) { - m_opaque_ap->SetInScopeOnly(in_scope_only); + m_opaque_up->SetInScopeOnly(in_scope_only); } bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const { - return m_opaque_ap->GetIncludeRuntimeSupportValues(); + return m_opaque_up->GetIncludeRuntimeSupportValues(); } void SBVariablesOptions::SetIncludeRuntimeSupportValues( bool runtime_support_values) { - m_opaque_ap->SetIncludeRuntimeSupportValues(runtime_support_values); + m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values); } lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const { - return m_opaque_ap->GetUseDynamic(); + return m_opaque_up->GetUseDynamic(); } void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) { - m_opaque_ap->SetUseDynamic(dynamic); + m_opaque_up->SetUseDynamic(dynamic); } VariablesOptionsImpl *SBVariablesOptions::operator->() { - return m_opaque_ap.operator->(); + return m_opaque_up.operator->(); } const VariablesOptionsImpl *SBVariablesOptions::operator->() const { - return m_opaque_ap.operator->(); + return m_opaque_up.operator->(); } -VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_ap.get(); } +VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); } -VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_ap; } +VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; } const VariablesOptionsImpl &SBVariablesOptions::ref() const { - return *m_opaque_ap; + return *m_opaque_up; } SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr) - : m_opaque_ap(std::move(lldb_object_ptr)) {} + : m_opaque_up(std::move(lldb_object_ptr)) {} void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) { - m_opaque_ap.reset(std::move(lldb_object_ptr)); + m_opaque_up.reset(std::move(lldb_object_ptr)); } |
