caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace 'ap' with 'up' suffix in variable names. (NFC)

Browse Source 
The `ap` suffix is a remnant of lldb's former use of auto pointers,
before they got deprecated. Although all their uses were replaced by
unique pointers, some variables still carried the suffix.

In r353795 I removed another auto_ptr remnant, namely redundant calls to
::get for unique_pointers. Jim justly noted that this is a good
opportunity to clean up the variable names as well.

I went over all the changes to ensure my find-and-replace didn't have
any undesired side-effects. I hope I didn't miss any, but if you end up
at this commit doing a git blame on a weirdly named variable, please
know that the change was unintentional.

llvm-svn: 353912
This commit is contained in:
Jonas Devlieghere
2019-02-13 06:25:41 +00:00
parent 5cf777e413
commit d5b440369d
190 changed files with 1963 additions and 1959 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
lldb/source/API/SBError.cpp
View File

@@ -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();