Upgrade fmt from 3.0.1 to 5.1.0

lib/fmt/CMakeLists.txt

@@ -0,0 +1,14 @@
+set(FMT_SOURCES ${FMT_SOURCES}
+	${CMAKE_CURRENT_SOURCE_DIR}/core.h
+	${CMAKE_CURRENT_SOURCE_DIR}/format.cc
+	${CMAKE_CURRENT_SOURCE_DIR}/format.h
+	${CMAKE_CURRENT_SOURCE_DIR}/format-inl.h
+	${CMAKE_CURRENT_SOURCE_DIR}/ostream.h
+	${CMAKE_CURRENT_SOURCE_DIR}/posix.cc
+	${CMAKE_CURRENT_SOURCE_DIR}/posix.h
+	${CMAKE_CURRENT_SOURCE_DIR}/printf.h
+	${CMAKE_CURRENT_SOURCE_DIR}/ranges.h
+	${CMAKE_CURRENT_SOURCE_DIR}/time.h
+)
+
+add_library(fmt STATIC ${FMT_SOURCES})

lib/fmt/format-inl.h

@@ -0,0 +1,564 @@
+// Formatting library for C++
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_FORMAT_INL_H_
+#define FMT_FORMAT_INL_H_
+
+#include "format.h"
+
+#include <string.h>
+
+#include <cctype>
+#include <cerrno>
+#include <climits>
+#include <cmath>
+#include <cstdarg>
+#include <cstddef>  // for std::ptrdiff_t
+#include <locale>
+
+#if defined(_WIN32) && defined(__MINGW32__)
+# include <cstring>
+#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 <windows.h>
+# else
+#  define NOMINMAX
+#  include <windows.h>
+#  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.
+inline fmt::internal::null<> strerror_r(int, char *, ...) {
+  return fmt::internal::null<>();
+}
+inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) {
+  return fmt::internal::null<>();
+}
+
+FMT_BEGIN_NAMESPACE
+
+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)
+
+typedef void (*FormatFunc)(internal::buffer &, int, string_view);
+
+// 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 != FMT_NULL && buffer_size != 0, "invalid buffer");
+
+  class dispatcher {
+   private:
+    int error_code_;
+    char *&buffer_;
+    std::size_t buffer_size_;
+
+    // A noop assignment operator to avoid bogus warnings.
+    void operator=(const dispatcher &) {}
+
+    // 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:
+    dispatcher(int err_code, char *&buf, std::size_t buf_size)
+      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
+
+    int run() {
+      return handle(strerror_r(error_code_, buffer_, buffer_size_));
+    }
+  };
+  return dispatcher(error_code, buffer, buffer_size).run();
+}
+
+void format_error_code(internal::buffer &out, int error_code,
+                       string_view 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.resize(0);
+  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::int_traits<int>::main_type main_type;
+  main_type abs_value = static_cast<main_type>(error_code);
+  if (internal::is_negative(error_code)) {
+    abs_value = 0 - abs_value;
+    ++error_code_size;
+  }
+  error_code_size += internal::count_digits(abs_value);
+  writer w(out);
+  if (message.size() <= inline_buffer_size - error_code_size) {
+    w.write(message);
+    w.write(SEP);
+  }
+  w.write(ERROR_STR);
+  w.write(error_code);
+  assert(out.size() <= inline_buffer_size);
+}
+
+void report_error(FormatFunc func, int error_code,
+                  string_view message) FMT_NOEXCEPT {
+  memory_buffer 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
+
+class locale {
+ private:
+  std::locale locale_;
+
+ public:
+  explicit locale(std::locale loc = std::locale()) : locale_(loc) {}
+  std::locale get() { return locale_; }
+};
+
+template <typename Char>
+FMT_FUNC Char internal::thousands_sep(locale_provider *lp) {
+  std::locale loc = lp ? lp->locale().get() : std::locale();
+  return std::use_facet<std::numpunct<Char>>(loc).thousands_sep();
+}
+
+FMT_FUNC void system_error::init(
+    int err_code, string_view format_str, format_args args) {
+  error_code_ = err_code;
+  memory_buffer buffer;
+  format_system_error(buffer, err_code, vformat(format_str, args));
+  std::runtime_error &base = *this;
+  base = std::runtime_error(to_string(buffer));
+}
+
+namespace internal {
+template <typename T>
+int char_traits<char>::format_float(
+    char *buffer, std::size_t size, const char *format, int precision, T value) {
+  return precision < 0 ?
+      FMT_SNPRINTF(buffer, size, format, value) :
+      FMT_SNPRINTF(buffer, size, format, precision, value);
+}
+
+template <typename T>
+int char_traits<wchar_t>::format_float(
+    wchar_t *buffer, std::size_t size, const wchar_t *format, int precision,
+    T value) {
+  return precision < 0 ?
+      FMT_SWPRINTF(buffer, size, format, value) :
+      FMT_SWPRINTF(buffer, size, format, precision, value);
+}
+
+template <typename T>
+const char basic_data<T>::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 <typename T>
+const uint32_t basic_data<T>::POWERS_OF_10_32[] = {
+  0, FMT_POWERS_OF_10(1)
+};
+
+template <typename T>
+const uint64_t basic_data<T>::POWERS_OF_10_64[] = {
+  0,
+  FMT_POWERS_OF_10(1),
+  FMT_POWERS_OF_10(1000000000ull),
+  10000000000000000000ull
+};
+
+// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
+// These are generated by support/compute-powers.py.
+template <typename T>
+const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {
+  0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
+  0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f,
+  0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
+  0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
+  0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5,
+  0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
+  0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
+  0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd,
+  0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
+  0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
+  0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c,
+  0x9c40000000000000, 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
+  0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
+  0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a,
+  0x924d692ca61be758, 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
+  0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
+  0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece,
+  0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
+  0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
+  0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429,
+  0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
+  0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b
+};
+
+// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
+// to significands above.
+template <typename T>
+const int16_t basic_data<T>::POW10_EXPONENTS[] = {
+  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,  -954,
+   -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,
+   -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396,  -369,
+   -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103,   -77,
+    -50,   -24,     3,    30,    56,    83,   109,   136,   162,   189,   216,
+    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,   508,
+    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,   800,
+    827,   853,   880,   907,   933,   960,   986,  1013,  1039,  1066
+};
+
+template <typename T> const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
+template <typename T> const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
+
+FMT_FUNC fp operator*(fp x, fp y) {
+  // Multiply 32-bit parts of significands.
+  uint64_t mask = (1ULL << 32) - 1;
+  uint64_t a = x.f >> 32, b = x.f & mask;
+  uint64_t c = y.f >> 32, d = y.f & mask;
+  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
+  // Compute mid 64-bit of result and round.
+  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
+  return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64);
+}
+
+FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
+  const double one_over_log2_10 = 0.30102999566398114;  // 1 / log2(10)
+  int index = static_cast<int>(std::ceil(
+        (min_exponent + fp::significand_size - 1) * one_over_log2_10));
+  // Decimal exponent of the first (smallest) cached power of 10.
+  const int first_dec_exp = -348;
+  // Difference between two consecutive decimal exponents in cached powers of 10.
+  const int dec_exp_step = 8;
+  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
+  pow10_exponent = first_dec_exp + index * dec_exp_step;
+  return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
+}
+}  // namespace internal
+
+#if FMT_USE_WINDOWS_H
+
+FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
+  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
+  if (s.size() > INT_MAX)
+    FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
+  int s_size = static_cast<int>(s.size());
+  if (s_size == 0) {
+    // MultiByteToWideChar does not support zero length, handle separately.
+    buffer_.resize(1);
+    buffer_[0] = 0;
+    return;
+  }
+
+  int length = MultiByteToWideChar(
+      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
+  if (length == 0)
+    FMT_THROW(windows_error(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(windows_error(GetLastError(), ERROR_MSG));
+  buffer_[length] = 0;
+}
+
+FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
+  if (int error_code = convert(s)) {
+    FMT_THROW(windows_error(error_code,
+        "cannot convert string from UTF-16 to UTF-8"));
+  }
+}
+
+FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
+  if (s.size() > INT_MAX)
+    return ERROR_INVALID_PARAMETER;
+  int s_size = static_cast<int>(s.size());
+  if (s_size == 0) {
+    // WideCharToMultiByte does not support zero length, handle separately.
+    buffer_.resize(1);
+    buffer_[0] = 0;
+    return 0;
+  }
+
+  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 windows_error::init(
+    int err_code, string_view format_str, format_args args) {
+  error_code_ = err_code;
+  memory_buffer buffer;
+  internal::format_windows_error(buffer, err_code, vformat(format_str, args));
+  std::runtime_error &base = *this;
+  base = std::runtime_error(to_string(buffer));
+}
+
+FMT_FUNC void internal::format_windows_error(
+    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
+  FMT_TRY {
+    wmemory_buffer buf;
+    buf.resize(inline_buffer_size);
+    for (;;) {
+      wchar_t *system_message = &buf[0];
+      int result = FormatMessageW(
+          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+          FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+          system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
+      if (result != 0) {
+        utf16_to_utf8 utf8_message;
+        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
+          writer w(out);
+          w.write(message);
+          w.write(": ");
+          w.write(utf8_message);
+          return;
+        }
+        break;
+      }
+      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+        break;  // Can't get error message, report error code instead.
+      buf.resize(buf.size() * 2);
+    }
+  } FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
+}
+
+#endif  // FMT_USE_WINDOWS_H
+
+FMT_FUNC void format_system_error(
+    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
+  FMT_TRY {
+    memory_buffer buf;
+    buf.resize(inline_buffer_size);
+    for (;;) {
+      char *system_message = &buf[0];
+      int result = safe_strerror(error_code, system_message, buf.size());
+      if (result == 0) {
+        writer w(out);
+        w.write(message);
+        w.write(": ");
+        w.write(system_message);
+        return;
+      }
+      if (result != ERANGE)
+        break;  // Can't get error message, report error code instead.
+      buf.resize(buf.size() * 2);
+    }
+  } FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
+}
+
+template <typename Char>
+void basic_fixed_buffer<Char>::grow(std::size_t) {
+  FMT_THROW(std::runtime_error("buffer overflow"));
+}
+
+FMT_FUNC void internal::error_handler::on_error(const char *message) {
+  FMT_THROW(format_error(message));
+}
+
+FMT_FUNC void report_system_error(
+    int error_code, fmt::string_view message) FMT_NOEXCEPT {
+  report_error(format_system_error, error_code, message);
+}
+
+#if FMT_USE_WINDOWS_H
+FMT_FUNC void report_windows_error(
+    int error_code, fmt::string_view message) FMT_NOEXCEPT {
+  report_error(internal::format_windows_error, error_code, message);
+}
+#endif
+
+FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) {
+  memory_buffer buffer;
+  vformat_to(buffer, format_str, args);
+  std::fwrite(buffer.data(), 1, buffer.size(), f);
+}
+
+FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) {
+  wmemory_buffer buffer;
+  vformat_to(buffer, format_str, args);
+  std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f);
+}
+
+FMT_FUNC void vprint(string_view format_str, format_args args) {
+  vprint(stdout, format_str, args);
+}
+
+FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
+  vprint(stdout, format_str, args);
+}
+
+#ifndef FMT_EXTENDED_COLORS
+FMT_FUNC void vprint_colored(color c, string_view format, format_args args) {
+  char escape[] = "\x1b[30m";
+  escape[3] = static_cast<char>('0' + c);
+  std::fputs(escape, stdout);
+  vprint(format, args);
+  std::fputs(internal::data::RESET_COLOR, stdout);
+}
+
+FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args) {
+  wchar_t escape[] = L"\x1b[30m";
+  escape[3] = static_cast<wchar_t>('0' + c);
+  std::fputws(escape, stdout);
+  vprint(format, args);
+  std::fputws(internal::data::WRESET_COLOR, stdout);
+}
+#else
+namespace internal {
+FMT_CONSTEXPR void to_esc(uint8_t c, char out[], int offset) {
+  out[offset + 0] = static_cast<char>('0' + c / 100);
+  out[offset + 1] = static_cast<char>('0' + c / 10 % 10);
+  out[offset + 2] = static_cast<char>('0' + c % 10);
+}
+} // namespace internal
+
+FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) {
+  char escape_fd[] = "\x1b[38;2;000;000;000m";
+  internal::to_esc(fd.r, escape_fd, 7);
+  internal::to_esc(fd.g, escape_fd, 11);
+  internal::to_esc(fd.b, escape_fd, 15);
+
+  std::fputs(escape_fd, stdout);
+  vprint(format, args);
+  std::fputs(internal::data::RESET_COLOR, stdout);
+}
+
+FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) {
+  char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color
+  char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color
+  internal::to_esc(fd.r, escape_fd, 7);
+  internal::to_esc(fd.g, escape_fd, 11);
+  internal::to_esc(fd.b, escape_fd, 15);
+
+  internal::to_esc(bg.r, escape_bg, 7);
+  internal::to_esc(bg.g, escape_bg, 11);
+  internal::to_esc(bg.b, escape_bg, 15);
+
+  std::fputs(escape_fd, stdout);
+  std::fputs(escape_bg, stdout);
+  vprint(format, args);
+  std::fputs(internal::data::RESET_COLOR, stdout);
+}
+#endif
+
+FMT_FUNC locale locale_provider::locale() { return fmt::locale(); }
+
+FMT_END_NAMESPACE
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+#endif  // FMT_FORMAT_INL_H_

lib/fmt/format.cc

@@ -0,0 +1,52 @@
+// Formatting library for C++
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/format-inl.h"
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+// Force linking of inline functions into the library.
+std::string (*vformat_ref)(string_view, format_args) = vformat;
+std::wstring (*vformat_wref)(wstring_view, wformat_args) = vformat;
+}
+
+template struct internal::basic_data<void>;
+
+// Explicit instantiations for char.
+
+template FMT_API char internal::thousands_sep(locale_provider *lp);
+
+template void basic_fixed_buffer<char>::grow(std::size_t);
+
+template void internal::arg_map<format_context>::init(
+    const basic_format_args<format_context> &args);
+
+template FMT_API int internal::char_traits<char>::format_float(
+    char *buffer, std::size_t size, const char *format, int precision,
+    double value);
+
+template FMT_API int internal::char_traits<char>::format_float(
+    char *buffer, std::size_t size, const char *format, int precision,
+    long double value);
+
+// Explicit instantiations for wchar_t.
+
+template FMT_API wchar_t internal::thousands_sep(locale_provider *lp);
+
+template void basic_fixed_buffer<wchar_t>::grow(std::size_t);
+
+template void internal::arg_map<wformat_context>::init(
+    const basic_format_args<wformat_context> &args);
+
+template FMT_API int internal::char_traits<wchar_t>::format_float(
+    wchar_t *buffer, std::size_t size, const wchar_t *format,
+    int precision, double value);
+
+template FMT_API int internal::char_traits<wchar_t>::format_float(
+    wchar_t *buffer, std::size_t size, const wchar_t *format,
+    int precision, long double value);
+FMT_END_NAMESPACE

lib/fmt/ostream.h

@@ -0,0 +1,162 @@
+// 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 <ostream>
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+template <class Char>
+class formatbuf : public std::basic_streambuf<Char> {
+ private:
+  typedef typename std::basic_streambuf<Char>::int_type int_type;
+  typedef typename std::basic_streambuf<Char>::traits_type traits_type;
+
+  basic_buffer<Char> &buffer_;
+
+ public:
+  formatbuf(basic_buffer<Char> &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<Char>(ch));
+    return ch;
+  }
+
+  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
+    buffer_.append(s, s + count);
+    return count;
+  }
+};
+
+template <typename Char>
+struct test_stream : std::basic_ostream<Char> {
+ private:
+  struct null;
+  // Hide all operator<< from std::basic_ostream<Char>.
+  void operator<<(null);
+};
+
+// Checks if T has a user-defined operator<< (e.g. not a member of std::ostream).
+template <typename T, typename Char>
+class is_streamable {
+ private:
+  template <typename U>
+  static decltype(
+    internal::declval<test_stream<Char>&>()
+      << internal::declval<U>(), std::true_type()) test(int);
+
+  template <typename>
+  static std::false_type test(...);
+
+  typedef decltype(test<T>(0)) result;
+
+ public:
+  // std::string operator<< is not considered user-defined because we handle strings
+  // specially.
+  static const bool value = result::value && !std::is_same<T, std::string>::value;
+};
+
+// Disable conversion to int if T has an overloaded operator<< which is a free
+// function (not a member of std::ostream).
+template <typename T, typename Char>
+class convert_to_int<T, Char, true> {
+ public:
+  static const bool value =
+    convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
+};
+
+// Write the content of buf to os.
+template <typename Char>
+void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf) {
+  const Char *data = buf.data();
+  typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
+  UnsignedStreamSize size = buf.size();
+  UnsignedStreamSize max_size =
+      internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
+  do {
+    UnsignedStreamSize n = size <= max_size ? size : max_size;
+    os.write(data, static_cast<std::streamsize>(n));
+    data += n;
+    size -= n;
+  } while (size != 0);
+}
+
+template <typename Char, typename T>
+void format_value(basic_buffer<Char> &buffer, const T &value) {
+  internal::formatbuf<Char> format_buf(buffer);
+  std::basic_ostream<Char> output(&format_buf);
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+  output << value;
+  buffer.resize(buffer.size());
+}
+
+// Disable builtin formatting of enums and use operator<< instead.
+template <typename T>
+struct format_enum<T,
+    typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type {};
+}  // namespace internal
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct formatter<T, Char,
+    typename std::enable_if<internal::is_streamable<T, Char>::value>::type>
+    : formatter<basic_string_view<Char>, Char> {
+
+  template <typename Context>
+  auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
+    basic_memory_buffer<Char> buffer;
+    internal::format_value(buffer, value);
+    basic_string_view<Char> str(buffer.data(), buffer.size());
+    formatter<basic_string_view<Char>, Char>::format(str, ctx);
+    return ctx.out();
+  }
+};
+
+template <typename Char>
+inline void vprint(std::basic_ostream<Char> &os,
+                   basic_string_view<Char> format_str,
+                   basic_format_args<typename buffer_context<Char>::type> args) {
+  basic_memory_buffer<Char> buffer;
+  vformat_to(buffer, format_str, args);
+  internal::write(os, buffer);
+}
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
+template <typename... Args>
+inline void print(std::ostream &os, string_view format_str,
+                  const Args & ... args) {
+  vprint<char>(os, format_str, make_format_args<format_context>(args...));
+}
+
+template <typename... Args>
+inline void print(std::wostream &os, wstring_view format_str,
+                  const Args & ... args) {
+  vprint<wchar_t>(os, format_str, make_format_args<wformat_context>(args...));
+}
+FMT_END_NAMESPACE
+
+#endif  // FMT_OSTREAM_H_

lib/fmt/posix.cc

@@ -0,0 +1,244 @@
+// 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.
+#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+# define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "fmt/posix.h"
+
+#include <limits.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifndef _WIN32
+# include <unistd.h>
+#else
+# ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+# endif
+# include <windows.h>
+# include <io.h>
+
+# 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<unsigned>(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_BEGIN_NAMESPACE
+
+buffered_file::~buffered_file() FMT_NOEXCEPT {
+  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
+  FMT_RETRY_VAL(file_,
+                FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), FMT_NULL);
+  if (!file_)
+    FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
+}
+
+void buffered_file::close() {
+  if (!file_)
+    return;
+  int result = FMT_SYSTEM(fclose(file_));
+  file_ = FMT_NULL;
+  if (result != 0)
+    FMT_THROW(system_error(errno, "cannot close file"));
+}
+
+// A macro used to prevent expansion of fileno on broken versions of MinGW.
+#define FMT_ARGS
+
+int buffered_file::fileno() const {
+  int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
+  if (fd == -1)
+    FMT_THROW(system_error(errno, "cannot get file descriptor"));
+  return fd;
+}
+
+file::file(cstring_view 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(system_error(errno, "cannot open file {}", path.c_str()));
+}
+
+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)
+    report_system_error(errno, "cannot close file");
+}
+
+void 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(system_error(errno, "cannot close file"));
+}
+
+long long 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<HANDLE>(_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(windows_error(GetLastError(), "cannot get file size"));
+  }
+  unsigned long long 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(system_error(errno, "cannot get file attributes"));
+  static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
+      "return type of file::size is not large enough");
+  return file_stat.st_size;
+#endif
+}
+
+std::size_t 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(system_error(errno, "cannot read from file"));
+  return internal::to_unsigned(result);
+}
+
+std::size_t 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(system_error(errno, "cannot write to file"));
+  return internal::to_unsigned(result);
+}
+
+file 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(system_error(errno, "cannot duplicate file descriptor {}", fd));
+  return file(new_fd);
+}
+
+void file::dup2(int fd) {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) {
+    FMT_THROW(system_error(errno,
+      "cannot duplicate file descriptor {} to {}", fd_, fd));
+  }
+}
+
+void file::dup2(int fd, error_code &ec) FMT_NOEXCEPT {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1)
+    ec = error_code(errno);
+}
+
+void 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(system_error(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]);
+}
+
+buffered_file 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(system_error(errno,
+                           "cannot associate stream with file descriptor"));
+  buffered_file bf(f);
+  fd_ = -1;
+  return bf;
+}
+
+long 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(system_error(errno, "cannot get memory page size"));
+  return size;
+#endif
+}
+FMT_END_NAMESPACE
+

lib/fmt/posix.h

@@ -0,0 +1,417 @@
+// 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 <errno.h>
+#include <fcntl.h>   // for O_RDONLY
+#include <locale.h>  // for locale_t
+#include <stdio.h>
+#include <stdlib.h>  // for strtod_l
+
+#include <cstddef>
+
+#if defined __APPLE__ || defined(__FreeBSD__)
+# include <xlocale.h>  // 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)
+
+FMT_BEGIN_NAMESPACE
+
+/**
+  \rst
+  A reference to a null-terminated string. It can be constructed from a C
+  string or ``std::string``.
+
+  You can use one of the following typedefs for common character types:
+
+  +---------------+-----------------------------+
+  | Type          | Definition                  |
+  +===============+=============================+
+  | cstring_view  | basic_cstring_view<char>    |
+  +---------------+-----------------------------+
+  | wcstring_view | basic_cstring_view<wchar_t> |
+  +---------------+-----------------------------+
+
+  This class is most useful as a parameter type to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
+template <typename Char>
+class basic_cstring_view {
+ private:
+  const Char *data_;
+
+ public:
+  /** Constructs a string reference object from a C string. */
+  basic_cstring_view(const Char *s) : data_(s) {}
+
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
+  basic_cstring_view(const std::basic_string<Char> &s) : data_(s.c_str()) {}
+
+  /** Returns the pointer to a C string. */
+  const Char *c_str() const { return data_; }
+};
+
+typedef basic_cstring_view<char> cstring_view;
+typedef basic_cstring_view<wchar_t> wcstring_view;
+
+// An error code.
+class error_code {
+ private:
+  int value_;
+
+ public:
+  explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
+
+  int get() const FMT_NOEXCEPT { return value_; }
+};
+
+// A buffered file.
+class buffered_file {
+ private:
+  FILE *file_;
+
+  friend class file;
+
+  explicit buffered_file(FILE *f) : file_(f) {}
+
+ public:
+  // Constructs a buffered_file object which doesn't represent any file.
+  buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {}
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~buffered_file() FMT_DTOR_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.
+  buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
+
+  // A "move constructor" for moving from an lvalue.
+  buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_) {
+    f.file_ = FMT_NULL;
+  }
+
+  // A "move assignment operator" for moving from a temporary.
+  buffered_file &operator=(Proxy p) {
+    close();
+    file_ = p.file;
+    return *this;
+  }
+
+  // A "move assignment operator" for moving from an lvalue.
+  buffered_file &operator=(buffered_file &other) {
+    close();
+    file_ = other.file_;
+    other.file_ = FMT_NULL;
+    return *this;
+  }
+
+  // Returns a proxy object for moving from a temporary:
+  //   buffered_file file = buffered_file(...);
+  operator Proxy() FMT_NOEXCEPT {
+    Proxy p = {file_};
+    file_ = FMT_NULL;
+    return p;
+  }
+
+#else
+ private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file);
+
+ public:
+  buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) {
+    other.file_ = FMT_NULL;
+  }
+
+  buffered_file& operator=(buffered_file &&other) {
+    close();
+    file_ = other.file_;
+    other.file_ = FMT_NULL;
+    return *this;
+  }
+#endif
+
+  // Opens a file.
+  FMT_API buffered_file(cstring_view filename, cstring_view mode);
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the pointer to a FILE object representing this file.
+  FILE *get() const FMT_NOEXCEPT { return file_; }
+
+  // We place parentheses around fileno to workaround a bug in some versions
+  // of MinGW that define fileno as a macro.
+  FMT_API int (fileno)() const;
+
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
+
+  template <typename... Args>
+  inline void print(string_view format_str, const Args & ... args) {
+    vprint(format_str, make_format_args(args...));
+  }
+};
+
+// A file. Closed file is represented by a file object with descriptor -1.
+// Methods that are not declared with FMT_NOEXCEPT may throw
+// fmt::system_error in case of failure. Note that some errors such as
+// closing the file multiple times will cause a crash on Windows rather
+// than an exception. You can get standard behavior by overriding the
+// invalid parameter handler with _set_invalid_parameter_handler.
+class file {
+ private:
+  int fd_;  // File descriptor.
+
+  // Constructs a file object with a given descriptor.
+  explicit file(int fd) : fd_(fd) {}
+
+ public:
+  // Possible values for the oflag argument to the constructor.
+  enum {
+    RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
+    WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
+    RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
+  };
+
+  // Constructs a file object which doesn't represent any file.
+  file() FMT_NOEXCEPT : fd_(-1) {}
+
+  // Opens a file and constructs a file object representing this file.
+  FMT_API file(cstring_view path, int oflag);
+
+#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 f = 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_DTOR_NOEXCEPT;
+
+  // Returns the file descriptor.
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the file size. The size has signed type for consistency with
+  // stat::st_size.
+  FMT_API long long size() const;
+
+  // Attempts to read count bytes from the file into the specified buffer.
+  FMT_API 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, error_code &ec) FMT_NOEXCEPT;
+
+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  FMT_API static void pipe(file &read_end, file &write_end);
+
+  // Creates a buffered_file object associated with this file and detaches
+  // this file object from the file.
+  FMT_API buffered_file fdopen(const char *mode);
+};
+
+// Returns the memory page size.
+long getpagesize();
+
+#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
+    !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
+# 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(system_error(errno, "cannot create locale"));
+  }
+  ~Locale() { freelocale(locale_); }
+
+  Type get() const { return locale_; }
+
+  // Converts string to floating-point number and advances str past the end
+  // of the parsed input.
+  double strtod(const char *&str) const {
+    char *end = FMT_NULL;
+    double result = strtod_l(str, &end, locale_);
+    str = end;
+    return result;
+  }
+};
+#endif  // FMT_LOCALE
+FMT_END_NAMESPACE
+
+#if !FMT_USE_RVALUE_REFERENCES
+namespace std {
+// For compatibility with C++98.
+inline fmt::buffered_file &move(fmt::buffered_file &f) { return f; }
+inline fmt::file &move(fmt::file &f) { return f; }
+}
+#endif
+
+#endif  // FMT_POSIX_H_

lib/fmt/printf.h

@@ -0,0 +1,728 @@
+// 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 <algorithm>  // std::fill_n
+#include <limits>     // std::numeric_limits
+
+#include "ostream.h"
+
+FMT_BEGIN_NAMESPACE
+namespace internal {
+
+// Checks if a value fits in int - used to avoid warnings about comparing
+// signed and unsigned integers.
+template <bool IsSigned>
+struct int_checker {
+  template <typename T>
+  static bool fits_in_int(T value) {
+    unsigned max = std::numeric_limits<int>::max();
+    return value <= max;
+  }
+  static bool fits_in_int(bool) { return true; }
+};
+
+template <>
+struct int_checker<true> {
+  template <typename T>
+  static bool fits_in_int(T value) {
+    return value >= std::numeric_limits<int>::min() &&
+           value <= std::numeric_limits<int>::max();
+  }
+  static bool fits_in_int(int) { return true; }
+};
+
+class printf_precision_handler: public function<int> {
+ public:
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, int>::type
+      operator()(T value) {
+    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+      FMT_THROW(format_error("number is too big"));
+    return static_cast<int>(value);
+  }
+
+  template <typename T>
+  typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T) {
+    FMT_THROW(format_error("precision is not integer"));
+    return 0;
+  }
+};
+
+// An argument visitor that returns true iff arg is a zero integer.
+class is_zero_int: public function<bool> {
+ public:
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, bool>::type
+      operator()(T value) { return value == 0; }
+
+  template <typename T>
+  typename std::enable_if<!std::is_integral<T>::value, bool>::type
+      operator()(T) { return false; }
+};
+
+template <typename T>
+struct make_unsigned_or_bool : std::make_unsigned<T> {};
+
+template <>
+struct make_unsigned_or_bool<bool> {
+  typedef bool type;
+};
+
+template <typename T, typename Context>
+class arg_converter: public function<void> {
+ private:
+  typedef typename Context::char_type Char;
+
+  basic_format_arg<Context> &arg_;
+  typename Context::char_type type_;
+
+ public:
+  arg_converter(basic_format_arg<Context> &arg, Char type)
+    : arg_(arg), type_(type) {}
+
+  void operator()(bool value) {
+    if (type_ != 's')
+      operator()<bool>(value);
+  }
+
+  template <typename U>
+  typename std::enable_if<std::is_integral<U>::value>::type
+      operator()(U value) {
+    bool is_signed = type_ == 'd' || type_ == 'i';
+    typedef typename std::conditional<
+        std::is_same<T, void>::value, U, T>::type TargetType;
+    if (const_check(sizeof(TargetType) <= sizeof(int))) {
+      // Extra casts are used to silence warnings.
+      if (is_signed) {
+        arg_ = internal::make_arg<Context>(
+          static_cast<int>(static_cast<TargetType>(value)));
+      } else {
+        typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
+        arg_ = internal::make_arg<Context>(
+          static_cast<unsigned>(static_cast<Unsigned>(value)));
+      }
+    } else {
+      if (is_signed) {
+        // 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_ = internal::make_arg<Context>(static_cast<long long>(value));
+      } else {
+        arg_ = internal::make_arg<Context>(
+          static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      }
+    }
+  }
+
+  template <typename U>
+  typename std::enable_if<!std::is_integral<U>::value>::type operator()(U) {
+    // No coversion needed for non-integral types.
+  }
+};
+
+// 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 <typename T, typename Context, typename Char>
+void convert_arg(basic_format_arg<Context> &arg, Char type) {
+  visit(arg_converter<T, Context>(arg, type), arg);
+}
+
+// Converts an integer argument to char for printf.
+template <typename Context>
+class char_converter: public function<void> {
+ private:
+  basic_format_arg<Context> &arg_;
+
+  FMT_DISALLOW_COPY_AND_ASSIGN(char_converter);
+
+ public:
+  explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
+
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value>::type
+      operator()(T value) {
+    typedef typename Context::char_type Char;
+    arg_ = internal::make_arg<Context>(static_cast<Char>(value));
+  }
+
+  template <typename T>
+  typename std::enable_if<!std::is_integral<T>::value>::type operator()(T) {
+    // No coversion needed for non-integral types.
+  }
+};
+
+// Checks if an argument is a valid printf width specifier and sets
+// left alignment if it is negative.
+template <typename Char>
+class printf_width_handler: public function<unsigned> {
+ private:
+  typedef basic_format_specs<Char> format_specs;
+
+  format_specs &spec_;
+
+  FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler);
+
+ public:
+  explicit printf_width_handler(format_specs &spec) : spec_(spec) {}
+
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, unsigned>::type
+      operator()(T value) {
+    typedef typename internal::int_traits<T>::main_type UnsignedType;
+    UnsignedType width = static_cast<UnsignedType>(value);
+    if (internal::is_negative(value)) {
+      spec_.align_ = ALIGN_LEFT;
+      width = 0 - width;
+    }
+    unsigned int_max = std::numeric_limits<int>::max();
+    if (width > int_max)
+      FMT_THROW(format_error("number is too big"));
+    return static_cast<unsigned>(width);
+  }
+
+  template <typename T>
+  typename std::enable_if<!std::is_integral<T>::value, unsigned>::type
+      operator()(T) {
+    FMT_THROW(format_error("width is not integer"));
+    return 0;
+  }
+};
+}  // namespace internal
+
+template <typename Range>
+class printf_arg_formatter;
+
+template <
+    typename OutputIt, typename Char,
+    typename ArgFormatter =
+      printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
+class basic_printf_context;
+
+/**
+  \rst
+  The ``printf`` argument formatter.
+  \endrst
+ */
+template <typename Range>
+class printf_arg_formatter:
+  public internal::function<
+    typename internal::arg_formatter_base<Range>::iterator>,
+  public internal::arg_formatter_base<Range> {
+ private:
+  typedef typename Range::value_type char_type;
+  typedef decltype(internal::declval<Range>().begin()) iterator;
+  typedef internal::arg_formatter_base<Range> base;
+  typedef basic_printf_context<iterator, char_type> context_type;
+
+  context_type &context_;
+
+  void write_null_pointer(char) {
+    this->spec().type_ = 0;
+    this->write("(nil)");
+  }
+
+  void write_null_pointer(wchar_t) {
+    this->spec().type_ = 0;
+    this->write(L"(nil)");
+  }
+
+ public:
+  typedef typename base::format_specs format_specs;
+
+  /**
+    \rst
+    Constructs an argument formatter object.
+    *buffer* is a reference to the output buffer and *spec* contains format
+    specifier information for standard argument types.
+    \endrst
+   */
+  printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
+                       format_specs &spec, context_type &ctx)
+    : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), spec),
+      context_(ctx) {}
+
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, iterator>::type
+      operator()(T value) {
+    // MSVC2013 fails to compile separate overloads for bool and char_type so
+    // use std::is_same instead.
+    if (std::is_same<T, bool>::value) {
+      format_specs &fmt_spec = this->spec();
+      if (fmt_spec.type_ != 's')
+        return base::operator()(value ? 1 : 0);
+      fmt_spec.type_ = 0;
+      this->write(value != 0);
+    } else if (std::is_same<T, char_type>::value) {
+      format_specs &fmt_spec = this->spec();
+      if (fmt_spec.type_ && fmt_spec.type_ != 'c')
+        return (*this)(static_cast<int>(value));
+      fmt_spec.flags_ = 0;
+      fmt_spec.align_ = ALIGN_RIGHT;
+      return base::operator()(value);
+    } else {
+      return base::operator()(value);
+    }
+    return this->out();
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
+      operator()(T value) {
+    return base::operator()(value);
+  }
+
+  /** Formats a null-terminated C string. */
+  iterator operator()(const char *value) {
+    if (value)
+      base::operator()(value);
+    else if (this->spec().type_ == 'p')
+      write_null_pointer(char_type());
+    else
+      this->write("(null)");
+    return this->out();
+  }
+
+  /** Formats a null-terminated wide C string. */
+  iterator operator()(const wchar_t *value) {
+    if (value)
+      base::operator()(value);
+    else if (this->spec().type_ == 'p')
+      write_null_pointer(char_type());
+    else
+      this->write(L"(null)");
+    return this->out();
+  }
+
+  iterator operator()(basic_string_view<char_type> value) {
+    return base::operator()(value);
+  }
+
+  iterator operator()(monostate value) {
+    return base::operator()(value);
+  }
+
+  /** Formats a pointer. */
+  iterator operator()(const void *value) {
+    if (value)
+      return base::operator()(value);
+    this->spec().type_ = 0;
+    write_null_pointer(char_type());
+    return this->out();
+  }
+
+  /** Formats an argument of a custom (user-defined) type. */
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+    handle.format(context_);
+    return this->out();
+  }
+};
+
+template <typename T>
+struct printf_formatter {
+  template <typename ParseContext>
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); }
+
+  template <typename FormatContext>
+  auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) {
+    internal::format_value(internal::get_container(ctx.out()), value);
+    return ctx.out();
+  }
+};
+
+/** This template formats data and writes the output to a writer. */
+template <typename OutputIt, typename Char, typename ArgFormatter>
+class basic_printf_context :
+  private internal::context_base<
+    OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char> {
+ public:
+  /** The character type for the output. */
+  typedef Char char_type;
+
+  template <typename T>
+  struct formatter_type { typedef printf_formatter<T> type; };
+
+ private:
+  typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
+  typedef typename base::format_arg format_arg;
+  typedef basic_format_specs<char_type> format_specs;
+  typedef internal::null_terminating_iterator<char_type> iterator;
+
+  void parse_flags(format_specs &spec, iterator &it);
+
+  // Returns the argument with specified index or, if arg_index is equal
+  // to the maximum unsigned value, the next argument.
+  format_arg get_arg(
+      iterator it,
+      unsigned arg_index = (std::numeric_limits<unsigned>::max)());
+
+  // Parses argument index, flags and width and returns the argument index.
+  unsigned parse_header(iterator &it, format_specs &spec);
+
+ public:
+  /**
+   \rst
+   Constructs a ``printf_context`` object. References to the arguments and
+   the writer are stored in the context object so make sure they have
+   appropriate lifetimes.
+   \endrst
+   */
+  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
+                       basic_format_args<basic_printf_context> args)
+    : base(out, format_str, args) {}
+
+  using base::parse_context;
+  using base::out;
+  using base::advance_to;
+
+  /** Formats stored arguments and writes the output to the range. */
+  void format();
+};
+
+template <typename OutputIt, typename Char, typename AF>
+void basic_printf_context<OutputIt, Char, AF>::parse_flags(
+    format_specs &spec, iterator &it) {
+  for (;;) {
+    switch (*it++) {
+      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:
+        --it;
+        return;
+    }
+  }
+}
+
+template <typename OutputIt, typename Char, typename AF>
+typename basic_printf_context<OutputIt, Char, AF>::format_arg
+  basic_printf_context<OutputIt, Char, AF>::get_arg(
+    iterator it, unsigned arg_index) {
+  (void)it;
+  if (arg_index == std::numeric_limits<unsigned>::max())
+    return this->do_get_arg(this->parse_context().next_arg_id());
+  return base::get_arg(arg_index - 1);
+}
+
+template <typename OutputIt, typename Char, typename AF>
+unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
+  iterator &it, format_specs &spec) {
+  unsigned arg_index = std::numeric_limits<unsigned>::max();
+  char_type c = *it;
+  if (c >= '0' && c <= '9') {
+    // Parse an argument index (if followed by '$') or a width possibly
+    // preceded with '0' flag(s).
+    internal::error_handler eh;
+    unsigned value = parse_nonnegative_int(it, eh);
+    if (*it == '$') {  // value is an argument index
+      ++it;
+      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, it);
+  // Parse width.
+  if (*it >= '0' && *it <= '9') {
+    internal::error_handler eh;
+    spec.width_ = parse_nonnegative_int(it, eh);
+  } else if (*it == '*') {
+    ++it;
+    spec.width_ =
+        visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
+  }
+  return arg_index;
+}
+
+template <typename OutputIt, typename Char, typename AF>
+void basic_printf_context<OutputIt, Char, AF>::format() {
+  auto &buffer = internal::get_container(this->out());
+  auto start = iterator(this->parse_context());
+  auto it = start;
+  using internal::pointer_from;
+  while (*it) {
+    char_type c = *it++;
+    if (c != '%') continue;
+    if (*it == c) {
+      buffer.append(pointer_from(start), pointer_from(it));
+      start = ++it;
+      continue;
+    }
+    buffer.append(pointer_from(start), pointer_from(it) - 1);
+
+    format_specs spec;
+    spec.align_ = ALIGN_RIGHT;
+
+    // Parse argument index, flags and width.
+    unsigned arg_index = parse_header(it, spec);
+
+    // Parse precision.
+    if (*it == '.') {
+      ++it;
+      if ('0' <= *it && *it <= '9') {
+        internal::error_handler eh;
+        spec.precision_ = static_cast<int>(parse_nonnegative_int(it, eh));
+      } else if (*it == '*') {
+        ++it;
+        spec.precision_ =
+            visit(internal::printf_precision_handler(), get_arg(it));
+      } else {
+        spec.precision_ = 0;
+      }
+    }
+
+    format_arg arg = get_arg(it, arg_index);
+    if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg))
+      spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
+    if (spec.fill_ == '0') {
+      if (arg.is_arithmetic())
+        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::convert_arg;
+    switch (*it++) {
+    case 'h':
+      if (*it == 'h')
+        convert_arg<signed char>(arg, *++it);
+      else
+        convert_arg<short>(arg, *it);
+      break;
+    case 'l':
+      if (*it == 'l')
+        convert_arg<long long>(arg, *++it);
+      else
+        convert_arg<long>(arg, *it);
+      break;
+    case 'j':
+      convert_arg<intmax_t>(arg, *it);
+      break;
+    case 'z':
+      convert_arg<std::size_t>(arg, *it);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, *it);
+      break;
+    case 'L':
+      // printf produces garbage when 'L' is omitted for long double, no
+      // need to do the same.
+      break;
+    default:
+      --it;
+      convert_arg<void>(arg, *it);
+    }
+
+    // Parse type.
+    if (!*it)
+      FMT_THROW(format_error("invalid format string"));
+    spec.type_ = static_cast<char>(*it++);
+    if (arg.is_integral()) {
+      // Normalize type.
+      switch (spec.type_) {
+      case 'i': case 'u':
+        spec.type_ = 'd';
+        break;
+      case 'c':
+        // TODO: handle wchar_t better?
+        visit(internal::char_converter<basic_printf_context>(arg), arg);
+        break;
+      }
+    }
+
+    start = it;
+
+    // Format argument.
+    visit(AF(buffer, spec, *this), arg);
+  }
+  buffer.append(pointer_from(start), pointer_from(it));
+}
+
+template <typename Char, typename Context>
+void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format,
+            basic_format_args<Context> args) {
+  Context(std::back_inserter(buf), format, args).format();
+}
+
+template <typename Buffer>
+struct printf_context {
+  typedef basic_printf_context<
+    std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
+};
+
+template <typename ...Args>
+inline format_arg_store<printf_context<internal::buffer>::type, Args...>
+    make_printf_args(const Args & ... args) {
+  return format_arg_store<printf_context<internal::buffer>::type, Args...>(
+      args...);
+}
+typedef basic_format_args<printf_context<internal::buffer>::type> printf_args;
+typedef basic_format_args<printf_context<internal::wbuffer>::type> wprintf_args;
+
+inline std::string vsprintf(string_view format, printf_args args) {
+  memory_buffer buffer;
+  printf(buffer, format, args);
+  return to_string(buffer);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template <typename... Args>
+inline std::string sprintf(string_view format_str, const Args & ... args) {
+  return vsprintf(format_str,
+    make_format_args<typename printf_context<internal::buffer>::type>(args...));
+}
+
+inline std::wstring vsprintf(wstring_view format, wprintf_args args) {
+  wmemory_buffer buffer;
+  printf(buffer, format, args);
+  return to_string(buffer);
+}
+
+template <typename... Args>
+inline std::wstring sprintf(wstring_view format_str, const Args & ... args) {
+  return vsprintf(format_str,
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+}
+
+template <typename Char>
+inline int vfprintf(std::FILE *f, basic_string_view<Char> format,
+                    basic_format_args<typename printf_context<
+                      internal::basic_buffer<Char>>::type> args) {
+  basic_memory_buffer<Char> buffer;
+  printf(buffer, format, args);
+  std::size_t size = buffer.size();
+  return std::fwrite(
+    buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
+}
+
+/**
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename... Args>
+inline int fprintf(std::FILE *f, string_view format_str, const Args & ... args) {
+  auto vargs = make_format_args<
+    typename printf_context<internal::buffer>::type>(args...);
+  return vfprintf<char>(f, format_str, vargs);
+}
+
+template <typename... Args>
+inline int fprintf(std::FILE *f, wstring_view format_str,
+                   const Args & ... args) {
+  return vfprintf(f, format_str,
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+}
+
+inline int vprintf(string_view format, printf_args args) {
+  return vfprintf(stdout, format, args);
+}
+
+inline int vprintf(wstring_view format, wprintf_args args) {
+  return vfprintf(stdout, format, args);
+}
+
+/**
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
+ */
+template <typename... Args>
+inline int printf(string_view format_str, const Args & ... args) {
+  return vprintf(format_str,
+    make_format_args<typename printf_context<internal::buffer>::type>(args...));
+}
+
+template <typename... Args>
+inline int printf(wstring_view format_str, const Args & ... args) {
+  return vprintf(format_str,
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+}
+
+inline int vfprintf(std::ostream &os, string_view format_str,
+                    printf_args args) {
+  memory_buffer buffer;
+  printf(buffer, format_str, args);
+  internal::write(os, buffer);
+  return static_cast<int>(buffer.size());
+}
+
+inline int vfprintf(std::wostream &os, wstring_view format_str,
+                    wprintf_args args) {
+  wmemory_buffer buffer;
+  printf(buffer, format_str, args);
+  internal::write(os, buffer);
+  return static_cast<int>(buffer.size());
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::fprintf(cerr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename... Args>
+inline int fprintf(std::ostream &os, string_view format_str,
+                   const Args & ... args) {
+  auto vargs = make_format_args<
+    typename printf_context<internal::buffer>::type>(args...);
+  return vfprintf(os, format_str, vargs);
+}
+
+template <typename... Args>
+inline int fprintf(std::wostream &os, wstring_view format_str,
+                   const Args & ... args) {
+  auto vargs = make_format_args<
+    typename printf_context<internal::buffer>::type>(args...);
+  return vfprintf(os, format_str, vargs);
+}
+FMT_END_NAMESPACE
+
+#endif  // FMT_PRINTF_H_

lib/fmt/ranges.h

@@ -0,0 +1,305 @@
+// Formatting library for C++ - the core API
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#ifndef FMT_RANGES_H_
+#define FMT_RANGES_H_
+
+#include "format.h"
+#include <type_traits>
+
+// output only up to N items from the range.
+#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
+# define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+#endif
+
+FMT_BEGIN_NAMESPACE
+
+template <typename Char>
+struct formatting_base {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+};
+
+template <typename Char, typename Enable = void>
+struct formatting_range : formatting_base<Char> {
+  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
+  Char prefix;
+  Char delimiter;
+  Char postfix;
+  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+};
+
+template <typename Char, typename Enable = void>
+struct formatting_tuple : formatting_base<Char> {
+  Char prefix;
+  Char delimiter;
+  Char postfix;
+  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+};
+
+namespace internal {
+
+template <typename RangeT, typename OutputIterator>
+void copy(const RangeT &range, OutputIterator out) {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+}
+
+template <typename OutputIterator>
+void copy(const char *str, OutputIterator out) {
+  const char *p_curr = str;
+  while (*p_curr) {
+    *out++ = *p_curr++;
+  }
+}
+
+template <typename OutputIterator>
+void copy(char ch, OutputIterator out) {
+  *out++ = ch;
+}
+
+/// Return true value if T has std::string interface, like std::string_view.
+template <typename T>
+class is_like_std_string {
+  template <typename U>
+  static auto check(U *p) ->
+    decltype(p->find('a'), p->length(), p->data(), int());
+  template <typename>
+  static void check(...);
+
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+};
+
+template <typename... Ts>
+struct conditional_helper {};
+
+template <typename T, typename _ = void>
+struct is_range_ : std::false_type {};
+
+#if !FMT_MSC_VER || FMT_MSC_VER > 1800
+template <typename T>
+struct is_range_<T, typename std::conditional<
+                    false,
+                    conditional_helper<decltype(internal::declval<T>().begin()),
+                                       decltype(internal::declval<T>().end())>,
+                    void>::type> : std::true_type {};
+#endif
+
+/// tuple_size and tuple_element check.
+template <typename T>
+class is_tuple_like_ {
+  template <typename U>
+  static auto check(U *p) ->
+    decltype(std::tuple_size<U>::value,
+      internal::declval<typename std::tuple_element<0, U>::type>(), int());
+  template <typename>
+  static void check(...);
+
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+};
+
+// Check for integer_sequence
+#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
+template <typename T, T... N>
+using integer_sequence = std::integer_sequence<T, N...>;
+template <std::size_t... N>
+using index_sequence = std::index_sequence<N...>;
+template <std::size_t N>
+using make_index_sequence = std::make_index_sequence<N>;
+#else
+template <typename T, T... N>
+struct integer_sequence {
+  typedef T value_type;
+
+  static FMT_CONSTEXPR std::size_t size() {
+    return sizeof...(N);
+  }
+};
+
+template <std::size_t... N>
+using index_sequence = integer_sequence<std::size_t, N...>;
+
+template <typename T, std::size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
+template <typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
+
+template <std::size_t N>
+using make_index_sequence = make_integer_sequence<std::size_t, N>;
+#endif
+
+template <class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
+}
+
+template <class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> 
+get_indexes(T const &) { return {}; }
+
+template <class Tuple, class F>
+void for_each(Tuple &&tup, F &&f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+}
+
+template<typename Arg>
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
+  typename std::enable_if<
+    !is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
+  return add_space ? " {}" : "{}";
+}
+
+template<typename Arg>
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
+  typename std::enable_if<
+    is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
+  return add_space ? " \"{}\"" : "\"{}\"";
+}
+
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
+  return add_space ? " \"{}\"" : "\"{}\"";
+}
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
+    return add_space ? L" \"{}\"" : L"\"{}\"";
+}
+
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
+    return add_space ? " '{}'" : "'{}'";
+}
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
+    return add_space ? L" '{}'" : L"'{}'";
+}
+
+}  // namespace internal
+
+template <typename T>
+struct is_tuple_like {
+  static FMT_CONSTEXPR_DECL const bool value =
+    internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
+};
+
+template <typename TupleT, typename Char>
+struct formatter<TupleT, Char, 
+    typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
+private:
+  // C++11 generic lambda for format()
+  template <typename FormatContext>
+  struct format_each {
+    template <typename T>
+    void operator()(const T& v) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) {
+          *out++ = ' ';
+        }
+        internal::copy(formatting.delimiter, out);
+      }
+      format_to(out,
+                internal::format_str_quoted(
+                    (formatting.add_delimiter_spaces && i > 0), v),
+                v);
+      ++i;
+    }
+
+    formatting_tuple<Char>& formatting;
+    std::size_t& i;
+    typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
+  };
+
+public:
+  formatting_tuple<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext = format_context>
+  auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    std::size_t i = 0;
+    internal::copy(formatting.prefix, out);
+
+    internal::for_each(values, format_each<FormatContext>{formatting, i, out});
+    if (formatting.add_prepostfix_space) {
+      *out++ = ' ';
+    }
+    internal::copy(formatting.postfix, out);
+
+    return ctx.out();
+  }
+};
+
+template <typename T>
+struct is_range {
+  static FMT_CONSTEXPR_DECL const bool value =
+    internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
+};
+
+template <typename RangeT, typename Char>
+struct formatter<RangeT, Char,
+    typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
+
+  formatting_range<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(
+      const RangeT &values, FormatContext &ctx) {
+    auto out = ctx.out();
+    internal::copy(formatting.prefix, out);
+    std::size_t i = 0;
+    for (auto it = values.begin(), end = values.end(); it != end; ++it) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) {
+          *out++ = ' ';
+        }
+        internal::copy(formatting.delimiter, out);
+      }
+      format_to(out,
+                internal::format_str_quoted(
+                    (formatting.add_delimiter_spaces && i > 0), *it),
+                *it);
+      if (++i > formatting.range_length_limit) {
+        format_to(out, " ... <other elements>");
+        break;
+      }
+    }
+    if (formatting.add_prepostfix_space) {
+      *out++ = ' ';
+    }
+    internal::copy(formatting.postfix, out);
+    return ctx.out();
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif // FMT_RANGES_H_
+

lib/fmt/time.h

@@ -0,0 +1,152 @@
+// 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 <ctime>
+
+FMT_BEGIN_NAMESPACE
+
+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 dispatcher {
+    std::time_t time_;
+    std::tm tm_;
+
+    dispatcher(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;
+    }
+  };
+  dispatcher lt(time);
+  if (lt.run())
+    return lt.tm_;
+  // Too big time values may be unsupported.
+  FMT_THROW(format_error("time_t value out of range"));
+}
+
+// Thread-safe replacement for std::gmtime
+inline std::tm gmtime(std::time_t time) {
+  struct dispatcher {
+    std::time_t time_;
+    std::tm tm_;
+
+    dispatcher(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) tm_ = *tm;
+      return tm != FMT_NULL;
+    }
+  };
+  dispatcher gt(time);
+  if (gt.run())
+    return gt.tm_;
+  // Too big time values may be unsupported.
+  FMT_THROW(format_error("time_t value out of range"));
+}
+
+namespace internal {
+inline std::size_t strftime(char *str, std::size_t count, const char *format,
+                            const std::tm *time) {
+  return std::strftime(str, count, format, time);
+}
+
+inline std::size_t strftime(wchar_t *str, std::size_t count,
+                            const wchar_t *format, const std::tm *time) {
+  return std::wcsftime(str, count, format, time);
+}
+}
+
+template <typename Char>
+struct formatter<std::tm, Char> {
+  template <typename ParseContext>
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    auto it = internal::null_terminating_iterator<Char>(ctx);
+    if (*it == ':')
+      ++it;
+    auto end = it;
+    while (*end && *end != '}')
+      ++end;
+    tm_format.reserve(end - it + 1);
+    using internal::pointer_from;
+    tm_format.append(pointer_from(it), pointer_from(end));
+    tm_format.push_back('\0');
+    return pointer_from(end);
+  }
+
+  template <typename FormatContext>
+  auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) {
+    internal::basic_buffer<Char> &buf = internal::get_container(ctx.out());
+    std::size_t start = buf.size();
+    for (;;) {
+      std::size_t size = buf.capacity() - start;
+      std::size_t count =
+        internal::strftime(&buf[start], size, &tm_format[0], &tm);
+      if (count != 0) {
+        buf.resize(start + count);
+        break;
+      }
+      if (size >= tm_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;
+      buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
+    }
+    return ctx.out();
+  }
+
+  basic_memory_buffer<Char> tm_format;
+};
+FMT_END_NAMESPACE
+
+#endif  // FMT_TIME_H_

src/CMakeLists.txt

@@ -37,6 +37,7 @@ if (WITH_WIN32_GUI)
 endif (WITH_WIN32_GUI)
 
 subdirs(compat common win32 bntrackd client bniutils bnpass)
+include_directories(${CMAKE_SOURCE_DIR}/lib)
 
 if(WITH_BNETD)
     add_subdirectory(bnetd)

src/bnetd/CMakeLists.txt

@@ -53,6 +53,9 @@ else(WITH_WIN32_GUI)
   add_executable(bnetd ${BNETD_SOURCES} ${BNETD_CONSOLE_RESOURCES})
 endif(WITH_WIN32_GUI)
 
-  target_link_libraries(bnetd common compat win32 ${NETWORK_LIBRARIES}
+target_include_directories(bnetd PUBLIC ${CMAKE_SOURCE_DIR}/fmt)
+
+target_link_libraries(bnetd PUBLIC fmt common compat win32 ${NETWORK_LIBRARIES}
     ${ZLIB_LIBRARIES} ${MYSQL_LIBRARIES} ${SQLITE3_LIBRARIES} ${PGSQL_LIBRARIES} ${ODBC_LIBRARIES} ${LUA_LIBRARIES})
+
   install(TARGETS bnetd DESTINATION ${SBINDIR})

src/bnetd/i18n.cpp

@@ -36,6 +36,8 @@
 # include <sys/stat.h>
 #endif
 
+#include <fmt/format.h>
+
 #include "compat/strcasecmp.h"
 #include "compat/pdir.h"
 
@@ -48,7 +50,6 @@
 #include "common/util.h"
 #include "common/tag.h"
 #include "common/pugixml.h"
-#include "common/format.h"
 
 #include "account.h"
 #include "connection.h"
@@ -199,7 +200,7 @@ namespace pvpgn
 
 			return 0;
 		}
-
+		/*
 		extern std::string _localize(t_connection * c, const char * func, const char * fmt, const fmt::ArgList &args)
 		{
 			const char *format = fmt;
@@ -231,7 +232,7 @@ namespace pvpgn
 
 			return output;
 		}
-
+		*/
 
 		/* Find localized text for the given language */
 		const char * _find_string(char const * text, t_gamelang gamelang)

src/bnetd/i18n.h

@@ -42,7 +42,7 @@ namespace pvpgn
 #define JUST_NEED_TYPES
 # include <string>
 # include "connection.h"
-# include "common/format.h"
+#include <fmt/format.h>
 #undef JUST_NEED_TYPES
 
 namespace pvpgn
@@ -67,8 +67,38 @@ namespace pvpgn
 		extern int tag_check_gamelang_real(t_tag gamelang);
 
 
-		extern std::string _localize(t_connection * c, const char * func, const char *fmt, const fmt::ArgList &args);
+		template <typename... Args>
-		FMT_VARIADIC(std::string, _localize, t_connection *, const char *, const char *)
+		std::string _localize(t_connection * c, const char * func, fmt::string_view format_str, const Args& ... args)
+		{
+			const char *format = fmt;
+			std::string output(fmt);
+			t_gamelang lang;
+
+			if (!c) {
+				eventlog(eventlog_level_error, __FUNCTION__, "got bad connection");
+				return format;
+			}
+			try
+			{
+				if (lang = conn_get_gamelang_localized(c))
+					if (!(format = _find_string(fmt, lang)))
+						format = fmt; // if not found use original
+
+				output = fmt::format(format, args);
+
+				char tmp[MAX_MESSAGE_LEN];
+				std::snprintf(tmp, sizeof tmp, "%s", output.c_str());
+
+				i18n_convert(c, tmp);
+				output = tmp;
+			}
+			catch (const std::exception& e)
+			{
+				WARN2("Can't format translation string \"{}\" ({})", fmt, e.what());
+			}
+
+			return output;
+		}
 
 		#define localize(c, ...) _localize(c, __FUNCTION__, __VA_ARGS__)
 	}

src/bnetd/versioncheck.cpp

@@ -38,19 +38,18 @@
 #include <tuple>
 #include <unordered_map>
 
-#include "common/eventlog.h"
+#include <fmt/format.h>
+#include "json/json.hpp"
 
+#include "common/eventlog.h"
 #include "common/field_sizes.h"
-#include "common/format.h"
 #include "common/hash_tuple.hpp"
 #include "common/proginfo.h"
 #include "compat/strcasecmp.h"
+#include "common/tag.h"
 #include "common/token.h"
 #include "common/util.h"
 
-
-#include "json/json.hpp"
-
 #include "prefs.h"
 #include "common/setup_after.h"
 

src/common/CMakeLists.txt

@@ -19,8 +19,8 @@ set(COMMON_SOURCES
 	version.h wolhash.cpp wolhash.h xalloc.cpp xalloc.h xstr.cpp xstr.h 
 	xstring.cpp xstring.h gui_printf.h gui_printf.cpp 
 	bigint.cpp bigint.h bnetsrp3.cpp bnetsrp3.h peerchat.cpp peerchat.h
-    wol_gameres_protocol.h
+    wol_gameres_protocol.h pugiconfig.h pugixml.cpp pugixml.h)
-	format.cc format.h pugiconfig.h pugixml.cpp pugixml.h)
 add_library(common
   ${COMMON_SOURCES}
 )
+target_link_libraries(common fmt)

src/common/eventlog.cpp

@@ -28,7 +28,7 @@
 #include <string>
 #include <sstream>
 
-#include <common/format.h>
+#include <fmt/format.h>
 
 #include "compat/strcasecmp.h"
 #include "common/hexdump.h"
@@ -40,8 +40,8 @@
 namespace pvpgn
 {
 
-	static std::FILE *           eventstrm = NULL;
+	extern std::FILE *eventstrm = NULL;
-	static unsigned currlevel = eventlog_level_debug |
+	extern unsigned currlevel = eventlog_level_debug |
 		eventlog_level_info |
 		eventlog_level_warn |
 		eventlog_level_error |
@@ -51,7 +51,7 @@ namespace pvpgn
 #endif
 		;
 	/* FIXME: maybe this should be default for win32 */
-	static int eventlog_debugmode = 0;
+	extern int eventlog_debugmode = 0;
 
 	extern void eventlog_set_debugmode(int debugmode)
 	{
@@ -264,102 +264,6 @@ namespace pvpgn
 		std::fflush(eventstrm);
 	}
 
-	//template <typename... Args>
-	//extern void eventlog2(t_eventlog_level level, const char* module, const char* format, const Args& ... args)
-	void eventlog(t_eventlog_level level, const char* module, const char* format, fmt::ArgList args)
-	{
-		if (!(level & currlevel))
-		{
-			return;
-		}
-
-		if (!eventstrm)
-		{
-			return;
-		}
-
-		std::time_t now = std::time(nullptr);
-		std::tm* tmnow = std::localtime(&now);
-		std::string time;
-		if (!tmnow)
-		{
-			time = "?";
-		}
-		else
-		{
-			std::stringstream temp;
-			temp << std::put_time(tmnow, EVENT_TIME_FORMAT);
-			time = fmt::format("{}", temp.str());
-		}
-
-		if (!module)
-		{
-			fmt::print(eventstrm, "{} [error] eventlog: got NULL module\n", time);
-#ifdef WIN32_GUI
-			if (eventlog_level_gui & currlevel)
-				gui_lvprintf(eventlog_level_error, "{} [error] eventlog: got NULL module\n", time);
-#endif
-			std::fflush(eventstrm);
-			return;
-		}
-
-		if (!format)
-		{
-			fmt::print(eventstrm, "{} [error] eventlog: got NULL fmt\n", time);
-#ifdef WIN32_GUI
-			if (eventlog_level_gui&currlevel)
-				gui_lvprintf(eventlog_level_error, "{} [error] eventlog: got NULL fmt\n", time);
-#endif
-			std::fflush(eventstrm);
-			return;
-		}
-
-		/****************************************************************/
-
-		try
-		{
-			fmt::print(eventstrm, "{} [{}] {}: ", time, eventlog_get_levelname_str(level), module);
-#ifdef WIN32_GUI
-			if (eventlog_level_gui&currlevel)
-			{
-				gui_lvprintf(level, "{} [{}] {}: ", time, eventlog_get_levelname_str(level), module);
-			}
-#endif
-
-			fmt::print(eventstrm, format, args);
-#ifdef WIN32_GUI
-			if (eventlog_level_gui & currlevel)
-			{
-				gui_lvprintf(level, format, args);
-			}
-#endif
-
-			fmt::print(eventstrm, "\n");
-#ifdef WIN32_GUI
-			if (eventlog_level_gui & currlevel)
-			{
-				gui_lvprintf(level, "\n");
-			}
-#endif
-
-			if (eventlog_debugmode)
-			{
-				fmt::print("{} [{}] {}: {}\n", time, eventlog_get_levelname_str(level), module, fmt::format(format, args));
-				std::fflush(stdout);
-			}
-		}
-		catch (const fmt::FormatError& e)
-		{
-			fmt::print(eventstrm, "Failed to format string ({})\n", e.what());
-#ifdef WIN32_GUI
-			if (eventlog_level_gui & currlevel)
-				gui_lvprintf(eventlog_level_error, "Failed to format string ({})\n", e.what());
-#endif
-		}
-
-		std::fflush(eventstrm);
-	}
-
 	extern void eventlog_step(char const * filename, t_eventlog_level level, char const * module, char const * fmt, ...)
 	{
 		std::va_list args;

src/common/eventlog.h

@@ -47,7 +47,17 @@ namespace pvpgn
 #define INCLUDED_EVENTLOG_PROTOS
 
 #include <cstdio>
-#include <common/format.h>
+#include <ctime>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#ifdef WIN32_GUI
+# include "common/gui_printf.h"
+#endif
+
+#include <fmt/format.h>
 
 namespace pvpgn
 {
@@ -63,10 +73,104 @@ namespace pvpgn
 	extern char const * eventlog_get_levelname_str(t_eventlog_level level);
 	extern void eventlog_hexdump_data(void const * data, unsigned int len);
 
-	void eventlog(t_eventlog_level level, const char* module, const char* format, fmt::ArgList args);
+	extern std::FILE *eventstrm;
-	FMT_VARIADIC(void, eventlog, t_eventlog_level, const char*, const char*)
+	extern unsigned currlevel;
-	//template <typename... Args>
+	extern int eventlog_debugmode;
-	// extern void eventlog2(t_eventlog_level level, const char* module, const char* format, const Args& ... args);
+
+	template <typename... Args>
+	void eventlog(t_eventlog_level level, const char* module, fmt::string_view format_str, const Args& ... args)
+	{
+		if (!(level & currlevel))
+		{
+			return;
+		}
+
+		if (!eventstrm)
+		{
+			return;
+		}
+
+		std::time_t now = std::time(nullptr);
+		std::tm* tmnow = std::localtime(&now);
+		std::string time;
+		if (!tmnow)
+		{
+			time = "?";
+		}
+		else
+		{
+			std::stringstream temp;
+			temp << std::put_time(tmnow, EVENT_TIME_FORMAT);
+			time = fmt::format("{}", temp.str());
+		}
+
+		if (!module)
+		{
+			fmt::print(eventstrm, "{} [error] eventlog: got NULL module\n", time);
+#ifdef WIN32_GUI
+			if (eventlog_level_gui & currlevel)
+				gui_lvprintf(eventlog_level_error, "{} [error] eventlog: got NULL module\n", time);
+#endif
+			std::fflush(eventstrm);
+			return;
+		}
+
+		if (format_str.size() == 0)
+		{
+			fmt::print(eventstrm, "{} [error] eventlog: got NULL fmt\n", time);
+#ifdef WIN32_GUI
+			if (eventlog_level_gui&currlevel)
+				gui_lvprintf(eventlog_level_error, "{} [error] eventlog: got NULL fmt\n", time);
+#endif
+			std::fflush(eventstrm);
+			return;
+		}
+
+		/****************************************************************/
+
+		try
+		{
+			fmt::print(eventstrm, "{} [{}] {}: ", time, eventlog_get_levelname_str(level), module);
+#ifdef WIN32_GUI
+			if (eventlog_level_gui&currlevel)
+			{
+				gui_lvprintf(level, "{} [{}] {}: ", time, eventlog_get_levelname_str(level), module);
+			}
+#endif
+
+			fmt::print(eventstrm, format_str, args...);
+#ifdef WIN32_GUI
+			if (eventlog_level_gui & currlevel)
+			{
+				gui_lvprintf(level, format_str.data(), args...);
+			}
+#endif
+
+			fmt::print(eventstrm, "\n");
+#ifdef WIN32_GUI
+			if (eventlog_level_gui & currlevel)
+			{
+				gui_lvprintf(level, "\n");
+			}
+#endif
+
+			if (eventlog_debugmode)
+			{
+				fmt::print("{} [{}] {}: {}\n", time, eventlog_get_levelname_str(level), module, fmt::format(format_str, args...));
+				std::fflush(stdout);
+			}
+		}
+		catch (const fmt::format_error& e)
+		{
+			fmt::print(eventstrm, "Failed to format string ({})\n", e.what());
+#ifdef WIN32_GUI
+			if (eventlog_level_gui & currlevel)
+				gui_lvprintf(eventlog_level_error, "Failed to format string ({})\n", e.what());
+#endif
+		}
+
+		std::fflush(eventstrm);
+	}
 
 	extern void eventlog_step(char const * filename, t_eventlog_level level, char const * module, char const * fmt, ...) PRINTF_ATTR(4, 5);
 

src/common/format.cc

@@ -1,948 +0,0 @@
-/*
-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 <string.h>
-
-#include <cctype>
-#include <cerrno>
-#include <climits>
-#include <cmath>
-#include <cstdarg>
-#include <cstddef>  // for std::ptrdiff_t
-
-#if defined(_WIN32) && defined(__MINGW32__)
-# include <cstring>
-#endif
-
-#if FMT_USE_WINDOWS_H
-# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#  include <windows.h>
-# else
-#  define NOMINMAX
-#  include <windows.h>
-#  undef NOMINMAX
-# endif
-#endif
-
-using fmt::internal::Arg;
-
-#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() throw() {}
-	FMT_FUNC FormatError::~FormatError() throw() {}
-	FMT_FUNC SystemError::~SystemError() throw() {}
-
-	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)
-
-		// Checks if a value fits in int - used to avoid warnings about comparing
-		// signed and unsigned integers.
-		template <bool IsSigned>
-		struct IntChecker {
-			template <typename T>
-			static bool fits_in_int(T value) {
-				unsigned max = INT_MAX;
-				return value <= max;
-			}
-			static bool fits_in_int(bool) { return true; }
-		};
-
-		template <>
-		struct IntChecker<true> {
-			template <typename T>
-			static bool fits_in_int(T value) {
-				return value >= INT_MIN && value <= INT_MAX;
-			}
-			static bool fits_in_int(int) { return true; }
-		};
-
-		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() {
-					strerror_r(0, 0, "");  // Suppress a warning about unused strerror_r.
-					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<int>::MainType MainType;
-			MainType abs_value = static_cast<MainType>(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);
-		}
-
-		// IsZeroInt::visit(arg) returns true iff arg is a zero integer.
-		class IsZeroInt : public ArgVisitor<IsZeroInt, bool> {
-		public:
-			template <typename T>
-			bool visit_any_int(T value) { return value == 0; }
-		};
-
-		// Checks if an argument is a valid printf width specifier and sets
-		// left alignment if it is negative.
-		class WidthHandler : public ArgVisitor<WidthHandler, unsigned> {
-		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 <typename T>
-			unsigned visit_any_int(T value) {
-				typedef typename internal::IntTraits<T>::MainType UnsignedType;
-				UnsignedType width = static_cast<UnsignedType>(value);
-				if (internal::is_negative(value)) {
-					spec_.align_ = ALIGN_LEFT;
-					width = 0 - width;
-				}
-				if (width > INT_MAX)
-					FMT_THROW(FormatError("number is too big"));
-				return static_cast<unsigned>(width);
-			}
-		};
-
-		class PrecisionHandler : public ArgVisitor<PrecisionHandler, int> {
-		public:
-			void report_unhandled_arg() {
-				FMT_THROW(FormatError("precision is not integer"));
-			}
-
-			template <typename T>
-			int visit_any_int(T value) {
-				if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-					FMT_THROW(FormatError("number is too big"));
-				return static_cast<int>(value);
-			}
-		};
-
-		template <typename T, typename U>
-		struct is_same {
-			enum { value = 0 };
-		};
-
-		template <typename T>
-		struct is_same<T, T> {
-			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 <typename T = void>
-		class ArgConverter : public ArgVisitor<ArgConverter<T>, 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);
-			}
-
-			template <typename U>
-			void visit_any_int(U value) {
-				bool is_signed = type_ == 'd' || type_ == 'i';
-				using internal::Arg;
-				typedef typename internal::Conditional<
-					is_same<T, void>::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<int>(static_cast<TargetType>(value));
-					}
-					else {
-						arg_.type = Arg::UINT;
-						typedef typename internal::MakeUnsigned<TargetType>::Type Unsigned;
-						arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(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<LongLong>(value);
-					}
-					else {
-						arg_.type = Arg::ULONG_LONG;
-						arg_.ulong_long_value =
-							static_cast<typename internal::MakeUnsigned<U>::Type>(value);
-					}
-				}
-			}
-		};
-
-		// Converts an integer argument to char for printf.
-		class CharConverter : public ArgVisitor<CharConverter, void> {
-		private:
-			internal::Arg &arg_;
-
-			FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
-
-		public:
-			explicit CharConverter(internal::Arg &arg) : arg_(arg) {}
-
-			template <typename T>
-			void visit_any_int(T value) {
-				arg_.type = internal::Arg::CHAR;
-				arg_.int_value = static_cast<char>(value);
-			}
-		};
-	}  // namespace
-
-	namespace internal {
-
-		template <typename Char>
-		class PrintfArgFormatter :
-			public ArgFormatterBase<PrintfArgFormatter<Char>, Char> {
-
-			void write_null_pointer() {
-				this->spec().type_ = 0;
-				this->write("(nil)");
-			}
-
-			typedef ArgFormatterBase<PrintfArgFormatter<Char>, Char> Base;
-
-		public:
-			PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
-				: ArgFormatterBase<PrintfArgFormatter<Char>, Char>(w, s) {}
-
-			void visit_bool(bool value) {
-				FormatSpec &fmt_spec = this->spec();
-				if (fmt_spec.type_ != 's')
-					return this->visit_any_int(value);
-				fmt_spec.type_ = 0;
-				this->write(value);
-			}
-
-			void visit_char(int value) {
-				const FormatSpec &fmt_spec = this->spec();
-				BasicWriter<Char> &w = this->writer();
-				if (fmt_spec.type_ && fmt_spec.type_ != 'c')
-					w.write_int(value, fmt_spec);
-				typedef typename BasicWriter<Char>::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<Char>(value);
-			}
-
-			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)");
-			}
-
-			void visit_pointer(const void *value) {
-				if (value)
-					return Base::visit_pointer(value);
-				this->spec().type_ = 0;
-				write_null_pointer();
-			}
-
-			void visit_custom(Arg::CustomValue c) {
-				BasicFormatter<Char> formatter(ArgList(), this->writer());
-				const Char format_str[] = { '}', 0 };
-				const Char *format = format_str;
-				c.format(&formatter, c.value, &format);
-			}
-		};
-	}  // namespace internal
-}  // namespace fmt
-
-FMT_FUNC void fmt::SystemError::init(
-	int err_code, CStringRef format_str, ArgList args) {
-	error_code_ = err_code;
-	MemoryWriter w;
-	internal::format_system_error(w, err_code, format(format_str, args));
-	std::runtime_error &base = *this;
-	base = std::runtime_error(w.str());
-}
-
-template <typename T>
-int fmt::internal::CharTraits<char>::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 <typename T>
-int fmt::internal::CharTraits<wchar_t>::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 <typename T>
-const char fmt::internal::BasicData<T>::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 <typename T>
-const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
-	0, FMT_POWERS_OF_10(1)
-};
-
-template <typename T>
-const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
-	0,
-	FMT_POWERS_OF_10(1),
-	FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),
-	// Multiply several constants instead of using a single long long constant
-	// to avoid warnings about C++98 not supporting long long.
-	fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10
-};
-
-FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) {
-	(void)type;
-	if (std::isprint(static_cast<unsigned char>(code))) {
-		FMT_THROW(fmt::FormatError(
-			fmt::format("unknown format code '{}' for {}", code, type)));
-	}
-	FMT_THROW(fmt::FormatError(
-		fmt::format("unknown format code '\\x{:02x}' for {}",
-			static_cast<unsigned>(code), type)));
-}
-
-#if FMT_USE_WINDOWS_H
-
-FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::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<int>(s.size());
-	int length = MultiByteToWideChar(
-		CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 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 fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::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 fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
-	if (s.size() > INT_MAX)
-		return ERROR_INVALID_PARAMETER;
-	int s_size = static_cast<int>(s.size());
-	int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);
-	if (length == 0)
-		return GetLastError();
-	buffer_.resize(length + 1);
-	length = WideCharToMultiByte(
-		CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);
-	if (length == 0)
-		return GetLastError();
-	buffer_[length] = 0;
-	return 0;
-}
-
-FMT_FUNC void fmt::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 fmt::internal::format_windows_error(
-	fmt::Writer &out, int error_code,
-	fmt::StringRef message) FMT_NOEXCEPT {
-	FMT_TRY{
-		MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;
-	buffer.resize(INLINE_BUFFER_SIZE);
-	for (;;) {
-		wchar_t *system_message = &buffer[0];
-		int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-			0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-			system_message, static_cast<uint32_t>(buffer.size()), 0);
-		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 fmt::internal::format_system_error(
-	fmt::Writer &out, int error_code,
-	fmt::StringRef message) FMT_NOEXCEPT {
-	FMT_TRY{
-		MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
-	buffer.resize(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 <typename Char>
-void fmt::internal::ArgMap<Char>::init(const ArgList &args) {
-	if (!map_.empty())
-		return;
-	typedef internal::NamedArg<Char> NamedArg;
-	const NamedArg *named_arg = 0;
-	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<const NamedArg*>(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<const NamedArg*>(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<const NamedArg*>(args.args_[i].pointer);
-			map_.push_back(Pair(named_arg->name, *named_arg));
-			break;
-		default:
-			/*nothing*/;
-		}
-	}
-}
-
-template <typename Char>
-void fmt::internal::FixedBuffer<Char>::grow(std::size_t) {
-	FMT_THROW(std::runtime_error("buffer overflow"));
-}
-
-FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
-	unsigned arg_index, const char *&error) {
-	Arg arg = args_[arg_index];
-	switch (arg.type) {
-	case Arg::NONE:
-		error = "argument index out of range";
-		break;
-	case Arg::NAMED_ARG:
-		arg = *static_cast<const internal::Arg*>(arg.pointer);
-		break;
-	default:
-		/*nothing*/;
-	}
-	return arg;
-}
-
-template <typename Char>
-void fmt::internal::PrintfFormatter<Char>::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 <typename Char>
-Arg fmt::internal::PrintfFormatter<Char>::get_arg(
-	const Char *s, unsigned arg_index) {
-	(void)s;
-	const char *error = 0;
-	Arg arg = arg_index == UINT_MAX ?
-		next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
-	if (error)
-		FMT_THROW(FormatError(!*s ? "invalid format string" : error));
-	return arg;
-}
-
-template <typename Char>
-unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
-	const Char *&s, FormatSpec &spec) {
-	unsigned arg_index = UINT_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 = 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_ = parse_nonnegative_int(s);
-	}
-	else if (*s == '*') {
-		++s;
-		spec.width_ = WidthHandler(spec).visit(get_arg(s));
-	}
-	return arg_index;
-}
-
-template <typename Char>
-void fmt::internal::PrintfFormatter<Char>::format(
-	BasicWriter<Char> &writer, BasicCStringRef<Char> 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<int>(parse_nonnegative_int(s));
-			}
-			else if (*s == '*') {
-				++s;
-				spec.precision_ = PrecisionHandler().visit(get_arg(s));
-			}
-		}
-
-		Arg arg = get_arg(s, arg_index);
-		if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg))
-			spec.flags_ &= ~to_unsigned<int>(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.
-		switch (*s++) {
-		case 'h':
-			if (*s == 'h')
-				ArgConverter<signed char>(arg, *++s).visit(arg);
-			else
-				ArgConverter<short>(arg, *s).visit(arg);
-			break;
-		case 'l':
-			if (*s == 'l')
-				ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
-			else
-				ArgConverter<long>(arg, *s).visit(arg);
-			break;
-		case 'j':
-			ArgConverter<intmax_t>(arg, *s).visit(arg);
-			break;
-		case 'z':
-			ArgConverter<std::size_t>(arg, *s).visit(arg);
-			break;
-		case 't':
-			ArgConverter<std::ptrdiff_t>(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<void>(arg, *s).visit(arg);
-		}
-
-		// Parse type.
-		if (!*s)
-			FMT_THROW(FormatError("invalid format string"));
-		spec.type_ = static_cast<char>(*s++);
-		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
-				CharConverter(arg).visit(arg);
-				break;
-			}
-		}
-
-		start = s;
-
-		// Format argument.
-		internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);
-	}
-	write(writer, start, s);
-}
-
-FMT_FUNC void fmt::report_system_error(
-	int error_code, fmt::StringRef message) FMT_NOEXCEPT {
-	// 'fmt::' is for bcc32.
-	fmt::report_error(internal::format_system_error, error_code, message);
-}
-
-#if FMT_USE_WINDOWS_H
-FMT_FUNC void fmt::report_windows_error(
-	int error_code, fmt::StringRef message) FMT_NOEXCEPT {
-	// 'fmt::' is for bcc32.
-	fmt::report_error(internal::format_windows_error, error_code, message);
-}
-#endif
-
-FMT_FUNC void fmt::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 fmt::print(CStringRef format_str, ArgList args) {
-	print(stdout, format_str, args);
-}
-
-FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
-	char escape[] = "\x1b[30m";
-	escape[3] = static_cast<char>('0' + c);
-	std::fputs(escape, stdout);
-	print(format, args);
-	std::fputs(RESET_COLOR, stdout);
-}
-
-FMT_FUNC int fmt::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<int>(size);
-}
-
-#ifndef FMT_HEADER_ONLY
-
-template struct fmt::internal::BasicData<void>;
-
-// Explicit instantiations for char.
-
-template void fmt::internal::FixedBuffer<char>::grow(std::size_t);
-
-template void fmt::internal::ArgMap<char>::init(const fmt::ArgList &args);
-
-template void fmt::internal::PrintfFormatter<char>::format(
-	BasicWriter<char> &writer, CStringRef format);
-
-template int fmt::internal::CharTraits<char>::format_float(
-	char *buffer, std::size_t size, const char *format,
-	unsigned width, int precision, double value);
-
-template int fmt::internal::CharTraits<char>::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 fmt::internal::FixedBuffer<wchar_t>::grow(std::size_t);
-
-template void fmt::internal::ArgMap<wchar_t>::init(const fmt::ArgList &args);
-
-template void fmt::internal::PrintfFormatter<wchar_t>::format(
-	BasicWriter<wchar_t> &writer, WCStringRef format);
-
-template int fmt::internal::CharTraits<wchar_t>::format_float(
-	wchar_t *buffer, std::size_t size, const wchar_t *format,
-	unsigned width, int precision, double value);
-
-template int fmt::internal::CharTraits<wchar_t>::format_float(
-	wchar_t *buffer, std::size_t size, const wchar_t *format,
-	unsigned width, int precision, long double value);
-
-#endif  // FMT_HEADER_ONLY
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif

src/common/gui_printf.cpp

@@ -27,8 +27,10 @@
 #include <windows.h>
 #include <richedit.h>
 
+#include <fmt/format.h>
+
 #include "common/eventlog.h"
-#include <common/format.h>
+
 #include "common/setup_after.h"
 
 namespace pvpgn
@@ -36,8 +38,37 @@ namespace pvpgn
 
 	HWND ghwndConsole;
 
-	static void guiAddText(const char *str, COLORREF clr)
+	extern void guiAddText(t_eventlog_level level, const char *str)
 	{
+		COLORREF clr;
+
+		switch (level)
+		{
+		case eventlog_level_none:
+			clr = RGB(0, 0, 0);
+			break;
+		case eventlog_level_trace:
+			clr = RGB(255, 0, 255);
+			break;
+		case eventlog_level_debug:
+			clr = RGB(0, 0, 255);
+			break;
+		case eventlog_level_info:
+			clr = RGB(0, 0, 0);
+			break;
+		case eventlog_level_warn:
+			clr = RGB(255, 128, 64);
+			break;
+		case eventlog_level_error:
+			clr = RGB(255, 0, 0);
+			break;
+		case eventlog_level_fatal:
+			clr = RGB(255, 0, 0);
+			break;
+		default:
+			clr = RGB(0, 0, 0);
+		}
+
 		int text_length = SendMessageW(ghwndConsole, WM_GETTEXTLENGTH, 0, 0);
 
 		if (text_length > 30000)
@@ -65,41 +96,5 @@ namespace pvpgn
 		SendMessageW(ghwndConsole, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
 		SendMessageA(ghwndConsole, EM_REPLACESEL, FALSE, (LPARAM)str);
 	}
-
-	//template <typename... Args>
-	//void gui_lvprintf(t_eventlog_level l, const char* format, const Args& ... args)
-	void gui_lvprintf(t_eventlog_level l, const char* format, fmt::ArgList args)
-	{
-		COLORREF clr;
-
-		switch (l)
-		{
-		case eventlog_level_none:
-			clr = RGB(0, 0, 0);
-			break;
-		case eventlog_level_trace:
-			clr = RGB(255, 0, 255);
-			break;
-		case eventlog_level_debug:
-			clr = RGB(0, 0, 255);
-			break;
-		case eventlog_level_info:
-			clr = RGB(0, 0, 0);
-			break;
-		case eventlog_level_warn:
-			clr = RGB(255, 128, 64);
-			break;
-		case eventlog_level_error:
-			clr = RGB(255, 0, 0);
-			break;
-		case eventlog_level_fatal:
-			clr = RGB(255, 0, 0);
-			break;
-		default:
-			clr = RGB(0, 0, 0);
-		}
-
-		guiAddText(fmt::format(format, args).c_str(), clr);
-	}
 }
 #endif

src/common/gui_printf.h

@@ -21,15 +21,24 @@
 
 #ifdef WIN32_GUI 
 
+#include <cstdarg>
+#include <cwchar>
+#include <string>
+#include <utility>
+
+#include <fmt/format.h>
+
 #include "common/eventlog.h"
-#include <common/format.h>
 
 namespace pvpgn
 {
-	//template <typename... Args>
+	extern void guiAddText(t_eventlog_level level, const char *str);
-	//void gui_lvprintf(t_eventlog_level l, const char* format, const Args& ... args);
+
-	void gui_lvprintf(t_eventlog_level l, const char* format, fmt::ArgList args);
+	template <typename... Args>
-	FMT_VARIADIC(void, gui_lvprintf, t_eventlog_level, const char*);
+	void gui_lvprintf(t_eventlog_level level, fmt::string_view format_str, const Args& ... args)
+	{
+		guiAddText(level, fmt::format(format_str, args...).c_str());
+	}
 }
 #endif