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

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

1 files changed, 38 insertions, 38 deletions

diff --git a/lldb/source/API/SBError.cpp b/lldb/source/API/SBError.cpp
index 5220ac4d30b3..2eca5463935b 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();