contrib/llvm/tools/lldb/source/API/SBCommunication.cpp

   1 //===-- SBCommunication.cpp -------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/API/SBCommunication.h"
  11 #include "lldb/API/SBBroadcaster.h"
  12 #include "lldb/Core/Communication.h"
  13 #include "lldb/Host/ConnectionFileDescriptor.h"
  14 #include "lldb/Host/Host.h"
  15 #include "lldb/Utility/Log.h"
  16
  17 using namespace lldb;
  18 using namespace lldb_private;
  19
  20 SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {}
  21
  22 SBCommunication::SBCommunication(const char *broadcaster_name)
  23     : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
  24   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
  25
  26   if (log)
  27     log->Printf("SBCommunication::SBCommunication (broadcaster_name=\"%s\") => "
  28                 "SBCommunication(%p)",
  29                 broadcaster_name, static_cast<void *>(m_opaque));
  30 }
  31
  32 SBCommunication::~SBCommunication() {
  33   if (m_opaque && m_opaque_owned)
  34     delete m_opaque;
  35   m_opaque = NULL;
  36   m_opaque_owned = false;
  37 }
  38
  39 bool SBCommunication::IsValid() const { return m_opaque != NULL; }
  40
  41 bool SBCommunication::GetCloseOnEOF() {
  42   if (m_opaque)
  43     return m_opaque->GetCloseOnEOF();
  44   return false;
  45 }
  46
  47 void SBCommunication::SetCloseOnEOF(bool b) {
  48   if (m_opaque)
  49     m_opaque->SetCloseOnEOF(b);
  50 }
  51
  52 ConnectionStatus SBCommunication::Connect(const char *url) {
  53   if (m_opaque) {
  54     if (!m_opaque->HasConnection())
  55       m_opaque->SetConnection(Host::CreateDefaultConnection(url).release());
  56     return m_opaque->Connect(url, NULL);
  57   }
  58   return eConnectionStatusNoConnection;
  59 }
  60
  61 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
  62   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
  63
  64   ConnectionStatus status = eConnectionStatusNoConnection;
  65   if (m_opaque) {
  66     if (m_opaque->HasConnection()) {
  67       if (m_opaque->IsConnected())
  68         m_opaque->Disconnect();
  69     }
  70     m_opaque->SetConnection(new ConnectionFileDescriptor(fd, owns_fd));
  71     if (m_opaque->IsConnected())
  72       status = eConnectionStatusSuccess;
  73     else
  74       status = eConnectionStatusLostConnection;
  75   }
  76
  77   if (log)
  78     log->Printf(
  79         "SBCommunication(%p)::AdoptFileDescriptor (fd=%d, ownd_fd=%i) => %s",
  80         static_cast<void *>(m_opaque), fd, owns_fd,
  81         Communication::ConnectionStatusAsCString(status));
  82
  83   return status;
  84 }
  85
  86 ConnectionStatus SBCommunication::Disconnect() {
  87   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
  88
  89   ConnectionStatus status = eConnectionStatusNoConnection;
  90   if (m_opaque)
  91     status = m_opaque->Disconnect();
  92
  93   if (log)
  94     log->Printf("SBCommunication(%p)::Disconnect () => %s",
  95                 static_cast<void *>(m_opaque),
  96                 Communication::ConnectionStatusAsCString(status));
  97
  98   return status;
  99 }
 100
 101 bool SBCommunication::IsConnected() const {
 102   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 103   bool result = false;
 104   if (m_opaque)
 105     result = m_opaque->IsConnected();
 106
 107   if (log)
 108     log->Printf("SBCommunication(%p)::IsConnected () => %i",
 109                 static_cast<void *>(m_opaque), result);
 110
 111   return false;
 112 }
 113
 114 size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
 115                              ConnectionStatus &status) {
 116   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 117   if (log)
 118     log->Printf("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64
 119                 ", timeout_usec=%u, &status)...",
 120                 static_cast<void *>(m_opaque), static_cast<void *>(dst),
 121                 static_cast<uint64_t>(dst_len), timeout_usec);
 122   size_t bytes_read = 0;
 123   Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
 124                                     ? Timeout<std::micro>(llvm::None)
 125                                     : std::chrono::microseconds(timeout_usec);
 126   if (m_opaque)
 127     bytes_read = m_opaque->Read(dst, dst_len, timeout, status, NULL);
 128   else
 129     status = eConnectionStatusNoConnection;
 130
 131   if (log)
 132     log->Printf("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64
 133                 ", timeout_usec=%u, &status=%s) => %" PRIu64,
 134                 static_cast<void *>(m_opaque), static_cast<void *>(dst),
 135                 static_cast<uint64_t>(dst_len), timeout_usec,
 136                 Communication::ConnectionStatusAsCString(status),
 137                 static_cast<uint64_t>(bytes_read));
 138   return bytes_read;
 139 }
 140
 141 size_t SBCommunication::Write(const void *src, size_t src_len,
 142                               ConnectionStatus &status) {
 143   size_t bytes_written = 0;
 144   if (m_opaque)
 145     bytes_written = m_opaque->Write(src, src_len, status, NULL);
 146   else
 147     status = eConnectionStatusNoConnection;
 148
 149   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 150   if (log)
 151     log->Printf("SBCommunication(%p)::Write (src=%p, src_len=%" PRIu64
 152                 ", &status=%s) => %" PRIu64,
 153                 static_cast<void *>(m_opaque), static_cast<const void *>(src),
 154                 static_cast<uint64_t>(src_len),
 155                 Communication::ConnectionStatusAsCString(status),
 156                 static_cast<uint64_t>(bytes_written));
 157
 158   return 0;
 159 }
 160
 161 bool SBCommunication::ReadThreadStart() {
 162   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 163
 164   bool success = false;
 165   if (m_opaque)
 166     success = m_opaque->StartReadThread();
 167
 168   if (log)
 169     log->Printf("SBCommunication(%p)::ReadThreadStart () => %i",
 170                 static_cast<void *>(m_opaque), success);
 171
 172   return success;
 173 }
 174
 175 bool SBCommunication::ReadThreadStop() {
 176   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 177   if (log)
 178     log->Printf("SBCommunication(%p)::ReadThreadStop ()...",
 179                 static_cast<void *>(m_opaque));
 180
 181   bool success = false;
 182   if (m_opaque)
 183     success = m_opaque->StopReadThread();
 184
 185   if (log)
 186     log->Printf("SBCommunication(%p)::ReadThreadStop () => %i",
 187                 static_cast<void *>(m_opaque), success);
 188
 189   return success;
 190 }
 191
 192 bool SBCommunication::ReadThreadIsRunning() {
 193   bool result = false;
 194   if (m_opaque)
 195     result = m_opaque->ReadThreadIsRunning();
 196   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 197   if (log)
 198     log->Printf("SBCommunication(%p)::ReadThreadIsRunning () => %i",
 199                 static_cast<void *>(m_opaque), result);
 200   return result;
 201 }
 202
 203 bool SBCommunication::SetReadThreadBytesReceivedCallback(
 204     ReadThreadBytesReceived callback, void *callback_baton) {
 205   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 206
 207   bool result = false;
 208   if (m_opaque) {
 209     m_opaque->SetReadThreadBytesReceivedCallback(callback, callback_baton);
 210     result = true;
 211   }
 212
 213   if (log)
 214     log->Printf("SBCommunication(%p)::SetReadThreadBytesReceivedCallback "
 215                 "(callback=%p, baton=%p) => %i",
 216                 static_cast<void *>(m_opaque),
 217                 reinterpret_cast<void *>(reinterpret_cast<intptr_t>(callback)),
 218                 static_cast<void *>(callback_baton), result);
 219
 220   return result;
 221 }
 222
 223 SBBroadcaster SBCommunication::GetBroadcaster() {
 224   SBBroadcaster broadcaster(m_opaque, false);
 225
 226   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 227
 228   if (log)
 229     log->Printf("SBCommunication(%p)::GetBroadcaster () => SBBroadcaster (%p)",
 230                 static_cast<void *>(m_opaque),
 231                 static_cast<void *>(broadcaster.get()));
 232
 233   return broadcaster;
 234 }
 235
 236 const char *SBCommunication::GetBroadcasterClass() {
 237   return Communication::GetStaticBroadcasterClass().AsCString();
 238 }
 239
 240 //
 241 // void
 242 // SBCommunication::CreateIfNeeded ()
 243 //{
 244 //    if (m_opaque == NULL)
 245 //    {
 246 //        static uint32_t g_broadcaster_num;
 247 //        char broadcaster_name[256];
 248 //        ::snprintf (name, broadcaster_name, "%p SBCommunication", this);
 249 //        m_opaque = new Communication (broadcaster_name);
 250 //        m_opaque_owned = true;
 251 //    }
 252 //    assert (m_opaque);
 253 //}
 254 //
 255 //