From c87c3aaa1faa4abbab2fd49c1429287123225ab5 Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Tue, 8 Aug 2017 19:48:38 +0000 Subject: [PATCH] Added fmt to linux --- linux/include/fmt/CMakeLists.txt | 90 + linux/include/fmt/container.h | 82 + linux/include/fmt/format.cc | 535 ++++ linux/include/fmt/format.h | 4012 ++++++++++++++++++++++++++++++ linux/include/fmt/ostream.cc | 35 + linux/include/fmt/ostream.h | 105 + linux/include/fmt/posix.cc | 241 ++ linux/include/fmt/posix.h | 367 +++ linux/include/fmt/printf.cc | 32 + linux/include/fmt/printf.h | 603 +++++ linux/include/fmt/string.h | 126 + linux/include/fmt/time.h | 143 ++ linux/lib/debug/libfmt.a | Bin 0 -> 2527182 bytes linux/lib/release/libfmt.a | Bin 0 -> 323268 bytes src/fmt/build_fmt.sh | 36 + 15 files changed, 6407 insertions(+) create mode 100644 linux/include/fmt/CMakeLists.txt create mode 100644 linux/include/fmt/container.h create mode 100644 linux/include/fmt/format.cc create mode 100644 linux/include/fmt/format.h create mode 100644 linux/include/fmt/ostream.cc create mode 100644 linux/include/fmt/ostream.h create mode 100644 linux/include/fmt/posix.cc create mode 100644 linux/include/fmt/posix.h create mode 100644 linux/include/fmt/printf.cc create mode 100644 linux/include/fmt/printf.h create mode 100644 linux/include/fmt/string.h create mode 100644 linux/include/fmt/time.h create mode 100644 linux/lib/debug/libfmt.a create mode 100644 linux/lib/release/libfmt.a create mode 100755 src/fmt/build_fmt.sh diff --git a/linux/include/fmt/CMakeLists.txt b/linux/include/fmt/CMakeLists.txt new file mode 100644 index 000000000..90eaf575f --- /dev/null +++ b/linux/include/fmt/CMakeLists.txt @@ -0,0 +1,90 @@ +# Define the fmt library, its includes and the needed defines. +# *.cc are added to FMT_HEADERS for the header-only configuration. +set(FMT_HEADERS container.h format.h format.cc ostream.h ostream.cc printf.h + printf.cc string.h time.h) +if (HAVE_OPEN) + set(FMT_HEADERS ${FMT_HEADERS} posix.h) + set(FMT_SOURCES ${FMT_SOURCES} posix.cc) +endif () + +add_library(fmt ${FMT_SOURCES} ${FMT_HEADERS} ../README.rst ../ChangeLog.rst) +add_library(fmt::fmt ALIAS fmt) + +# Starting with cmake 3.1 the CXX_STANDARD property can be used instead. +# Note: Don't make -std=c++11 public or interface, since it breaks projects +# that use C++14. +target_compile_options(fmt PRIVATE ${CPP11_FLAG}) +if (FMT_PEDANTIC) + target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS}) +endif () + +target_include_directories(fmt PUBLIC + $ + $) + +set_target_properties(fmt PROPERTIES + VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}) + +if (BUILD_SHARED_LIBS) + if (UNIX AND NOT APPLE) + # Fix rpmlint warning: + # unused-direct-shlib-dependency /usr/lib/libformat.so.1.1.0 /lib/libm.so.6. + target_link_libraries(fmt -Wl,--as-needed) + endif () + target_compile_definitions(fmt PRIVATE FMT_EXPORT INTERFACE FMT_SHARED) +endif () + +#------------------------------------------------------------------------------ +# additionally define a header only library when cmake is new enough +if (CMAKE_VERSION VERSION_GREATER 3.1.0 OR CMAKE_VERSION VERSION_EQUAL 3.1.0) + add_library(fmt-header-only INTERFACE) + add_library(fmt::fmt-header-only ALIAS fmt-header-only) + + target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1) + + target_include_directories(fmt-header-only INTERFACE + $ + $) +endif () + +# Install targets. +if (FMT_INSTALL) + include(CMakePackageConfigHelpers) + set(FMT_CMAKE_DIR lib/cmake/fmt CACHE STRING + "Installation directory for cmake files, relative to ${CMAKE_INSTALL_PREFIX}.") + set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake) + set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake) + set(targets_export_name fmt-targets) + + set (INSTALL_TARGETS fmt) + if (TARGET fmt-header-only) + set(INSTALL_TARGETS ${INSTALL_TARGETS} fmt-header-only) + endif () + + set(FMT_LIB_DIR lib CACHE STRING + "Installation directory for libraries, relative to ${CMAKE_INSTALL_PREFIX}.") + + # Generate the version, config and target files into the build directory. + write_basic_package_version_file( + ${version_config} + VERSION ${FMT_VERSION} + COMPATIBILITY AnyNewerVersion) + configure_package_config_file( + ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in + ${project_config} + INSTALL_DESTINATION ${FMT_CMAKE_DIR}) + export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt:: + FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake) + + # Install version, config and target files. + install( + FILES ${project_config} ${version_config} + DESTINATION ${FMT_CMAKE_DIR}) + install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR} + NAMESPACE fmt::) + + # Install the library and headers. + install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name} + DESTINATION ${FMT_LIB_DIR}) + install(FILES ${FMT_HEADERS} DESTINATION include/fmt) +endif () diff --git a/linux/include/fmt/container.h b/linux/include/fmt/container.h new file mode 100644 index 000000000..cb6303fb7 --- /dev/null +++ b/linux/include/fmt/container.h @@ -0,0 +1,82 @@ +/* + Formatting library for C++ - standard container utilities + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +#ifndef FMT_CONTAINER_H_ +#define FMT_CONTAINER_H_ + +#include "format.h" + +namespace fmt { + +namespace internal { + +/** + \rst + A "buffer" that appends data to a standard container (e.g. typically a + ``std::vector`` or ``std::basic_string``). + \endrst + */ +template +class ContainerBuffer : public Buffer { + private: + Container& container_; + + protected: + virtual void grow(std::size_t size) FMT_OVERRIDE { + container_.resize(size); + this->ptr_ = &container_[0]; + this->capacity_ = size; + } + + public: + explicit ContainerBuffer(Container& container) : container_(container) { + this->size_ = container_.size(); + if (this->size_ > 0) { + this->ptr_ = &container_[0]; + this->capacity_ = this->size_; + } + } +}; +} // namespace internal + +/** + \rst + This class template provides operations for formatting and appending data + to a standard *container* like ``std::vector`` or ``std::basic_string``. + + **Example**:: + + void vecformat(std::vector& dest, fmt::BasicCStringRef format, + fmt::ArgList args) { + fmt::BasicContainerWriter > appender(dest); + appender.write(format, args); + } + FMT_VARIADIC(void, vecformat, std::vector&, + fmt::BasicCStringRef); + \endrst + */ +template +class BasicContainerWriter + : public BasicWriter { + private: + internal::ContainerBuffer buffer_; + + public: + /** + \rst + Constructs a :class:`fmt::BasicContainerWriter` object. + \endrst + */ + explicit BasicContainerWriter(Container& dest) + : BasicWriter(buffer_), buffer_(dest) {} +}; + +} // namespace fmt + +#endif // FMT_CONTAINER_H_ diff --git a/linux/include/fmt/format.cc b/linux/include/fmt/format.cc new file mode 100644 index 000000000..09d2ea9fd --- /dev/null +++ b/linux/include/fmt/format.cc @@ -0,0 +1,535 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "format.h" + +#include + +#include +#include +#include +#include +#include +#include // for std::ptrdiff_t + +#if defined(_WIN32) && defined(__MINGW32__) +# include +#endif + +#if FMT_USE_WINDOWS_H +# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN) +# define WIN32_LEAN_AND_MEAN +# endif +# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX) +# include +# else +# define NOMINMAX +# include +# undef NOMINMAX +# endif +#endif + +#if FMT_EXCEPTIONS +# define FMT_TRY try +# define FMT_CATCH(x) catch (x) +#else +# define FMT_TRY if (true) +# define FMT_CATCH(x) if (false) +#endif + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4127) // conditional expression is constant +# pragma warning(disable: 4702) // unreachable code +// Disable deprecation warning for strerror. The latter is not called but +// MSVC fails to detect it. +# pragma warning(disable: 4996) +#endif + +// Dummy implementations of strerror_r and strerror_s called if corresponding +// system functions are not available. +static inline fmt::internal::Null<> strerror_r(int, char *, ...) { + return fmt::internal::Null<>(); +} +static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) { + return fmt::internal::Null<>(); +} + +namespace fmt { + +FMT_FUNC internal::RuntimeError::~RuntimeError() FMT_DTOR_NOEXCEPT {} +FMT_FUNC FormatError::~FormatError() FMT_DTOR_NOEXCEPT {} +FMT_FUNC SystemError::~SystemError() FMT_DTOR_NOEXCEPT {} + +namespace { + +#ifndef _MSC_VER +# define FMT_SNPRINTF snprintf +#else // _MSC_VER +inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) { + va_list args; + va_start(args, format); + int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); + va_end(args); + return result; +} +# define FMT_SNPRINTF fmt_snprintf +#endif // _MSC_VER + +#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) +# define FMT_SWPRINTF snwprintf +#else +# define FMT_SWPRINTF swprintf +#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) + +const char RESET_COLOR[] = "\x1b[0m"; + +typedef void (*FormatFunc)(Writer &, int, StringRef); + +// Portable thread-safe version of strerror. +// Sets buffer to point to a string describing the error code. +// This can be either a pointer to a string stored in buffer, +// or a pointer to some static immutable string. +// Returns one of the following values: +// 0 - success +// ERANGE - buffer is not large enough to store the error message +// other - failure +// Buffer should be at least of size 1. +int safe_strerror( + int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT { + FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer"); + + class StrError { + private: + int error_code_; + char *&buffer_; + std::size_t buffer_size_; + + // A noop assignment operator to avoid bogus warnings. + void operator=(const StrError &) {} + + // Handle the result of XSI-compliant version of strerror_r. + int handle(int result) { + // glibc versions before 2.13 return result in errno. + return result == -1 ? errno : result; + } + + // Handle the result of GNU-specific version of strerror_r. + int handle(char *message) { + // If the buffer is full then the message is probably truncated. + if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1) + return ERANGE; + buffer_ = message; + return 0; + } + + // Handle the case when strerror_r is not available. + int handle(internal::Null<>) { + return fallback(strerror_s(buffer_, buffer_size_, error_code_)); + } + + // Fallback to strerror_s when strerror_r is not available. + int fallback(int result) { + // If the buffer is full then the message is probably truncated. + return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? + ERANGE : result; + } + + // Fallback to strerror if strerror_r and strerror_s are not available. + int fallback(internal::Null<>) { + errno = 0; + buffer_ = strerror(error_code_); + return errno; + } + + public: + StrError(int err_code, char *&buf, std::size_t buf_size) + : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {} + + int run() { + // Suppress a warning about unused strerror_r. + strerror_r(0, FMT_NULL, ""); + return handle(strerror_r(error_code_, buffer_, buffer_size_)); + } + }; + return StrError(error_code, buffer, buffer_size).run(); +} + +void format_error_code(Writer &out, int error_code, + StringRef message) FMT_NOEXCEPT { + // Report error code making sure that the output fits into + // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential + // bad_alloc. + out.clear(); + static const char SEP[] = ": "; + static const char ERROR_STR[] = "error "; + // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. + std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; + typedef internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(error_code); + if (internal::is_negative(error_code)) { + abs_value = 0 - abs_value; + ++error_code_size; + } + error_code_size += internal::count_digits(abs_value); + if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size) + out << message << SEP; + out << ERROR_STR << error_code; + assert(out.size() <= internal::INLINE_BUFFER_SIZE); +} + +void report_error(FormatFunc func, int error_code, + StringRef message) FMT_NOEXCEPT { + MemoryWriter full_message; + func(full_message, error_code, message); + // Use Writer::data instead of Writer::c_str to avoid potential memory + // allocation. + std::fwrite(full_message.data(), full_message.size(), 1, stderr); + std::fputc('\n', stderr); +} +} // namespace + +FMT_FUNC void SystemError::init( + int err_code, CStringRef format_str, ArgList args) { + error_code_ = err_code; + MemoryWriter w; + format_system_error(w, err_code, format(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(w.str()); +} + +template +int internal::CharTraits::format_float( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, T value) { + if (width == 0) { + return precision < 0 ? + FMT_SNPRINTF(buffer, size, format, value) : + FMT_SNPRINTF(buffer, size, format, precision, value); + } + return precision < 0 ? + FMT_SNPRINTF(buffer, size, format, width, value) : + FMT_SNPRINTF(buffer, size, format, width, precision, value); +} + +template +int internal::CharTraits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, T value) { + if (width == 0) { + return precision < 0 ? + FMT_SWPRINTF(buffer, size, format, value) : + FMT_SWPRINTF(buffer, size, format, precision, value); + } + return precision < 0 ? + FMT_SWPRINTF(buffer, size, format, width, value) : + FMT_SWPRINTF(buffer, size, format, width, precision, value); +} + +template +const char internal::BasicData::DIGITS[] = + "0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"; + +#define FMT_POWERS_OF_10(factor) \ + factor * 10, \ + factor * 100, \ + factor * 1000, \ + factor * 10000, \ + factor * 100000, \ + factor * 1000000, \ + factor * 10000000, \ + factor * 100000000, \ + factor * 1000000000 + +template +const uint32_t internal::BasicData::POWERS_OF_10_32[] = { + 0, FMT_POWERS_OF_10(1) +}; + +template +const uint64_t internal::BasicData::POWERS_OF_10_64[] = { + 0, + FMT_POWERS_OF_10(1), + FMT_POWERS_OF_10(ULongLong(1000000000)), + // Multiply several constants instead of using a single long long constant + // to avoid warnings about C++98 not supporting long long. + ULongLong(1000000000) * ULongLong(1000000000) * 10 +}; + +FMT_FUNC void internal::report_unknown_type(char code, const char *type) { + (void)type; + if (std::isprint(static_cast(code))) { + FMT_THROW(FormatError( + format("unknown format code '{}' for {}", code, type))); + } + FMT_THROW(FormatError( + format("unknown format code '\\x{:02x}' for {}", + static_cast(code), type))); +} + +#if FMT_USE_WINDOWS_H + +FMT_FUNC internal::UTF8ToUTF16::UTF8ToUTF16(StringRef s) { + static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; + if (s.size() > INT_MAX) + FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG)); + int s_size = static_cast(s.size()); + int length = MultiByteToWideChar( + CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0); + if (length == 0) + FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); + buffer_.resize(length + 1); + length = MultiByteToWideChar( + CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length); + if (length == 0) + FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); + buffer_[length] = 0; +} + +FMT_FUNC internal::UTF16ToUTF8::UTF16ToUTF8(WStringRef s) { + if (int error_code = convert(s)) { + FMT_THROW(WindowsError(error_code, + "cannot convert string from UTF-16 to UTF-8")); + } +} + +FMT_FUNC int internal::UTF16ToUTF8::convert(WStringRef s) { + if (s.size() > INT_MAX) + return ERROR_INVALID_PARAMETER; + int s_size = static_cast(s.size()); + int length = WideCharToMultiByte( + CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL); + if (length == 0) + return GetLastError(); + buffer_.resize(length + 1); + length = WideCharToMultiByte( + CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL); + if (length == 0) + return GetLastError(); + buffer_[length] = 0; + return 0; +} + +FMT_FUNC void WindowsError::init( + int err_code, CStringRef format_str, ArgList args) { + error_code_ = err_code; + MemoryWriter w; + internal::format_windows_error(w, err_code, format(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(w.str()); +} + +FMT_FUNC void internal::format_windows_error( + Writer &out, int error_code, StringRef message) FMT_NOEXCEPT { + FMT_TRY { + MemoryBuffer buffer; + buffer.resize(INLINE_BUFFER_SIZE); + for (;;) { + wchar_t *system_message = &buffer[0]; + int result = FormatMessageW( + FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + system_message, static_cast(buffer.size()), FMT_NULL); + if (result != 0) { + UTF16ToUTF8 utf8_message; + if (utf8_message.convert(system_message) == ERROR_SUCCESS) { + out << message << ": " << utf8_message; + return; + } + break; + } + if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) + break; // Can't get error message, report error code instead. + buffer.resize(buffer.size() * 2); + } + } FMT_CATCH(...) {} + fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32. +} + +#endif // FMT_USE_WINDOWS_H + +FMT_FUNC void format_system_error( + Writer &out, int error_code, StringRef message) FMT_NOEXCEPT { + FMT_TRY { + internal::MemoryBuffer buffer; + buffer.resize(internal::INLINE_BUFFER_SIZE); + for (;;) { + char *system_message = &buffer[0]; + int result = safe_strerror(error_code, system_message, buffer.size()); + if (result == 0) { + out << message << ": " << system_message; + return; + } + if (result != ERANGE) + break; // Can't get error message, report error code instead. + buffer.resize(buffer.size() * 2); + } + } FMT_CATCH(...) {} + fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32. +} + +template +void internal::ArgMap::init(const ArgList &args) { + if (!map_.empty()) + return; + typedef internal::NamedArg NamedArg; + const NamedArg *named_arg = FMT_NULL; + bool use_values = + args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE; + if (use_values) { + for (unsigned i = 0;/*nothing*/; ++i) { + internal::Arg::Type arg_type = args.type(i); + switch (arg_type) { + case internal::Arg::NONE: + return; + case internal::Arg::NAMED_ARG: + named_arg = static_cast(args.values_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + break; + default: + /*nothing*/; + } + } + return; + } + for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) { + internal::Arg::Type arg_type = args.type(i); + if (arg_type == internal::Arg::NAMED_ARG) { + named_arg = static_cast(args.args_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + } + } + for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) { + switch (args.args_[i].type) { + case internal::Arg::NONE: + return; + case internal::Arg::NAMED_ARG: + named_arg = static_cast(args.args_[i].pointer); + map_.push_back(Pair(named_arg->name, *named_arg)); + break; + default: + /*nothing*/; + } + } +} + +template +void internal::FixedBuffer::grow(std::size_t) { + FMT_THROW(std::runtime_error("buffer overflow")); +} + +FMT_FUNC internal::Arg internal::FormatterBase::do_get_arg( + unsigned arg_index, const char *&error) { + internal::Arg arg = args_[arg_index]; + switch (arg.type) { + case internal::Arg::NONE: + error = "argument index out of range"; + break; + case internal::Arg::NAMED_ARG: + arg = *static_cast(arg.pointer); + break; + default: + /*nothing*/; + } + return arg; +} + +FMT_FUNC void report_system_error( + int error_code, fmt::StringRef message) FMT_NOEXCEPT { + // 'fmt::' is for bcc32. + report_error(format_system_error, error_code, message); +} + +#if FMT_USE_WINDOWS_H +FMT_FUNC void report_windows_error( + int error_code, fmt::StringRef message) FMT_NOEXCEPT { + // 'fmt::' is for bcc32. + report_error(internal::format_windows_error, error_code, message); +} +#endif + +FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args) { + MemoryWriter w; + w.write(format_str, args); + std::fwrite(w.data(), 1, w.size(), f); +} + +FMT_FUNC void print(CStringRef format_str, ArgList args) { + print(stdout, format_str, args); +} + +FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args) { + char escape[] = "\x1b[30m"; + escape[3] = static_cast('0' + c); + std::fputs(escape, stdout); + print(format, args); + std::fputs(RESET_COLOR, stdout); +} + +#ifndef FMT_HEADER_ONLY + +template struct internal::BasicData; + +// Explicit instantiations for char. + +template void internal::FixedBuffer::grow(std::size_t); + +template void internal::ArgMap::init(const ArgList &args); + +template FMT_API int internal::CharTraits::format_float( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, double value); + +template FMT_API int internal::CharTraits::format_float( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, long double value); + +// Explicit instantiations for wchar_t. + +template void internal::FixedBuffer::grow(std::size_t); + +template void internal::ArgMap::init(const ArgList &args); + +template FMT_API int internal::CharTraits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, double value); + +template FMT_API int internal::CharTraits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, long double value); + +#endif // FMT_HEADER_ONLY + +} // namespace fmt + +#ifdef _MSC_VER +# pragma warning(pop) +#endif diff --git a/linux/include/fmt/format.h b/linux/include/fmt/format.h new file mode 100644 index 000000000..6ee9d2a21 --- /dev/null +++ b/linux/include/fmt/format.h @@ -0,0 +1,4012 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FMT_FORMAT_H_ +#define FMT_FORMAT_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for std::pair + +// The fmt library version in the form major * 10000 + minor * 100 + patch. +#define FMT_VERSION 40000 + +#ifdef _SECURE_SCL +# define FMT_SECURE_SCL _SECURE_SCL +#else +# define FMT_SECURE_SCL 0 +#endif + +#if FMT_SECURE_SCL +# include +#endif + +#ifdef _MSC_VER +# define FMT_MSC_VER _MSC_VER +#else +# define FMT_MSC_VER 0 +#endif + +#if FMT_MSC_VER && FMT_MSC_VER <= 1500 +typedef unsigned __int32 uint32_t; +typedef unsigned __int64 uint64_t; +typedef __int64 intmax_t; +#else +#include +#endif + +#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) +# ifdef FMT_EXPORT +# define FMT_API __declspec(dllexport) +# elif defined(FMT_SHARED) +# define FMT_API __declspec(dllimport) +# endif +#endif +#ifndef FMT_API +# define FMT_API +#endif + +#ifdef __GNUC__ +# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +# define FMT_GCC_EXTENSION __extension__ +# if FMT_GCC_VERSION >= 406 +# pragma GCC diagnostic push +// Disable the warning about "long long" which is sometimes reported even +// when using __extension__. +# pragma GCC diagnostic ignored "-Wlong-long" +// Disable the warning about declaration shadowing because it affects too +// many valid cases. +# pragma GCC diagnostic ignored "-Wshadow" +// Disable the warning about implicit conversions that may change the sign of +// an integer; silencing it otherwise would require many explicit casts. +# pragma GCC diagnostic ignored "-Wsign-conversion" +# endif +# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__ +# define FMT_HAS_GXX_CXX11 1 +# endif +#else +# define FMT_GCC_EXTENSION +#endif + +#if defined(__INTEL_COMPILER) +# define FMT_ICC_VERSION __INTEL_COMPILER +#elif defined(__ICL) +# define FMT_ICC_VERSION __ICL +#endif + +#if defined(__clang__) && !defined(FMT_ICC_VERSION) +# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +# pragma clang diagnostic ignored "-Wpadded" +#endif + +#ifdef __GNUC_LIBSTD__ +# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) +#endif + +#ifdef __has_feature +# define FMT_HAS_FEATURE(x) __has_feature(x) +#else +# define FMT_HAS_FEATURE(x) 0 +#endif + +#ifdef __has_builtin +# define FMT_HAS_BUILTIN(x) __has_builtin(x) +#else +# define FMT_HAS_BUILTIN(x) 0 +#endif + +#ifdef __has_cpp_attribute +# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +# define FMT_HAS_CPP_ATTRIBUTE(x) 0 +#endif + +#ifndef FMT_USE_VARIADIC_TEMPLATES +// Variadic templates are available in GCC since version 4.4 +// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++ +// since version 2013. +# define FMT_USE_VARIADIC_TEMPLATES \ + (FMT_HAS_FEATURE(cxx_variadic_templates) || \ + (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800) +#endif + +#ifndef FMT_USE_RVALUE_REFERENCES +// Don't use rvalue references when compiling with clang and an old libstdc++ +// as the latter doesn't provide std::move. +# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402 +# define FMT_USE_RVALUE_REFERENCES 0 +# else +# define FMT_USE_RVALUE_REFERENCES \ + (FMT_HAS_FEATURE(cxx_rvalue_references) || \ + (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600) +# endif +#endif + +// Check if exceptions are disabled. +#if defined(__GNUC__) && !defined(__EXCEPTIONS) +# define FMT_EXCEPTIONS 0 +#endif +#if FMT_MSC_VER && !_HAS_EXCEPTIONS +# define FMT_EXCEPTIONS 0 +#endif +#ifndef FMT_EXCEPTIONS +# define FMT_EXCEPTIONS 1 +#endif + +#ifndef FMT_THROW +# if FMT_EXCEPTIONS +# define FMT_THROW(x) throw x +# else +# define FMT_THROW(x) assert(false) +# endif +#endif + +// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature). +#ifndef FMT_USE_NOEXCEPT +# define FMT_USE_NOEXCEPT 0 +#endif + +#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \ + (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \ + FMT_MSC_VER >= 1900 +# define FMT_DETECTED_NOEXCEPT noexcept +#else +# define FMT_DETECTED_NOEXCEPT throw() +#endif + +#ifndef FMT_NOEXCEPT +# if FMT_EXCEPTIONS +# define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT +# else +# define FMT_NOEXCEPT +# endif +#endif + +// This is needed because GCC still uses throw() in its headers when exceptions +// are disabled. +#if FMT_GCC_VERSION +# define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT +#else +# define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT +#endif + +#ifndef FMT_OVERRIDE +# if (defined(FMT_USE_OVERRIDE) && FMT_USE_OVERRIDE) || FMT_HAS_FEATURE(cxx_override) || \ + (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \ + FMT_MSC_VER >= 1900 +# define FMT_OVERRIDE override +# else +# define FMT_OVERRIDE +# endif +#endif + +#ifndef FMT_NULL +# if FMT_HAS_FEATURE(cxx_nullptr) || \ + (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \ + FMT_MSC_VER >= 1600 +# define FMT_NULL nullptr +# else +# define FMT_NULL NULL +# endif +#endif + +// A macro to disallow the copy constructor and operator= functions +// This should be used in the private: declarations for a class +#ifndef FMT_USE_DELETED_FUNCTIONS +# define FMT_USE_DELETED_FUNCTIONS 0 +#endif + +#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \ + (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800 +# define FMT_DELETED_OR_UNDEFINED = delete +# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&) = delete; \ + TypeName& operator=(const TypeName&) = delete +#else +# define FMT_DELETED_OR_UNDEFINED +# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ + TypeName(const TypeName&); \ + TypeName& operator=(const TypeName&) +#endif + +#ifndef FMT_USE_DEFAULTED_FUNCTIONS +# define FMT_USE_DEFAULTED_FUNCTIONS 0 +#endif + +#ifndef FMT_DEFAULTED_COPY_CTOR +# if FMT_USE_DEFAULTED_FUNCTIONS || FMT_HAS_FEATURE(cxx_defaulted_functions) || \ + (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800 +# define FMT_DEFAULTED_COPY_CTOR(TypeName) \ + TypeName(const TypeName&) = default; +# else +# define FMT_DEFAULTED_COPY_CTOR(TypeName) +# endif +#endif + +#ifndef FMT_USE_USER_DEFINED_LITERALS +// All compilers which support UDLs also support variadic templates. This +// makes the fmt::literals implementation easier. However, an explicit check +// for variadic templates is added here just in case. +// For Intel's compiler both it and the system gcc/msc must support UDLs. +# define FMT_USE_USER_DEFINED_LITERALS \ + FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \ + (FMT_HAS_FEATURE(cxx_user_literals) || \ + (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \ + (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500) +#endif + +#ifndef FMT_USE_EXTERN_TEMPLATES +# define FMT_USE_EXTERN_TEMPLATES \ + (FMT_CLANG_VERSION >= 209 || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11)) +#endif + +#ifdef FMT_HEADER_ONLY +// If header only do not use extern templates. +# undef FMT_USE_EXTERN_TEMPLATES +# define FMT_USE_EXTERN_TEMPLATES 0 +#endif + +#ifndef FMT_ASSERT +# define FMT_ASSERT(condition, message) assert((condition) && message) +#endif + +// __builtin_clz is broken in clang with Microsoft CodeGen: +// https://github.com/fmtlib/fmt/issues/519 +#ifndef _MSC_VER +# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz) +# define FMT_BUILTIN_CLZ(n) __builtin_clz(n) +# endif + +# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll) +# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) +# endif +#endif + +// Some compilers masquerade as both MSVC and GCC-likes or +// otherwise support __builtin_clz and __builtin_clzll, so +// only define FMT_BUILTIN_CLZ using the MSVC intrinsics +// if the clz and clzll builtins are not available. +#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED) +# include // _BitScanReverse, _BitScanReverse64 + +namespace fmt { +namespace internal { +# pragma intrinsic(_BitScanReverse) +inline uint32_t clz(uint32_t x) { + unsigned long r = 0; + _BitScanReverse(&r, x); + + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. +# pragma warning(suppress: 6102) + return 31 - r; +} +# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) + +# ifdef _WIN64 +# pragma intrinsic(_BitScanReverse64) +# endif + +inline uint32_t clzll(uint64_t x) { + unsigned long r = 0; +# ifdef _WIN64 + _BitScanReverse64(&r, x); +# else + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 - (r + 32); + + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); +# endif + + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. +# pragma warning(suppress: 6102) + return 63 - r; +} +# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) +} +} +#endif + +namespace fmt { +namespace internal { +struct DummyInt { + int data[2]; + operator int() const { return 0; } +}; +typedef std::numeric_limits FPUtil; + +// Dummy implementations of system functions such as signbit and ecvt called +// if the latter are not available. +inline DummyInt signbit(...) { return DummyInt(); } +inline DummyInt _ecvt_s(...) { return DummyInt(); } +inline DummyInt isinf(...) { return DummyInt(); } +inline DummyInt _finite(...) { return DummyInt(); } +inline DummyInt isnan(...) { return DummyInt(); } +inline DummyInt _isnan(...) { return DummyInt(); } + +// A helper function to suppress bogus "conditional expression is constant" +// warnings. +template +inline T const_check(T value) { return value; } +} +} // namespace fmt + +namespace std { +// Standard permits specialization of std::numeric_limits. This specialization +// is used to resolve ambiguity between isinf and std::isinf in glibc: +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891 +// and the same for isnan and signbit. +template <> +class numeric_limits : + public std::numeric_limits { + public: + // Portable version of isinf. + template + static bool isinfinity(T x) { + using namespace fmt::internal; + // The resolution "priority" is: + // isinf macro > std::isinf > ::isinf > fmt::internal::isinf + if (const_check(sizeof(isinf(x)) == sizeof(bool) || + sizeof(isinf(x)) == sizeof(int))) { + return isinf(x) != 0; + } + return !_finite(static_cast(x)); + } + + // Portable version of isnan. + template + static bool isnotanumber(T x) { + using namespace fmt::internal; + if (const_check(sizeof(isnan(x)) == sizeof(bool) || + sizeof(isnan(x)) == sizeof(int))) { + return isnan(x) != 0; + } + return _isnan(static_cast(x)) != 0; + } + + // Portable version of signbit. + static bool isnegative(double x) { + using namespace fmt::internal; + if (const_check(sizeof(signbit(x)) == sizeof(bool) || + sizeof(signbit(x)) == sizeof(int))) { + return signbit(x) != 0; + } + if (x < 0) return true; + if (!isnotanumber(x)) return false; + int dec = 0, sign = 0; + char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. + _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign); + return sign != 0; + } +}; +} // namespace std + +namespace fmt { + +// Fix the warning about long long on older versions of GCC +// that don't support the diagnostic pragma. +FMT_GCC_EXTENSION typedef long long LongLong; +FMT_GCC_EXTENSION typedef unsigned long long ULongLong; + +#if FMT_USE_RVALUE_REFERENCES +using std::move; +#endif + +template +class BasicWriter; + +typedef BasicWriter Writer; +typedef BasicWriter WWriter; + +template +class ArgFormatter; + +struct FormatSpec; + +template +class BasicPrintfArgFormatter; + +template > +class BasicFormatter; + +/** + \rst + A string reference. It can be constructed from a C string or + ``std::basic_string``. + + You can use one of the following typedefs for common character types: + + +------------+-------------------------+ + | Type | Definition | + +============+=========================+ + | StringRef | BasicStringRef | + +------------+-------------------------+ + | WStringRef | BasicStringRef | + +------------+-------------------------+ + + This class is most useful as a parameter type to allow passing + different types of strings to a function, for example:: + + template + std::string format(StringRef format_str, const Args & ... args); + + format("{}", 42); + format(std::string("{}"), 42); + \endrst + */ +template +class BasicStringRef { + private: + const Char *data_; + std::size_t size_; + + public: + /** Constructs a string reference object from a C string and a size. */ + BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {} + + /** + \rst + Constructs a string reference object from a C string computing + the size with ``std::char_traits::length``. + \endrst + */ + BasicStringRef(const Char *s) + : data_(s), size_(std::char_traits::length(s)) {} + + /** + \rst + Constructs a string reference from a ``std::basic_string`` object. + \endrst + */ + template + BasicStringRef( + const std::basic_string, Allocator> &s) + : data_(s.c_str()), size_(s.size()) {} + + /** + \rst + Converts a string reference to an ``std::string`` object. + \endrst + */ + std::basic_string to_string() const { + return std::basic_string(data_, size_); + } + + /** Returns a pointer to the string data. */ + const Char *data() const { return data_; } + + /** Returns the string size. */ + std::size_t size() const { return size_; } + + // Lexicographically compare this string reference to other. + int compare(BasicStringRef other) const { + std::size_t size = size_ < other.size_ ? size_ : other.size_; + int result = std::char_traits::compare(data_, other.data_, size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) == 0; + } + friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) != 0; + } + friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) < 0; + } + friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) <= 0; + } + friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) > 0; + } + friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) { + return lhs.compare(rhs) >= 0; + } +}; + +typedef BasicStringRef StringRef; +typedef BasicStringRef WStringRef; + +/** + \rst + A reference to a null terminated string. It can be constructed from a C + string or ``std::basic_string``. + + You can use one of the following typedefs for common character types: + + +-------------+--------------------------+ + | Type | Definition | + +=============+==========================+ + | CStringRef | BasicCStringRef | + +-------------+--------------------------+ + | WCStringRef | BasicCStringRef | + +-------------+--------------------------+ + + This class is most useful as a parameter type to allow passing + different types of strings to a function, for example:: + + template + std::string format(CStringRef format_str, const Args & ... args); + + format("{}", 42); + format(std::string("{}"), 42); + \endrst + */ +template +class BasicCStringRef { + private: + const Char *data_; + + public: + /** Constructs a string reference object from a C string. */ + BasicCStringRef(const Char *s) : data_(s) {} + + /** + \rst + Constructs a string reference from a ``std::basic_string`` object. + \endrst + */ + template + BasicCStringRef( + const std::basic_string, Allocator> &s) + : data_(s.c_str()) {} + + /** Returns the pointer to a C string. */ + const Char *c_str() const { return data_; } +}; + +typedef BasicCStringRef CStringRef; +typedef BasicCStringRef WCStringRef; + +/** A formatting error such as invalid format string. */ +class FormatError : public std::runtime_error { + public: + explicit FormatError(CStringRef message) + : std::runtime_error(message.c_str()) {} + FormatError(const FormatError &ferr) : std::runtime_error(ferr) {} + FMT_API ~FormatError() FMT_DTOR_NOEXCEPT; +}; + +namespace internal { + +// MakeUnsigned::Type gives an unsigned type corresponding to integer type T. +template +struct MakeUnsigned { typedef T Type; }; + +#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \ + template <> \ + struct MakeUnsigned { typedef U Type; } + +FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char); +FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char); +FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short); +FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned); +FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long); +FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong); + +// Casts nonnegative integer to unsigned. +template +inline typename MakeUnsigned::Type to_unsigned(Int value) { + FMT_ASSERT(value >= 0, "negative value"); + return static_cast::Type>(value); +} + +// The number of characters to store in the MemoryBuffer object itself +// to avoid dynamic memory allocation. +enum { INLINE_BUFFER_SIZE = 500 }; + +#if FMT_SECURE_SCL +// Use checked iterator to avoid warnings on MSVC. +template +inline stdext::checked_array_iterator make_ptr(T *ptr, std::size_t size) { + return stdext::checked_array_iterator(ptr, size); +} +#else +template +inline T *make_ptr(T *ptr, std::size_t) { return ptr; } +#endif +} // namespace internal + +/** + \rst + A buffer supporting a subset of ``std::vector``'s operations. + \endrst + */ +template +class Buffer { + private: + FMT_DISALLOW_COPY_AND_ASSIGN(Buffer); + + protected: + T *ptr_; + std::size_t size_; + std::size_t capacity_; + + Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0) + : ptr_(ptr), size_(0), capacity_(capacity) {} + + /** + \rst + Increases the buffer capacity to hold at least *size* elements updating + ``ptr_`` and ``capacity_``. + \endrst + */ + virtual void grow(std::size_t size) = 0; + + public: + virtual ~Buffer() {} + + /** Returns the size of this buffer. */ + std::size_t size() const { return size_; } + + /** Returns the capacity of this buffer. */ + std::size_t capacity() const { return capacity_; } + + /** + Resizes the buffer. If T is a POD type new elements may not be initialized. + */ + void resize(std::size_t new_size) { + if (new_size > capacity_) + grow(new_size); + size_ = new_size; + } + + /** + \rst + Reserves space to store at least *capacity* elements. + \endrst + */ + void reserve(std::size_t capacity) { + if (capacity > capacity_) + grow(capacity); + } + + void clear() FMT_NOEXCEPT { size_ = 0; } + + void push_back(const T &value) { + if (size_ == capacity_) + grow(size_ + 1); + ptr_[size_++] = value; + } + + /** Appends data to the end of the buffer. */ + template + void append(const U *begin, const U *end); + + T &operator[](std::size_t index) { return ptr_[index]; } + const T &operator[](std::size_t index) const { return ptr_[index]; } +}; + +template +template +void Buffer::append(const U *begin, const U *end) { + FMT_ASSERT(end >= begin, "negative value"); + std::size_t new_size = size_ + (end - begin); + if (new_size > capacity_) + grow(new_size); + std::uninitialized_copy(begin, end, + internal::make_ptr(ptr_, capacity_) + size_); + size_ = new_size; +} + +namespace internal { + +// A memory buffer for trivially copyable/constructible types with the first +// SIZE elements stored in the object itself. +template > +class MemoryBuffer : private Allocator, public Buffer { + private: + T data_[SIZE]; + + // Deallocate memory allocated by the buffer. + void deallocate() { + if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_); + } + + protected: + void grow(std::size_t size) FMT_OVERRIDE; + + public: + explicit MemoryBuffer(const Allocator &alloc = Allocator()) + : Allocator(alloc), Buffer(data_, SIZE) {} + ~MemoryBuffer() { deallocate(); } + +#if FMT_USE_RVALUE_REFERENCES + private: + // Move data from other to this buffer. + void move(MemoryBuffer &other) { + Allocator &this_alloc = *this, &other_alloc = other; + this_alloc = std::move(other_alloc); + this->size_ = other.size_; + this->capacity_ = other.capacity_; + if (other.ptr_ == other.data_) { + this->ptr_ = data_; + std::uninitialized_copy(other.data_, other.data_ + this->size_, + make_ptr(data_, this->capacity_)); + } else { + this->ptr_ = other.ptr_; + // Set pointer to the inline array so that delete is not called + // when deallocating. + other.ptr_ = other.data_; + } + } + + public: + MemoryBuffer(MemoryBuffer &&other) { + move(other); + } + + MemoryBuffer &operator=(MemoryBuffer &&other) { + assert(this != &other); + deallocate(); + move(other); + return *this; + } +#endif + + // Returns a copy of the allocator associated with this buffer. + Allocator get_allocator() const { return *this; } +}; + +template +void MemoryBuffer::grow(std::size_t size) { + std::size_t new_capacity = this->capacity_ + this->capacity_ / 2; + if (size > new_capacity) + new_capacity = size; + T *new_ptr = this->allocate(new_capacity, FMT_NULL); + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_, + make_ptr(new_ptr, new_capacity)); + std::size_t old_capacity = this->capacity_; + T *old_ptr = this->ptr_; + this->capacity_ = new_capacity; + this->ptr_ = new_ptr; + // deallocate may throw (at least in principle), but it doesn't matter since + // the buffer already uses the new storage and will deallocate it in case + // of exception. + if (old_ptr != data_) + Allocator::deallocate(old_ptr, old_capacity); +} + +// A fixed-size buffer. +template +class FixedBuffer : public fmt::Buffer { + public: + FixedBuffer(Char *array, std::size_t size) : fmt::Buffer(array, size) {} + + protected: + FMT_API void grow(std::size_t size) FMT_OVERRIDE; +}; + +template +class BasicCharTraits { + public: +#if FMT_SECURE_SCL + typedef stdext::checked_array_iterator CharPtr; +#else + typedef Char *CharPtr; +#endif + static Char cast(int value) { return static_cast(value); } +}; + +template +class CharTraits; + +template <> +class CharTraits : public BasicCharTraits { + private: + // Conversion from wchar_t to char is not allowed. + static char convert(wchar_t); + + public: + static char convert(char value) { return value; } + + // Formats a floating-point number. + template + FMT_API static int format_float(char *buffer, std::size_t size, + const char *format, unsigned width, int precision, T value); +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template int CharTraits::format_float + (char *buffer, std::size_t size, + const char* format, unsigned width, int precision, double value); +extern template int CharTraits::format_float + (char *buffer, std::size_t size, + const char* format, unsigned width, int precision, long double value); +#endif + +template <> +class CharTraits : public BasicCharTraits { + public: + static wchar_t convert(char value) { return value; } + static wchar_t convert(wchar_t value) { return value; } + + template + FMT_API static int format_float(wchar_t *buffer, std::size_t size, + const wchar_t *format, unsigned width, int precision, T value); +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template int CharTraits::format_float + (wchar_t *buffer, std::size_t size, + const wchar_t* format, unsigned width, int precision, double value); +extern template int CharTraits::format_float + (wchar_t *buffer, std::size_t size, + const wchar_t* format, unsigned width, int precision, long double value); +#endif + +// Checks if a number is negative - used to avoid warnings. +template +struct SignChecker { + template + static bool is_negative(T value) { return value < 0; } +}; + +template <> +struct SignChecker { + template + static bool is_negative(T) { return false; } +}; + +// Returns true if value is negative, false otherwise. +// Same as (value < 0) but doesn't produce warnings if T is an unsigned type. +template +inline bool is_negative(T value) { + return SignChecker::is_signed>::is_negative(value); +} + +// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise. +template +struct TypeSelector { typedef uint32_t Type; }; + +template <> +struct TypeSelector { typedef uint64_t Type; }; + +template +struct IntTraits { + // Smallest of uint32_t and uint64_t that is large enough to represent + // all values of T. + typedef typename + TypeSelector::digits <= 32>::Type MainType; +}; + +FMT_API void report_unknown_type(char code, const char *type); + +// Static data is placed in this class template to allow header-only +// configuration. +template +struct FMT_API BasicData { + static const uint32_t POWERS_OF_10_32[]; + static const uint64_t POWERS_OF_10_64[]; + static const char DIGITS[]; +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template struct BasicData; +#endif + +typedef BasicData<> Data; + +#ifdef FMT_BUILTIN_CLZLL +// Returns the number of decimal digits in n. Leading zeros are not counted +// except for n == 0 in which case count_digits returns 1. +inline unsigned count_digits(uint64_t n) { + // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 + // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. + int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1; +} +#else +// Fallback version of count_digits used when __builtin_clz is not available. +inline unsigned count_digits(uint64_t n) { + unsigned count = 1; + for (;;) { + // Integer division is slow so do it for a group of four digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + if (n < 10) return count; + if (n < 100) return count + 1; + if (n < 1000) return count + 2; + if (n < 10000) return count + 3; + n /= 10000u; + count += 4; + } +} +#endif + +#ifdef FMT_BUILTIN_CLZ +// Optional version of count_digits for better performance on 32-bit platforms. +inline unsigned count_digits(uint32_t n) { + int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1; +} +#endif + +// A functor that doesn't add a thousands separator. +struct NoThousandsSep { + template + void operator()(Char *) {} +}; + +// A functor that adds a thousands separator. +class ThousandsSep { + private: + fmt::StringRef sep_; + + // Index of a decimal digit with the least significant digit having index 0. + unsigned digit_index_; + + public: + explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {} + + template + void operator()(Char *&buffer) { + if (++digit_index_ % 3 != 0) + return; + buffer -= sep_.size(); + std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), + internal::make_ptr(buffer, sep_.size())); + } +}; + +// Formats a decimal unsigned integer value writing into buffer. +// thousands_sep is a functor that is called after writing each char to +// add a thousands separator if necessary. +template +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits, + ThousandsSep thousands_sep) { + buffer += num_digits; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = static_cast((value % 100) * 2); + value /= 100; + *--buffer = Data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = Data::DIGITS[index]; + thousands_sep(buffer); + } + if (value < 10) { + *--buffer = static_cast('0' + value); + return; + } + unsigned index = static_cast(value * 2); + *--buffer = Data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = Data::DIGITS[index]; +} + +template +inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) { + format_decimal(buffer, value, num_digits, NoThousandsSep()); + return; +} + +#ifndef _WIN32 +# define FMT_USE_WINDOWS_H 0 +#elif !defined(FMT_USE_WINDOWS_H) +# define FMT_USE_WINDOWS_H 1 +#endif + +// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h. +// All the functionality that relies on it will be disabled too. +#if FMT_USE_WINDOWS_H +// A converter from UTF-8 to UTF-16. +// It is only provided for Windows since other systems support UTF-8 natively. +class UTF8ToUTF16 { + private: + MemoryBuffer buffer_; + + public: + FMT_API explicit UTF8ToUTF16(StringRef s); + operator WStringRef() const { return WStringRef(&buffer_[0], size()); } + size_t size() const { return buffer_.size() - 1; } + const wchar_t *c_str() const { return &buffer_[0]; } + std::wstring str() const { return std::wstring(&buffer_[0], size()); } +}; + +// A converter from UTF-16 to UTF-8. +// It is only provided for Windows since other systems support UTF-8 natively. +class UTF16ToUTF8 { + private: + MemoryBuffer buffer_; + + public: + UTF16ToUTF8() {} + FMT_API explicit UTF16ToUTF8(WStringRef s); + operator StringRef() const { return StringRef(&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(WStringRef s); +}; + +FMT_API void format_windows_error(fmt::Writer &out, int error_code, + fmt::StringRef message) FMT_NOEXCEPT; +#endif + +// A formatting argument value. +struct Value { + template + struct StringValue { + const Char *value; + std::size_t size; + }; + + typedef void (*FormatFunc)( + void *formatter, const void *arg, void *format_str_ptr); + + struct CustomValue { + const void *value; + FormatFunc format; + }; + + union { + int int_value; + unsigned uint_value; + LongLong long_long_value; + ULongLong ulong_long_value; + double double_value; + long double long_double_value; + const void *pointer; + StringValue string; + StringValue sstring; + StringValue ustring; + StringValue wstring; + CustomValue custom; + }; + + enum Type { + NONE, NAMED_ARG, + // Integer types should go first, + INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR, + // followed by floating-point types. + DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE, + CSTRING, STRING, WSTRING, POINTER, CUSTOM + }; +}; + +// A formatting argument. It is a trivially copyable/constructible type to +// allow storage in internal::MemoryBuffer. +struct Arg : Value { + Type type; +}; + +template +struct NamedArg; +template +struct NamedArgWithType; + +template +struct Null {}; + +// A helper class template to enable or disable overloads taking wide +// characters and strings in MakeValue. +template +struct WCharHelper { + typedef Null Supported; + typedef T Unsupported; +}; + +template +struct WCharHelper { + typedef T Supported; + typedef Null Unsupported; +}; + +typedef char Yes[1]; +typedef char No[2]; + +template +T &get(); + +// These are non-members to workaround an overload resolution bug in bcc32. +Yes &convert(fmt::ULongLong); +No &convert(...); + +template +struct ConvertToIntImpl { + enum { value = ENABLE_CONVERSION }; +}; + +template +struct ConvertToIntImpl2 { + enum { value = false }; +}; + +template +struct ConvertToIntImpl2 { + enum { + // Don't convert numeric types. + value = ConvertToIntImpl::is_specialized>::value + }; +}; + +template +struct ConvertToInt { + enum { + enable_conversion = sizeof(fmt::internal::convert(get())) == sizeof(Yes) + }; + enum { value = ConvertToIntImpl2::value }; +}; + +#define FMT_DISABLE_CONVERSION_TO_INT(Type) \ + template <> \ + struct ConvertToInt { enum { value = 0 }; } + +// Silence warnings about convering float to int. +FMT_DISABLE_CONVERSION_TO_INT(float); +FMT_DISABLE_CONVERSION_TO_INT(double); +FMT_DISABLE_CONVERSION_TO_INT(long double); + +template +struct EnableIf {}; + +template +struct EnableIf { typedef T type; }; + +template +struct Conditional { typedef T type; }; + +template +struct Conditional { typedef F type; }; + +// For bcc32 which doesn't understand ! in template arguments. +template +struct Not { enum { value = 0 }; }; + +template <> +struct Not { enum { value = 1 }; }; + +template +struct FalseType { enum { value = 0 }; }; + +template struct LConvCheck { + LConvCheck(int) {} +}; + +// Returns the thousands separator for the current locale. +// We check if ``lconv`` contains ``thousands_sep`` because on Android +// ``lconv`` is stubbed as an empty struct. +template +inline StringRef thousands_sep( + LConv *lc, LConvCheck = 0) { + return lc->thousands_sep; +} + +inline fmt::StringRef thousands_sep(...) { return ""; } + +#define FMT_CONCAT(a, b) a##b + +#if FMT_GCC_VERSION >= 303 +# define FMT_UNUSED __attribute__((unused)) +#else +# define FMT_UNUSED +#endif + +#ifndef FMT_USE_STATIC_ASSERT +# define FMT_USE_STATIC_ASSERT 0 +#endif + +#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \ + (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600 +# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message) +#else +# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b) +# define FMT_STATIC_ASSERT(cond, message) \ + typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED +#endif + +template +void format_arg(Formatter &, const Char *, const T &) { + FMT_STATIC_ASSERT(FalseType::value, + "Cannot format argument. To enable the use of ostream " + "operator<< include fmt/ostream.h. Otherwise provide " + "an overload of format_arg."); +} + +// Makes an Arg object from any type. +template +class MakeValue : public Arg { + public: + typedef typename Formatter::Char Char; + + private: + // The following two methods are private to disallow formatting of + // arbitrary pointers. If you want to output a pointer cast it to + // "void *" or "const void *". In particular, this forbids formatting + // of "[const] volatile char *" which is printed as bool by iostreams. + // Do not implement! + template + MakeValue(const T *value); + template + MakeValue(T *value); + + // The following methods are private to disallow formatting of wide + // characters and strings into narrow strings as in + // fmt::format("{}", L"test"); + // To fix this, use a wide format string: fmt::format(L"{}", L"test"). +#if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED) + MakeValue(typename WCharHelper::Unsupported); +#endif + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + MakeValue(typename WCharHelper::Unsupported); + + void set_string(StringRef str) { + string.value = str.data(); + string.size = str.size(); + } + + void set_string(WStringRef str) { + wstring.value = str.data(); + wstring.size = str.size(); + } + + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg( + void *formatter, const void *arg, void *format_str_ptr) { + format_arg(*static_cast(formatter), + *static_cast(format_str_ptr), + *static_cast(arg)); + } + + public: + MakeValue() {} + +#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \ + MakeValue(Type value) { field = rhs; } \ + static uint64_t type(Type) { return Arg::TYPE; } + +#define FMT_MAKE_VALUE(Type, field, TYPE) \ + FMT_MAKE_VALUE_(Type, field, TYPE, value) + + FMT_MAKE_VALUE(bool, int_value, BOOL) + FMT_MAKE_VALUE(short, int_value, INT) + FMT_MAKE_VALUE(unsigned short, uint_value, UINT) + FMT_MAKE_VALUE(int, int_value, INT) + FMT_MAKE_VALUE(unsigned, uint_value, UINT) + + MakeValue(long value) { + // To minimize the number of types we need to deal with, long is + // translated either to int or to long long depending on its size. + if (const_check(sizeof(long) == sizeof(int))) + int_value = static_cast(value); + else + long_long_value = value; + } + static uint64_t type(long) { + return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG; + } + + MakeValue(unsigned long value) { + if (const_check(sizeof(unsigned long) == sizeof(unsigned))) + uint_value = static_cast(value); + else + ulong_long_value = value; + } + static uint64_t type(unsigned long) { + return sizeof(unsigned long) == sizeof(unsigned) ? + Arg::UINT : Arg::ULONG_LONG; + } + + FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG) + FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG) + FMT_MAKE_VALUE(float, double_value, DOUBLE) + FMT_MAKE_VALUE(double, double_value, DOUBLE) + FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE) + FMT_MAKE_VALUE(signed char, int_value, INT) + FMT_MAKE_VALUE(unsigned char, uint_value, UINT) + FMT_MAKE_VALUE(char, int_value, CHAR) + +#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) + MakeValue(typename WCharHelper::Supported value) { + int_value = value; + } + static uint64_t type(wchar_t) { return Arg::CHAR; } +#endif + +#define FMT_MAKE_STR_VALUE(Type, TYPE) \ + MakeValue(Type value) { set_string(value); } \ + static uint64_t type(Type) { return Arg::TYPE; } + + FMT_MAKE_VALUE(char *, string.value, CSTRING) + FMT_MAKE_VALUE(const char *, string.value, CSTRING) + FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING) + FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING) + FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING) + FMT_MAKE_STR_VALUE(const std::string &, STRING) + FMT_MAKE_STR_VALUE(StringRef, STRING) + FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str()) + +#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ + MakeValue(typename WCharHelper::Supported value) { \ + set_string(value); \ + } \ + static uint64_t type(Type) { return Arg::TYPE; } + + FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING) + FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING) + FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING) + + FMT_MAKE_VALUE(void *, pointer, POINTER) + FMT_MAKE_VALUE(const void *, pointer, POINTER) + + template + MakeValue(const T &value, + typename EnableIf::value>::value, int>::type = 0) { + custom.value = &value; + custom.format = &format_custom_arg; + } + + template + static typename EnableIf::value>::value, uint64_t>::type + type(const T &) { + return Arg::CUSTOM; + } + + // Additional template param `Char_` is needed here because make_type always + // uses char. + template + MakeValue(const NamedArg &value) { pointer = &value; } + template + MakeValue(const NamedArgWithType &value) { pointer = &value; } + + template + static uint64_t type(const NamedArg &) { return Arg::NAMED_ARG; } + template + static uint64_t type(const NamedArgWithType &) { return Arg::NAMED_ARG; } +}; + +template +class MakeArg : public Arg { +public: + MakeArg() { + type = Arg::NONE; + } + + template + MakeArg(const T &value) + : Arg(MakeValue(value)) { + type = static_cast(MakeValue::type(value)); + } +}; + +template +struct NamedArg : Arg { + BasicStringRef name; + + template + NamedArg(BasicStringRef argname, const T &value) + : Arg(MakeArg< BasicFormatter >(value)), name(argname) {} +}; + +template +struct NamedArgWithType : NamedArg { + NamedArgWithType(BasicStringRef argname, const T &value) + : NamedArg(argname, value) {} +}; + +class RuntimeError : public std::runtime_error { + protected: + RuntimeError() : std::runtime_error("") {} + RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {} + FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT; +}; + +template +class ArgMap; +} // namespace internal + +/** An argument list. */ +class ArgList { + private: + // To reduce compiled code size per formatting function call, types of first + // MAX_PACKED_ARGS arguments are passed in the types_ field. + uint64_t types_; + union { + // If the number of arguments is less than MAX_PACKED_ARGS, the argument + // values are stored in values_, otherwise they are stored in args_. + // This is done to reduce compiled code size as storing larger objects + // may require more code (at least on x86-64) even if the same amount of + // data is actually copied to stack. It saves ~10% on the bloat test. + const internal::Value *values_; + const internal::Arg *args_; + }; + + internal::Arg::Type type(unsigned index) const { + return type(types_, index); + } + + template + friend class internal::ArgMap; + + public: + // Maximum number of arguments with packed types. + enum { MAX_PACKED_ARGS = 16 }; + + ArgList() : types_(0) {} + + ArgList(ULongLong types, const internal::Value *values) + : types_(types), values_(values) {} + ArgList(ULongLong types, const internal::Arg *args) + : types_(types), args_(args) {} + + uint64_t types() const { return types_; } + + /** Returns the argument at specified index. */ + internal::Arg operator[](unsigned index) const { + using internal::Arg; + Arg arg; + bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE; + if (index < MAX_PACKED_ARGS) { + Arg::Type arg_type = type(index); + internal::Value &val = arg; + if (arg_type != Arg::NONE) + val = use_values ? values_[index] : args_[index]; + arg.type = arg_type; + return arg; + } + if (use_values) { + // The index is greater than the number of arguments that can be stored + // in values, so return a "none" argument. + arg.type = Arg::NONE; + return arg; + } + for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) { + if (args_[i].type == Arg::NONE) + return args_[i]; + } + return args_[index]; + } + + static internal::Arg::Type type(uint64_t types, unsigned index) { + unsigned shift = index * 4; + uint64_t mask = 0xf; + return static_cast( + (types & (mask << shift)) >> shift); + } +}; + +#define FMT_DISPATCH(call) static_cast(this)->call + +/** + \rst + An argument visitor based on the `curiously recurring template pattern + `_. + + To use `~fmt::ArgVisitor` define a subclass that implements some or all of the + visit methods with the same signatures as the methods in `~fmt::ArgVisitor`, + for example, `~fmt::ArgVisitor::visit_int()`. + Pass the subclass as the *Impl* template parameter. Then calling + `~fmt::ArgVisitor::visit` for some argument will dispatch to a visit method + specific to the argument type. For example, if the argument type is + ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass + will be called. If the subclass doesn't contain a method with this signature, + then a corresponding method of `~fmt::ArgVisitor` will be called. + + **Example**:: + + class MyArgVisitor : public fmt::ArgVisitor { + public: + void visit_int(int value) { fmt::print("{}", value); } + void visit_double(double value) { fmt::print("{}", value ); } + }; + \endrst + */ +template +class ArgVisitor { + private: + typedef internal::Arg Arg; + + public: + void report_unhandled_arg() {} + + Result visit_unhandled_arg() { + FMT_DISPATCH(report_unhandled_arg()); + return Result(); + } + + /** Visits an ``int`` argument. **/ + Result visit_int(int value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``long long`` argument. **/ + Result visit_long_long(LongLong value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an ``unsigned`` argument. **/ + Result visit_uint(unsigned value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an ``unsigned long long`` argument. **/ + Result visit_ulong_long(ULongLong value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``bool`` argument. **/ + Result visit_bool(bool value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits a ``char`` or ``wchar_t`` argument. **/ + Result visit_char(int value) { + return FMT_DISPATCH(visit_any_int(value)); + } + + /** Visits an argument of any integral type. **/ + template + Result visit_any_int(T) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a ``double`` argument. **/ + Result visit_double(double value) { + return FMT_DISPATCH(visit_any_double(value)); + } + + /** Visits a ``long double`` argument. **/ + Result visit_long_double(long double value) { + return FMT_DISPATCH(visit_any_double(value)); + } + + /** Visits a ``double`` or ``long double`` argument. **/ + template + Result visit_any_double(T) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a null-terminated C string (``const char *``) argument. **/ + Result visit_cstring(const char *) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a string argument. **/ + Result visit_string(Arg::StringValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a wide string argument. **/ + Result visit_wstring(Arg::StringValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits a pointer argument. **/ + Result visit_pointer(const void *) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** Visits an argument of a custom (user-defined) type. **/ + Result visit_custom(Arg::CustomValue) { + return FMT_DISPATCH(visit_unhandled_arg()); + } + + /** + \rst + Visits an argument dispatching to the appropriate visit method based on + the argument type. For example, if the argument type is ``double`` then + the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be + called. + \endrst + */ + Result visit(const Arg &arg) { + switch (arg.type) { + case Arg::NONE: + case Arg::NAMED_ARG: + FMT_ASSERT(false, "invalid argument type"); + break; + case Arg::INT: + return FMT_DISPATCH(visit_int(arg.int_value)); + case Arg::UINT: + return FMT_DISPATCH(visit_uint(arg.uint_value)); + case Arg::LONG_LONG: + return FMT_DISPATCH(visit_long_long(arg.long_long_value)); + case Arg::ULONG_LONG: + return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value)); + case Arg::BOOL: + return FMT_DISPATCH(visit_bool(arg.int_value != 0)); + case Arg::CHAR: + return FMT_DISPATCH(visit_char(arg.int_value)); + case Arg::DOUBLE: + return FMT_DISPATCH(visit_double(arg.double_value)); + case Arg::LONG_DOUBLE: + return FMT_DISPATCH(visit_long_double(arg.long_double_value)); + case Arg::CSTRING: + return FMT_DISPATCH(visit_cstring(arg.string.value)); + case Arg::STRING: + return FMT_DISPATCH(visit_string(arg.string)); + case Arg::WSTRING: + return FMT_DISPATCH(visit_wstring(arg.wstring)); + case Arg::POINTER: + return FMT_DISPATCH(visit_pointer(arg.pointer)); + case Arg::CUSTOM: + return FMT_DISPATCH(visit_custom(arg.custom)); + } + return Result(); + } +}; + +enum Alignment { + ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC +}; + +// Flags. +enum { + SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8, + CHAR_FLAG = 0x10 // Argument has char type - used in error reporting. +}; + +// An empty format specifier. +struct EmptySpec {}; + +// A type specifier. +template +struct TypeSpec : EmptySpec { + Alignment align() const { return ALIGN_DEFAULT; } + unsigned width() const { return 0; } + int precision() const { return -1; } + bool flag(unsigned) const { return false; } + char type() const { return TYPE; } + char type_prefix() const { return TYPE; } + char fill() const { return ' '; } +}; + +// A width specifier. +struct WidthSpec { + unsigned width_; + // Fill is always wchar_t and cast to char if necessary to avoid having + // two specialization of WidthSpec and its subclasses. + wchar_t fill_; + + WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {} + + unsigned width() const { return width_; } + wchar_t fill() const { return fill_; } +}; + +// An alignment specifier. +struct AlignSpec : WidthSpec { + Alignment align_; + + AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT) + : WidthSpec(width, fill), align_(align) {} + + Alignment align() const { return align_; } + + int precision() const { return -1; } +}; + +// An alignment and type specifier. +template +struct AlignTypeSpec : AlignSpec { + AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {} + + bool flag(unsigned) const { return false; } + char type() const { return TYPE; } + char type_prefix() const { return TYPE; } +}; + +// A full format specifier. +struct FormatSpec : AlignSpec { + unsigned flags_; + int precision_; + char type_; + + FormatSpec( + unsigned width = 0, char type = 0, wchar_t fill = ' ') + : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {} + + bool flag(unsigned f) const { return (flags_ & f) != 0; } + int precision() const { return precision_; } + char type() const { return type_; } + char type_prefix() const { return type_; } +}; + +// An integer format specifier. +template , typename Char = char> +class IntFormatSpec : public SpecT { + private: + T value_; + + public: + IntFormatSpec(T val, const SpecT &spec = SpecT()) + : SpecT(spec), value_(val) {} + + T value() const { return value_; } +}; + +// A string format specifier. +template +class StrFormatSpec : public AlignSpec { + private: + const Char *str_; + + public: + template + StrFormatSpec(const Char *str, unsigned width, FillChar fill) + : AlignSpec(width, fill), str_(str) { + internal::CharTraits::convert(FillChar()); + } + + const Char *str() const { return str_; } +}; + +/** + Returns an integer format specifier to format the value in base 2. + */ +IntFormatSpec > bin(int value); + +/** + Returns an integer format specifier to format the value in base 8. + */ +IntFormatSpec > oct(int value); + +/** + Returns an integer format specifier to format the value in base 16 using + lower-case letters for the digits above 9. + */ +IntFormatSpec > hex(int value); + +/** + Returns an integer formatter format specifier to format in base 16 using + upper-case letters for the digits above 9. + */ +IntFormatSpec > hexu(int value); + +/** + \rst + Returns an integer format specifier to pad the formatted argument with the + fill character to the specified width using the default (right) numeric + alignment. + + **Example**:: + + MemoryWriter out; + out << pad(hex(0xcafe), 8, '0'); + // out.str() == "0000cafe" + + \endrst + */ +template +IntFormatSpec, Char> pad( + int value, unsigned width, Char fill = ' '); + +#define FMT_DEFINE_INT_FORMATTERS(TYPE) \ +inline IntFormatSpec > bin(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'b'>()); \ +} \ + \ +inline IntFormatSpec > oct(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'o'>()); \ +} \ + \ +inline IntFormatSpec > hex(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'x'>()); \ +} \ + \ +inline IntFormatSpec > hexu(TYPE value) { \ + return IntFormatSpec >(value, TypeSpec<'X'>()); \ +} \ + \ +template \ +inline IntFormatSpec > pad( \ + IntFormatSpec > f, unsigned width) { \ + return IntFormatSpec >( \ + f.value(), AlignTypeSpec(width, ' ')); \ +} \ + \ +/* For compatibility with older compilers we provide two overloads for pad, */ \ +/* one that takes a fill character and one that doesn't. In the future this */ \ +/* can be replaced with one overload making the template argument Char */ \ +/* default to char (C++11). */ \ +template \ +inline IntFormatSpec, Char> pad( \ + IntFormatSpec, Char> f, \ + unsigned width, Char fill) { \ + return IntFormatSpec, Char>( \ + f.value(), AlignTypeSpec(width, fill)); \ +} \ + \ +inline IntFormatSpec > pad( \ + TYPE value, unsigned width) { \ + return IntFormatSpec >( \ + value, AlignTypeSpec<0>(width, ' ')); \ +} \ + \ +template \ +inline IntFormatSpec, Char> pad( \ + TYPE value, unsigned width, Char fill) { \ + return IntFormatSpec, Char>( \ + value, AlignTypeSpec<0>(width, fill)); \ +} + +FMT_DEFINE_INT_FORMATTERS(int) +FMT_DEFINE_INT_FORMATTERS(long) +FMT_DEFINE_INT_FORMATTERS(unsigned) +FMT_DEFINE_INT_FORMATTERS(unsigned long) +FMT_DEFINE_INT_FORMATTERS(LongLong) +FMT_DEFINE_INT_FORMATTERS(ULongLong) + +/** + \rst + Returns a string formatter that pads the formatted argument with the fill + character to the specified width using the default (left) string alignment. + + **Example**:: + + std::string s = str(MemoryWriter() << pad("abc", 8)); + // s == "abc " + + \endrst + */ +template +inline StrFormatSpec pad( + const Char *str, unsigned width, Char fill = ' ') { + return StrFormatSpec(str, width, fill); +} + +inline StrFormatSpec pad( + const wchar_t *str, unsigned width, char fill = ' ') { + return StrFormatSpec(str, width, fill); +} + +namespace internal { + +template +class ArgMap { + private: + typedef std::vector< + std::pair, internal::Arg> > MapType; + typedef typename MapType::value_type Pair; + + MapType map_; + + public: + FMT_API void init(const ArgList &args); + + const internal::Arg *find(const fmt::BasicStringRef &name) const { + // The list is unsorted, so just return the first matching name. + for (typename MapType::const_iterator it = map_.begin(), end = map_.end(); + it != end; ++it) { + if (it->first == name) + return &it->second; + } + return FMT_NULL; + } +}; + +template +class ArgFormatterBase : public ArgVisitor { + private: + BasicWriter &writer_; + Spec &spec_; + + FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase); + + void write_pointer(const void *p) { + spec_.flags_ = HASH_FLAG; + spec_.type_ = 'x'; + writer_.write_int(reinterpret_cast(p), spec_); + } + + // workaround MSVC two-phase lookup issue + typedef internal::Arg Arg; + + protected: + BasicWriter &writer() { return writer_; } + Spec &spec() { return spec_; } + + void write(bool value) { + const char *str_value = value ? "true" : "false"; + Arg::StringValue str = { str_value, std::strlen(str_value) }; + writer_.write_str(str, spec_); + } + + void write(const char *value) { + Arg::StringValue str = {value, value ? std::strlen(value) : 0}; + writer_.write_str(str, spec_); + } + + public: + typedef Spec SpecType; + + ArgFormatterBase(BasicWriter &w, Spec &s) + : writer_(w), spec_(s) {} + + template + void visit_any_int(T value) { writer_.write_int(value, spec_); } + + template + void visit_any_double(T value) { writer_.write_double(value, spec_); } + + void visit_bool(bool value) { + if (spec_.type_) { + visit_any_int(value); + return; + } + write(value); + } + + void visit_char(int value) { + if (spec_.type_ && spec_.type_ != 'c') { + spec_.flags_ |= CHAR_FLAG; + writer_.write_int(value, spec_); + return; + } + if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0) + FMT_THROW(FormatError("invalid format specifier for char")); + typedef typename BasicWriter::CharPtr CharPtr; + Char fill = internal::CharTraits::cast(spec_.fill()); + CharPtr out = CharPtr(); + const unsigned CHAR_SIZE = 1; + if (spec_.width_ > CHAR_SIZE) { + out = writer_.grow_buffer(spec_.width_); + if (spec_.align_ == ALIGN_RIGHT) { + std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill); + out += spec_.width_ - CHAR_SIZE; + } else if (spec_.align_ == ALIGN_CENTER) { + out = writer_.fill_padding(out, spec_.width_, + internal::const_check(CHAR_SIZE), fill); + } else { + std::uninitialized_fill_n(out + CHAR_SIZE, + spec_.width_ - CHAR_SIZE, fill); + } + } else { + out = writer_.grow_buffer(CHAR_SIZE); + } + *out = internal::CharTraits::cast(value); + } + + void visit_cstring(const char *value) { + if (spec_.type_ == 'p') + return write_pointer(value); + write(value); + } + + // Qualification with "internal" here and below is a workaround for nvcc. + void visit_string(internal::Arg::StringValue value) { + writer_.write_str(value, spec_); + } + + using ArgVisitor::visit_wstring; + + void visit_wstring(internal::Arg::StringValue value) { + writer_.write_str(value, spec_); + } + + void visit_pointer(const void *value) { + if (spec_.type_ && spec_.type_ != 'p') + report_unknown_type(spec_.type_, "pointer"); + write_pointer(value); + } +}; + +class FormatterBase { + private: + ArgList args_; + int next_arg_index_; + + // Returns the argument with specified index. + FMT_API Arg do_get_arg(unsigned arg_index, const char *&error); + + protected: + const ArgList &args() const { return args_; } + + explicit FormatterBase(const ArgList &args) { + args_ = args; + next_arg_index_ = 0; + } + + // Returns the next argument. + Arg next_arg(const char *&error) { + if (next_arg_index_ >= 0) + return do_get_arg(internal::to_unsigned(next_arg_index_++), error); + error = "cannot switch from manual to automatic argument indexing"; + return Arg(); + } + + // Checks if manual indexing is used and returns the argument with + // specified index. + Arg get_arg(unsigned arg_index, const char *&error) { + return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg(); + } + + bool check_no_auto_index(const char *&error) { + if (next_arg_index_ > 0) { + error = "cannot switch from automatic to manual argument indexing"; + return false; + } + next_arg_index_ = -1; + return true; + } + + template + void write(BasicWriter &w, const Char *start, const Char *end) { + if (start != end) + w << BasicStringRef(start, internal::to_unsigned(end - start)); + } +}; +} // namespace internal + +/** + \rst + An argument formatter based on the `curiously recurring template pattern + `_. + + To use `~fmt::BasicArgFormatter` define a subclass that implements some or + all of the visit methods with the same signatures as the methods in + `~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`. + Pass the subclass as the *Impl* template parameter. When a formatting + function processes an argument, it will dispatch to a visit method + specific to the argument type. For example, if the argument type is + ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass + will be called. If the subclass doesn't contain a method with this signature, + then a corresponding method of `~fmt::BasicArgFormatter` or its superclass + will be called. + \endrst + */ +template +class BasicArgFormatter : public internal::ArgFormatterBase { + private: + BasicFormatter &formatter_; + const Char *format_; + + public: + /** + \rst + Constructs an argument formatter object. + *formatter* is a reference to the main formatter object, *spec* contains + format specifier information for standard argument types, and *fmt* points + to the part of the format string being parsed for custom argument types. + \endrst + */ + BasicArgFormatter(BasicFormatter &formatter, + Spec &spec, const Char *fmt) + : internal::ArgFormatterBase(formatter.writer(), spec), + formatter_(formatter), format_(fmt) {} + + /** Formats an argument of a custom (user-defined) type. */ + void visit_custom(internal::Arg::CustomValue c) { + c.format(&formatter_, c.value, &format_); + } +}; + +/** The default argument formatter. */ +template +class ArgFormatter : + public BasicArgFormatter, Char, FormatSpec> { + public: + /** Constructs an argument formatter object. */ + ArgFormatter(BasicFormatter &formatter, + FormatSpec &spec, const Char *fmt) + : BasicArgFormatter, + Char, FormatSpec>(formatter, spec, fmt) {} +}; + +/** This template formats data and writes the output to a writer. */ +template +class BasicFormatter : private internal::FormatterBase { + public: + /** The character type for the output. */ + typedef CharType Char; + + private: + BasicWriter &writer_; + internal::ArgMap map_; + + FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter); + + using internal::FormatterBase::get_arg; + + // Checks if manual indexing is used and returns the argument with + // specified name. + internal::Arg get_arg(BasicStringRef arg_name, const char *&error); + + // Parses argument index and returns corresponding argument. + internal::Arg parse_arg_index(const Char *&s); + + // Parses argument name and returns corresponding argument. + internal::Arg parse_arg_name(const Char *&s); + + public: + /** + \rst + Constructs a ``BasicFormatter`` object. References to the arguments and + the writer are stored in the formatter object so make sure they have + appropriate lifetimes. + \endrst + */ + BasicFormatter(const ArgList &args, BasicWriter &w) + : internal::FormatterBase(args), writer_(w) {} + + /** Returns a reference to the writer associated with this formatter. */ + BasicWriter &writer() { return writer_; } + + /** Formats stored arguments and writes the output to the writer. */ + void format(BasicCStringRef format_str); + + // Formats a single argument and advances format_str, a format string pointer. + const Char *format(const Char *&format_str, const internal::Arg &arg); +}; + +// Generates a comma-separated list with results of applying f to +// numbers 0..n-1. +# define FMT_GEN(n, f) FMT_GEN##n(f) +# define FMT_GEN1(f) f(0) +# define FMT_GEN2(f) FMT_GEN1(f), f(1) +# define FMT_GEN3(f) FMT_GEN2(f), f(2) +# define FMT_GEN4(f) FMT_GEN3(f), f(3) +# define FMT_GEN5(f) FMT_GEN4(f), f(4) +# define FMT_GEN6(f) FMT_GEN5(f), f(5) +# define FMT_GEN7(f) FMT_GEN6(f), f(6) +# define FMT_GEN8(f) FMT_GEN7(f), f(7) +# define FMT_GEN9(f) FMT_GEN8(f), f(8) +# define FMT_GEN10(f) FMT_GEN9(f), f(9) +# define FMT_GEN11(f) FMT_GEN10(f), f(10) +# define FMT_GEN12(f) FMT_GEN11(f), f(11) +# define FMT_GEN13(f) FMT_GEN12(f), f(12) +# define FMT_GEN14(f) FMT_GEN13(f), f(13) +# define FMT_GEN15(f) FMT_GEN14(f), f(14) + +namespace internal { +inline uint64_t make_type() { return 0; } + +template +inline uint64_t make_type(const T &arg) { + return MakeValue< BasicFormatter >::type(arg); +} + +template +struct ArgArray; + +template +struct ArgArray { + typedef Value Type[N > 0 ? N : 1]; + + template + static Value make(const T &value) { +#ifdef __clang__ + Value result = MakeValue(value); + // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang: + // https://github.com/fmtlib/fmt/issues/276 + (void)result.custom.format; + return result; +#else + return MakeValue(value); +#endif + } +}; + +template +struct ArgArray { + typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE + + template + static Arg make(const T &value) { return MakeArg(value); } +}; + +#if FMT_USE_VARIADIC_TEMPLATES +template +inline uint64_t make_type(const Arg &first, const Args & ... tail) { + return make_type(first) | (make_type(tail...) << 4); +} + +#else + +struct ArgType { + uint64_t type; + + ArgType() : type(0) {} + + template + ArgType(const T &arg) : type(make_type(arg)) {} +}; + +# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType() + +inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) { + return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) | + (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) | + (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) | + (t12.type << 48) | (t13.type << 52) | (t14.type << 56); +} +#endif +} // namespace internal + +# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n +# define FMT_MAKE_ARG_TYPE(n) T##n +# define FMT_MAKE_ARG(n) const T##n &v##n +# define FMT_ASSIGN_char(n) \ + arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter >(v##n) +# define FMT_ASSIGN_wchar_t(n) \ + arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter >(v##n) + +#if FMT_USE_VARIADIC_TEMPLATES +// Defines a variadic function returning void. +# define FMT_VARIADIC_VOID(func, arg_type) \ + template \ + void func(arg_type arg0, const Args & ... args) { \ + typedef fmt::internal::ArgArray ArgArray; \ + typename ArgArray::Type array{ \ + ArgArray::template make >(args)...}; \ + func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \ + } + +// Defines a variadic constructor. +# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ + template \ + ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \ + typedef fmt::internal::ArgArray ArgArray; \ + typename ArgArray::Type array{ \ + ArgArray::template make >(args)...}; \ + func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \ + } + +#else + +# define FMT_MAKE_REF(n) \ + fmt::internal::MakeValue< fmt::BasicFormatter >(v##n) +# define FMT_MAKE_REF2(n) v##n + +// Defines a wrapper for a function taking one argument of type arg_type +// and n additional arguments of arbitrary types. +# define FMT_WRAP1(func, arg_type, n) \ + template \ + inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \ + const fmt::internal::ArgArray::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \ + func(arg1, fmt::ArgList( \ + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \ + } + +// Emulates a variadic function returning void on a pre-C++11 compiler. +# define FMT_VARIADIC_VOID(func, arg_type) \ + inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \ + FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \ + FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \ + FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \ + FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \ + FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10) + +# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \ + template \ + ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \ + const fmt::internal::ArgArray::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \ + func(arg0, arg1, fmt::ArgList( \ + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \ + } + +// Emulates a variadic constructor on a pre-C++11 compiler. +# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \ + FMT_CTOR(ctor, func, arg0_type, arg1_type, 10) +#endif + +// Generates a comma-separated list with results of applying f to pairs +// (argument, index). +#define FMT_FOR_EACH1(f, x0) f(x0, 0) +#define FMT_FOR_EACH2(f, x0, x1) \ + FMT_FOR_EACH1(f, x0), f(x1, 1) +#define FMT_FOR_EACH3(f, x0, x1, x2) \ + FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2) +#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \ + FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3) +#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \ + FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4) +#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \ + FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5) +#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \ + FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6) +#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \ + FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7) +#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \ + FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8) +#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \ + FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9) + +/** + An error returned by an operating system or a language runtime, + for example a file opening error. +*/ +class SystemError : public internal::RuntimeError { + private: + FMT_API void init(int err_code, CStringRef format_str, ArgList args); + + protected: + int error_code_; + + typedef char Char; // For FMT_VARIADIC_CTOR. + + SystemError() {} + + public: + /** + \rst + Constructs a :class:`fmt::SystemError` object with a description + formatted with `fmt::format_system_error`. *message* and additional + arguments passed into the constructor are formatted similarly to + `fmt::format`. + + **Example**:: + + // This throws a SystemError with the description + // cannot open file 'madeup': No such file or directory + // or similar (system message may vary). + const char *filename = "madeup"; + std::FILE *file = std::fopen(filename, "r"); + if (!file) + throw fmt::SystemError(errno, "cannot open file '{}'", filename); + \endrst + */ + SystemError(int error_code, CStringRef message) { + init(error_code, message, ArgList()); + } + FMT_DEFAULTED_COPY_CTOR(SystemError) + FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef) + + FMT_API ~SystemError() FMT_DTOR_NOEXCEPT; + + int error_code() const { return error_code_; } +}; + +/** + \rst + Formats an error returned by an operating system or a language runtime, + for example a file opening error, and writes it to *out* in the following + form: + + .. parsed-literal:: + **: ** + + where ** is the passed message and ** is + the system message corresponding to the error code. + *error_code* is a system error code as given by ``errno``. + If *error_code* is not a valid error code such as -1, the system message + may look like "Unknown error -1" and is platform-dependent. + \endrst + */ +FMT_API void format_system_error(fmt::Writer &out, int error_code, + fmt::StringRef message) FMT_NOEXCEPT; + +/** + \rst + This template provides operations for formatting and writing data into + a character stream. The output is stored in a buffer provided by a subclass + such as :class:`fmt::BasicMemoryWriter`. + + You can use one of the following typedefs for common character types: + + +---------+----------------------+ + | Type | Definition | + +=========+======================+ + | Writer | BasicWriter | + +---------+----------------------+ + | WWriter | BasicWriter | + +---------+----------------------+ + + \endrst + */ +template +class BasicWriter { + private: + // Output buffer. + Buffer &buffer_; + + FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter); + + typedef typename internal::CharTraits::CharPtr CharPtr; + +#if FMT_SECURE_SCL + // Returns pointer value. + static Char *get(CharPtr p) { return p.base(); } +#else + static Char *get(Char *p) { return p; } +#endif + + // Fills the padding around the content and returns the pointer to the + // content area. + static CharPtr fill_padding(CharPtr buffer, + unsigned total_size, std::size_t content_size, wchar_t fill); + + // Grows the buffer by n characters and returns a pointer to the newly + // allocated area. + CharPtr grow_buffer(std::size_t n) { + std::size_t size = buffer_.size(); + buffer_.resize(size + n); + return internal::make_ptr(&buffer_[size], n); + } + + // Writes an unsigned decimal integer. + template + Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) { + unsigned num_digits = internal::count_digits(value); + Char *ptr = get(grow_buffer(prefix_size + num_digits)); + internal::format_decimal(ptr + prefix_size, value, num_digits); + return ptr; + } + + // Writes a decimal integer. + template + void write_decimal(Int value) { + typedef typename internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(value); + if (internal::is_negative(value)) { + abs_value = 0 - abs_value; + *write_unsigned_decimal(abs_value, 1) = '-'; + } else { + write_unsigned_decimal(abs_value, 0); + } + } + + // Prepare a buffer for integer formatting. + CharPtr prepare_int_buffer(unsigned num_digits, + const EmptySpec &, const char *prefix, unsigned prefix_size) { + unsigned size = prefix_size + num_digits; + CharPtr p = grow_buffer(size); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } + + template + CharPtr prepare_int_buffer(unsigned num_digits, + const Spec &spec, const char *prefix, unsigned prefix_size); + + // Formats an integer. + template + void write_int(T value, Spec spec); + + // Formats a floating-point number (double or long double). + template + void write_double(T value, const Spec &spec); + + // Writes a formatted string. + template + CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec); + + template + void write_str(const internal::Arg::StringValue &str, + const Spec &spec); + + // This following methods are private to disallow writing wide characters + // and strings to a char stream. If you want to print a wide string as a + // pointer as std::ostream does, cast it to const void*. + // Do not implement! + void operator<<(typename internal::WCharHelper::Unsupported); + void operator<<( + typename internal::WCharHelper::Unsupported); + + // Appends floating-point length specifier to the format string. + // The second argument is only used for overload resolution. + void append_float_length(Char *&format_ptr, long double) { + *format_ptr++ = 'L'; + } + + template + void append_float_length(Char *&, T) {} + + template + friend class internal::ArgFormatterBase; + + template + friend class BasicPrintfArgFormatter; + + protected: + /** + Constructs a ``BasicWriter`` object. + */ + explicit BasicWriter(Buffer &b) : buffer_(b) {} + + public: + /** + \rst + Destroys a ``BasicWriter`` object. + \endrst + */ + virtual ~BasicWriter() {} + + /** + Returns the total number of characters written. + */ + std::size_t size() const { return buffer_.size(); } + + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; } + + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + const Char *c_str() const { + std::size_t size = buffer_.size(); + buffer_.reserve(size + 1); + buffer_[size] = '\0'; + return &buffer_[0]; + } + + /** + \rst + Returns the content of the output buffer as an `std::string`. + \endrst + */ + std::basic_string str() const { + return std::basic_string(&buffer_[0], buffer_.size()); + } + + /** + \rst + Writes formatted data. + + *args* is an argument list representing arbitrary arguments. + + **Example**:: + + MemoryWriter out; + out.write("Current point:\n"); + out.write("({:+f}, {:+f})", -3.14, 3.14); + + This will write the following output to the ``out`` object: + + .. code-block:: none + + Current point: + (-3.140000, +3.140000) + + The output can be accessed using :func:`data()`, :func:`c_str` or + :func:`str` methods. + + See also :ref:`syntax`. + \endrst + */ + void write(BasicCStringRef format, ArgList args) { + BasicFormatter(args, *this).format(format); + } + FMT_VARIADIC_VOID(write, BasicCStringRef) + + BasicWriter &operator<<(int value) { + write_decimal(value); + return *this; + } + BasicWriter &operator<<(unsigned value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(long value) { + write_decimal(value); + return *this; + } + BasicWriter &operator<<(unsigned long value) { + return *this << IntFormatSpec(value); + } + BasicWriter &operator<<(LongLong value) { + write_decimal(value); + return *this; + } + + /** + \rst + Formats *value* and writes it to the stream. + \endrst + */ + BasicWriter &operator<<(ULongLong value) { + return *this << IntFormatSpec(value); + } + + BasicWriter &operator<<(double value) { + write_double(value, FormatSpec()); + return *this; + } + + /** + \rst + Formats *value* using the general format for floating-point numbers + (``'g'``) and writes it to the stream. + \endrst + */ + BasicWriter &operator<<(long double value) { + write_double(value, FormatSpec()); + return *this; + } + + /** + Writes a character to the stream. + */ + BasicWriter &operator<<(char value) { + buffer_.push_back(value); + return *this; + } + + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) { + buffer_.push_back(value); + return *this; + } + + /** + \rst + Writes *value* to the stream. + \endrst + */ + BasicWriter &operator<<(fmt::BasicStringRef value) { + const Char *str = value.data(); + buffer_.append(str, str + value.size()); + return *this; + } + + BasicWriter &operator<<( + typename internal::WCharHelper::Supported value) { + const char *str = value.data(); + buffer_.append(str, str + value.size()); + return *this; + } + + template + BasicWriter &operator<<(IntFormatSpec spec) { + internal::CharTraits::convert(FillChar()); + write_int(spec.value(), spec); + return *this; + } + + template + BasicWriter &operator<<(const StrFormatSpec &spec) { + const StrChar *s = spec.str(); + write_str(s, std::char_traits::length(s), spec); + return *this; + } + + void clear() FMT_NOEXCEPT { buffer_.clear(); } + + Buffer &buffer() FMT_NOEXCEPT { return buffer_; } +}; + +template +template +typename BasicWriter::CharPtr BasicWriter::write_str( + const StrChar *s, std::size_t size, const AlignSpec &spec) { + CharPtr out = CharPtr(); + if (spec.width() > size) { + out = grow_buffer(spec.width()); + Char fill = internal::CharTraits::cast(spec.fill()); + if (spec.align() == ALIGN_RIGHT) { + std::uninitialized_fill_n(out, spec.width() - size, fill); + out += spec.width() - size; + } else if (spec.align() == ALIGN_CENTER) { + out = fill_padding(out, spec.width(), size, fill); + } else { + std::uninitialized_fill_n(out + size, spec.width() - size, fill); + } + } else { + out = grow_buffer(size); + } + std::uninitialized_copy(s, s + size, out); + return out; +} + +template +template +void BasicWriter::write_str( + const internal::Arg::StringValue &s, const Spec &spec) { + // Check if StrChar is convertible to Char. + internal::CharTraits::convert(StrChar()); + if (spec.type_ && spec.type_ != 's') + internal::report_unknown_type(spec.type_, "string"); + const StrChar *str_value = s.value; + std::size_t str_size = s.size; + if (str_size == 0) { + if (!str_value) { + FMT_THROW(FormatError("string pointer is null")); + } + } + std::size_t precision = static_cast(spec.precision_); + if (spec.precision_ >= 0 && precision < str_size) + str_size = precision; + write_str(str_value, str_size, spec); +} + +template +typename BasicWriter::CharPtr + BasicWriter::fill_padding( + CharPtr buffer, unsigned total_size, + std::size_t content_size, wchar_t fill) { + std::size_t padding = total_size - content_size; + std::size_t left_padding = padding / 2; + Char fill_char = internal::CharTraits::cast(fill); + std::uninitialized_fill_n(buffer, left_padding, fill_char); + buffer += left_padding; + CharPtr content = buffer; + std::uninitialized_fill_n(buffer + content_size, + padding - left_padding, fill_char); + return content; +} + +template +template +typename BasicWriter::CharPtr + BasicWriter::prepare_int_buffer( + unsigned num_digits, const Spec &spec, + const char *prefix, unsigned prefix_size) { + unsigned width = spec.width(); + Alignment align = spec.align(); + Char fill = internal::CharTraits::cast(spec.fill()); + if (spec.precision() > static_cast(num_digits)) { + // Octal prefix '0' is counted as a digit, so ignore it if precision + // is specified. + if (prefix_size > 0 && prefix[prefix_size - 1] == '0') + --prefix_size; + unsigned number_size = + prefix_size + internal::to_unsigned(spec.precision()); + AlignSpec subspec(number_size, '0', ALIGN_NUMERIC); + if (number_size >= width) + return prepare_int_buffer(num_digits, subspec, prefix, prefix_size); + buffer_.reserve(width); + unsigned fill_size = width - number_size; + if (align != ALIGN_LEFT) { + CharPtr p = grow_buffer(fill_size); + std::uninitialized_fill(p, p + fill_size, fill); + } + CharPtr result = prepare_int_buffer( + num_digits, subspec, prefix, prefix_size); + if (align == ALIGN_LEFT) { + CharPtr p = grow_buffer(fill_size); + std::uninitialized_fill(p, p + fill_size, fill); + } + return result; + } + unsigned size = prefix_size + num_digits; + if (width <= size) { + CharPtr p = grow_buffer(size); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + return p + size - 1; + } + CharPtr p = grow_buffer(width); + CharPtr end = p + width; + if (align == ALIGN_LEFT) { + std::uninitialized_copy(prefix, prefix + prefix_size, p); + p += size; + std::uninitialized_fill(p, end, fill); + } else if (align == ALIGN_CENTER) { + p = fill_padding(p, width, size, fill); + std::uninitialized_copy(prefix, prefix + prefix_size, p); + p += size; + } else { + if (align == ALIGN_NUMERIC) { + if (prefix_size != 0) { + p = std::uninitialized_copy(prefix, prefix + prefix_size, p); + size -= prefix_size; + } + } else { + std::uninitialized_copy(prefix, prefix + prefix_size, end - size); + } + std::uninitialized_fill(p, end - size, fill); + p = end; + } + return p - 1; +} + +template +template +void BasicWriter::write_int(T value, Spec spec) { + unsigned prefix_size = 0; + typedef typename internal::IntTraits::MainType UnsignedType; + UnsignedType abs_value = static_cast(value); + char prefix[4] = ""; + if (internal::is_negative(value)) { + prefix[0] = '-'; + ++prefix_size; + abs_value = 0 - abs_value; + } else if (spec.flag(SIGN_FLAG)) { + prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; + ++prefix_size; + } + switch (spec.type()) { + case 0: case 'd': { + unsigned num_digits = internal::count_digits(abs_value); + CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1; + internal::format_decimal(get(p), abs_value, 0); + break; + } + case 'x': case 'X': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = spec.type_prefix(); + } + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 4) != 0); + Char *p = get(prepare_int_buffer( + num_digits, spec, prefix, prefix_size)); + n = abs_value; + const char *digits = spec.type() == 'x' ? + "0123456789abcdef" : "0123456789ABCDEF"; + do { + *p-- = digits[n & 0xf]; + } while ((n >>= 4) != 0); + break; + } + case 'b': case 'B': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = spec.type_prefix(); + } + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 1) != 0); + Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); + n = abs_value; + do { + *p-- = static_cast('0' + (n & 1)); + } while ((n >>= 1) != 0); + break; + } + case 'o': { + UnsignedType n = abs_value; + if (spec.flag(HASH_FLAG)) + prefix[prefix_size++] = '0'; + unsigned num_digits = 0; + do { + ++num_digits; + } while ((n >>= 3) != 0); + Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size)); + n = abs_value; + do { + *p-- = static_cast('0' + (n & 7)); + } while ((n >>= 3) != 0); + break; + } + case 'n': { + unsigned num_digits = internal::count_digits(abs_value); + fmt::StringRef sep = ""; +#if !(defined(ANDROID) || defined(__ANDROID__)) + sep = internal::thousands_sep(std::localeconv()); +#endif + unsigned size = static_cast( + num_digits + sep.size() * ((num_digits - 1) / 3)); + CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1; + internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep)); + break; + } + default: + internal::report_unknown_type( + spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer"); + break; + } +} + +template +template +void BasicWriter::write_double(T value, const Spec &spec) { + // Check type. + char type = spec.type(); + bool upper = false; + switch (type) { + case 0: + type = 'g'; + break; + case 'e': case 'f': case 'g': case 'a': + break; + case 'F': +#if FMT_MSC_VER + // MSVC's printf doesn't support 'F'. + type = 'f'; +#endif + // Fall through. + case 'E': case 'G': case 'A': + upper = true; + break; + default: + internal::report_unknown_type(type, "double"); + break; + } + + char sign = 0; + // Use isnegative instead of value < 0 because the latter is always + // false for NaN. + if (internal::FPUtil::isnegative(static_cast(value))) { + sign = '-'; + value = -value; + } else if (spec.flag(SIGN_FLAG)) { + sign = spec.flag(PLUS_FLAG) ? '+' : ' '; + } + + if (internal::FPUtil::isnotanumber(value)) { + // Format NaN ourselves because sprintf's output is not consistent + // across platforms. + std::size_t nan_size = 4; + const char *nan = upper ? " NAN" : " nan"; + if (!sign) { + --nan_size; + ++nan; + } + CharPtr out = write_str(nan, nan_size, spec); + if (sign) + *out = sign; + return; + } + + if (internal::FPUtil::isinfinity(value)) { + // Format infinity ourselves because sprintf's output is not consistent + // across platforms. + std::size_t inf_size = 4; + const char *inf = upper ? " INF" : " inf"; + if (!sign) { + --inf_size; + ++inf; + } + CharPtr out = write_str(inf, inf_size, spec); + if (sign) + *out = sign; + return; + } + + std::size_t offset = buffer_.size(); + unsigned width = spec.width(); + if (sign) { + buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u)); + if (width > 0) + --width; + ++offset; + } + + // Build format string. + enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg + Char format[MAX_FORMAT_SIZE]; + Char *format_ptr = format; + *format_ptr++ = '%'; + unsigned width_for_sprintf = width; + if (spec.flag(HASH_FLAG)) + *format_ptr++ = '#'; + if (spec.align() == ALIGN_CENTER) { + width_for_sprintf = 0; + } else { + if (spec.align() == ALIGN_LEFT) + *format_ptr++ = '-'; + if (width != 0) + *format_ptr++ = '*'; + } + if (spec.precision() >= 0) { + *format_ptr++ = '.'; + *format_ptr++ = '*'; + } + + append_float_length(format_ptr, value); + *format_ptr++ = type; + *format_ptr = '\0'; + + // Format using snprintf. + Char fill = internal::CharTraits::cast(spec.fill()); + unsigned n = 0; + Char *start = FMT_NULL; + for (;;) { + std::size_t buffer_size = buffer_.capacity() - offset; +#if FMT_MSC_VER + // MSVC's vsnprintf_s doesn't work with zero size, so reserve + // space for at least one extra character to make the size non-zero. + // Note that the buffer's capacity will increase by more than 1. + if (buffer_size == 0) { + buffer_.reserve(offset + 1); + buffer_size = buffer_.capacity() - offset; + } +#endif + start = &buffer_[offset]; + int result = internal::CharTraits::format_float( + start, buffer_size, format, width_for_sprintf, spec.precision(), value); + if (result >= 0) { + n = internal::to_unsigned(result); + if (offset + n < buffer_.capacity()) + break; // The buffer is large enough - continue with formatting. + buffer_.reserve(offset + n + 1); + } else { + // If result is negative we ask to increase the capacity by at least 1, + // but as std::vector, the buffer grows exponentially. + buffer_.reserve(buffer_.capacity() + 1); + } + } + if (sign) { + if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || + *start != ' ') { + *(start - 1) = sign; + sign = 0; + } else { + *(start - 1) = fill; + } + ++n; + } + if (spec.align() == ALIGN_CENTER && spec.width() > n) { + width = spec.width(); + CharPtr p = grow_buffer(width); + std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char)); + fill_padding(p, spec.width(), n, fill); + return; + } + if (spec.fill() != ' ' || sign) { + while (*start == ' ') + *start++ = fill; + if (sign) + *(start - 1) = sign; + } + grow_buffer(n); +} + +/** + \rst + This class template provides operations for formatting and writing data + into a character stream. The output is stored in a memory buffer that grows + dynamically. + + You can use one of the following typedefs for common character types + and the standard allocator: + + +---------------+-----------------------------------------------------+ + | Type | Definition | + +===============+=====================================================+ + | MemoryWriter | BasicMemoryWriter> | + +---------------+-----------------------------------------------------+ + | WMemoryWriter | BasicMemoryWriter> | + +---------------+-----------------------------------------------------+ + + **Example**:: + + MemoryWriter out; + out << "The answer is " << 42 << "\n"; + out.write("({:+f}, {:+f})", -3.14, 3.14); + + This will write the following output to the ``out`` object: + + .. code-block:: none + + The answer is 42 + (-3.140000, +3.140000) + + The output can be converted to an ``std::string`` with ``out.str()`` or + accessed as a C string with ``out.c_str()``. + \endrst + */ +template > +class BasicMemoryWriter : public BasicWriter { + private: + internal::MemoryBuffer buffer_; + + public: + explicit BasicMemoryWriter(const Allocator& alloc = Allocator()) + : BasicWriter(buffer_), buffer_(alloc) {} + +#if FMT_USE_RVALUE_REFERENCES + /** + \rst + Constructs a :class:`fmt::BasicMemoryWriter` object moving the content + of the other object to it. + \endrst + */ + BasicMemoryWriter(BasicMemoryWriter &&other) + : BasicWriter(buffer_), buffer_(std::move(other.buffer_)) { + } + + /** + \rst + Moves the content of the other ``BasicMemoryWriter`` object to this one. + \endrst + */ + BasicMemoryWriter &operator=(BasicMemoryWriter &&other) { + buffer_ = std::move(other.buffer_); + return *this; + } +#endif +}; + +typedef BasicMemoryWriter MemoryWriter; +typedef BasicMemoryWriter WMemoryWriter; + +/** + \rst + This class template provides operations for formatting and writing data + into a fixed-size array. For writing into a dynamically growing buffer + use :class:`fmt::BasicMemoryWriter`. + + Any write method will throw ``std::runtime_error`` if the output doesn't fit + into the array. + + You can use one of the following typedefs for common character types: + + +--------------+---------------------------+ + | Type | Definition | + +==============+===========================+ + | ArrayWriter | BasicArrayWriter | + +--------------+---------------------------+ + | WArrayWriter | BasicArrayWriter | + +--------------+---------------------------+ + \endrst + */ +template +class BasicArrayWriter : public BasicWriter { + private: + internal::FixedBuffer buffer_; + + public: + /** + \rst + Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the + given size. + \endrst + */ + BasicArrayWriter(Char *array, std::size_t size) + : BasicWriter(buffer_), buffer_(array, size) {} + + /** + \rst + Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the + size known at compile time. + \endrst + */ + template + explicit BasicArrayWriter(Char (&array)[SIZE]) + : BasicWriter(buffer_), buffer_(array, SIZE) {} +}; + +typedef BasicArrayWriter ArrayWriter; +typedef BasicArrayWriter WArrayWriter; + +// Reports a system error without throwing an exception. +// Can be used to report errors from destructors. +FMT_API void report_system_error(int error_code, + StringRef message) FMT_NOEXCEPT; + +#if FMT_USE_WINDOWS_H + +/** A Windows error. */ +class WindowsError : public SystemError { + private: + FMT_API void init(int error_code, CStringRef format_str, ArgList args); + + public: + /** + \rst + Constructs a :class:`fmt::WindowsError` object with the description + of the form + + .. parsed-literal:: + **: ** + + where ** is the formatted message and ** 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 WindowsError 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::WindowsError(GetLastError(), + "cannot open file '{}'", filename); + } + \endrst + */ + WindowsError(int error_code, CStringRef message) { + init(error_code, message, ArgList()); + } + FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef) +}; + +// 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, + StringRef message) FMT_NOEXCEPT; + +#endif + +enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE }; + +/** + Formats a string and prints it to stdout using ANSI escape sequences + to specify color (experimental). + Example: + print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23); + */ +FMT_API void print_colored(Color c, CStringRef format, ArgList args); + +/** + \rst + Formats arguments and returns the result as a string. + + **Example**:: + + std::string message = format("The answer is {}", 42); + \endrst +*/ +inline std::string format(CStringRef format_str, ArgList args) { + MemoryWriter w; + w.write(format_str, args); + return w.str(); +} + +inline std::wstring format(WCStringRef format_str, ArgList args) { + WMemoryWriter w; + w.write(format_str, args); + return w.str(); +} + +/** + \rst + Prints formatted data to the file *f*. + + **Example**:: + + print(stderr, "Don't {}!", "panic"); + \endrst + */ +FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args); + +/** + \rst + Prints formatted data to ``stdout``. + + **Example**:: + + print("Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ +FMT_API void print(CStringRef format_str, ArgList args); + +/** + Fast integer formatter. + */ +class FormatInt { + private: + // Buffer should be large enough to hold all digits (digits10 + 1), + // a sign and a null character. + enum {BUFFER_SIZE = std::numeric_limits::digits10 + 3}; + mutable char buffer_[BUFFER_SIZE]; + char *str_; + + // Formats value in reverse and returns the number of digits. + char *format_decimal(ULongLong value) { + char *buffer_end = buffer_ + BUFFER_SIZE - 1; + while (value >= 100) { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = static_cast((value % 100) * 2); + value /= 100; + *--buffer_end = internal::Data::DIGITS[index + 1]; + *--buffer_end = internal::Data::DIGITS[index]; + } + if (value < 10) { + *--buffer_end = static_cast('0' + value); + return buffer_end; + } + unsigned index = static_cast(value * 2); + *--buffer_end = internal::Data::DIGITS[index + 1]; + *--buffer_end = internal::Data::DIGITS[index]; + return buffer_end; + } + + void FormatSigned(LongLong value) { + ULongLong abs_value = static_cast(value); + bool negative = value < 0; + if (negative) + abs_value = 0 - abs_value; + str_ = format_decimal(abs_value); + if (negative) + *--str_ = '-'; + } + + public: + explicit FormatInt(int value) { FormatSigned(value); } + explicit FormatInt(long value) { FormatSigned(value); } + explicit FormatInt(LongLong value) { FormatSigned(value); } + explicit FormatInt(unsigned value) : str_(format_decimal(value)) {} + explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {} + explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {} + + /** Returns the number of characters written to the output buffer. */ + std::size_t size() const { + return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1); + } + + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const char *data() const { return str_; } + + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + const char *c_str() const { + buffer_[BUFFER_SIZE - 1] = '\0'; + return str_; + } + + /** + \rst + Returns the content of the output buffer as an ``std::string``. + \endrst + */ + std::string str() const { return std::string(str_, size()); } +}; + +// Formats a decimal integer value writing into buffer and returns +// a pointer to the end of the formatted string. This function doesn't +// write a terminating null character. +template +inline void format_decimal(char *&buffer, T value) { + typedef typename internal::IntTraits::MainType MainType; + MainType abs_value = static_cast(value); + if (internal::is_negative(value)) { + *buffer++ = '-'; + abs_value = 0 - abs_value; + } + if (abs_value < 100) { + if (abs_value < 10) { + *buffer++ = static_cast('0' + abs_value); + return; + } + unsigned index = static_cast(abs_value * 2); + *buffer++ = internal::Data::DIGITS[index]; + *buffer++ = internal::Data::DIGITS[index + 1]; + return; + } + unsigned num_digits = internal::count_digits(abs_value); + internal::format_decimal(buffer, abs_value, num_digits); + buffer += num_digits; +} + +/** + \rst + Returns a named argument for formatting functions. + + **Example**:: + + print("Elapsed time: {s:.2f} seconds", arg("s", 1.23)); + + \endrst + */ +template +inline internal::NamedArgWithType arg(StringRef name, const T &arg) { + return internal::NamedArgWithType(name, arg); +} + +template +inline internal::NamedArgWithType arg(WStringRef name, const T &arg) { + return internal::NamedArgWithType(name, arg); +} + +// The following two functions are deleted intentionally to disable +// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``. +template +void arg(StringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; +template +void arg(WStringRef, const internal::NamedArg&) FMT_DELETED_OR_UNDEFINED; +} + +#if FMT_GCC_VERSION +// Use the system_header pragma to suppress warnings about variadic macros +// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't +// work. It is used at the end because we want to suppress as little warnings +// as possible. +# pragma GCC system_header +#endif + +// This is used to work around VC++ bugs in handling variadic macros. +#define FMT_EXPAND(args) args + +// Returns the number of arguments. +// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s. +#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N()) +#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__)) +#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N +#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 + +#define FMT_FOR_EACH_(N, f, ...) \ + FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__)) +#define FMT_FOR_EACH(f, ...) \ + FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__)) + +#define FMT_ADD_ARG_NAME(type, index) type arg##index +#define FMT_GET_ARG_NAME(type, index) arg##index + +#if FMT_USE_VARIADIC_TEMPLATES +# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ + template \ + ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ + const Args & ... args) { \ + typedef fmt::internal::ArgArray ArgArray; \ + typename ArgArray::Type array{ \ + ArgArray::template make >(args)...}; \ + call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \ + fmt::ArgList(fmt::internal::make_type(args...), array)); \ + } +#else +// Defines a wrapper for a function taking __VA_ARGS__ arguments +// and n additional arguments of arbitrary types. +# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \ + template \ + inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ + FMT_GEN(n, FMT_MAKE_ARG)) { \ + fmt::internal::ArgArray::Type arr; \ + FMT_GEN(n, FMT_ASSIGN_##Char); \ + call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \ + fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \ + } + +# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ + inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \ + call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \ + } \ + FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \ + FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__) +#endif // FMT_USE_VARIADIC_TEMPLATES + +/** + \rst + Defines a variadic function with the specified return type, function name + and argument types passed as variable arguments to this macro. + + **Example**:: + + void print_error(const char *file, int line, const char *format, + fmt::ArgList args) { + fmt::print("{}: {}: ", file, line); + fmt::print(format, args); + } + FMT_VARIADIC(void, print_error, const char *, int, const char *) + + ``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that + don't implement variadic templates. You don't have to use this macro if + you don't need legacy compiler support and can use variadic templates + directly:: + + template + void print_error(const char *file, int line, const char *format, + const Args & ... args) { + fmt::print("{}: {}: ", file, line); + fmt::print(format, args...); + } + \endrst + */ +#define FMT_VARIADIC(ReturnType, func, ...) \ + FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__) + +#define FMT_VARIADIC_W(ReturnType, func, ...) \ + FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__) + +#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id) + +#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id) + +/** + \rst + Convenient macro to capture the arguments' names and values into several + ``fmt::arg(name, value)``. + + **Example**:: + + int x = 1, y = 2; + print("point: ({x}, {y})", FMT_CAPTURE(x, y)); + // same as: + // print("point: ({x}, {y})", arg("x", x), arg("y", y)); + + \endrst + */ +#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__) + +#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__) + +namespace fmt { +FMT_VARIADIC(std::string, format, CStringRef) +FMT_VARIADIC_W(std::wstring, format, WCStringRef) +FMT_VARIADIC(void, print, CStringRef) +FMT_VARIADIC(void, print, std::FILE *, CStringRef) +FMT_VARIADIC(void, print_colored, Color, CStringRef) + +namespace internal { +template +inline bool is_name_start(Char c) { + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; +} + +// Parses an unsigned integer advancing s to the end of the parsed input. +// This function assumes that the first character of s is a digit. +template +unsigned parse_nonnegative_int(const Char *&s) { + assert('0' <= *s && *s <= '9'); + unsigned value = 0; + do { + unsigned new_value = value * 10 + (*s++ - '0'); + // Check if value wrapped around. + if (new_value < value) { + value = (std::numeric_limits::max)(); + break; + } + value = new_value; + } while ('0' <= *s && *s <= '9'); + // Convert to unsigned to prevent a warning. + unsigned max_int = (std::numeric_limits::max)(); + if (value > max_int) + FMT_THROW(FormatError("number is too big")); + return value; +} + +inline void require_numeric_argument(const Arg &arg, char spec) { + if (arg.type > Arg::LAST_NUMERIC_TYPE) { + std::string message = + fmt::format("format specifier '{}' requires numeric argument", spec); + FMT_THROW(fmt::FormatError(message)); + } +} + +template +void check_sign(const Char *&s, const Arg &arg) { + char sign = static_cast(*s); + require_numeric_argument(arg, sign); + if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) { + FMT_THROW(FormatError(fmt::format( + "format specifier '{}' requires signed argument", sign))); + } + ++s; +} +} // namespace internal + +template +inline internal::Arg BasicFormatter::get_arg( + BasicStringRef arg_name, const char *&error) { + if (check_no_auto_index(error)) { + map_.init(args()); + const internal::Arg *arg = map_.find(arg_name); + if (arg) + return *arg; + error = "argument not found"; + } + return internal::Arg(); +} + +template +inline internal::Arg BasicFormatter::parse_arg_index(const Char *&s) { + const char *error = FMT_NULL; + internal::Arg arg = *s < '0' || *s > '9' ? + next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error); + if (error) { + FMT_THROW(FormatError( + *s != '}' && *s != ':' ? "invalid format string" : error)); + } + return arg; +} + +template +inline internal::Arg BasicFormatter::parse_arg_name(const Char *&s) { + assert(internal::is_name_start(*s)); + const Char *start = s; + Char c; + do { + c = *++s; + } while (internal::is_name_start(c) || ('0' <= c && c <= '9')); + const char *error = FMT_NULL; + internal::Arg arg = get_arg(BasicStringRef(start, s - start), error); + if (error) + FMT_THROW(FormatError(error)); + return arg; +} + +template +const Char *BasicFormatter::format( + const Char *&format_str, const internal::Arg &arg) { + using internal::Arg; + const Char *s = format_str; + typename ArgFormatter::SpecType spec; + if (*s == ':') { + if (arg.type == Arg::CUSTOM) { + arg.custom.format(this, arg.custom.value, &s); + return s; + } + ++s; + // Parse fill and alignment. + if (Char c = *s) { + const Char *p = s + 1; + spec.align_ = ALIGN_DEFAULT; + do { + switch (*p) { + case '<': + spec.align_ = ALIGN_LEFT; + break; + case '>': + spec.align_ = ALIGN_RIGHT; + break; + case '=': + spec.align_ = ALIGN_NUMERIC; + break; + case '^': + spec.align_ = ALIGN_CENTER; + break; + } + if (spec.align_ != ALIGN_DEFAULT) { + if (p != s) { + if (c == '}') break; + if (c == '{') + FMT_THROW(FormatError("invalid fill character '{'")); + s += 2; + spec.fill_ = c; + } else ++s; + if (spec.align_ == ALIGN_NUMERIC) + require_numeric_argument(arg, '='); + break; + } + } while (--p >= s); + } + + // Parse sign. + switch (*s) { + case '+': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + break; + case '-': + check_sign(s, arg); + spec.flags_ |= MINUS_FLAG; + break; + case ' ': + check_sign(s, arg); + spec.flags_ |= SIGN_FLAG; + break; + } + + if (*s == '#') { + require_numeric_argument(arg, '#'); + spec.flags_ |= HASH_FLAG; + ++s; + } + + // Parse zero flag. + if (*s == '0') { + require_numeric_argument(arg, '0'); + spec.align_ = ALIGN_NUMERIC; + spec.fill_ = '0'; + ++s; + } + + // Parse width. + if ('0' <= *s && *s <= '9') { + spec.width_ = internal::parse_nonnegative_int(s); + } else if (*s == '{') { + ++s; + Arg width_arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + if (*s++ != '}') + FMT_THROW(FormatError("invalid format string")); + ULongLong value = 0; + switch (width_arg.type) { + case Arg::INT: + if (width_arg.int_value < 0) + FMT_THROW(FormatError("negative width")); + value = width_arg.int_value; + break; + case Arg::UINT: + value = width_arg.uint_value; + break; + case Arg::LONG_LONG: + if (width_arg.long_long_value < 0) + FMT_THROW(FormatError("negative width")); + value = width_arg.long_long_value; + break; + case Arg::ULONG_LONG: + value = width_arg.ulong_long_value; + break; + default: + FMT_THROW(FormatError("width is not integer")); + } + if (value > (std::numeric_limits::max)()) + FMT_THROW(FormatError("number is too big")); + spec.width_ = static_cast(value); + } + + // Parse precision. + if (*s == '.') { + ++s; + spec.precision_ = 0; + if ('0' <= *s && *s <= '9') { + spec.precision_ = internal::parse_nonnegative_int(s); + } else if (*s == '{') { + ++s; + Arg precision_arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + if (*s++ != '}') + FMT_THROW(FormatError("invalid format string")); + ULongLong value = 0; + switch (precision_arg.type) { + case Arg::INT: + if (precision_arg.int_value < 0) + FMT_THROW(FormatError("negative precision")); + value = precision_arg.int_value; + break; + case Arg::UINT: + value = precision_arg.uint_value; + break; + case Arg::LONG_LONG: + if (precision_arg.long_long_value < 0) + FMT_THROW(FormatError("negative precision")); + value = precision_arg.long_long_value; + break; + case Arg::ULONG_LONG: + value = precision_arg.ulong_long_value; + break; + default: + FMT_THROW(FormatError("precision is not integer")); + } + if (value > (std::numeric_limits::max)()) + FMT_THROW(FormatError("number is too big")); + spec.precision_ = static_cast(value); + } else { + FMT_THROW(FormatError("missing precision specifier")); + } + if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) { + FMT_THROW(FormatError( + fmt::format("precision not allowed in {} format specifier", + arg.type == Arg::POINTER ? "pointer" : "integer"))); + } + } + + // Parse type. + if (*s != '}' && *s) + spec.type_ = static_cast(*s++); + } + + if (*s++ != '}') + FMT_THROW(FormatError("missing '}' in format string")); + + // Format argument. + ArgFormatter(*this, spec, s - 1).visit(arg); + return s; +} + +template +void BasicFormatter::format(BasicCStringRef format_str) { + const Char *s = format_str.c_str(); + const Char *start = s; + while (*s) { + Char c = *s++; + if (c != '{' && c != '}') continue; + if (*s == c) { + write(writer_, start, s); + start = ++s; + continue; + } + if (c == '}') + FMT_THROW(FormatError("unmatched '}' in format string")); + write(writer_, start, s - 1); + internal::Arg arg = internal::is_name_start(*s) ? + parse_arg_name(s) : parse_arg_index(s); + start = s = format(s, arg); + } + write(writer_, start, s); +} + +template +struct ArgJoin { + It first; + It last; + BasicCStringRef sep; + + ArgJoin(It first, It last, const BasicCStringRef& sep) : + first(first), + last(last), + sep(sep) {} +}; + +template +ArgJoin join(It first, It last, const BasicCStringRef& sep) { + return ArgJoin(first, last, sep); +} + +template +ArgJoin join(It first, It last, const BasicCStringRef& sep) { + return ArgJoin(first, last, sep); +} + +#if FMT_HAS_GXX_CXX11 +template +auto join(const Range& range, const BasicCStringRef& sep) + -> ArgJoin { + return join(std::begin(range), std::end(range), sep); +} + +template +auto join(const Range& range, const BasicCStringRef& sep) + -> ArgJoin { + return join(std::begin(range), std::end(range), sep); +} +#endif + +template +void format_arg(fmt::BasicFormatter &f, + const Char *&format_str, const ArgJoin& e) { + const Char* end = format_str; + if (*end == ':') + ++end; + while (*end && *end != '}') + ++end; + if (*end != '}') + FMT_THROW(FormatError("missing '}' in format string")); + + It it = e.first; + if (it != e.last) { + const Char* save = format_str; + f.format(format_str, internal::MakeArg >(*it++)); + while (it != e.last) { + f.writer().write(e.sep); + format_str = save; + f.format(format_str, internal::MakeArg >(*it++)); + } + } + format_str = end + 1; +} +} // namespace fmt + +#if FMT_USE_USER_DEFINED_LITERALS +namespace fmt { +namespace internal { + +template +struct UdlFormat { + const Char *str; + + template + auto operator()(Args && ... args) const + -> decltype(format(str, std::forward(args)...)) { + return format(str, std::forward(args)...); + } +}; + +template +struct UdlArg { + const Char *str; + + template + NamedArgWithType operator=(T &&value) const { + return {str, std::forward(value)}; + } +}; + +} // namespace internal + +inline namespace literals { + +/** + \rst + C++11 literal equivalent of :func:`fmt::format`. + + **Example**:: + + using namespace fmt::literals; + std::string message = "The answer is {}"_format(42); + \endrst + */ +inline internal::UdlFormat +operator"" _format(const char *s, std::size_t) { return {s}; } +inline internal::UdlFormat +operator"" _format(const wchar_t *s, std::size_t) { return {s}; } + +/** + \rst + C++11 literal equivalent of :func:`fmt::arg`. + + **Example**:: + + using namespace fmt::literals; + print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); + \endrst + */ +inline internal::UdlArg +operator"" _a(const char *s, std::size_t) { return {s}; } +inline internal::UdlArg +operator"" _a(const wchar_t *s, std::size_t) { return {s}; } + +} // inline namespace literals +} // namespace fmt +#endif // FMT_USE_USER_DEFINED_LITERALS + +// Restore warnings. +#if FMT_GCC_VERSION >= 406 +# pragma GCC diagnostic pop +#endif + +#if defined(__clang__) && !defined(FMT_ICC_VERSION) +# pragma clang diagnostic pop +#endif + +#ifdef FMT_HEADER_ONLY +# define FMT_FUNC inline +# include "format.cc" +#else +# define FMT_FUNC +#endif + +#endif // FMT_FORMAT_H_ diff --git a/linux/include/fmt/ostream.cc b/linux/include/fmt/ostream.cc new file mode 100644 index 000000000..2d443f730 --- /dev/null +++ b/linux/include/fmt/ostream.cc @@ -0,0 +1,35 @@ +/* + Formatting library for C++ - std::ostream support + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +#include "ostream.h" + +namespace fmt { + +namespace internal { +FMT_FUNC void write(std::ostream &os, Writer &w) { + const char *data = w.data(); + typedef internal::MakeUnsigned::Type UnsignedStreamSize; + UnsignedStreamSize size = w.size(); + UnsignedStreamSize max_size = + internal::to_unsigned((std::numeric_limits::max)()); + do { + UnsignedStreamSize n = size <= max_size ? size : max_size; + os.write(data, static_cast(n)); + data += n; + size -= n; + } while (size != 0); +} +} + +FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) { + MemoryWriter w; + w.write(format_str, args); + internal::write(os, w); +} +} // namespace fmt diff --git a/linux/include/fmt/ostream.h b/linux/include/fmt/ostream.h new file mode 100644 index 000000000..84a02d173 --- /dev/null +++ b/linux/include/fmt/ostream.h @@ -0,0 +1,105 @@ +/* + Formatting library for C++ - std::ostream support + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +#ifndef FMT_OSTREAM_H_ +#define FMT_OSTREAM_H_ + +#include "format.h" +#include + +namespace fmt { + +namespace internal { + +template +class FormatBuf : public std::basic_streambuf { + private: + typedef typename std::basic_streambuf::int_type int_type; + typedef typename std::basic_streambuf::traits_type traits_type; + + Buffer &buffer_; + + public: + FormatBuf(Buffer &buffer) : buffer_(buffer) {} + + protected: + // The put-area is actually always empty. This makes the implementation + // simpler and has the advantage that the streambuf and the buffer are always + // in sync and sputc never writes into uninitialized memory. The obvious + // disadvantage is that each call to sputc always results in a (virtual) call + // to overflow. There is no disadvantage here for sputn since this always + // results in a call to xsputn. + + int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast(ch)); + return ch; + } + + std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE { + buffer_.append(s, s + count); + return count; + } +}; + +Yes &convert(std::ostream &); + +struct DummyStream : std::ostream { + DummyStream(); // Suppress a bogus warning in MSVC. + // Hide all operator<< overloads from std::ostream. + void operator<<(Null<>); +}; + +No &operator<<(std::ostream &, int); + +template +struct ConvertToIntImpl { + // Convert to int only if T doesn't have an overloaded operator<<. + enum { + value = sizeof(convert(get() << get())) == sizeof(No) + }; +}; + +// Write the content of w to os. +FMT_API void write(std::ostream &os, Writer &w); +} // namespace internal + +// Formats a value. +template +void format_arg(BasicFormatter &f, + const Char *&format_str, const T &value) { + internal::MemoryBuffer buffer; + + internal::FormatBuf format_buf(buffer); + std::basic_ostream output(&format_buf); + output << value; + + BasicStringRef str(&buffer[0], buffer.size()); + typedef internal::MakeArg< BasicFormatter > MakeArg; + format_str = f.format(format_str, MakeArg(str)); +} + +/** + \rst + Prints formatted data to the stream *os*. + + **Example**:: + + print(cerr, "Don't {}!", "panic"); + \endrst + */ +FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args); +FMT_VARIADIC(void, print, std::ostream &, CStringRef) +} // namespace fmt + +#ifdef FMT_HEADER_ONLY +# include "ostream.cc" +#endif + +#endif // FMT_OSTREAM_H_ diff --git a/linux/include/fmt/posix.cc b/linux/include/fmt/posix.cc new file mode 100644 index 000000000..356668c13 --- /dev/null +++ b/linux/include/fmt/posix.cc @@ -0,0 +1,241 @@ +/* + A C++ interface to POSIX functions. + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +// Disable bogus MSVC warnings. +#ifndef _CRT_SECURE_NO_WARNINGS +# define _CRT_SECURE_NO_WARNINGS +#endif + +#include "posix.h" + +#include +#include +#include + +#ifndef _WIN32 +# include +#else +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include +# include + +# define O_CREAT _O_CREAT +# define O_TRUNC _O_TRUNC + +# ifndef S_IRUSR +# define S_IRUSR _S_IREAD +# endif + +# ifndef S_IWUSR +# define S_IWUSR _S_IWRITE +# endif + +# ifdef __MINGW32__ +# define _SH_DENYNO 0x40 +# endif + +#endif // _WIN32 + +#ifdef fileno +# undef fileno +#endif + +namespace { +#ifdef _WIN32 +// Return type of read and write functions. +typedef int RWResult; + +// 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(count) : UINT_MAX; +} +#else +// Return type of read and write functions. +typedef ssize_t RWResult; + +inline std::size_t convert_rwcount(std::size_t count) { return count; } +#endif +} + +fmt::BufferedFile::~BufferedFile() FMT_NOEXCEPT { + if (file_ && FMT_SYSTEM(fclose(file_)) != 0) + fmt::report_system_error(errno, "cannot close file"); +} + +fmt::BufferedFile::BufferedFile( + fmt::CStringRef filename, fmt::CStringRef mode) { + FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), 0); + if (!file_) + FMT_THROW(SystemError(errno, "cannot open file {}", filename)); +} + +void fmt::BufferedFile::close() { + if (!file_) + return; + int result = FMT_SYSTEM(fclose(file_)); + file_ = FMT_NULL; + if (result != 0) + FMT_THROW(SystemError(errno, "cannot close file")); +} + +// A macro used to prevent expansion of fileno on broken versions of MinGW. +#define FMT_ARGS + +int fmt::BufferedFile::fileno() const { + int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_)); + if (fd == -1) + FMT_THROW(SystemError(errno, "cannot get file descriptor")); + return fd; +} + +fmt::File::File(fmt::CStringRef path, int oflag) { + int mode = S_IRUSR | S_IWUSR; +#if defined(_WIN32) && !defined(__MINGW32__) + fd_ = -1; + FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode)); +#else + FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode))); +#endif + if (fd_ == -1) + FMT_THROW(SystemError(errno, "cannot open file {}", path)); +} + +fmt::File::~File() FMT_NOEXCEPT { + // Don't retry close in case of EINTR! + // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html + if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0) + fmt::report_system_error(errno, "cannot close file"); +} + +void fmt::File::close() { + if (fd_ == -1) + return; + // Don't retry close in case of EINTR! + // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html + int result = FMT_POSIX_CALL(close(fd_)); + fd_ = -1; + if (result != 0) + FMT_THROW(SystemError(errno, "cannot close file")); +} + +fmt::LongLong fmt::File::size() const { +#ifdef _WIN32 + // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT + // is less than 0x0500 as is the case with some default MinGW builds. + // Both functions support large file sizes. + DWORD size_upper = 0; + HANDLE handle = reinterpret_cast(_get_osfhandle(fd_)); + DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper)); + if (size_lower == INVALID_FILE_SIZE) { + DWORD error = GetLastError(); + if (error != NO_ERROR) + FMT_THROW(WindowsError(GetLastError(), "cannot get file size")); + } + fmt::ULongLong long_size = size_upper; + return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower; +#else + typedef struct stat Stat; + Stat file_stat = Stat(); + if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1) + FMT_THROW(SystemError(errno, "cannot get file attributes")); + FMT_STATIC_ASSERT(sizeof(fmt::LongLong) >= sizeof(file_stat.st_size), + "return type of File::size is not large enough"); + return file_stat.st_size; +#endif +} + +std::size_t fmt::File::read(void *buffer, std::size_t count) { + RWResult result = 0; + FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count)))); + if (result < 0) + FMT_THROW(SystemError(errno, "cannot read from file")); + return internal::to_unsigned(result); +} + +std::size_t fmt::File::write(const void *buffer, std::size_t count) { + RWResult result = 0; + FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count)))); + if (result < 0) + FMT_THROW(SystemError(errno, "cannot write to file")); + return internal::to_unsigned(result); +} + +fmt::File fmt::File::dup(int fd) { + // Don't retry as dup doesn't return EINTR. + // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html + int new_fd = FMT_POSIX_CALL(dup(fd)); + if (new_fd == -1) + FMT_THROW(SystemError(errno, "cannot duplicate file descriptor {}", fd)); + return File(new_fd); +} + +void fmt::File::dup2(int fd) { + int result = 0; + FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd))); + if (result == -1) { + FMT_THROW(SystemError(errno, + "cannot duplicate file descriptor {} to {}", fd_, fd)); + } +} + +void fmt::File::dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT { + int result = 0; + FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd))); + if (result == -1) + ec = ErrorCode(errno); +} + +void fmt::File::pipe(File &read_end, File &write_end) { + // Close the descriptors first to make sure that assignments don't throw + // and there are no leaks. + read_end.close(); + write_end.close(); + int fds[2] = {}; +#ifdef _WIN32 + // Make the default pipe capacity same as on Linux 2.6.11+. + enum { DEFAULT_CAPACITY = 65536 }; + int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY)); +#else + // Don't retry as the pipe function doesn't return EINTR. + // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html + int result = FMT_POSIX_CALL(pipe(fds)); +#endif + if (result != 0) + FMT_THROW(SystemError(errno, "cannot create pipe")); + // The following assignments don't throw because read_fd and write_fd + // are closed. + read_end = File(fds[0]); + write_end = File(fds[1]); +} + +fmt::BufferedFile fmt::File::fdopen(const char *mode) { + // Don't retry as fdopen doesn't return EINTR. + FILE *f = FMT_POSIX_CALL(fdopen(fd_, mode)); + if (!f) + FMT_THROW(SystemError(errno, "cannot associate stream with file descriptor")); + BufferedFile file(f); + fd_ = -1; + return file; +} + +long fmt::getpagesize() { +#ifdef _WIN32 + SYSTEM_INFO si; + GetSystemInfo(&si); + return si.dwPageSize; +#else + long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE)); + if (size < 0) + FMT_THROW(SystemError(errno, "cannot get memory page size")); + return size; +#endif +} diff --git a/linux/include/fmt/posix.h b/linux/include/fmt/posix.h new file mode 100644 index 000000000..88512de55 --- /dev/null +++ b/linux/include/fmt/posix.h @@ -0,0 +1,367 @@ +/* + A C++ interface to POSIX functions. + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +#ifndef FMT_POSIX_H_ +#define FMT_POSIX_H_ + +#if defined(__MINGW32__) || defined(__CYGWIN__) +// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/. +# undef __STRICT_ANSI__ +#endif + +#include +#include // for O_RDONLY +#include // for locale_t +#include +#include // for strtod_l + +#include + +#if defined __APPLE__ || defined(__FreeBSD__) +# include // for LC_NUMERIC_MASK on OS X +#endif + +#include "format.h" + +#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) + +namespace fmt { + +// An error code. +class ErrorCode { + private: + int value_; + + public: + explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {} + + int get() const FMT_NOEXCEPT { return value_; } +}; + +// A buffered file. +class BufferedFile { + private: + FILE *file_; + + friend class File; + + explicit BufferedFile(FILE *f) : file_(f) {} + + public: + // Constructs a BufferedFile object which doesn't represent any file. + BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {} + + // Destroys the object closing the file it represents if any. + FMT_API ~BufferedFile() FMT_NOEXCEPT; + +#if !FMT_USE_RVALUE_REFERENCES + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. + + private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy { + FILE *file; + }; + +public: + // A "move constructor" for moving from a temporary. + BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {} + + // A "move constructor" for moving from an lvalue. + BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) { + f.file_ = FMT_NULL; + } + + // A "move assignment operator" for moving from a temporary. + BufferedFile &operator=(Proxy p) { + close(); + file_ = p.file; + return *this; + } + + // A "move assignment operator" for moving from an lvalue. + BufferedFile &operator=(BufferedFile &other) { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } + + // Returns a proxy object for moving from a temporary: + // BufferedFile file = BufferedFile(...); + operator Proxy() FMT_NOEXCEPT { + Proxy p = {file_}; + file_ = FMT_NULL; + return p; + } + +#else + private: + FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile); + + public: + BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) { + other.file_ = FMT_NULL; + } + + BufferedFile& operator=(BufferedFile &&other) { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } +#endif + + // Opens a file. + FMT_API BufferedFile(CStringRef filename, CStringRef 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 print(CStringRef format_str, const ArgList &args) { + fmt::print(file_, format_str, args); + } + FMT_VARIADIC(void, print, CStringRef) +}; + +// A file. Closed file is represented by a File object with descriptor -1. +// Methods that are not declared with FMT_NOEXCEPT may throw +// fmt::SystemError 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. + }; + + // 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(CStringRef path, int oflag); + +#if !FMT_USE_RVALUE_REFERENCES + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. + + private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy { + int fd; + }; + + public: + // A "move constructor" for moving from a temporary. + File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {} + + // A "move constructor" for moving from an lvalue. + File(File &other) FMT_NOEXCEPT : fd_(other.fd_) { + other.fd_ = -1; + } + + // A "move assignment operator" for moving from a temporary. + File &operator=(Proxy p) { + close(); + fd_ = p.fd; + return *this; + } + + // A "move assignment operator" for moving from an lvalue. + File &operator=(File &other) { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } + + // Returns a proxy object for moving from a temporary: + // File file = File(...); + operator Proxy() FMT_NOEXCEPT { + Proxy p = {fd_}; + fd_ = -1; + return p; + } + +#else + private: + FMT_DISALLOW_COPY_AND_ASSIGN(File); + + public: + File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) { + other.fd_ = -1; + } + + File& operator=(File &&other) { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } +#endif + + // 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 LongLong size() const; + + // Attempts to read count bytes from the file into the specified buffer. + FMT_API std::size_t read(void *buffer, std::size_t count); + + // Attempts to write count bytes from the specified buffer to the file. + FMT_API std::size_t write(const void *buffer, std::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, ErrorCode &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 BufferedFile object associated with this file and detaches + // this File object from the file. + FMT_API BufferedFile fdopen(const char *mode); +}; + +// Returns the memory page size. +long getpagesize(); + +#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \ + !defined(__ANDROID__) && !defined(__CYGWIN__) +# define FMT_LOCALE +#endif + +#ifdef FMT_LOCALE +// A "C" numeric locale. +class Locale { + private: +# ifdef _MSC_VER + typedef _locale_t locale_t; + + enum { LC_NUMERIC_MASK = LC_NUMERIC }; + + static locale_t newlocale(int category_mask, const char *locale, locale_t) { + return _create_locale(category_mask, locale); + } + + static void freelocale(locale_t locale) { + _free_locale(locale); + } + + static double strtod_l(const char *nptr, char **endptr, _locale_t locale) { + return _strtod_l(nptr, endptr, locale); + } +# endif + + locale_t locale_; + + FMT_DISALLOW_COPY_AND_ASSIGN(Locale); + + public: + typedef locale_t Type; + + Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) { + if (!locale_) + FMT_THROW(fmt::SystemError(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 = FMT_NULL; + double result = strtod_l(str, &end, locale_); + str = end; + return result; + } +}; +#endif // FMT_LOCALE +} // namespace fmt + +#if !FMT_USE_RVALUE_REFERENCES +namespace std { +// For compatibility with C++98. +inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; } +inline fmt::File &move(fmt::File &f) { return f; } +} +#endif + +#endif // FMT_POSIX_H_ diff --git a/linux/include/fmt/printf.cc b/linux/include/fmt/printf.cc new file mode 100644 index 000000000..95d7a36ab --- /dev/null +++ b/linux/include/fmt/printf.cc @@ -0,0 +1,32 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +#include "format.h" +#include "printf.h" + +namespace fmt { + +template +void printf(BasicWriter &w, BasicCStringRef format, ArgList args); + +FMT_FUNC int fprintf(std::FILE *f, CStringRef format, ArgList args) { + MemoryWriter w; + printf(w, format, args); + std::size_t size = w.size(); + return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast(size); +} + +#ifndef FMT_HEADER_ONLY + +template void PrintfFormatter::format(CStringRef format); +template void PrintfFormatter::format(WCStringRef format); + +#endif // FMT_HEADER_ONLY + +} // namespace fmt diff --git a/linux/include/fmt/printf.h b/linux/include/fmt/printf.h new file mode 100644 index 000000000..30cbc49ba --- /dev/null +++ b/linux/include/fmt/printf.h @@ -0,0 +1,603 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +#ifndef FMT_PRINTF_H_ +#define FMT_PRINTF_H_ + +#include // std::fill_n +#include // std::numeric_limits + +#include "ostream.h" + +namespace fmt { +namespace internal { + +// Checks if a value fits in int - used to avoid warnings about comparing +// signed and unsigned integers. +template +struct IntChecker { + template + static bool fits_in_int(T value) { + unsigned max = std::numeric_limits::max(); + return value <= max; + } + static bool fits_in_int(bool) { return true; } +}; + +template <> +struct IntChecker { + template + static bool fits_in_int(T value) { + return value >= std::numeric_limits::min() && + value <= std::numeric_limits::max(); + } + static bool fits_in_int(int) { return true; } +}; + +class PrecisionHandler : public ArgVisitor { + public: + void report_unhandled_arg() { + FMT_THROW(FormatError("precision is not integer")); + } + + template + int visit_any_int(T value) { + if (!IntChecker::is_signed>::fits_in_int(value)) + FMT_THROW(FormatError("number is too big")); + return static_cast(value); + } +}; + +// IsZeroInt::visit(arg) returns true iff arg is a zero integer. +class IsZeroInt : public ArgVisitor { + public: + template + bool visit_any_int(T value) { return value == 0; } +}; + +// returns the default type for format specific "%s" +class DefaultType : public ArgVisitor { + public: + char visit_char(int) { return 'c'; } + + char visit_bool(bool) { return 's'; } + + char visit_pointer(const void *) { return 'p'; } + + template + char visit_any_int(T) { return 'd'; } + + template + char visit_any_double(T) { return 'g'; } + + char visit_unhandled_arg() { return 's'; } +}; + +template +struct is_same { + enum { value = 0 }; +}; + +template +struct is_same { + enum { value = 1 }; +}; + +// An argument visitor that converts an integer argument to T for printf, +// if T is an integral type. If T is void, the argument is converted to +// corresponding signed or unsigned type depending on the type specifier: +// 'd' and 'i' - signed, other - unsigned) +template +class ArgConverter : public ArgVisitor, void> { + private: + internal::Arg &arg_; + wchar_t type_; + + FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); + + public: + ArgConverter(internal::Arg &arg, wchar_t type) + : arg_(arg), type_(type) {} + + void visit_bool(bool value) { + if (type_ != 's') + visit_any_int(value); + } + + void visit_char(char value) { + if (type_ != 's') + visit_any_int(value); + } + + template + void visit_any_int(U value) { + bool is_signed = type_ == 'd' || type_ == 'i'; + if (type_ == 's') { + is_signed = std::numeric_limits::is_signed; + } + + using internal::Arg; + typedef typename internal::Conditional< + is_same::value, U, T>::type TargetType; + if (sizeof(TargetType) <= sizeof(int)) { + // Extra casts are used to silence warnings. + if (is_signed) { + arg_.type = Arg::INT; + arg_.int_value = static_cast(static_cast(value)); + } else { + arg_.type = Arg::UINT; + typedef typename internal::MakeUnsigned::Type Unsigned; + arg_.uint_value = static_cast(static_cast(value)); + } + } else { + if (is_signed) { + arg_.type = Arg::LONG_LONG; + // glibc's printf doesn't sign extend arguments of smaller types: + // std::printf("%lld", -42); // prints "4294967254" + // but we don't have to do the same because it's a UB. + arg_.long_long_value = static_cast(value); + } else { + arg_.type = Arg::ULONG_LONG; + arg_.ulong_long_value = + static_cast::Type>(value); + } + } + } +}; + +// Converts an integer argument to char for printf. +class CharConverter : public ArgVisitor { + private: + internal::Arg &arg_; + + FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); + + public: + explicit CharConverter(internal::Arg &arg) : arg_(arg) {} + + template + void visit_any_int(T value) { + arg_.type = internal::Arg::CHAR; + arg_.int_value = static_cast(value); + } +}; + +// Checks if an argument is a valid printf width specifier and sets +// left alignment if it is negative. +class WidthHandler : public ArgVisitor { + private: + FormatSpec &spec_; + + FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); + + public: + explicit WidthHandler(FormatSpec &spec) : spec_(spec) {} + + void report_unhandled_arg() { + FMT_THROW(FormatError("width is not integer")); + } + + template + unsigned visit_any_int(T value) { + typedef typename internal::IntTraits::MainType UnsignedType; + UnsignedType width = static_cast(value); + if (internal::is_negative(value)) { + spec_.align_ = ALIGN_LEFT; + width = 0 - width; + } + unsigned int_max = std::numeric_limits::max(); + if (width > int_max) + FMT_THROW(FormatError("number is too big")); + return static_cast(width); + } +}; +} // namespace internal + +/** + \rst + A ``printf`` argument formatter based on the `curiously recurring template + pattern `_. + + To use `~fmt::BasicPrintfArgFormatter` define a subclass that implements some + or all of the visit methods with the same signatures as the methods in + `~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`. + Pass the subclass as the *Impl* template parameter. When a formatting + function processes an argument, it will dispatch to a visit method + specific to the argument type. For example, if the argument type is + ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass + will be called. If the subclass doesn't contain a method with this signature, + then a corresponding method of `~fmt::BasicPrintfArgFormatter` or its + superclass will be called. + \endrst + */ +template +class BasicPrintfArgFormatter : + public internal::ArgFormatterBase { + private: + void write_null_pointer() { + this->spec().type_ = 0; + this->write("(nil)"); + } + + typedef internal::ArgFormatterBase Base; + + public: + /** + \rst + Constructs an argument formatter object. + *writer* is a reference to the output writer and *spec* contains format + specifier information for standard argument types. + \endrst + */ + BasicPrintfArgFormatter(BasicWriter &w, Spec &s) + : internal::ArgFormatterBase(w, s) {} + + /** Formats an argument of type ``bool``. */ + void visit_bool(bool value) { + Spec &fmt_spec = this->spec(); + if (fmt_spec.type_ != 's') + return this->visit_any_int(value); + fmt_spec.type_ = 0; + this->write(value); + } + + /** Formats a character. */ + void visit_char(int value) { + const Spec &fmt_spec = this->spec(); + BasicWriter &w = this->writer(); + if (fmt_spec.type_ && fmt_spec.type_ != 'c') + w.write_int(value, fmt_spec); + typedef typename BasicWriter::CharPtr CharPtr; + CharPtr out = CharPtr(); + if (fmt_spec.width_ > 1) { + Char fill = ' '; + out = w.grow_buffer(fmt_spec.width_); + if (fmt_spec.align_ != ALIGN_LEFT) { + std::fill_n(out, fmt_spec.width_ - 1, fill); + out += fmt_spec.width_ - 1; + } else { + std::fill_n(out + 1, fmt_spec.width_ - 1, fill); + } + } else { + out = w.grow_buffer(1); + } + *out = static_cast(value); + } + + /** Formats a null-terminated C string. */ + void visit_cstring(const char *value) { + if (value) + Base::visit_cstring(value); + else if (this->spec().type_ == 'p') + write_null_pointer(); + else + this->write("(null)"); + } + + /** Formats a pointer. */ + void visit_pointer(const void *value) { + if (value) + return Base::visit_pointer(value); + this->spec().type_ = 0; + write_null_pointer(); + } + + /** Formats an argument of a custom (user-defined) type. */ + void visit_custom(internal::Arg::CustomValue c) { + BasicFormatter formatter(ArgList(), this->writer()); + const Char format_str[] = {'}', 0}; + const Char *format = format_str; + c.format(&formatter, c.value, &format); + } +}; + +/** The default printf argument formatter. */ +template +class PrintfArgFormatter : + public BasicPrintfArgFormatter, Char, FormatSpec> { + public: + /** Constructs an argument formatter object. */ + PrintfArgFormatter(BasicWriter &w, FormatSpec &s) + : BasicPrintfArgFormatter, Char, FormatSpec>(w, s) {} +}; + +/** This template formats data and writes the output to a writer. */ +template > +class PrintfFormatter : private internal::FormatterBase { + private: + BasicWriter &writer_; + + void parse_flags(FormatSpec &spec, const Char *&s); + + // Returns the argument with specified index or, if arg_index is equal + // to the maximum unsigned value, the next argument. + internal::Arg get_arg( + const Char *s, + unsigned arg_index = (std::numeric_limits::max)()); + + // Parses argument index, flags and width and returns the argument index. + unsigned parse_header(const Char *&s, FormatSpec &spec); + + public: + /** + \rst + Constructs a ``PrintfFormatter`` object. References to the arguments and + the writer are stored in the formatter object so make sure they have + appropriate lifetimes. + \endrst + */ + explicit PrintfFormatter(const ArgList &al, BasicWriter &w) + : FormatterBase(al), writer_(w) {} + + /** Formats stored arguments and writes the output to the writer. */ + void format(BasicCStringRef format_str); +}; + +template +void PrintfFormatter::parse_flags(FormatSpec &spec, const Char *&s) { + for (;;) { + switch (*s++) { + case '-': + spec.align_ = ALIGN_LEFT; + break; + case '+': + spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + break; + case '0': + spec.fill_ = '0'; + break; + case ' ': + spec.flags_ |= SIGN_FLAG; + break; + case '#': + spec.flags_ |= HASH_FLAG; + break; + default: + --s; + return; + } + } +} + +template +internal::Arg PrintfFormatter::get_arg(const Char *s, + unsigned arg_index) { + (void)s; + const char *error = FMT_NULL; + internal::Arg arg = arg_index == std::numeric_limits::max() ? + next_arg(error) : FormatterBase::get_arg(arg_index - 1, error); + if (error) + FMT_THROW(FormatError(!*s ? "invalid format string" : error)); + return arg; +} + +template +unsigned PrintfFormatter::parse_header( + const Char *&s, FormatSpec &spec) { + unsigned arg_index = std::numeric_limits::max(); + Char c = *s; + if (c >= '0' && c <= '9') { + // Parse an argument index (if followed by '$') or a width possibly + // preceded with '0' flag(s). + unsigned value = internal::parse_nonnegative_int(s); + if (*s == '$') { // value is an argument index + ++s; + arg_index = value; + } else { + if (c == '0') + spec.fill_ = '0'; + if (value != 0) { + // Nonzero value means that we parsed width and don't need to + // parse it or flags again, so return now. + spec.width_ = value; + return arg_index; + } + } + } + parse_flags(spec, s); + // Parse width. + if (*s >= '0' && *s <= '9') { + spec.width_ = internal::parse_nonnegative_int(s); + } else if (*s == '*') { + ++s; + spec.width_ = internal::WidthHandler(spec).visit(get_arg(s)); + } + return arg_index; +} + +template +void PrintfFormatter::format(BasicCStringRef format_str) { + const Char *start = format_str.c_str(); + const Char *s = start; + while (*s) { + Char c = *s++; + if (c != '%') continue; + if (*s == c) { + write(writer_, start, s); + start = ++s; + continue; + } + write(writer_, start, s - 1); + + FormatSpec spec; + spec.align_ = ALIGN_RIGHT; + + // Parse argument index, flags and width. + unsigned arg_index = parse_header(s, spec); + + // Parse precision. + if (*s == '.') { + ++s; + if ('0' <= *s && *s <= '9') { + spec.precision_ = static_cast(internal::parse_nonnegative_int(s)); + } else if (*s == '*') { + ++s; + spec.precision_ = internal::PrecisionHandler().visit(get_arg(s)); + } else { + spec.precision_ = 0; + } + } + + using internal::Arg; + Arg arg = get_arg(s, arg_index); + if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg)) + spec.flags_ &= ~internal::to_unsigned(HASH_FLAG); + if (spec.fill_ == '0') { + if (arg.type <= Arg::LAST_NUMERIC_TYPE) + spec.align_ = ALIGN_NUMERIC; + else + spec.fill_ = ' '; // Ignore '0' flag for non-numeric types. + } + + // Parse length and convert the argument to the required type. + using internal::ArgConverter; + switch (*s++) { + case 'h': + if (*s == 'h') + ArgConverter(arg, *++s).visit(arg); + else + ArgConverter(arg, *s).visit(arg); + break; + case 'l': + if (*s == 'l') + ArgConverter(arg, *++s).visit(arg); + else + ArgConverter(arg, *s).visit(arg); + break; + case 'j': + ArgConverter(arg, *s).visit(arg); + break; + case 'z': + ArgConverter(arg, *s).visit(arg); + break; + case 't': + ArgConverter(arg, *s).visit(arg); + break; + case 'L': + // printf produces garbage when 'L' is omitted for long double, no + // need to do the same. + break; + default: + --s; + ArgConverter(arg, *s).visit(arg); + } + + // Parse type. + if (!*s) + FMT_THROW(FormatError("invalid format string")); + spec.type_ = static_cast(*s++); + + if (spec.type_ == 's') { + // set the format type to the default if 's' is specified + spec.type_ = internal::DefaultType().visit(arg); + } + + if (arg.type <= Arg::LAST_INTEGER_TYPE) { + // Normalize type. + switch (spec.type_) { + case 'i': case 'u': + spec.type_ = 'd'; + break; + case 'c': + // TODO: handle wchar_t + internal::CharConverter(arg).visit(arg); + break; + } + } + + start = s; + + // Format argument. + AF(writer_, spec).visit(arg); + } + write(writer_, start, s); +} + +inline void printf(Writer &w, CStringRef format, ArgList args) { + PrintfFormatter(args, w).format(format); +} +FMT_VARIADIC(void, printf, Writer &, CStringRef) + +inline void printf(WWriter &w, WCStringRef format, ArgList args) { + PrintfFormatter(args, w).format(format); +} +FMT_VARIADIC(void, printf, WWriter &, WCStringRef) + +/** + \rst + Formats arguments and returns the result as a string. + + **Example**:: + + std::string message = fmt::sprintf("The answer is %d", 42); + \endrst +*/ +inline std::string sprintf(CStringRef format, ArgList args) { + MemoryWriter w; + printf(w, format, args); + return w.str(); +} +FMT_VARIADIC(std::string, sprintf, CStringRef) + +inline std::wstring sprintf(WCStringRef format, ArgList args) { + WMemoryWriter w; + printf(w, format, args); + return w.str(); +} +FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef) + +/** + \rst + Prints formatted data to the file *f*. + + **Example**:: + + fmt::fprintf(stderr, "Don't %s!", "panic"); + \endrst + */ +FMT_API int fprintf(std::FILE *f, CStringRef format, ArgList args); +FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef) + +/** + \rst + Prints formatted data to ``stdout``. + + **Example**:: + + fmt::printf("Elapsed time: %.2f seconds", 1.23); + \endrst + */ +inline int printf(CStringRef format, ArgList args) { + return fprintf(stdout, format, args); +} +FMT_VARIADIC(int, printf, CStringRef) + +/** + \rst + Prints formatted data to the stream *os*. + + **Example**:: + + fprintf(cerr, "Don't %s!", "panic"); + \endrst + */ +inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args) { + MemoryWriter w; + printf(w, format_str, args); + internal::write(os, w); + return static_cast(w.size()); +} +FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef) +} // namespace fmt + +#ifdef FMT_HEADER_ONLY +# include "printf.cc" +#endif + +#endif // FMT_PRINTF_H_ diff --git a/linux/include/fmt/string.h b/linux/include/fmt/string.h new file mode 100644 index 000000000..ccf46ee11 --- /dev/null +++ b/linux/include/fmt/string.h @@ -0,0 +1,126 @@ +/* + Formatting library for C++ - string utilities + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +#ifndef FMT_STRING_H_ +#define FMT_STRING_H_ + +#include "format.h" + +namespace fmt { + +namespace internal { + +// A buffer that stores data in ``std::basic_string``. +template > +class StringBuffer : public Buffer { + public: + typedef std::basic_string, Allocator> StringType; + + private: + StringType data_; + + protected: + virtual void grow(std::size_t size) FMT_OVERRIDE { + data_.resize(size); + this->ptr_ = &data_[0]; + this->capacity_ = size; + } + + public: + explicit StringBuffer(const Allocator &allocator = Allocator()) + : data_(allocator) {} + + // Moves the data to ``str`` clearing the buffer. + void move_to(StringType &str) { + data_.resize(this->size_); + str.swap(data_); + this->capacity_ = this->size_ = 0; + this->ptr_ = FMT_NULL; + } +}; +} // namespace internal + +/** + \rst + This class template provides operations for formatting and writing data + into a character stream. The output is stored in a ``std::basic_string`` + that grows dynamically. + + You can use one of the following typedefs for common character types + and the standard allocator: + + +---------------+----------------------------+ + | Type | Definition | + +===============+============================+ + | StringWriter | BasicStringWriter | + +---------------+----------------------------+ + | WStringWriter | BasicStringWriter | + +---------------+----------------------------+ + + **Example**:: + + StringWriter out; + out << "The answer is " << 42 << "\n"; + + This will write the following output to the ``out`` object: + + .. code-block:: none + + The answer is 42 + + The output can be moved to a ``std::basic_string`` with ``out.move_to()``. + \endrst + */ +template > +class BasicStringWriter : public BasicWriter { + private: + internal::StringBuffer buffer_; + + public: + /** + \rst + Constructs a :class:`fmt::BasicStringWriter` object. + \endrst + */ + explicit BasicStringWriter(const Allocator &allocator = Allocator()) + : BasicWriter(buffer_), buffer_(allocator) {} + + /** + \rst + Moves the buffer content to *str* clearing the buffer. + \endrst + */ + void move_to(std::basic_string, Allocator> &str) { + buffer_.move_to(str); + } +}; + +typedef BasicStringWriter StringWriter; +typedef BasicStringWriter WStringWriter; + +/** + \rst + Converts *value* to ``std::string`` using the default format for type *T*. + + **Example**:: + + #include "fmt/string.h" + + std::string answer = fmt::to_string(42); + \endrst + */ +template +std::string to_string(const T &value) { + fmt::MemoryWriter w; + w << value; + return w.str(); +} +} + +#endif // FMT_STRING_H_ diff --git a/linux/include/fmt/time.h b/linux/include/fmt/time.h new file mode 100644 index 000000000..c98b0e011 --- /dev/null +++ b/linux/include/fmt/time.h @@ -0,0 +1,143 @@ +/* + Formatting library for C++ - time formatting + + Copyright (c) 2012 - 2016, Victor Zverovich + All rights reserved. + + For the license information refer to format.h. + */ + +#ifndef FMT_TIME_H_ +#define FMT_TIME_H_ + +#include "format.h" +#include + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4702) // unreachable code +# pragma warning(disable: 4996) // "deprecated" functions +#endif + +namespace fmt { +template +void format_arg(BasicFormatter &f, + const char *&format_str, const std::tm &tm) { + if (*format_str == ':') + ++format_str; + const char *end = format_str; + while (*end && *end != '}') + ++end; + if (*end != '}') + FMT_THROW(FormatError("missing '}' in format string")); + internal::MemoryBuffer format; + format.append(format_str, end + 1); + format[format.size() - 1] = '\0'; + Buffer &buffer = f.writer().buffer(); + std::size_t start = buffer.size(); + for (;;) { + std::size_t size = buffer.capacity() - start; + std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm); + if (count != 0) { + buffer.resize(start + count); + break; + } + if (size >= format.size() * 256) { + // If the buffer is 256 times larger than the format string, assume + // that `strftime` gives an empty result. There doesn't seem to be a + // better way to distinguish the two cases: + // https://github.com/fmtlib/fmt/issues/367 + break; + } + const std::size_t MIN_GROWTH = 10; + buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH)); + } + format_str = end + 1; +} + +namespace internal{ +inline Null<> localtime_r(...) { return Null<>(); } +inline Null<> localtime_s(...) { return Null<>(); } +inline Null<> gmtime_r(...) { return Null<>(); } +inline Null<> gmtime_s(...) { return Null<>(); } +} + +// Thread-safe replacement for std::localtime +inline std::tm localtime(std::time_t time) { + struct LocalTime { + std::time_t time_; + std::tm tm_; + + LocalTime(std::time_t t): time_(t) {} + + bool run() { + using namespace fmt::internal; + return handle(localtime_r(&time_, &tm_)); + } + + bool handle(std::tm *tm) { return tm != FMT_NULL; } + + bool handle(internal::Null<>) { + using namespace fmt::internal; + return fallback(localtime_s(&tm_, &time_)); + } + + bool fallback(int res) { return res == 0; } + + bool fallback(internal::Null<>) { + using namespace fmt::internal; + std::tm *tm = std::localtime(&time_); + if (tm) tm_ = *tm; + return tm != FMT_NULL; + } + }; + LocalTime lt(time); + if (lt.run()) + return lt.tm_; + // Too big time values may be unsupported. + FMT_THROW(fmt::FormatError("time_t value out of range")); + return std::tm(); +} + +// Thread-safe replacement for std::gmtime +inline std::tm gmtime(std::time_t time) { + struct GMTime { + std::time_t time_; + std::tm tm_; + + GMTime(std::time_t t): time_(t) {} + + bool run() { + using namespace fmt::internal; + return handle(gmtime_r(&time_, &tm_)); + } + + bool handle(std::tm *tm) { return tm != FMT_NULL; } + + bool handle(internal::Null<>) { + using namespace fmt::internal; + return fallback(gmtime_s(&tm_, &time_)); + } + + bool fallback(int res) { return res == 0; } + + bool fallback(internal::Null<>) { + std::tm *tm = std::gmtime(&time_); + if (tm != FMT_NULL) tm_ = *tm; + return tm != FMT_NULL; + } + }; + GMTime gt(time); + if (gt.run()) + return gt.tm_; + // Too big time values may be unsupported. + FMT_THROW(fmt::FormatError("time_t value out of range")); + return std::tm(); +} +} //namespace fmt + +#ifdef _MSC_VER +# pragma warning(pop) +#endif + +#endif // FMT_TIME_H_ diff --git a/linux/lib/debug/libfmt.a b/linux/lib/debug/libfmt.a new file mode 100644 index 0000000000000000000000000000000000000000..6caad7c97d402d51887b9305f1a54d6e3994be47 GIT binary patch literal 2527182 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�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