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
14using namespace lldb;
15using namespace lldb_private;
16
17SBFile::~SBFile() = default;
18
19SBFile::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
25SBFile::SBFile(const SBFile &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
26  LLDB_INSTRUMENT_VA(this, rhs);
27}
28
29SBFile &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
37SBFile::SBFile() { LLDB_INSTRUMENT_VA(this); }
38
39SBFile::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
45SBFile::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
57SBError 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
72SBError 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
88SBError 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
101bool SBFile::IsValid() const {
102  LLDB_INSTRUMENT_VA(this);
103  return m_opaque_sp && m_opaque_sp->IsValid();
104}
105
106SBError 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
116SBFile::operator bool() const {
117  LLDB_INSTRUMENT_VA(this);
118  return IsValid();
119}
120
121bool SBFile::operator!() const {
122  LLDB_INSTRUMENT_VA(this);
123  return !IsValid();
124}
125
126FileSP SBFile::GetFile() const {
127  LLDB_INSTRUMENT_VA(this);
128  return m_opaque_sp;
129}
130