1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
/*
* Copyright (c) 2020, the SerenityOS developers.
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Stream.h>
#ifndef KERNEL
# include <errno.h>
# include <stdio.h>
namespace AK {
class InputFileStream : public InputStream {
public:
explicit InputFileStream(int fd)
: m_file(fdopen(fd, "r"))
, m_owned(true)
{
if (!m_file)
set_fatal_error();
}
explicit InputFileStream(FILE* fp)
: m_file(fp)
{
if (!m_file)
set_fatal_error();
}
~InputFileStream()
{
if (m_file) {
fflush(m_file);
if (m_owned)
fclose(m_file);
}
}
bool unreliable_eof() const override { return eof(); }
bool eof() const { return feof(m_file); }
size_t read(Bytes bytes) override
{
if (has_any_error())
return 0;
return fread(bytes.data(), sizeof(u8), bytes.size(), m_file);
}
bool read_or_error(Bytes bytes) override
{
if (has_any_error())
return false;
auto size = read(bytes);
if (size < bytes.size()) {
set_recoverable_error();
return false;
}
return true;
}
bool discard_or_error(size_t count) override
{
if (fseek(m_file, count, SEEK_CUR) == 0)
return true;
// TODO: Why not ferror(m_file)?
if (errno != ESPIPE)
return false;
char buf[4];
size_t i = 0;
while (i < count) {
auto size = min(count - i, 4ul);
if (read({ buf, size }) < size) {
// Can't reset here.
return false;
}
i += size;
}
return true;
}
bool seek(size_t offset, int whence = SEEK_SET)
{
return fseek(m_file, offset, whence) == 0;
}
virtual bool handle_any_error() override
{
clearerr(m_file);
return Stream::handle_any_error();
}
void make_unbuffered()
{
setvbuf(m_file, nullptr, _IONBF, 0);
}
private:
FILE* m_file { nullptr };
bool m_owned { false };
};
class OutputFileStream : public OutputStream {
public:
explicit OutputFileStream(int fd)
: m_file(fdopen(fd, "w"))
, m_owned(true)
{
if (!m_file)
set_fatal_error();
}
explicit OutputFileStream(FILE* fp)
: m_file(fp)
{
if (!m_file)
set_fatal_error();
}
~OutputFileStream()
{
if (m_file) {
fflush(m_file);
if (m_owned)
fclose(m_file);
}
}
size_t write(ReadonlyBytes bytes) override
{
auto nwritten = fwrite(bytes.data(), sizeof(u8), bytes.size(), m_file);
m_bytes_written += nwritten;
return nwritten;
}
bool write_or_error(ReadonlyBytes bytes) override
{
auto nwritten = write(bytes);
if (nwritten < bytes.size()) {
set_recoverable_error();
return false;
}
return true;
}
size_t size() const { return m_bytes_written; }
virtual bool handle_any_error() override
{
clearerr(m_file);
return Stream::handle_any_error();
}
void make_unbuffered()
{
setvbuf(m_file, nullptr, _IONBF, 0);
}
private:
FILE* m_file { nullptr };
size_t m_bytes_written { 0 };
bool m_owned { false };
};
}
using AK::InputFileStream;
using AK::OutputFileStream;
#endif
|
