From d8ef8a9e9b416150d4127fd9998dcf2665712c27 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 06:23:43 -0800
Subject: [PATCH 01/62] Cleanup

---
 include/fmt/core.h     |  6 +--
 test/container-test.cc | 94 ------------------------------------------
 test/format-test.cc    |  2 +-
 3 files changed, 3 insertions(+), 99 deletions(-)
 delete mode 100644 test/container-test.cc

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 0944973e..5da04ed0 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -24,7 +24,7 @@
 # define FMT_HAS_FEATURE(x) 0
 #endif
 
-#if defined(__has_include)
+#ifdef __has_include
 # define FMT_HAS_INCLUDE(x) __has_include(x)
 #else
 # define FMT_HAS_INCLUDE(x) 0
@@ -36,7 +36,7 @@
 # define FMT_GCC_VERSION 0
 #endif
 
-#if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
+#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
 # define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
 #else
 # define FMT_HAS_GXX_CXX11 0
@@ -82,8 +82,6 @@
 # endif
 #endif
 
-#define FMT_USE_STRONG_ENUMS FMT_HAS_FEATURE(cxx_strong_enums)
-
 // Check if exceptions are disabled.
 #if defined(__GNUC__) && !defined(__EXCEPTIONS)
 # define FMT_EXCEPTIONS 0
diff --git a/test/container-test.cc b/test/container-test.cc
deleted file mode 100644
index 8cafb3d0..00000000
--- a/test/container-test.cc
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- Tests of container utilities
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-#include "fmt/container.h"
-#include "gtest/gtest.h"
-
-using fmt::internal::ContainerBuffer;
-
-TEST(ContainerBufferTest, Empty) {
-  std::string data;
-  ContainerBuffer<std::string> buffer(data);
-  EXPECT_EQ(0u, buffer.size());
-  EXPECT_EQ(0u, buffer.capacity());
-}
-
-TEST(ContainerBufferTest, Reserve) {
-  std::string data;
-  ContainerBuffer<std::string> buffer(data);
-  std::size_t capacity = std::string().capacity() + 10;
-  buffer.reserve(capacity);
-  EXPECT_EQ(0u, buffer.size());
-  EXPECT_EQ(capacity, buffer.capacity());
-}
-
-TEST(ContainerBufferTest, Resize) {
-  std::string data;
-  ContainerBuffer<std::string> buffer(data);
-  std::size_t size = std::string().capacity() + 10;
-  buffer.resize(size);
-  EXPECT_EQ(size, buffer.size());
-  EXPECT_EQ(size, buffer.capacity());
-}
-
-TEST(ContainerBufferTest, Append) {
-  std::string data("Why so");
-  const std::string serious(" serious");
-  ContainerBuffer<std::string> buffer(data);
-  buffer.append(serious.c_str(), serious.c_str() + serious.length());
-  EXPECT_EQ("Why so serious", data);
-  EXPECT_EQ(data.length(), buffer.size());
-}
-
-TEST(BasicContainerWriterTest, String) {
-  std::string data;
-  fmt::BasicContainerWriter<std::string> out(data);
-  out << "The answer is " << 42 << "\n";
-  EXPECT_EQ("The answer is 42\n", data);
-  EXPECT_EQ(17u, out.size());
-}
-
-TEST(BasicContainerWriterTest, WString) {
-  std::wstring data;
-  fmt::BasicContainerWriter<std::wstring> out(data);
-  out << "The answer is " << 42 << "\n";
-  EXPECT_EQ(L"The answer is 42\n", data);
-  EXPECT_EQ(17u, out.size());
-}
-
-TEST(BasicContainerWriterTest, Vector) {
-  std::vector<char> data;
-  fmt::BasicContainerWriter<std::vector<char> > out(data);
-  out << "The answer is " << 42 << "\n";
-  EXPECT_EQ(17u, data.size());
-  EXPECT_EQ(out.size(), data.size());
-}
-
-TEST(BasicContainerWriterTest, StringAppend) {
-  std::string data("The");
-  fmt::BasicContainerWriter<std::string> out(data);
-  EXPECT_EQ(3u, data.size());
-  EXPECT_EQ(3u, out.size());
-  out << " answer is " << 42 << "\n";
-  EXPECT_EQ("The answer is 42\n", data);
-  EXPECT_EQ(17u, out.size());
-}
-
-TEST(BasicContainerWriterTest, VectorAppend) {
-  std::vector<char> data;
-  data.push_back('T');
-  data.push_back('h');
-  data.push_back('e');
-  fmt::BasicContainerWriter<std::vector<char> > out(data);
-  EXPECT_EQ(3u, data.size());
-  EXPECT_EQ(3u, out.size());
-  out << " answer is " << 42 << "\n";
-  EXPECT_EQ(17u, data.size());
-  EXPECT_EQ(17u, out.size());
-}
diff --git a/test/format-test.cc b/test/format-test.cc
index 30b59fc2..54fe79ac 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1508,7 +1508,7 @@ TEST(FormatTest, Enum) {
   EXPECT_EQ("0", fmt::format("{}", A));
 }
 
-#if FMT_USE_STRONG_ENUMS
+#if FMT_HAS_FEATURE(cxx_strong_enums)
 enum TestFixedEnum : short { B };
 
 TEST(FormatTest, FixedEnum) {

From 78166ccd363fb7088ce86c0bcc839a7fe2457a19 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 06:50:56 -0800
Subject: [PATCH 02/62] Get rid of generic lambdas

---
 include/fmt/format.h | 82 ++++++++++++++++++++++++++++++++------------
 1 file changed, 60 insertions(+), 22 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 2e94fab0..687c1745 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2216,6 +2216,22 @@ class basic_writer {
   template <typename F>
   void write_padded(std::size_t size, const align_spec &spec, F f);
 
+  template <typename F>
+  struct padded_int_writer {
+    string_view prefix;
+    wchar_t fill;
+    unsigned padding;
+    F f;
+
+    template <typename It>
+    void operator()(It &&it) const {
+      if (prefix.size() != 0)
+        it = std::copy_n(prefix.data(), prefix.size(), it);
+      it = std::fill_n(it, padding, fill);
+      f(it);
+    }
+  };
+
   // Writes an integer in the format
   //   <left-padding><prefix><numeric-padding><digits><right-padding>
   // where <digits> are written by f(it).
@@ -2238,12 +2254,7 @@ class basic_writer {
     align_spec as = spec;
     if (spec.align() == ALIGN_DEFAULT)
       as.align_ = ALIGN_RIGHT;
-    write_padded(size, as, [prefix, fill, padding, f](auto &&it) {
-      if (prefix.size() != 0)
-        it = std::copy_n(prefix.data(), prefix.size(), it);
-      it = std::fill_n(it, padding, fill);
-      f(it);
-    });
+    write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
   }
 
   // Writes a decimal integer.
@@ -2368,16 +2379,54 @@ class basic_writer {
                                    int_writer<T, Spec>(*this, value, spec));
   }
 
+  enum {INF_SIZE = 3}; // This is an enum to workaround a bug in MSVC.
+
+  struct inf_or_nan_writer {
+    char sign;
+    const char *str;
+
+    template <typename It>
+    void operator()(It &&it) const {
+      if (sign)
+        *it++ = sign;
+      it = std::copy_n(str, static_cast<std::size_t>(INF_SIZE), it);
+    }
+  };
+
+  struct double_writer {
+    unsigned n;
+    char sign;
+    basic_memory_buffer<char_type> &buffer;
+
+    template <typename It>
+    void operator()(It &&it) {
+      if (sign) {
+        *it++ = sign;
+        --n;
+      }
+      it = std::copy_n(buffer.begin(), n, it);
+    }
+  };
+
   // Formats a floating-point number (double or long double).
   template <typename T>
   void write_double(T value, const format_specs &spec);
 
+  template <typename Char>
+  struct str_writer {
+    const Char *s;
+    std::size_t size;
+
+    template <typename It>
+    void operator()(It &&it) const {
+      it = std::copy_n(s, size, it);
+    }
+  };
+
   // Writes a formatted string.
   template <typename Char>
   void write_str(const Char *s, std::size_t size, const align_spec &spec) {
-    write_padded(size, spec, [s, size](auto &&it) {
-      it = std::copy_n(s, size, it);
-    });
+    write_padded(size, spec, str_writer<Char>{s, size});
   }
 
   template <typename Char>
@@ -2562,12 +2611,7 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
   }
 
   auto write_inf_or_nan = [this, &spec, sign](const char *str) {
-    enum {SIZE = 3}; // This is an enum to workaround a bug in MSVC.
-    write_padded(SIZE + (sign ? 1 : 0), spec, [sign, str](auto &&it) {
-      if (sign)
-        *it++ = sign;
-      it = std::copy_n(str, static_cast<std::size_t>(SIZE), it);
-    });
+    write_padded(INF_SIZE + (sign ? 1 : 0), spec, inf_or_nan_writer{sign, str});
   };
 
   // Format NaN and ininity ourselves because sprintf's output is not consistent
@@ -2646,13 +2690,7 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
     if (sign)
       ++n;
   }
-  write_padded(n, as, [n, sign, &buffer](auto &&it) mutable {
-    if (sign) {
-      *it++ = sign;
-      --n;
-    }
-    it = std::copy_n(buffer.begin(), n, it);
-  });
+  write_padded(n, as, double_writer{n, sign, buffer});
 }
 
 // A range where begin() returns back_insert_iterator.

From 3239c518145bc10a9cf8ffdd42b5a259c71e3045 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 07:05:14 -0800
Subject: [PATCH 03/62] Get rid of generic lambdas

---
 include/fmt/format.h | 72 ++++++++++++++++++++++++++++++++------------
 1 file changed, 53 insertions(+), 19 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 687c1745..62716424 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2308,14 +2308,33 @@ class basic_writer {
       }
     }
 
+    struct dec_writer {
+      unsigned_type abs_value;
+      unsigned num_digits;
+
+      template <typename It>
+      void operator()(It &&it) const {
+        it = internal::format_decimal(it, abs_value, num_digits);
+      }
+    };
+
     void on_dec() {
       unsigned num_digits = internal::count_digits(abs_value);
       writer.write_int(num_digits, get_prefix(), spec,
-                       [this, num_digits](auto &&it) {
-        it = internal::format_decimal(it, abs_value, num_digits);
-      });
+                       dec_writer{abs_value, num_digits});
     }
 
+    struct hex_writer {
+      int_writer &self;
+      unsigned num_digits;
+
+      template <typename It>
+      void operator()(It &&it) const {
+        it = internal::format_uint<4>(it, self.abs_value, num_digits,
+                                      self.spec.type() != 'x');
+      }
+    };
+
     void on_hex() {
       if (spec.flag(HASH_FLAG)) {
         prefix[prefix_size++] = '0';
@@ -2323,12 +2342,20 @@ class basic_writer {
       }
       unsigned num_digits = count_digits<4>();
       writer.write_int(num_digits, get_prefix(), spec,
-                       [this, num_digits](auto &&it) {
-        it = internal::format_uint<4>(it, abs_value, num_digits,
-                                      spec.type() != 'x');
-      });
+                       hex_writer{*this, num_digits});
     }
 
+    template <int BITS>
+    struct bin_writer {
+      unsigned_type abs_value;
+      unsigned num_digits;
+
+      template <typename It>
+      void operator()(It &&it) const {
+        it = internal::format_uint<BITS>(it, abs_value, num_digits);
+      }
+    };
+
     void on_bin() {
       if (spec.flag(HASH_FLAG)) {
         prefix[prefix_size++] = '0';
@@ -2336,9 +2363,7 @@ class basic_writer {
       }
       unsigned num_digits = count_digits<1>();
       writer.write_int(num_digits, get_prefix(), spec,
-                       [this, num_digits](auto &&it) {
-        it = internal::format_uint<1>(it, abs_value, num_digits);
-      });
+                       bin_writer<1>{abs_value, num_digits});
     }
 
     void on_oct() {
@@ -2350,21 +2375,30 @@ class basic_writer {
         prefix[prefix_size++] = '0';
       }
       writer.write_int(num_digits, get_prefix(), spec,
-                       [this, num_digits](auto &&it) {
-        it = internal::format_uint<3>(it, abs_value, num_digits);
-      });
+                       bin_writer<3>{abs_value, num_digits});
     }
 
+    enum { SEP_SIZE = 1 };
+
+    struct num_writer {
+      unsigned_type abs_value;
+      unsigned size;
+      char_type sep;
+
+      template <typename It>
+      void operator()(It &&it) const {
+        basic_string_view<char_type> s(&sep, SEP_SIZE);
+        it = format_decimal(it, abs_value, size,
+                            internal::add_thousands_sep<char_type>(s));
+      }
+    };
+
     void on_num() {
       unsigned num_digits = internal::count_digits(abs_value);
       char_type sep = internal::thousands_sep<char_type>(writer.locale_.get());
-      enum { SEP_SIZE = 1 };
       unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3);
-      writer.write_int(size, get_prefix(), spec, [this, size, sep](auto &&it) {
-        basic_string_view<char_type> s(&sep, SEP_SIZE);
-        it = format_decimal(it, abs_value, size,
-                            internal::add_thousands_sep<char_type>(s));
-      });
+      writer.write_int(size, get_prefix(), spec,
+                       num_writer{abs_value, size, sep});
     }
 
     void on_error() {

From 1849735f127c86deed80d90521b7117d1ebb38da Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 07:25:53 -0800
Subject: [PATCH 04/62] Fallback to c++11 if c++14 not available

---
 support/cmake/cxx14.cmake | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/support/cmake/cxx14.cmake b/support/cmake/cxx14.cmake
index c86cf508..d725917a 100644
--- a/support/cmake/cxx14.cmake
+++ b/support/cmake/cxx14.cmake
@@ -40,6 +40,17 @@ if (FMT_USE_CPP14)
     check_cxx_compiler_flag(-std=c++1y HAVE_STD_CPP1Y_FLAG)
     if (HAVE_STD_CPP1Y_FLAG)
       set(CPP14_FLAG -std=c++1y)
+    else ()
+      # Fallback on c++11 if c++14 is not available.
+      check_cxx_compiler_flag(-std=c++11 HAVE_STD_CPP11_FLAG)
+      if (HAVE_STD_CPP11_FLAG)
+        set(CPP14_FLAG -std=c++11)
+      else ()
+        check_cxx_compiler_flag(-std=c++0x HAVE_STD_CPP11_FLAG)
+        if (HAVE_STD_CPP0X_FLAG)
+          set(CPP14_FLAG -std=c++0x)
+        endif ()
+      endif ()
     endif ()
   endif ()
 endif ()

From 0b508fd29d22b2535b9f641a49d886c9b2d85532 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 07:32:22 -0800
Subject: [PATCH 05/62] Fix c++0x detection

---
 support/cmake/cxx14.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/support/cmake/cxx14.cmake b/support/cmake/cxx14.cmake
index d725917a..eb2c77e9 100644
--- a/support/cmake/cxx14.cmake
+++ b/support/cmake/cxx14.cmake
@@ -46,7 +46,7 @@ if (FMT_USE_CPP14)
       if (HAVE_STD_CPP11_FLAG)
         set(CPP14_FLAG -std=c++11)
       else ()
-        check_cxx_compiler_flag(-std=c++0x HAVE_STD_CPP11_FLAG)
+        check_cxx_compiler_flag(-std=c++0x HAVE_STD_CPP0X_FLAG)
         if (HAVE_STD_CPP0X_FLAG)
           set(CPP14_FLAG -std=c++0x)
         endif ()

From 522de7b55dc9fc46496e4dac721503f235edef04 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 08:32:02 -0800
Subject: [PATCH 06/62] Replace using with typedef for compatibility with
 gcc-4.6

---
 include/fmt/core.h   |  78 +++++++++++++++----------------
 include/fmt/format.h | 106 +++++++++++++++++++++----------------------
 include/fmt/printf.h |   2 +-
 test/util-test.cc    |  18 ++++----
 4 files changed, 103 insertions(+), 101 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 5da04ed0..1c56cd44 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -168,8 +168,8 @@ class basic_string_view {
   size_t size_;
 
  public:
-  using char_type = Char;
-  using iterator = const Char *;
+  typedef Char char_type;
+  typedef const Char *iterator;
 
   FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(0), size_(0) {}
 
@@ -242,8 +242,8 @@ class basic_string_view {
 #endif
 
 namespace fmt {
-using string_view = basic_string_view<char>;
-using wstring_view = basic_string_view<wchar_t>;
+typedef basic_string_view<char> string_view;
+typedef basic_string_view<wchar_t> wstring_view;
 
 template <typename Context>
 class basic_arg;
@@ -285,7 +285,7 @@ class basic_buffer {
   virtual void grow(std::size_t capacity) = 0;
 
  public:
-  using value_type = T;
+  typedef T value_type;
 
   virtual ~basic_buffer() {}
 
@@ -335,8 +335,8 @@ class basic_buffer {
   const T &operator[](std::size_t index) const { return ptr_[index]; }
 };
 
-using buffer = basic_buffer<char>;
-using wbuffer = basic_buffer<wchar_t>;
+typedef basic_buffer<char> buffer;
+typedef basic_buffer<wchar_t> wbuffer;
 
 // A container-backed buffer.
 template <typename Container>
@@ -443,7 +443,7 @@ struct custom_value {
 template <typename Context>
 class value {
  public:
-  using char_type = typename Context::char_type;
+  typedef typename Context::char_type char_type;
 
   union {
     int int_value;
@@ -499,7 +499,7 @@ class value {
     // Get the formatter type through the context to allow different contexts
     // have different extension points, e.g. `formatter<T>` for `format` and
     // `printf_formatter<T>` for `printf`.
-    typename Context::template formatter_type<T> f;
+    typename Context::template formatter_type<T>::type f;
     auto &&parse_ctx = ctx.parse_context();
     parse_ctx.advance_to(f.parse(parse_ctx));
     ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
@@ -531,12 +531,11 @@ FMT_MAKE_VALUE(UINT, unsigned, unsigned)
 
 // To minimize the number of types we need to deal with, long is translated
 // either to int or to long long depending on its size.
-using long_type =
-  std::conditional<sizeof(long) == sizeof(int), int, long long>::type;
+typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
+        long_type;
 FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? INT : LONG_LONG), long, long_type)
-using ulong_type =
-  std::conditional<sizeof(unsigned long) == sizeof(unsigned),
-                   unsigned, unsigned long long>::type;
+typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
+                         unsigned, unsigned long long>::type ulong_type;
 FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? UINT : ULONG_LONG),
     unsigned long, ulong_type)
 
@@ -628,7 +627,7 @@ class basic_arg {
   friend class basic_format_args<Context>;
   friend class internal::arg_map<Context>;
 
-  using char_type = typename Context::char_type;
+  typedef typename Context::char_type char_type;
 
  public:
   class handle {
@@ -663,8 +662,8 @@ class basic_parse_context : private ErrorHandler {
   int next_arg_id_;
 
  public:
-  using char_type = Char;
-  using iterator = typename basic_string_view<Char>::iterator;
+  typedef Char char_type;
+  typedef typename basic_string_view<Char>::iterator iterator;
 
   explicit FMT_CONSTEXPR basic_parse_context(
       basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
@@ -704,8 +703,8 @@ class basic_parse_context : private ErrorHandler {
   FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
 };
 
-using parse_context = basic_parse_context<char>;
-using wparse_context = basic_parse_context<wchar_t>;
+typedef basic_parse_context<char> parse_context;
+typedef basic_parse_context<wchar_t> wparse_context;
 
 namespace internal {
 // A map from argument names to their values for named arguments.
@@ -714,7 +713,7 @@ class arg_map {
  private:
   FMT_DISALLOW_COPY_AND_ASSIGN(arg_map);
 
-  using char_type = typename Context::char_type;
+  typedef typename Context::char_type char_type;
 
   struct entry {
     basic_string_view<char_type> name;
@@ -748,7 +747,7 @@ class arg_map {
 template <typename OutputIt, typename Context, typename Char>
 class context_base {
  public:
-  using iterator = OutputIt;
+  typedef OutputIt iterator;
 
  private:
   basic_parse_context<Char> parse_context_;
@@ -756,8 +755,8 @@ class context_base {
   basic_format_args<Context> args_;
 
  protected:
-  using char_type = Char;
-  using format_arg = basic_arg<Context>;
+  typedef Char char_type;
+  typedef basic_arg<Context> format_arg;
 
   context_base(OutputIt out, basic_string_view<char_type> format_str,
                basic_format_args<Context> args)
@@ -801,7 +800,7 @@ class context_base {
 // Extracts a reference to the container from back_insert_iterator.
 template <typename Container>
 inline Container &get_container(std::back_insert_iterator<Container> it) {
-  using iterator = std::back_insert_iterator<Container>;
+  typedef std::back_insert_iterator<Container> iterator;
   struct accessor: iterator {
     accessor(iterator it) : iterator(it) {}
     using iterator::container;
@@ -816,11 +815,11 @@ class output_range {
   OutputIt it_;
 
   // Unused yet.
-  using sentinel = void;
+  typedef void sentinel;
   sentinel end() const;
 
  public:
-  using value_type = T;
+  typedef T value_type;
 
   explicit output_range(OutputIt it): it_(it) {}
   OutputIt begin() const { return it_; }
@@ -832,18 +831,19 @@ class basic_context :
   public internal::context_base<OutputIt, basic_context<OutputIt, Char>, Char> {
  public:
   /** The character type for the output. */
-  using char_type = Char;
+  typedef Char char_type;
 
+  // using formatter_type = formatter<T, char_type>;
   template <typename T>
-  using formatter_type = formatter<T, char_type>;
+  struct formatter_type { typedef formatter<T, char_type> type; };
 
  private:
   internal::arg_map<basic_context> map_;
 
   FMT_DISALLOW_COPY_AND_ASSIGN(basic_context);
 
-  using base = internal::context_base<OutputIt, basic_context, Char>;
-  using format_arg = typename base::format_arg;
+  typedef internal::context_base<OutputIt, basic_context, Char> base;
+  typedef typename base::format_arg format_arg;
   using base::get_arg;
 
  public:
@@ -872,8 +872,8 @@ class basic_context :
 template <typename Char>
 using buffer_context_t = basic_context<
   std::back_insert_iterator<internal::basic_buffer<Char>>, Char>;
-using context = buffer_context_t<char>;
-using wcontext = buffer_context_t<wchar_t>;
+typedef buffer_context_t<char> context;
+typedef buffer_context_t<wchar_t> wcontext;
 
 namespace internal {
 template <typename Context, typename T>
@@ -882,7 +882,7 @@ class get_type {
   static const T& val();
 
  public:
-  using value_type = decltype(make_value<Context>(val()));
+  typedef decltype(make_value<Context>(val())) value_type;
   static const type value = value_type::type_tag;
 };
 
@@ -923,8 +923,8 @@ class arg_store {
   // Packed is a macro on MinGW so use IS_PACKED instead.
   static const bool IS_PACKED = NUM_ARGS < internal::MAX_PACKED_ARGS;
 
-  using value_type = typename std::conditional<
-    IS_PACKED, internal::value<Context>, basic_arg<Context>>::type;
+  typedef typename std::conditional<
+    IS_PACKED, internal::value<Context>, basic_arg<Context>>::type value_type;
 
   // If the arguments are not packed, add one more element to mark the end.
   value_type data_[NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1)];
@@ -959,8 +959,8 @@ inline arg_store<context, Args...> make_args(const Args & ... args) {
 template <typename Context>
 class basic_format_args {
  public:
-  using size_type = unsigned;
-  using format_arg = basic_arg<Context> ;
+  typedef unsigned size_type;
+  typedef basic_arg<Context>  format_arg;
 
  private:
   // To reduce compiled code size per formatting function call, types of first
@@ -1028,8 +1028,8 @@ class basic_format_args {
   }
 };
 
-using format_args = basic_format_args<context>;
-using wformat_args = basic_format_args<wcontext>;
+typedef basic_format_args<context> format_args;
+typedef basic_format_args<wcontext> wformat_args;
 
 namespace internal {
 template <typename Char>
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 62716424..2a66c9f6 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -575,11 +575,11 @@ FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it);
 template <typename Char>
 class null_terminating_iterator {
  public:
-  using difference_type = std::ptrdiff_t;
-  using value_type = Char;
-  using pointer = const Char*;
-  using reference = const Char&;
-  using iterator_category = std::random_access_iterator_tag;
+  typedef std::ptrdiff_t difference_type;
+  typedef Char value_type;
+  typedef const Char* pointer;
+  typedef const Char& reference;
+  typedef std::random_access_iterator_tag iterator_category;
 
   null_terminating_iterator() : ptr_(0), end_(0) {}
 
@@ -667,11 +667,11 @@ class counting_iterator {
   mutable T blackhole_;
 
  public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = T;
-  using difference_type = std::ptrdiff_t;
-  using pointer = T*;
-  using reference = T&;
+  typedef std::output_iterator_tag iterator_category;
+  typedef T value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef T* pointer;
+  typedef T& reference;
 
   explicit counting_iterator(std::size_t &count): count_(count) {}
   counting_iterator(const counting_iterator &other): count_(other.count_) {}
@@ -998,7 +998,7 @@ struct monostate {};
 template <typename Visitor, typename Context>
 FMT_CONSTEXPR typename std::result_of<Visitor(int)>::type
     visit(Visitor &&vis, basic_arg<Context> arg) {
-  using char_type = typename Context::char_type;
+  typedef typename Context::char_type char_type;
   switch (arg.type_) {
   case internal::NONE:
     return vis(monostate());
@@ -1058,7 +1058,7 @@ class format_spec {
 };
 
 // template <typename Char>
-// using fill_spec = format_spec<Char, fill_tag>;
+// typedef format_spec<Char, fill_tag> fill_spec;
 template <typename Char>
 class fill_spec : public format_spec<Char, fill_tag> {
  public:
@@ -1323,11 +1323,11 @@ void arg_map<Context>::init(const basic_format_args<Context> &args) {
 template <typename Range>
 class arg_formatter_base {
  public:
-  using char_type = typename Range::value_type;
-  using format_specs = basic_format_specs<char_type>;
+  typedef typename Range::value_type char_type;
+  typedef basic_format_specs<char_type> format_specs;
 
  private:
-  using writer_type = basic_writer<Range>;
+  typedef basic_writer<Range> writer_type;
   writer_type writer_;
   format_specs &specs_;
 
@@ -1717,7 +1717,7 @@ template <typename ParseContext>
 class dynamic_specs_handler :
     public specs_setter<typename ParseContext::char_type> {
  public:
-  using char_type = typename ParseContext::char_type;
+  typedef typename ParseContext::char_type char_type;
 
   FMT_CONSTEXPR dynamic_specs_handler(
       dynamic_format_specs<char_type> &specs, ParseContext &ctx)
@@ -1742,7 +1742,7 @@ class dynamic_specs_handler :
   }
 
  private:
-  using arg_ref_type = arg_ref<char_type>;
+  typedef arg_ref<char_type> arg_ref_type;
 
   template <typename Id>
   FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
@@ -1760,7 +1760,7 @@ class dynamic_specs_handler :
 
 template <typename Iterator, typename IDHandler>
 FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler) {
-  using char_type = typename std::iterator_traits<Iterator>::value_type;
+  typedef typename std::iterator_traits<Iterator>::value_type char_type;
   char_type c = *it;
   if (c == '}' || c == ':') {
     handler();
@@ -1830,7 +1830,7 @@ struct precision_adapter {
 //     format specifiers.
 template <typename Iterator, typename SpecHandler>
 FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler) {
-  using char_type = typename std::iterator_traits<Iterator>::value_type;
+  typedef typename std::iterator_traits<Iterator>::value_type char_type;
   // Parse fill and alignment.
   if (char_type c = *it) {
     alignment align = ALIGN_DEFAULT;
@@ -1949,7 +1949,7 @@ struct id_adapter {
 
 template <typename Iterator, typename Handler>
 FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler) {
-  using char_type = typename std::iterator_traits<Iterator>::value_type;
+  typedef typename std::iterator_traits<Iterator>::value_type char_type;
   auto start = it;
   while (*it) {
     char_type ch = *it++;
@@ -2025,7 +2025,7 @@ class format_string_checker {
   }
 
  private:
-  using parse_context_type = basic_parse_context<Char, ErrorHandler>;
+  typedef basic_parse_context<Char, ErrorHandler> parse_context_type;
   enum { NUM_ARGS = sizeof...(Args) };
 
   FMT_CONSTEXPR void check_arg_id() {
@@ -2034,7 +2034,7 @@ class format_string_checker {
   }
 
   // Format specifier parsing function.
-  using parse_func = const Char *(*)(parse_context_type &);
+  typedef const Char *(*parse_func)(parse_context_type &);
 
   int arg_id_ = -1;
   parse_context_type context_;
@@ -2065,7 +2065,7 @@ struct format_enum : std::integral_constant<bool, std::is_enum<T>::value> {};
 template <template <typename> class Handler, typename Spec, typename Context>
 void handle_dynamic_spec(
     Spec &value, arg_ref<typename Context::char_type> ref, Context &ctx) {
-  using char_type = typename Context::char_type;
+  typedef typename Context::char_type char_type;
   switch (ref.kind) {
   case arg_ref<char_type>::NONE:
     break;
@@ -2085,16 +2085,16 @@ void handle_dynamic_spec(
 template <typename Range>
 class arg_formatter: public internal::arg_formatter_base<Range> {
  private:
-  using char_type = typename Range::value_type;
-  using iterator = decltype(std::declval<Range>().begin());
-  using base = internal::arg_formatter_base<Range>;
-  using context_type = basic_context<iterator, char_type>;
+  typedef typename Range::value_type char_type;
+  typedef decltype(std::declval<Range>().begin()) iterator;
+  typedef internal::arg_formatter_base<Range> base;
+  typedef basic_context<iterator, char_type> context_type;
 
   context_type &ctx_;
 
  public:
-  using range = Range;
-  using format_specs = typename base::format_specs;
+  typedef Range range;
+  typedef typename base::format_specs format_specs;
 
   /**
     \rst
@@ -2183,9 +2183,9 @@ FMT_API void format_system_error(fmt::internal::buffer &out, int error_code,
 template <typename Range>
 class basic_writer {
  public:
-  using char_type = typename Range::value_type;
-  using iterator = decltype(std::declval<Range>().begin());
-  using format_specs = basic_format_specs<char_type>;
+  typedef typename Range::value_type char_type;
+  typedef decltype(std::declval<Range>().begin()) iterator;
+  typedef basic_format_specs<char_type> format_specs;
 
  private:
   // Output iterator.
@@ -2196,11 +2196,11 @@ class basic_writer {
   FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer);
 
 #if FMT_SECURE_SCL
-  using pointer_type = stdext::checked_array_iterator<char_type*>;
+  typedef stdext::checked_array_iterator<char_type*> pointer_type;
   // Returns pointer value.
   static char_type *get(pointer_type p) { return p.base(); }
 #else
-  using pointer_type = char_type*;
+  typedef char_type* pointer_type;
   static char_type *get(char_type *p) { return p; }
 #endif
 
@@ -2260,7 +2260,7 @@ class basic_writer {
   // Writes a decimal integer.
   template <typename Int>
   void write_decimal(Int value) {
-    using main_type = typename internal::int_traits<Int>::main_type;
+    typedef typename internal::int_traits<Int>::main_type main_type;
     main_type abs_value = static_cast<main_type>(value);
     bool is_negative = internal::is_negative(value);
     if (is_negative)
@@ -2275,7 +2275,7 @@ class basic_writer {
   // The handle_int_type_spec handler that writes an integer.
   template <typename Int, typename Spec>
   struct int_writer {
-    using unsigned_type = typename internal::int_traits<Int>::main_type;
+    typedef typename internal::int_traits<Int>::main_type unsigned_type;
 
     basic_writer<Range> &writer;
     const Spec &spec;
@@ -2731,16 +2731,16 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
 template <typename Container>
 class back_insert_range:
     public output_range<std::back_insert_iterator<Container>> {
-  using base = output_range<std::back_insert_iterator<Container>>;
+  typedef output_range<std::back_insert_iterator<Container>> base;
  public:
-  using value_type = typename Container::value_type;
+  typedef typename Container::value_type value_type;
 
   using base::base;
   back_insert_range(Container &c): base(std::back_inserter(c)) {}
 };
 
-using writer = basic_writer<back_insert_range<internal::buffer>>;
-using wwriter = basic_writer<back_insert_range<internal::wbuffer>>;
+typedef basic_writer<back_insert_range<internal::buffer>> writer;
+typedef basic_writer<back_insert_range<internal::wbuffer>> wwriter;
 
 // Reports a system error without throwing an exception.
 // Can be used to report errors from destructors.
@@ -2878,7 +2878,7 @@ class FormatInt {
 // write a terminating null character.
 template <typename T>
 inline void format_decimal(char *&buffer, T value) {
-  using main_type = typename internal::int_traits<T>::main_type;
+  typedef typename internal::int_traits<T>::main_type main_type;
   main_type abs_value = static_cast<main_type>(value);
   if (internal::is_negative(value)) {
     *buffer++ = '-';
@@ -2911,7 +2911,7 @@ struct formatter<
   template <typename ParseContext>
   FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) {
     auto it = internal::null_terminating_iterator<Char>(ctx);
-    using handler_type = internal::dynamic_specs_handler<ParseContext>;
+    typedef internal::dynamic_specs_handler<ParseContext> handler_type;
     auto type = internal::get_type<buffer_context_t<Char>, T>::value;
     internal::specs_checker<handler_type>
         handler(handler_type(specs_, ctx), type);
@@ -2964,8 +2964,8 @@ struct formatter<
       specs_.width_, specs_.width_ref, ctx);
     internal::handle_dynamic_spec<internal::precision_checker>(
       specs_.precision_, specs_.precision_ref, ctx);
-    using range = output_range<
-      typename FormatContext::iterator, typename FormatContext::char_type>;
+    typedef output_range<typename FormatContext::iterator,
+                         typename FormatContext::char_type> range;
     visit(arg_formatter<range>(ctx, specs_),
           internal::make_arg<FormatContext>(val));
     return ctx.begin();
@@ -2988,7 +2988,7 @@ struct formatter<T, Char,
 // A formatter for types known only at run time such as variant alternatives.
 //
 // Usage:
-//   using variant = std::variant<int, std::string>;
+//   typedef std::variant<int, std::string> variant;
 //   template <>
 //   struct formatter<variant>: dynamic_formatter<> {
 //     void format(buffer &buf, const variant &v, context &ctx) {
@@ -3033,8 +3033,8 @@ struct dynamic_formatter {
     }
     if (specs_.precision_ != -1)
       checker.end_precision();
-    using range = output_range<
-      typename FormatContext::iterator, typename FormatContext::char_type>;
+    typedef output_range<typename FormatContext::iterator,
+                         typename FormatContext::char_type> range;
     visit(arg_formatter<range>(ctx, specs_),
           internal::make_arg<FormatContext>(val));
     return ctx.begin();
@@ -3067,8 +3067,8 @@ template <typename ArgFormatter, typename Char, typename Context>
 typename Context::iterator do_vformat_to(typename ArgFormatter::range out,
                                          basic_string_view<Char> format_str,
                                          basic_format_args<Context> args) {
-  using iterator = internal::null_terminating_iterator<Char>;
-  using range = typename ArgFormatter::range;
+  typedef internal::null_terminating_iterator<Char> iterator;
+  typedef typename ArgFormatter::range range;
 
   struct handler : internal::error_handler {
     handler(range r, basic_string_view<Char> str,
@@ -3171,7 +3171,7 @@ struct formatter<arg_join<It, Char>, Char>:
     formatter<typename std::iterator_traits<It>::value_type, Char> {
   template <typename FormatContext>
   auto format(const arg_join<It, Char> &value, FormatContext &ctx) {
-    using base = formatter<typename std::iterator_traits<It>::value_type, Char>;
+    typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
     auto it = value.begin;
     auto out = ctx.begin(); 
     if (it != value.end) {
@@ -3244,13 +3244,13 @@ std::basic_string<Char> to_string(const basic_memory_buffer<Char> &buffer) {
 
 inline void vformat_to(internal::buffer &buf, string_view format_str,
                        format_args args) {
-  using range = back_insert_range<internal::buffer>;
+  typedef back_insert_range<internal::buffer> range;
   do_vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
 inline void vformat_to(internal::wbuffer &buf, wstring_view format_str,
                        wformat_args args) {
-  using range = back_insert_range<internal::wbuffer>;
+  typedef back_insert_range<internal::wbuffer> range;
   do_vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
@@ -3275,7 +3275,7 @@ using format_args_t = basic_format_args<context_t<OutputIt, Char>>;
 template <typename OutputIt, typename... Args>
 inline OutputIt vformat_to(OutputIt out, string_view format_str,
                            format_args_t<OutputIt> args) {
-  using range = output_range<OutputIt, char>;
+  typedef output_range<OutputIt, char> range;
   return do_vformat_to<arg_formatter<range>>(range(out), format_str, args);
 }
 
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index 522d8d01..f25a8b64 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -309,7 +309,7 @@ class basic_printf_context :
   using char_type = Char;
 
   template <typename T>
-  using formatter_type = printf_formatter<T>;
+  struct formatter_type { typedef printf_formatter<T> type; };
 
  private:
   using base = internal::context_base<OutputIt, basic_printf_context, Char>;
diff --git a/test/util-test.cc b/test/util-test.cc
index 47cf21c4..54296a74 100644
--- a/test/util-test.cc
+++ b/test/util-test.cc
@@ -440,15 +440,17 @@ struct custom_context {
 
   template <typename T>
   struct formatter_type {
-    template <typename ParseContext>
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-      return ctx.begin();
-    }
+    struct type {
+      template <typename ParseContext>
+      auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+        return ctx.begin();
+      }
 
-    const char *format(const T &, custom_context& ctx) {
-      ctx.called = true;
-      return 0;
-    }
+      const char *format(const T &, custom_context& ctx) {
+        ctx.called = true;
+        return 0;
+      }
+    };
   };
 
   bool called;

From 1a4e892765ef40f4b4bc54b45d7afeec2e0cd75c Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 08:36:44 -0800
Subject: [PATCH 07/62] Move output_range to format.h

---
 include/fmt/core.h   | 16 ----------------
 include/fmt/format.h | 16 ++++++++++++++++
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 1c56cd44..4e14bced 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -809,22 +809,6 @@ inline Container &get_container(std::back_insert_iterator<Container> it) {
 }
 }  // namespace internal
 
-template <typename OutputIt, typename T = typename OutputIt::value_type>
-class output_range {
- private:
-  OutputIt it_;
-
-  // Unused yet.
-  typedef void sentinel;
-  sentinel end() const;
-
- public:
-  typedef T value_type;
-
-  explicit output_range(OutputIt it): it_(it) {}
-  OutputIt begin() const { return it_; }
-};
-
 // Formatting context.
 template <typename OutputIt, typename Char>
 class basic_context :
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 2a66c9f6..651ddabf 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2727,6 +2727,22 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
   write_padded(n, as, double_writer{n, sign, buffer});
 }
 
+template <typename OutputIt, typename T = typename OutputIt::value_type>
+class output_range {
+ private:
+  OutputIt it_;
+
+  // Unused yet.
+  typedef void sentinel;
+  sentinel end() const;
+
+ public:
+  typedef T value_type;
+
+  explicit output_range(OutputIt it): it_(it) {}
+  OutputIt begin() const { return it_; }
+};
+
 // A range where begin() returns back_insert_iterator.
 template <typename Container>
 class back_insert_range:

From 9710c058aa0bd4903c74eeda121c75c70e363d62 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 09:23:17 -0800
Subject: [PATCH 08/62] Update documentation building script

---
 doc/build.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/build.py b/doc/build.py
index cb8d0c3c..2506e45a 100755
--- a/doc/build.py
+++ b/doc/build.py
@@ -62,8 +62,8 @@ def create_build_env(dirname='virtualenv'):
 def build_docs(version='dev', **kwargs):
   doc_dir = kwargs.get('doc_dir', os.path.dirname(os.path.realpath(__file__)))
   work_dir = kwargs.get('work_dir', '.')
-  include_dir = kwargs.get('include_dir',
-                           os.path.join(os.path.dirname(doc_dir), 'fmt'))
+  include_dir = kwargs.get(
+      'include_dir', os.path.join(os.path.dirname(doc_dir), 'include', 'fmt'))
   # Build docs.
   cmd = ['doxygen', '-']
   p = Popen(cmd, stdin=PIPE)
@@ -74,8 +74,8 @@ def build_docs(version='dev', **kwargs):
       GENERATE_MAN      = NO
       GENERATE_RTF      = NO
       CASE_SENSE_NAMES  = NO
-      INPUT             = {0}/container.h {0}/format.h {0}/ostream.h \
-                          {0}/printf.h {0}/string.h
+      INPUT             = {0}/core.h {0}/format.h {0}/ostream.h \
+                          {0}/printf.h {0}/time.h
       QUIET             = YES
       JAVADOC_AUTOBRIEF = YES
       AUTOLINK_SUPPORT  = NO

From affb35cfb93e2dcafc02b3806bbb6dff821f3cef Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 09:23:47 -0800
Subject: [PATCH 09/62] Replace using with typedef for compatibility with
 gcc-4.6

---
 include/fmt/core.h            | 10 +++++---
 include/fmt/format.h          | 20 +++++++++------
 include/fmt/ostream.h         |  4 +--
 include/fmt/printf.h          | 46 ++++++++++++++++++++---------------
 test/custom-formatter-test.cc |  6 ++---
 test/format-test.cc           | 14 +++++------
 test/ostream-test.cc          |  2 +-
 test/util-test.cc             | 10 ++++----
 8 files changed, 63 insertions(+), 49 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 4e14bced..0079b598 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -854,10 +854,12 @@ class basic_context :
 };
 
 template <typename Char>
-using buffer_context_t = basic_context<
-  std::back_insert_iterator<internal::basic_buffer<Char>>, Char>;
-typedef buffer_context_t<char> context;
-typedef buffer_context_t<wchar_t> wcontext;
+struct buffer_context {
+  typedef basic_context<
+    std::back_insert_iterator<internal::basic_buffer<Char>>, Char> type;
+};
+typedef buffer_context<char>::type context;
+typedef buffer_context<wchar_t>::type wcontext;
 
 namespace internal {
 template <typename Context, typename T>
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 651ddabf..91cf5ab1 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2919,8 +2919,8 @@ inline void format_decimal(char *&buffer, T value) {
 template <typename T, typename Char>
 struct formatter<
     T, Char,
-    typename std::enable_if<
-      internal::format_type<buffer_context_t<Char>, T>::value>::type> {
+    typename std::enable_if<internal::format_type<
+        typename buffer_context<Char>::type, T>::value>::type> {
 
   // Parses format specifiers stopping either at the end of the range or at the
   // terminating '}'.
@@ -2928,7 +2928,8 @@ struct formatter<
   FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) {
     auto it = internal::null_terminating_iterator<Char>(ctx);
     typedef internal::dynamic_specs_handler<ParseContext> handler_type;
-    auto type = internal::get_type<buffer_context_t<Char>, T>::value;
+    auto type = internal::get_type<
+      typename buffer_context<Char>::type, T>::value;
     internal::specs_checker<handler_type>
         handler(handler_type(specs_, ctx), type);
     it = parse_format_specs(it, handler);
@@ -3283,14 +3284,18 @@ inline void format_to(wmemory_buffer &buf, wstring_view format_str,
 }
 
 template <typename OutputIt, typename Char = char>
-using context_t = basic_context<OutputIt, Char>;
+//using context_t = basic_context<OutputIt, Char>;
+struct context_t { typedef basic_context<OutputIt, Char> type; };
 
 template <typename OutputIt, typename Char = char>
-using format_args_t = basic_format_args<context_t<OutputIt, Char>>;
+//using format_args_t = basic_format_args<context_t<OutputIt, Char>>;
+struct format_args_t {
+  typedef basic_format_args<typename context_t<OutputIt, Char>::type> type;
+};
 
 template <typename OutputIt, typename... Args>
 inline OutputIt vformat_to(OutputIt out, string_view format_str,
-                           format_args_t<OutputIt> args) {
+                           typename format_args_t<OutputIt>::type args) {
   typedef output_range<OutputIt, char> range;
   return do_vformat_to<arg_formatter<range>>(range(out), format_str, args);
 }
@@ -3298,7 +3303,8 @@ inline OutputIt vformat_to(OutputIt out, string_view format_str,
 template <typename OutputIt, typename... Args>
 inline OutputIt format_to(OutputIt out, string_view format_str,
                           const Args & ... args) {
-  return vformat_to(out, format_str, *make_args<context_t<OutputIt>>(args...));
+  return vformat_to(out, format_str,
+      *make_args<typename context_t<OutputIt>::type>(args...));
 }
 
 template <typename Container, typename... Args>
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index c93b82ed..922be754 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -104,8 +104,8 @@ struct format_enum<T,
 // Formats an object of type T that has an overloaded ostream operator<<.
 template <typename T, typename Char>
 struct formatter<T, Char,
-    typename std::enable_if<
-      !internal::format_type<buffer_context_t<Char>, T>::value>::type>
+    typename std::enable_if<!internal::format_type<
+      typename buffer_context<Char>::type, T>::value>::type>
     : formatter<basic_string_view<Char>, Char> {
 
   template <typename Context>
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index f25a8b64..531f6864 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -73,7 +73,7 @@ struct make_unsigned_or_bool : std::make_unsigned<T> {};
 
 template <>
 struct make_unsigned_or_bool<bool> {
-  using type = bool;
+  typedef bool type;
 };
 
 template <typename T, typename Context>
@@ -215,10 +215,10 @@ class basic_printf_context;
 template <typename Range>
 class printf_arg_formatter : public internal::arg_formatter_base<Range> {
  private:
-  using char_type = typename Range::value_type;
-  using iterator = decltype(std::declval<Range>().begin());
-  using base = internal::arg_formatter_base<Range>;
-  using context_type = basic_printf_context<iterator, char_type>;
+  typedef typename Range::value_type char_type;
+  typedef decltype(std::declval<Range>().begin()) iterator;
+  typedef internal::arg_formatter_base<Range> base;
+  typedef basic_printf_context<iterator, char_type> context_type;
 
   context_type &context_;
 
@@ -228,7 +228,7 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
   }
 
  public:
-  using format_specs = typename base::format_specs;
+  typedef typename base::format_specs format_specs;
 
   /**
     \rst
@@ -306,16 +306,16 @@ class basic_printf_context :
     OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char> {
  public:
   /** The character type for the output. */
-  using char_type = Char;
+  typedef Char char_type;
 
   template <typename T>
   struct formatter_type { typedef printf_formatter<T> type; };
 
  private:
-  using base = internal::context_base<OutputIt, basic_printf_context, Char>;
-  using format_arg = typename base::format_arg;
-  using format_specs = basic_format_specs<char_type>;
-  using iterator = internal::null_terminating_iterator<char_type>;
+  typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
+  typedef typename base::format_arg format_arg;
+  typedef basic_format_specs<char_type> format_specs;
+  typedef internal::null_terminating_iterator<char_type> iterator;
 
   void parse_flags(format_specs &spec, iterator &it);
 
@@ -534,10 +534,13 @@ void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format,
 }
 
 template <typename Buffer>
-using printf_context = basic_printf_context<
-  std::back_insert_iterator<Buffer>, typename Buffer::value_type>;
+struct printf_context {
+  typedef basic_printf_context<
+    std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
+};
 
-using printf_args = basic_format_args<printf_context<internal::buffer>>;
+typedef basic_format_args<
+  typename printf_context<internal::buffer>::type> printf_args;
 
 inline std::string vsprintf(string_view format, printf_args args) {
   memory_buffer buffer;
@@ -557,12 +560,12 @@ inline std::string vsprintf(string_view format, printf_args args) {
 template <typename... Args>
 inline std::string sprintf(string_view format_str, const Args & ... args) {
   return vsprintf(format_str,
-                  make_args<printf_context<internal::buffer>>(args...));
+    make_args<typename printf_context<internal::buffer>::type>(args...));
 }
 
 inline std::wstring vsprintf(
     wstring_view format,
-    basic_format_args<printf_context<internal::wbuffer>> args) {
+    basic_format_args<typename printf_context<internal::wbuffer>::type> args) {
   wmemory_buffer buffer;
   printf(buffer, format, args);
   return to_string(buffer);
@@ -570,7 +573,8 @@ inline std::wstring vsprintf(
 
 template <typename... Args>
 inline std::wstring sprintf(wstring_view format_str, const Args & ... args) {
-  auto vargs = make_args<printf_context<internal::wbuffer>>(args...);
+  auto vargs = make_args<
+    typename printf_context<internal::wbuffer>::type>(args...);
   return vsprintf(format_str, vargs);
 }
 
@@ -593,7 +597,8 @@ inline int vfprintf(std::FILE *f, string_view format, printf_args args) {
  */
 template <typename... Args>
 inline int fprintf(std::FILE *f, string_view format_str, const Args & ... args) {
-  auto vargs = make_args<printf_context<internal::buffer>>(args...);
+  auto vargs = make_args<
+    typename printf_context<internal::buffer>::type>(args...);
   return vfprintf(f, format_str, vargs);
 }
 
@@ -613,7 +618,7 @@ inline int vprintf(string_view format, printf_args args) {
 template <typename... Args>
 inline int printf(string_view format_str, const Args & ... args) {
   return vprintf(format_str,
-                 make_args<printf_context<internal::buffer>>(args...));
+    make_args<typename printf_context<internal::buffer>::type>(args...));
 }
 
 inline int vfprintf(std::ostream &os, string_view format_str,
@@ -636,7 +641,8 @@ inline int vfprintf(std::ostream &os, string_view format_str,
 template <typename... Args>
 inline int fprintf(std::ostream &os, string_view format_str,
                    const Args & ... args) {
-  auto vargs = make_args<printf_context<internal::buffer>>(args...);
+  auto vargs = make_args<
+    typename printf_context<internal::buffer>::type>(args...);
   return vfprintf(os, format_str, vargs);
 }
 }  // namespace fmt
diff --git a/test/custom-formatter-test.cc b/test/custom-formatter-test.cc
index d44f7002..d8be5375 100644
--- a/test/custom-formatter-test.cc
+++ b/test/custom-formatter-test.cc
@@ -17,9 +17,9 @@ using fmt::printf_arg_formatter;
 class CustomArgFormatter :
     public fmt::arg_formatter<fmt::back_insert_range<fmt::internal::buffer>> {
  public:
-  using range = fmt::back_insert_range<fmt::internal::buffer>;
-  using iterator = decltype(std::declval<range>().begin());
-  using base = fmt::arg_formatter<range>;
+  typedef fmt::back_insert_range<fmt::internal::buffer> range;
+  typedef decltype(std::declval<range>().begin()) iterator;
+  typedef fmt::arg_formatter<range> base;
 
   CustomArgFormatter(fmt::basic_context<iterator, char> &ctx,
                      fmt::format_specs &s)
diff --git a/test/format-test.cc b/test/format-test.cc
index 54fe79ac..b7093e3d 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -89,7 +89,7 @@ void std_format(long double value, std::wstring &result) {
 template <typename Char, typename T>
 ::testing::AssertionResult check_write(const T &value, const char *type) {
   fmt::basic_memory_buffer<Char> buffer;
-  using range = fmt::back_insert_range<fmt::internal::basic_buffer<Char>>;
+  typedef fmt::back_insert_range<fmt::internal::basic_buffer<Char>> range;
   fmt::basic_writer<range> writer(buffer);
   writer.write(value);
   std::basic_string<Char> actual = to_string(buffer);
@@ -1516,7 +1516,7 @@ TEST(FormatTest, FixedEnum) {
 }
 #endif
 
-using buffer_range = fmt::back_insert_range<fmt::internal::buffer>;
+typedef fmt::back_insert_range<fmt::internal::buffer> buffer_range;
 
 class mock_arg_formatter :
     public fmt::internal::arg_formatter_base<buffer_range> {
@@ -1524,8 +1524,8 @@ class mock_arg_formatter :
   MOCK_METHOD1(call, void (int value));
 
  public:
-  using base = fmt::internal::arg_formatter_base<buffer_range>;
-  using range = buffer_range;
+  typedef fmt::internal::arg_formatter_base<buffer_range> base;
+  typedef buffer_range range;
 
   mock_arg_formatter(fmt::context &ctx, fmt::format_specs &s)
     : base(fmt::internal::get_container(ctx.begin()), s) {
@@ -1719,7 +1719,7 @@ FMT_CONSTEXPR test_format_specs_handler parse_test_specs(const char *s) {
 }
 
 TEST(FormatTest, ConstexprParseFormatSpecs) {
-  using handler = test_format_specs_handler;
+  typedef test_format_specs_handler handler;
   static_assert(parse_test_specs("<").align == fmt::ALIGN_LEFT, "");
   static_assert(parse_test_specs("*^").fill == '*', "");
   static_assert(parse_test_specs("+").res == handler::PLUS, "");
@@ -1736,7 +1736,7 @@ TEST(FormatTest, ConstexprParseFormatSpecs) {
 }
 
 struct test_context {
-  using char_type = char;
+  typedef char char_type;
 
   FMT_CONSTEXPR fmt::basic_arg<test_context> next_arg() {
     return fmt::internal::make_arg<test_context>(11);
@@ -1817,7 +1817,7 @@ FMT_CONSTEXPR test_format_specs_handler check_specs(const char *s) {
 }
 
 TEST(FormatTest, ConstexprSpecsChecker) {
-  using handler = test_format_specs_handler;
+  typedef test_format_specs_handler handler;
   static_assert(check_specs("<").align == fmt::ALIGN_LEFT, "");
   static_assert(check_specs("*^").fill == '*', "");
   static_assert(check_specs("+").res == handler::PLUS, "");
diff --git a/test/ostream-test.cc b/test/ostream-test.cc
index 1a0656f5..e42f3344 100644
--- a/test/ostream-test.cc
+++ b/test/ostream-test.cc
@@ -58,7 +58,7 @@ TEST(OStreamTest, Enum) {
   EXPECT_EQ("0", fmt::format("{}", A));
 }
 
-using range = fmt::back_insert_range<fmt::internal::buffer>;
+typedef fmt::back_insert_range<fmt::internal::buffer> range;
 
 struct test_arg_formatter: fmt::arg_formatter<range> {
   test_arg_formatter(fmt::context &ctx, fmt::format_specs &s)
diff --git a/test/util-test.cc b/test/util-test.cc
index 54296a74..5ada007b 100644
--- a/test/util-test.cc
+++ b/test/util-test.cc
@@ -81,7 +81,7 @@ struct formatter<Test, Char> {
     return ctx.begin();
   }
 
-  using iterator = std::back_insert_iterator<basic_buffer<Char>>;
+  typedef std::back_insert_iterator<basic_buffer<Char>> iterator;
 
   auto format(Test, basic_context<iterator, char> &ctx)
       -> decltype(ctx.begin()) {
@@ -436,7 +436,7 @@ TEST(UtilTest, FormatArgs) {
 }
 
 struct custom_context {
-  using char_type = char;
+  typedef char char_type;
 
   template <typename T>
   struct formatter_type {
@@ -525,7 +525,7 @@ VISIT_TYPE(float, double);
 #define CHECK_ARG_(Char, expected, value) { \
   testing::StrictMock<MockVisitor<decltype(expected)>> visitor; \
   EXPECT_CALL(visitor, visit(expected)); \
-  using iterator = std::back_insert_iterator<basic_buffer<Char>>; \
+  typedef std::back_insert_iterator<basic_buffer<Char>> iterator; \
   fmt::visit(visitor, make_arg<fmt::basic_context<iterator, Char>>(value)); \
 }
 
@@ -599,8 +599,8 @@ TEST(UtilTest, PointerArg) {
 
 TEST(UtilTest, CustomArg) {
   ::Test test;
-  using handle = typename fmt::basic_arg<fmt::context>::handle;
-  using visitor = MockVisitor<handle>;
+  typedef typename fmt::basic_arg<fmt::context>::handle handle;
+  typedef MockVisitor<handle> visitor;
   testing::StrictMock<visitor> v;
   EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke([&](handle h) {
     fmt::memory_buffer buffer;

From e9fa42acb8c4edaa6c9891f1d181e0879c149821 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 09:43:54 -0800
Subject: [PATCH 10/62] Fix docs and build issues on gcc-4.6

---
 doc/api.rst        | 21 +++++++++------------
 include/fmt/core.h |  8 ++++----
 2 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index 4c18268c..c1a8bbdc 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -20,7 +20,7 @@ They take *format_str* and *args* as arguments.
 fields surrounded by braces ``{}``. The fields are replaced with formatted
 arguments in the resulting string.
 
-*args* is an argument list representing arbitrary arguments.
+*args* is an argument list representing objects to be formatted.
 
 The `performance of the format API
 <https://github.com/fmtlib/fmt/blob/master/README.rst#speed-tests>`_ is close
@@ -29,18 +29,15 @@ For even better speed use the `write API`_.
 
 .. _format:
 
-.. doxygenfunction:: format(CStringRef, ArgList)
+.. doxygenfunction:: format(string_view, const Args&...)
 
 .. doxygenfunction:: operator""_format(const char *, std::size_t)
 
 .. _print:
 
-.. doxygenfunction:: print(CStringRef, ArgList)
+.. doxygenfunction:: print(string_view, const Args&...)
 
-.. doxygenfunction:: print(std::FILE *, CStringRef, ArgList)
-
-.. doxygenclass:: fmt::BasicFormatter
-   :members:
+.. doxygenfunction:: print(std::FILE *, string_view, const Args&...)
 
 Date and time formatting
 ------------------------
@@ -116,7 +113,7 @@ formatting of user-defined types that have overloaded ``operator<<``::
   std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
   // s == "The date is 2012-12-9"
 
-.. doxygenfunction:: print(std::ostream&, CStringRef, ArgList)
+.. doxygenfunction:: print(std::ostream&, string_view, ArgList)
 
 Argument formatters
 -------------------
@@ -171,13 +168,13 @@ the POSIX extension for positional arguments. Unlike their standard
 counterparts, the ``fmt`` functions are type-safe and throw an exception if an
 argument type doesn't match its format specification.
 
-.. doxygenfunction:: printf(CStringRef, ArgList)
+.. doxygenfunction:: printf(string_view, ArgList)
 
-.. doxygenfunction:: fprintf(std::FILE *, CStringRef, ArgList)
+.. doxygenfunction:: fprintf(std::FILE *, string_view, ArgList)
 
-.. doxygenfunction:: fprintf(std::ostream&, CStringRef, ArgList)
+.. doxygenfunction:: fprintf(std::ostream&, string_view, ArgList)
 
-.. doxygenfunction:: sprintf(CStringRef, ArgList)
+.. doxygenfunction:: sprintf(string_view, ArgList)
 
 .. doxygenclass:: fmt::PrintfFormatter
    :members:
diff --git a/include/fmt/core.h b/include/fmt/core.h
index 0079b598..95d8aac4 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -720,8 +720,8 @@ class arg_map {
     basic_arg<Context> arg;
   };
 
-  entry *map_ = nullptr;
-  unsigned size_ = 0;
+  entry *map_;
+  unsigned size_;
 
   void push_back(value<Context> val) {
     const internal::named_arg_base<char_type> &named = val.as_named_arg();
@@ -730,7 +730,7 @@ class arg_map {
   }
 
  public:
-  arg_map() {}
+  arg_map() : map_(FMT_NULL), size_(0) {}
   void init(const basic_format_args<Context> &args);
   ~arg_map() { delete [] map_; }
 
@@ -791,7 +791,7 @@ class context_base {
   void on_error(const char *message) { parse_context_.on_error(message); }
 
   // Returns an iterator to the beginning of the output range.
-  auto begin() { return out_; }
+  iterator begin() { return out_; }
 
   // Advances the begin iterator to ``it``.
   void advance_to(iterator it) { out_ = it; }

From f3f19e762ff8fb6b97a03f0690ab893a46253b25 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Feb 2018 13:43:16 -0800
Subject: [PATCH 11/62] Update docs

---
 README.rst           |  6 +++---
 doc/api.rst          | 20 ++++++++++----------
 include/fmt/format.h |  2 +-
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/README.rst b/README.rst
index 0b802058..861286cf 100644
--- a/README.rst
+++ b/README.rst
@@ -42,8 +42,8 @@ Features
   performance of IOStreams. See `Speed tests`_ and
   `Fast integer to string conversion in C++
   <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_.
-* Small code size both in terms of source code (the core library consists of a
-  single header file and a single source file) and compiled code.
+* Small code size both in terms of source code (the core library consists of two
+  header files and a single source file) and compiled code.
   See `Compile time and code bloat`_.
 * Reliability: the library has an extensive set of `unit tests
   <https://github.com/fmtlib/fmt/tree/master/test>`_.
@@ -101,7 +101,7 @@ Format strings can be checked at compile time:
           on_error("argument index out of range");
           ^
 
-fmt can be used as a safe portable replacement for ``itoa``:
+{fmt} can be used as a safe portable replacement for ``itoa``:
 
 .. code:: c++
 
diff --git a/doc/api.rst b/doc/api.rst
index c1a8bbdc..45408d38 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -11,7 +11,7 @@ namespace is usually omitted in examples.
 Format API
 ==========
 
-The following functions defined in ``fmt/format.h`` use :ref:`format string
+The following functions defined in ``fmt/core.h`` use :ref:`format string
 syntax <syntax>` similar to the one used by Python's `str.format
 <http://docs.python.org/3/library/stdtypes.html#str.format>`_ function.
 They take *format_str* and *args* as arguments.
@@ -71,7 +71,7 @@ template and implement ``parse`` and ``format`` methods::
 
     template <typename FormatContext>
     auto format(const MyStruct &s, FormatContext &ctx) {
-      fmt::format_to(ctx.begin(), "[MyStruct: x={:.1f}, y={:.2f}]", s.x, s.y);
+      return format_to(ctx.begin(), "[MyStruct: x={:.1f}, y={:.2f}]", s.x, s.y);
     }
   };
   }
@@ -84,7 +84,7 @@ Then you can pass objects of type ``MyStruct`` to any formatting function::
 
 In the example above the ``formatter<MyStruct>::parse`` function ignores the
 contents of the format string referred to by ``ctx.begin()`` so the object will
-always be formatted as specified. See ``formatter<tm>::parse`` in
+always be formatted in the same way. See ``formatter<tm>::parse`` in
 :file:`fmt/time.h` for an advanced example of how to parse the format string and
 customize the formatted output.
 
@@ -113,7 +113,7 @@ formatting of user-defined types that have overloaded ``operator<<``::
   std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
   // s == "The date is 2012-12-9"
 
-.. doxygenfunction:: print(std::ostream&, string_view, ArgList)
+.. doxygenfunction:: print(std::ostream&, string_view, const Args&...)
 
 Argument formatters
 -------------------
@@ -168,13 +168,13 @@ the POSIX extension for positional arguments. Unlike their standard
 counterparts, the ``fmt`` functions are type-safe and throw an exception if an
 argument type doesn't match its format specification.
 
-.. doxygenfunction:: printf(string_view, ArgList)
+.. doxygenfunction:: printf(string_view, const Args&...)
 
-.. doxygenfunction:: fprintf(std::FILE *, string_view, ArgList)
+.. doxygenfunction:: fprintf(std::FILE *, string_view, const Args&...)
 
-.. doxygenfunction:: fprintf(std::ostream&, string_view, ArgList)
+.. doxygenfunction:: fprintf(std::ostream&, string_view, const Args&...)
 
-.. doxygenfunction:: sprintf(string_view, ArgList)
+.. doxygenfunction:: sprintf(string_view, const Args&...)
 
 .. doxygenclass:: fmt::PrintfFormatter
    :members:
@@ -246,12 +246,12 @@ Utilities
 System errors
 =============
 
-.. doxygenclass:: fmt::SystemError
+.. doxygenclass:: fmt::system_error
    :members:
 
 .. doxygenfunction:: fmt::format_system_error
 
-.. doxygenclass:: fmt::WindowsError
+.. doxygenclass:: fmt::windows_error
    :members:
 
 .. _formatstrings:
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 91cf5ab1..ccd12f03 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -3233,7 +3233,7 @@ auto join(const Range &range, wstring_view sep)
 
   **Example**::
 
-    #include "fmt/string.h"
+    #include "fmt/format.h"
 
     std::string answer = fmt::to_string(42);
   \endrst

From 229887bd407f822fc093de6a638a369ac936d549 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 14 Feb 2018 05:46:41 -0800
Subject: [PATCH 12/62] Make constexpr remove_prefix gcc version check tighter
 (#648)

---
 include/fmt/core.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 95d8aac4..efd44385 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -147,9 +147,10 @@
     (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
 # include <string_view>
 namespace fmt { using std::basic_string_view; }
-// std::experimental::basic_string_view::remove_prefix isn't constexpr in gcc 6.
+// std::experimental::basic_string_view::remove_prefix isn't constexpr until
+// gcc 7.3.
 #elif (FMT_HAS_INCLUDE(<experimental/string_view>) && \
-       (FMT_GCC_VERSION == 0 || FMT_GCC_VERSION >= 700) && \
+       (FMT_GCC_VERSION == 0 || FMT_GCC_VERSION >= 730) && \
        __cplusplus >= 201402L)
 # include <experimental/string_view>
 namespace fmt { using std::experimental::basic_string_view; }
@@ -1065,8 +1066,8 @@ inline internal::named_arg<T, wchar_t> arg(wstring_view name, const T &arg) {
 
 // This function template is deleted intentionally to disable nested named
 // arguments as in ``format("{}", arg("a", arg("b", 42)))``.
-template <typename S, typename... T>
-void arg(S, internal::named_arg<T...>) FMT_DELETED;
+template <typename S, typename T, typename Char>
+void arg(S, internal::named_arg<T, Char>) FMT_DELETED;
 
 enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
 

From 24d66c5d654cb6efe86aa7179ef76a350c010dca Mon Sep 17 00:00:00 2001
From: Alex Alabuzhev <alabuzhev@gmail.com>
Date: Wed, 14 Feb 2018 23:30:55 +0000
Subject: [PATCH 13/62] compilation fix & warnings

---
 include/fmt/core.h   | 15 ++++++---------
 include/fmt/format.h | 20 +++++++++++++-------
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index efd44385..fef420d2 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -346,7 +346,7 @@ class container_buffer : public basic_buffer<typename Container::value_type> {
   Container &container_;
 
  protected:
-  virtual void grow(std::size_t capacity) {
+  void grow(std::size_t capacity) FMT_OVERRIDE {
     container_.resize(capacity);
     this->set(&container_[0], capacity);
   }
@@ -801,10 +801,10 @@ class context_base {
 // Extracts a reference to the container from back_insert_iterator.
 template <typename Container>
 inline Container &get_container(std::back_insert_iterator<Container> it) {
-  typedef std::back_insert_iterator<Container> iterator;
-  struct accessor: iterator {
-    accessor(iterator it) : iterator(it) {}
-    using iterator::container;
+  typedef std::back_insert_iterator<Container> bi_iterator;
+  struct accessor: bi_iterator {
+    accessor(bi_iterator it) : bi_iterator(it) {}
+    using bi_iterator::container;
   };
   return *accessor(it).container;
 }
@@ -865,11 +865,8 @@ typedef buffer_context<wchar_t>::type wcontext;
 namespace internal {
 template <typename Context, typename T>
 class get_type {
- private:
-  static const T& val();
-
  public:
-  typedef decltype(make_value<Context>(val())) value_type;
+  typedef decltype(make_value<Context>(std::declval<typename std::decay<T>::type&>())) value_type;
   static const type value = value_type::type_tag;
 };
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index ccd12f03..e1c3e155 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -382,7 +382,7 @@ class basic_memory_buffer: private Allocator, public internal::basic_buffer<T> {
   }
 
  protected:
-  void grow(std::size_t size);
+  void grow(std::size_t size) FMT_OVERRIDE;
 
  public:
   explicit basic_memory_buffer(const Allocator &alloc = Allocator())
@@ -494,7 +494,7 @@ class basic_fixed_buffer : public internal::basic_buffer<Char> {
   }
 
  protected:
-  FMT_API void grow(std::size_t size);
+  FMT_API void grow(std::size_t size) FMT_OVERRIDE;
 };
 
 namespace internal {
@@ -567,7 +567,7 @@ template <typename Char>
 class null_terminating_iterator;
 
 template <typename Char>
-FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it);
+FMT_CONSTEXPR_DECL const Char *pointer_from(null_terminating_iterator<Char> it);
 
 // An iterator that produces a null terminator on *end. This simplifies parsing
 // and allows comparing the performance of processing a null-terminated string
@@ -642,7 +642,13 @@ class null_terminating_iterator {
     return ptr_ >= other.ptr_;
   }
 
+  // 'fmt::internal::pointer_from': the inline specifier cannot be used
+  // when a friend declaration refers to a specialization of a function
+
+  // pointer_from is defined with the inline specifier, but declared without,
+  // so this looks like a bug in the compiler.
   friend FMT_CONSTEXPR_DECL const Char *pointer_from<Char>(
+# pragma warning(suppress: 4396)
       null_terminating_iterator it);
 
  private:
@@ -1360,7 +1366,7 @@ class arg_formatter_base {
   }
 
   void write(const char_type *value) {
-    auto length = value != 0 ? std::char_traits<char_type>::length(value) : 0;
+    auto length = value != FMT_NULL ? std::char_traits<char_type>::length(value) : 0;
     writer_.write_str(basic_string_view<char_type>(value, length), specs_);
   }
 
@@ -2220,7 +2226,7 @@ class basic_writer {
   struct padded_int_writer {
     string_view prefix;
     wchar_t fill;
-    unsigned padding;
+    std::size_t padding;
     F f;
 
     template <typename It>
@@ -2238,9 +2244,9 @@ class basic_writer {
   template <typename Spec, typename F>
   void write_int(unsigned num_digits, string_view prefix,
                  const Spec &spec, F f) {
-    unsigned size = prefix.size() + num_digits;
+    std::size_t size = prefix.size() + num_digits;
     auto fill = spec.fill();
-    unsigned padding = 0;
+    std::size_t padding = 0;
     if (spec.align() == ALIGN_NUMERIC) {
       if (spec.width() > size) {
         padding = spec.width() - size;

From 7d2723d57c07affc86e5cf0aa85e70e2306f8b40 Mon Sep 17 00:00:00 2001
From: Andrew Gunnerson <andrewgunnerson@gmail.com>
Date: Thu, 15 Feb 2018 20:26:24 -0500
Subject: [PATCH 14/62] posix.cc: Fix compilation with -fno-exceptions

Signed-off-by: Andrew Gunnerson <andrewgunnerson@gmail.com>
---
 include/fmt/posix.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/fmt/posix.cc b/include/fmt/posix.cc
index a7a255ac..67513b07 100644
--- a/include/fmt/posix.cc
+++ b/include/fmt/posix.cc
@@ -180,8 +180,8 @@ void fmt::File::dup2(int fd) {
   int result = 0;
   FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
   if (result == -1) {
-    throw system_error(errno,
-      "cannot duplicate file descriptor {} to {}", fd_, fd);
+    FMT_THROW(system_error(errno,
+      "cannot duplicate file descriptor {} to {}", fd_, fd));
   }
 }
 

From 4ba3f7db82618db7c3de40aec767a72931cf3f7d Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Thu, 15 Feb 2018 18:52:44 -0800
Subject: [PATCH 15/62] Update docs

---
 doc/api.rst | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index 45408d38..5112b56d 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -176,15 +176,6 @@ argument type doesn't match its format specification.
 
 .. doxygenfunction:: sprintf(string_view, const Args&...)
 
-.. doxygenclass:: fmt::PrintfFormatter
-   :members:
-
-.. doxygenclass:: fmt::BasicPrintfArgFormatter
-   :members:
-
-.. doxygenclass:: fmt::PrintfArgFormatter
-   :members:
-
 Write API
 =========
 

From 8ed264fcd49de5716204e77c6293e1a7aef46906 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Fri, 16 Feb 2018 17:20:33 +0000
Subject: [PATCH 16/62] Rename type enum constants to prevent collision with
 poorly written C libs (#644)

---
 include/fmt/core.h   | 95 +++++++++++++++++++++++---------------------
 include/fmt/format.h | 78 ++++++++++++++++++------------------
 test/format-test.cc  |  2 +-
 3 files changed, 89 insertions(+), 86 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index fef420d2..27bce7a9 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -394,22 +394,23 @@ template <typename T, typename Char>
 struct is_named_arg<named_arg<T, Char>> : std::true_type {};
 
 enum type {
-  NONE, NAMED_ARG,
+  none_type, name_arg_type,
   // Integer types should go first,
-  INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
+  int_type, uint_type, long_long_type, ulong_long_type, bool_type, char_type,
+  last_integer_type = char_type,
   // followed by floating-point types.
-  DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
-  CSTRING, STRING, POINTER, CUSTOM
+  double_type, long_double_type, last_numeric_type = long_double_type,
+  cstring_type, string_type, pointer_type, custom_type
 };
 
 FMT_CONSTEXPR bool is_integral(type t) {
-  FMT_ASSERT(t != internal::NAMED_ARG, "invalid argument type");
-  return t > internal::NONE && t <= internal::LAST_INTEGER_TYPE;
+  FMT_ASSERT(t != internal::name_arg_type, "invalid argument type");
+  return t > internal::none_type && t <= internal::last_integer_type;
 }
 
 FMT_CONSTEXPR bool is_arithmetic(type t) {
-  FMT_ASSERT(t != internal::NAMED_ARG, "invalid argument type");
-  return t > internal::NONE && t <= internal::LAST_NUMERIC_TYPE;
+  FMT_ASSERT(t != internal::name_arg_type, "invalid argument type");
+  return t > internal::none_type && t <= internal::last_numeric_type;
 }
 
 template <typename T, bool ENABLE = true>
@@ -519,61 +520,63 @@ template <typename Context, typename T>
 FMT_CONSTEXPR basic_arg<Context> make_arg(const T &value);
 
 #define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \
-  template <typename C, typename char_type = typename C::char_type> \
+  template <typename C, typename Char = typename C::char_type> \
   FMT_CONSTEXPR typed_value<C, TAG> make_value(ArgType val) { \
     return static_cast<ValueType>(val); \
   }
 
-FMT_MAKE_VALUE(BOOL, bool, int)
-FMT_MAKE_VALUE(INT, short, int)
-FMT_MAKE_VALUE(UINT, unsigned short, unsigned)
-FMT_MAKE_VALUE(INT, int, int)
-FMT_MAKE_VALUE(UINT, unsigned, unsigned)
+FMT_MAKE_VALUE(bool_type, bool, int)
+FMT_MAKE_VALUE(int_type, short, int)
+FMT_MAKE_VALUE(uint_type, unsigned short, unsigned)
+FMT_MAKE_VALUE(int_type, int, int)
+FMT_MAKE_VALUE(uint_type, unsigned, unsigned)
 
 // To minimize the number of types we need to deal with, long is translated
 // either to int or to long long depending on its size.
 typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
         long_type;
-FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? INT : LONG_LONG), long, long_type)
+FMT_MAKE_VALUE(
+    (sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type)
 typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
                          unsigned, unsigned long long>::type ulong_type;
-FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? UINT : ULONG_LONG),
+FMT_MAKE_VALUE(
+    (sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type),
     unsigned long, ulong_type)
 
-FMT_MAKE_VALUE(LONG_LONG, long long, long long)
-FMT_MAKE_VALUE(ULONG_LONG, unsigned long long, unsigned long long)
-FMT_MAKE_VALUE(INT, signed char, int)
-FMT_MAKE_VALUE(UINT, unsigned char, unsigned)
-FMT_MAKE_VALUE(CHAR, char, int)
+FMT_MAKE_VALUE(long_long_type, long long, long long)
+FMT_MAKE_VALUE(ulong_long_type, unsigned long long, unsigned long long)
+FMT_MAKE_VALUE(int_type, signed char, int)
+FMT_MAKE_VALUE(uint_type, unsigned char, unsigned)
+FMT_MAKE_VALUE(char_type, char, int)
 
 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
 template <typename C>
-inline typed_value<C, CHAR> make_value(wchar_t val) {
+inline typed_value<C, char_type> make_value(wchar_t val) {
   require_wchar<typename C::char_type>();
   return static_cast<int>(val);
 }
 #endif
 
-FMT_MAKE_VALUE(DOUBLE, float, double)
-FMT_MAKE_VALUE(DOUBLE, double, double)
-FMT_MAKE_VALUE(LONG_DOUBLE, long double, long double)
+FMT_MAKE_VALUE(double_type, float, double)
+FMT_MAKE_VALUE(double_type, double, double)
+FMT_MAKE_VALUE(long_double_type, long double, long double)
 
 // Formatting of wide strings into a narrow buffer and multibyte strings
 // into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606).
-FMT_MAKE_VALUE(CSTRING, char_type*, const char_type*)
-FMT_MAKE_VALUE(CSTRING, const char_type*, const char_type*)
+FMT_MAKE_VALUE(cstring_type, Char*, const Char*)
+FMT_MAKE_VALUE(cstring_type, const Char*, const Char*)
 
-FMT_MAKE_VALUE(CSTRING, signed char*, const signed char*)
-FMT_MAKE_VALUE(CSTRING, const signed char*, const signed char*)
-FMT_MAKE_VALUE(CSTRING, unsigned char*, const unsigned char*)
-FMT_MAKE_VALUE(CSTRING, const unsigned char*, const unsigned char*)
-FMT_MAKE_VALUE(STRING, basic_string_view<char_type>,
-               basic_string_view<char_type>)
-FMT_MAKE_VALUE(STRING, const std::basic_string<char_type>&,
-               basic_string_view<char_type>)
-FMT_MAKE_VALUE(POINTER, void*, const void*)
-FMT_MAKE_VALUE(POINTER, const void*, const void*)
-FMT_MAKE_VALUE(POINTER, std::nullptr_t, const void*)
+FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
+FMT_MAKE_VALUE(cstring_type, const signed char*, const signed char*)
+FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
+FMT_MAKE_VALUE(cstring_type, const unsigned char*, const unsigned char*)
+FMT_MAKE_VALUE(string_type, basic_string_view<Char>,
+               basic_string_view<Char>)
+FMT_MAKE_VALUE(string_type, const std::basic_string<Char>&,
+               basic_string_view<Char>)
+FMT_MAKE_VALUE(pointer_type, void*, const void*)
+FMT_MAKE_VALUE(pointer_type, const void*, const void*)
+FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
 
 // Formatting of arbitrary pointers is disallowed. If you want to output a
 // pointer cast it to "void *" or "const void *". In particular, this forbids
@@ -587,16 +590,16 @@ void make_value(const T *p) {
 template <typename C, typename T>
 inline typename std::enable_if<
     convert_to_int<T>::value && std::is_enum<T>::value,
-    typed_value<C, INT>>::type
+    typed_value<C, int_type>>::type
   make_value(const T &val) { return static_cast<int>(val); }
 
 template <typename C, typename T>
 inline typename std::enable_if<
-    !convert_to_int<T>::value, typed_value<C, CUSTOM>>::type
+    !convert_to_int<T>::value, typed_value<C, custom_type>>::type
   make_value(const T &val) { return val; }
 
 template <typename C, typename T>
-typed_value<C, NAMED_ARG>
+typed_value<C, name_arg_type>
     make_value(const named_arg<T, typename C::char_type> &val) {
   basic_arg<C> arg = make_arg<C>(val.value);
   std::memcpy(val.data, &arg, sizeof(arg));
@@ -641,17 +644,17 @@ class basic_arg {
     internal::custom_value<Context> custom_;
   };
 
-  FMT_CONSTEXPR basic_arg() : type_(internal::NONE) {}
+  FMT_CONSTEXPR basic_arg() : type_(internal::none_type) {}
 
   explicit operator bool() const FMT_NOEXCEPT {
-    return type_ != internal::NONE;
+    return type_ != internal::none_type;
   }
 
   internal::type type() const { return type_; }
 
   bool is_integral() const { return internal::is_integral(type_); }
   bool is_arithmetic() const { return internal::is_arithmetic(type_); }
-  bool is_pointer() const { return type_ == internal::POINTER; }
+  bool is_pointer() const { return type_ == internal::pointer_type; }
 };
 
 // Parsing context consisting of a format string range being parsed and an
@@ -982,7 +985,7 @@ class basic_format_args {
     if (index > internal::MAX_PACKED_ARGS)
       return arg;
     arg.type_ = type(index);
-    if (arg.type_ == internal::NONE)
+    if (arg.type_ == internal::none_type)
       return arg;
     internal::value<Context> &val = arg.value_;
     val = values_[index];
@@ -1001,7 +1004,7 @@ class basic_format_args {
   /** Returns the argument at specified index. */
   format_arg operator[](size_type index) const {
     format_arg arg = get(index);
-    return arg.type_ == internal::NAMED_ARG ?
+    return arg.type_ == internal::name_arg_type ?
           arg.value_.as_named_arg().template deserialize<Context>() : arg;
   }
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index e1c3e155..c6120fa7 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -1006,35 +1006,35 @@ FMT_CONSTEXPR typename std::result_of<Visitor(int)>::type
     visit(Visitor &&vis, basic_arg<Context> arg) {
   typedef typename Context::char_type char_type;
   switch (arg.type_) {
-  case internal::NONE:
+  case internal::none_type:
     return vis(monostate());
-  case internal::NAMED_ARG:
+  case internal::name_arg_type:
     FMT_ASSERT(false, "invalid argument type");
     break;
-  case internal::INT:
+  case internal::int_type:
     return vis(arg.value_.int_value);
-  case internal::UINT:
+  case internal::uint_type:
     return vis(arg.value_.uint_value);
-  case internal::LONG_LONG:
+  case internal::long_long_type:
     return vis(arg.value_.long_long_value);
-  case internal::ULONG_LONG:
+  case internal::ulong_long_type:
     return vis(arg.value_.ulong_long_value);
-  case internal::BOOL:
+  case internal::bool_type:
     return vis(arg.value_.int_value != 0);
-  case internal::CHAR:
+  case internal::char_type:
     return vis(static_cast<char_type>(arg.value_.int_value));
-  case internal::DOUBLE:
+  case internal::double_type:
     return vis(arg.value_.double_value);
-  case internal::LONG_DOUBLE:
+  case internal::long_double_type:
     return vis(arg.value_.long_double_value);
-  case internal::CSTRING:
+  case internal::cstring_type:
     return vis(arg.value_.string.value);
-  case internal::STRING:
+  case internal::string_type:
     return vis(basic_string_view<char_type>(
                  arg.value_.string.value, arg.value_.string.size));
-  case internal::POINTER:
+  case internal::pointer_type:
     return vis(arg.value_.pointer);
-  case internal::CUSTOM:
+  case internal::custom_type:
     return vis(typename basic_arg<Context>::handle(arg.value_.custom));
   }
   return typename std::result_of<Visitor(int)>::type();
@@ -1293,14 +1293,14 @@ void arg_map<Context>::init(const basic_format_args<Context> &args) {
   if (map_)
     return;
   map_ = new entry[args.max_size()];
-  bool use_values = args.type(MAX_PACKED_ARGS - 1) == internal::NONE;
+  bool use_values = args.type(MAX_PACKED_ARGS - 1) == internal::none_type;
   if (use_values) {
     for (unsigned i = 0;/*nothing*/; ++i) {
       internal::type arg_type = args.type(i);
       switch (arg_type) {
-        case internal::NONE:
+        case internal::none_type:
           return;
-        case internal::NAMED_ARG:
+        case internal::name_arg_type:
           push_back(args.values_[i]);
           break;
         default:
@@ -1310,14 +1310,14 @@ void arg_map<Context>::init(const basic_format_args<Context> &args) {
     return;
   }
   for (unsigned i = 0; i != MAX_PACKED_ARGS; ++i) {
-    if (args.type(i) == internal::NAMED_ARG)
+    if (args.type(i) == internal::name_arg_type)
       push_back(args.args_[i].value_);
   }
   for (unsigned i = MAX_PACKED_ARGS; ; ++i) {
     switch (args.args_[i].type_) {
-      case internal::NONE:
+      case internal::none_type:
         return;
-      case internal::NAMED_ARG:
+      case internal::name_arg_type:
         push_back(args.args_[i].value_);
         break;
       default:
@@ -1614,7 +1614,7 @@ class specs_checker : public Handler {
   }
 
   FMT_CONSTEXPR void end_precision() {
-    if (is_integral(arg_type_) || arg_type_ == POINTER)
+    if (is_integral(arg_type_) || arg_type_ == pointer_type)
       this->on_error("precision not allowed for this argument type");
   }
 
@@ -1626,8 +1626,8 @@ class specs_checker : public Handler {
 
   FMT_CONSTEXPR void check_sign() {
     require_numeric_argument();
-    if (is_integral(arg_type_) && arg_type_ != INT && arg_type_ != LONG_LONG &&
-        arg_type_ != CHAR) {
+    if (is_integral(arg_type_) && arg_type_ != int_type &&
+        arg_type_ != long_long_type && arg_type_ != char_type) {
       this->on_error("format specifier requires signed argument");
     }
   }
@@ -2062,7 +2062,7 @@ FMT_CONSTEXPR bool check_format_string(
 // because of a bug in MSVC.
 template <typename Context, typename T>
 struct format_type :
-  std::integral_constant<bool, get_type<Context, T>::value != CUSTOM> {};
+  std::integral_constant<bool, get_type<Context, T>::value != custom_type> {};
 
 // Specifies whether to format enums.
 template <typename T, typename Enable = void>
@@ -2942,38 +2942,38 @@ struct formatter<
     auto type_spec = specs_.type();
     auto eh = ctx.error_handler();
     switch (type) {
-    case internal::NONE:
-    case internal::NAMED_ARG:
+    case internal::none_type:
+    case internal::name_arg_type:
       FMT_ASSERT(false, "invalid argument type");
       break;
-    case internal::INT:
-    case internal::UINT:
-    case internal::LONG_LONG:
-    case internal::ULONG_LONG:
-    case internal::BOOL:
+    case internal::int_type:
+    case internal::uint_type:
+    case internal::long_long_type:
+    case internal::ulong_long_type:
+    case internal::bool_type:
       handle_int_type_spec(
             type_spec, internal::int_type_checker<decltype(eh)>(eh));
       break;
-    case internal::CHAR:
+    case internal::char_type:
       handle_char_specs(specs_, internal::char_specs_checker<decltype(eh)>(
                           type_spec, eh));
       break;
-    case internal::DOUBLE:
-    case internal::LONG_DOUBLE:
+    case internal::double_type:
+    case internal::long_double_type:
       handle_float_type_spec(
             type_spec, internal::float_type_checker<decltype(eh)>(eh));
       break;
-    case internal::CSTRING:
+    case internal::cstring_type:
       internal::handle_cstring_type_spec(
             type_spec, internal::cstring_type_checker<decltype(eh)>(eh));
       break;
-    case internal::STRING:
+    case internal::string_type:
       internal::check_string_type_spec(type_spec, eh);
       break;
-    case internal::POINTER:
+    case internal::pointer_type:
       internal::check_pointer_type_spec(type_spec, eh);
       break;
-    case internal::CUSTOM:
+    case internal::custom_type:
       // Custom format specifiers should be checked in parse functions of
       // formatter specializations.
       break;
@@ -3080,7 +3080,7 @@ typename basic_context<Range, Char>::format_arg
   basic_context<Range, Char>::get_arg(basic_string_view<char_type> name) {
   map_.init(this->args());
   format_arg arg = map_.find(name);
-  if (arg.type() == internal::NONE)
+  if (arg.type() == internal::none_type)
     this->on_error("argument not found");
   return arg;
 }
diff --git a/test/format-test.cc b/test/format-test.cc
index b7093e3d..67f6da35 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1811,7 +1811,7 @@ TEST(FormatTest, ConstexprDynamicSpecsHandler) {
 
 FMT_CONSTEXPR test_format_specs_handler check_specs(const char *s) {
   fmt::internal::specs_checker<test_format_specs_handler>
-      checker(test_format_specs_handler(), fmt::internal::DOUBLE);
+      checker(test_format_specs_handler(), fmt::internal::double_type);
   parse_format_specs(s, checker);
   return checker;
 }

From 1efc15c177f57f0571d12cd494804af9e9de928a Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Fri, 16 Feb 2018 18:13:54 +0000
Subject: [PATCH 17/62] Fix MSVC build

---
 include/fmt/format.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index c6120fa7..89834476 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -1627,7 +1627,7 @@ class specs_checker : public Handler {
   FMT_CONSTEXPR void check_sign() {
     require_numeric_argument();
     if (is_integral(arg_type_) && arg_type_ != int_type &&
-        arg_type_ != long_long_type && arg_type_ != char_type) {
+        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
       this->on_error("format specifier requires signed argument");
     }
   }

From 91721caa42a7d509974d9938fc76a29adf9101a6 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 17 Feb 2018 09:03:43 +0000
Subject: [PATCH 18/62] Add detection of wostream operator<< (#650)

---
 include/fmt/core.h    | 12 ++++++------
 include/fmt/ostream.h | 11 ++++++-----
 test/ostream-test.cc  |  2 +-
 test/util-test.cc     |  8 ++++----
 4 files changed, 17 insertions(+), 16 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 27bce7a9..bda0e078 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -413,7 +413,7 @@ FMT_CONSTEXPR bool is_arithmetic(type t) {
   return t > internal::none_type && t <= internal::last_numeric_type;
 }
 
-template <typename T, bool ENABLE = true>
+template <typename T, typename Char, bool ENABLE = true>
 struct convert_to_int {
   enum {
    value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
@@ -421,8 +421,8 @@ struct convert_to_int {
 };
 
 #define FMT_DISABLE_CONVERSION_TO_INT(Type) \
-  template <> \
-  struct convert_to_int<Type> { enum { value = 0 }; }
+  template <typename Char> \
+  struct convert_to_int<Type, Char> { enum { value = 0 }; }
 
 // Silence warnings about convering float to int.
 FMT_DISABLE_CONVERSION_TO_INT(float);
@@ -589,13 +589,13 @@ void make_value(const T *p) {
 
 template <typename C, typename T>
 inline typename std::enable_if<
-    convert_to_int<T>::value && std::is_enum<T>::value,
+    convert_to_int<T, typename C::char_type>::value && std::is_enum<T>::value,
     typed_value<C, int_type>>::type
   make_value(const T &val) { return static_cast<int>(val); }
 
 template <typename C, typename T>
-inline typename std::enable_if<
-    !convert_to_int<T>::value, typed_value<C, custom_type>>::type
+inline typename std::enable_if<!convert_to_int<
+    T, typename C::char_type>::value, typed_value<C, custom_type>>::type
   make_value(const T &val) { return val; }
 
 template <typename C, typename T>
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index 922be754..16d490b2 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -46,21 +46,22 @@ class FormatBuf : public std::basic_streambuf<Char> {
   }
 };
 
-struct test_stream : std::ostream {
+template <typename Char>
+struct test_stream : std::basic_ostream<Char> {
  private:
   struct null;
-  // Hide all operator<< from std::ostream.
+  // Hide all operator<< from std::basic_ostream<Char>.
   void operator<<(null);
 };
 
 // Disable conversion to int if T has an overloaded operator<< which is a free
 // function (not a member of std::ostream).
-template <typename T>
-class convert_to_int<T, true> {
+template <typename T, typename Char>
+class convert_to_int<T, Char, true> {
  private:
   template <typename U>
   static decltype(
-    std::declval<test_stream&>() << std::declval<U>(), std::true_type())
+    std::declval<test_stream<Char>&>() << std::declval<U>(), std::true_type())
       test(int);
 
   template <typename>
diff --git a/test/ostream-test.cc b/test/ostream-test.cc
index e42f3344..41f65396 100644
--- a/test/ostream-test.cc
+++ b/test/ostream-test.cc
@@ -53,7 +53,7 @@ std::ostream &operator<<(std::ostream &os, TestEnum) {
 enum TestEnum2 {A};
 
 TEST(OStreamTest, Enum) {
-  EXPECT_FALSE(fmt::internal::convert_to_int<TestEnum>::value);
+  EXPECT_FALSE((fmt::internal::convert_to_int<TestEnum, char>::value));
   EXPECT_EQ("TestEnum", fmt::format("{}", TestEnum()));
   EXPECT_EQ("0", fmt::format("{}", A));
 }
diff --git a/test/util-test.cc b/test/util-test.cc
index 5ada007b..6a16096b 100644
--- a/test/util-test.cc
+++ b/test/util-test.cc
@@ -843,15 +843,15 @@ TEST(UtilTest, ReportWindowsError) {
 enum TestEnum2 {};
 
 TEST(UtilTest, ConvertToInt) {
-  EXPECT_FALSE(fmt::internal::convert_to_int<char>::value);
-  EXPECT_FALSE(fmt::internal::convert_to_int<const char *>::value);
-  EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum2>::value);
+  EXPECT_FALSE((fmt::internal::convert_to_int<char, char>::value));
+  EXPECT_FALSE((fmt::internal::convert_to_int<const char *, char>::value));
+  EXPECT_TRUE((fmt::internal::convert_to_int<TestEnum2, char>::value));
 }
 
 #if FMT_USE_ENUM_BASE
 enum TestEnum : char {TestValue};
 TEST(UtilTest, IsEnumConvertibleToInt) {
-  EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum>::value);
+  EXPECT_TRUE((fmt::internal::convert_to_int<TestEnum, char>::value));
 }
 #endif
 

From ce4a65ffea258c52f3fa1fba63f2375a1241d4ab Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 17 Feb 2018 09:38:46 +0000
Subject: [PATCH 19/62] Add pointer support to basic_writer

---
 include/fmt/format.h | 8 ++++++++
 test/format-test.cc  | 1 +
 2 files changed, 9 insertions(+)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 89834476..f77b51c6 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2553,6 +2553,14 @@ class basic_writer {
   void write(basic_string_view<char_type> str, FormatSpecs... specs) {
     write_str(str, format_specs(specs...));
   }
+
+  template <typename T>
+  typename std::enable_if<std::is_same<T, void>::value>::type write(const T* p) {
+    format_specs specs;
+    specs.flags_ = HASH_FLAG;
+    specs.type_ = 'x';
+    write_int(reinterpret_cast<uintptr_t>(p), specs);
+  }
 };
 
 template <typename Range>
diff --git a/test/format-test.cc b/test/format-test.cc
index 67f6da35..56a1f879 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1609,6 +1609,7 @@ TEST(FormatTest, UdlTemplate) {
 
 TEST(FormatTest, ToString) {
   EXPECT_EQ("42", fmt::to_string(42));
+  EXPECT_EQ("0x1234", fmt::to_string(reinterpret_cast<void*>(0x1234)));
 }
 
 TEST(FormatTest, ToWString) {

From 18ac98700edc60a4401ebe18bff6a64420fe7e8c Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 17 Feb 2018 12:57:18 +0000
Subject: [PATCH 20/62] Fix formatting of objects convertible to std::string

---
 include/fmt/core.h  | 13 +++++++------
 test/format-test.cc | 10 ++++++++++
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index bda0e078..2f309501 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -570,9 +570,8 @@ FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
 FMT_MAKE_VALUE(cstring_type, const signed char*, const signed char*)
 FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
 FMT_MAKE_VALUE(cstring_type, const unsigned char*, const unsigned char*)
-FMT_MAKE_VALUE(string_type, basic_string_view<Char>,
-               basic_string_view<Char>)
-FMT_MAKE_VALUE(string_type, const std::basic_string<Char>&,
+FMT_MAKE_VALUE(string_type, basic_string_view<Char>, basic_string_view<Char>)
+FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
                basic_string_view<Char>)
 FMT_MAKE_VALUE(pointer_type, void*, const void*)
 FMT_MAKE_VALUE(pointer_type, const void*, const void*)
@@ -593,9 +592,11 @@ inline typename std::enable_if<
     typed_value<C, int_type>>::type
   make_value(const T &val) { return static_cast<int>(val); }
 
-template <typename C, typename T>
-inline typename std::enable_if<!convert_to_int<
-    T, typename C::char_type>::value, typed_value<C, custom_type>>::type
+template <typename C, typename T, typename Char = typename C::char_type>
+inline typename std::enable_if<
+    !convert_to_int<T, Char>::value &&
+    !std::is_convertible<T, std::basic_string<Char>>::value,
+    typed_value<C, custom_type>>::type
   make_value(const T &val) { return val; }
 
 template <typename C, typename T>
diff --git a/test/format-test.cc b/test/format-test.cc
index 56a1f879..af4018dc 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1213,6 +1213,16 @@ TEST(FormatterTest, FormatStringView) {
   EXPECT_EQ("test", format("{0}", string_view("test")));
 }
 
+struct ConvertibleToString {
+  std::string s;
+  ConvertibleToString() : s("foo") {}
+  operator const std::string &() const { return s; }
+};
+
+TEST(FormatterTest, FormatConvertibleToString) {
+  EXPECT_EQ("foo", format("{}", ConvertibleToString()));
+}
+
 namespace fmt {
 template <>
 struct formatter<Date> {

From 8ca3ab2c4c6323ed941853f54489c19135a99d75 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 18 Feb 2018 05:38:32 +0000
Subject: [PATCH 21/62] Revert problematic pragma

---
 include/fmt/core.h   | 3 ++-
 include/fmt/format.h | 6 ------
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 2f309501..2881c200 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -870,7 +870,8 @@ namespace internal {
 template <typename Context, typename T>
 class get_type {
  public:
-  typedef decltype(make_value<Context>(std::declval<typename std::decay<T>::type&>())) value_type;
+  typedef decltype(make_value<Context>(
+        std::declval<typename std::decay<T>::type&>())) value_type;
   static const type value = value_type::type_tag;
 };
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index f77b51c6..15717fbd 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -642,13 +642,7 @@ class null_terminating_iterator {
     return ptr_ >= other.ptr_;
   }
 
-  // 'fmt::internal::pointer_from': the inline specifier cannot be used
-  // when a friend declaration refers to a specialization of a function
-
-  // pointer_from is defined with the inline specifier, but declared without,
-  // so this looks like a bug in the compiler.
   friend FMT_CONSTEXPR_DECL const Char *pointer_from<Char>(
-# pragma warning(suppress: 4396)
       null_terminating_iterator it);
 
  private:

From 0ee4273b042d5ce8fc2da1542c942867797e0ae4 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 18 Feb 2018 05:47:29 +0000
Subject: [PATCH 22/62] Put is_enum check first not to instantiate
 convert_to_int unnecessarily

---
 include/fmt/core.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 2881c200..eebce949 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -588,7 +588,7 @@ void make_value(const T *p) {
 
 template <typename C, typename T>
 inline typename std::enable_if<
-    convert_to_int<T, typename C::char_type>::value && std::is_enum<T>::value,
+    std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value,
     typed_value<C, int_type>>::type
   make_value(const T &val) { return static_cast<int>(val); }
 

From e508e30800dc2bbe7fe15b87aee7df4fc084e80c Mon Sep 17 00:00:00 2001
From: hubslave <29800872+hubslave@users.noreply.github.com>
Date: Mon, 19 Feb 2018 00:43:35 +0200
Subject: [PATCH 23/62] Don't define FMT_LOCALE on OpenBSD

OpenBSD doesn't have strtod_l() (at least under the default
headers), so the class Locale that the macro gates won't compile.
---
 include/fmt/posix.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/fmt/posix.h b/include/fmt/posix.h
index a3e0ec22..1be9a87e 100644
--- a/include/fmt/posix.h
+++ b/include/fmt/posix.h
@@ -353,7 +353,7 @@ class File {
 long getpagesize();
 
 #if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
-    !defined(__ANDROID__) && !defined(__CYGWIN__)
+    !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
 # define FMT_LOCALE
 #endif
 

From 24d249b0b44fa74aeb0604aabf6b00d41dd29b44 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Mon, 19 Feb 2018 20:25:56 +0000
Subject: [PATCH 24/62] Fix formatting of objects convertible to string_view

---
 include/fmt/core.h  | 4 +++-
 test/format-test.cc | 8 ++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index eebce949..0b91e0d5 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -570,7 +570,8 @@ FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
 FMT_MAKE_VALUE(cstring_type, const signed char*, const signed char*)
 FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
 FMT_MAKE_VALUE(cstring_type, const unsigned char*, const unsigned char*)
-FMT_MAKE_VALUE(string_type, basic_string_view<Char>, basic_string_view<Char>)
+FMT_MAKE_VALUE(string_type, basic_string_view<typename C::char_type>,
+               basic_string_view<Char>)
 FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
                basic_string_view<Char>)
 FMT_MAKE_VALUE(pointer_type, void*, const void*)
@@ -595,6 +596,7 @@ inline typename std::enable_if<
 template <typename C, typename T, typename Char = typename C::char_type>
 inline typename std::enable_if<
     !convert_to_int<T, Char>::value &&
+    !std::is_convertible<T, basic_string_view<Char>>::value &&
     !std::is_convertible<T, std::basic_string<Char>>::value,
     typed_value<C, custom_type>>::type
   make_value(const T &val) { return val; }
diff --git a/test/format-test.cc b/test/format-test.cc
index af4018dc..d689b15f 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1223,6 +1223,14 @@ TEST(FormatterTest, FormatConvertibleToString) {
   EXPECT_EQ("foo", format("{}", ConvertibleToString()));
 }
 
+struct ConvertibleToStringView {
+  operator fmt::string_view() const { return "foo"; }
+};
+
+TEST(FormatterTest, FormatConvertibleToStringView) {
+  EXPECT_EQ("foo", format("{}", ConvertibleToStringView()));
+}
+
 namespace fmt {
 template <>
 struct formatter<Date> {

From a7ae5666a02b1b9cee5e44a07758dcaa244b5b62 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Mon, 19 Feb 2018 21:03:51 +0000
Subject: [PATCH 25/62] Enable join on msvc

---
 include/fmt/format.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 15717fbd..f30d5f9c 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -140,6 +140,10 @@
 # endif
 #endif
 
+#if FMT_HAS_GXX_CXX11 || FMT_MSC_VER >= 1600
+# define FMT_USE_TRAILING_RETURN 1
+#endif
+
 // __builtin_clz is broken in clang with Microsoft CodeGen:
 // https://github.com/fmtlib/fmt/issues/519
 #ifndef _MSC_VER
@@ -3221,7 +3225,7 @@ arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
   return arg_join<It, wchar_t>(begin, end, sep);
 }
 
-#if FMT_HAS_GXX_CXX11
+#if FMT_USE_TRAILING_RETURN
 template <typename Range>
 auto join(const Range &range, string_view sep)
     -> arg_join<decltype(std::begin(range)), char> {

From e92ba1071db7a1fcaee1274bef914bf639dae718 Mon Sep 17 00:00:00 2001
From: johnthagen <johnthagen@users.noreply.github.com>
Date: Tue, 20 Feb 2018 11:54:56 -0500
Subject: [PATCH 26/62] Fix Python str.format link to point to Python 3 docs

---
 doc/index.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/index.rst b/doc/index.rst
index a00828b0..ea70c46e 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -25,7 +25,7 @@ The replacement-based Format API provides a safe alternative to ``printf``,
 ``sprintf`` and friends with comparable or `better performance
 <http://zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html>`_.
 The `format string syntax <syntax.html>`_ is similar to the one used by
-`str.format <http://docs.python.org/2/library/stdtypes.html#str.format>`_
+`str.format <http://docs.python.org/3/library/stdtypes.html#str.format>`_
 in Python:
 
 .. code:: c++

From 55f5c9f21b900cbc334afc9d80c84491d6f0ab81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20Gullik=20Bj=C3=B8nnes?= <lbjonnes@cisco.com>
Date: Thu, 15 Feb 2018 17:23:44 +0100
Subject: [PATCH 27/62] Use FMT_NULL instead of 0 is a few more places.

Found with GCC and -Wzero-as-null-pointer-constant
---
 include/fmt/core.h   | 2 +-
 include/fmt/posix.cc | 2 +-
 include/fmt/posix.h  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 0b91e0d5..31960a8f 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -172,7 +172,7 @@ class basic_string_view {
   typedef Char char_type;
   typedef const Char *iterator;
 
-  FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(0), size_(0) {}
+  FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {}
 
   /** Constructs a string reference object from a C string and a size. */
   FMT_CONSTEXPR basic_string_view(const Char *s, size_t size) FMT_NOEXCEPT
diff --git a/include/fmt/posix.cc b/include/fmt/posix.cc
index 67513b07..76414842 100644
--- a/include/fmt/posix.cc
+++ b/include/fmt/posix.cc
@@ -71,7 +71,7 @@ fmt::BufferedFile::~BufferedFile() FMT_NOEXCEPT {
 
 fmt::BufferedFile::BufferedFile(
     fmt::cstring_view filename, fmt::cstring_view mode) {
-  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), 0);
+  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), FMT_NULL);
   if (!file_)
     FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
 }
diff --git a/include/fmt/posix.h b/include/fmt/posix.h
index 1be9a87e..30f7b904 100644
--- a/include/fmt/posix.h
+++ b/include/fmt/posix.h
@@ -134,7 +134,7 @@ class BufferedFile {
 
  public:
   // Constructs a BufferedFile object which doesn't represent any file.
-  BufferedFile() FMT_NOEXCEPT : file_(0) {}
+  BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {}
 
   // Destroys the object closing the file it represents if any.
   FMT_API ~BufferedFile() FMT_DTOR_NOEXCEPT;

From db86e8d5d3215cae1272dfac98ed9ba64ac4295a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20Gullik=20Bj=C3=B8nnes?= <lbjonnes@cisco.com>
Date: Thu, 15 Feb 2018 17:32:54 +0100
Subject: [PATCH 28/62] Remove a couple of unused argument names

---
 include/fmt/core.h   | 2 +-
 include/fmt/format.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 31960a8f..6ab2df08 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -583,7 +583,7 @@ FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
 // formatting of "[const] volatile char *" which is printed as bool by
 // iostreams.
 template <typename T>
-void make_value(const T *p) {
+void make_value(const T *) {
   static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
 }
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index f30d5f9c..a0572fc5 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -904,7 +904,7 @@ inline Char *format_decimal(Char *buffer, UInt value, unsigned num_digits,
 
 template <typename UInt, typename Iterator, typename ThousandsSep>
 inline Iterator format_decimal(
-    Iterator out, UInt value, unsigned num_digits, ThousandsSep thousands_sep) {
+    Iterator out, UInt value, unsigned num_digits, ThousandsSep) {
   // Buffer should be large enough to hold all digits (digits10 + 1) and null.
   char buffer[std::numeric_limits<UInt>::digits10 + 2];
   format_decimal(buffer, value, num_digits, no_thousands_sep());

From f45f70af097bf54897b6cb0ced2699ee38515276 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20Gullik=20Bj=C3=B8nnes?= <lbjonnes@cisco.com>
Date: Thu, 15 Feb 2018 17:34:38 +0100
Subject: [PATCH 29/62] Use trailing return type instead of deduction

C++11 does not support deduction of return type.
---
 include/fmt/format.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index a0572fc5..2e725364 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -3199,10 +3199,10 @@ template <typename It, typename Char>
 struct formatter<arg_join<It, Char>, Char>:
     formatter<typename std::iterator_traits<It>::value_type, Char> {
   template <typename FormatContext>
-  auto format(const arg_join<It, Char> &value, FormatContext &ctx) {
+  auto format(const arg_join<It, Char> &value, FormatContext &ctx) -> decltype(ctx.begin()) {
     typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
     auto it = value.begin;
-    auto out = ctx.begin(); 
+    auto out = ctx.begin();
     if (it != value.end) {
       out = base::format(*it++, ctx);
       while (it != value.end) {

From 5b49177352d6668586a4f244f6f367d632809a89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20Gullik=20Bj=C3=B8nnes?= <lbjonnes@cisco.com>
Date: Fri, 16 Feb 2018 11:04:33 +0100
Subject: [PATCH 30/62] test: Initialize some local variables

GCC 7.3 complains about uninitialized varaibles in constexpr context.
---
 test/format-test.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/format-test.cc b/test/format-test.cc
index d689b15f..4555e479 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1779,7 +1779,7 @@ struct test_context {
 
 FMT_CONSTEXPR fmt::format_specs parse_specs(const char *s) {
   fmt::format_specs specs;
-  test_context ctx;
+  test_context ctx{};
   fmt::internal::specs_handler<test_context> h(specs, ctx);
   parse_format_specs(s, h);
   return specs;
@@ -1805,7 +1805,7 @@ TEST(FormatTest, ConstexprSpecsHandler) {
 FMT_CONSTEXPR fmt::internal::dynamic_format_specs<char>
     parse_dynamic_specs(const char *s) {
   fmt::internal::dynamic_format_specs<char> specs;
-  test_context ctx;
+  test_context ctx{};
   fmt::internal::dynamic_specs_handler<test_context> h(specs, ctx);
   parse_format_specs(s, h);
   return specs;

From ea06f021f8cdd08b89b29a296f53b7d4984e88fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20Gullik=20Bj=C3=B8nnes?= <lbjonnes@cisco.com>
Date: Fri, 16 Feb 2018 11:05:40 +0100
Subject: [PATCH 31/62] test: comment out one FormatStringErrors constexpr test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

GCC 7.3 complains that this is not a compile time constant.

test/format-test.cc: In member function ‘virtual void FormatTest_FormatStringErrors_Test::TestBody()’:
test/format-test.cc:1919:3: error: non-constant condition for static assertion
   static_assert(test_error<__VA_ARGS__>(fmt, error), "")
   ^
test/format-test.cc:1924:3: note: in expansion of macro ‘EXPECT_ERROR’
   EXPECT_ERROR("{0:s", "unknown format specifier", Date);
   ^~~~~~~~~~~~
---
 test/format-test.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/format-test.cc b/test/format-test.cc
index 4555e479..01c8dbbd 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1929,7 +1929,7 @@ FMT_CONSTEXPR bool test_error(const char *fmt, const char *expected_error) {
 TEST(FormatTest, FormatStringErrors) {
   EXPECT_ERROR("foo", nullptr);
   EXPECT_ERROR("}", "unmatched '}' in format string");
-  EXPECT_ERROR("{0:s", "unknown format specifier", Date);
+  //EXPECT_ERROR("{0:s", "unknown format specifier", Date);
 #ifndef _MSC_VER
   // This causes an internal compiler error in MSVC2017.
   EXPECT_ERROR("{0:=5", "unknown format specifier", int);

From f5dc0ed342578f14d6e0756fc6c8cb24856feed4 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 24 Feb 2018 08:39:17 +0000
Subject: [PATCH 32/62] Break long lines

---
 include/fmt/format.h | 3 ++-
 include/fmt/posix.cc | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 2e725364..4d40598c 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -3199,7 +3199,8 @@ template <typename It, typename Char>
 struct formatter<arg_join<It, Char>, Char>:
     formatter<typename std::iterator_traits<It>::value_type, Char> {
   template <typename FormatContext>
-  auto format(const arg_join<It, Char> &value, FormatContext &ctx) -> decltype(ctx.begin()) {
+  auto format(const arg_join<It, Char> &value, FormatContext &ctx)
+      -> decltype(ctx.begin()) {
     typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
     auto it = value.begin;
     auto out = ctx.begin();
diff --git a/include/fmt/posix.cc b/include/fmt/posix.cc
index 76414842..463f22d0 100644
--- a/include/fmt/posix.cc
+++ b/include/fmt/posix.cc
@@ -71,7 +71,8 @@ fmt::BufferedFile::~BufferedFile() FMT_NOEXCEPT {
 
 fmt::BufferedFile::BufferedFile(
     fmt::cstring_view filename, fmt::cstring_view mode) {
-  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), FMT_NULL);
+  FMT_RETRY_VAL(file_,
+                FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), FMT_NULL);
   if (!file_)
     FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
 }

From 0565d65461dd5cd9efdae954176a5d26d57ff2a9 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 24 Feb 2018 09:29:15 +0000
Subject: [PATCH 33/62] Fix gcc 7.2 issue

---
 include/fmt/format.h | 3 ++-
 test/format-test.cc  | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 4d40598c..85e84044 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -1992,7 +1992,8 @@ FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler) {
 template <typename T, typename ParseContext>
 FMT_CONSTEXPR const typename ParseContext::char_type *
     parse_format_specs(ParseContext &ctx) {
-  formatter<T, typename ParseContext::char_type> f;
+  // GCC 7.2 requires initializer.
+  formatter<T, typename ParseContext::char_type> f{};
   return f.parse(ctx);
 }
 
diff --git a/test/format-test.cc b/test/format-test.cc
index 01c8dbbd..4555e479 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1929,7 +1929,7 @@ FMT_CONSTEXPR bool test_error(const char *fmt, const char *expected_error) {
 TEST(FormatTest, FormatStringErrors) {
   EXPECT_ERROR("foo", nullptr);
   EXPECT_ERROR("}", "unmatched '}' in format string");
-  //EXPECT_ERROR("{0:s", "unknown format specifier", Date);
+  EXPECT_ERROR("{0:s", "unknown format specifier", Date);
 #ifndef _MSC_VER
   // This causes an internal compiler error in MSVC2017.
   EXPECT_ERROR("{0:=5", "unknown format specifier", int);

From 34cf54c2fc17c367ee28794117e3f6a9aedd88dc Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 24 Feb 2018 09:37:17 +0000
Subject: [PATCH 34/62] Update README.rst

---
 README.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.rst b/README.rst
index 861286cf..7d144cad 100644
--- a/README.rst
+++ b/README.rst
@@ -159,6 +159,8 @@ Projects using this library
 
 * `AMPL/MP <https://github.com/ampl/mp>`_:
   An open-source library for mathematical programming
+  
+* `AvioBook <https://www.aviobook.aero/en>`_: A comprehensive aircraft operations suite.
 
 * `CUAUV <http://cuauv.org/>`_: Cornell University's autonomous underwater vehicle
 

From 4d35f94133ed14794e53c9f8627d047b408e0dc7 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 24 Feb 2018 18:19:30 +0000
Subject: [PATCH 35/62] Always use fallback string_view to pass format string
 (#664)

---
 include/fmt/core.h  | 32 +++++++++++++++++++++++++-------
 test/format-test.cc |  6 ++++++
 2 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 6ab2df08..b2c8360c 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -146,20 +146,23 @@
 #if (FMT_HAS_INCLUDE(<string_view>) && __cplusplus > 201402L) || \
     (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
 # include <string_view>
-namespace fmt { using std::basic_string_view; }
+# define FMT_USE_STD_STRING_VIEW
 // std::experimental::basic_string_view::remove_prefix isn't constexpr until
 // gcc 7.3.
 #elif (FMT_HAS_INCLUDE(<experimental/string_view>) && \
        (FMT_GCC_VERSION == 0 || FMT_GCC_VERSION >= 730) && \
        __cplusplus >= 201402L)
 # include <experimental/string_view>
-namespace fmt { using std::experimental::basic_string_view; }
-#else
+# define FMT_USE_EXPERIMENTAL_STRING_VIEW
+#endif
+
 namespace fmt {
 /**
   \rst
   An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
-  subset of the API.
+  subset of the API. fmt::basic_string_view is used for format strings even if
+  std::string_view is available to prevent issues when a library is compiled
+  with different -std option than the client code (which is not recommended).
   \endrst
  */
 template <typename Char>
@@ -172,6 +175,18 @@ class basic_string_view {
   typedef Char char_type;
   typedef const Char *iterator;
 
+  // Standard basic_string_view type.
+#if defined(FMT_USE_STD_STRING_VIEW)
+  typedef std::basic_string_view<Char> type;
+#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
+  typedef std::experimental::basic_string_view<Char> type;
+#else
+  struct type {
+    const char *data() const { return FMT_NULL; }
+    size_t size() const { return 0; };
+  };
+#endif
+
   FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {}
 
   /** Constructs a string reference object from a C string and a size. */
@@ -197,6 +212,9 @@ class basic_string_view {
       const std::basic_string<Char, Alloc> &s) FMT_NOEXCEPT
   : data_(s.c_str()), size_(s.size()) {}
 
+  FMT_CONSTEXPR basic_string_view(type s) FMT_NOEXCEPT
+  : data_(s.data()), size_(s.size()) {}
+
   /** Returns a pointer to the string data. */
   const Char *data() const { return data_; }
 
@@ -239,10 +257,7 @@ class basic_string_view {
     return lhs.compare(rhs) >= 0;
   }
 };
-}  // namespace fmt
-#endif
 
-namespace fmt {
 typedef basic_string_view<char> string_view;
 typedef basic_string_view<wchar_t> wstring_view;
 
@@ -572,6 +587,9 @@ FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
 FMT_MAKE_VALUE(cstring_type, const unsigned char*, const unsigned char*)
 FMT_MAKE_VALUE(string_type, basic_string_view<typename C::char_type>,
                basic_string_view<Char>)
+FMT_MAKE_VALUE(string_type,
+               typename basic_string_view<typename C::char_type>::type,
+               basic_string_view<Char>)
 FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
                basic_string_view<Char>)
 FMT_MAKE_VALUE(pointer_type, void*, const void*)
diff --git a/test/format-test.cc b/test/format-test.cc
index 4555e479..f3a961f2 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1213,6 +1213,12 @@ TEST(FormatterTest, FormatStringView) {
   EXPECT_EQ("test", format("{0}", string_view("test")));
 }
 
+#ifdef FMT_USE_STD_STRING_VIEW
+TEST(FormatterTest, FormatStringView) {
+  EXPECT_EQ("test", format("{0}", std::string_view("test")));
+}
+#endif
+
 struct ConvertibleToString {
   std::string s;
   ConvertibleToString() : s("foo") {}

From 0827ec5aa912ddd4ef3a651572d3129234eb5677 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 28 Feb 2018 04:33:43 -0800
Subject: [PATCH 36/62] Fix compilation errors on gcc 4.6

---
 include/fmt/format.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 85e84044..211279bc 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -232,7 +232,7 @@ typename Allocator::value_type *allocate(Allocator& alloc, std::size_t n) {
 #if __cplusplus >= 201103L || FMT_MSC_VER >= 1700
   return std::allocator_traits<Allocator>::allocate(alloc, n);
 #else
-  return this->allocate(n);
+  return alloc.allocate(n);
 #endif
 }
 }  // namespace internal
@@ -2002,7 +2002,7 @@ class format_string_checker {
  public:
   explicit FMT_CONSTEXPR format_string_checker(
       basic_string_view<Char> format_str, ErrorHandler eh)
-    : context_(format_str, eh) {}
+    : arg_id_(-1), context_(format_str, eh) {}
 
   FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
 
@@ -2041,7 +2041,7 @@ class format_string_checker {
   // Format specifier parsing function.
   typedef const Char *(*parse_func)(parse_context_type &);
 
-  int arg_id_ = -1;
+  int arg_id_;
   parse_context_type context_;
   parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1] = {
       &parse_format_specs<Args, parse_context_type>...

From 6090e51b655142f71c5cab183c6d229f3c605737 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 28 Feb 2018 04:49:20 -0800
Subject: [PATCH 37/62] Fix compilation errors on gcc 4.6

---
 include/fmt/format.h | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 211279bc..7eac976d 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2002,7 +2002,8 @@ class format_string_checker {
  public:
   explicit FMT_CONSTEXPR format_string_checker(
       basic_string_view<Char> format_str, ErrorHandler eh)
-    : arg_id_(-1), context_(format_str, eh) {}
+    : arg_id_(-1), context_(format_str, eh),
+      parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
 
   FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
 
@@ -2043,9 +2044,7 @@ class format_string_checker {
 
   int arg_id_;
   parse_context_type context_;
-  parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1] = {
-      &parse_format_specs<Args, parse_context_type>...
-  };
+  parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1];
 };
 
 template <typename Char, typename ErrorHandler, typename... Args>
@@ -2286,7 +2285,7 @@ class basic_writer {
     const Spec &spec;
     unsigned_type abs_value;
     char prefix[4];
-    unsigned prefix_size = 0;
+    unsigned prefix_size;
 
     string_view get_prefix() const { return string_view(prefix, prefix_size); }
 
@@ -2302,7 +2301,8 @@ class basic_writer {
     }
 
     int_writer(basic_writer<Range> &w, Int value, const Spec &s)
-      : writer(w), spec(s), abs_value(static_cast<unsigned_type>(value)) {
+      : writer(w), spec(s), abs_value(static_cast<unsigned_type>(value)),
+        prefix_size(0) {
       if (internal::is_negative(value)) {
         prefix[0] = '-';
         ++prefix_size;
@@ -2609,9 +2609,9 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
   // Check type.
   struct spec_handler {
     char_type type;
-    bool upper = false;
+    bool upper;
 
-    explicit spec_handler(char_type t) : type(t) {}
+    explicit spec_handler(char_type t) : type(t), upper(false) {}
 
     void on_general() {
       if (type == 'G')
@@ -2750,6 +2750,7 @@ class output_range {
   sentinel end() const;
 
  public:
+  typedef OutputIt iterator;
   typedef T value_type;
 
   explicit output_range(OutputIt it): it_(it) {}
@@ -2764,8 +2765,8 @@ class back_insert_range:
  public:
   typedef typename Container::value_type value_type;
 
-  using base::base;
   back_insert_range(Container &c): base(std::back_inserter(c)) {}
+  back_insert_range(typename base::iterator it): base(it) {}
 };
 
 typedef basic_writer<back_insert_range<internal::buffer>> writer;

From 1b4525384bff8fdbf149c1cb7c3b7c884eaafbae Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 28 Feb 2018 05:09:24 -0800
Subject: [PATCH 38/62] Fix more compilation errors on gcc 4.6

---
 include/fmt/format.h  | 3 ++-
 include/fmt/ostream.h | 4 +++-
 include/fmt/printf.h  | 2 +-
 test/format-test.cc   | 3 +++
 4 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 7eac976d..0d577795 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2658,7 +2658,8 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
   }
 
   auto write_inf_or_nan = [this, &spec, sign](const char *str) {
-    write_padded(INF_SIZE + (sign ? 1 : 0), spec, inf_or_nan_writer{sign, str});
+    this->write_padded(INF_SIZE + (sign ? 1 : 0), spec,
+                       inf_or_nan_writer{sign, str});
   };
 
   // Format NaN and ininity ourselves because sprintf's output is not consistent
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index 16d490b2..e28170d4 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -67,8 +67,10 @@ class convert_to_int<T, Char, true> {
   template <typename>
   static std::false_type test(...);
 
+  typedef decltype(test<T>(0)) result;
+
  public:
-  static const bool value = !decltype(test<T>(0))::value;
+  static const bool value = !result::value;
 };
 
 // Write the content of buf to os.
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index 531f6864..9720d972 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -290,7 +290,7 @@ class printf_arg_formatter : public internal::arg_formatter_base<Range> {
 template <typename T>
 struct printf_formatter {
   template <typename ParseContext>
-  auto parse(ParseContext &ctx) { return ctx.begin(); }
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); }
 
   template <typename FormatContext>
   auto format(const T &value, FormatContext &ctx) -> decltype(ctx.begin()) {
diff --git a/test/format-test.cc b/test/format-test.cc
index f3a961f2..924c6aff 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -137,6 +137,8 @@ TEST(StringViewTest, Ctor) {
   EXPECT_EQ(4u, string_view(std::string("defg")).size());
 }
 
+// GCC 4.6 doesn't have std::is_copy_*.
+#if FMT_GCC_VERSION && FMT_GCC_VERSION >= 407
 TEST(WriterTest, NotCopyConstructible) {
   EXPECT_FALSE(std::is_copy_constructible<fmt::writer>::value);
 }
@@ -144,6 +146,7 @@ TEST(WriterTest, NotCopyConstructible) {
 TEST(WriterTest, NotCopyAssignable) {
   EXPECT_FALSE(std::is_copy_assignable<fmt::writer>::value);
 }
+#endif
 
 TEST(WriterTest, Data) {
   memory_buffer buf;

From 81074c7048c4132718f59d2afa1378ba09e4374e Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 28 Feb 2018 05:23:25 -0800
Subject: [PATCH 39/62] Fix more compilation errors on gcc 4.6

---
 test/format-test.cc | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/test/format-test.cc b/test/format-test.cc
index 924c6aff..7c39ac04 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1251,7 +1251,7 @@ struct formatter<Date> {
     return it;
   }
 
-  auto format(const Date &d, context &ctx) {
+  auto format(const Date &d, context &ctx) -> decltype(ctx.begin()) {
     format_to(ctx.begin(), "{}-{}-{}", d.year(), d.month(), d.day());
     return ctx.begin();
   }
@@ -1269,7 +1269,7 @@ class Answer {};
 namespace fmt {
 template <>
 struct formatter<Answer> : formatter<int> {
-  auto format(Answer, fmt::context &ctx) {
+  auto format(Answer, fmt::context &ctx) -> decltype(ctx.begin()) {
     return formatter<int>::format(42, ctx);
   }
 };
@@ -1527,6 +1527,12 @@ TEST(LiteralsTest, NamedArg) {
                    fmt::arg(L"third", 99)),
             udl_a_w);
 }
+
+TEST(FormatTest, UdlTemplate) {
+  EXPECT_EQ("foo", "foo"_format());
+  EXPECT_EQ("        42", "{0:10}"_format(42));
+  EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), 42));
+}
 #endif // FMT_USE_USER_DEFINED_LITERALS
 
 enum TestEnum { A };
@@ -1594,7 +1600,7 @@ struct variant {
 namespace fmt {
 template <>
 struct formatter<variant> : dynamic_formatter<> {
-  auto format(variant value, context& ctx) {
+  auto format(variant value, context& ctx) -> decltype(ctx.begin()) {
     if (value.type == variant::INT)
       return dynamic_formatter::format(42, ctx);
     return dynamic_formatter::format("foo", ctx);
@@ -1628,12 +1634,6 @@ TEST(FormatTest, DynamicFormatter) {
       format_error, "precision not allowed for this argument type");
 }
 
-TEST(FormatTest, UdlTemplate) {
-  EXPECT_EQ("foo", "foo"_format());
-  EXPECT_EQ("        42", "{0:10}"_format(42));
-  EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), 42));
-}
-
 TEST(FormatTest, ToString) {
   EXPECT_EQ("42", fmt::to_string(42));
   EXPECT_EQ("0x1234", fmt::to_string(reinterpret_cast<void*>(0x1234)));

From 698d909706adbd3a32ec6f75ae8b70daf9ea5095 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 28 Feb 2018 06:14:56 -0800
Subject: [PATCH 40/62] Workaround a bug in gcc 5.1

---
 include/fmt/format.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 0d577795..95b92447 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -646,8 +646,11 @@ class null_terminating_iterator {
     return ptr_ >= other.ptr_;
   }
 
-  friend FMT_CONSTEXPR_DECL const Char *pointer_from<Char>(
-      null_terminating_iterator it);
+  // This should be a friend specialization pointer_from<Char> but the latter
+  // doesn't compile by gcc 5.1 due to a compiler bug.
+  template <typename CharT>
+  friend FMT_CONSTEXPR_DECL const CharT *pointer_from(
+      null_terminating_iterator<CharT> it);
 
  private:
   const Char *ptr_;

From 45518c3fe191e0cf1652aa779eb9fbaabddb1f39 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 28 Feb 2018 07:47:24 -0800
Subject: [PATCH 41/62] Fix compilation errors on gcc 4.4

---
 include/fmt/core.h   | 25 +++++++++++++++++++++++--
 include/fmt/format.h |  4 ++--
 2 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index b2c8360c..f8dc5755 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -72,16 +72,27 @@
 # endif
 #endif
 
+#if FMT_HAS_FEATURE(cxx_explicit_conversions)
+# define FMT_EXPLICIT explicit
+#else
+# define FMT_EXPLICIT
+#endif
+
 #ifndef FMT_NULL
 # if FMT_HAS_FEATURE(cxx_nullptr) || \
    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
    FMT_MSC_VER >= 1600
 #  define FMT_NULL nullptr
+#  define FMT_USE_NULLPTR 1
 # else
 #  define FMT_NULL NULL
 # endif
 #endif
 
+#ifndef FMT_USE_NULLPTR
+# define FMT_USE_NULLPTR 0
+#endif
+
 // Check if exceptions are disabled.
 #if defined(__GNUC__) && !defined(__EXCEPTIONS)
 # define FMT_EXCEPTIONS 0
@@ -157,6 +168,11 @@
 #endif
 
 namespace fmt {
+
+// An implementation of declval for pre-C++11 compilers such as gcc 4.
+template <typename T>
+typename std::add_rvalue_reference<T>::type declval() FMT_NOEXCEPT;
+
 /**
   \rst
   An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
@@ -284,6 +300,8 @@ class basic_buffer {
   std::size_t capacity_;
 
  protected:
+  typedef const T &const_reference;
+
   basic_buffer(T *p = FMT_NULL, std::size_t size = 0, std::size_t capacity = 0)
     FMT_NOEXCEPT: ptr_(p), size_(size), capacity_(capacity) {}
 
@@ -594,7 +612,10 @@ FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
                basic_string_view<Char>)
 FMT_MAKE_VALUE(pointer_type, void*, const void*)
 FMT_MAKE_VALUE(pointer_type, const void*, const void*)
+
+#if FMT_USE_NULLPTR
 FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
+#endif
 
 // Formatting of arbitrary pointers is disallowed. If you want to output a
 // pointer cast it to "void *" or "const void *". In particular, this forbids
@@ -667,7 +688,7 @@ class basic_arg {
 
   FMT_CONSTEXPR basic_arg() : type_(internal::none_type) {}
 
-  explicit operator bool() const FMT_NOEXCEPT {
+  FMT_EXPLICIT operator bool() const FMT_NOEXCEPT {
     return type_ != internal::none_type;
   }
 
@@ -891,7 +912,7 @@ template <typename Context, typename T>
 class get_type {
  public:
   typedef decltype(make_value<Context>(
-        std::declval<typename std::decay<T>::type&>())) value_type;
+        declval<typename std::decay<T>::type&>())) value_type;
   static const type value = value_type::type_tag;
 };
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 95b92447..e72dcd1e 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2093,7 +2093,7 @@ template <typename Range>
 class arg_formatter: public internal::arg_formatter_base<Range> {
  private:
   typedef typename Range::value_type char_type;
-  typedef decltype(std::declval<Range>().begin()) iterator;
+  typedef decltype(declval<Range>().begin()) iterator;
   typedef internal::arg_formatter_base<Range> base;
   typedef basic_context<iterator, char_type> context_type;
 
@@ -2191,7 +2191,7 @@ template <typename Range>
 class basic_writer {
  public:
   typedef typename Range::value_type char_type;
-  typedef decltype(std::declval<Range>().begin()) iterator;
+  typedef decltype(declval<Range>().begin()) iterator;
   typedef basic_format_specs<char_type> format_specs;
 
  private:

From 1d2adef28d39aa563e5b448d28691aba488b3314 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Thu, 1 Mar 2018 03:45:25 -0800
Subject: [PATCH 42/62] Fix compilation errors on gcc 4.4

---
 include/fmt/core.h   |  9 +++++++++
 include/fmt/format.h | 38 ++++++++++++++++++++++++++++----------
 2 files changed, 37 insertions(+), 10 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index f8dc5755..58d0e7bb 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -170,8 +170,10 @@
 namespace fmt {
 
 // An implementation of declval for pre-C++11 compilers such as gcc 4.
+namespace internal {
 template <typename T>
 typename std::add_rvalue_reference<T>::type declval() FMT_NOEXCEPT;
+}
 
 /**
   \rst
@@ -962,8 +964,15 @@ class arg_store {
  public:
   static const uint64_t TYPES;
 
+#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 405 && !defined(__clang__)
+  // Workaround an array initialization bug in gcc 4.5 and earlier.
+  arg_store(const Args &... args) {
+    data_ = {internal::make_arg<IS_PACKED, Context>(args)...};
+  }
+#else
   arg_store(const Args &... args)
     : data_{internal::make_arg<IS_PACKED, Context>(args)...} {}
+#endif
 
   basic_format_args<Context> operator*() const { return *this; }
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index e72dcd1e..5e771bcf 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -212,6 +212,19 @@ inline uint32_t clzll(uint64_t x) {
 
 namespace fmt {
 namespace internal {
+
+// An implementation of begin and end for pre-C++11 compilers such as gcc 4.
+template <typename C>
+FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin()) {
+  return c.begin();
+}
+template <typename T, std::size_t N>
+FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT { return array; }
+template <typename C>
+FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end()) { return c.end(); }
+template <typename T, std::size_t N>
+FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT { return array + N; }
+
 struct dummy_int {
   int data[2];
   operator int() const { return 0; }
@@ -2093,7 +2106,7 @@ template <typename Range>
 class arg_formatter: public internal::arg_formatter_base<Range> {
  private:
   typedef typename Range::value_type char_type;
-  typedef decltype(declval<Range>().begin()) iterator;
+  typedef decltype(internal::declval<Range>().begin()) iterator;
   typedef internal::arg_formatter_base<Range> base;
   typedef basic_context<iterator, char_type> context_type;
 
@@ -2191,7 +2204,7 @@ template <typename Range>
 class basic_writer {
  public:
   typedef typename Range::value_type char_type;
-  typedef decltype(declval<Range>().begin()) iterator;
+  typedef decltype(internal::declval<Range>().begin()) iterator;
   typedef basic_format_specs<char_type> format_specs;
 
  private:
@@ -2660,10 +2673,15 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
     sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
   }
 
-  auto write_inf_or_nan = [this, &spec, sign](const char *str) {
-    this->write_padded(INF_SIZE + (sign ? 1 : 0), spec,
-                       inf_or_nan_writer{sign, str});
-  };
+  struct write_inf_or_nan_t {
+    basic_writer &writer;
+    format_specs spec;
+    char sign;
+    void operator()(const char *str) const {
+      writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec,
+                          inf_or_nan_writer{sign, str});
+    }
+  } write_inf_or_nan = {*this, spec, sign};
 
   // Format NaN and ininity ourselves because sprintf's output is not consistent
   // across platforms.
@@ -3235,14 +3253,14 @@ arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
 #if FMT_USE_TRAILING_RETURN
 template <typename Range>
 auto join(const Range &range, string_view sep)
-    -> arg_join<decltype(std::begin(range)), char> {
-  return join(std::begin(range), std::end(range), sep);
+    -> arg_join<decltype(internal::begin(range)), char> {
+  return join(internal::begin(range), internal::end(range), sep);
 }
 
 template <typename Range>
 auto join(const Range &range, wstring_view sep)
-    -> arg_join<decltype(std::begin(range)), wchar_t> {
-  return join(std::begin(range), std::end(range), sep);
+    -> arg_join<decltype(internal::begin(range)), wchar_t> {
+  return join(internal::begin(range), internal::end(range), sep);
 }
 #endif
 

From 418659adbe9be1646cff3870a743706327fd77c1 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 3 Mar 2018 14:04:59 -0800
Subject: [PATCH 43/62] Fix compilation errors on gcc 4.4

---
 include/fmt/core.h            |  20 ++-
 include/fmt/format.h          | 302 +++++++++++++++++++---------------
 include/fmt/ostream.h         |   4 +-
 include/fmt/printf.h          |  46 +++---
 test/custom-formatter-test.cc |   2 +-
 test/format-impl-test.cc      |   4 +-
 test/format-test.cc           |  13 +-
 test/util-test.cc             |  42 ++---
 8 files changed, 241 insertions(+), 192 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 58d0e7bb..670fce2b 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -167,6 +167,11 @@
 # define FMT_USE_EXPERIMENTAL_STRING_VIEW
 #endif
 
+// std::result_of is defined in <functional> in gcc 4.4.
+#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404
+# include <functional>
+#endif
+
 namespace fmt {
 
 // An implementation of declval for pre-C++11 compilers such as gcc 4.
@@ -302,8 +307,6 @@ class basic_buffer {
   std::size_t capacity_;
 
  protected:
-  typedef const T &const_reference;
-
   basic_buffer(T *p = FMT_NULL, std::size_t size = 0, std::size_t capacity = 0)
     FMT_NOEXCEPT: ptr_(p), size_(size), capacity_(capacity) {}
 
@@ -322,6 +325,7 @@ class basic_buffer {
 
  public:
   typedef T value_type;
+  typedef const T &const_reference;
 
   virtual ~basic_buffer() {}
 
@@ -655,6 +659,16 @@ enum { MAX_PACKED_ARGS = 15 };
 
 template <typename Context>
 class arg_map;
+
+template <typename>
+struct result_of;
+
+template <typename F, typename... Args>
+struct result_of<F(Args...)> {
+  // A workaround for gcc 4.4 that doesn't allow F to be a reference.
+  typedef typename std::result_of<
+    typename std::remove_reference<F>::type(Args...)>::type type;
+};
 }
 
 // A formatting argument. It is a trivially copyable/constructible type to
@@ -669,7 +683,7 @@ class basic_arg {
   friend FMT_CONSTEXPR basic_arg<ContextType> internal::make_arg(const T &value);
 
   template <typename Visitor, typename Ctx>
-  friend FMT_CONSTEXPR typename std::result_of<Visitor(int)>::type
+  friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
     visit(Visitor &&vis, basic_arg<Ctx> arg);
 
   friend class basic_format_args<Context>;
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 5e771bcf..b388fdbe 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -156,6 +156,13 @@
 # endif
 #endif
 
+// A workaround for gcc 4.4 that doesn't support union members with ctors.
+#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404
+# define FMT_UNION struct
+#else
+# define FMT_UNION union
+#endif
+
 // Some compilers masquerade as both MSVC and GCC-likes or otherwise support
 // __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
 // MSVC intrinsics if the clz and clzll builtins are not available.
@@ -225,6 +232,13 @@ FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end()) { return c.end(); }
 template <typename T, std::size_t N>
 FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT { return array + N; }
 
+// For std::result_of in gcc 4.4.
+template <typename Result>
+struct function {
+  template <typename T>
+  struct result { typedef Result type; };
+};
+
 struct dummy_int {
   int data[2];
   operator int() const { return 0; }
@@ -1016,7 +1030,7 @@ struct monostate {};
   \endrst
  */
 template <typename Visitor, typename Context>
-FMT_CONSTEXPR typename std::result_of<Visitor(int)>::type
+FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
     visit(Visitor &&vis, basic_arg<Context> arg) {
   typedef typename Context::char_type char_type;
   switch (arg.type_) {
@@ -1051,7 +1065,7 @@ FMT_CONSTEXPR typename std::result_of<Visitor(int)>::type
   case internal::custom_type:
     return vis(typename basic_arg<Context>::handle(arg.value_.custom));
   }
-  return typename std::result_of<Visitor(int)>::type();
+  return typename internal::result_of<Visitor(int)>::type();
 }
 
 enum alignment {
@@ -1405,33 +1419,35 @@ class arg_formatter_base {
     write(value);
   }
 
+  struct char_spec_handler : internal::error_handler {
+    arg_formatter_base &formatter;
+    char_type value;
+
+    char_spec_handler(arg_formatter_base& f, char_type val)
+      : formatter(f), value(val) {}
+
+    void on_int() { formatter.writer_.write_int(value, formatter.specs_); }
+    void on_char() { formatter.write_char(value); }
+  };
+
   void operator()(char_type value) {
-    struct spec_handler : internal::error_handler {
-      arg_formatter_base &formatter;
-      char_type value;
-
-      spec_handler(arg_formatter_base& f, char_type val)
-        : formatter(f), value(val) {}
-
-      void on_int() { formatter.writer_.write_int(value, formatter.specs_); }
-      void on_char() { formatter.write_char(value); }
-    };
-    internal::handle_char_specs(specs_, spec_handler(*this, value));
+    internal::handle_char_specs(specs_, char_spec_handler(*this, value));
   }
 
+  struct cstring_spec_handler : internal::error_handler {
+    arg_formatter_base &formatter;
+    const char_type *value;
+
+    cstring_spec_handler(arg_formatter_base &f, const char_type *val)
+      : formatter(f), value(val) {}
+
+    void on_string() { formatter.write(value); }
+    void on_pointer() { formatter.write_pointer(value); }
+  };
+
   void operator()(const char_type *value) {
-    struct spec_handler : internal::error_handler {
-      arg_formatter_base &formatter;
-      const char_type *value;
-
-      spec_handler(arg_formatter_base &f, const char_type *val)
-        : formatter(f), value(val) {}
-
-      void on_string() { formatter.write(value); }
-      void on_pointer() { formatter.write_pointer(value); }
-    };
     internal::handle_cstring_type_spec(
-          specs_.type_, spec_handler(*this, value));
+          specs_.type_, cstring_spec_handler(*this, value));
   }
 
   void operator()(basic_string_view<char_type> value) {
@@ -1480,20 +1496,20 @@ FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) {
 }
 
 template <typename Char, typename Context>
-class custom_formatter {
+class custom_formatter: public function<bool> {
  private:
   Context &ctx_;
 
  public:
   explicit custom_formatter(Context &ctx): ctx_(ctx) {}
 
-  bool operator()(typename basic_arg<Context>::handle h) {
+  bool operator()(typename basic_arg<Context>::handle h) const {
     h.format(ctx_);
     return true;
   }
 
   template <typename T>
-  bool operator()(T) { return false; }
+  bool operator()(T) const { return false; }
 };
 
 template <typename T>
@@ -1505,12 +1521,13 @@ struct is_integer {
 };
 
 template <typename ErrorHandler>
-class width_checker {
+class width_checker: public function<unsigned long long> {
  public:
   explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh) : handler_(eh) {}
 
   template <typename T>
-  FMT_CONSTEXPR typename std::enable_if<
+  FMT_CONSTEXPR 
+  typename std::enable_if<
       is_integer<T>::value, unsigned long long>::type operator()(T value) {
     if (is_negative(value))
       handler_.on_error("negative width");
@@ -1529,7 +1546,7 @@ class width_checker {
 };
 
 template <typename ErrorHandler>
-class precision_checker {
+class precision_checker: public function<unsigned long long> {
  public:
   explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh) : handler_(eh) {}
 
@@ -1716,7 +1733,7 @@ struct arg_ref {
   }
 
   Kind kind;
-  union {
+  FMT_UNION {
     unsigned index;
     basic_string_view<Char> name;
   };
@@ -2103,7 +2120,8 @@ void handle_dynamic_spec(
 
 /** The default argument formatter. */
 template <typename Range>
-class arg_formatter: public internal::arg_formatter_base<Range> {
+class arg_formatter:
+  public internal::function<void>, public internal::arg_formatter_base<Range> {
  private:
   typedef typename Range::value_type char_type;
   typedef decltype(internal::declval<Range>().begin()) iterator;
@@ -2129,7 +2147,7 @@ class arg_formatter: public internal::arg_formatter_base<Range> {
   using base::operator();
 
   /** Formats an argument of a custom (user-defined) type. */
-  void operator()(typename basic_arg<context_type>::handle handle) {
+  void operator()(typename basic_arg<context_type>::handle handle) const {
     handle.format(ctx_);
   }
 };
@@ -2516,10 +2534,10 @@ class basic_writer {
     Formats *value* and writes it to the buffer.
     \endrst
    */
-  template <typename T, typename... FormatSpecs>
+  template <typename T, typename FormatSpec, typename... FormatSpecs>
   typename std::enable_if<std::is_integral<T>::value, void>::type
-      write(T value, FormatSpecs... specs) {
-    format_specs s(specs...);
+      write(T value, FormatSpec spec, FormatSpecs... specs) {
+    format_specs s(spec, specs...);
     s.align_ = ALIGN_RIGHT;
     write_int(value, s);
   }
@@ -2619,48 +2637,50 @@ void basic_writer<Range>::write_str(
   write_str(data, size, spec);
 }
 
+template <typename Char>
+struct float_spec_handler {
+  Char type;
+  bool upper;
+
+  explicit float_spec_handler(Char t) : type(t), upper(false) {}
+
+  void on_general() {
+    if (type == 'G')
+      upper = true;
+    else
+      type = 'g';
+  }
+
+  void on_exp() {
+    if (type == 'E')
+      upper = true;
+  }
+
+  void on_fixed() {
+    if (type == 'F') {
+      upper = true;
+#if FMT_MSC_VER
+      // MSVC's printf doesn't support 'F'.
+      type = 'f';
+#endif
+    }
+  }
+
+  void on_hex() {
+    if (type == 'A')
+      upper = true;
+  }
+
+  void on_error() {
+    FMT_THROW(format_error("invalid type specifier"));
+  }
+};
+
 template <typename Range>
 template <typename T>
 void basic_writer<Range>::write_double(T value, const format_specs &spec) {
   // Check type.
-  struct spec_handler {
-    char_type type;
-    bool upper;
-
-    explicit spec_handler(char_type t) : type(t), upper(false) {}
-
-    void on_general() {
-      if (type == 'G')
-        upper = true;
-      else
-        type = 'g';
-    }
-
-    void on_exp() {
-      if (type == 'E')
-        upper = true;
-    }
-
-    void on_fixed() {
-      if (type == 'F') {
-        upper = true;
-#if FMT_MSC_VER
-        // MSVC's printf doesn't support 'F'.
-        type = 'f';
-#endif
-      }
-    }
-
-    void on_hex() {
-      if (type == 'A')
-        upper = true;
-    }
-
-    void on_error() {
-      FMT_THROW(format_error("invalid type specifier"));
-    }
-  };
-  spec_handler handler(spec.type());
+  float_spec_handler<char_type> handler(spec.type());
   internal::handle_float_type_spec(spec.type(), handler);
 
   char sign = 0;
@@ -3049,7 +3069,17 @@ struct formatter<T, Char,
 //     }
 //   };
 template <typename Char = char>
-struct dynamic_formatter {
+class dynamic_formatter {
+ private:
+  struct null_handler: internal::error_handler {
+    void on_align(alignment) {}
+    void on_plus() {}
+    void on_minus() {}
+    void on_space() {}
+    void on_hash() {}
+  };
+
+ public:
   template <typename ParseContext>
   auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
     auto it = internal::null_terminating_iterator<Char>(ctx);
@@ -3062,13 +3092,6 @@ struct dynamic_formatter {
   template <typename T, typename FormatContext>
   auto format(const T &val, FormatContext &ctx) -> decltype(ctx.begin()) {
     handle_specs(ctx);
-    struct null_handler : internal::error_handler {
-      void on_align(alignment) {}
-      void on_plus() {}
-      void on_minus() {}
-      void on_space() {}
-      void on_hash() {}
-    };
     internal::specs_checker<null_handler>
         checker(null_handler(), internal::get_type<FormatContext, T>::value);
     checker.on_align(specs_.align());
@@ -3115,66 +3138,70 @@ typename basic_context<Range, Char>::format_arg
   return arg;
 }
 
+template <typename ArgFormatter, typename Char, typename Context>
+struct format_handler : internal::error_handler {
+  typedef internal::null_terminating_iterator<Char> iterator;
+  typedef typename ArgFormatter::range range;
+
+  format_handler(range r, basic_string_view<Char> str,
+                 basic_format_args<Context> format_args)
+    : context(r.begin(), str, format_args) {}
+
+  void on_text(iterator begin, iterator end) {
+    size_t size = end - begin;
+    auto out = context.begin();
+    auto &&it = internal::reserve(out, size);
+    it = std::copy_n(begin, size, it);
+    context.advance_to(out);
+  }
+
+  void on_arg_id() { arg = context.next_arg(); }
+  void on_arg_id(unsigned id) {
+    context.parse_context().check_arg_id(id);
+    arg = context.get_arg(id);
+  }
+  void on_arg_id(basic_string_view<Char> id) {
+    arg = context.get_arg(id);
+  }
+
+  void on_replacement_field(iterator it) {
+    context.parse_context().advance_to(pointer_from(it));
+    using internal::custom_formatter;
+    if (visit(custom_formatter<Char, Context>(context), arg))
+      return;
+    basic_format_specs<Char> specs;
+    visit(ArgFormatter(context, specs), arg);
+  }
+
+  iterator on_format_specs(iterator it) {
+    auto& parse_ctx = context.parse_context();
+    parse_ctx.advance_to(pointer_from(it));
+    using internal::custom_formatter;
+    if (visit(custom_formatter<Char, Context>(context), arg))
+      return iterator(parse_ctx);
+    basic_format_specs<Char> specs;
+    using internal::specs_handler;
+    internal::specs_checker<specs_handler<Context>>
+        handler(specs_handler<Context>(specs, context), arg.type());
+    it = parse_format_specs(it, handler);
+    if (*it != '}')
+      on_error("missing '}' in format string");
+    parse_ctx.advance_to(pointer_from(it));
+    visit(ArgFormatter(context, specs), arg);
+    return it;
+  }
+
+  Context context;
+  basic_arg<Context> arg;
+};
+
 /** Formats arguments and writes the output to the buffer. */
 template <typename ArgFormatter, typename Char, typename Context>
 typename Context::iterator do_vformat_to(typename ArgFormatter::range out,
                                          basic_string_view<Char> format_str,
                                          basic_format_args<Context> args) {
   typedef internal::null_terminating_iterator<Char> iterator;
-  typedef typename ArgFormatter::range range;
-
-  struct handler : internal::error_handler {
-    handler(range r, basic_string_view<Char> str,
-            basic_format_args<Context> format_args)
-      : context(r.begin(), str, format_args) {}
-
-    void on_text(iterator begin, iterator end) {
-      size_t size = end - begin;
-      auto out = context.begin();
-      auto &&it = internal::reserve(out, size);
-      it = std::copy_n(begin, size, it);
-      context.advance_to(out);
-    }
-
-    void on_arg_id() { arg = context.next_arg(); }
-    void on_arg_id(unsigned id) {
-      context.parse_context().check_arg_id(id);
-      arg = context.get_arg(id);
-    }
-    void on_arg_id(basic_string_view<Char> id) {
-      arg = context.get_arg(id);
-    }
-
-    void on_replacement_field(iterator it) {
-      context.parse_context().advance_to(pointer_from(it));
-      using internal::custom_formatter;
-      if (visit(custom_formatter<Char, Context>(context), arg))
-        return;
-      basic_format_specs<Char> specs;
-      visit(ArgFormatter(context, specs), arg);
-    }
-
-    iterator on_format_specs(iterator it) {
-      auto& parse_ctx = context.parse_context();
-      parse_ctx.advance_to(pointer_from(it));
-      using internal::custom_formatter;
-      if (visit(custom_formatter<Char, Context>(context), arg))
-        return iterator(parse_ctx);
-      basic_format_specs<Char> specs;
-      using internal::specs_handler;
-      internal::specs_checker<specs_handler<Context>>
-          handler(specs_handler<Context>(specs, context), arg.type());
-      it = parse_format_specs(it, handler);
-      if (*it != '}')
-        on_error("missing '}' in format string");
-      parse_ctx.advance_to(pointer_from(it));
-      visit(ArgFormatter(context, specs), arg);
-      return it;
-    }
-
-    Context context;
-    basic_arg<Context> arg;
-  } h(out, format_str, args);
+  format_handler<ArgFormatter, Char, Context> h(out, format_str, args);
   parse_format_string(iterator(format_str.begin(), format_str.end()), h);
   return h.context.begin();
 }
@@ -3250,7 +3277,8 @@ arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
   return arg_join<It, wchar_t>(begin, end, sep);
 }
 
-#if FMT_USE_TRAILING_RETURN
+// The following causes ICE in gcc 4.4.
+#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
 template <typename Range>
 auto join(const Range &range, string_view sep)
     -> arg_join<decltype(internal::begin(range)), char> {
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index e28170d4..3ec8919a 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -61,8 +61,8 @@ class convert_to_int<T, Char, true> {
  private:
   template <typename U>
   static decltype(
-    std::declval<test_stream<Char>&>() << std::declval<U>(), std::true_type())
-      test(int);
+    internal::declval<test_stream<Char>&>()
+      << internal::declval<U>(), std::true_type()) test(int);
 
   template <typename>
   static std::false_type test(...);
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index 9720d972..4bc92253 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -19,7 +19,7 @@ namespace internal {
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
 template <bool IsSigned>
-struct IntChecker {
+struct int_checker {
   template <typename T>
   static bool fits_in_int(T value) {
     unsigned max = std::numeric_limits<int>::max();
@@ -29,7 +29,7 @@ struct IntChecker {
 };
 
 template <>
-struct IntChecker<true> {
+struct int_checker<true> {
   template <typename T>
   static bool fits_in_int(T value) {
     return value >= std::numeric_limits<int>::min() &&
@@ -38,12 +38,12 @@ struct IntChecker<true> {
   static bool fits_in_int(int) { return true; }
 };
 
-class PrintfPrecisionHandler {
+class printf_precision_handler: public function<int> {
  public:
   template <typename T>
   typename std::enable_if<std::is_integral<T>::value, int>::type
       operator()(T value) {
-    if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
       FMT_THROW(format_error("number is too big"));
     return static_cast<int>(value);
   }
@@ -57,7 +57,7 @@ class PrintfPrecisionHandler {
 };
 
 // An argument visitor that returns true iff arg is a zero integer.
-class IsZeroInt {
+class is_zero_int: public function<bool> {
  public:
   template <typename T>
   typename std::enable_if<std::is_integral<T>::value, bool>::type
@@ -77,7 +77,7 @@ struct make_unsigned_or_bool<bool> {
 };
 
 template <typename T, typename Context>
-class ArgConverter {
+class arg_converter: public function<void> {
  private:
   typedef typename Context::char_type Char;
 
@@ -85,7 +85,7 @@ class ArgConverter {
   typename Context::char_type type_;
 
  public:
-  ArgConverter(basic_arg<Context> &arg, Char type)
+  arg_converter(basic_arg<Context> &arg, Char type)
     : arg_(arg), type_(type) {}
 
   void operator()(bool value) {
@@ -134,19 +134,19 @@ class ArgConverter {
 // unsigned).
 template <typename T, typename Context, typename Char>
 void convert_arg(basic_arg<Context> &arg, Char type) {
-  visit(ArgConverter<T, Context>(arg, type), arg);
+  visit(arg_converter<T, Context>(arg, type), arg);
 }
 
 // Converts an integer argument to char for printf.
 template <typename Context>
-class CharConverter {
+class char_converter: public function<void> {
  private:
   basic_arg<Context> &arg_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
+  FMT_DISALLOW_COPY_AND_ASSIGN(char_converter);
 
  public:
-  explicit CharConverter(basic_arg<Context> &arg) : arg_(arg) {}
+  explicit char_converter(basic_arg<Context> &arg) : arg_(arg) {}
 
   template <typename T>
   typename std::enable_if<std::is_integral<T>::value>::type
@@ -163,16 +163,16 @@ class CharConverter {
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
 template <typename Char>
-class PrintfWidthHandler {
+class printf_width_handler: public function<unsigned> {
  private:
   typedef basic_format_specs<Char> format_specs;
 
   format_specs &spec_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(PrintfWidthHandler);
+  FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler);
 
  public:
-  explicit PrintfWidthHandler(format_specs &spec) : spec_(spec) {}
+  explicit printf_width_handler(format_specs &spec) : spec_(spec) {}
 
   template <typename T>
   typename std::enable_if<std::is_integral<T>::value, unsigned>::type
@@ -213,10 +213,11 @@ class basic_printf_context;
   \endrst
  */
 template <typename Range>
-class printf_arg_formatter : public internal::arg_formatter_base<Range> {
+class printf_arg_formatter:
+  public internal::function<void>, public internal::arg_formatter_base<Range> {
  private:
   typedef typename Range::value_type char_type;
-  typedef decltype(std::declval<Range>().begin()) iterator;
+  typedef decltype(internal::declval<Range>().begin()) iterator;
   typedef internal::arg_formatter_base<Range> base;
   typedef basic_printf_context<iterator, char_type> context_type;
 
@@ -417,7 +418,7 @@ unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
   } else if (*it == '*') {
     ++it;
     spec.width_ =
-        visit(internal::PrintfWidthHandler<char_type>(spec), get_arg(it));
+        visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
   }
   return arg_index;
 }
@@ -453,14 +454,14 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
       } else if (*it == '*') {
         ++it;
         spec.precision_ =
-            visit(internal::PrintfPrecisionHandler(), get_arg(it));
+            visit(internal::printf_precision_handler(), get_arg(it));
       } else {
         spec.precision_ = 0;
       }
     }
 
     format_arg arg = get_arg(it, arg_index);
-    if (spec.flag(HASH_FLAG) && visit(internal::IsZeroInt(), arg))
+    if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg))
       spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
     if (spec.fill_ == '0') {
       if (arg.is_arithmetic())
@@ -514,7 +515,7 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
         break;
       case 'c':
         // TODO: handle wchar_t
-        visit(internal::CharConverter<basic_printf_context>(arg), arg);
+        visit(internal::char_converter<basic_printf_context>(arg), arg);
         break;
       }
     }
@@ -539,8 +540,7 @@ struct printf_context {
     std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
 };
 
-typedef basic_format_args<
-  typename printf_context<internal::buffer>::type> printf_args;
+typedef basic_format_args<printf_context<internal::buffer>::type> printf_args;
 
 inline std::string vsprintf(string_view format, printf_args args) {
   memory_buffer buffer;
@@ -565,7 +565,7 @@ inline std::string sprintf(string_view format_str, const Args & ... args) {
 
 inline std::wstring vsprintf(
     wstring_view format,
-    basic_format_args<typename printf_context<internal::wbuffer>::type> args) {
+    basic_format_args<printf_context<internal::wbuffer>::type> args) {
   wmemory_buffer buffer;
   printf(buffer, format, args);
   return to_string(buffer);
diff --git a/test/custom-formatter-test.cc b/test/custom-formatter-test.cc
index d8be5375..59be29ca 100644
--- a/test/custom-formatter-test.cc
+++ b/test/custom-formatter-test.cc
@@ -18,7 +18,7 @@ class CustomArgFormatter :
     public fmt::arg_formatter<fmt::back_insert_range<fmt::internal::buffer>> {
  public:
   typedef fmt::back_insert_range<fmt::internal::buffer> range;
-  typedef decltype(std::declval<range>().begin()) iterator;
+  typedef decltype(fmt::internal::declval<range>().begin()) iterator;
   typedef fmt::arg_formatter<range> base;
 
   CustomArgFormatter(fmt::basic_context<iterator, char> &ctx,
diff --git a/test/format-impl-test.cc b/test/format-impl-test.cc
index fea4d7dd..3d7f1150 100644
--- a/test/format-impl-test.cc
+++ b/test/format-impl-test.cc
@@ -44,7 +44,7 @@
 #undef max
 
 template <typename T>
-struct ValueExtractor {
+struct ValueExtractor: fmt::internal::function<T> {
   T operator()(T value) {
     return value;
   }
@@ -59,7 +59,7 @@ struct ValueExtractor {
 TEST(FormatTest, ArgConverter) {
   long long value = std::numeric_limits<long long>::max();
   auto arg = fmt::internal::make_arg<fmt::context>(value);
-  visit(fmt::internal::ArgConverter<long long, fmt::context>(arg, 'd'), arg);
+  visit(fmt::internal::arg_converter<long long, fmt::context>(arg, 'd'), arg);
   EXPECT_EQ(value, visit(ValueExtractor<long long>(), arg));
 }
 
diff --git a/test/format-test.cc b/test/format-test.cc
index 7c39ac04..801beea4 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1205,7 +1205,9 @@ TEST(FormatterTest, FormatPointer) {
   EXPECT_EQ("0x" + std::string(sizeof(void*) * CHAR_BIT / 4, 'f'),
       format("{0}", reinterpret_cast<void*>(~uintptr_t())));
   EXPECT_EQ("0x1234", format("{}", fmt::ptr(reinterpret_cast<int*>(0x1234))));
-  EXPECT_EQ("0x0", format("{}", nullptr));
+#if FMT_USE_NULLPTR
+  EXPECT_EQ("0x0", format("{}", FMT_NULL));
+#endif
 }
 
 TEST(FormatterTest, FormatString) {
@@ -1450,7 +1452,7 @@ TEST(FormatTest, JoinArg) {
   EXPECT_EQ(L"(1, 2, 3)", format(L"({})", join(v1, v1 + 3, L", ")));
   EXPECT_EQ("1, 2, 3", format("{0:{1}}", join(v1, v1 + 3, ", "), 1));
 
-#if FMT_HAS_GXX_CXX11
+#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
   EXPECT_EQ("(1, 2, 3)", format("({})", join(v1, ", ")));
   EXPECT_EQ("(+01.20, +03.40)", format("({:+06.2f})", join(v2, ", ")));
 #endif
@@ -1551,7 +1553,8 @@ TEST(FormatTest, FixedEnum) {
 
 typedef fmt::back_insert_range<fmt::internal::buffer> buffer_range;
 
-class mock_arg_formatter :
+class mock_arg_formatter:
+    public fmt::internal::function<void>,
     public fmt::internal::arg_formatter_base<buffer_range> {
  private:
   MOCK_METHOD1(call, void (int value));
@@ -1602,8 +1605,8 @@ template <>
 struct formatter<variant> : dynamic_formatter<> {
   auto format(variant value, context& ctx) -> decltype(ctx.begin()) {
     if (value.type == variant::INT)
-      return dynamic_formatter::format(42, ctx);
-    return dynamic_formatter::format("foo", ctx);
+      return dynamic_formatter<>::format(42, ctx);
+    return dynamic_formatter<>::format("foo", ctx);
   }
 };
 }
diff --git a/test/util-test.cc b/test/util-test.cc
index 6a16096b..eb1c09d9 100644
--- a/test/util-test.cc
+++ b/test/util-test.cc
@@ -478,12 +478,12 @@ bool operator==(custom_value<Char> lhs, custom_value<Char> rhs) {
 }
 }
 
-template <typename T>
-struct MockVisitor {
-  // Use a unique result type to make sure that there are no undesirable
-  // conversions.
-  struct Result {};
+// Use a unique result type to make sure that there are no undesirable
+// conversions.
+struct Result {};
 
+template <typename T>
+struct MockVisitor: fmt::internal::function<Result> {
   MockVisitor() {
     ON_CALL(*this, visit(_)).WillByDefault(Return(Result()));
   }
@@ -529,8 +529,9 @@ VISIT_TYPE(float, double);
   fmt::visit(visitor, make_arg<fmt::basic_context<iterator, Char>>(value)); \
 }
 
-#define CHECK_ARG(value) { \
-  typename VisitType<decltype(value)>::Type expected = value; \
+#define CHECK_ARG(value, typename_) { \
+  typedef decltype(value) value_type; \
+  typename_ VisitType<value_type>::Type expected = value; \
   CHECK_ARG_(char, expected, value) \
   CHECK_ARG_(wchar_t, expected, value) \
 }
@@ -556,9 +557,9 @@ typename std::enable_if<std::is_floating_point<T>::value, T>::type
 }
 
 TYPED_TEST(NumericArgTest, MakeAndVisit) {
-  CHECK_ARG(test_value<TypeParam>());
-  CHECK_ARG(std::numeric_limits<TypeParam>::min());
-  CHECK_ARG(std::numeric_limits<TypeParam>::max());
+  CHECK_ARG(test_value<TypeParam>(), typename);
+  CHECK_ARG(std::numeric_limits<TypeParam>::min(), typename);
+  CHECK_ARG(std::numeric_limits<TypeParam>::max(), typename);
 }
 
 TEST(UtilTest, CharArg) {
@@ -594,22 +595,25 @@ TEST(UtilTest, PointerArg) {
   const void *cp = 0;
   CHECK_ARG_(char, cp, p);
   CHECK_ARG_(wchar_t, cp, p);
-  CHECK_ARG(cp);
+  CHECK_ARG(cp, );
 }
 
-TEST(UtilTest, CustomArg) {
-  ::Test test;
-  typedef typename fmt::basic_arg<fmt::context>::handle handle;
-  typedef MockVisitor<handle> visitor;
-  testing::StrictMock<visitor> v;
-  EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke([&](handle h) {
+struct check_custom {
+  Result operator()(fmt::basic_arg<fmt::context>::handle h) const {
     fmt::memory_buffer buffer;
     fmt::internal::basic_buffer<char> &base = buffer;
     fmt::context ctx(std::back_inserter(base), "", fmt::format_args());
     h.format(ctx);
     EXPECT_EQ("test", std::string(buffer.data(), buffer.size()));
-    return visitor::Result();
-  }));
+    return Result();
+  }
+};
+
+TEST(UtilTest, CustomArg) {
+  ::Test test;
+  typedef MockVisitor<fmt::basic_arg<fmt::context>::handle> visitor;
+  testing::StrictMock<visitor> v;
+  EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke(check_custom()));
   fmt::visit(v, make_arg<fmt::context>(test));
 }
 

From d07ba49821b120c655f1c8409ab2f3d419d59e0f Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 3 Mar 2018 22:12:23 -0800
Subject: [PATCH 44/62] Fix docs

---
 doc/api.rst | 63 +++++++++++++++++++++++++++--------------------------
 1 file changed, 32 insertions(+), 31 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index 5112b56d..263b4f72 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -4,16 +4,16 @@
 API Reference
 *************
 
-All functions and classes provided by the fmt library reside
-in namespace ``fmt`` and macros have prefix ``FMT_``. For brevity the
-namespace is usually omitted in examples.
+All functions and classes provided by the fmt library reside in namespace
+``fmt`` and macros have prefix ``FMT_``. For brevity the namespace is usually
+omitted in examples.
 
 Format API
 ==========
 
 The following functions defined in ``fmt/core.h`` use :ref:`format string
-syntax <syntax>` similar to the one used by Python's `str.format
-<http://docs.python.org/3/library/stdtypes.html#str.format>`_ function.
+syntax <syntax>` similar to that of Python's `str.format
+<http://docs.python.org/3/library/stdtypes.html#str.format>`_.
 They take *format_str* and *args* as arguments.
 
 *format_str* is a format string that contains literal text and replacement
@@ -25,7 +25,6 @@ arguments in the resulting string.
 The `performance of the format API
 <https://github.com/fmtlib/fmt/blob/master/README.rst#speed-tests>`_ is close
 to that of glibc's ``printf`` and better than the performance of IOStreams.
-For even better speed use the `write API`_.
 
 .. _format:
 
@@ -121,41 +120,48 @@ Argument formatters
 It is possible to change the way arguments are formatted by providing a
 custom argument formatter class::
 
+  using arg_formatter =
+    fmt::arg_formatter<fmt::back_insert_range<fmt::internal::buffer>>;
+
   // A custom argument formatter that formats negative integers as unsigned
   // with the ``x`` format specifier.
-  class CustomArgFormatter :
-    public fmt::BasicArgFormatter<CustomArgFormatter, char> {
+  class custom_arg_formatter : public arg_formatter {
    public:
-    CustomArgFormatter(fmt::BasicFormatter<char, CustomArgFormatter> &f,
-                       fmt::FormatSpec &s, const char *fmt)
-      : fmt::BasicArgFormatter<CustomArgFormatter, char>(f, s, fmt) {}
+    custom_arg_formatter(context_type &ctx, fmt::format_specs &spec)
+      : arg_formatter(ctx, spec) {}
 
-    void visit_int(int value) {
+    using arg_formatter::operator();
+
+    void operator()(int value) {
       if (spec().type() == 'x')
-        visit_uint(value); // convert to unsigned and format
+        (*this)(static_cast<unsigned>(value)); // convert to unsigned and format
       else
-        fmt::BasicArgFormatter<CustomArgFormatter, char>::visit_int(value);
+        arg_formatter::operator()(value);
     }
   };
 
-  std::string custom_format(const char *format_str, fmt::ArgList args) {
-    fmt::MemoryWriter writer;
-    // Pass custom argument formatter as a template arg to BasicFormatter.
-    fmt::BasicFormatter<char, CustomArgFormatter> formatter(args, writer);
-    formatter.format(format_str);
-    return writer.str();
+  std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
+    fmt::memory_buffer buffer;
+    // Pass custom argument formatter as a template arg to do_vformat.
+    fmt::do_vformat_to<custom_arg_formatter>(buffer, format_str, args);
+    return fmt::to_string(buffer);
+  }
+
+  template <typename ...Args>
+  inline std::string custom_format(
+      fmt::string_view format_str, const Args &... args) {
+    return custom_vformat(format_str, fmt::make_args(args...));
   }
-  FMT_VARIADIC(std::string, custom_format, const char *)
 
   std::string s = custom_format("{:x}", -42); // s == "ffffffd6"
 
 .. doxygenclass:: fmt::ArgVisitor
    :members:
 
-.. doxygenclass:: fmt::BasicArgFormatter
+.. doxygenclass:: fmt::arg_formatter_base
    :members:
 
-.. doxygenclass:: fmt::ArgFormatter
+.. doxygenclass:: fmt::arg_formatter
    :members:
 
 Printf formatting
@@ -211,23 +217,18 @@ store output elsewhere by subclassing `~fmt::BasicWriter`.
 Utilities
 =========
 
-.. doxygenfunction:: fmt::arg(StringRef, const T&)
+.. doxygenfunction:: fmt::arg(string_view, const T&)
 
 .. doxygenfunction:: operator""_a(const char *, std::size_t)
 
 .. doxygendefine:: FMT_CAPTURE
 
-.. doxygendefine:: FMT_VARIADIC
-
-.. doxygenclass:: fmt::ArgList
+.. doxygenclass:: fmt::basic_format_args
    :members:
 
 .. doxygenfunction:: fmt::to_string(const T&)
 
-.. doxygenclass:: fmt::BasicStringRef
-   :members:
-
-.. doxygenclass:: fmt::BasicCStringRef
+.. doxygenclass:: fmt::basic_string_view
    :members:
 
 .. doxygenclass:: fmt::Buffer

From 5281ea6ad2eef17c9b8dbe27b060b78103659f2a Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 06:40:43 -0800
Subject: [PATCH 45/62] do_vformat_to -> vformat_to and update docs

---
 doc/api.rst                   |  8 ++++----
 include/fmt/core.h            |  7 ++++---
 include/fmt/format.h          | 16 ++++++++--------
 test/custom-formatter-test.cc |  2 +-
 test/format-test.cc           |  2 +-
 5 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index 263b4f72..de5604b4 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -22,7 +22,7 @@ arguments in the resulting string.
 
 *args* is an argument list representing objects to be formatted.
 
-The `performance of the format API
+The `performance of the formating functions
 <https://github.com/fmtlib/fmt/blob/master/README.rst#speed-tests>`_ is close
 to that of glibc's ``printf`` and better than the performance of IOStreams.
 
@@ -127,7 +127,7 @@ custom argument formatter class::
   // with the ``x`` format specifier.
   class custom_arg_formatter : public arg_formatter {
    public:
-    custom_arg_formatter(context_type &ctx, fmt::format_specs &spec)
+    custom_arg_formatter(fmt::context &ctx, fmt::format_specs &spec)
       : arg_formatter(ctx, spec) {}
 
     using arg_formatter::operator();
@@ -142,8 +142,8 @@ custom argument formatter class::
 
   std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
     fmt::memory_buffer buffer;
-    // Pass custom argument formatter as a template arg to do_vformat.
-    fmt::do_vformat_to<custom_arg_formatter>(buffer, format_str, args);
+    // Pass custom argument formatter as a template arg to vformat_to.
+    fmt::vformat_to<custom_arg_formatter>(buffer, format_str, args);
     return fmt::to_string(buffer);
   }
 
diff --git a/include/fmt/core.h b/include/fmt/core.h
index 670fce2b..fe214cf0 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -183,9 +183,10 @@ typename std::add_rvalue_reference<T>::type declval() FMT_NOEXCEPT;
 /**
   \rst
   An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
-  subset of the API. fmt::basic_string_view is used for format strings even if
-  std::string_view is available to prevent issues when a library is compiled
-  with different -std option than the client code (which is not recommended).
+  subset of the API. ``fmt::basic_string_view`` is used for format strings even
+  if ``std::string_view`` is available to prevent issues when a library is
+  compiled with a different ``-std`` option than the client code (which is not
+  recommended).
   \endrst
  */
 template <typename Char>
diff --git a/include/fmt/format.h b/include/fmt/format.h
index b388fdbe..5d3edd6f 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -3197,9 +3197,9 @@ struct format_handler : internal::error_handler {
 
 /** Formats arguments and writes the output to the buffer. */
 template <typename ArgFormatter, typename Char, typename Context>
-typename Context::iterator do_vformat_to(typename ArgFormatter::range out,
-                                         basic_string_view<Char> format_str,
-                                         basic_format_args<Context> args) {
+typename Context::iterator vformat_to(typename ArgFormatter::range out,
+                                      basic_string_view<Char> format_str,
+                                      basic_format_args<Context> args) {
   typedef internal::null_terminating_iterator<Char> iterator;
   format_handler<ArgFormatter, Char, Context> h(out, format_str, args);
   parse_format_string(iterator(format_str.begin(), format_str.end()), h);
@@ -3327,13 +3327,13 @@ std::basic_string<Char> to_string(const basic_memory_buffer<Char> &buffer) {
 inline void vformat_to(internal::buffer &buf, string_view format_str,
                        format_args args) {
   typedef back_insert_range<internal::buffer> range;
-  do_vformat_to<arg_formatter<range>>(buf, format_str, args);
+  vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
 inline void vformat_to(internal::wbuffer &buf, wstring_view format_str,
                        wformat_args args) {
   typedef back_insert_range<internal::wbuffer> range;
-  do_vformat_to<arg_formatter<range>>(buf, format_str, args);
+  vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
 template <typename... Args>
@@ -3362,7 +3362,7 @@ template <typename OutputIt, typename... Args>
 inline OutputIt vformat_to(OutputIt out, string_view format_str,
                            typename format_args_t<OutputIt>::type args) {
   typedef output_range<OutputIt, char> range;
-  return do_vformat_to<arg_formatter<range>>(range(out), format_str, args);
+  return vformat_to<arg_formatter<range>>(range(out), format_str, args);
 }
 
 template <typename OutputIt, typename... Args>
@@ -3465,7 +3465,7 @@ FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
 # else
 /**
   \rst
-  C++11 literal equivalent of :func:`fmt::format`.
+  User-defined literal equivalent of :func:`fmt::format`.
 
   **Example**::
 
@@ -3481,7 +3481,7 @@ operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
 
 /**
   \rst
-  C++11 literal equivalent of :func:`fmt::arg`.
+  User-defined literal equivalent of :func:`fmt::arg`.
 
   **Example**::
 
diff --git a/test/custom-formatter-test.cc b/test/custom-formatter-test.cc
index 59be29ca..8eda9154 100644
--- a/test/custom-formatter-test.cc
+++ b/test/custom-formatter-test.cc
@@ -37,7 +37,7 @@ class CustomArgFormatter :
 std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
   fmt::memory_buffer buffer;
   // Pass custom argument formatter as a template arg to vwrite.
-  fmt::do_vformat_to<CustomArgFormatter>(buffer, format_str, args);
+  fmt::vformat_to<CustomArgFormatter>(buffer, format_str, args);
   return std::string(buffer.data(), buffer.size());
 }
 
diff --git a/test/format-test.cc b/test/format-test.cc
index 801beea4..f118c8d6 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1577,7 +1577,7 @@ class mock_arg_formatter:
 
 void custom_vformat(fmt::string_view format_str, fmt::format_args args) {
   fmt::memory_buffer buffer;
-  fmt::do_vformat_to<mock_arg_formatter>(buffer, format_str, args);
+  fmt::vformat_to<mock_arg_formatter>(buffer, format_str, args);
 }
 
 template <typename... Args>

From b7632e9641fc1fefa970552d40c241989e4ab126 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 08:13:08 -0800
Subject: [PATCH 46/62] Make format_to return iterator and update docs

---
 doc/api.rst           | 23 +++++++++++------------
 include/fmt/core.h    | 25 ++++++++++++++-----------
 include/fmt/format.h  | 31 ++++++++++++++++---------------
 include/fmt/ostream.h |  2 +-
 4 files changed, 42 insertions(+), 39 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index de5604b4..1c9d1bc2 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -4,9 +4,8 @@
 API Reference
 *************
 
-All functions and classes provided by the fmt library reside in namespace
-``fmt`` and macros have prefix ``FMT_``. For brevity the namespace is usually
-omitted in examples.
+All functions and classes provided by the {fmt} library reside in namespace
+``fmt`` and macros have prefix ``FMT_``.
 
 Format API
 ==========
@@ -60,28 +59,28 @@ Formatting user-defined types
 To make a user-defined type formattable, specialize the ``formatter<T>`` struct
 template and implement ``parse`` and ``format`` methods::
 
-  struct MyStruct { double x, y; };
+  struct point { double x, y; };
 
   namespace fmt {
   template <>
-  struct formatter<MyStruct> {
+  struct formatter<point> {
     template <typename ParseContext>
     auto parse(ParseContext &ctx) { return ctx.begin(); }
 
     template <typename FormatContext>
-    auto format(const MyStruct &s, FormatContext &ctx) {
-      return format_to(ctx.begin(), "[MyStruct: x={:.1f}, y={:.2f}]", s.x, s.y);
+    auto format(const point &p, FormatContext &ctx) {
+      return format_to(ctx.begin(), "({:.1f}, {:.1f})", p.x, p.y);
     }
   };
   }
 
-Then you can pass objects of type ``MyStruct`` to any formatting function::
+Then you can pass objects of type ``point`` to any formatting function::
 
-  MyStruct m = {1, 2};
-  std::string s = fmt::format("m={}", m);
-  // s == "m=[MyStruct: x=1.0, y=2.00]"
+  point p = {1, 2};
+  std::string s = fmt::format("{}", p);
+  // s == "(1.0, 2.0)"
 
-In the example above the ``formatter<MyStruct>::parse`` function ignores the
+In the example above the ``formatter<point>::parse`` function ignores the
 contents of the format string referred to by ``ctx.begin()`` so the object will
 always be formatted in the same way. See ``formatter<tm>::parse`` in
 :file:`fmt/time.h` for an advanced example of how to parse the format string and
diff --git a/include/fmt/core.h b/include/fmt/core.h
index fe214cf0..ebcf7cfe 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1118,7 +1118,7 @@ struct named_arg : named_arg_base<Char> {
 
   **Example**::
 
-    print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
+    fmt::print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
   \endrst
  */
 template <typename T>
@@ -1144,7 +1144,7 @@ FMT_API void vprint_colored(Color c, string_view format, format_args args);
   Formats a string and prints it to stdout using ANSI escape sequences to
   specify color (experimental).
   Example:
-    print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
+    fmt::print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
  */
 template <typename... Args>
 inline void print_colored(Color c, string_view format_str,
@@ -1152,10 +1152,10 @@ inline void print_colored(Color c, string_view format_str,
   vprint_colored(c, format_str, make_args(args...));
 }
 
-void vformat_to(internal::buffer &buf, string_view format_str,
-                format_args args);
-void vformat_to(internal::wbuffer &buf, wstring_view format_str,
-                wformat_args args);
+context::iterator vformat_to(internal::buffer &buf, string_view format_str,
+                             format_args args);
+wcontext::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str,
+                               wformat_args args);
 
 template <typename Container>
 struct is_contiguous : std::false_type {};
@@ -1168,11 +1168,14 @@ struct is_contiguous<fmt::internal::basic_buffer<Char>> : std::true_type {};
 
 /** Formats a string and writes the output to ``out``. */
 template <typename Container>
-typename std::enable_if<is_contiguous<Container>::value>::type
+typename std::enable_if<
+  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
     vformat_to(std::back_insert_iterator<Container> out,
                string_view format_str, format_args args) {
-  internal::container_buffer<Container> buf(internal::get_container(out));
+  auto& container = internal::get_container(out);
+  internal::container_buffer<Container> buf(container);
   vformat_to(buf, format_str, args);
+  return std::back_inserter(container);
 }
 
 std::string vformat(string_view format_str, format_args args);
@@ -1184,7 +1187,7 @@ std::wstring vformat(wstring_view format_str, wformat_args args);
 
   **Example**::
 
-    std::string message = format("The answer is {}", 42);
+    std::string message = fmt::format("The answer is {}", 42);
   \endrst
 */
 template <typename... Args>
@@ -1204,7 +1207,7 @@ FMT_API void vprint(std::FILE *f, string_view format_str, format_args args);
 
   **Example**::
 
-    print(stderr, "Don't {}!", "panic");
+    fmt::print(stderr, "Don't {}!", "panic");
   \endrst
  */
 template <typename... Args>
@@ -1220,7 +1223,7 @@ FMT_API void vprint(string_view format_str, format_args args);
 
   **Example**::
 
-    print("Elapsed time: {0:.2f} seconds", 1.23);
+    fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
   \endrst
  */
 template <typename... Args>
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 5d3edd6f..94b1cfcb 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2146,7 +2146,7 @@ class arg_formatter:
 
   using base::operator();
 
-  /** Formats an argument of a custom (user-defined) type. */
+  /** Formats an argument of a user-defined type. */
   void operator()(typename basic_arg<context_type>::handle handle) const {
     handle.format(ctx_);
   }
@@ -3324,28 +3324,28 @@ std::basic_string<Char> to_string(const basic_memory_buffer<Char> &buffer) {
   return std::basic_string<Char>(buffer.data(), buffer.size());
 }
 
-inline void vformat_to(internal::buffer &buf, string_view format_str,
-                       format_args args) {
+inline context::iterator vformat_to(
+    internal::buffer &buf, string_view format_str, format_args args) {
   typedef back_insert_range<internal::buffer> range;
-  vformat_to<arg_formatter<range>>(buf, format_str, args);
+  return vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
-inline void vformat_to(internal::wbuffer &buf, wstring_view format_str,
-                       wformat_args args) {
+inline wcontext::iterator vformat_to(
+    internal::wbuffer &buf, wstring_view format_str, wformat_args args) {
   typedef back_insert_range<internal::wbuffer> range;
-  vformat_to<arg_formatter<range>>(buf, format_str, args);
+  return vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
 template <typename... Args>
-inline void format_to(memory_buffer &buf, string_view format_str,
-                      const Args & ... args) {
-  vformat_to(buf, format_str, make_args(args...));
+inline context::iterator format_to(
+    memory_buffer &buf, string_view format_str, const Args & ... args) {
+  return vformat_to(buf, format_str, make_args(args...));
 }
 
 template <typename... Args>
-inline void format_to(wmemory_buffer &buf, wstring_view format_str,
-                      const Args & ... args) {
-  vformat_to(buf, format_str, make_args<wcontext>(args...));
+inline wcontext::iterator format_to(
+    wmemory_buffer &buf, wstring_view format_str, const Args & ... args) {
+  return vformat_to(buf, format_str, make_args<wcontext>(args...));
 }
 
 template <typename OutputIt, typename Char = char>
@@ -3373,10 +3373,11 @@ inline OutputIt format_to(OutputIt out, string_view format_str,
 }
 
 template <typename Container, typename... Args>
-inline typename std::enable_if<is_contiguous<Container>::value>::type
+inline typename std::enable_if<
+  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
     format_to(std::back_insert_iterator<Container> out,
               string_view format_str, const Args & ... args) {
-  vformat_to(out, format_str, make_args(args...));
+  return vformat_to(out, format_str, make_args(args...));
 }
 
 inline std::string vformat(string_view format_str, format_args args) {
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index 3ec8919a..3ac5cd65 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -133,7 +133,7 @@ inline void vprint(std::ostream &os, string_view format_str, format_args args) {
 
   **Example**::
 
-    print(cerr, "Don't {}!", "panic");
+    fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
 template <typename... Args>

From 86a9bc82915e21672b50af29a8f9cfa10581c364 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 09:16:51 -0800
Subject: [PATCH 47/62] Cleanup

---
 doc/api.rst                   | 10 +++++-----
 test/assert-test.cc           | 35 ++++++++---------------------------
 test/custom-formatter-test.cc | 26 ++++++++++----------------
 test/format-impl-test.cc      | 34 +++++++---------------------------
 test/format-test.cc           | 32 ++++++--------------------------
 test/gtest-extra-test.cc      | 32 ++++++--------------------------
 test/gtest-extra.cc           | 32 ++++++--------------------------
 test/gtest-extra.h            | 32 ++++++--------------------------
 test/mock-allocator.h         | 32 ++++++--------------------------
 test/ostream-test.cc          | 32 ++++++--------------------------
 test/posix-mock-test.cc       | 32 ++++++--------------------------
 test/posix-mock.h             | 32 ++++++--------------------------
 test/posix-test.cc            | 32 ++++++--------------------------
 test/printf-test.cc           | 32 ++++++--------------------------
 test/test-assert.h            | 32 ++++++--------------------------
 test/test-main.cc             | 32 ++++++--------------------------
 test/time-test.cc             | 14 ++++++--------
 test/util-test.cc             | 32 ++++++--------------------------
 test/util.cc                  | 32 ++++++--------------------------
 test/util.h                   | 32 ++++++--------------------------
 20 files changed, 126 insertions(+), 473 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index 1c9d1bc2..88e4f75f 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -65,7 +65,7 @@ template and implement ``parse`` and ``format`` methods::
   template <>
   struct formatter<point> {
     template <typename ParseContext>
-    auto parse(ParseContext &ctx) { return ctx.begin(); }
+    constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
 
     template <typename FormatContext>
     auto format(const point &p, FormatContext &ctx) {
@@ -98,17 +98,17 @@ formatting of user-defined types that have overloaded ``operator<<``::
 
   #include "fmt/ostream.h"
 
-  class Date {
+  class date {
     int year_, month_, day_;
   public:
-    Date(int year, int month, int day): year_(year), month_(month), day_(day) {}
+    date(int year, int month, int day): year_(year), month_(month), day_(day) {}
 
-    friend std::ostream &operator<<(std::ostream &os, const Date &d) {
+    friend std::ostream &operator<<(std::ostream &os, const date &d) {
       return os << d.year_ << '-' << d.month_ << '-' << d.day_;
     }
   };
 
-  std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
+  std::string s = fmt::format("The date is {}", date(2012, 12, 9));
   // s == "The date is 2012-12-9"
 
 .. doxygenfunction:: print(std::ostream&, string_view, const Args&...)
diff --git a/test/assert-test.cc b/test/assert-test.cc
index 897740c0..29c6d40b 100644
--- a/test/assert-test.cc
+++ b/test/assert-test.cc
@@ -1,29 +1,9 @@
-/*
- Assertion tests
-
- Copyright (c) 2015, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - assertion tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include "fmt/core.h"
 #include "gtest/gtest.h"
@@ -37,5 +17,6 @@
 #endif
 
 TEST(AssertTest, Fail) {
-  EXPECT_DEBUG_DEATH_IF_SUPPORTED(FMT_ASSERT(false, "don't panic!"), "don't panic!");
+  EXPECT_DEBUG_DEATH_IF_SUPPORTED(
+      FMT_ASSERT(false, "don't panic!"), "don't panic!");
 }
diff --git a/test/custom-formatter-test.cc b/test/custom-formatter-test.cc
index 8eda9154..b7a85a5a 100644
--- a/test/custom-formatter-test.cc
+++ b/test/custom-formatter-test.cc
@@ -1,28 +1,22 @@
-/*
- Custom argument formatter tests
+// Formatting library for C++ - custom argument formatter tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
- Copyright (c) 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-#include "fmt/printf.h"
+#include "fmt/format.h"
 #include "gtest-extra.h"
 
-using fmt::printf_arg_formatter;
-
 // A custom argument formatter that doesn't print `-` for floating-point values
 // rounded to 0.
-class CustomArgFormatter :
+class custom_arg_formatter :
     public fmt::arg_formatter<fmt::back_insert_range<fmt::internal::buffer>> {
  public:
   typedef fmt::back_insert_range<fmt::internal::buffer> range;
-  typedef decltype(fmt::internal::declval<range>().begin()) iterator;
   typedef fmt::arg_formatter<range> base;
 
-  CustomArgFormatter(fmt::basic_context<iterator, char> &ctx,
-                     fmt::format_specs &s)
+  custom_arg_formatter(fmt::context &ctx, fmt::format_specs &s)
   : base(ctx, s) {}
 
   using base::operator();
@@ -37,7 +31,7 @@ class CustomArgFormatter :
 std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
   fmt::memory_buffer buffer;
   // Pass custom argument formatter as a template arg to vwrite.
-  fmt::vformat_to<CustomArgFormatter>(buffer, format_str, args);
+  fmt::vformat_to<custom_arg_formatter>(buffer, format_str, args);
   return std::string(buffer.data(), buffer.size());
 }
 
diff --git a/test/format-impl-test.cc b/test/format-impl-test.cc
index 3d7f1150..f5f29f50 100644
--- a/test/format-impl-test.cc
+++ b/test/format-impl-test.cc
@@ -1,35 +1,15 @@
-/*
- Formatting library implementation tests.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - formatting library implementation tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #define FMT_NOEXCEPT
 #undef FMT_SHARED
 #include "test-assert.h"
 
-// Include format.cc instead of format.h to test implementation-specific stuff.
+// Include format.cc instead of format.h to test implementation.
 #include "fmt/format.cc"
 #include "fmt/printf.h"
 
diff --git a/test/format-test.cc b/test/format-test.cc
index f118c8d6..19b57d62 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1,29 +1,9 @@
-/*
- Formatting library tests.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - formatting library tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include <cctype>
 #include <cfloat>
diff --git a/test/gtest-extra-test.cc b/test/gtest-extra-test.cc
index b86a5636..2043f549 100644
--- a/test/gtest-extra-test.cc
+++ b/test/gtest-extra-test.cc
@@ -1,29 +1,9 @@
-/*
- Tests of custom Google Test assertions.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - tests of custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include "gtest-extra.h"
 
diff --git a/test/gtest-extra.cc b/test/gtest-extra.cc
index 307bd84d..21a7ea97 100644
--- a/test/gtest-extra.cc
+++ b/test/gtest-extra.cc
@@ -1,29 +1,9 @@
-/*
- Custom Google Test assertions.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include "gtest-extra.h"
 
diff --git a/test/gtest-extra.h b/test/gtest-extra.h
index cb739575..198d9b1e 100644
--- a/test/gtest-extra.h
+++ b/test/gtest-extra.h
@@ -1,29 +1,9 @@
-/*
- Custom Google Test assertions.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #ifndef FMT_GTEST_EXTRA_H_
 #define FMT_GTEST_EXTRA_H_
diff --git a/test/mock-allocator.h b/test/mock-allocator.h
index 96a41352..e32b3816 100644
--- a/test/mock-allocator.h
+++ b/test/mock-allocator.h
@@ -1,29 +1,9 @@
-/*
- Mock allocator.
-
- Copyright (c) 2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - mock allocator
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #ifndef FMT_MOCK_ALLOCATOR_H_
 #define FMT_MOCK_ALLOCATOR_H_
diff --git a/test/ostream-test.cc b/test/ostream-test.cc
index 41f65396..6ded223e 100644
--- a/test/ostream-test.cc
+++ b/test/ostream-test.cc
@@ -1,29 +1,9 @@
-/*
- std::ostream support tests
-
- Copyright (c) 2012-2016, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - std::ostream support tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include "fmt/ostream.h"
 
diff --git a/test/posix-mock-test.cc b/test/posix-mock-test.cc
index f17d87da..6c913285 100644
--- a/test/posix-mock-test.cc
+++ b/test/posix-mock-test.cc
@@ -1,29 +1,9 @@
-/*
- Tests of the C++ interface to POSIX functions that require mocks
-
- Copyright (c) 2012-2015, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Tests of the C++ interface to POSIX functions that require mocks
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 // Disable bogus MSVC warnings.
 #define _CRT_SECURE_NO_WARNINGS
diff --git a/test/posix-mock.h b/test/posix-mock.h
index 32dd6639..eb575579 100644
--- a/test/posix-mock.h
+++ b/test/posix-mock.h
@@ -1,29 +1,9 @@
-/*
- Mocks of POSIX functions
-
- Copyright (c) 2012-2015, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - mocks of POSIX functions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #ifndef FMT_POSIX_TEST_H
 #define FMT_POSIX_TEST_H
diff --git a/test/posix-test.cc b/test/posix-test.cc
index a0b2c90d..d6b1953c 100644
--- a/test/posix-test.cc
+++ b/test/posix-test.cc
@@ -1,29 +1,9 @@
-/*
- Tests of the C++ interface to POSIX functions
-
- Copyright (c) 2015, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - tests of the C++ interface to POSIX functions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include <cstdlib>  // std::exit
 #include <cstring>
diff --git a/test/printf-test.cc b/test/printf-test.cc
index 15003316..c6e56700 100644
--- a/test/printf-test.cc
+++ b/test/printf-test.cc
@@ -1,29 +1,9 @@
-/*
- printf tests.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - printf tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include <cctype>
 #include <climits>
diff --git a/test/test-assert.h b/test/test-assert.h
index 281b2367..a074263d 100644
--- a/test/test-assert.h
+++ b/test/test-assert.h
@@ -1,29 +1,9 @@
-/*
- Test version of FMT_ASSERT
-
- Copyright (c) 2015, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - test version of FMT_ASSERT
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #ifndef FMT_TEST_ASSERT_H
 #define FMT_TEST_ASSERT_H
diff --git a/test/test-main.cc b/test/test-main.cc
index 34731ea8..2749a644 100644
--- a/test/test-main.cc
+++ b/test/test-main.cc
@@ -1,29 +1,9 @@
-/*
- Test main function.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - test main function.
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include <cstdlib>
 #include <gtest/gtest.h>
diff --git a/test/time-test.cc b/test/time-test.cc
index 702febe3..e285223b 100644
--- a/test/time-test.cc
+++ b/test/time-test.cc
@@ -1,11 +1,9 @@
-/*
- Time formatting tests
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
+// Formatting library for C++ - time formatting tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #ifdef WIN32
 #define _CRT_SECURE_NO_WARNINGS
diff --git a/test/util-test.cc b/test/util-test.cc
index eb1c09d9..474fe144 100644
--- a/test/util-test.cc
+++ b/test/util-test.cc
@@ -1,29 +1,9 @@
-/*
- Utility tests.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - utility tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include "test-assert.h"
 
diff --git a/test/util.cc b/test/util.cc
index 7b1cdb57..17837414 100644
--- a/test/util.cc
+++ b/test/util.cc
@@ -1,29 +1,9 @@
-/*
- Test utilities.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - test utilities
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include "util.h"
 #include <cstring>
diff --git a/test/util.h b/test/util.h
index b7faf62a..16aae737 100644
--- a/test/util.h
+++ b/test/util.h
@@ -1,29 +1,9 @@
-/*
- Test utilities.
-
- Copyright (c) 2012-2014, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+// Formatting library for C++ - test utilities
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
 
 #include <cstdarg>
 #include <cstdio>

From 40232917598d246c24f3730d8758658239cb0d86 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 09:55:17 -0800
Subject: [PATCH 48/62] Update docs

---
 doc/api.rst          | 37 +++++++++++++++++++++----------------
 include/fmt/core.h   |  4 ++--
 include/fmt/format.h |  6 +++---
 include/fmt/printf.h |  2 +-
 4 files changed, 27 insertions(+), 22 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index 88e4f75f..f79e1688 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -187,14 +187,14 @@ Write API
 The write API provides classes for writing formatted data into character
 streams. It is usually faster than the `format API`_ but, as IOStreams,
 may result in larger compiled code size. The main writer class is
-`~fmt::BasicMemoryWriter` which stores its output in a memory buffer and
+`~fmt::basic_memory_writer` which stores its output in a memory buffer and
 provides direct access to it. It is possible to create custom writers that
 store output elsewhere by subclassing `~fmt::BasicWriter`.
 
 .. doxygenclass:: fmt::BasicWriter
    :members:
 
-.. doxygenclass:: fmt::BasicMemoryWriter
+.. doxygenclass:: fmt::basic_memory_writer
    :members:
 
 .. doxygenclass:: fmt::BasicArrayWriter
@@ -220,8 +220,6 @@ Utilities
 
 .. doxygenfunction:: operator""_a(const char *, std::size_t)
 
-.. doxygendefine:: FMT_CAPTURE
-
 .. doxygenclass:: fmt::basic_format_args
    :members:
 
@@ -230,7 +228,7 @@ Utilities
 .. doxygenclass:: fmt::basic_string_view
    :members:
 
-.. doxygenclass:: fmt::Buffer
+.. doxygenclass:: fmt::basic_memory_buffer
    :protected-members:
    :members:
 
@@ -250,22 +248,29 @@ System errors
 Custom allocators
 =================
 
-The fmt library supports custom dynamic memory allocators.
+The {fmt} library supports custom dynamic memory allocators.
 A custom allocator class can be specified as a template argument to
-:class:`fmt::BasicMemoryWriter`::
+:class:`fmt::basic_memory_buffer`::
 
-    typedef fmt::BasicMemoryWriter<char, CustomAllocator> CustomMemoryWriter;
+    using custom_memory_buffer = 
+      fmt::basic_memory_buffer<char, custom_allocator>;
 
 It is also possible to write a formatting function that uses a custom
 allocator::
 
-    typedef std::basic_string<char, std::char_traits<char>, CustomAllocator>
-            CustomString;
+    using custom_string =
+      std::basic_string<char, std::char_traits<char>, custom_allocator>;
 
-    CustomString format(CustomAllocator alloc, fmt::CStringRef format_str,
-                        fmt::ArgList args) {
-      CustomMemoryWriter writer(alloc);
-      writer.write(format_str, args);
-      return CustomString(writer.data(), writer.size(), alloc);
+    custom_string format(custom_allocator alloc, fmt::string_view format_str,
+                         fmt::format_args args) {
+      custom_memory_buffer buf(alloc);
+      fmt::vformat_to(buf, format_str, args);
+      return custom_string(buf.data(), buf.size(), alloc);
+    }
+
+    template <typename ...Args>
+    inline custom_string format(custom_allocator alloc,
+                                fmt::string_view format_str,
+                                const Args & ... args) {
+      return vformat(alloc, format_str, fmt::make_args(args...));
     }
-    FMT_VARIADIC(CustomString, format, CustomAllocator, fmt::CStringRef)
diff --git a/include/fmt/core.h b/include/fmt/core.h
index ebcf7cfe..166447b1 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1114,11 +1114,11 @@ struct named_arg : named_arg_base<Char> {
 
 /**
   \rst
-  Returns a named argument for formatting functions.
+  Returns a named argument to be used in a formatting function.
 
   **Example**::
 
-    fmt::print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
+    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
   \endrst
  */
 template <typename T>
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 94b1cfcb..32652a67 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -374,7 +374,7 @@ class locale_provider {
 /**
   \rst
   A dynamically growing memory buffer for trivially copyable/constructible types
-  with the first SIZE elements stored in the object itself.
+  with the first ``SIZE`` elements stored in the object itself.
 
   You can use one of the following typedefs for common character types:
 
@@ -388,7 +388,7 @@ class locale_provider {
 
   **Example**::
 
-     memory_buffer out;
+     fmt::memory_buffer out;
      format_to(out, "The answer is {}.", 42);
 
   This will write the following output to the ``out`` object:
@@ -3487,7 +3487,7 @@ operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
   **Example**::
 
     using namespace fmt::literals;
-    print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
+    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
   \endrst
  */
 inline internal::udl_arg<char>
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index 4bc92253..9a189844 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -635,7 +635,7 @@ inline int vfprintf(std::ostream &os, string_view format_str,
 
   **Example**::
 
-    fprintf(cerr, "Don't %s!", "panic");
+    fmt::fprintf(cerr, "Don't %s!", "panic");
   \endrst
  */
 template <typename... Args>

From 995b63adfe263fb95f7c996465f77a30ccae0e0f Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 10:11:44 -0800
Subject: [PATCH 49/62] Update copyright

---
 doc/conf.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/conf.py b/doc/conf.py
index 1e9010e7..0756192b 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -47,7 +47,7 @@ source_suffix = '.rst'
 
 # General information about the project.
 project = u'fmt'
-copyright = u'2012-2015, Victor Zverovich'
+copyright = u'2012-present, Victor Zverovich'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the

From f1ede6380b490351f8495c0c03125721f9e9db4f Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 10:33:42 -0800
Subject: [PATCH 50/62] Make inline_buffer_size public and update docs

---
 doc/api.rst              |  6 +++---
 include/fmt/format.cc    | 10 +++++-----
 include/fmt/format.h     | 10 +++++-----
 test/format-impl-test.cc |  6 +++---
 test/format-test.cc      |  4 ++--
 test/util-test.cc        |  4 ++--
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index f79e1688..2899e880 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -253,7 +253,7 @@ A custom allocator class can be specified as a template argument to
 :class:`fmt::basic_memory_buffer`::
 
     using custom_memory_buffer = 
-      fmt::basic_memory_buffer<char, custom_allocator>;
+      fmt::basic_memory_buffer<char, fmt::inline_buffer_size, custom_allocator>;
 
 It is also possible to write a formatting function that uses a custom
 allocator::
@@ -261,8 +261,8 @@ allocator::
     using custom_string =
       std::basic_string<char, std::char_traits<char>, custom_allocator>;
 
-    custom_string format(custom_allocator alloc, fmt::string_view format_str,
-                         fmt::format_args args) {
+    custom_string vformat(custom_allocator alloc, fmt::string_view format_str,
+                          fmt::format_args args) {
       custom_memory_buffer buf(alloc);
       fmt::vformat_to(buf, format_str, args);
       return custom_string(buf.data(), buf.size(), alloc);
diff --git a/include/fmt/format.cc b/include/fmt/format.cc
index edecd87d..0e7abb23 100644
--- a/include/fmt/format.cc
+++ b/include/fmt/format.cc
@@ -166,7 +166,7 @@ int safe_strerror(
 void format_error_code(internal::buffer &out, int error_code,
                        string_view message) FMT_NOEXCEPT {
   // Report error code making sure that the output fits into
-  // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
+  // inline_buffer_size to avoid dynamic memory allocation and potential
   // bad_alloc.
   out.resize(0);
   static const char SEP[] = ": ";
@@ -181,13 +181,13 @@ void format_error_code(internal::buffer &out, int error_code,
   }
   error_code_size += internal::count_digits(abs_value);
   writer w(out);
-  if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size) {
+  if (message.size() <= inline_buffer_size - error_code_size) {
     w.write(message);
     w.write(SEP);
   }
   w.write(ERROR_STR);
   w.write(error_code);
-  assert(out.size() <= internal::INLINE_BUFFER_SIZE);
+  assert(out.size() <= inline_buffer_size);
 }
 
 void report_error(FormatFunc func, int error_code,
@@ -332,7 +332,7 @@ FMT_FUNC void internal::format_windows_error(
     internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
   FMT_TRY {
     wmemory_buffer buf;
-    buf.resize(INLINE_BUFFER_SIZE);
+    buf.resize(inline_buffer_size);
     for (;;) {
       wchar_t *system_message = &buf[0];
       int result = FormatMessageW(
@@ -364,7 +364,7 @@ FMT_FUNC void format_system_error(
     internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
   FMT_TRY {
     memory_buffer buf;
-    buf.resize(internal::INLINE_BUFFER_SIZE);
+    buf.resize(inline_buffer_size);
     for (;;) {
       char *system_message = &buf[0];
       int result = safe_strerror(error_code, system_message, buf.size());
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 32652a67..d85d7f7b 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -335,10 +335,6 @@ FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
   return static_cast<typename std::make_unsigned<Int>::type>(value);
 }
 
-// The number of characters to store in the basic_memory_buffer object itself
-// to avoid dynamic memory allocation.
-enum { INLINE_BUFFER_SIZE = 500 };
-
 #if FMT_SECURE_SCL
 // Use checked iterator to avoid warnings on MSVC.
 template <typename T>
@@ -371,6 +367,10 @@ class locale_provider {
   virtual fmt::locale locale();
 };
 
+// The number of characters to store in the basic_memory_buffer object itself
+// to avoid dynamic memory allocation.
+enum { inline_buffer_size = 500 };
+
 /**
   \rst
   A dynamically growing memory buffer for trivially copyable/constructible types
@@ -400,7 +400,7 @@ class locale_provider {
   The output can be converted to an ``std::string`` with ``to_string(out)``.
   \endrst
  */
-template <typename T, std::size_t SIZE = internal::INLINE_BUFFER_SIZE,
+template <typename T, std::size_t SIZE = inline_buffer_size,
           typename Allocator = std::allocator<T> >
 class basic_memory_buffer: private Allocator, public internal::basic_buffer<T> {
  private:
diff --git a/test/format-impl-test.cc b/test/format-impl-test.cc
index f5f29f50..c234c1b4 100644
--- a/test/format-impl-test.cc
+++ b/test/format-impl-test.cc
@@ -94,7 +94,7 @@ TEST(FormatTest, FormatErrorCode) {
   {
     fmt::memory_buffer buffer;
     std::string prefix(
-        fmt::internal::INLINE_BUFFER_SIZE - msg.size() - sep.size() + 1, 'x');
+        fmt::inline_buffer_size - msg.size() - sep.size() + 1, 'x');
     fmt::format_error_code(buffer, 42, prefix);
     EXPECT_EQ(msg, to_string(buffer));
   }
@@ -104,10 +104,10 @@ TEST(FormatTest, FormatErrorCode) {
     msg = fmt::format("error {}", codes[i]);
     fmt::memory_buffer buffer;
     std::string prefix(
-        fmt::internal::INLINE_BUFFER_SIZE - msg.size() - sep.size(), 'x');
+        fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
     fmt::format_error_code(buffer, codes[i], prefix);
     EXPECT_EQ(prefix + sep + msg, to_string(buffer));
-    std::size_t size = fmt::internal::INLINE_BUFFER_SIZE;
+    std::size_t size = fmt::inline_buffer_size;
     EXPECT_EQ(size, buffer.size());
     buffer.resize(0);
     // Test with a message that doesn't fit into the buffer.
diff --git a/test/format-test.cc b/test/format-test.cc
index 19b57d62..fcf2322f 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -192,11 +192,11 @@ TEST(WriterTest, WriteDoubleWithFilledBuffer) {
   memory_buffer buf;
   fmt::writer writer(buf);
   // Fill the buffer.
-  for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i)
+  for (int i = 0; i < fmt::inline_buffer_size; ++i)
     writer.write(' ');
   writer.write(1.2);
   fmt::string_view sv(buf.data(), buf.size());
-  sv.remove_prefix(fmt::internal::INLINE_BUFFER_SIZE);
+  sv.remove_prefix(fmt::inline_buffer_size);
   EXPECT_EQ("1.2", sv);
 }
 
diff --git a/test/util-test.cc b/test/util-test.cc
index 474fe144..97dabfbb 100644
--- a/test/util-test.cc
+++ b/test/util-test.cc
@@ -341,7 +341,7 @@ TEST(MemoryBufferTest, Allocator) {
   {
     basic_memory_buffer<char, 10, TestAllocator> buffer2((TestAllocator(&alloc)));
     EXPECT_EQ(&alloc, buffer2.get_allocator().get());
-    std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
+    std::size_t size = 2 * fmt::inline_buffer_size;
     EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
     buffer2.reserve(size);
     EXPECT_CALL(alloc, deallocate(&mem, size));
@@ -352,7 +352,7 @@ TEST(MemoryBufferTest, ExceptionInDeallocate) {
   typedef AllocatorRef< MockAllocator<char> > TestAllocator;
   StrictMock< MockAllocator<char> > alloc;
   basic_memory_buffer<char, 10, TestAllocator> buffer((TestAllocator(&alloc)));
-  std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
+  std::size_t size = 2 * fmt::inline_buffer_size;
   std::vector<char> mem(size);
   {
     EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));

From bb47109a7815848b44dea2ac5afd39fa197aabc0 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 11:25:40 -0800
Subject: [PATCH 51/62] Cleanup

---
 include/fmt/core.h    | 11 +++--------
 include/fmt/format.cc |  2 +-
 include/fmt/format.h  |  5 +++++
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 166447b1..e11a8986 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -397,11 +397,6 @@ class container_buffer : public basic_buffer<typename Container::value_type> {
       container_(c) {}
 };
 
-// A helper function to suppress bogus "conditional expression is constant"
-// warnings.
-template <typename T>
-inline T const_check(T value) { return value; }
-
 struct error_handler {
   FMT_CONSTEXPR error_handler() {}
   FMT_CONSTEXPR error_handler(const error_handler &) {}
@@ -1136,9 +1131,9 @@ inline internal::named_arg<T, wchar_t> arg(wstring_view name, const T &arg) {
 template <typename S, typename T, typename Char>
 void arg(S, internal::named_arg<T, Char>) FMT_DELETED;
 
-enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
+enum color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
 
-FMT_API void vprint_colored(Color c, string_view format, format_args args);
+FMT_API void vprint_colored(color c, string_view format, format_args args);
 
 /**
   Formats a string and prints it to stdout using ANSI escape sequences to
@@ -1147,7 +1142,7 @@ FMT_API void vprint_colored(Color c, string_view format, format_args args);
     fmt::print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
  */
 template <typename... Args>
-inline void print_colored(Color c, string_view format_str,
+inline void print_colored(color c, string_view format_str,
                           const Args & ... args) {
   vprint_colored(c, format_str, make_args(args...));
 }
diff --git a/include/fmt/format.cc b/include/fmt/format.cc
index 0e7abb23..cff18aad 100644
--- a/include/fmt/format.cc
+++ b/include/fmt/format.cc
@@ -414,7 +414,7 @@ FMT_FUNC void vprint(string_view format_str, format_args args) {
   vprint(stdout, format_str, args);
 }
 
-FMT_FUNC void vprint_colored(Color c, string_view format, format_args args) {
+FMT_FUNC void vprint_colored(color c, string_view format, format_args args) {
   char escape[] = "\x1b[30m";
   escape[3] = static_cast<char>('0' + c);
   std::fputs(escape, stdout);
diff --git a/include/fmt/format.h b/include/fmt/format.h
index d85d7f7b..2ec2f889 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -262,6 +262,11 @@ typename Allocator::value_type *allocate(Allocator& alloc, std::size_t n) {
   return alloc.allocate(n);
 #endif
 }
+
+// A helper function to suppress bogus "conditional expression is constant"
+// warnings.
+template <typename T>
+inline T const_check(T value) { return value; }
 }  // namespace internal
 }  // namespace fmt
 

From a103b9bc4634c7f3ca38819e17073d4a9fa2ec15 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 11:45:20 -0800
Subject: [PATCH 52/62] Workaround missed optimization in gcc (#668)

---
 include/fmt/core.h | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index e11a8986..b30ed4c8 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1187,11 +1187,16 @@ std::wstring vformat(wstring_view format_str, wformat_args args);
 */
 template <typename... Args>
 inline std::string format(string_view format_str, const Args & ... args) {
-  return vformat(format_str, make_args(args...));
+  // This should be just
+  // return vformat(format_str, make_args(args...));
+  // but gcc has trouble optimizing the latter, so break it down.
+  arg_store<context, Args...> as(args...);
+  return vformat(format_str, as);
 }
 template <typename... Args>
 inline std::wstring format(wstring_view format_str, const Args & ... args) {
-  return vformat(format_str, make_args<wcontext>(args...));
+  arg_store<wcontext, Args...> as(args...);
+  return vformat(format_str, as);
 }
 
 FMT_API void vprint(std::FILE *f, string_view format_str, format_args args);
@@ -1207,7 +1212,8 @@ FMT_API void vprint(std::FILE *f, string_view format_str, format_args args);
  */
 template <typename... Args>
 inline void print(std::FILE *f, string_view format_str, const Args & ... args) {
-  vprint(f, format_str, make_args(args...));
+  arg_store<context, Args...> as(args...);
+  vprint(f, format_str, as);
 }
 
 FMT_API void vprint(string_view format_str, format_args args);
@@ -1223,7 +1229,8 @@ FMT_API void vprint(string_view format_str, format_args args);
  */
 template <typename... Args>
 inline void print(string_view format_str, const Args & ... args) {
-  vprint(format_str, make_args(args...));
+  arg_store<context, Args...> as(args...);
+  vprint(format_str, as);
 }
 }  // namespace fmt
 

From f867d082398185bb935151a8d06b4ff28c29b2e7 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 12:09:34 -0800
Subject: [PATCH 53/62] Update docs

---
 doc/api.rst        | 17 +++++++++++------
 include/fmt/core.h |  1 +
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index 2899e880..b79810b1 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -29,8 +29,6 @@ to that of glibc's ``printf`` and better than the performance of IOStreams.
 
 .. doxygenfunction:: format(string_view, const Args&...)
 
-.. doxygenfunction:: operator""_format(const char *, std::size_t)
-
 .. _print:
 
 .. doxygenfunction:: print(string_view, const Args&...)
@@ -113,8 +111,17 @@ formatting of user-defined types that have overloaded ``operator<<``::
 
 .. doxygenfunction:: print(std::ostream&, string_view, const Args&...)
 
-Argument formatters
--------------------
+Literal-based API
+-----------------
+
+The following user-defined literals are defined in ``fmt/format.h``.
+
+.. doxygenfunction:: operator""_format(const char *, std::size_t)
+
+.. doxygenfunction:: operator""_a(const char *, std::size_t)
+
+Custom formatting of built-in types
+-----------------------------------
 
 It is possible to change the way arguments are formatted by providing a
 custom argument formatter class::
@@ -218,8 +225,6 @@ Utilities
 
 .. doxygenfunction:: fmt::arg(string_view, const T&)
 
-.. doxygenfunction:: operator""_a(const char *, std::size_t)
-
 .. doxygenclass:: fmt::basic_format_args
    :members:
 
diff --git a/include/fmt/core.h b/include/fmt/core.h
index b30ed4c8..2cf83894 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1182,6 +1182,7 @@ std::wstring vformat(wstring_view format_str, wformat_args args);
 
   **Example**::
 
+    #include "fmt/core.h"
     std::string message = fmt::format("The answer is {}", 42);
   \endrst
 */

From 7755cdc199f552e1f1b8e162677c09d459048a8a Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 14:46:24 -0800
Subject: [PATCH 54/62] Make symbols readable

---
 include/fmt/core.h    | 7 ++++++-
 include/fmt/format.cc | 3 ++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 2cf83894..8953e513 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1077,7 +1077,12 @@ class basic_format_args {
   }
 };
 
-typedef basic_format_args<context> format_args;
+// This is a separate type rather than a typedef to make symbols readable.
+struct format_args: basic_format_args<context> {
+  template <typename ...Args>
+  format_args(Args && ... arg)
+  : basic_format_args<context>(std::forward<Args>(arg)...) {};
+};
 typedef basic_format_args<wcontext> wformat_args;
 
 namespace internal {
diff --git a/include/fmt/format.cc b/include/fmt/format.cc
index cff18aad..429657fb 100644
--- a/include/fmt/format.cc
+++ b/include/fmt/format.cc
@@ -434,7 +434,8 @@ template char internal::thousands_sep(locale_provider *lp);
 
 template void basic_fixed_buffer<char>::grow(std::size_t);
 
-template void internal::arg_map<context>::init(const format_args &args);
+template void internal::arg_map<context>::init(
+    const basic_format_args<context> &args);
 
 template FMT_API int internal::char_traits<char>::format_float(
     char *buffer, std::size_t size, const char *format,

From 585512fc7cdcda4b5f0ff5559c91c5859bf7f5dd Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 4 Mar 2018 15:14:02 -0800
Subject: [PATCH 55/62] Remove unnecessary instantiations

---
 include/fmt/core.h | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 8953e513..96ec79d1 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -451,19 +451,10 @@ FMT_CONSTEXPR bool is_arithmetic(type t) {
 template <typename T, typename Char, bool ENABLE = true>
 struct convert_to_int {
   enum {
-   value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
+    value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
   };
 };
 
-#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
-  template <typename Char> \
-  struct convert_to_int<Type, Char> { enum { value = 0 }; }
-
-// Silence warnings about convering float to int.
-FMT_DISABLE_CONVERSION_TO_INT(float);
-FMT_DISABLE_CONVERSION_TO_INT(double);
-FMT_DISABLE_CONVERSION_TO_INT(long double);
-
 template <typename Char>
 struct string_value {
   const Char *value;

From ae3cc844e790021e926474fbc5366777d4c14864 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 7 Mar 2018 05:41:45 -0800
Subject: [PATCH 56/62] Check format string at compile time in print

---
 include/fmt/format.h | 30 +++++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 2ec2f889..57f1867e 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -1468,6 +1468,10 @@ class arg_formatter_base {
 
 struct format_string {};
 
+template <typename S>
+struct is_format_string:
+  std::integral_constant<bool, std::is_base_of<format_string, S>::value> {};
+
 template <typename Char>
 FMT_CONSTEXPR bool is_name_start(Char c) {
   return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
@@ -2093,6 +2097,14 @@ FMT_CONSTEXPR bool check_format_string(
   return true;
 }
 
+template <typename... Args, typename String>
+void check_format_string(String format_str) {
+  FMT_CONSTEXPR_DECL bool invalid_format =
+      internal::check_format_string<char, internal::error_handler, Args...>(
+        string_view(format_str.data(), format_str.size()));
+  (void)invalid_format;
+}
+
 // Specifies whether to format T using the standard formatter.
 // It is not possible to use get_type in formatter specialization directly
 // because of a bug in MSVC.
@@ -3399,13 +3411,17 @@ inline std::wstring vformat(wstring_view format_str, wformat_args args) {
 
 template <typename String, typename... Args>
 inline typename std::enable_if<
-  std::is_base_of<internal::format_string, String>::value, std::string>::type
+  internal::is_format_string<String>::value, std::string>::type
     format(String format_str, const Args & ... args) {
-  FMT_CONSTEXPR_DECL bool invalid_format =
-      internal::check_format_string<char, internal::error_handler, Args...>(
-        string_view(format_str.value(), format_str.size()));
-  (void)invalid_format;
-  return vformat(format_str.value(), make_args(args...));
+  internal::check_format_string<Args...>(format_str);
+  return vformat(format_str.data(), make_args(args...));
+}
+
+template <typename String, typename... Args>
+inline typename std::enable_if<internal::is_format_string<String>::value>::type
+    print(String format_str, const Args & ... args) {
+  internal::check_format_string<Args...>(format_str);
+  return vprint(format_str.data(), make_args(args...));
 }
 
 // Counts the number of characters in the output of format(format_str, args...).
@@ -3505,7 +3521,7 @@ operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
 
 #define FMT_STRING(s) [] { \
     struct S : fmt::internal::format_string { \
-      static FMT_CONSTEXPR auto value() { return s; } \
+      static FMT_CONSTEXPR auto data() { return s; } \
       static FMT_CONSTEXPR size_t size() { return sizeof(s); } \
     }; \
     return S{}; \

From 80e57c7a3da62e04c216700f154f23f10eafb339 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Wed, 7 Mar 2018 07:36:13 -0800
Subject: [PATCH 57/62] Update to new naming conventions

---
 include/fmt/core.h   | 17 ++++++++---------
 include/fmt/format.h |  6 +++---
 test/format-test.cc  |  8 ++++----
 3 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 96ec79d1..ea3bf969 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -642,7 +642,7 @@ typed_value<C, name_arg_type>
 }
 
 // Maximum number of arguments with packed types.
-enum { MAX_PACKED_ARGS = 15 };
+enum { max_packed_args = 15 };
 
 template <typename Context>
 class arg_map;
@@ -912,8 +912,7 @@ typedef buffer_context<wchar_t>::type wcontext;
 
 namespace internal {
 template <typename Context, typename T>
-class get_type {
- public:
+struct get_type {
   typedef decltype(make_value<Context>(
         declval<typename std::decay<T>::type&>())) value_type;
   static const type value = value_type::type_tag;
@@ -954,7 +953,7 @@ class arg_store {
   static const size_t NUM_ARGS = sizeof...(Args);
 
   // Packed is a macro on MinGW so use IS_PACKED instead.
-  static const bool IS_PACKED = NUM_ARGS < internal::MAX_PACKED_ARGS;
+  static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
 
   typedef typename std::conditional<
     IS_PACKED, internal::value<Context>, basic_arg<Context>>::type value_type;
@@ -1004,10 +1003,10 @@ class basic_format_args {
 
  private:
   // To reduce compiled code size per formatting function call, types of first
-  // MAX_PACKED_ARGS arguments are passed in the types_ field.
+  // max_packed_args arguments are passed in the types_ field.
   uint64_t types_;
   union {
-    // If the number of arguments is less than MAX_PACKED_ARGS, the argument
+    // If the number of arguments is less than max_packed_args, the argument
     // values are stored in values_, otherwise they are stored in args_.
     // This is done to reduce compiled code size as storing larger objects
     // may require more code (at least on x86-64) even if the same amount of
@@ -1035,7 +1034,7 @@ class basic_format_args {
       return index < num_args ? args_[index] : format_arg();
     }
     format_arg arg;
-    if (index > internal::MAX_PACKED_ARGS)
+    if (index > internal::max_packed_args)
       return arg;
     arg.type_ = type(index);
     if (arg.type_ == internal::none_type)
@@ -1064,7 +1063,7 @@ class basic_format_args {
   unsigned max_size() const {
     int64_t signed_types = static_cast<int64_t>(types_);
     return signed_types < 0 ?
-          -signed_types : static_cast<int64_t>(internal::MAX_PACKED_ARGS);
+          -signed_types : static_cast<int64_t>(internal::max_packed_args);
   }
 };
 
@@ -1127,7 +1126,7 @@ inline internal::named_arg<T, wchar_t> arg(wstring_view name, const T &arg) {
 template <typename S, typename T, typename Char>
 void arg(S, internal::named_arg<T, Char>) FMT_DELETED;
 
-enum color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
+enum color { black, red, green, yellow, blue, magenta, cyan, white };
 
 FMT_API void vprint_colored(color c, string_view format, format_args args);
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 57f1867e..2cb7e828 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -1326,7 +1326,7 @@ void arg_map<Context>::init(const basic_format_args<Context> &args) {
   if (map_)
     return;
   map_ = new entry[args.max_size()];
-  bool use_values = args.type(MAX_PACKED_ARGS - 1) == internal::none_type;
+  bool use_values = args.type(max_packed_args - 1) == internal::none_type;
   if (use_values) {
     for (unsigned i = 0;/*nothing*/; ++i) {
       internal::type arg_type = args.type(i);
@@ -1342,11 +1342,11 @@ void arg_map<Context>::init(const basic_format_args<Context> &args) {
     }
     return;
   }
-  for (unsigned i = 0; i != MAX_PACKED_ARGS; ++i) {
+  for (unsigned i = 0; i != max_packed_args; ++i) {
     if (args.type(i) == internal::name_arg_type)
       push_back(args.args_[i].value_);
   }
-  for (unsigned i = MAX_PACKED_ARGS; ; ++i) {
+  for (unsigned i = max_packed_args; ; ++i) {
     switch (args.args_[i].type_) {
       case internal::none_type:
         return;
diff --git a/test/format-test.cc b/test/format-test.cc
index fcf2322f..62bf224e 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -442,9 +442,9 @@ TEST(FormatterTest, ManyArgs) {
                    format_error, "argument index out of range");
   EXPECT_THROW_MSG(TestFormat<21>::format("{21}"),
                    format_error, "argument index out of range");
-  enum { MAX_PACKED_ARGS = fmt::internal::MAX_PACKED_ARGS };
-  std::string format_str = fmt::format("{{{}}}", MAX_PACKED_ARGS + 1);
-  EXPECT_THROW_MSG(TestFormat<MAX_PACKED_ARGS>::format(format_str),
+  enum { max_packed_args = fmt::internal::max_packed_args };
+  std::string format_str = fmt::format("{{{}}}", max_packed_args + 1);
+  EXPECT_THROW_MSG(TestFormat<max_packed_args>::format(format_str),
                    format_error, "argument index out of range");
 }
 
@@ -1405,7 +1405,7 @@ TEST(FormatTest, Print) {
 
 #if FMT_USE_FILE_DESCRIPTORS
 TEST(FormatTest, PrintColored) {
-  EXPECT_WRITE(stdout, fmt::print_colored(fmt::RED, "Hello, {}!\n", "world"),
+  EXPECT_WRITE(stdout, fmt::print_colored(fmt::red, "Hello, {}!\n", "world"),
     "\x1b[31mHello, world!\n\x1b[0m");
 }
 #endif

From ca93be130abcef1d6776b19d3248338d4bccc3d0 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Fri, 9 Mar 2018 15:40:40 -0800
Subject: [PATCH 58/62] Use fmt(s) as an alias for FMT_STRING(s)

---
 include/fmt/format.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index 2cb7e828..09edaba7 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -3527,6 +3527,10 @@ operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
     return S{}; \
   }()
 
+#ifndef FMT_NO_FMT_STRING_ALIAS
+# define fmt(s) FMT_STRING(s)
+#endif
+
 #ifdef FMT_HEADER_ONLY
 # define FMT_FUNC inline
 # include "format.cc"

From 8fd7e30f37ce7890b5831cd6cd282ff25291b1a2 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Fri, 9 Mar 2018 15:44:46 -0800
Subject: [PATCH 59/62] Update README.rst

---
 README.rst | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/README.rst b/README.rst
index 7d144cad..757d0b99 100644
--- a/README.rst
+++ b/README.rst
@@ -84,22 +84,22 @@ Format strings can be checked at compile time:
 .. code:: c++
 
     // test.cc
-    using namespace fmt::literals;
-    std::string s = "{2}"_format(42);
+    #include <fmt/format.h>
+    std::string s = fmt::format(fmt("{2}"), 42);
 
 .. code::
 
     $ g++ -Iinclude test.cc -std=c++14
     ...
-    test.cc:5:31: note: in instantiation of function template specialization
-    'fmt::internal::udl_formatter<char, '{', '2', '}'>::operator()<int>' requested
-    here
-      std::string s = "{2}"_format(42);
-                                  ^
-    include/fmt/format.h:3838:7: note: non-constexpr function 'on_error' cannot be
-    used in a constant expression
-          on_error("argument index out of range");
-          ^
+    test.cc:2:22: note: in instantiation of function template specialization 'fmt::format<S, int>' requested here
+    std::string s = fmt::format(fmt("{2}"), 42);
+                         ^
+    include/fmt/core.h:749:19: note: non-constexpr function 'on_error' cannot be used in a constant expression
+        ErrorHandler::on_error(message);
+                      ^
+    include/fmt/format.h:2081:16: note: in call to '&checker.context_->on_error(&"argument index out of range"[0])'
+          context_.on_error("argument index out of range");
+                   ^
 
 {fmt} can be used as a safe portable replacement for ``itoa``:
 

From daf650c49a61339e540c21d9ea1de78a426f39a8 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 10 Mar 2018 06:46:41 -0800
Subject: [PATCH 60/62] Disallow formatting of multibyte strings into a wide
 buffer (#606)

---
 include/fmt/core.h               | 14 ++++++++------
 test/compile-test/CMakeLists.txt | 16 +++-------------
 2 files changed, 11 insertions(+), 19 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index ea3bf969..2e8335ed 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -546,7 +546,7 @@ template <typename Context, typename T>
 FMT_CONSTEXPR basic_arg<Context> make_arg(const T &value);
 
 #define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \
-  template <typename C, typename Char = typename C::char_type> \
+  template <typename C> \
   FMT_CONSTEXPR typed_value<C, TAG> make_value(ArgType val) { \
     return static_cast<ValueType>(val); \
   }
@@ -589,20 +589,22 @@ FMT_MAKE_VALUE(long_double_type, long double, long double)
 
 // Formatting of wide strings into a narrow buffer and multibyte strings
 // into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606).
-FMT_MAKE_VALUE(cstring_type, Char*, const Char*)
-FMT_MAKE_VALUE(cstring_type, const Char*, const Char*)
+FMT_MAKE_VALUE(cstring_type, typename C::char_type*,
+               const typename C::char_type*)
+FMT_MAKE_VALUE(cstring_type, const typename C::char_type*,
+               const typename C::char_type*)
 
 FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
 FMT_MAKE_VALUE(cstring_type, const signed char*, const signed char*)
 FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
 FMT_MAKE_VALUE(cstring_type, const unsigned char*, const unsigned char*)
 FMT_MAKE_VALUE(string_type, basic_string_view<typename C::char_type>,
-               basic_string_view<Char>)
+               basic_string_view<typename C::char_type>)
 FMT_MAKE_VALUE(string_type,
                typename basic_string_view<typename C::char_type>::type,
-               basic_string_view<Char>)
+               basic_string_view<typename C::char_type>)
 FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
-               basic_string_view<Char>)
+               basic_string_view<typename C::char_type>)
 FMT_MAKE_VALUE(pointer_type, void*, const void*)
 FMT_MAKE_VALUE(pointer_type, const void*, const void*)
 
diff --git a/test/compile-test/CMakeLists.txt b/test/compile-test/CMakeLists.txt
index ded517ad..cebcee01 100644
--- a/test/compile-test/CMakeLists.txt
+++ b/test/compile-test/CMakeLists.txt
@@ -47,22 +47,12 @@ endfunction ()
 # check if the source file skeleton compiles
 expect_compile("")
 
-# MakeArg doesn't accept [const] volatile char *.
-expect_compile_error("volatile char s[] = \"test\"; (fmt::internal::MakeArg<char>)(s);")
-expect_compile_error("const volatile char s[] = \"test\"; (fmt::internal::MakeArg<char>)(s);")
-
-# MakeArg<char> doesn't accept wchar_t.
-expect_compile_error("fmt::internal::MakeValue<char>(L'a');")
-expect_compile_error("fmt::internal::MakeValue<char>(L\"test\");")
-
-# Writing a wide character to a character stream Writer is forbidden.
-expect_compile_error("fmt::MemoryWriter() << L'a';")
-expect_compile_error("fmt::MemoryWriter() << fmt::pad(\"abc\", 5, L' ');")
-expect_compile_error("fmt::MemoryWriter() << fmt::pad(42, 5, L' ');")
-
 # Formatting a wide character with a narrow format string is forbidden.
 expect_compile_error("fmt::format(\"{}\", L'a';")
 
+# Formatting a wide string with a narrow format string is forbidden.
+expect_compile_error("fmt::format(\"{}\", L\"foo\";")
+
 # Make sure that compiler features detected in the header
 # match the features detected in CMake.
 if (SUPPORTS_USER_DEFINED_LITERALS)

From 9facc119a603824b3c5063b31a9b4508c68d4dc1 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 10 Mar 2018 09:25:17 -0800
Subject: [PATCH 61/62] Update docs

---
 doc/api.rst          | 259 ++++++++++++++++++++++++++-----------------
 include/fmt/core.h   |   5 +-
 include/fmt/format.h |  12 +-
 3 files changed, 170 insertions(+), 106 deletions(-)

diff --git a/doc/api.rst b/doc/api.rst
index b79810b1..e888f94f 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -4,14 +4,29 @@
 API Reference
 *************
 
-All functions and classes provided by the {fmt} library reside in namespace
-``fmt`` and macros have prefix ``FMT_``.
+The {fmt} library API consists of the following parts:
 
-Format API
-==========
+* :ref:`fmt/core.h <core-api>`: the core API providing argument handling
+  facilities and a lightweight subset of formatting functions
+* :ref:`fmt/format.h <format-api>`: the full format API providing compile-time
+  format string checks, output iterator and user-defined type support
+* :ref:`fmt/time.h <time-api>`: date and time formatting
+* :ref:`fmt/ostream.h <ostream-api>`: ``std::ostream`` support
+* :ref:`fmt/printf.h <printf-api>`: ``printf`` formatting
 
-The following functions defined in ``fmt/core.h`` use :ref:`format string
-syntax <syntax>` similar to that of Python's `str.format
+All functions and types provided by the library reside in namespace ``fmt`` and
+macros have prefix ``FMT_`` or ``fmt``.
+
+.. _core-api:
+
+Core API
+========
+
+``fmt/core.h`` defines the core API which provides argument handling facilities
+and a lightweight subset of formatting functions.
+
+The following functions use :ref:`format string syntax <syntax>`
+imilar to that of Python's `str.format
 <http://docs.python.org/3/library/stdtypes.html#str.format>`_.
 They take *format_str* and *args* as arguments.
 
@@ -21,35 +36,52 @@ arguments in the resulting string.
 
 *args* is an argument list representing objects to be formatted.
 
-The `performance of the formating functions
-<https://github.com/fmtlib/fmt/blob/master/README.rst#speed-tests>`_ is close
-to that of glibc's ``printf`` and better than the performance of IOStreams.
-
 .. _format:
 
 .. doxygenfunction:: format(string_view, const Args&...)
+.. doxygenfunction:: vformat(string_view, format_args)
 
 .. _print:
 
 .. doxygenfunction:: print(string_view, const Args&...)
+.. doxygenfunction:: vprint(string_view, format_args)
 
 .. doxygenfunction:: print(std::FILE *, string_view, const Args&...)
+.. doxygenfunction:: vprint(std::FILE *, string_view, format_args)
 
-Date and time formatting
-------------------------
+.. _format-api:
 
-The library supports `strftime
-<http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like date and time
-formatting::
+Named arguments
+---------------
 
-  #include "fmt/time.h"
+.. doxygenfunction:: fmt::arg(string_view, const T&)
 
-  std::time_t t = std::time(nullptr);
-  // Prints "The date is 2016-04-29." (with the current date)
-  fmt::print("The date is {:%Y-%m-%d}.", *std::localtime(&t));
+Argument lists
+--------------
 
-The format string syntax is described in the documentation of
-`strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_.
+.. doxygenclass:: fmt::basic_format_args
+   :members:
+
+.. doxygenstruct:: fmt::format_args
+
+.. doxygenfunction:: fmt::make_args(const Args&...)
+
+Compatibility
+-------------
+
+.. doxygenclass:: fmt::basic_string_view
+   :members:
+
+Format API
+==========
+
+``fmt/format.h`` defines the full format API providing compile-time format
+string checks, output iterator and user-defined type support.
+
+Compile-time format string checks
+---------------------------------
+
+.. doxygendefine:: fmt
 
 Formatting user-defined types
 -----------------------------
@@ -57,6 +89,8 @@ Formatting user-defined types
 To make a user-defined type formattable, specialize the ``formatter<T>`` struct
 template and implement ``parse`` and ``format`` methods::
 
+  #include <fmt/format.h>
+
   struct point { double x, y; };
 
   namespace fmt {
@@ -88,28 +122,10 @@ This section shows how to define a custom format function for a user-defined
 type. The next section describes how to get ``fmt`` to use a conventional stream
 output ``operator<<`` when one is defined for a user-defined type.
 
-``std::ostream`` support
-------------------------
+Output iterator support
+-----------------------
 
-The header ``fmt/ostream.h`` provides ``std::ostream`` support including
-formatting of user-defined types that have overloaded ``operator<<``::
-
-  #include "fmt/ostream.h"
-
-  class date {
-    int year_, month_, day_;
-  public:
-    date(int year, int month, int day): year_(year), month_(month), day_(day) {}
-
-    friend std::ostream &operator<<(std::ostream &os, const date &d) {
-      return os << d.year_ << '-' << d.month_ << '-' << d.day_;
-    }
-  };
-
-  std::string s = fmt::format("The date is {}", date(2012, 12, 9));
-  // s == "The date is 2012-12-9"
-
-.. doxygenfunction:: print(std::ostream&, string_view, const Args&...)
+.. doxygenfunction:: fmt::format_to(OutputIt, string_view, const Args&...)
 
 Literal-based API
 -----------------
@@ -120,6 +136,57 @@ The following user-defined literals are defined in ``fmt/format.h``.
 
 .. doxygenfunction:: operator""_a(const char *, std::size_t)
 
+Utilities
+---------
+
+.. doxygenfunction:: fmt::to_string(const T&)
+
+.. doxygenclass:: fmt::basic_memory_buffer
+   :protected-members:
+   :members:
+
+System errors
+-------------
+
+.. doxygenclass:: fmt::system_error
+   :members:
+
+.. doxygenfunction:: fmt::format_system_error
+
+.. doxygenclass:: fmt::windows_error
+   :members:
+
+.. _formatstrings:
+
+Custom allocators
+-----------------
+
+The {fmt} library supports custom dynamic memory allocators.
+A custom allocator class can be specified as a template argument to
+:class:`fmt::basic_memory_buffer`::
+
+    using custom_memory_buffer = 
+      fmt::basic_memory_buffer<char, fmt::inline_buffer_size, custom_allocator>;
+
+It is also possible to write a formatting function that uses a custom
+allocator::
+
+    using custom_string =
+      std::basic_string<char, std::char_traits<char>, custom_allocator>;
+
+    custom_string vformat(custom_allocator alloc, fmt::string_view format_str,
+                          fmt::format_args args) {
+      custom_memory_buffer buf(alloc);
+      fmt::vformat_to(buf, format_str, args);
+      return custom_string(buf.data(), buf.size(), alloc);
+    }
+
+    template <typename ...Args>
+    inline custom_string format(custom_allocator alloc,
+                                fmt::string_view format_str,
+                                const Args & ... args) {
+      return vformat(alloc, format_str, fmt::make_args(args...));
+    }
 Custom formatting of built-in types
 -----------------------------------
 
@@ -170,8 +237,53 @@ custom argument formatter class::
 .. doxygenclass:: fmt::arg_formatter
    :members:
 
-Printf formatting
------------------
+.. _time-api:
+
+Date and time formatting
+========================
+
+The library supports `strftime
+<http://en.cppreference.com/w/cpp/chrono/c/strftime>`_-like date and time
+formatting::
+
+  #include <fmt/time.h>
+
+  std::time_t t = std::time(nullptr);
+  // Prints "The date is 2016-04-29." (with the current date)
+  fmt::print("The date is {:%Y-%m-%d}.", *std::localtime(&t));
+
+The format string syntax is described in the documentation of
+`strftime <http://en.cppreference.com/w/cpp/chrono/c/strftime>`_.
+
+.. _ostream-api:
+
+``std::ostream`` support
+========================
+
+``fmt/ostream.h`` provides ``std::ostream`` support including formatting of
+user-defined types that have overloaded ``operator<<``::
+
+  #include <fmt/ostream.h>
+
+  class date {
+    int year_, month_, day_;
+  public:
+    date(int year, int month, int day): year_(year), month_(month), day_(day) {}
+
+    friend std::ostream &operator<<(std::ostream &os, const date &d) {
+      return os << d.year_ << '-' << d.month_ << '-' << d.day_;
+    }
+  };
+
+  std::string s = fmt::format("The date is {}", date(2012, 12, 9));
+  // s == "The date is 2012-12-9"
+
+.. doxygenfunction:: print(std::ostream&, string_view, const Args&...)
+
+.. _printf-api:
+
+``printf`` formatting
+=====================
 
 The header ``fmt/printf.h`` provides ``printf``-like formatting functionality.
 The following functions use `printf format string syntax
@@ -220,62 +332,3 @@ store output elsewhere by subclassing `~fmt::BasicWriter`.
 
 .. doxygenfunction:: pad(int, unsigned, Char)
 
-Utilities
-=========
-
-.. doxygenfunction:: fmt::arg(string_view, const T&)
-
-.. doxygenclass:: fmt::basic_format_args
-   :members:
-
-.. doxygenfunction:: fmt::to_string(const T&)
-
-.. doxygenclass:: fmt::basic_string_view
-   :members:
-
-.. doxygenclass:: fmt::basic_memory_buffer
-   :protected-members:
-   :members:
-
-System errors
-=============
-
-.. doxygenclass:: fmt::system_error
-   :members:
-
-.. doxygenfunction:: fmt::format_system_error
-
-.. doxygenclass:: fmt::windows_error
-   :members:
-
-.. _formatstrings:
-
-Custom allocators
-=================
-
-The {fmt} library supports custom dynamic memory allocators.
-A custom allocator class can be specified as a template argument to
-:class:`fmt::basic_memory_buffer`::
-
-    using custom_memory_buffer = 
-      fmt::basic_memory_buffer<char, fmt::inline_buffer_size, custom_allocator>;
-
-It is also possible to write a formatting function that uses a custom
-allocator::
-
-    using custom_string =
-      std::basic_string<char, std::char_traits<char>, custom_allocator>;
-
-    custom_string vformat(custom_allocator alloc, fmt::string_view format_str,
-                          fmt::format_args args) {
-      custom_memory_buffer buf(alloc);
-      fmt::vformat_to(buf, format_str, args);
-      return custom_string(buf.data(), buf.size(), alloc);
-    }
-
-    template <typename ...Args>
-    inline custom_string format(custom_allocator alloc,
-                                fmt::string_view format_str,
-                                const Args & ... args) {
-      return vformat(alloc, format_str, fmt::make_args(args...));
-    }
diff --git a/include/fmt/core.h b/include/fmt/core.h
index 2e8335ed..8acc2f60 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1069,7 +1069,8 @@ class basic_format_args {
   }
 };
 
-// This is a separate type rather than a typedef to make symbols readable.
+/** An alias to ``basic_format_args<context>``. */
+// It is a separate type rather than a typedef to make symbols readable.
 struct format_args: basic_format_args<context> {
   template <typename ...Args>
   format_args(Args && ... arg)
@@ -1179,7 +1180,7 @@ std::wstring vformat(wstring_view format_str, wformat_args args);
 
   **Example**::
 
-    #include "fmt/core.h"
+    #include <fmt/core.h>
     std::string message = fmt::format("The answer is {}", 42);
   \endrst
 */
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 09edaba7..d635b91d 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -3315,7 +3315,7 @@ auto join(const Range &range, wstring_view sep)
 
   **Example**::
 
-    #include "fmt/format.h"
+    #include <fmt/format.h>
 
     std::string answer = fmt::to_string(42);
   \endrst
@@ -3528,6 +3528,16 @@ operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
   }()
 
 #ifndef FMT_NO_FMT_STRING_ALIAS
+/**
+  \rst
+  Constructs a compile-time format string.
+
+  **Example**::
+
+    #include <fmt/format.h>
+    std::string s = fmt::format(fmt("{:d}"), "foo"); // fails to compile
+  \endrst
+ */
 # define fmt(s) FMT_STRING(s)
 #endif
 

From 7db0e94b9e5a54efcee27ebd6abb344836b68c8e Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 11 Mar 2018 21:04:42 -0400
Subject: [PATCH 62/62] Fix handling of numeric alignment with no width (#675)

---
 include/fmt/format.h | 3 ++-
 test/format-test.cc  | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/fmt/format.h b/include/fmt/format.h
index d635b91d..dc2336cd 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2787,7 +2787,8 @@ void basic_writer<Range>::write_double(T value, const format_specs &spec) {
     if (sign) {
       *reserve(1) = sign;
       sign = 0;
-      --as.width_;
+      if (as.width_)
+        --as.width_;
     }
     as.align_ = ALIGN_RIGHT;
   } else {
diff --git a/test/format-test.cc b/test/format-test.cc
index 62bf224e..17dedd3b 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -532,6 +532,7 @@ TEST(FormatterTest, NumericAlign) {
       format_error, "format specifier requires numeric argument");
   EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)),
       format_error, "format specifier requires numeric argument");
+  EXPECT_EQ(" 1", fmt::format("{:= }", 1.0));
 }
 
 TEST(FormatterTest, CenterAlign) {