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 } 195