lldb/source/API/SBStream.cpp

   1 //===-- SBStream.cpp ------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/API/SBStream.h"
  10
  11 #include "lldb/API/SBFile.h"
  12 #include "lldb/Host/FileSystem.h"
  13 #include "lldb/Host/StreamFile.h"
  14 #include "lldb/Utility/Instrumentation.h"
  15 #include "lldb/Utility/LLDBLog.h"
  16 #include "lldb/Utility/Status.h"
  17 #include "lldb/Utility/Stream.h"
  18 #include "lldb/Utility/StreamString.h"
  19
  20 using namespace lldb;
  21 using namespace lldb_private;
  22
  23 SBStream::SBStream() : m_opaque_up(new StreamString()) {
  24   LLDB_INSTRUMENT_VA(this);
  25 }
  26
  27 SBStream::SBStream(SBStream &&rhs)
  28     : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {}
  29
  30 SBStream::~SBStream() = default;
  31
  32 bool SBStream::IsValid() const {
  33   LLDB_INSTRUMENT_VA(this);
  34   return this->operator bool();
  35 }
  36 SBStream::operator bool() const {
  37   LLDB_INSTRUMENT_VA(this);
  38
  39   return (m_opaque_up != nullptr);
  40 }
  41
  42 // If this stream is not redirected to a file, it will maintain a local cache
  43 // for the stream data which can be accessed using this accessor.
  44 const char *SBStream::GetData() {
  45   LLDB_INSTRUMENT_VA(this);
  46
  47   if (m_is_file || m_opaque_up == nullptr)
  48     return nullptr;
  49
  50   return ConstString(static_cast<StreamString *>(m_opaque_up.get())->GetData())
  51       .GetCString();
  52 }
  53
  54 // If this stream is not redirected to a file, it will maintain a local cache
  55 // for the stream output whose length can be accessed using this accessor.
  56 size_t SBStream::GetSize() {
  57   LLDB_INSTRUMENT_VA(this);
  58
  59   if (m_is_file || m_opaque_up == nullptr)
  60     return 0;
  61
  62   return static_cast<StreamString *>(m_opaque_up.get())->GetSize();
  63 }
  64
  65 void SBStream::Print(const char *str) {
  66   LLDB_INSTRUMENT_VA(this, str);
  67
  68   Printf("%s", str);
  69 }
  70
  71 void SBStream::Printf(const char *format, ...) {
  72   if (!format)
  73     return;
  74   va_list args;
  75   va_start(args, format);
  76   ref().PrintfVarArg(format, args);
  77   va_end(args);
  78 }
  79
  80 void SBStream::RedirectToFile(const char *path, bool append) {
  81   LLDB_INSTRUMENT_VA(this, path, append);
  82
  83   if (path == nullptr)
  84     return;
  85
  86   std::string local_data;
  87   if (m_opaque_up) {
  88     // See if we have any locally backed data. If so, copy it so we can then
  89     // redirect it to the file so we don't lose the data
  90     if (!m_is_file)
  91       local_data = std::string(
  92           static_cast<StreamString *>(m_opaque_up.get())->GetString());
  93   }
  94   auto open_options = File::eOpenOptionWriteOnly | File::eOpenOptionCanCreate;
  95   if (append)
  96     open_options |= File::eOpenOptionAppend;
  97   else
  98     open_options |= File::eOpenOptionTruncate;
  99
 100   llvm::Expected<FileUP> file =
 101       FileSystem::Instance().Open(FileSpec(path), open_options);
 102   if (!file) {
 103     LLDB_LOG_ERROR(GetLog(LLDBLog::API), file.takeError(),
 104                    "Cannot open {1}: {0}", path);
 105     return;
 106   }
 107
 108   m_opaque_up = std::make_unique<StreamFile>(std::move(file.get()));
 109   m_is_file = true;
 110
 111   // If we had any data locally in our StreamString, then pass that along to
 112   // the to new file we are redirecting to.
 113   if (!local_data.empty())
 114     m_opaque_up->Write(&local_data[0], local_data.size());
 115 }
 116
 117 void SBStream::RedirectToFileHandle(FILE *fh, bool transfer_fh_ownership) {
 118   LLDB_INSTRUMENT_VA(this, fh, transfer_fh_ownership);
 119   FileSP file = std::make_unique<NativeFile>(fh, transfer_fh_ownership);
 120   return RedirectToFile(file);
 121 }
 122
 123 void SBStream::RedirectToFile(SBFile file) {
 124   LLDB_INSTRUMENT_VA(this, file)
 125   RedirectToFile(file.GetFile());
 126 }
 127
 128 void SBStream::RedirectToFile(FileSP file_sp) {
 129   LLDB_INSTRUMENT_VA(this, file_sp);
 130
 131   if (!file_sp || !file_sp->IsValid())
 132     return;
 133
 134   std::string local_data;
 135   if (m_opaque_up) {
 136     // See if we have any locally backed data. If so, copy it so we can then
 137     // redirect it to the file so we don't lose the data
 138     if (!m_is_file)
 139       local_data = std::string(
 140           static_cast<StreamString *>(m_opaque_up.get())->GetString());
 141   }
 142
 143   m_opaque_up = std::make_unique<StreamFile>(file_sp);
 144   m_is_file = true;
 145
 146   // If we had any data locally in our StreamString, then pass that along to
 147   // the to new file we are redirecting to.
 148   if (!local_data.empty())
 149     m_opaque_up->Write(&local_data[0], local_data.size());
 150 }
 151
 152 void SBStream::RedirectToFileDescriptor(int fd, bool transfer_fh_ownership) {
 153   LLDB_INSTRUMENT_VA(this, fd, transfer_fh_ownership);
 154
 155   std::string local_data;
 156   if (m_opaque_up) {
 157     // See if we have any locally backed data. If so, copy it so we can then
 158     // redirect it to the file so we don't lose the data
 159     if (!m_is_file)
 160       local_data = std::string(
 161           static_cast<StreamString *>(m_opaque_up.get())->GetString());
 162   }
 163
 164   m_opaque_up = std::make_unique<StreamFile>(fd, transfer_fh_ownership);
 165   m_is_file = true;
 166
 167   // If we had any data locally in our StreamString, then pass that along to
 168   // the to new file we are redirecting to.
 169   if (!local_data.empty())
 170     m_opaque_up->Write(&local_data[0], local_data.size());
 171 }
 172
 173 lldb_private::Stream *SBStream::operator->() { return m_opaque_up.get(); }
 174
 175 lldb_private::Stream *SBStream::get() { return m_opaque_up.get(); }
 176
 177 lldb_private::Stream &SBStream::ref() {
 178   if (m_opaque_up == nullptr)
 179     m_opaque_up = std::make_unique<StreamString>();
 180   return *m_opaque_up;
 181 }
 182
 183 void SBStream::Clear() {
 184   LLDB_INSTRUMENT_VA(this);
 185
 186   if (m_opaque_up) {
 187     // See if we have any locally backed data. If so, copy it so we can then
 188     // redirect it to the file so we don't lose the data
 189     if (m_is_file)
 190       m_opaque_up.reset();
 191     else
 192       static_cast<StreamString *>(m_opaque_up.get())->Clear();
 193   }
 194 }