Merge branch 'next' of github.com:cryfs/cryfs into next

vendor/README

@@ -1,4 +1,4 @@
 This directory contains external projects, taken from the following locations:
 scrypt: http://www.tarsnap.com/scrypt.html
 googletest: https://github.com/google/googletest/tree/release-1.8.0
-spdlog: https://github.com/gabime/spdlog/tree/v0.13.0/include/spdlog
+spdlog: https://github.com/gabime/spdlog/tree/v0.14.0/include/spdlog

vendor/spdlog/spdlog/async_logger.h

@@ -15,8 +15,8 @@
 //    3. will throw spdlog_ex upon log exceptions
 // Upon destruction, logs all remaining messages in the queue before destructing..
 
-#include <spdlog/common.h>
+#include "spdlog/common.h"
-#include <spdlog/logger.h>
+#include "spdlog/logger.h"
 
 #include <chrono>
 #include <functional>
@@ -31,7 +31,7 @@ namespace details
 class async_log_helper;
 }
 
-class async_logger :public logger
+class async_logger SPDLOG_FINAL :public logger
 {
 public:
     template<class It>
@@ -61,7 +61,7 @@ public:
                  const std::function<void()>& worker_teardown_cb = nullptr);
 
     //Wait for the queue to be empty, and flush synchronously
-    //Warning: this can potentialy last forever as we wait it to complete
+    //Warning: this can potentially last forever as we wait it to complete
     void flush() override;
 
     // Error handler
@@ -71,7 +71,7 @@ public:
 protected:
     void _sink_it(details::log_msg& msg) override;
     void _set_formatter(spdlog::formatter_ptr msg_formatter) override;
-    void _set_pattern(const std::string& pattern) override;
+    void _set_pattern(const std::string& pattern, pattern_time_type pattern_time) override;
 
 private:
     std::unique_ptr<details::async_log_helper> _async_log_helper;
@@ -79,4 +79,4 @@ private:
 }
 
 
-#include <spdlog/details/async_logger_impl.h>
+#include "spdlog/details/async_logger_impl.h"

vendor/spdlog/spdlog/common.h

@@ -18,7 +18,7 @@
 #include <locale>
 #endif
 
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
 
 //visual studio upto 2013 does not support noexcept nor constexpr
 #if defined(_MSC_VER) && (_MSC_VER < 1900)
@@ -29,6 +29,11 @@
 #define SPDLOG_CONSTEXPR constexpr
 #endif
 
+// See tweakme.h
+#if !defined(SPDLOG_FINAL)
+#define SPDLOG_FINAL
+#endif
+
 #if defined(__GNUC__)  || defined(__clang__)
 #define SPDLOG_DEPRECATED __attribute__((deprecated))
 #elif defined(_MSC_VER)
@@ -38,7 +43,7 @@
 #endif
 
 
-#include <spdlog/fmt/fmt.h>
+#include "spdlog/fmt/fmt.h"
 
 namespace spdlog
 {
@@ -76,7 +81,10 @@ typedef enum
     off = 6
 } level_enum;
 
-static const char* level_names[] { "trace", "debug", "info",  "warning", "error", "critical", "off" };
+#if !defined(SPDLOG_LEVEL_NAMES)
+#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info",  "warning", "error", "critical", "off" };
+#endif
+static const char* level_names[] SPDLOG_LEVEL_NAMES
 
 static const char* short_level_names[] { "T", "D", "I", "W", "E", "C", "O" };
 
@@ -101,6 +109,15 @@ enum class async_overflow_policy
     discard_log_msg // Discard the message it enqueue fails
 };
 
+//
+// Pattern time - specific time getting to use for pattern_formatter.
+// local time by default
+//
+enum class pattern_time_type
+{
+    local, // log localtime
+    utc    // log utc
+};
 
 //
 // Log exception

vendor/spdlog/spdlog/details/async_log_helper.h

@@ -9,17 +9,15 @@
 // If the internal queue of log messages reaches its max size,
 // then the client call will block until there is more room.
 //
-// If the back thread throws during logging, a spdlog::spdlog_ex exception
-// will be thrown in client's thread when tries to log the next message
 
 #pragma once
 
-#include <spdlog/common.h>
+#include "spdlog/common.h"
-#include <spdlog/sinks/sink.h>
+#include "spdlog/sinks/sink.h"
-#include <spdlog/details/mpmc_bounded_q.h>
+#include "spdlog/details/mpmc_bounded_q.h"
-#include <spdlog/details/log_msg.h>
+#include "spdlog/details/log_msg.h"
-#include <spdlog/details/os.h>
+#include "spdlog/details/os.h"
-#include <spdlog/formatter.h>
+#include "spdlog/formatter.h"
 
 #include <chrono>
 #include <exception>
@@ -53,6 +51,7 @@ class async_log_helper
         size_t thread_id;
         std::string txt;
         async_msg_type msg_type;
+        size_t msg_id;
 
         async_msg() = default;
         ~async_msg() = default;
@@ -62,11 +61,17 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
         logger_name(std::move(other.logger_name)),
                     level(std::move(other.level)),
                     time(std::move(other.time)),
+                    thread_id(other.thread_id),
                     txt(std::move(other.txt)),
-                    msg_type(std::move(other.msg_type))
+                    msg_type(std::move(other.msg_type)),
+                    msg_id(other.msg_id)
         {}
 
-        async_msg(async_msg_type m_type):msg_type(m_type)
+        async_msg(async_msg_type m_type):
+            level(level::info),
+            thread_id(0),
+            msg_type(m_type),
+            msg_id(0)
         {}
 
         async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT
@@ -77,6 +82,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
             thread_id = other.thread_id;
             txt = std::move(other.txt);
             msg_type = other.msg_type;
+            msg_id = other.msg_id;
             return *this;
         }
 
@@ -90,7 +96,8 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
             time(m.time),
             thread_id(m.thread_id),
             txt(m.raw.data(), m.raw.size()),
-            msg_type(async_msg_type::log)
+            msg_type(async_msg_type::log),
+            msg_id(m.msg_id)
         {
 #ifndef SPDLOG_NO_NAME
             logger_name = *m.logger_name;
@@ -106,6 +113,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
             msg.time = time;
             msg.thread_id = thread_id;
             msg.raw << txt;
+            msg.msg_id = msg_id;
         }
     };
 
@@ -177,7 +185,7 @@ private:
 
     void handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush);
 
-    // sleep,yield or return immediatly using the time passed since last message as a hint
+    // sleep,yield or return immediately using the time passed since last message as a hint
     static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time);
 
     // wait until the queue is empty

vendor/spdlog/spdlog/details/async_logger_impl.h

@@ -8,8 +8,8 @@
 // Async Logger implementation
 // Use an async_sink (queue per logger) to perform the logging in a worker thread
 
-#include <spdlog/details/async_log_helper.h>
+#include "spdlog/details/async_log_helper.h"
-#include <spdlog/async_logger.h>
+#include "spdlog/async_logger.h"
 
 #include <string>
 #include <functional>
@@ -76,9 +76,9 @@ inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_forma
     _async_log_helper->set_formatter(_formatter);
 }
 
-inline void spdlog::async_logger::_set_pattern(const std::string& pattern)
+inline void spdlog::async_logger::_set_pattern(const std::string& pattern, pattern_time_type pattern_time)
 {
-    _formatter = std::make_shared<pattern_formatter>(pattern);
+    _formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
     _async_log_helper->set_formatter(_formatter);
 }
 
@@ -87,6 +87,9 @@ inline void spdlog::async_logger::_sink_it(details::log_msg& msg)
 {
     try
     {
+#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
+        msg.msg_id = _msg_counter.fetch_add(1, std::memory_order_relaxed);
+#endif
         _async_log_helper->log(msg);
         if (_should_flush_on(msg))
             _async_log_helper->flush(false); // do async flush

vendor/spdlog/spdlog/details/file_helper.h

@@ -7,11 +7,10 @@
 
 // Helper class for file sink
 // When failing to open a file, retry several times(5) with small delay between the tries(10 ms)
-// Can be set to auto flush on every line
 // Throw spdlog_ex exception on errors
 
-#include <spdlog/details/os.h>
+#include "spdlog/details/os.h"
-#include <spdlog/details/log_msg.h>
+#include "spdlog/details/log_msg.h"
 
 #include <chrono>
 #include <cstdio>

vendor/spdlog/spdlog/details/log_msg.h

@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include <spdlog/common.h>
+#include "spdlog/common.h"
-#include <spdlog/details/os.h>
+#include "spdlog/details/os.h"
 
 
 #include <string>
@@ -19,7 +19,10 @@ namespace details
 struct log_msg
 {
     log_msg() = default;
-    log_msg(const std::string *loggers_name, level::level_enum lvl) : logger_name(loggers_name), level(lvl)
+    log_msg(const std::string *loggers_name, level::level_enum lvl) :
+        logger_name(loggers_name),
+        level(lvl),
+        msg_id(0)
     {
 #ifndef SPDLOG_NO_DATETIME
         time = os::now();
@@ -41,6 +44,7 @@ struct log_msg
     size_t thread_id;
     fmt::MemoryWriter raw;
     fmt::MemoryWriter formatted;
+    size_t msg_id;
 };
 }
 }

vendor/spdlog/spdlog/details/logger_impl.h

@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include <spdlog/logger.h>
+#include "spdlog/logger.h"
-#include <spdlog/sinks/stdout_sinks.h>
+#include "spdlog/sinks/stdout_sinks.h"
 
 #include <memory>
 #include <string>
@@ -18,11 +18,12 @@ template<class It>
 inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end):
     _name(logger_name),
     _sinks(begin, end),
-    _formatter(std::make_shared<pattern_formatter>("%+"))
+    _formatter(std::make_shared<pattern_formatter>("%+")),
+    _level(level::info),
+    _flush_level(level::off),
+    _last_err_time(0),
+    _msg_counter(1)  // message counter will start from 1. 0-message id will be reserved for controll messages
 {
-    _level = level::info;
-    _flush_level = level::off;
-    _last_err_time = 0;
     _err_handler = [this](const std::string &msg)
     {
         this->_default_err_handler(msg);
@@ -52,9 +53,9 @@ inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
     _set_formatter(msg_formatter);
 }
 
-inline void spdlog::logger::set_pattern(const std::string& pattern)
+inline void spdlog::logger::set_pattern(const std::string& pattern, pattern_time_type pattern_time)
 {
-    _set_pattern(pattern);
+    _set_pattern(pattern, pattern_time);
 }
 
 
@@ -157,6 +158,79 @@ inline void spdlog::logger::critical(const char* fmt, const Arg1 &arg1, const Ar
     log(level::critical, fmt, arg1, args...);
 }
 
+template <typename... Args>
+inline void spdlog::logger::log_if(const bool flag, level::level_enum lvl, const char* msg)
+{
+    if (flag)
+    {
+        log(lvl, msg);
+    }
+}
+
+template<typename T>
+inline void spdlog::logger::log_if(const bool flag, level::level_enum lvl, const T& msg)
+{
+    if (flag)
+    {
+        log(lvl, msg);
+    }
+}
+
+template <typename Arg1, typename... Args>
+inline void spdlog::logger::trace_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::trace, fmt, arg1, args...);
+    }
+}
+
+template <typename Arg1, typename... Args>
+inline void spdlog::logger::debug_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::debug, fmt, arg1, args...);
+    }
+}
+
+template <typename Arg1, typename... Args>
+inline void spdlog::logger::info_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::info, fmt, arg1, args...);
+    }
+}
+
+template <typename Arg1, typename... Args>
+inline void spdlog::logger::warn_if(const bool flag, const char* fmt, const Arg1& arg1, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::warn, fmt, arg1, args...);
+    }
+}
+
+template <typename Arg1, typename... Args>
+inline void spdlog::logger::error_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::err, fmt, arg1, args...);
+    }
+}
+
+template <typename Arg1, typename... Args>
+inline void spdlog::logger::critical_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::critical, fmt, arg1, args...);
+    }
+}
+
+
 template<typename T>
 inline void spdlog::logger::trace(const T& msg)
 {
@@ -195,6 +269,196 @@ inline void spdlog::logger::critical(const T& msg)
     log(level::critical, msg);
 }
 
+template<typename T>
+inline void spdlog::logger::trace_if(const bool flag, const T& msg)
+{
+    if (flag)
+    {
+        log(level::trace, msg);
+    }
+}
+
+template<typename T>
+inline void spdlog::logger::debug_if(const bool flag, const T& msg)
+{
+    if (flag)
+    {
+        log(level::debug, msg);
+    }
+}
+
+template<typename T>
+inline void spdlog::logger::info_if(const bool flag, const T& msg)
+{
+    if (flag)
+    {
+        log(level::info, msg);
+    }
+}
+
+template<typename T>
+inline void spdlog::logger::warn_if(const bool flag, const T& msg)
+{
+    if (flag)
+    {
+        log(level::warn, msg);
+    }
+}
+
+template<typename T>
+inline void spdlog::logger::error_if(const bool flag, const T& msg)
+{
+    if (flag)
+    {
+        log(level::err, msg);
+    }
+}
+
+template<typename T>
+inline void spdlog::logger::critical_if(const bool flag, const T& msg)
+{
+    if (flag)
+    {
+        log(level::critical, msg);
+    }
+}
+
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+#include <codecvt>
+
+template <typename... Args>
+inline void spdlog::logger::log(level::level_enum lvl, const wchar_t* msg)
+{
+    std::wstring_convert<std::codecvt_utf8<wchar_t> > conv;
+
+    log(lvl, conv.to_bytes(msg));
+}
+
+template <typename... Args>
+inline void spdlog::logger::log(level::level_enum lvl, const wchar_t* fmt, const Args&... args)
+{
+    fmt::WMemoryWriter wWriter;
+
+    wWriter.write(fmt, args...);
+    log(lvl, wWriter.c_str());
+}
+
+template <typename... Args>
+inline void spdlog::logger::trace(const wchar_t* fmt, const Args&... args)
+{
+    log(level::trace, fmt, args...);
+}
+
+template <typename... Args>
+inline void spdlog::logger::debug(const wchar_t* fmt, const Args&... args)
+{
+    log(level::debug, fmt, args...);
+}
+
+template <typename... Args>
+inline void spdlog::logger::info(const wchar_t* fmt, const Args&... args)
+{
+    log(level::info, fmt, args...);
+}
+
+
+template <typename... Args>
+inline void spdlog::logger::warn(const wchar_t* fmt, const Args&... args)
+{
+    log(level::warn, fmt, args...);
+}
+
+template <typename... Args>
+inline void spdlog::logger::error(const wchar_t* fmt, const Args&... args)
+{
+    log(level::err, fmt, args...);
+}
+
+template <typename... Args>
+inline void spdlog::logger::critical(const wchar_t* fmt, const Args&... args)
+{
+    log(level::critical, fmt, args...);
+}
+
+//
+// conditional logging
+//
+
+template <typename... Args>
+inline void spdlog::logger::log_if(const bool flag, level::level_enum lvl, const wchar_t* msg)
+{
+    if (flag)
+    {
+        log(lvl, msg);
+    }
+}
+
+template <typename... Args>
+inline void spdlog::logger::log_if(const bool flag, level::level_enum lvl, const wchar_t* fmt, const Args&... args)
+{
+    if (flag)
+    {
+        log(lvl, fmt, args);
+    }
+}
+
+template <typename... Args>
+inline void spdlog::logger::trace_if(const bool flag, const wchar_t* fmt, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::trace, fmt, args...);
+    }
+}
+
+template <typename... Args>
+inline void spdlog::logger::debug_if(const bool flag, const wchar_t* fmt, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::debug, fmt, args...);
+    }
+}
+
+template <typename... Args>
+inline void spdlog::logger::info_if(const bool flag, const wchar_t* fmt, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::info, fmt, args...);
+    }
+}
+
+
+template <typename... Args>
+inline void spdlog::logger::warn_if(const bool flag, const wchar_t* fmt, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::warn, fmt, args...);
+    }
+}
+
+template <typename... Args>
+inline void spdlog::logger::error_if(const bool flag, const wchar_t* fmt, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::err, fmt, args...);
+    }
+}
+
+template <typename... Args>
+inline void spdlog::logger::critical_if(const bool flag, const wchar_t* fmt, const Args&... args)
+{
+    if (flag)
+    {
+        log(level::critical, fmt, args...);
+    }
+}
+
+#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
 
 
 
@@ -242,6 +506,9 @@ inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) cons
 //
 inline void spdlog::logger::_sink_it(details::log_msg& msg)
 {
+#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
+    msg.msg_id = _msg_counter.fetch_add(1, std::memory_order_relaxed);
+#endif
     _formatter->format(msg);
     for (auto &sink : _sinks)
     {
@@ -255,9 +522,9 @@ inline void spdlog::logger::_sink_it(details::log_msg& msg)
         flush();
 }
 
-inline void spdlog::logger::_set_pattern(const std::string& pattern)
+inline void spdlog::logger::_set_pattern(const std::string& pattern, pattern_time_type pattern_time)
 {
-    _formatter = std::make_shared<pattern_formatter>(pattern);
+    _formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
 }
 inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
 {

vendor/spdlog/spdlog/details/mpmc_bounded_q.h

@@ -43,7 +43,7 @@ Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
 #pragma once
 
-#include <spdlog/common.h>
+#include "spdlog/common.h"
 
 #include <atomic>
 #include <utility>

vendor/spdlog/spdlog/details/os.h

@@ -4,7 +4,7 @@
 //
 #pragma once
 
-#include <spdlog/common.h>
+#include "spdlog/common.h"
 
 #include <cstdio>
 #include <ctime>
@@ -12,8 +12,9 @@
 #include <string>
 #include <chrono>
 #include <thread>
-#include <stdio.h>
+#include <algorithm>
-#include <string.h>
+#include <cstring>
+#include <cstdlib>
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ -28,7 +29,7 @@
 #endif
 #include <windows.h>
 #include <process.h> //  _get_pid support
-#include <io.h> // _get_osfhandle support
+#include <io.h> // _get_osfhandle and _isatty support
 
 #ifdef __MINGW32__
 #include <share.h>
@@ -150,7 +151,7 @@ inline void prevent_child_fd(FILE *f)
         throw spdlog_ex("SetHandleInformation failed", errno);
 #else
     auto fd = fileno(f);
-    if(fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
+    if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
         throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
 #endif
 }
@@ -170,7 +171,7 @@ inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode
 #endif
 
 #ifdef SPDLOG_PREVENT_CHILD_FD
-    if(*fp != nullptr)
+    if (*fp != nullptr)
         prevent_child_fd(*fp);
 #endif
     return *fp == nullptr;
@@ -208,7 +209,7 @@ inline bool file_exists(const filename_t& filename)
     return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
 #else //common linux/unix all have the stat system call
     struct stat buffer;
-    return (stat (filename.c_str(), &buffer) == 0);
+    return (stat(filename.c_str(), &buffer) == 0);
 #endif
 }
 
@@ -329,7 +330,11 @@ inline size_t _thread_id()
     long tid;
     thr_self(&tid);
     return static_cast<size_t>(tid);
-#else //Default to standard C++11 (OSX and other Unix)
+#elif __APPLE__
+    uint64_t tid;
+    pthread_threadid_np(nullptr, &tid);
+    return static_cast<size_t>(tid);
+#else //Default to standard C++11 (other Unix)
     return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
 #endif
 }
@@ -364,6 +369,22 @@ inline std::string filename_to_str(const filename_t& filename)
 }
 #endif
 
+inline std::string errno_to_string(char[256], char* res)
+{
+    return std::string(res);
+}
+
+inline std::string errno_to_string(char buf[256], int res)
+{
+    if (res == 0)
+    {
+        return std::string(buf);
+    }
+    else
+    {
+        return "Unknown error";
+    }
+}
 
 // Return errno string (thread safe)
 inline std::string errno_str(int err_num)
@@ -372,10 +393,10 @@ inline std::string errno_str(int err_num)
     SPDLOG_CONSTEXPR auto buf_size = sizeof(buf);
 
 #ifdef _WIN32
-    if(strerror_s(buf, buf_size, err_num) == 0)
+    if (strerror_s(buf, buf_size, err_num) == 0)
         return std::string(buf);
     else
-        return "Unkown error";
+        return "Unknown error";
 
 #elif defined(__FreeBSD__) || defined(__APPLE__) || defined(ANDROID) || defined(__SUNPRO_CC) || \
       ((_POSIX_C_SOURCE >= 200112L) && ! defined(_GNU_SOURCE)) // posix version
@@ -383,10 +404,11 @@ inline std::string errno_str(int err_num)
     if (strerror_r(err_num, buf, buf_size) == 0)
         return std::string(buf);
     else
-        return "Unkown error";
+        return "Unknown error";
 
 #else  // gnu version (might not use the given buf, so its retval pointer must be used)
-    return std::string(strerror_r(err_num, buf, buf_size));
+    auto err = strerror_r(err_num, buf, buf_size); // let compiler choose type
+    return errno_to_string(buf, err); // use overloading to select correct stringify function
 #endif
 }
 
@@ -401,6 +423,47 @@ inline int pid()
 
 }
 
+
+// Detrmine if the terminal supports colors
+// Source: https://github.com/agauniyal/rang/
+inline bool is_color_terminal()
+{
+#ifdef _WIN32
+    return true;
+#else
+    static constexpr const char* Terms[] =
+    {
+        "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm",
+        "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"
+    };
+
+    const char *env_p = std::getenv("TERM");
+    if (env_p == nullptr)
+    {
+        return false;
+    }
+
+    static const bool result = std::any_of(
+                                   std::begin(Terms), std::end(Terms), [&](const char* term)
+    {
+        return std::strstr(env_p, term) != nullptr;
+    });
+    return result;
+#endif
+}
+
+
+// Detrmine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+inline bool in_terminal(FILE* file)
+{
+
+#ifdef _WIN32
+    return _isatty(_fileno(file)) ? true : false;
+#else
+    return isatty(fileno(file)) ? true : false;
+#endif
+}
 } //os
 } //details
 } //spdlog

vendor/spdlog/spdlog/details/pattern_formatter_impl.h

@@ -5,10 +5,10 @@
 
 #pragma once
 
-#include <spdlog/formatter.h>
+#include "spdlog/formatter.h"
-#include <spdlog/details/log_msg.h>
+#include "spdlog/details/log_msg.h"
-#include <spdlog/details/os.h>
+#include "spdlog/details/os.h"
-#include <spdlog/fmt/fmt.h>
+#include "spdlog/fmt/fmt.h"
 
 #include <chrono>
 #include <ctime>
@@ -79,60 +79,42 @@ static int to12h(const tm& t)
 }
 
 //Abbreviated weekday name
-using days_array = std::array<std::string, 7>;
+static const std::string days[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-static const days_array& days()
-{
-    static const days_array arr{ { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" } };
-    return arr;
-}
 class a_formatter:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
-        msg.formatted << days()[tm_time.tm_wday];
+        msg.formatted << days[tm_time.tm_wday];
     }
 };
 
 //Full weekday name
-static const days_array& full_days()
+static const std::string full_days[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
-{
-    static const days_array arr{ { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" } };
-    return arr;
-}
 class A_formatter:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
-        msg.formatted << full_days()[tm_time.tm_wday];
+        msg.formatted << full_days[tm_time.tm_wday];
     }
 };
 
 //Abbreviated month
-using months_array = std::array<std::string, 12>;
+static const std::string  months[] { "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sept", "Oct", "Nov", "Dec" };
-static const months_array& months()
-{
-    static const months_array arr{ { "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sept", "Oct", "Nov", "Dec" } };
-    return arr;
-}
 class b_formatter:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
-        msg.formatted << months()[tm_time.tm_mon];
+        msg.formatted << months[tm_time.tm_mon];
     }
 };
 
 //Full month name
-static const months_array& full_months()
+static const std::string full_months[] { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
-{
-    static const months_array arr{ { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" } };
-    return arr;
-}
 class B_formatter:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
-        msg.formatted << full_months()[tm_time.tm_mon];
+        msg.formatted << full_months[tm_time.tm_mon];
     }
 };
 
@@ -153,18 +135,18 @@ static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, int v
 
 
 //Date and time representation (Thu Aug 23 15:35:46 2014)
-class c_formatter:public flag_formatter
+class c_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
-        msg.formatted << days()[tm_time.tm_wday] << ' ' << months()[tm_time.tm_mon] << ' ' << tm_time.tm_mday << ' ';
+        msg.formatted << days[tm_time.tm_wday] << ' ' << months[tm_time.tm_mon] << ' ' << tm_time.tm_mday << ' ';
         pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << tm_time.tm_year + 1900;
     }
 };
 
 
 // year - 2 digit
-class C_formatter:public flag_formatter
+class C_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -175,7 +157,7 @@ class C_formatter:public flag_formatter
 
 
 // Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
-class D_formatter:public flag_formatter
+class D_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -185,7 +167,7 @@ class D_formatter:public flag_formatter
 
 
 // year - 4 digit
-class Y_formatter:public flag_formatter
+class Y_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -194,7 +176,7 @@ class Y_formatter:public flag_formatter
 };
 
 // month 1-12
-class m_formatter:public flag_formatter
+class m_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -203,7 +185,7 @@ class m_formatter:public flag_formatter
 };
 
 // day of month 1-31
-class d_formatter:public flag_formatter
+class d_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -212,7 +194,7 @@ class d_formatter:public flag_formatter
 };
 
 // hours in 24 format  0-23
-class H_formatter:public flag_formatter
+class H_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -221,7 +203,7 @@ class H_formatter:public flag_formatter
 };
 
 // hours in 12 format  1-12
-class I_formatter:public flag_formatter
+class I_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -230,7 +212,7 @@ class I_formatter:public flag_formatter
 };
 
 // minutes 0-59
-class M_formatter:public flag_formatter
+class M_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -239,7 +221,7 @@ class M_formatter:public flag_formatter
 };
 
 // seconds 0-59
-class S_formatter:public flag_formatter
+class S_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -248,7 +230,7 @@ class S_formatter:public flag_formatter
 };
 
 // milliseconds
-class e_formatter:public flag_formatter
+class e_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -259,7 +241,7 @@ class e_formatter:public flag_formatter
 };
 
 // microseconds
-class f_formatter:public flag_formatter
+class f_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -270,7 +252,7 @@ class f_formatter:public flag_formatter
 };
 
 // nanoseconds
-class F_formatter:public flag_formatter
+class F_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -281,7 +263,7 @@ class F_formatter:public flag_formatter
 };
 
 // AM/PM
-class p_formatter:public flag_formatter
+class p_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -291,7 +273,7 @@ class p_formatter:public flag_formatter
 
 
 // 12 hour clock 02:55:02 pm
-class r_formatter:public flag_formatter
+class r_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -300,7 +282,7 @@ class r_formatter:public flag_formatter
 };
 
 // 24-hour HH:MM time, equivalent to %H:%M
-class R_formatter:public flag_formatter
+class R_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -309,7 +291,7 @@ class R_formatter:public flag_formatter
 };
 
 // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
-class T_formatter:public flag_formatter
+class T_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -317,14 +299,13 @@ class T_formatter:public flag_formatter
     }
 };
 
-
 // ISO 8601 offset from UTC in timezone (+-HH:MM)
-class z_formatter:public flag_formatter
+class z_formatter SPDLOG_FINAL:public flag_formatter
 {
 public:
     const std::chrono::seconds cache_refresh = std::chrono::seconds(5);
 
-    z_formatter():_last_update(std::chrono::seconds(0))
+    z_formatter():_last_update(std::chrono::seconds(0)), _offset_minutes(0)
     {}
     z_formatter(const z_formatter&) = delete;
     z_formatter& operator=(const z_formatter&) = delete;
@@ -376,7 +357,7 @@ private:
 
 
 // Thread id
-class t_formatter:public flag_formatter
+class t_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -385,7 +366,7 @@ class t_formatter:public flag_formatter
 };
 
 // Current pid
-class pid_formatter:public flag_formatter
+class pid_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -394,7 +375,7 @@ class pid_formatter:public flag_formatter
 };
 
 
-class v_formatter:public flag_formatter
+class v_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm&) override
     {
@@ -402,7 +383,7 @@ class v_formatter:public flag_formatter
     }
 };
 
-class ch_formatter:public flag_formatter
+class ch_formatter SPDLOG_FINAL:public flag_formatter
 {
 public:
     explicit ch_formatter(char ch): _ch(ch)
@@ -417,7 +398,7 @@ private:
 
 
 //aggregate user chars to display as is
-class aggregate_formatter:public flag_formatter
+class aggregate_formatter SPDLOG_FINAL:public flag_formatter
 {
 public:
     aggregate_formatter()
@@ -436,7 +417,7 @@ private:
 
 // Full info formatter
 // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
-class full_formatter:public flag_formatter
+class full_formatter SPDLOG_FINAL:public flag_formatter
 {
     void format(details::log_msg& msg, const std::tm& tm_time) override
     {
@@ -488,7 +469,8 @@ class full_formatter:public flag_formatter
 ///////////////////////////////////////////////////////////////////////////////
 // pattern_formatter inline impl
 ///////////////////////////////////////////////////////////////////////////////
-inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern)
+inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time)
+    : _pattern_time(pattern_time)
 {
     compile_pattern(pattern);
 }
@@ -645,19 +627,32 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
         _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::pid_formatter()));
         break;
 
-    default: //Unkown flag appears as is
+#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
+    case ('i'):
+        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::i_formatter()));
+        break;
+#endif
+
+    default: //Unknown flag appears as is
         _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter('%')));
         _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter(flag)));
         break;
     }
 }
 
+inline std::tm spdlog::pattern_formatter::get_time(details::log_msg& msg)
+{
+    if (_pattern_time == pattern_time_type::local)
+        return details::os::localtime(log_clock::to_time_t(msg.time));
+    else
+        return details::os::gmtime(log_clock::to_time_t(msg.time));
+}
 
 inline void spdlog::pattern_formatter::format(details::log_msg& msg)
 {
 
 #ifndef SPDLOG_NO_DATETIME
-    auto tm_time = details::os::localtime(log_clock::to_time_t(msg.time));
+    auto tm_time = get_time(msg);
 #else
     std::tm tm_time;
 #endif

vendor/spdlog/spdlog/details/registry.h

@@ -10,10 +10,10 @@
 // If user requests a non existing logger, nullptr will be returned
 // This class is thread safe
 
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
-#include <spdlog/logger.h>
+#include "spdlog/logger.h"
-#include <spdlog/async_logger.h>
+#include "spdlog/async_logger.h"
-#include <spdlog/common.h>
+#include "spdlog/common.h"
 
 #include <chrono>
 #include <functional>
@@ -71,6 +71,26 @@ public:
         return new_logger;
     }
 
+    template<class It>
+    std::shared_ptr<async_logger> create_async(const std::string& logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb, const It& sinks_begin, const It& sinks_end)
+    {
+        std::lock_guard<Mutex> lock(_mutex);
+        throw_if_exists(logger_name);
+        auto new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb);
+
+        if (_formatter)
+            new_logger->set_formatter(_formatter);
+
+        if (_err_handler)
+            new_logger->set_error_handler(_err_handler);
+
+        new_logger->set_level(_level);
+
+        //Add to registry
+        _loggers[logger_name] = new_logger;
+        return new_logger;
+    }
+
     void apply_all(std::function<void(std::shared_ptr<logger>)> fun)
     {
         std::lock_guard<Mutex> lock(_mutex);
@@ -99,6 +119,15 @@ public:
         return create(logger_name, { sink });
     }
 
+    std::shared_ptr<async_logger> create_async(const std::string& logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb, sinks_init_list sinks)
+    {
+        return create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sinks.begin(), sinks.end());
+    }
+
+    std::shared_ptr<async_logger> create_async(const std::string& logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb, sink_ptr sink)
+    {
+        return create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, { sink });
+    }
 
     void formatter(formatter_ptr f)
     {

vendor/spdlog/spdlog/details/spdlog_impl.h

@@ -8,23 +8,23 @@
 //
 // Global registry functions
 //
-#include <spdlog/spdlog.h>
+#include "spdlog/spdlog.h"
-#include <spdlog/details/registry.h>
+#include "spdlog/details/registry.h"
-#include <spdlog/sinks/file_sinks.h>
+#include "spdlog/sinks/file_sinks.h"
-#include <spdlog/sinks/stdout_sinks.h>
+#include "spdlog/sinks/stdout_sinks.h"
 #ifdef SPDLOG_ENABLE_SYSLOG
-#include <spdlog/sinks/syslog_sink.h>
+#include "spdlog/sinks/syslog_sink.h"
 #endif
 
 #ifdef _WIN32
-#include <spdlog/sinks/wincolor_sink.h>
+#include "spdlog/sinks/wincolor_sink.h"
 #else
-#include <spdlog/sinks/ansicolor_sink.h>
+#include "spdlog/sinks/ansicolor_sink.h"
 #endif
 
 
 #ifdef __ANDROID__
-#include <spdlog/sinks/android_sink.h>
+#include "spdlog/sinks/android_sink.h"
 #endif
 
 #include <chrono>
@@ -137,25 +137,25 @@ inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string
 
 inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt(const std::string& logger_name)
 {
-    auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stdout_sink_mt::instance());
+    auto sink = std::make_shared<spdlog::sinks::ansicolor_stdout_sink_mt>();
     return spdlog::details::registry::instance().create(logger_name, sink);
 }
 
 inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_st(const std::string& logger_name)
 {
-    auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stdout_sink_st::instance());
+    auto sink = std::make_shared<spdlog::sinks::ansicolor_stdout_sink_st>();
     return spdlog::details::registry::instance().create(logger_name, sink);
 }
 
 inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt(const std::string& logger_name)
 {
-    auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stderr_sink_mt::instance());
+    auto sink = std::make_shared<spdlog::sinks::ansicolor_stderr_sink_mt>();
     return spdlog::details::registry::instance().create(logger_name, sink);
 }
 
 inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string& logger_name)
 {
-    auto sink = std::make_shared<spdlog::sinks::ansicolor_sink>(spdlog::sinks::stderr_sink_st::instance());
+    auto sink = std::make_shared<spdlog::sinks::ansicolor_stderr_sink_st>();
     return spdlog::details::registry::instance().create(logger_name, sink);
 }
 #endif
@@ -203,6 +203,24 @@ inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_
     return details::registry::instance().create(logger_name, sinks_begin, sinks_end);
 }
 
+// Create and register an async logger with a single sink
+inline std::shared_ptr<spdlog::logger> spdlog::create_async(const std::string& logger_name, const sink_ptr& sink, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
+{
+    return details::registry::instance().create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sink);
+}
+
+// Create and register an async logger with multiple sinks
+inline std::shared_ptr<spdlog::logger> spdlog::create_async(const std::string& logger_name, sinks_init_list sinks, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb )
+{
+    return details::registry::instance().create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sinks);
+}
+
+template<class It>
+inline std::shared_ptr<spdlog::logger> spdlog::create_async(const std::string& logger_name, const It& sinks_begin, const It& sinks_end, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
+{
+    return details::registry::instance().create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sinks_begin, sinks_end);
+}
+
 inline void spdlog::set_formatter(spdlog::formatter_ptr f)
 {
     details::registry::instance().formatter(f);

vendor/spdlog/spdlog/fmt/bundled/format.cc

@@ -41,6 +41,9 @@
 #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
@@ -50,8 +53,6 @@
 # endif
 #endif
 
-using fmt::internal::Arg;
-
 #if FMT_EXCEPTIONS
 # define FMT_TRY try
 # define FMT_CATCH(x) catch (x)
@@ -80,9 +81,9 @@ static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
 
 namespace fmt {
 
-FMT_FUNC internal::RuntimeError::~RuntimeError() throw() {}
+FMT_FUNC internal::RuntimeError::~RuntimeError() FMT_DTOR_NOEXCEPT {}
-FMT_FUNC FormatError::~FormatError() throw() {}
+FMT_FUNC FormatError::~FormatError() FMT_DTOR_NOEXCEPT {}
-FMT_FUNC SystemError::~SystemError() throw() {}
+FMT_FUNC SystemError::~SystemError() FMT_DTOR_NOEXCEPT {}
 
 namespace {
 
@@ -105,27 +106,6 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
 # 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);
@@ -191,7 +171,8 @@ int safe_strerror(
       : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
 
     int run() {
-      strerror_r(0, 0, "");  // Suppress a warning about unused strerror_r.
+      // Suppress a warning about unused strerror_r.
+      strerror_r(0, FMT_NULL, "");
       return handle(strerror_r(error_code_, buffer_, buffer_size_));
     }
   };
@@ -230,222 +211,19 @@ void report_error(FormatFunc func, int error_code,
   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 {
+FMT_FUNC void SystemError::init(
-
-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));
+  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(
+int internal::CharTraits<char>::format_float(
     char *buffer, std::size_t size, const char *format,
     unsigned width, int precision, T value) {
   if (width == 0) {
@@ -459,7 +237,7 @@ int fmt::internal::CharTraits<char>::format_float(
 }
 
 template <typename T>
-int fmt::internal::CharTraits<wchar_t>::format_float(
+int 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) {
@@ -473,7 +251,7 @@ int fmt::internal::CharTraits<wchar_t>::format_float(
 }
 
 template <typename T>
-const char fmt::internal::BasicData<T>::DIGITS[] =
+const char internal::BasicData<T>::DIGITS[] =
     "0001020304050607080910111213141516171819"
     "2021222324252627282930313233343536373839"
     "4041424344454647484950515253545556575859"
@@ -492,40 +270,40 @@ const char fmt::internal::BasicData<T>::DIGITS[] =
   factor * 1000000000
 
 template <typename T>
-const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
+const uint32_t 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[] = {
+const uint64_t internal::BasicData<T>::POWERS_OF_10_64[] = {
   0,
   FMT_POWERS_OF_10(1),
-  FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),
+  FMT_POWERS_OF_10(ULongLong(1000000000)),
   // Multiply several constants instead of using a single long long constant
   // to avoid warnings about C++98 not supporting long long.
-  fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10
+  ULongLong(1000000000) * ULongLong(1000000000) * 10
 };
 
-FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) {
+FMT_FUNC void internal::report_unknown_type(char code, const char *type) {
   (void)type;
   if (std::isprint(static_cast<unsigned char>(code))) {
-    FMT_THROW(fmt::FormatError(
+    FMT_THROW(FormatError(
-        fmt::format("unknown format code '{}' for {}", code, type)));
+        format("unknown format code '{}' for {}", code, type)));
   }
-  FMT_THROW(fmt::FormatError(
+  FMT_THROW(FormatError(
-      fmt::format("unknown format code '\\x{:02x}' for {}",
+      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) {
+FMT_FUNC internal::UTF8ToUTF16::UTF8ToUTF16(StringRef s) {
   static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
   if (s.size() > INT_MAX)
     FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
   int s_size = static_cast<int>(s.size());
   int length = MultiByteToWideChar(
-      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);
+      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
   if (length == 0)
     FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
   buffer_.resize(length + 1);
@@ -536,30 +314,31 @@ FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
   buffer_[length] = 0;
 }
 
-FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) {
+FMT_FUNC internal::UTF16ToUTF8::UTF16ToUTF8(WStringRef s) {
   if (int error_code = convert(s)) {
     FMT_THROW(WindowsError(error_code,
         "cannot convert string from UTF-16 to UTF-8"));
   }
 }
 
-FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
+FMT_FUNC int internal::UTF16ToUTF8::convert(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);
+  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, 0, 0);
+    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 fmt::WindowsError::init(
+FMT_FUNC void WindowsError::init(
     int err_code, CStringRef format_str, ArgList args) {
   error_code_ = err_code;
   MemoryWriter w;
@@ -568,17 +347,17 @@ FMT_FUNC void fmt::WindowsError::init(
   base = std::runtime_error(w.str());
 }
 
-FMT_FUNC void fmt::internal::format_windows_error(
+FMT_FUNC void internal::format_windows_error(
-    fmt::Writer &out, int error_code,
+    Writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
-    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,
+      int result = FormatMessageW(
-                                  0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-                                  system_message, static_cast<uint32_t>(buffer.size()), 0);
+        FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        system_message, static_cast<uint32_t>(buffer.size()), FMT_NULL);
       if (result != 0) {
         UTF16ToUTF8 utf8_message;
         if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
@@ -597,12 +376,11 @@ FMT_FUNC void fmt::internal::format_windows_error(
 
 #endif  // FMT_USE_WINDOWS_H
 
-FMT_FUNC void fmt::internal::format_system_error(
+FMT_FUNC void format_system_error(
-    fmt::Writer &out, int error_code,
+    Writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
-    fmt::StringRef message) FMT_NOEXCEPT {
   FMT_TRY {
-    MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
+    internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer;
-    buffer.resize(INLINE_BUFFER_SIZE);
+    buffer.resize(internal::INLINE_BUFFER_SIZE);
     for (;;) {
       char *system_message = &buffer[0];
       int result = safe_strerror(error_code, system_message, buffer.size());
@@ -619,11 +397,11 @@ FMT_FUNC void fmt::internal::format_system_error(
 }
 
 template <typename Char>
-void fmt::internal::ArgMap<Char>::init(const ArgList &args) {
+void internal::ArgMap<Char>::init(const ArgList &args) {
   if (!map_.empty())
     return;
   typedef internal::NamedArg<Char> NamedArg;
-  const NamedArg *named_arg = 0;
+  const NamedArg *named_arg = FMT_NULL;
   bool use_values =
       args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
   if (use_values) {
@@ -664,18 +442,18 @@ void fmt::internal::ArgMap<Char>::init(const ArgList &args) {
 }
 
 template <typename Char>
-void fmt::internal::FixedBuffer<Char>::grow(std::size_t) {
+void internal::FixedBuffer<Char>::grow(std::size_t) {
   FMT_THROW(std::runtime_error("buffer overflow"));
 }
 
-FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
+FMT_FUNC internal::Arg internal::FormatterBase::do_get_arg(
     unsigned arg_index, const char *&error) {
-  Arg arg = args_[arg_index];
+  internal::Arg arg = args_[arg_index];
   switch (arg.type) {
-  case Arg::NONE:
+  case internal::Arg::NONE:
     error = "argument index out of range";
     break;
-  case Arg::NAMED_ARG:
+  case internal::Arg::NAMED_ARG:
     arg = *static_cast<const internal::Arg*>(arg.pointer);
     break;
   default:
@@ -684,203 +462,31 @@ FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
   return arg;
 }
 
-template <typename Char>
+FMT_FUNC void report_system_error(
-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);
+  report_error(format_system_error, error_code, message);
 }
 
 #if FMT_USE_WINDOWS_H
-FMT_FUNC void fmt::report_windows_error(
+FMT_FUNC void 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);
+  report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-FMT_FUNC void fmt::print(std::FILE *f, CStringRef format_str, ArgList args) {
+FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args) {
   MemoryWriter w;
   w.write(format_str, args);
   std::fwrite(w.data(), 1, w.size(), f);
 }
 
-FMT_FUNC void fmt::print(CStringRef format_str, ArgList args) {
+FMT_FUNC void print(CStringRef format_str, ArgList args) {
   print(stdout, format_str, args);
 }
 
-FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
+FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args) {
   char escape[] = "\x1b[30m";
   escape[3] = static_cast<char>('0' + c);
   std::fputs(escape, stdout);
@@ -888,53 +494,42 @@ FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList 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>;
+template struct internal::BasicData<void>;
 
 // Explicit instantiations for char.
 
-template void fmt::internal::FixedBuffer<char>::grow(std::size_t);
+template void internal::FixedBuffer<char>::grow(std::size_t);
 
-template void fmt::internal::ArgMap<char>::init(const fmt::ArgList &args);
+template void internal::ArgMap<char>::init(const ArgList &args);
 
-template void fmt::internal::PrintfFormatter<char>::format(
+template FMT_API int internal::CharTraits<char>::format_float(
-  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(
+template FMT_API int 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 internal::FixedBuffer<wchar_t>::grow(std::size_t);
 
-template void fmt::internal::ArgMap<wchar_t>::init(const fmt::ArgList &args);
+template void internal::ArgMap<wchar_t>::init(const ArgList &args);
 
-template void fmt::internal::PrintfFormatter<wchar_t>::format(
+template FMT_API int internal::CharTraits<wchar_t>::format_float(
-    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(
+template FMT_API int 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
 
+}  // namespace fmt
+
 #ifdef _MSC_VER
 # pragma warning(pop)
 #endif

vendor/spdlog/spdlog/fmt/bundled/ostream.cc

@@ -11,9 +11,8 @@
 
 namespace fmt {
 
-namespace {
+namespace internal {
-// Write the content of w to os.
+FMT_FUNC void write(std::ostream &os, Writer &w) {
-void write(std::ostream &os, Writer &w) {
   const char *data = w.data();
   typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
   UnsignedStreamSize size = w.size();
@@ -31,13 +30,6 @@ void write(std::ostream &os, Writer &w) {
 FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) {
   MemoryWriter w;
   w.write(format_str, args);
-  write(os, w);
+  internal::write(os, w);
-}
-
-FMT_FUNC int fprintf(std::ostream &os, CStringRef format, ArgList args) {
-  MemoryWriter w;
-  printf(w, format, args);
-  write(os, w);
-  return static_cast<int>(w.size());
 }
 }  // namespace fmt

vendor/spdlog/spdlog/fmt/bundled/ostream.h

@@ -13,85 +13,76 @@
 #include "format.h"
 #include <ostream>
 
-namespace fmt
+namespace fmt {
-{
 
-namespace internal
+namespace internal {
-{
 
 template <class Char>
-class FormatBuf : public std::basic_streambuf<Char>
+class FormatBuf : public std::basic_streambuf<Char> {
-{
+ private:
-private:
+  typedef typename std::basic_streambuf<Char>::int_type int_type;
-    typedef typename std::basic_streambuf<Char>::int_type int_type;
+  typedef typename std::basic_streambuf<Char>::traits_type traits_type;
-    typedef typename std::basic_streambuf<Char>::traits_type traits_type;
 
-    Buffer<Char> &buffer_;
+  Buffer<Char> &buffer_;
-    Char *start_;
 
-public:
+ public:
-    FormatBuf(Buffer<Char> &buffer) : buffer_(buffer), start_(&buffer[0])
+  FormatBuf(Buffer<Char> &buffer) : buffer_(buffer) {}
-    {
-        this->setp(start_, start_ + buffer_.capacity());
-    }
 
-    int_type overflow(int_type ch = traits_type::eof())
+ protected:
-    {
+  // The put-area is actually always empty. This makes the implementation
-        if (!traits_type::eq_int_type(ch, traits_type::eof()))
+  // simpler and has the advantage that the streambuf and the buffer are always
-        {
+  // in sync and sputc never writes into uninitialized memory. The obvious
-            size_t buf_size = size();
+  // disadvantage is that each call to sputc always results in a (virtual) call
-            buffer_.resize(buf_size);
+  // to overflow. There is no disadvantage here for sputn since this always
-            buffer_.reserve(buf_size * 2);
+  // results in a call to xsputn.
 
-            start_ = &buffer_[0];
+  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-            start_[buf_size] = traits_type::to_char_type(ch);
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-            this->setp(start_+ buf_size + 1, start_ + buf_size * 2);
+      buffer_.push_back(static_cast<Char>(ch));
-        }
+    return ch;
-        return ch;
+  }
-    }
 
-    size_t size() const
+  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
-    {
+    buffer_.append(s, s + count);
-        return to_unsigned(this->pptr() - start_);
+    return count;
-    }
+  }
 };
 
 Yes &convert(std::ostream &);
 
-struct DummyStream : std::ostream
+struct DummyStream : std::ostream {
-{
+  DummyStream();  // Suppress a bogus warning in MSVC.
-    DummyStream();  // Suppress a bogus warning in MSVC.
+  // Hide all operator<< overloads from std::ostream.
-    // Hide all operator<< overloads from std::ostream.
+  void operator<<(Null<>);
-    void operator<<(Null<>);
 };
 
 No &operator<<(std::ostream &, int);
 
 template<typename T>
-struct ConvertToIntImpl<T, true>
+struct ConvertToIntImpl<T, true> {
-{
+  // Convert to int only if T doesn't have an overloaded operator<<.
-    // Convert to int only if T doesn't have an overloaded operator<<.
+  enum {
-    enum
+    value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
-    {
+  };
-        value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
-    };
 };
+
+// Write the content of w to os.
+FMT_API void write(std::ostream &os, Writer &w);
 }  // namespace internal
 
 // Formats a value.
-template <typename Char, typename ArgFormatter, typename T>
+template <typename Char, typename ArgFormatter_, typename T>
-void format(BasicFormatter<Char, ArgFormatter> &f,
+void format_arg(BasicFormatter<Char, ArgFormatter_> &f,
-            const Char *&format_str, const T &value)
+                const Char *&format_str, const T &value) {
-{
+  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
-    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
 
-    internal::FormatBuf<Char> format_buf(buffer);
+  internal::FormatBuf<Char> format_buf(buffer);
-    std::basic_ostream<Char> output(&format_buf);
+  std::basic_ostream<Char> output(&format_buf);
-    output << value;
+  output << value;
 
-    BasicStringRef<Char> str(&buffer[0], format_buf.size());
+  BasicStringRef<Char> str(&buffer[0], buffer.size());
-    typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
+  typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
-    format_str = f.format(format_str, MakeArg(str));
+  format_str = f.format(format_str, MakeArg(str));
 }
 
 /**
@@ -105,18 +96,6 @@ void format(BasicFormatter<Char, ArgFormatter> &f,
  */
 FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
 FMT_VARIADIC(void, print, std::ostream &, CStringRef)
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fprintf(cerr, "Don't %s!", "panic");
-  \endrst
- */
-FMT_API int fprintf(std::ostream &os, CStringRef format_str, ArgList args);
-FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
 }  // namespace fmt
 
 #ifdef FMT_HEADER_ONLY

vendor/spdlog/spdlog/fmt/bundled/posix.cc

@@ -21,6 +21,9 @@
 #ifndef _WIN32
 # include <unistd.h>
 #else
+# ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+# endif
 # include <windows.h>
 # include <io.h>
 
@@ -79,7 +82,7 @@ void fmt::BufferedFile::close() {
   if (!file_)
     return;
   int result = FMT_SYSTEM(fclose(file_));
-  file_ = 0;
+  file_ = FMT_NULL;
   if (result != 0)
     FMT_THROW(SystemError(errno, "cannot close file"));
 }

vendor/spdlog/spdlog/fmt/bundled/posix.h

@@ -51,25 +51,6 @@
 # endif
 #endif
 
-#if FMT_GCC_VERSION >= 407
-# define FMT_UNUSED __attribute__((unused))
-#else
-# define FMT_UNUSED
-#endif
-
-#ifndef FMT_USE_STATIC_ASSERT
-# define FMT_USE_STATIC_ASSERT 0
-#endif
-
-#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \
-  (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600
-# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message)
-#else
-# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b)
-# define FMT_STATIC_ASSERT(cond, message) \
-  typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
-#endif
-
 // Retries the expression while it evaluates to error_result and errno
 // equals to EINTR.
 #ifndef _WIN32
@@ -83,134 +64,112 @@
 
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 
-namespace fmt
+namespace fmt {
-{
 
 // An error code.
-class ErrorCode
+class ErrorCode {
-{
+ private:
-private:
+  int value_;
-    int value_;
 
-public:
+ public:
-explicit ErrorCode(int value = 0) FMT_NOEXCEPT :
+  explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {}
-    value_(value) {}
 
-    int get() const FMT_NOEXCEPT
+  int get() const FMT_NOEXCEPT { return value_; }
-    {
-        return value_;
-    }
 };
 
 // A buffered file.
-class BufferedFile
+class BufferedFile {
-{
+ private:
-private:
+  FILE *file_;
-    FILE *file_;
 
-    friend class File;
+  friend class File;
 
-    explicit BufferedFile(FILE *f) : file_(f) {}
+  explicit BufferedFile(FILE *f) : file_(f) {}
 
-public:
+ public:
-    // Constructs a BufferedFile object which doesn't represent any file.
+  // Constructs a BufferedFile object which doesn't represent any file.
-BufferedFile() FMT_NOEXCEPT :
+  BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {}
-    file_(0) {}
 
-    // Destroys the object closing the file it represents if any.
+  // Destroys the object closing the file it represents if any.
-    ~BufferedFile() FMT_NOEXCEPT;
+  FMT_API ~BufferedFile() FMT_NOEXCEPT;
 
 #if !FMT_USE_RVALUE_REFERENCES
-    // Emulate a move constructor and a move assignment operator if rvalue
+  // Emulate a move constructor and a move assignment operator if rvalue
-    // references are not supported.
+  // references are not supported.
 
-private:
+ private:
-    // A proxy object to emulate a move constructor.
+  // A proxy object to emulate a move constructor.
-    // It is private to make it impossible call operator Proxy directly.
+  // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
+  struct Proxy {
-    {
+    FILE *file;
-        FILE *file;
+  };
-    };
 
 public:
-    // A "move constructor" for moving from a temporary.
+  // A "move constructor" for moving from a temporary.
-BufferedFile(Proxy p) FMT_NOEXCEPT :
+  BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
-    file_(p.file) {}
 
-    // A "move constructor" for moving from an lvalue.
+  // A "move constructor" for moving from an lvalue.
-BufferedFile(BufferedFile &f) FMT_NOEXCEPT :
+  BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) {
-    file_(f.file_)
+    f.file_ = FMT_NULL;
-    {
+  }
-        f.file_ = 0;
-    }
 
-    // A "move assignment operator" for moving from a temporary.
+  // A "move assignment operator" for moving from a temporary.
-    BufferedFile &operator=(Proxy p)
+  BufferedFile &operator=(Proxy p) {
-    {
+    close();
-        close();
+    file_ = p.file;
-        file_ = p.file;
+    return *this;
-        return *this;
+  }
-    }
 
-    // A "move assignment operator" for moving from an lvalue.
+  // A "move assignment operator" for moving from an lvalue.
-    BufferedFile &operator=(BufferedFile &other)
+  BufferedFile &operator=(BufferedFile &other) {
-    {
+    close();
-        close();
+    file_ = other.file_;
-        file_ = other.file_;
+    other.file_ = FMT_NULL;
-        other.file_ = 0;
+    return *this;
-        return *this;
+  }
-    }
 
-    // Returns a proxy object for moving from a temporary:
+  // Returns a proxy object for moving from a temporary:
-    //   BufferedFile file = BufferedFile(...);
+  //   BufferedFile file = BufferedFile(...);
-    operator Proxy() FMT_NOEXCEPT
+  operator Proxy() FMT_NOEXCEPT {
-    {
+    Proxy p = {file_};
-        Proxy p = {file_};
+    file_ = FMT_NULL;
-        file_ = 0;
+    return p;
-        return p;
+  }
-    }
 
 #else
-private:
+ private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);
+  FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);
 
-public:
+ public:
-BufferedFile(BufferedFile &&other) FMT_NOEXCEPT :
+  BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) {
-    file_(other.file_)
+    other.file_ = FMT_NULL;
-    {
+  }
-        other.file_ = 0;
-    }
 
-    BufferedFile& operator=(BufferedFile &&other)
+  BufferedFile& operator=(BufferedFile &&other) {
-    {
+    close();
-        close();
+    file_ = other.file_;
-        file_ = other.file_;
+    other.file_ = FMT_NULL;
-        other.file_ = 0;
+    return *this;
-        return *this;
+  }
-    }
 #endif
 
-    // Opens a file.
+  // Opens a file.
-    BufferedFile(CStringRef filename, CStringRef mode);
+  FMT_API BufferedFile(CStringRef filename, CStringRef mode);
 
-    // Closes the file.
+  // Closes the file.
-    void close();
+  FMT_API void close();
 
-    // Returns the pointer to a FILE object representing this file.
+  // Returns the pointer to a FILE object representing this file.
-    FILE *get() const FMT_NOEXCEPT
+  FILE *get() const FMT_NOEXCEPT { return file_; }
-    {
-        return file_;
-    }
 
-    // We place parentheses around fileno to workaround a bug in some versions
+  // We place parentheses around fileno to workaround a bug in some versions
-    // of MinGW that define fileno as a macro.
+  // of MinGW that define fileno as a macro.
-    int (fileno)() const;
+  FMT_API int (fileno)() const;
 
-    void print(CStringRef format_str, const ArgList &args)
+  void print(CStringRef format_str, const ArgList &args) {
-    {
+    fmt::print(file_, format_str, args);
-        fmt::print(file_, format_str, args);
+  }
-    }
+  FMT_VARIADIC(void, print, CStringRef)
-    FMT_VARIADIC(void, print, CStringRef)
 };
 
 // A file. Closed file is represented by a File object with descriptor -1.
@@ -219,141 +178,125 @@ BufferedFile(BufferedFile &&other) FMT_NOEXCEPT :
 // 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
+class File {
-{
+ private:
-private:
+  int fd_;  // File descriptor.
-    int fd_;  // File descriptor.
 
-    // Constructs a File object with a given descriptor.
+  // Constructs a File object with a given descriptor.
-    explicit File(int fd) : fd_(fd) {}
+  explicit File(int fd) : fd_(fd) {}
 
-public:
+ public:
-    // Possible values for the oflag argument to the constructor.
+  // Possible values for the oflag argument to the constructor.
-    enum
+  enum {
-    {
+    RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
-        RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
+    WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
-        WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
+    RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
-        RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
+  };
-    };
 
-    // Constructs a File object which doesn't represent any file.
+  // Constructs a File object which doesn't represent any file.
-File() FMT_NOEXCEPT :
+  File() FMT_NOEXCEPT : fd_(-1) {}
-    fd_(-1) {}
 
-    // Opens a file and constructs a File object representing this file.
+  // Opens a file and constructs a File object representing this file.
-    File(CStringRef path, int oflag);
+  FMT_API File(CStringRef path, int oflag);
 
 #if !FMT_USE_RVALUE_REFERENCES
-    // Emulate a move constructor and a move assignment operator if rvalue
+  // Emulate a move constructor and a move assignment operator if rvalue
-    // references are not supported.
+  // references are not supported.
 
-private:
+ private:
-    // A proxy object to emulate a move constructor.
+  // A proxy object to emulate a move constructor.
-    // It is private to make it impossible call operator Proxy directly.
+  // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
+  struct Proxy {
-    {
+    int fd;
-        int fd;
+  };
-    };
 
-public:
+ public:
-    // A "move constructor" for moving from a temporary.
+  // A "move constructor" for moving from a temporary.
-File(Proxy p) FMT_NOEXCEPT :
+  File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}
-    fd_(p.fd) {}
 
-    // A "move constructor" for moving from an lvalue.
+  // A "move constructor" for moving from an lvalue.
-File(File &other) FMT_NOEXCEPT :
+  File(File &other) FMT_NOEXCEPT : fd_(other.fd_) {
-    fd_(other.fd_)
+    other.fd_ = -1;
-    {
+  }
-        other.fd_ = -1;
-    }
 
-    // A "move assignment operator" for moving from a temporary.
+  // A "move assignment operator" for moving from a temporary.
-    File &operator=(Proxy p)
+  File &operator=(Proxy p) {
-    {
+    close();
-        close();
+    fd_ = p.fd;
-        fd_ = p.fd;
+    return *this;
-        return *this;
+  }
-    }
 
-    // A "move assignment operator" for moving from an lvalue.
+  // A "move assignment operator" for moving from an lvalue.
-    File &operator=(File &other)
+  File &operator=(File &other) {
-    {
+    close();
-        close();
+    fd_ = other.fd_;
-        fd_ = other.fd_;
+    other.fd_ = -1;
-        other.fd_ = -1;
+    return *this;
-        return *this;
+  }
-    }
 
-    // Returns a proxy object for moving from a temporary:
+  // Returns a proxy object for moving from a temporary:
-    //   File file = File(...);
+  //   File file = File(...);
-    operator Proxy() FMT_NOEXCEPT
+  operator Proxy() FMT_NOEXCEPT {
-    {
+    Proxy p = {fd_};
-        Proxy p = {fd_};
+    fd_ = -1;
-        fd_ = -1;
+    return p;
-        return p;
+  }
-    }
 
 #else
-private:
+ private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(File);
+  FMT_DISALLOW_COPY_AND_ASSIGN(File);
 
-public:
+ public:
-File(File &&other) FMT_NOEXCEPT :
+  File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) {
-    fd_(other.fd_)
+    other.fd_ = -1;
-    {
+  }
-        other.fd_ = -1;
-    }
 
-    File& operator=(File &&other)
+  File& operator=(File &&other) {
-    {
+    close();
-        close();
+    fd_ = other.fd_;
-        fd_ = other.fd_;
+    other.fd_ = -1;
-        other.fd_ = -1;
+    return *this;
-        return *this;
+  }
-    }
 #endif
 
-    // Destroys the object closing the file it represents if any.
+  // Destroys the object closing the file it represents if any.
-    ~File() FMT_NOEXCEPT;
+  FMT_API ~File() FMT_NOEXCEPT;
 
-    // Returns the file descriptor.
+  // Returns the file descriptor.
-    int descriptor() const FMT_NOEXCEPT
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
-    {
-        return fd_;
-    }
 
-    // Closes the file.
+  // Closes the file.
-    void close();
+  FMT_API void close();
 
-    // Returns the file size. The size has signed type for consistency with
+  // Returns the file size. The size has signed type for consistency with
-    // stat::st_size.
+  // stat::st_size.
-    LongLong size() const;
+  FMT_API LongLong size() const;
 
-    // Attempts to read count bytes from the file into the specified buffer.
+  // Attempts to read count bytes from the file into the specified buffer.
-    std::size_t read(void *buffer, std::size_t count);
+  FMT_API std::size_t read(void *buffer, std::size_t count);
 
-    // Attempts to write count bytes from the specified buffer to the file.
+  // Attempts to write count bytes from the specified buffer to the file.
-    std::size_t write(const void *buffer, std::size_t count);
+  FMT_API std::size_t write(const void *buffer, std::size_t count);
 
-    // Duplicates a file descriptor with the dup function and returns
+  // Duplicates a file descriptor with the dup function and returns
-    // the duplicate as a file object.
+  // the duplicate as a file object.
-    static File dup(int fd);
+  FMT_API static File dup(int fd);
 
-    // Makes fd be the copy of this file descriptor, closing fd first if
+  // Makes fd be the copy of this file descriptor, closing fd first if
-    // necessary.
+  // necessary.
-    void dup2(int fd);
+  FMT_API void dup2(int fd);
 
-    // Makes fd be the copy of this file descriptor, closing fd first if
+  // Makes fd be the copy of this file descriptor, closing fd first if
-    // necessary.
+  // necessary.
-    void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;
+  FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;
 
-    // Creates a pipe setting up read_end and write_end file objects for reading
+  // Creates a pipe setting up read_end and write_end file objects for reading
-    // and writing respectively.
+  // and writing respectively.
-    static void pipe(File &read_end, File &write_end);
+  FMT_API static void pipe(File &read_end, File &write_end);
 
-    // Creates a BufferedFile object associated with this file and detaches
+  // Creates a BufferedFile object associated with this file and detaches
-    // this File object from the file.
+  // this File object from the file.
-    BufferedFile fdopen(const char *mode);
+  FMT_API BufferedFile fdopen(const char *mode);
 };
 
 // Returns the memory page size.
@@ -366,77 +309,58 @@ long getpagesize();
 
 #ifdef FMT_LOCALE
 // A "C" numeric locale.
-class Locale
+class Locale {
-{
+ private:
-private:
 # ifdef _MSC_VER
-    typedef _locale_t locale_t;
+  typedef _locale_t locale_t;
 
-    enum { LC_NUMERIC_MASK = LC_NUMERIC };
+  enum { LC_NUMERIC_MASK = LC_NUMERIC };
 
-    static locale_t newlocale(int category_mask, const char *locale, locale_t)
+  static locale_t newlocale(int category_mask, const char *locale, locale_t) {
-    {
+    return _create_locale(category_mask, locale);
-        return _create_locale(category_mask, locale);
+  }
-    }
 
-    static void freelocale(locale_t locale)
+  static void freelocale(locale_t locale) {
-    {
+    _free_locale(locale);
-        _free_locale(locale);
+  }
-    }
 
-    static double strtod_l(const char *nptr, char **endptr, _locale_t locale)
+  static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
-    {
+    return _strtod_l(nptr, endptr, locale);
-        return _strtod_l(nptr, endptr, locale);
+  }
-    }
 # endif
 
-    locale_t locale_;
+  locale_t locale_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
+  FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
 
-public:
+ public:
-    typedef locale_t Type;
+  typedef locale_t Type;
 
-    Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", NULL))
+  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
-    {
+    if (!locale_)
-        if (!locale_)
+      FMT_THROW(fmt::SystemError(errno, "cannot create locale"));
-            FMT_THROW(fmt::SystemError(errno, "cannot create locale"));
+  }
-    }
+  ~Locale() { freelocale(locale_); }
-    ~Locale()
-    {
-        freelocale(locale_);
-    }
 
-    Type get() const
+  Type get() const { return locale_; }
-    {
-        return locale_;
-    }
 
-    // Converts string to floating-point number and advances str past the end
+  // Converts string to floating-point number and advances str past the end
-    // of the parsed input.
+  // of the parsed input.
-    double strtod(const char *&str) const
+  double strtod(const char *&str) const {
-    {
+    char *end = FMT_NULL;
-        char *end = 0;
+    double result = strtod_l(str, &end, locale_);
-        double result = strtod_l(str, &end, locale_);
+    str = end;
-        str = end;
+    return result;
-        return result;
+  }
-    }
 };
 #endif  // FMT_LOCALE
 }  // namespace fmt
 
 #if !FMT_USE_RVALUE_REFERENCES
-namespace std
+namespace std {
-{
 // For compatibility with C++98.
-inline fmt::BufferedFile &move(fmt::BufferedFile &f)
+inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; }
-{
+inline fmt::File &move(fmt::File &f) { return f; }
-    return f;
-}
-inline fmt::File &move(fmt::File &f)
-{
-    return f;
-}
 }
 #endif
 

vendor/spdlog/spdlog/fmt/bundled/time.h

@@ -13,46 +13,131 @@
 #include "format.h"
 #include <ctime>
 
-namespace fmt
+#ifdef _MSC_VER
-{
+# pragma warning(push)
+# pragma warning(disable: 4702)  // unreachable code
+# pragma warning(disable: 4996)  // "deprecated" functions
+#endif
+
+namespace fmt {
 template <typename ArgFormatter>
-void format(BasicFormatter<char, ArgFormatter> &f,
+void format_arg(BasicFormatter<char, ArgFormatter> &f,
-            const char *&format_str, const std::tm &tm)
+                const char *&format_str, const std::tm &tm) {
-{
+  if (*format_str == ':')
-    if (*format_str == ':')
+    ++format_str;
-        ++format_str;
+  const char *end = format_str;
-    const char *end = format_str;
+  while (*end && *end != '}')
-    while (*end && *end != '}')
+    ++end;
-        ++end;
+  if (*end != '}')
-    if (*end != '}')
+    FMT_THROW(FormatError("missing '}' in format string"));
-        FMT_THROW(FormatError("missing '}' in format string"));
+  internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
-    internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
+  format.append(format_str, end + 1);
-    format.append(format_str, end + 1);
+  format[format.size() - 1] = '\0';
-    format[format.size() - 1] = '\0';
+  Buffer<char> &buffer = f.writer().buffer();
-    Buffer<char> &buffer = f.writer().buffer();
+  std::size_t start = buffer.size();
-    std::size_t start = buffer.size();
+  for (;;) {
-    for (;;)
+    std::size_t size = buffer.capacity() - start;
-    {
+    std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
-        std::size_t size = buffer.capacity() - start;
+    if (count != 0) {
-        std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
+      buffer.resize(start + count);
-        if (count != 0)
+      break;
-        {
-            buffer.resize(start + count);
-            break;
-        }
-        if (size >= format.size() * 256)
-        {
-            // If the buffer is 256 times larger than the format string, assume
-            // that `strftime` gives an empty result. There doesn't seem to be a
-            // better way to distinguish the two cases:
-            // https://github.com/fmtlib/fmt/issues/367
-            break;
-        }
-        const std::size_t MIN_GROWTH = 10;
-        buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
     }
-    format_str = end + 1;
+    if (size >= format.size() * 256) {
-}
+      // If the buffer is 256 times larger than the format string, assume
+      // that `strftime` gives an empty result. There doesn't seem to be a
+      // better way to distinguish the two cases:
+      // https://github.com/fmtlib/fmt/issues/367
+      break;
+    }
+    const std::size_t MIN_GROWTH = 10;
+    buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
+  }
+  format_str = end + 1;
 }
 
+namespace internal{
+inline Null<> localtime_r(...) { return Null<>(); }
+inline Null<> localtime_s(...) { return Null<>(); }
+inline Null<> gmtime_r(...) { return Null<>(); }
+inline Null<> gmtime_s(...) { return Null<>(); }
+}
+
+// Thread-safe replacement for std::localtime
+inline std::tm localtime(std::time_t time) {
+  struct LocalTime {
+    std::time_t time_;
+    std::tm tm_;
+
+    LocalTime(std::time_t t): time_(t) {}
+
+    bool run() {
+      using namespace fmt::internal;
+      return handle(localtime_r(&time_, &tm_));
+    }
+
+    bool handle(std::tm *tm) { return tm != FMT_NULL; }
+
+    bool handle(internal::Null<>) {
+      using namespace fmt::internal;
+      return fallback(localtime_s(&tm_, &time_));
+    }
+
+    bool fallback(int res) { return res == 0; }
+
+    bool fallback(internal::Null<>) {
+      using namespace fmt::internal;
+      std::tm *tm = std::localtime(&time_);
+      if (tm) tm_ = *tm;
+      return tm != FMT_NULL;
+    }
+  };
+  LocalTime lt(time);
+  if (lt.run())
+    return lt.tm_;
+  // Too big time values may be unsupported.
+  FMT_THROW(fmt::FormatError("time_t value out of range"));
+  return std::tm();
+}
+
+// Thread-safe replacement for std::gmtime
+inline std::tm gmtime(std::time_t time) {
+  struct GMTime {
+    std::time_t time_;
+    std::tm tm_;
+
+    GMTime(std::time_t t): time_(t) {}
+
+    bool run() {
+      using namespace fmt::internal;
+      return handle(gmtime_r(&time_, &tm_));
+    }
+
+    bool handle(std::tm *tm) { return tm != FMT_NULL; }
+
+    bool handle(internal::Null<>) {
+      using namespace fmt::internal;
+      return fallback(gmtime_s(&tm_, &time_));
+    }
+
+    bool fallback(int res) { return res == 0; }
+
+    bool fallback(internal::Null<>) {
+      std::tm *tm = std::gmtime(&time_);
+      if (tm != FMT_NULL) tm_ = *tm;
+      return tm != FMT_NULL;
+    }
+  };
+  GMTime gt(time);
+  if (gt.run())
+    return gt.tm_;
+  // Too big time values may be unsupported.
+  FMT_THROW(fmt::FormatError("time_t value out of range"));
+  return std::tm();
+}
+} //namespace fmt
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
 #endif  // FMT_TIME_H_

vendor/spdlog/spdlog/fmt/fmt.h

@@ -18,7 +18,7 @@
 #ifndef FMT_USE_WINDOWS_H
 #define FMT_USE_WINDOWS_H 0
 #endif
-#include <spdlog/fmt/bundled/format.h>
+#include "spdlog/fmt/bundled/format.h"
 
 #else //external fmtlib
 

vendor/spdlog/spdlog/fmt/ostr.h

@@ -8,8 +8,8 @@
 // include external or bundled copy of fmtlib's ostream support
 //
 #if !defined(SPDLOG_FMT_EXTERNAL)
-#include <spdlog/fmt/fmt.h>
+#include "spdlog/fmt/fmt.h"
-#include <spdlog/fmt/bundled/ostream.h>
+#include "spdlog/fmt/bundled/ostream.h"
 #else
 #include <fmt/ostream.h>
 #endif

vendor/spdlog/spdlog/formatter.h

@@ -5,7 +5,7 @@
 
 #pragma once
 
-#include <spdlog/details/log_msg.h>
+#include "spdlog/details/log_msg.h"
 
 #include <vector>
 #include <string>
@@ -25,21 +25,23 @@ public:
     virtual void format(details::log_msg& msg) = 0;
 };
 
-class pattern_formatter : public formatter
+class pattern_formatter SPDLOG_FINAL : public formatter
 {
 
 public:
-    explicit pattern_formatter(const std::string& pattern);
+    explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local);
     pattern_formatter(const pattern_formatter&) = delete;
     pattern_formatter& operator=(const pattern_formatter&) = delete;
     void format(details::log_msg& msg) override;
 private:
     const std::string _pattern;
+    const pattern_time_type _pattern_time;
     std::vector<std::unique_ptr<details::flag_formatter>> _formatters;
+    std::tm get_time(details::log_msg& msg);
     void handle_flag(char flag);
     void compile_pattern(const std::string& pattern);
 };
 }
 
-#include <spdlog/details/pattern_formatter_impl.h>
+#include "spdlog/details/pattern_formatter_impl.h"
 

vendor/spdlog/spdlog/logger.h

@@ -12,8 +12,8 @@
 // 2. Format the message using the formatter function
 // 3. Pass the formatted message to its sinks to performa the actual logging
 
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
-#include <spdlog/common.h>
+#include "spdlog/common.h"
 
 #include <vector>
 #include <memory>
@@ -44,6 +44,35 @@ public:
     template <typename Arg1, typename... Args> void error(const char* fmt, const Arg1&, const Args&... args);
     template <typename Arg1, typename... Args> void critical(const char* fmt, const Arg1&, const Args&... args);
 
+    template <typename... Args> void log_if(const bool flag, level::level_enum lvl, const char* fmt, const Args&... args);
+    template <typename... Args> void log_if(const bool flag, level::level_enum lvl, const char* msg);
+    template <typename Arg1, typename... Args> void trace_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
+    template <typename Arg1, typename... Args> void debug_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
+    template <typename Arg1, typename... Args> void info_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
+    template <typename Arg1, typename... Args> void warn_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
+    template <typename Arg1, typename... Args> void error_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
+    template <typename Arg1, typename... Args> void critical_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+    template <typename... Args> void log(level::level_enum lvl, const wchar_t* msg);
+    template <typename... Args> void log(level::level_enum lvl, const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void trace(const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void debug(const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void info(const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void warn(const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void error(const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void critical(const wchar_t* fmt, const Args&... args);
+
+    template <typename... Args> void log_if(const bool flag, level::level_enum lvl, const wchar_t* msg);
+    template <typename... Args> void log_if(const bool flag, level::level_enum lvl, const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void trace_if(const bool flag, const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void debug_if(const bool flag, const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void info_if(const bool flag, const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void warn_if(const bool flag, const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void error_if(const bool flag, const wchar_t* fmt, const Args&... args);
+    template <typename... Args> void critical_if(const bool flag, const wchar_t* fmt, const Args&... args);
+#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
+
     template <typename T> void log(level::level_enum lvl, const T&);
     template <typename T> void trace(const T&);
     template <typename T> void debug(const T&);
@@ -52,11 +81,19 @@ public:
     template <typename T> void error(const T&);
     template <typename T> void critical(const T&);
 
+    template <typename T> void log_if(const bool flag, level::level_enum lvl, const T&);
+    template <typename T> void trace_if(const bool flag, const T&);
+    template <typename T> void debug_if(const bool flag, const T&);
+    template <typename T> void info_if(const bool flag, const T&);
+    template <typename T> void warn_if(const bool flag, const T&);
+    template <typename T> void error_if(const bool flag, const T&);
+    template <typename T> void critical_if(const bool flag, const T&);
+
     bool should_log(level::level_enum) const;
     void set_level(level::level_enum);
     level::level_enum level() const;
     const std::string& name() const;
-    void set_pattern(const std::string&);
+    void set_pattern(const std::string&, pattern_time_type = pattern_time_type::local);
     void set_formatter(formatter_ptr);
 
     // automatically call flush() if message level >= log_level
@@ -72,7 +109,7 @@ public:
 
 protected:
     virtual void _sink_it(details::log_msg&);
-    virtual void _set_pattern(const std::string&);
+    virtual void _set_pattern(const std::string&, pattern_time_type);
     virtual void _set_formatter(formatter_ptr);
 
     // default error handler: print the error to stderr with the max rate of 1 message/minute
@@ -88,7 +125,8 @@ protected:
     spdlog::level_t _flush_level;
     log_err_handler _err_handler;
     std::atomic<time_t> _last_err_time;
+    std::atomic<size_t> _msg_counter;
 };
 }
 
-#include <spdlog/details/logger_impl.h>
+#include "spdlog/details/logger_impl.h"

vendor/spdlog/spdlog/sinks/android_sink.h

@@ -7,11 +7,17 @@
 
 #if defined(__ANDROID__)
 
-#include <spdlog/sinks/sink.h>
+#include "spdlog/sinks/sink.h"
 
 #include <mutex>
 #include <string>
 #include <android/log.h>
+#include <thread>
+#include <chrono>
+
+#if !defined(SPDLOG_ANDROID_RETRIES)
+#define SPDLOG_ANDROID_RETRIES 2
+#endif
 
 namespace spdlog
 {
@@ -25,15 +31,23 @@ namespace sinks
 class android_sink : public sink
 {
 public:
-    explicit android_sink(const std::string& tag = "spdlog"): _tag(tag) {}
+    explicit android_sink(const std::string& tag = "spdlog", bool use_raw_msg = false): _tag(tag), _use_raw_msg(use_raw_msg) {}
 
     void log(const details::log_msg& msg) override
     {
         const android_LogPriority priority = convert_to_android(msg.level);
+        const char *msg_output = (_use_raw_msg ? msg.raw.c_str() : msg.formatted.c_str());
+
         // See system/core/liblog/logger_write.c for explanation of return value
-        const int ret = __android_log_write(
+        int ret = __android_log_write(priority, _tag.c_str(), msg_output);
-                            priority, _tag.c_str(), msg.formatted.c_str()
+        int retry_count = 0;
-                        );
+        while ((ret == -11/*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            ret = __android_log_write(priority, _tag.c_str(), msg_output);
+            retry_count++;
+        }
+
         if (ret < 0)
         {
             throw spdlog_ex("__android_log_write() failed", ret);
@@ -67,6 +81,7 @@ private:
     }
 
     std::string _tag;
+    bool _use_raw_msg;
 };
 
 }

vendor/spdlog/spdlog/sinks/ansicolor_sink.h

@@ -1,12 +1,13 @@
 //
-// Copyright(c) 2016 Kevin M. Godby (a modified version by spdlog).
+// Copyright(c) 2017 spdlog authors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 
 #pragma once
 
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
-#include <spdlog/common.h>
+#include "spdlog/common.h"
+#include "spdlog/details/os.h"
 
 #include <string>
 #include <map>
@@ -17,99 +18,115 @@ namespace sinks
 {
 
 /**
- * @brief The ansi_color_sink is a decorator around another sink and prefixes
+ * This sink prefixes the output with an ANSI escape sequence color code depending on the severity
- * the output with an ANSI escape sequence color code depending on the severity
  * of the message.
+ * If no color terminal detected, omit the escape codes.
  */
-class ansicolor_sink : public sink
+template <class Mutex>
+class ansicolor_sink: public base_sink<Mutex>
 {
 public:
-    ansicolor_sink(sink_ptr wrapped_sink);
+    ansicolor_sink(FILE* file): target_file_(file)
-    virtual ~ansicolor_sink();
+    {
+        should_do_colors_ = details::os::in_terminal(file) && details::os::is_color_terminal();
+        colors_[level::trace] = cyan;
+        colors_[level::debug] = cyan;
+        colors_[level::info] = reset;
+        colors_[level::warn] = yellow + bold;
+        colors_[level::err] = red + bold;
+        colors_[level::critical] = bold + on_red;
+        colors_[level::off] = reset;
+    }
+    virtual ~ansicolor_sink()
+    {
+        _flush();
+    }
 
-    ansicolor_sink(const ansicolor_sink& other) = delete;
+    void set_color(level::level_enum color_level, const std::string& color)
-    ansicolor_sink& operator=(const ansicolor_sink& other) = delete;
+    {
-
+        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-    virtual void log(const details::log_msg& msg) override;
+        colors_[color_level] = color;
-    virtual void flush() override;
+    }
-
-    void set_color(level::level_enum color_level, const std::string& color);
 
     /// Formatting codes
-    const std::string reset      = "\033[00m";
+    const std::string reset = "\033[00m";
-    const std::string bold       = "\033[1m";
+    const std::string bold = "\033[1m";
-    const std::string dark       = "\033[2m";
+    const std::string dark = "\033[2m";
-    const std::string underline  = "\033[4m";
+    const std::string underline = "\033[4m";
-    const std::string blink      = "\033[5m";
+    const std::string blink = "\033[5m";
-    const std::string reverse    = "\033[7m";
+    const std::string reverse = "\033[7m";
-    const std::string concealed  = "\033[8m";
+    const std::string concealed = "\033[8m";
 
     // Foreground colors
-    const std::string grey       = "\033[30m";
+    const std::string grey = "\033[30m";
-    const std::string red        = "\033[31m";
+    const std::string red = "\033[31m";
-    const std::string green      = "\033[32m";
+    const std::string green = "\033[32m";
-    const std::string yellow     = "\033[33m";
+    const std::string yellow = "\033[33m";
-    const std::string blue       = "\033[34m";
+    const std::string blue = "\033[34m";
-    const std::string magenta    = "\033[35m";
+    const std::string magenta = "\033[35m";
-    const std::string cyan       = "\033[36m";
+    const std::string cyan = "\033[36m";
-    const std::string white      = "\033[37m";
+    const std::string white = "\033[37m";
 
     /// Background colors
-    const std::string on_grey    = "\033[40m";
+    const std::string on_grey = "\033[40m";
-    const std::string on_red     = "\033[41m";
+    const std::string on_red = "\033[41m";
-    const std::string on_green   = "\033[42m";
+    const std::string on_green = "\033[42m";
-    const std::string on_yellow  = "\033[43m";
+    const std::string on_yellow = "\033[43m";
-    const std::string on_blue    = "\033[44m";
+    const std::string on_blue = "\033[44m";
     const std::string on_magenta = "\033[45m";
-    const std::string on_cyan    = "\033[46m";
+    const std::string on_cyan = "\033[46m";
-    const std::string on_white   = "\033[47m";
+    const std::string on_white = "\033[47m";
-
 
 protected:
-    sink_ptr sink_;
+    virtual void _sink_it(const details::log_msg& msg) override
+    {
+        // Wrap the originally formatted message in color codes.
+        // If color is not supported in the terminal, log as is instead.
+        if (should_do_colors_)
+        {
+            const std::string& prefix = colors_[msg.level];
+            fwrite(prefix.data(), sizeof(char), prefix.size(), target_file_);
+            fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), target_file_);
+            fwrite(reset.data(), sizeof(char), reset.size(), target_file_);
+        }
+        else
+        {
+            fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), target_file_);
+        }
+        _flush();
+    }
+
+    void _flush() override
+    {
+        fflush(target_file_);
+    }
+    FILE* target_file_;
+    bool should_do_colors_;
     std::map<level::level_enum, std::string> colors_;
 };
 
-inline ansicolor_sink::ansicolor_sink(sink_ptr wrapped_sink) : sink_(wrapped_sink)
-{
-    colors_[level::trace]   = cyan;
-    colors_[level::debug]   = cyan;
-    colors_[level::info]    = bold;
-    colors_[level::warn]    = yellow + bold;
-    colors_[level::err]     = red + bold;
-    colors_[level::critical] = bold + on_red;
-    colors_[level::off]      = reset;
-}
 
-inline void ansicolor_sink::log(const details::log_msg& msg)
+template<class Mutex>
+class ansicolor_stdout_sink: public ansicolor_sink<Mutex>
 {
-    // Wrap the originally formatted message in color codes
+public:
-    const std::string& prefix = colors_[msg.level];
+    ansicolor_stdout_sink(): ansicolor_sink<Mutex>(stdout)
-    const std::string& s = msg.formatted.str();
+    {}
-    const std::string& suffix = reset;
+};
-    details::log_msg m;
-    m.level = msg.level;
-    m.logger_name = msg.logger_name;
-    m.time = msg.time;
-    m.thread_id = msg.thread_id;
-    m.formatted << prefix  << s << suffix;
-    sink_->log(m);
-}
 
-inline void ansicolor_sink::flush()
+template<class Mutex>
+class ansicolor_stderr_sink: public ansicolor_sink<Mutex>
 {
-    sink_->flush();
+public:
-}
+    ansicolor_stderr_sink(): ansicolor_sink<Mutex>(stderr)
+    {}
+};
 
-inline void ansicolor_sink::set_color(level::level_enum color_level, const std::string& color)
+typedef ansicolor_stdout_sink<std::mutex> ansicolor_stdout_sink_mt;
-{
+typedef ansicolor_stdout_sink<details::null_mutex> ansicolor_stdout_sink_st;
-    colors_[color_level] = color;
-}
 
-inline ansicolor_sink::~ansicolor_sink()
+typedef ansicolor_stderr_sink<std::mutex> ansicolor_stderr_sink_mt;
-{
+typedef ansicolor_stderr_sink<details::null_mutex> ansicolor_stderr_sink_st;
-    flush();
-}
 
 } // namespace sinks
 } // namespace spdlog

vendor/spdlog/spdlog/sinks/base_sink.h

@@ -5,15 +5,15 @@
 
 #pragma once
 //
-// base sink templated over a mutex (either dummy or realy)
+// base sink templated over a mutex (either dummy or real)
-// concrete implementation should only overrid the _sink_it method.
+// concrete implementation should only override the _sink_it method.
 // all locking is taken care of here so no locking needed by the implementers..
 //
 
-#include <spdlog/sinks/sink.h>
+#include "spdlog/sinks/sink.h"
-#include <spdlog/formatter.h>
+#include "spdlog/formatter.h"
-#include <spdlog/common.h>
+#include "spdlog/common.h"
-#include <spdlog/details/log_msg.h>
+#include "spdlog/details/log_msg.h"
 
 #include <mutex>
 
@@ -31,14 +31,19 @@ public:
     base_sink(const base_sink&) = delete;
     base_sink& operator=(const base_sink&) = delete;
 
-    void log(const details::log_msg& msg) override
+    void log(const details::log_msg& msg) SPDLOG_FINAL override
     {
         std::lock_guard<Mutex> lock(_mutex);
         _sink_it(msg);
     }
+    void flush() SPDLOG_FINAL override
+    {
+        _flush();
+    }
 
 protected:
     virtual void _sink_it(const details::log_msg& msg) = 0;
+    virtual void _flush() = 0;
     Mutex _mutex;
 };
 }

vendor/spdlog/spdlog/sinks/dist_sink.h

@@ -5,10 +5,10 @@
 
 #pragma once
 
-#include <spdlog/details/log_msg.h>
+#include "spdlog/details/log_msg.h"
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
-#include <spdlog/sinks/sink.h>
+#include "spdlog/sinks/sink.h"
 
 #include <algorithm>
 #include <mutex>
@@ -44,14 +44,16 @@ protected:
         }
     }
 
-public:
+    void _flush() override
-    void flush() override
     {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
         for (auto &sink : _sinks)
             sink->flush();
     }
 
+public:
+
+
     void add_sink(std::shared_ptr<sink> sink)
     {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);

vendor/spdlog/spdlog/sinks/file_sinks.h

@@ -5,10 +5,10 @@
 
 #pragma once
 
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
-#include <spdlog/details/file_helper.h>
+#include "spdlog/details/file_helper.h"
-#include <spdlog/fmt/fmt.h>
+#include "spdlog/fmt/fmt.h"
 
 #include <algorithm>
 #include <chrono>
@@ -26,17 +26,14 @@ namespace sinks
  * Trivial file sink with single file as target
  */
 template<class Mutex>
-class simple_file_sink : public base_sink < Mutex >
+class simple_file_sink SPDLOG_FINAL : public base_sink < Mutex >
 {
 public:
     explicit simple_file_sink(const filename_t &filename, bool truncate = false):_force_flush(false)
     {
         _file_helper.open(filename, truncate);
     }
-    void flush() override
+
-    {
-        _file_helper.flush();
-    }
     void set_force_flush(bool force_flush)
     {
         _force_flush = force_flush;
@@ -49,6 +46,10 @@ protected:
         if(_force_flush)
             _file_helper.flush();
     }
+    void _flush() override
+    {
+        _file_helper.flush();
+    }
 private:
     details::file_helper _file_helper;
     bool _force_flush;
@@ -61,7 +62,7 @@ typedef simple_file_sink<details::null_mutex> simple_file_sink_st;
  * Rotating file sink based on size
  */
 template<class Mutex>
-class rotating_file_sink : public base_sink < Mutex >
+class rotating_file_sink SPDLOG_FINAL : public base_sink < Mutex >
 {
 public:
     rotating_file_sink(const filename_t &base_filename,
@@ -76,10 +77,6 @@ public:
         _current_size = _file_helper.size(); //expensive. called only once
     }
 
-    void flush() override
-    {
-        _file_helper.flush();
-    }
 
 protected:
     void _sink_it(const details::log_msg& msg) override
@@ -93,6 +90,11 @@ protected:
         _file_helper.write(msg);
     }
 
+    void _flush() override
+    {
+        _file_helper.flush();
+    }
+
 private:
     static filename_t calc_filename(const filename_t& filename, std::size_t index)
     {
@@ -177,7 +179,7 @@ struct dateonly_daily_file_name_calculator
  * Rotating file sink based on date. rotates at midnight
  */
 template<class Mutex, class FileNameCalc = default_daily_file_name_calculator>
-class daily_file_sink :public base_sink < Mutex >
+class daily_file_sink SPDLOG_FINAL :public base_sink < Mutex >
 {
 public:
     //create daily file sink which rotates on given time
@@ -194,10 +196,6 @@ public:
         _file_helper.open(FileNameCalc::calc_filename(_base_filename));
     }
 
-    void flush() override
-    {
-        _file_helper.flush();
-    }
 
 protected:
     void _sink_it(const details::log_msg& msg) override
@@ -210,6 +208,11 @@ protected:
         _file_helper.write(msg);
     }
 
+    void _flush() override
+    {
+        _file_helper.flush();
+    }
+
 private:
     std::chrono::system_clock::time_point _next_rotation_tp()
     {

vendor/spdlog/spdlog/sinks/msvc_sink.h

@@ -7,8 +7,8 @@
 
 #if defined(_MSC_VER)
 
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
 
 #include <WinBase.h>
 
@@ -30,15 +30,16 @@ public:
     {
     }
 
-    void flush() override
+
-    {
-    }
 
 protected:
     void _sink_it(const details::log_msg& msg) override
     {
         OutputDebugStringA(msg.formatted.c_str());
     }
+
+    void _flush() override
+    {}
 };
 
 typedef msvc_sink<std::mutex> msvc_sink_mt;

vendor/spdlog/spdlog/sinks/null_sink.h

@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
 
 #include <mutex>
 
@@ -22,7 +22,7 @@ protected:
     void _sink_it(const details::log_msg&) override
     {}
 
-    void flush() override
+    void _flush() override
     {}
 
 };

vendor/spdlog/spdlog/sinks/ostream_sink.h

@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
 
 #include <ostream>
 #include <mutex>
@@ -32,7 +32,7 @@ protected:
             _ostream.flush();
     }
 
-    void flush() override
+    void _flush() override
     {
         _ostream.flush();
     }

vendor/spdlog/spdlog/sinks/sink.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <spdlog/details/log_msg.h>
+#include "spdlog/details/log_msg.h"
 
 namespace spdlog
 {

vendor/spdlog/spdlog/sinks/stdout_sinks.h

@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
 
 #include <cstdio>
 #include <memory>
@@ -18,7 +18,7 @@ namespace sinks
 {
 
 template <class Mutex>
-class stdout_sink: public base_sink<Mutex>
+class stdout_sink SPDLOG_FINAL : public base_sink<Mutex>
 {
     using MyType = stdout_sink<Mutex>;
 public:
@@ -29,14 +29,14 @@ public:
         static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
         return instance;
     }
-
+protected:
     void _sink_it(const details::log_msg& msg) override
     {
         fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stdout);
-        flush();
+        _flush();
     }
 
-    void flush() override
+    void _flush() override
     {
         fflush(stdout);
     }
@@ -47,7 +47,7 @@ typedef stdout_sink<std::mutex> stdout_sink_mt;
 
 
 template <class Mutex>
-class stderr_sink: public base_sink<Mutex>
+class stderr_sink SPDLOG_FINAL : public base_sink<Mutex>
 {
     using MyType = stderr_sink<Mutex>;
 public:
@@ -58,14 +58,14 @@ public:
         static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
         return instance;
     }
-
+protected:
     void _sink_it(const details::log_msg& msg) override
     {
         fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stderr);
-        flush();
+        _flush();
     }
 
-    void flush() override
+    void _flush() override
     {
         fflush(stderr);
     }

vendor/spdlog/spdlog/sinks/syslog_sink.h

@@ -5,12 +5,12 @@
 
 #pragma once
 
-#include <spdlog/common.h>
+#include "spdlog/common.h"
 
 #ifdef SPDLOG_ENABLE_SYSLOG
 
-#include <spdlog/sinks/sink.h>
+#include "spdlog/sinks/sink.h"
-#include <spdlog/details/log_msg.h>
+#include "spdlog/details/log_msg.h"
 
 #include <array>
 #include <string>

vendor/spdlog/spdlog/sinks/wincolor_sink.h

@@ -5,9 +5,9 @@
 
 #pragma once
 
-#include <spdlog/sinks/base_sink.h>
+#include "spdlog/sinks/base_sink.h"
-#include <spdlog/details/null_mutex.h>
+#include "spdlog/details/null_mutex.h"
-#include <spdlog/common.h>
+#include "spdlog/common.h"
 
 #include <mutex>
 #include <string>
@@ -44,12 +44,13 @@ public:
 
     virtual ~wincolor_sink()
     {
-        flush();
+        this->flush();
     }
 
     wincolor_sink(const wincolor_sink& other) = delete;
     wincolor_sink& operator=(const wincolor_sink& other) = delete;
 
+protected:
     virtual void _sink_it(const details::log_msg& msg) override
     {
         auto color = colors_[msg.level];
@@ -58,7 +59,7 @@ public:
         SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors
     }
 
-    virtual void flush() override
+    virtual void _flush() override
     {
         // windows console always flushed?
     }
@@ -79,7 +80,11 @@ private:
     {
         CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
         GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info);
-        SetConsoleTextAttribute(out_handle_, attribs);
+        WORD back_color = orig_buffer_info.wAttributes;
+        // retrieve the current background color
+        back_color &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
+        // keep the background color unchanged
+        SetConsoleTextAttribute(out_handle_, attribs | back_color);
         return  orig_buffer_info.wAttributes; //return orig attribs
     }
 };

vendor/spdlog/spdlog/spdlog.h

@@ -7,11 +7,11 @@
 
 #pragma once
 
-#define SPDLOG_VERSION "0.13.0"
+#define SPDLOG_VERSION "0.14.0"
 
-#include <spdlog/tweakme.h>
+#include "spdlog/tweakme.h"
-#include <spdlog/common.h>
+#include "spdlog/common.h"
-#include <spdlog/logger.h>
+#include "spdlog/logger.h"
 
 #include <memory>
 #include <functional>
@@ -69,7 +69,7 @@ void set_sync_mode();
 
 //
 // Create and register multi/single threaded basic file logger.
-// Basic logger simply writes to given file without any limitatons or rotations.
+// Basic logger simply writes to given file without any limitations or rotations.
 //
 std::shared_ptr<logger> basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate = false);
 std::shared_ptr<logger> basic_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate = false);
@@ -113,7 +113,7 @@ std::shared_ptr<logger> syslog_logger(const std::string& logger_name, const std:
 std::shared_ptr<logger> android_logger(const std::string& logger_name, const std::string& tag = "spdlog");
 #endif
 
-// Create and register a logger a single sink
+// Create and register a logger with a single sink
 std::shared_ptr<logger> create(const std::string& logger_name, const sink_ptr& sink);
 
 // Create and register a logger with multiple sinks
@@ -128,6 +128,13 @@ std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_b
 template <typename Sink, typename... Args>
 std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);
 
+// Create and register an async logger with a single sink
+std::shared_ptr<logger> create_async(const std::string& logger_name, const sink_ptr& sink, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);
+
+// Create and register an async logger with multiple sinks
+std::shared_ptr<logger> create_async(const std::string& logger_name, sinks_init_list sinks, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);
+template<class It>
+std::shared_ptr<logger> create_async(const std::string& logger_name, const It& sinks_begin, const It& sinks_end, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);
 
 // Register the given logger with the given name
 void register_logger(std::shared_ptr<logger> logger);
@@ -155,24 +162,28 @@ void drop_all();
 // SPDLOG_TRACE(my_logger, "some trace message");
 // SPDLOG_TRACE(my_logger, "another trace message {} {}", 1, 2);
 // SPDLOG_DEBUG(my_logger, "some debug message {} {}", 3, 4);
+// SPDLOG_DEBUG_IF(my_logger, true, "some debug message {} {}", 3, 4);
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SPDLOG_TRACE_ON
 #define SPDLOG_STR_H(x) #x
 #define SPDLOG_STR_HELPER(x) SPDLOG_STR_H(x)
 #define SPDLOG_TRACE(logger, ...) logger->trace("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__)
+#define SPDLOG_TRACE_IF(logger, flag, ...) logger->trace_if(flag, "[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__)
 #else
 #define SPDLOG_TRACE(logger, ...)
+#define SPDLOG_TRACE_IF(logger, flag, ...)
 #endif
 
 #ifdef SPDLOG_DEBUG_ON
 #define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__)
+#define SPDLOG_DEBUG_IF(logger, flag, ...) logger->debug_if(flag, __VA_ARGS__)
 #else
 #define SPDLOG_DEBUG(logger, ...)
+#define SPDLOG_DEBUG_IF(logger, flag, ...)
 #endif
 
-
 }
 
 
-#include <spdlog/details/spdlog_impl.h>
+#include "spdlog/details/spdlog_impl.h"

vendor/spdlog/spdlog/tweakme.h

@@ -73,12 +73,14 @@
 // #define SPDLOG_NO_ATOMIC_LEVELS
 ///////////////////////////////////////////////////////////////////////////////
 
+
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment to enable usage of wchar_t for file names on Windows.
 //
 // #define SPDLOG_WCHAR_FILENAMES
 ///////////////////////////////////////////////////////////////////////////////
 
+
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment to override default eol ("\n" or "\r\n" under Linux/Windows)
 //
@@ -101,8 +103,39 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to enable wchar_t support (convert to utf8)
+//
+// #define SPDLOG_WCHAR_TO_UTF8_SUPPORT
+///////////////////////////////////////////////////////////////////////////////
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment to prevent child processes from inheriting log file descriptors
 //
 // #define SPDLOG_PREVENT_CHILD_FD
 ///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to mark some types as final, allowing more optimizations in release
+// mode with recent compilers. See GCC's documentation for -Wsuggest-final-types
+// for instance.
+//
+// #define SPDLOG_FINAL final
+///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to enable message counting feature. Adds %i logger pattern that
+// prints log message sequence id.
+//
+// #define SPDLOG_ENABLE_MESSAGE_COUNTER
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to enable user defined tag names
+//
+// #define SPDLOG_LEVEL_NAMES  { "   TRACE", "   DEBUG", "    INFO",
+// " WARNING", "   ERROR", "CRITICAL", "OFF" };
+///////////////////////////////////////////////////////////////////////////////