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/Core/Log.h"
  14 #include "lldb/Host/ConnectionFileDescriptor.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19
  20
  21 SBCommunication::SBCommunication() :
  22     m_opaque (NULL),
  23     m_opaque_owned (false)
  24 {
  25 }
  26
  27 SBCommunication::SBCommunication(const char * broadcaster_name) :
  28     m_opaque (new Communication (broadcaster_name)),
  29     m_opaque_owned (true)
  30 {
  31     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  32
  33     if (log)
  34         log->Printf ("SBCommunication::SBCommunication (broadcaster_name=\"%s\") => "
  35                      "SBCommunication(%p)", broadcaster_name,
  36                      static_cast<void*>(m_opaque));
  37 }
  38
  39 SBCommunication::~SBCommunication()
  40 {
  41     if (m_opaque && m_opaque_owned)
  42         delete m_opaque;
  43     m_opaque = NULL;
  44     m_opaque_owned = false;
  45 }
  46
  47 bool
  48 SBCommunication::IsValid () const
  49 {
  50     return m_opaque != NULL;
  51 }
  52
  53 bool
  54 SBCommunication::GetCloseOnEOF ()
  55 {
  56     if (m_opaque)
  57         return m_opaque->GetCloseOnEOF ();
  58     return false;
  59 }
  60
  61 void
  62 SBCommunication::SetCloseOnEOF (bool b)
  63 {
  64     if (m_opaque)
  65         m_opaque->SetCloseOnEOF (b);
  66 }
  67
  68 ConnectionStatus
  69 SBCommunication::Connect (const char *url)
  70 {
  71     if (m_opaque)
  72     {
  73         if (!m_opaque->HasConnection ())
  74             m_opaque->SetConnection(Connection::CreateDefaultConnection(url));
  75         return m_opaque->Connect (url, NULL);
  76     }
  77     return eConnectionStatusNoConnection;
  78 }
  79
  80 ConnectionStatus
  81 SBCommunication::AdoptFileDesriptor (int fd, bool owns_fd)
  82 {
  83     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  84
  85     ConnectionStatus status = eConnectionStatusNoConnection;
  86     if (m_opaque)
  87     {
  88         if (m_opaque->HasConnection ())
  89         {
  90             if (m_opaque->IsConnected())
  91                 m_opaque->Disconnect();
  92         }
  93         m_opaque->SetConnection (new ConnectionFileDescriptor (fd, owns_fd));
  94         if (m_opaque->IsConnected())
  95             status = eConnectionStatusSuccess;
  96         else
  97             status = eConnectionStatusLostConnection;
  98     }
  99
 100     if (log)
 101         log->Printf ("SBCommunication(%p)::AdoptFileDescriptor (fd=%d, ownd_fd=%i) => %s",
 102                      static_cast<void*>(m_opaque), fd, owns_fd,
 103                      Communication::ConnectionStatusAsCString (status));
 104
 105     return status;
 106 }
 107
 108
 109 ConnectionStatus
 110 SBCommunication::Disconnect ()
 111 {
 112     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 113
 114     ConnectionStatus status= eConnectionStatusNoConnection;
 115     if (m_opaque)
 116         status = m_opaque->Disconnect ();
 117
 118     if (log)
 119         log->Printf ("SBCommunication(%p)::Disconnect () => %s",
 120                      static_cast<void*>(m_opaque),
 121                      Communication::ConnectionStatusAsCString (status));
 122
 123     return status;
 124 }
 125
 126 bool
 127 SBCommunication::IsConnected () const
 128 {
 129     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 130     bool result = false;
 131     if (m_opaque)
 132         result = m_opaque->IsConnected ();
 133
 134     if (log)
 135         log->Printf ("SBCommunication(%p)::IsConnected () => %i",
 136                      static_cast<void*>(m_opaque), result);
 137
 138     return false;
 139 }
 140
 141 size_t
 142 SBCommunication::Read (void *dst, size_t dst_len, uint32_t timeout_usec, ConnectionStatus &status)
 143 {
 144     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 145     if (log)
 146         log->Printf ("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64 ", timeout_usec=%u, &status)...",
 147                      static_cast<void*>(m_opaque), static_cast<void*>(dst),
 148                      static_cast<uint64_t>(dst_len), timeout_usec);
 149     size_t bytes_read = 0;
 150     if (m_opaque)
 151         bytes_read = m_opaque->Read (dst, dst_len, timeout_usec, status, NULL);
 152     else
 153         status = eConnectionStatusNoConnection;
 154
 155     if (log)
 156         log->Printf ("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64 ", timeout_usec=%u, &status=%s) => %" PRIu64,
 157                      static_cast<void*>(m_opaque), static_cast<void*>(dst),
 158                      static_cast<uint64_t>(dst_len), timeout_usec,
 159                      Communication::ConnectionStatusAsCString (status),
 160                      static_cast<uint64_t>(bytes_read));
 161     return bytes_read;
 162 }
 163
 164
 165 size_t
 166 SBCommunication::Write (const void *src, size_t src_len, ConnectionStatus &status)
 167 {
 168     size_t bytes_written = 0;
 169     if (m_opaque)
 170         bytes_written = m_opaque->Write (src, src_len, status, NULL);
 171     else
 172         status = eConnectionStatusNoConnection;
 173
 174     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 175     if (log)
 176         log->Printf ("SBCommunication(%p)::Write (src=%p, src_len=%" PRIu64 ", &status=%s) => %" PRIu64,
 177                      static_cast<void*>(m_opaque), static_cast<const void*>(src),
 178                      static_cast<uint64_t>(src_len),
 179                      Communication::ConnectionStatusAsCString (status),
 180                      static_cast<uint64_t>(bytes_written));
 181
 182     return 0;
 183 }
 184
 185 bool
 186 SBCommunication::ReadThreadStart ()
 187 {
 188     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 189
 190     bool success = false;
 191     if (m_opaque)
 192         success = m_opaque->StartReadThread ();
 193
 194     if (log)
 195         log->Printf ("SBCommunication(%p)::ReadThreadStart () => %i",
 196                      static_cast<void*>(m_opaque), success);
 197
 198     return success;
 199 }
 200
 201
 202 bool
 203 SBCommunication::ReadThreadStop ()
 204 {
 205     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 206     if (log)
 207         log->Printf ("SBCommunication(%p)::ReadThreadStop ()...",
 208                      static_cast<void*>(m_opaque));
 209
 210     bool success = false;
 211     if (m_opaque)
 212         success = m_opaque->StopReadThread ();
 213
 214     if (log)
 215         log->Printf ("SBCommunication(%p)::ReadThreadStop () => %i",
 216                      static_cast<void*>(m_opaque), success);
 217
 218     return success;
 219 }
 220
 221 bool
 222 SBCommunication::ReadThreadIsRunning ()
 223 {
 224     bool result = false;
 225     if (m_opaque)
 226         result = m_opaque->ReadThreadIsRunning ();
 227     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 228     if (log)
 229         log->Printf ("SBCommunication(%p)::ReadThreadIsRunning () => %i",
 230                      static_cast<void*>(m_opaque), result);
 231     return result;
 232 }
 233
 234 bool
 235 SBCommunication::SetReadThreadBytesReceivedCallback
 236 (
 237     ReadThreadBytesReceived callback,
 238     void *callback_baton
 239 )
 240 {
 241     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 242
 243     bool result = false;
 244     if (m_opaque)
 245     {
 246         m_opaque->SetReadThreadBytesReceivedCallback (callback, callback_baton);
 247         result = true;
 248     }
 249
 250     if (log)
 251         log->Printf ("SBCommunication(%p)::SetReadThreadBytesReceivedCallback (callback=%p, baton=%p) => %i",
 252                      static_cast<void*>(m_opaque),
 253                      reinterpret_cast<void*>(reinterpret_cast<intptr_t>(callback)),
 254                      static_cast<void*>(callback_baton), result);
 255
 256     return result;
 257 }
 258
 259 SBBroadcaster
 260 SBCommunication::GetBroadcaster ()
 261 {
 262     SBBroadcaster broadcaster (m_opaque, false);
 263
 264     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 265
 266     if (log)
 267         log->Printf ("SBCommunication(%p)::GetBroadcaster () => SBBroadcaster (%p)",
 268                      static_cast<void*>(m_opaque),
 269                      static_cast<void*>(broadcaster.get()));
 270
 271     return broadcaster;
 272 }
 273
 274 const char *
 275 SBCommunication::GetBroadcasterClass ()
 276 {
 277     return Communication::GetStaticBroadcasterClass().AsCString();
 278 }
 279
 280 //
 281 //void
 282 //SBCommunication::CreateIfNeeded ()
 283 //{
 284 //    if (m_opaque == NULL)
 285 //    {
 286 //        static uint32_t g_broadcaster_num;
 287 //        char broadcaster_name[256];
 288 //        ::snprintf (name, broadcaster_name, "%p SBCommunication", this);
 289 //        m_opaque = new Communication (broadcaster_name);
 290 //        m_opaque_owned = true;
 291 //    }
 292 //    assert (m_opaque);
 293 //}
 294 //
 295 //