// Formatting library for C++ - optional OS-specific functionality // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_OS_H_ #define FMT_OS_H_ #if defined(__MINGW32__) || defined(__CYGWIN__) // Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/. # undef __STRICT_ANSI__ #endif #include <cerrno> #include <clocale> // for locale_t #include <cstddef> #include <cstdio> #include <cstdlib> // for strtod_l #if defined __APPLE__ || defined(__FreeBSD__) # include <xlocale.h> // for LC_NUMERIC_MASK on OS X #endif #include "format.h" // UWP doesn't provide _pipe. #if FMT_HAS_INCLUDE("winapifamily.h") # include <winapifamily.h> #endif #if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \ defined(__linux__)) && \ (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) # include <fcntl.h> // for O_RDONLY # define FMT_USE_FCNTL 1 #else # define FMT_USE_FCNTL 0 #endif #ifndef FMT_POSIX # if defined(_WIN32) && !defined(__MINGW32__) // Fix warnings about deprecated symbols. # define FMT_POSIX(call) _##call # else # define FMT_POSIX(call) call # endif #endif // Calls to system functions are wrapped in FMT_SYSTEM for testability. #ifdef FMT_SYSTEM # define FMT_POSIX_CALL(call) FMT_SYSTEM(call) #else # define FMT_SYSTEM(call) ::call # ifdef _WIN32 // Fix warnings about deprecated symbols. # define FMT_POSIX_CALL(call) ::_##call # else # define FMT_POSIX_CALL(call) ::call # endif #endif // Retries the expression while it evaluates to error_result and errno // equals to EINTR. #ifndef _WIN32 # define FMT_RETRY_VAL(result, expression, error_result) \ do { \ (result) = (expression); \ } while ((result) == (error_result) && errno == EINTR) #else # define FMT_RETRY_VAL(result, expression, error_result) result = (expression) #endif #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) FMT_BEGIN_NAMESPACE /** \rst A reference to a null-terminated string. It can be constructed from a C string or ``std::string``. You can use one of the following type aliases for common character types: +---------------+-----------------------------+ | Type | Definition | +===============+=============================+ | cstring_view | basic_cstring_view<char> | +---------------+-----------------------------+ | wcstring_view | basic_cstring_view<wchar_t> | +---------------+-----------------------------+ This class is most useful as a parameter type to allow passing different types of strings to a function, for example:: template <typename... Args> std::string format(cstring_view format_str, const Args & ... args); format("{}", 42); format(std::string("{}"), 42); \endrst */ template <typename Char> class basic_cstring_view { private: const Char* data_; public: /** Constructs a string reference object from a C string. */ basic_cstring_view(const Char* s) : data_(s) {} /** \rst Constructs a string reference from an ``std::string`` object. \endrst */ basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {} /** Returns the pointer to a C string. */ const Char* c_str() const { return data_; } }; using cstring_view = basic_cstring_view<char>; using wcstring_view = basic_cstring_view<wchar_t>; // An error code. class error_code { private: int value_; public: explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {} int get() const FMT_NOEXCEPT { return value_; } }; #ifdef _WIN32 namespace detail { // A converter from UTF-16 to UTF-8. // It is only provided for Windows since other systems support UTF-8 natively. class utf16_to_utf8 { private: memory_buffer buffer_; public: utf16_to_utf8() {} FMT_API explicit utf16_to_utf8(wstring_view s); operator string_view() const { return string_view(&buffer_[0], size()); } size_t size() const { return buffer_.size() - 1; } const char* c_str() const { return &buffer_[0]; } std::string str() const { return std::string(&buffer_[0], size()); } // Performs conversion returning a system error code instead of // throwing exception on conversion error. This method may still throw // in case of memory allocation error. FMT_API int convert(wstring_view s); }; FMT_API void format_windows_error(buffer<char>& out, int error_code, string_view message) FMT_NOEXCEPT; } // namespace detail /** A Windows error. */ class windows_error : public system_error { private: FMT_API void init(int error_code, string_view format_str, format_args args); public: /** \rst Constructs a :class:`fmt::windows_error` object with the description of the form .. parsed-literal:: *<message>*: *<system-message>* where *<message>* is the formatted message and *<system-message>* is the system message corresponding to the error code. *error_code* is a Windows error code as given by ``GetLastError``. If *error_code* is not a valid error code such as -1, the system message will look like "error -1". **Example**:: // This throws a windows_error with the description // cannot open file 'madeup': The system cannot find the file specified. // or similar (system message may vary). const char *filename = "madeup"; LPOFSTRUCT of = LPOFSTRUCT(); HFILE file = OpenFile(filename, &of, OF_READ); if (file == HFILE_ERROR) { throw fmt::windows_error(GetLastError(), "cannot open file '{}'", filename); } \endrst */ template <typename... Args> windows_error(int error_code, string_view message, const Args&... args) { init(error_code, message, make_format_args(args...)); } }; // Reports a Windows error without throwing an exception. // Can be used to report errors from destructors. FMT_API void report_windows_error(int error_code, string_view message) FMT_NOEXCEPT; #endif // _WIN32 // A buffered file. class buffered_file { private: FILE* file_; friend class file; explicit buffered_file(FILE* f) : file_(f) {} public: buffered_file(const buffered_file&) = delete; void operator=(const buffered_file&) = delete; // Constructs a buffered_file object which doesn't represent any file. buffered_file() FMT_NOEXCEPT : file_(nullptr) {} // Destroys the object closing the file it represents if any. FMT_API ~buffered_file() FMT_NOEXCEPT; public: buffered_file(buffered_file&& other) FMT_NOEXCEPT : file_(other.file_) { other.file_ = nullptr; } buffered_file& operator=(buffered_file&& other) { close(); file_ = other.file_; other.file_ = nullptr; return *this; } // Opens a file. FMT_API buffered_file(cstring_view filename, cstring_view mode); // Closes the file. FMT_API void close(); // Returns the pointer to a FILE object representing this file. FILE* get() const FMT_NOEXCEPT { return file_; } // We place parentheses around fileno to workaround a bug in some versions // of MinGW that define fileno as a macro. FMT_API int(fileno)() const; void vprint(string_view format_str, format_args args) { fmt::vprint(file_, format_str, args); } template <typename... Args> inline void print(string_view format_str, const Args&... args) { vprint(format_str, make_format_args(args...)); } }; #if FMT_USE_FCNTL // A file. Closed file is represented by a file object with descriptor -1. // Methods that are not declared with FMT_NOEXCEPT may throw // fmt::system_error in case of failure. Note that some errors such as // closing the file multiple times will cause a crash on Windows rather // than an exception. You can get standard behavior by overriding the // invalid parameter handler with _set_invalid_parameter_handler. class file { private: int fd_; // File descriptor. // Constructs a file object with a given descriptor. explicit file(int fd) : fd_(fd) {} public: // Possible values for the oflag argument to the constructor. enum { RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. RDWR = FMT_POSIX(O_RDWR), // Open for reading and writing. CREATE = FMT_POSIX(O_CREAT), // Create if the file doesn't exist. APPEND = FMT_POSIX(O_APPEND) // Open in append mode. }; // Constructs a file object which doesn't represent any file. file() FMT_NOEXCEPT : fd_(-1) {} // Opens a file and constructs a file object representing this file. FMT_API file(cstring_view path, int oflag); public: file(const file&) = delete; void operator=(const file&) = delete; file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; } file& operator=(file&& other) FMT_NOEXCEPT { close(); fd_ = other.fd_; other.fd_ = -1; return *this; } // Destroys the object closing the file it represents if any. FMT_API ~file() FMT_NOEXCEPT; // Returns the file descriptor. int descriptor() const FMT_NOEXCEPT { return fd_; } // Closes the file. FMT_API void close(); // Returns the file size. The size has signed type for consistency with // stat::st_size. FMT_API long long size() const; // Attempts to read count bytes from the file into the specified buffer. FMT_API size_t read(void* buffer, size_t count); // Attempts to write count bytes from the specified buffer to the file. FMT_API size_t write(const void* buffer, size_t count); // Duplicates a file descriptor with the dup function and returns // the duplicate as a file object. FMT_API static file dup(int fd); // Makes fd be the copy of this file descriptor, closing fd first if // necessary. FMT_API void dup2(int fd); // Makes fd be the copy of this file descriptor, closing fd first if // necessary. FMT_API void dup2(int fd, error_code& ec) FMT_NOEXCEPT; // Creates a pipe setting up read_end and write_end file objects for reading // and writing respectively. FMT_API static void pipe(file& read_end, file& write_end); // Creates a buffered_file object associated with this file and detaches // this file object from the file. FMT_API buffered_file fdopen(const char* mode); }; // Returns the memory page size. long getpagesize(); namespace detail { struct buffer_size { size_t value = 0; buffer_size operator=(size_t val) const { auto bs = buffer_size(); bs.value = val; return bs; } }; struct ostream_params { int oflag = file::WRONLY | file::CREATE; size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768; ostream_params() {} template <typename... T> ostream_params(T... params, int oflag) : ostream_params(params...) { this->oflag = oflag; } template <typename... T> ostream_params(T... params, detail::buffer_size bs) : ostream_params(params...) { this->buffer_size = bs.value; } }; } // namespace detail static constexpr detail::buffer_size buffer_size; // A fast output stream which is not thread-safe. class ostream final : private detail::buffer<char> { private: file file_; void flush() { if (size() == 0) return; file_.write(data(), size()); clear(); } FMT_API void grow(size_t) override final; ostream(cstring_view path, const detail::ostream_params& params) : file_(path, params.oflag) { set(new char[params.buffer_size], params.buffer_size); } public: ostream(ostream&& other) : detail::buffer<char>(other.data(), other.size(), other.capacity()), file_(std::move(other.file_)) { other.set(nullptr, 0); } ~ostream() { flush(); delete[] data(); } template <typename... T> friend ostream output_file(cstring_view path, T... params); void close() { flush(); file_.close(); } template <typename S, typename... Args> void print(const S& format_str, const Args&... args) { format_to(detail::buffer_appender<char>(*this), format_str, args...); } }; /** Opens a file for writing. Supported parameters passed in `params`: * ``<integer>``: Output flags (``file::WRONLY | file::CREATE`` by default) * ``buffer_size=<integer>``: Output buffer size */ template <typename... T> inline ostream output_file(cstring_view path, T... params) { return {path, detail::ostream_params(params...)}; } #endif // FMT_USE_FCNTL #ifdef FMT_LOCALE // A "C" numeric locale. class locale { private: # ifdef _WIN32 using locale_t = _locale_t; static void freelocale(locale_t loc) { _free_locale(loc); } static double strtod_l(const char* nptr, char** endptr, _locale_t loc) { return _strtod_l(nptr, endptr, loc); } # endif locale_t locale_; public: using type = locale_t; locale(const locale&) = delete; void operator=(const locale&) = delete; locale() { # ifndef _WIN32 locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr)); # else locale_ = _create_locale(LC_NUMERIC, "C"); # endif if (!locale_) FMT_THROW(system_error(errno, "cannot create locale")); } ~locale() { freelocale(locale_); } type get() const { return locale_; } // Converts string to floating-point number and advances str past the end // of the parsed input. double strtod(const char*& str) const { char* end = nullptr; double result = strtod_l(str, &end, locale_); str = end; return result; } }; using Locale FMT_DEPRECATED_ALIAS = locale; #endif // FMT_LOCALE FMT_END_NAMESPACE #endif // FMT_OS_H_