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

   1 //===-- SBInputReader.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
  11 #include "lldb/lldb-enumerations.h"
  12
  13 #include "lldb/API/SBDebugger.h"
  14 #include "lldb/API/SBError.h"
  15 #include "lldb/API/SBInputReader.h"
  16 #include "lldb/API/SBStream.h"
  17 #include "lldb/API/SBStringList.h"
  18 #include "lldb/Core/InputReader.h"
  19 #include "lldb/Core/Log.h"
  20
  21
  22 using namespace lldb;
  23 using namespace lldb_private;
  24
  25 SBInputReader::SBInputReader ()  :
  26     m_opaque_sp (),
  27     m_callback_function (NULL),
  28     m_callback_baton (NULL)
  29
  30 {
  31 }
  32
  33 SBInputReader::SBInputReader (const lldb::InputReaderSP &reader_sp) :
  34     m_opaque_sp (reader_sp)
  35 {
  36     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  37
  38     if (log)
  39         log->Printf ("SBInputReader::SBInputReader (reader_sp=%p) => SBInputReader(%p)", reader_sp.get(),
  40                      m_opaque_sp.get());
  41 }
  42
  43 SBInputReader::SBInputReader (const SBInputReader &rhs) :
  44     m_opaque_sp (rhs.m_opaque_sp)
  45 {
  46     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  47
  48     if (log)
  49         log->Printf("SBInputReader::SBInputReader (rhs.sp=%p) => SBInputReader(%p)",
  50                     rhs.m_opaque_sp.get(), m_opaque_sp.get());
  51 }
  52
  53 SBInputReader::~SBInputReader ()
  54 {
  55 }
  56
  57 size_t
  58 SBInputReader::PrivateCallback
  59 (
  60     void *baton,
  61     InputReader &reader,
  62     lldb::InputReaderAction notification,
  63     const char *bytes,
  64     size_t bytes_len
  65 )
  66 {
  67     SBInputReader *sb_reader = (SBInputReader *)baton;
  68     return sb_reader->m_callback_function (sb_reader->m_callback_baton,
  69                                            sb_reader,
  70                                            notification,
  71                                            bytes,
  72                                            bytes_len);
  73 }
  74
  75 SBError
  76 SBInputReader::Initialize
  77 (
  78     SBDebugger &debugger,
  79     Callback callback_function,
  80     void *callback_baton,
  81     lldb::InputReaderGranularity granularity,
  82     const char *end_token,
  83     const char *prompt,
  84     bool echo
  85 )
  86 {
  87     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  88
  89     if (log)
  90         log->Printf("SBInputReader(%p)::Initialize (SBDebugger(%p), callback_function=%p, callback_baton=%p, "
  91                     "granularity=%s, end_token=\"%s\", prompt=\"%s\", echo=%i)",
  92                     m_opaque_sp.get(),
  93                     debugger.get(),
  94                     callback_function,
  95                     callback_baton,
  96                     InputReader::GranularityAsCString (granularity), end_token, prompt,
  97                     echo);
  98
  99     SBError sb_error;
 100     m_opaque_sp.reset (new InputReader (debugger.ref()));
 101
 102     m_callback_function = callback_function;
 103     m_callback_baton = callback_baton;
 104
 105     if (m_opaque_sp)
 106     {
 107         sb_error.SetError (m_opaque_sp->Initialize (SBInputReader::PrivateCallback,
 108                                                     this,
 109                                                     granularity,
 110                                                     end_token,
 111                                                     prompt,
 112                                                     echo));
 113     }
 114
 115     if (sb_error.Fail())
 116     {
 117         m_opaque_sp.reset ();
 118         m_callback_function = NULL;
 119         m_callback_baton = NULL;
 120     }
 121
 122     if (log)
 123     {
 124         SBStream sstr;
 125         sb_error.GetDescription (sstr);
 126         log->Printf ("SBInputReader(%p)::Initialize (...) => SBError(%p): %s", m_opaque_sp.get(),
 127                      sb_error.get(), sstr.GetData());
 128     }
 129
 130     return sb_error;
 131 }
 132
 133 bool
 134 SBInputReader::IsValid () const
 135 {
 136     return (m_opaque_sp.get() != NULL);
 137 }
 138
 139 const SBInputReader &
 140 SBInputReader::operator = (const SBInputReader &rhs)
 141 {
 142     if (this != &rhs)
 143         m_opaque_sp = rhs.m_opaque_sp;
 144     return *this;
 145 }
 146
 147 InputReader *
 148 SBInputReader::operator->() const
 149 {
 150     return m_opaque_sp.get();
 151 }
 152
 153 lldb::InputReaderSP &
 154 SBInputReader::operator *()
 155 {
 156     return m_opaque_sp;
 157 }
 158
 159 const lldb::InputReaderSP &
 160 SBInputReader::operator *() const
 161 {
 162     return m_opaque_sp;
 163 }
 164
 165 InputReader *
 166 SBInputReader::get() const
 167 {
 168     return m_opaque_sp.get();
 169 }
 170
 171 InputReader &
 172 SBInputReader::ref() const
 173 {
 174     assert (m_opaque_sp.get());
 175     return *m_opaque_sp;
 176 }
 177
 178 bool
 179 SBInputReader::IsDone () const
 180 {
 181     if (m_opaque_sp)
 182         return m_opaque_sp->IsDone();
 183     else
 184         return true;
 185 }
 186
 187 void
 188 SBInputReader::SetIsDone (bool value)
 189 {
 190     if (m_opaque_sp)
 191         m_opaque_sp->SetIsDone (value);
 192 }
 193
 194 bool
 195 SBInputReader::IsActive () const
 196 {
 197     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 198
 199     bool ret_value = false;
 200     if (m_opaque_sp)
 201         ret_value = m_opaque_sp->IsActive();
 202
 203     if (log)
 204         log->Printf ("SBInputReader(%p)::IsActive () => %i", m_opaque_sp.get(), ret_value);
 205
 206     return ret_value;
 207 }
 208
 209 InputReaderGranularity
 210 SBInputReader::GetGranularity ()
 211 {
 212     if (m_opaque_sp)
 213         return m_opaque_sp->GetGranularity();
 214     else
 215         return eInputReaderGranularityInvalid;
 216 }