# define WIN32_LEAN_AND_MEAN
# endif
# include <io.h>
-# include <windows.h>
# define O_CREAT _O_CREAT
# define O_TRUNC _O_TRUNC
namespace {
#ifdef _WIN32
// Return type of read and write functions.
-using RWResult = int;
+using rwresult = int;
// On Windows the count argument to read and write is unsigned, so convert
// it from size_t preventing integer overflow.
inline unsigned convert_rwcount(std::size_t count) {
return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
}
-#else
+#elif FMT_USE_FCNTL
// Return type of read and write functions.
-using RWResult = ssize_t;
+using rwresult = ssize_t;
inline std::size_t convert_rwcount(std::size_t count) { return count; }
#endif
FMT_BEGIN_NAMESPACE
#ifdef _WIN32
-detail::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
+detail::utf16_to_utf8::utf16_to_utf8(basic_string_view<wchar_t> s) {
if (int error_code = convert(s)) {
FMT_THROW(windows_error(error_code,
"cannot convert string from UTF-16 to UTF-8"));
}
}
-int detail::utf16_to_utf8::convert(wstring_view s) {
+int detail::utf16_to_utf8::convert(basic_string_view<wchar_t> s) {
if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
int s_size = static_cast<int>(s.size());
if (s_size == 0) {
return 0;
}
-void windows_error::init(int err_code, string_view format_str,
- format_args args) {
- error_code_ = err_code;
- memory_buffer buffer;
- detail::format_windows_error(buffer, err_code, vformat(format_str, args));
- std::runtime_error& base = *this;
- base = std::runtime_error(to_string(buffer));
+namespace detail {
+
+class system_message {
+ system_message(const system_message&) = delete;
+ void operator=(const system_message&) = delete;
+
+ unsigned long result_;
+ wchar_t* message_;
+
+ static bool is_whitespace(wchar_t c) FMT_NOEXCEPT {
+ return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0';
+ }
+
+ public:
+ explicit system_message(unsigned long error_code)
+ : result_(0), message_(nullptr) {
+ result_ = FormatMessageW(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ reinterpret_cast<wchar_t*>(&message_), 0, nullptr);
+ if (result_ != 0) {
+ while (result_ != 0 && is_whitespace(message_[result_ - 1])) {
+ --result_;
+ }
+ }
+ }
+ ~system_message() { LocalFree(message_); }
+ explicit operator bool() const FMT_NOEXCEPT { return result_ != 0; }
+ operator basic_string_view<wchar_t>() const FMT_NOEXCEPT {
+ return basic_string_view<wchar_t>(message_, result_);
+ }
+};
+
+class utf8_system_category final : public std::error_category {
+ public:
+ const char* name() const FMT_NOEXCEPT override { return "system"; }
+ std::string message(int error_code) const override {
+ system_message msg(error_code);
+ if (msg) {
+ utf16_to_utf8 utf8_message;
+ if (utf8_message.convert(msg) == ERROR_SUCCESS) {
+ return utf8_message.str();
+ }
+ }
+ return "unknown error";
+ }
+};
+
+} // namespace detail
+
+FMT_API const std::error_category& system_category() FMT_NOEXCEPT {
+ static const detail::utf8_system_category category;
+ return category;
+}
+
+std::system_error vwindows_error(int err_code, string_view format_str,
+ format_args args) {
+ auto ec = std::error_code(err_code, system_category());
+ return std::system_error(ec, vformat(format_str, args));
}
void detail::format_windows_error(detail::buffer<char>& out, int error_code,
- string_view message) FMT_NOEXCEPT {
+ const char* message) FMT_NOEXCEPT {
FMT_TRY {
- wmemory_buffer buf;
- buf.resize(inline_buffer_size);
- for (;;) {
- wchar_t* system_message = &buf[0];
- int result = FormatMessageW(
- FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr,
- error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message,
- static_cast<uint32_t>(buf.size()), nullptr);
- if (result != 0) {
- utf16_to_utf8 utf8_message;
- if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
- format_to(std::back_inserter(out), "{}: {}", message, utf8_message);
- return;
- }
- break;
+ system_message msg(error_code);
+ if (msg) {
+ utf16_to_utf8 utf8_message;
+ if (utf8_message.convert(msg) == ERROR_SUCCESS) {
+ format_to(buffer_appender<char>(out), "{}: {}", message, utf8_message);
+ return;
}
- if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
- break; // Can't get error message, report error code instead.
- buf.resize(buf.size() * 2);
}
}
FMT_CATCH(...) {}
format_error_code(out, error_code, message);
}
-void report_windows_error(int error_code,
- fmt::string_view message) FMT_NOEXCEPT {
+void report_windows_error(int error_code, const char* message) FMT_NOEXCEPT {
report_error(detail::format_windows_error, error_code, message);
}
#endif // _WIN32
}
std::size_t file::read(void* buffer, std::size_t count) {
- RWResult result = 0;
+ rwresult result = 0;
FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
if (result < 0) FMT_THROW(system_error(errno, "cannot read from file"));
return detail::to_unsigned(result);
}
std::size_t file::write(const void* buffer, std::size_t count) {
- RWResult result = 0;
+ rwresult result = 0;
FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
if (result < 0) FMT_THROW(system_error(errno, "cannot write to file"));
return detail::to_unsigned(result);
}
}
-void file::dup2(int fd, error_code& ec) FMT_NOEXCEPT {
+void file::dup2(int fd, std::error_code& ec) FMT_NOEXCEPT {
int result = 0;
FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
- if (result == -1) ec = error_code(errno);
+ if (result == -1) ec = std::error_code(errno, std::generic_category());
}
void file::pipe(file& read_end, file& write_end) {
}
buffered_file file::fdopen(const char* mode) {
- // Don't retry as fdopen doesn't return EINTR.
- #if defined(__MINGW32__) && defined(_POSIX_)
+// Don't retry as fdopen doesn't return EINTR.
+# if defined(__MINGW32__) && defined(_POSIX_)
FILE* f = ::fdopen(fd_, mode);
- #else
+# else
FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
- #endif
+# endif
if (!f)
FMT_THROW(
system_error(errno, "cannot associate stream with file descriptor"));
return size;
# endif
}
+
+FMT_API void ostream::grow(size_t) {
+ if (this->size() == this->capacity()) flush();
+}
#endif // FMT_USE_FCNTL
FMT_END_NAMESPACE
projects / ceph.git / blobdiff