bumped bundled fmt version to 4.1.0

include/spdlog/fmt/bundled/format.cc

@@ -72,9 +72,11 @@
 
 // Dummy implementations of strerror_r and strerror_s called if corresponding
 // system functions are not available.
+FMT_MAYBE_UNUSED
 static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
   return fmt::internal::Null<>();
 }
+FMT_MAYBE_UNUSED
 static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
   return fmt::internal::Null<>();
 }
@@ -121,7 +123,7 @@ typedef void (*FormatFunc)(Writer &, int, StringRef);
 // Buffer should be at least of size 1.
 int safe_strerror(
     int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
-  FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");
+  FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");
 
   class StrError {
    private:
@@ -159,6 +161,11 @@ int safe_strerror(
             ERANGE : result;
     }
 
+#ifdef __c2__
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
     // Fallback to strerror if strerror_r and strerror_s are not available.
     int fallback(internal::Null<>) {
       errno = 0;
@@ -166,13 +173,15 @@ int safe_strerror(
       return errno;
     }
 
+#ifdef __c2__
+# pragma clang diagnostic pop
+#endif
+
    public:
     StrError(int err_code, char *&buf, std::size_t buf_size)
       : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
 
     int run() {
-      // Suppress a warning about unused strerror_r.
-      strerror_r(0, FMT_NULL, "");
       return handle(strerror_r(error_code_, buffer_, buffer_size_));
     }
   };
@@ -396,51 +405,6 @@ FMT_FUNC void format_system_error(
   fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
 }
 
-template <typename Char>
-void internal::ArgMap<Char>::init(const ArgList &args) {
-  if (!map_.empty())
-    return;
-  typedef internal::NamedArg<Char> NamedArg;
-  const NamedArg *named_arg = FMT_NULL;
-  bool use_values =
-      args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
-  if (use_values) {
-    for (unsigned i = 0;/*nothing*/; ++i) {
-      internal::Arg::Type arg_type = args.type(i);
-      switch (arg_type) {
-      case internal::Arg::NONE:
-        return;
-      case internal::Arg::NAMED_ARG:
-        named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
-        map_.push_back(Pair(named_arg->name, *named_arg));
-        break;
-      default:
-        /*nothing*/;
-      }
-    }
-    return;
-  }
-  for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
-    internal::Arg::Type arg_type = args.type(i);
-    if (arg_type == internal::Arg::NAMED_ARG) {
-      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
-      map_.push_back(Pair(named_arg->name, *named_arg));
-    }
-  }
-  for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
-    switch (args.args_[i].type) {
-    case internal::Arg::NONE:
-      return;
-    case internal::Arg::NAMED_ARG:
-      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
-      map_.push_back(Pair(named_arg->name, *named_arg));
-      break;
-    default:
-      /*nothing*/;
-    }
-  }
-}
-
 template <typename Char>
 void internal::FixedBuffer<Char>::grow(std::size_t) {
   FMT_THROW(std::runtime_error("buffer overflow"));
@@ -502,8 +466,6 @@ template struct internal::BasicData<void>;
 
 template void internal::FixedBuffer<char>::grow(std::size_t);
 
-template void internal::ArgMap<char>::init(const ArgList &args);
-
 template FMT_API int internal::CharTraits<char>::format_float(
     char *buffer, std::size_t size, const char *format,
     unsigned width, int precision, double value);
@@ -516,8 +478,6 @@ template FMT_API int internal::CharTraits<char>::format_float(
 
 template void internal::FixedBuffer<wchar_t>::grow(std::size_t);
 
-template void internal::ArgMap<wchar_t>::init(const ArgList &args);
-
 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, double value);

include/spdlog/fmt/bundled/ostream.h

@@ -13,25 +13,22 @@
 #include "format.h"
 #include <ostream>
 
-namespace fmt
-{
+namespace fmt {
 
-namespace internal
-{
+namespace internal {
 
 template <class Char>
-class FormatBuf : public std::basic_streambuf<Char>
-{
-private:
+class FormatBuf : public std::basic_streambuf<Char> {
+ private:
   typedef typename std::basic_streambuf<Char>::int_type int_type;
   typedef typename std::basic_streambuf<Char>::traits_type traits_type;
 
   Buffer<Char> &buffer_;
 
-public:
+ public:
   FormatBuf(Buffer<Char> &buffer) : buffer_(buffer) {}
 
-protected:
+ protected:
   // The put-area is actually always empty. This makes the implementation
   // simpler and has the advantage that the streambuf and the buffer are always
   // in sync and sputc never writes into uninitialized memory. The obvious
@@ -39,15 +36,13 @@ protected:
   // to overflow. There is no disadvantage here for sputn since this always
   // results in a call to xsputn.
 
-    int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE
-    {
+  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
     if (!traits_type::eq_int_type(ch, traits_type::eof()))
       buffer_.push_back(static_cast<Char>(ch));
     return ch;
   }
 
-    std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE
-    {
+  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
     buffer_.append(s, s + count);
     return count;
   }
@@ -55,21 +50,20 @@ protected:
 
 Yes &convert(std::ostream &);
 
-struct DummyStream : std::ostream
-{
+struct DummyStream : std::ostream {
   DummyStream();  // Suppress a bogus warning in MSVC.
+
   // Hide all operator<< overloads from std::ostream.
-    void operator<<(Null<>);
+  template <typename T>
+  typename EnableIf<sizeof(T) == 0>::type operator<<(const T &);
 };
 
 No &operator<<(std::ostream &, int);
 
-template<typename T>
-struct ConvertToIntImpl<T, true>
-{
+template <typename T>
+struct ConvertToIntImpl<T, true> {
   // Convert to int only if T doesn't have an overloaded operator<<.
-    enum
-    {
+  enum {
     value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
   };
 };
@@ -81,12 +75,12 @@ FMT_API void write(std::ostream &os, Writer &w);
 // Formats a value.
 template <typename Char, typename ArgFormatter_, typename T>
 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::FormatBuf<Char> format_buf(buffer);
   std::basic_ostream<Char> output(&format_buf);
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
   output << value;
 
   BasicStringRef<Char> str(&buffer[0], buffer.size());

include/spdlog/fmt/bundled/posix.h

@@ -64,39 +64,31 @@
 
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 
-namespace fmt
-{
+namespace fmt {
 
 // An error code.
-class ErrorCode
-{
-private:
+class ErrorCode {
+ private:
   int value_;
 
-public:
-explicit ErrorCode(int value = 0) FMT_NOEXCEPT :
-    value_(value) {}
+ public:
+  explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {}
 
-    int get() const FMT_NOEXCEPT
-    {
-        return value_;
-    }
+  int get() const FMT_NOEXCEPT { return value_; }
 };
 
 // A buffered file.
-class BufferedFile
-{
-private:
+class BufferedFile {
+ private:
   FILE *file_;
 
   friend class File;
 
   explicit BufferedFile(FILE *f) : file_(f) {}
 
-public:
+ public:
   // Constructs a BufferedFile object which doesn't represent any file.
-BufferedFile() FMT_NOEXCEPT :
-    file_(FMT_NULL) {}
+  BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {}
 
   // Destroys the object closing the file it represents if any.
   FMT_API ~BufferedFile() FMT_NOEXCEPT;
@@ -105,37 +97,31 @@ BufferedFile() FMT_NOEXCEPT :
   // Emulate a move constructor and a move assignment operator if rvalue
   // references are not supported.
 
-private:
+ private:
   // A proxy object to emulate a move constructor.
   // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
-    {
+  struct Proxy {
     FILE *file;
   };
 
 public:
   // A "move constructor" for moving from a temporary.
-BufferedFile(Proxy p) FMT_NOEXCEPT :
-    file_(p.file) {}
+  BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
 
   // A "move constructor" for moving from an lvalue.
-BufferedFile(BufferedFile &f) FMT_NOEXCEPT :
-    file_(f.file_)
-    {
+  BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) {
     f.file_ = FMT_NULL;
   }
 
   // A "move assignment operator" for moving from a temporary.
-    BufferedFile &operator=(Proxy p)
-    {
+  BufferedFile &operator=(Proxy p) {
     close();
     file_ = p.file;
     return *this;
   }
 
   // A "move assignment operator" for moving from an lvalue.
-    BufferedFile &operator=(BufferedFile &other)
-    {
+  BufferedFile &operator=(BufferedFile &other) {
     close();
     file_ = other.file_;
     other.file_ = FMT_NULL;
@@ -144,26 +130,22 @@ BufferedFile(BufferedFile &f) FMT_NOEXCEPT :
 
   // Returns a proxy object for moving from a temporary:
   //   BufferedFile file = BufferedFile(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
+  operator Proxy() FMT_NOEXCEPT {
     Proxy p = {file_};
     file_ = FMT_NULL;
     return p;
   }
 
 #else
-private:
+ private:
   FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);
 
-public:
-BufferedFile(BufferedFile &&other) FMT_NOEXCEPT :
-    file_(other.file_)
-    {
+ public:
+  BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) {
     other.file_ = FMT_NULL;
   }
 
-    BufferedFile& operator=(BufferedFile &&other)
-    {
+  BufferedFile& operator=(BufferedFile &&other) {
     close();
     file_ = other.file_;
     other.file_ = FMT_NULL;
@@ -178,17 +160,13 @@ BufferedFile(BufferedFile &&other) FMT_NOEXCEPT :
   FMT_API void close();
 
   // Returns the pointer to a FILE object representing this file.
-    FILE *get() const FMT_NOEXCEPT
-    {
-        return file_;
-    }
+  FILE *get() const FMT_NOEXCEPT { return file_; }
 
   // We place parentheses around fileno to workaround a bug in some versions
   // of MinGW that define fileno as a macro.
   FMT_API int (fileno)() const;
 
-    void print(CStringRef format_str, const ArgList &args)
-    {
+  void print(CStringRef format_str, const ArgList &args) {
     fmt::print(file_, format_str, args);
   }
   FMT_VARIADIC(void, print, CStringRef)
@@ -200,26 +178,23 @@ 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
-{
-private:
+class File {
+ private:
   int fd_;  // File descriptor.
 
   // Constructs a File object with a given descriptor.
   explicit File(int fd) : fd_(fd) {}
 
-public:
+ public:
   // Possible values for the oflag argument to the constructor.
-    enum
-    {
+  enum {
     RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
     WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
     RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
   };
 
   // Constructs a File object which doesn't represent any file.
-File() FMT_NOEXCEPT :
-    fd_(-1) {}
+  File() FMT_NOEXCEPT : fd_(-1) {}
 
   // Opens a file and constructs a File object representing this file.
   FMT_API File(CStringRef path, int oflag);
@@ -228,37 +203,31 @@ File() FMT_NOEXCEPT :
   // Emulate a move constructor and a move assignment operator if rvalue
   // references are not supported.
 
-private:
+ private:
   // A proxy object to emulate a move constructor.
   // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
-    {
+  struct Proxy {
     int fd;
   };
 
-public:
+ public:
   // A "move constructor" for moving from a temporary.
-File(Proxy p) FMT_NOEXCEPT :
-    fd_(p.fd) {}
+  File(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {}
 
   // A "move constructor" for moving from an lvalue.
-File(File &other) FMT_NOEXCEPT :
-    fd_(other.fd_)
-    {
+  File(File &other) FMT_NOEXCEPT : fd_(other.fd_) {
     other.fd_ = -1;
   }
 
   // A "move assignment operator" for moving from a temporary.
-    File &operator=(Proxy p)
-    {
+  File &operator=(Proxy p) {
     close();
     fd_ = p.fd;
     return *this;
   }
 
   // A "move assignment operator" for moving from an lvalue.
-    File &operator=(File &other)
-    {
+  File &operator=(File &other) {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -267,26 +236,22 @@ File(File &other) FMT_NOEXCEPT :
 
   // Returns a proxy object for moving from a temporary:
   //   File file = File(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
+  operator Proxy() FMT_NOEXCEPT {
     Proxy p = {fd_};
     fd_ = -1;
     return p;
   }
 
 #else
-private:
+ private:
   FMT_DISALLOW_COPY_AND_ASSIGN(File);
 
-public:
-File(File &&other) FMT_NOEXCEPT :
-    fd_(other.fd_)
-    {
+ public:
+  File(File &&other) FMT_NOEXCEPT : fd_(other.fd_) {
     other.fd_ = -1;
   }
 
-    File& operator=(File &&other)
-    {
+  File& operator=(File &&other) {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -298,10 +263,7 @@ File(File &&other) FMT_NOEXCEPT :
   FMT_API ~File() FMT_NOEXCEPT;
 
   // Returns the file descriptor.
-    int descriptor() const FMT_NOEXCEPT
-    {
-        return fd_;
-    }
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
 
   // Closes the file.
   FMT_API void close();
@@ -347,26 +309,22 @@ long getpagesize();
 
 #ifdef FMT_LOCALE
 // A "C" numeric locale.
-class Locale
-{
-private:
+class Locale {
+ private:
 # ifdef _MSC_VER
   typedef _locale_t locale_t;
 
   enum { LC_NUMERIC_MASK = LC_NUMERIC };
 
-    static locale_t newlocale(int category_mask, const char *locale, locale_t)
-    {
+  static locale_t newlocale(int category_mask, const char *locale, locale_t) {
     return _create_locale(category_mask, locale);
   }
 
-    static void freelocale(locale_t locale)
-    {
+  static void freelocale(locale_t 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);
   }
 # endif
@@ -375,28 +333,20 @@ private:
 
   FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
 
-public:
+ public:
   typedef locale_t Type;
 
-    Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL))
-    {
+  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
     if (!locale_)
       FMT_THROW(fmt::SystemError(errno, "cannot create locale"));
   }
-    ~Locale()
-    {
-        freelocale(locale_);
-    }
+  ~Locale() { freelocale(locale_); }
 
-    Type get() const
-    {
-        return locale_;
-    }
+  Type get() const { return locale_; }
 
   // Converts string to floating-point number and advances str past the end
   // of the parsed input.
-    double strtod(const char *&str) const
-    {
+  double strtod(const char *&str) const {
     char *end = FMT_NULL;
     double result = strtod_l(str, &end, locale_);
     str = end;
@@ -407,17 +357,10 @@ public:
 }  // namespace fmt
 
 #if !FMT_USE_RVALUE_REFERENCES
-namespace std
-{
+namespace std {
 // For compatibility with C++98.
-inline fmt::BufferedFile &move(fmt::BufferedFile &f)
-{
-    return f;
-}
-inline fmt::File &move(fmt::File &f)
-{
-    return f;
-}
+inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; }
+inline fmt::File &move(fmt::File &f) { return f; }
 }
 #endif
 

include/spdlog/fmt/bundled/time.h

@@ -19,12 +19,10 @@
 # pragma warning(disable: 4996)  // "deprecated" functions
 #endif
 
-namespace fmt
-{
+namespace fmt {
 template <typename ArgFormatter>
 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 == ':')
     ++format_str;
   const char *end = format_str;
@@ -37,17 +35,14 @@ void format_arg(BasicFormatter<char, ArgFormatter> &f,
   format[format.size() - 1] = '\0';
   Buffer<char> &buffer = f.writer().buffer();
   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);
-        if (count != 0)
-        {
+    if (count != 0) {
       buffer.resize(start + count);
       break;
     }
-        if (size >= format.size() * 256)
-        {
+    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:
@@ -60,60 +55,36 @@ void format_arg(BasicFormatter<char, ArgFormatter> &f,
   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<>();
-}
+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
-    {
+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()
-        {
+    bool run() {
       using namespace fmt::internal;
       return handle(localtime_r(&time_, &tm_));
     }
 
-        bool handle(std::tm *tm)
-        {
-            return tm != FMT_NULL;
-        }
+    bool handle(std::tm *tm) { return tm != FMT_NULL; }
 
-        bool handle(internal::Null<>)
-        {
+    bool handle(internal::Null<>) {
       using namespace fmt::internal;
       return fallback(localtime_s(&tm_, &time_));
     }
 
-        bool fallback(int res)
-        {
-            return res == 0;
-        }
+    bool fallback(int res) { return res == 0; }
 
-        bool fallback(internal::Null<>)
-        {
+    bool fallback(internal::Null<>) {
       using namespace fmt::internal;
       std::tm *tm = std::localtime(&time_);
       if (tm) tm_ = *tm;
@@ -129,39 +100,28 @@ inline std::tm localtime(std::time_t time)
 }
 
 // Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time)
-{
-    struct 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()
-        {
+    bool run() {
       using namespace fmt::internal;
       return handle(gmtime_r(&time_, &tm_));
     }
 
-        bool handle(std::tm *tm)
-        {
-            return tm != FMT_NULL;
-        }
+    bool handle(std::tm *tm) { return tm != FMT_NULL; }
 
-        bool handle(internal::Null<>)
-        {
+    bool handle(internal::Null<>) {
       using namespace fmt::internal;
       return fallback(gmtime_s(&tm_, &time_));
     }
 
-        bool fallback(int res)
-        {
-            return res == 0;
-        }
+    bool fallback(int res) { return res == 0; }
 
-        bool fallback(internal::Null<>)
-        {
+    bool fallback(internal::Null<>) {
       std::tm *tm = std::gmtime(&time_);
       if (tm != FMT_NULL) tm_ = *tm;
       return tm != FMT_NULL;