1 //===-- SBFile.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/SBFile.h"
10 #include "lldb/API/SBError.h"
11 #include "lldb/Host/File.h"
12 #include "lldb/Utility/Instrumentation.h"
13 
14 using namespace lldb;
15 using namespace lldb_private;
16 
17 SBFile::~SBFile() = default;
18 
19 SBFile::SBFile(FileSP file_sp) : m_opaque_sp(file_sp) {
20   // We have no way to capture the incoming FileSP as the class isn't
21   // instrumented, so pretend that it's always null.
22   LLDB_INSTRUMENT_VA(this, file_sp);
23 }
24 
25 SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
26   LLDB_INSTRUMENT_VA(this, rhs);
27 }
28 
29 SBFile &SBFile ::operator=(const SBFile &rhs) {
30   LLDB_INSTRUMENT_VA(this, rhs);
31 
32   if (this != &rhs)
33     m_opaque_sp = rhs.m_opaque_sp;
34   return *this;
35 }
36 
37 SBFile::SBFile() { LLDB_INSTRUMENT_VA(this); }
38 
39 SBFile::SBFile(FILE *file, bool transfer_ownership) {
40   LLDB_INSTRUMENT_VA(this, file, transfer_ownership);
41 
42   m_opaque_sp = std::make_shared<NativeFile>(file, transfer_ownership);
43 }
44 
45 SBFile::SBFile(int fd, const char *mode, bool transfer_owndership) {
46   LLDB_INSTRUMENT_VA(this, fd, mode, transfer_owndership);
47 
48   auto options = File::GetOptionsFromMode(mode);
49   if (!options) {
50     llvm::consumeError(options.takeError());
51     return;
52   }
53   m_opaque_sp =
54       std::make_shared<NativeFile>(fd, options.get(), transfer_owndership);
55 }
56 
57 SBError SBFile::Read(uint8_t *buf, size_t num_bytes, size_t *bytes_read) {
58   LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_read);
59 
60   SBError error;
61   if (!m_opaque_sp) {
62     error.SetErrorString("invalid SBFile");
63     *bytes_read = 0;
64   } else {
65     Status status = m_opaque_sp->Read(buf, num_bytes);
66     error.SetError(status);
67     *bytes_read = num_bytes;
68   }
69   return error;
70 }
71 
72 SBError SBFile::Write(const uint8_t *buf, size_t num_bytes,
73                       size_t *bytes_written) {
74   LLDB_INSTRUMENT_VA(this, buf, num_bytes, bytes_written);
75 
76   SBError error;
77   if (!m_opaque_sp) {
78     error.SetErrorString("invalid SBFile");
79     *bytes_written = 0;
80   } else {
81     Status status = m_opaque_sp->Write(buf, num_bytes);
82     error.SetError(status);
83     *bytes_written = num_bytes;
84   }
85   return error;
86 }
87 
88 SBError SBFile::Flush() {
89   LLDB_INSTRUMENT_VA(this);
90 
91   SBError error;
92   if (!m_opaque_sp) {
93     error.SetErrorString("invalid SBFile");
94   } else {
95     Status status = m_opaque_sp->Flush();
96     error.SetError(status);
97   }
98   return error;
99 }
100 
101 bool SBFile::IsValid() const {
102   LLDB_INSTRUMENT_VA(this);
103   return m_opaque_sp && m_opaque_sp->IsValid();
104 }
105 
106 SBError SBFile::Close() {
107   LLDB_INSTRUMENT_VA(this);
108   SBError error;
109   if (m_opaque_sp) {
110     Status status = m_opaque_sp->Close();
111     error.SetError(status);
112   }
113   return error;
114 }
115 
116 SBFile::operator bool() const {
117   LLDB_INSTRUMENT_VA(this);
118   return IsValid();
119 }
120 
121 bool SBFile::operator!() const {
122   LLDB_INSTRUMENT_VA(this);
123   return !IsValid();
124 }
125 
126 FileSP SBFile::GetFile() const {
127   LLDB_INSTRUMENT_VA(this);
128   return m_opaque_sp;
129 }
130