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, 60 insertions, 60 deletions

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);
 }