os.h

Go to the documentation of this file.

// 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_
 
#include <cerrno>
#include <cstddef>
#include <cstdio>
#include <system_error> // std::system_error
 
#if defined __APPLE__ || defined(__FreeBSD__)
#include <xlocale.h> // for LC_NUMERIC_MASK on OS X
#endif
 
#include "format.h"
 
#ifndef FMT_USE_FCNTL
// 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
#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
FMT_MODULE_EXPORT_BEGIN
 
template <typename Char>
class basic_cstring_view
{
private:
    const Char* data_;
 
public:
    basic_cstring_view(const Char* s)
        : data_(s)
    {
    }
 
    basic_cstring_view(const std::basic_string<Char>& s)
        : data_(s.c_str())
    {
    }
 
    const Char* c_str() const
    {
        return data_;
    }
};
 
using cstring_view  = basic_cstring_view<char>;
using wcstring_view = basic_cstring_view<wchar_t>;
 
template <typename Char>
struct formatter<std::error_code, Char>
{
    template <typename ParseContext>
    FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin())
    {
        return ctx.begin();
    }
 
    template <typename FormatContext>
    FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
        -> decltype(ctx.out())
    {
        auto out = ctx.out();
        out      = detail::write_bytes(out, ec.category().name(),
                                       basic_format_specs<Char>());
        out      = detail::write<Char>(out, Char(':'));
        out      = detail::write<Char>(out, ec.value());
        return out;
    }
};
 
#ifdef _WIN32
FMT_API const std::error_category& system_category() noexcept;
 
FMT_BEGIN_DETAIL_NAMESPACE
// 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(basic_string_view<wchar_t> 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(basic_string_view<wchar_t> s);
};
 
FMT_API void format_windows_error(buffer<char>& out, int error_code, const char* message) noexcept;
FMT_END_DETAIL_NAMESPACE
 
FMT_API std::system_error vwindows_error(int error_code, string_view format_str, format_args args);
 
template <typename... Args>
std::system_error windows_error(int error_code, string_view message, const Args&... args)
{
    return vwindows_error(error_code, message, fmt::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, const char* message) noexcept;
#else
inline const std::error_category& system_category() noexcept
{
    return std::system_category();
}
#endif // _WIN32
 
// std::system is not available on some platforms such as iOS (#2248).
#ifdef __OSX__
template <typename S, typename... Args, typename Char = char_t<S>>
void say(const S& format_str, Args&&... args)
{
    std::system(format("say \"{}\"", format(format_str, args...)).c_str());
}
#endif
 
// 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() noexcept
        : file_(nullptr)
    {
    }
 
    // Destroys the object closing the file it represents if any.
    FMT_API ~buffered_file() noexcept;
 
public:
    buffered_file(buffered_file&& other) 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 noexcept
    {
        return file_;
    }
 
    FMT_API int descriptor() 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, fmt::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 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 FMT_API 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.
        TRUNC  = FMT_POSIX(O_TRUNC)   // Truncate the content of the file.
    };
 
    // Constructs a file object which doesn't represent any file.
    file() noexcept
        : fd_(-1)
    {
    }
 
    // Opens a file and constructs a file object representing this file.
    file(cstring_view path, int oflag);
 
public:
    file(const file&)           = delete;
    void operator=(const file&) = delete;
 
    file(file&& other) noexcept
        : fd_(other.fd_)
    {
        other.fd_ = -1;
    }
 
    // Move assignment is not noexcept because close may throw.
    file& operator=(file&& other)
    {
        close();
        fd_       = other.fd_;
        other.fd_ = -1;
        return *this;
    }
 
    // Destroys the object closing the file it represents if any.
    ~file() noexcept;
 
    // Returns the file descriptor.
    int descriptor() const noexcept
    {
        return fd_;
    }
 
    // Closes the file.
    void close();
 
    // Returns the file size. The size has signed type for consistency with
    // stat::st_size.
    long long size() const;
 
    // Attempts to read count bytes from the file into the specified buffer.
    size_t read(void* buffer, size_t count);
 
    // Attempts to write count bytes from the specified buffer to the file.
    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.
    static file dup(int fd);
 
    // Makes fd be the copy of this file descriptor, closing fd first if
    // necessary.
    void dup2(int fd);
 
    // Makes fd be the copy of this file descriptor, closing fd first if
    // necessary.
    void dup2(int fd, std::error_code& ec) noexcept;
 
    // Creates a pipe setting up read_end and write_end file objects for reading
    // and writing respectively.
    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.
    buffered_file fdopen(const char* mode);
};
 
// Returns the memory page size.
long getpagesize();
 
FMT_BEGIN_DETAIL_NAMESPACE
 
struct buffer_size
{
    buffer_size()     = default;
    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 | file::TRUNC;
    size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
 
    ostream_params()
    {
    }
 
    template <typename... T>
    ostream_params(T... params, int new_oflag)
        : ostream_params(params...)
    {
        oflag = new_oflag;
    }
 
    template <typename... T>
    ostream_params(T... params, detail::buffer_size bs)
        : ostream_params(params...)
    {
        this->buffer_size = bs.value;
    }
 
// Intel has a bug that results in failure to deduce a constructor
// for empty parameter packs.
#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000
    ostream_params(int new_oflag)
        : oflag(new_oflag)
    {
    }
    ostream_params(detail::buffer_size bs)
        : buffer_size(bs.value)
    {
    }
#endif
};
 
FMT_END_DETAIL_NAMESPACE
 
// Added {} below to work around default constructor error known to
// occur in Xcode versions 7.2.1 and 8.2.1.
constexpr detail::buffer_size buffer_size{};
 
class FMT_API ostream final : private detail::buffer<char>
{
private:
    file file_;
 
    void grow(size_t) override;
 
    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.clear();
        other.set(nullptr, 0);
    }
    ~ostream()
    {
        flush();
        delete[] data();
    }
 
    void flush()
    {
        if (size() == 0)
            return;
        file_.write(data(), size());
        clear();
    }
 
    template <typename... T>
    friend ostream output_file(cstring_view path, T... params);
 
    void close()
    {
        flush();
        file_.close();
    }
 
    template <typename... T>
    void print(format_string<T...> fmt, T&&... args)
    {
        vformat_to(detail::buffer_appender<char>(*this), fmt,
                   fmt::make_format_args(args...));
    }
};
 
template <typename... T>
inline ostream output_file(cstring_view path, T... params)
{
    return {path, detail::ostream_params(params...)};
}
#endif // FMT_USE_FCNTL
 
FMT_MODULE_EXPORT_END
FMT_END_NAMESPACE
 
#endif // FMT_OS_H_