src/cpp-common: add {fmt} 10.1.1
[babeltrace.git] / src / cpp-common / vendor / fmt / os.cc
1 // Formatting library for C++ - optional OS-specific functionality
2 //
3 // Copyright (c) 2012 - 2016, Victor Zverovich
4 // All rights reserved.
5 //
6 // For the license information refer to format.h.
7
8 // Disable bogus MSVC warnings.
9 #if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
10 # define _CRT_SECURE_NO_WARNINGS
11 #endif
12
13 #include "cpp-common/vendor/fmt/os.h"
14
15 #include <climits>
16
17 #if FMT_USE_FCNTL
18 # include <sys/stat.h>
19 # include <sys/types.h>
20
21 # ifdef _WRS_KERNEL // VxWorks7 kernel
22 # include <ioLib.h> // getpagesize
23 # endif
24
25 # ifndef _WIN32
26 # include <unistd.h>
27 # else
28 # ifndef WIN32_LEAN_AND_MEAN
29 # define WIN32_LEAN_AND_MEAN
30 # endif
31 # include <io.h>
32
33 # ifndef S_IRUSR
34 # define S_IRUSR _S_IREAD
35 # endif
36 # ifndef S_IWUSR
37 # define S_IWUSR _S_IWRITE
38 # endif
39 # ifndef S_IRGRP
40 # define S_IRGRP 0
41 # endif
42 # ifndef S_IWGRP
43 # define S_IWGRP 0
44 # endif
45 # ifndef S_IROTH
46 # define S_IROTH 0
47 # endif
48 # ifndef S_IWOTH
49 # define S_IWOTH 0
50 # endif
51 # endif // _WIN32
52 #endif // FMT_USE_FCNTL
53
54 #ifdef _WIN32
55 # include <windows.h>
56 #endif
57
58 namespace {
59 #ifdef _WIN32
60 // Return type of read and write functions.
61 using rwresult = int;
62
63 // On Windows the count argument to read and write is unsigned, so convert
64 // it from size_t preventing integer overflow.
65 inline unsigned convert_rwcount(std::size_t count) {
66 return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
67 }
68 #elif FMT_USE_FCNTL
69 // Return type of read and write functions.
70 using rwresult = ssize_t;
71
72 inline std::size_t convert_rwcount(std::size_t count) { return count; }
73 #endif
74 } // namespace
75
76 FMT_BEGIN_NAMESPACE
77
78 #ifdef _WIN32
79 namespace detail {
80
81 class system_message {
82 system_message(const system_message&) = delete;
83 void operator=(const system_message&) = delete;
84
85 unsigned long result_;
86 wchar_t* message_;
87
88 static bool is_whitespace(wchar_t c) noexcept {
89 return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0';
90 }
91
92 public:
93 explicit system_message(unsigned long error_code)
94 : result_(0), message_(nullptr) {
95 result_ = FormatMessageW(
96 FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
97 FORMAT_MESSAGE_IGNORE_INSERTS,
98 nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
99 reinterpret_cast<wchar_t*>(&message_), 0, nullptr);
100 if (result_ != 0) {
101 while (result_ != 0 && is_whitespace(message_[result_ - 1])) {
102 --result_;
103 }
104 }
105 }
106 ~system_message() { LocalFree(message_); }
107 explicit operator bool() const noexcept { return result_ != 0; }
108 operator basic_string_view<wchar_t>() const noexcept {
109 return basic_string_view<wchar_t>(message_, result_);
110 }
111 };
112
113 class utf8_system_category final : public std::error_category {
114 public:
115 const char* name() const noexcept override { return "system"; }
116 std::string message(int error_code) const override {
117 auto&& msg = system_message(error_code);
118 if (msg) {
119 auto utf8_message = to_utf8<wchar_t>();
120 if (utf8_message.convert(msg)) {
121 return utf8_message.str();
122 }
123 }
124 return "unknown error";
125 }
126 };
127
128 } // namespace detail
129
130 FMT_API const std::error_category& system_category() noexcept {
131 static const detail::utf8_system_category category;
132 return category;
133 }
134
135 std::system_error vwindows_error(int err_code, string_view format_str,
136 format_args args) {
137 auto ec = std::error_code(err_code, system_category());
138 return std::system_error(ec, vformat(format_str, args));
139 }
140
141 void detail::format_windows_error(detail::buffer<char>& out, int error_code,
142 const char* message) noexcept {
143 FMT_TRY {
144 auto&& msg = system_message(error_code);
145 if (msg) {
146 auto utf8_message = to_utf8<wchar_t>();
147 if (utf8_message.convert(msg)) {
148 fmt::format_to(appender(out), FMT_STRING("{}: {}"), message,
149 string_view(utf8_message));
150 return;
151 }
152 }
153 }
154 FMT_CATCH(...) {}
155 format_error_code(out, error_code, message);
156 }
157
158 void report_windows_error(int error_code, const char* message) noexcept {
159 report_error(detail::format_windows_error, error_code, message);
160 }
161 #endif // _WIN32
162
163 buffered_file::~buffered_file() noexcept {
164 if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
165 report_system_error(errno, "cannot close file");
166 }
167
168 buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
169 FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())),
170 nullptr);
171 if (!file_)
172 FMT_THROW(system_error(errno, FMT_STRING("cannot open file {}"),
173 filename.c_str()));
174 }
175
176 void buffered_file::close() {
177 if (!file_) return;
178 int result = FMT_SYSTEM(fclose(file_));
179 file_ = nullptr;
180 if (result != 0)
181 FMT_THROW(system_error(errno, FMT_STRING("cannot close file")));
182 }
183
184 int buffered_file::descriptor() const {
185 #ifdef fileno // fileno is a macro on OpenBSD so we cannot use FMT_POSIX_CALL.
186 int fd = fileno(file_);
187 #else
188 int fd = FMT_POSIX_CALL(fileno(file_));
189 #endif
190 if (fd == -1)
191 FMT_THROW(system_error(errno, FMT_STRING("cannot get file descriptor")));
192 return fd;
193 }
194
195 #if FMT_USE_FCNTL
196 # ifdef _WIN32
197 using mode_t = int;
198 # endif
199 constexpr mode_t default_open_mode =
200 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
201
202 file::file(cstring_view path, int oflag) {
203 # if defined(_WIN32) && !defined(__MINGW32__)
204 fd_ = -1;
205 auto converted = detail::utf8_to_utf16(string_view(path.c_str()));
206 *this = file::open_windows_file(converted.c_str(), oflag);
207 # else
208 FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, default_open_mode)));
209 if (fd_ == -1)
210 FMT_THROW(
211 system_error(errno, FMT_STRING("cannot open file {}"), path.c_str()));
212 # endif
213 }
214
215 file::~file() noexcept {
216 // Don't retry close in case of EINTR!
217 // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
218 if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
219 report_system_error(errno, "cannot close file");
220 }
221
222 void file::close() {
223 if (fd_ == -1) return;
224 // Don't retry close in case of EINTR!
225 // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
226 int result = FMT_POSIX_CALL(close(fd_));
227 fd_ = -1;
228 if (result != 0)
229 FMT_THROW(system_error(errno, FMT_STRING("cannot close file")));
230 }
231
232 long long file::size() const {
233 # ifdef _WIN32
234 // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
235 // is less than 0x0500 as is the case with some default MinGW builds.
236 // Both functions support large file sizes.
237 DWORD size_upper = 0;
238 HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
239 DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
240 if (size_lower == INVALID_FILE_SIZE) {
241 DWORD error = GetLastError();
242 if (error != NO_ERROR)
243 FMT_THROW(windows_error(GetLastError(), "cannot get file size"));
244 }
245 unsigned long long long_size = size_upper;
246 return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
247 # else
248 using Stat = struct stat;
249 Stat file_stat = Stat();
250 if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
251 FMT_THROW(system_error(errno, FMT_STRING("cannot get file attributes")));
252 static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
253 "return type of file::size is not large enough");
254 return file_stat.st_size;
255 # endif
256 }
257
258 std::size_t file::read(void* buffer, std::size_t count) {
259 rwresult result = 0;
260 FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
261 if (result < 0)
262 FMT_THROW(system_error(errno, FMT_STRING("cannot read from file")));
263 return detail::to_unsigned(result);
264 }
265
266 std::size_t file::write(const void* buffer, std::size_t count) {
267 rwresult result = 0;
268 FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
269 if (result < 0)
270 FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
271 return detail::to_unsigned(result);
272 }
273
274 file file::dup(int fd) {
275 // Don't retry as dup doesn't return EINTR.
276 // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
277 int new_fd = FMT_POSIX_CALL(dup(fd));
278 if (new_fd == -1)
279 FMT_THROW(system_error(
280 errno, FMT_STRING("cannot duplicate file descriptor {}"), fd));
281 return file(new_fd);
282 }
283
284 void file::dup2(int fd) {
285 int result = 0;
286 FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
287 if (result == -1) {
288 FMT_THROW(system_error(
289 errno, FMT_STRING("cannot duplicate file descriptor {} to {}"), fd_,
290 fd));
291 }
292 }
293
294 void file::dup2(int fd, std::error_code& ec) noexcept {
295 int result = 0;
296 FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
297 if (result == -1) ec = std::error_code(errno, std::generic_category());
298 }
299
300 void file::pipe(file& read_end, file& write_end) {
301 // Close the descriptors first to make sure that assignments don't throw
302 // and there are no leaks.
303 read_end.close();
304 write_end.close();
305 int fds[2] = {};
306 # ifdef _WIN32
307 // Make the default pipe capacity same as on Linux 2.6.11+.
308 enum { DEFAULT_CAPACITY = 65536 };
309 int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
310 # else
311 // Don't retry as the pipe function doesn't return EINTR.
312 // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
313 int result = FMT_POSIX_CALL(pipe(fds));
314 # endif
315 if (result != 0)
316 FMT_THROW(system_error(errno, FMT_STRING("cannot create pipe")));
317 // The following assignments don't throw because read_fd and write_fd
318 // are closed.
319 read_end = file(fds[0]);
320 write_end = file(fds[1]);
321 }
322
323 buffered_file file::fdopen(const char* mode) {
324 // Don't retry as fdopen doesn't return EINTR.
325 # if defined(__MINGW32__) && defined(_POSIX_)
326 FILE* f = ::fdopen(fd_, mode);
327 # else
328 FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
329 # endif
330 if (!f) {
331 FMT_THROW(system_error(
332 errno, FMT_STRING("cannot associate stream with file descriptor")));
333 }
334 buffered_file bf(f);
335 fd_ = -1;
336 return bf;
337 }
338
339 # if defined(_WIN32) && !defined(__MINGW32__)
340 file file::open_windows_file(wcstring_view path, int oflag) {
341 int fd = -1;
342 auto err = _wsopen_s(&fd, path.c_str(), oflag, _SH_DENYNO, default_open_mode);
343 if (fd == -1) {
344 FMT_THROW(system_error(err, FMT_STRING("cannot open file {}"),
345 detail::to_utf8<wchar_t>(path.c_str()).c_str()));
346 }
347 return file(fd);
348 }
349 # endif
350
351 # if !defined(__MSDOS__)
352 long getpagesize() {
353 # ifdef _WIN32
354 SYSTEM_INFO si;
355 GetSystemInfo(&si);
356 return si.dwPageSize;
357 # else
358 # ifdef _WRS_KERNEL
359 long size = FMT_POSIX_CALL(getpagesize());
360 # else
361 long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
362 # endif
363
364 if (size < 0)
365 FMT_THROW(system_error(errno, FMT_STRING("cannot get memory page size")));
366 return size;
367 # endif
368 }
369 # endif
370
371 namespace detail {
372
373 void file_buffer::grow(size_t) {
374 if (this->size() == this->capacity()) flush();
375 }
376
377 file_buffer::file_buffer(cstring_view path,
378 const detail::ostream_params& params)
379 : file_(path, params.oflag) {
380 set(new char[params.buffer_size], params.buffer_size);
381 }
382
383 file_buffer::file_buffer(file_buffer&& other)
384 : detail::buffer<char>(other.data(), other.size(), other.capacity()),
385 file_(std::move(other.file_)) {
386 other.clear();
387 other.set(nullptr, 0);
388 }
389
390 file_buffer::~file_buffer() {
391 flush();
392 delete[] data();
393 }
394 } // namespace detail
395
396 ostream::~ostream() = default;
397 #endif // FMT_USE_FCNTL
398 FMT_END_NAMESPACE
This page took 0.037192 seconds and 4 git commands to generate.