Ticket #3190: cppformat.patch

source/third_party/cppformat/format.cpp

@@ -1 +1 @@
 /*
- * Slightly modified version of cppformat, by Wildfire Games, for 0 A.D.
- * Based on cppformat v0.11.0 from https://github.com/cppformat/cppformat
- */
-
-/*
  Formatting library for C++
 
- Copyright (c) 2012 - 2014, Victor Zverovich
+ Copyright (c) 2012 - 2015, Victor Zverovich
  All rights reserved.
 
  Redistribution and use in source and binary forms, with or without
@@ -30 +25 @@
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "precompiled.h"
-
-// Disable useless MSVC warnings.
-#undef _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_WARNINGS
-#undef _SCL_SECURE_NO_WARNINGS
-#define _SCL_SECURE_NO_WARNINGS
-
 #include "format.h"
 
 #include <string.h>
@@ -47 +34 @@
 #include <climits>
 #include <cmath>
 #include <cstdarg>
+#include <cstddef>  // for std::ptrdiff_t
 
-#ifdef _WIN32
-# define WIN32_LEAN_AND_MEAN
-# ifdef __MINGW32__
-#  include <cstring>
+#if defined(_WIN32) && defined(__MINGW32__)
+# include <cstring>
+#endif
+
+#if FMT_USE_WINDOWS_H
+# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
+#  include <windows.h>
+# else
+#  define NOMINMAX
+#  include <windows.h>
+#  undef NOMINMAX
 # endif
-# include <windows.h>
-# undef ERROR
 #endif
 
-using fmt::LongLong;
-using fmt::ULongLong;
 using fmt::internal::Arg;
 
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127) // conditional expression is constant
+// Check if exceptions are disabled.
+#if defined(__GNUC__) && !defined(__EXCEPTIONS)
+# define FMT_EXCEPTIONS 0
+#endif
+#if defined(_MSC_VER) && !_HAS_EXCEPTIONS
+# define FMT_EXCEPTIONS 0
+#endif
+#ifndef FMT_EXCEPTIONS
+# define FMT_EXCEPTIONS 1
 #endif
 
-namespace {
-
-#ifndef _MSC_VER
-
-// Portable version of signbit.
-// When compiled in C++11 mode signbit is no longer a macro but a function
-// defined in namespace std and the macro is undefined.
-inline int getsign(double x) {
-#ifdef signbit
-  return signbit(x);
+#if FMT_EXCEPTIONS
+# define FMT_TRY try
+# define FMT_CATCH(x) catch (x)
 #else
-  return std::signbit(x);
+# define FMT_TRY if (true)
+# define FMT_CATCH(x) if (false)
 #endif
-}
 
-// Portable version of isinf.
-#ifdef isinf
-inline int isinfinity(double x) { return isinf(x); }
-inline int isinfinity(long double x) { return isinf(x); }
-#else
-inline int isinfinity(double x) { return std::isinf(x); }
-inline int isinfinity(long double x) { return std::isinf(x); }
+#ifndef FMT_THROW
+# if FMT_EXCEPTIONS
+#  define FMT_THROW(x) throw x
+# else
+#  define FMT_THROW(x) assert(false)
+# endif
 #endif
 
-#define FMT_SNPRINTF snprintf
+#ifdef FMT_HEADER_ONLY
+# define FMT_FUNC inline
+#else
+# define FMT_FUNC
+#endif
 
-#else  // _MSC_VER
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable: 4127)  // conditional expression is constant
+# pragma warning(disable: 4702)  // unreachable code
+// Disable deprecation warning for strerror. The latter is not called but
+// MSVC fails to detect it.
+# pragma warning(disable: 4996)
+#endif
 
-inline int getsign(double value) {
-  if (value < 0) return 1;
-  if (value == value) return 0;
-  int dec = 0, sign = 0;
-  char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
-  _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign);
-  return sign;
+// Dummy implementations of strerror_r and strerror_s called if corresponding
+// system functions are not available.
+static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
+  return fmt::internal::Null<>();
+}
+static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
+  return fmt::internal::Null<>();
 }
 
-inline int isinfinity(double x) { return !_finite(x); }
+namespace fmt {
+namespace {
 
+#ifndef _MSC_VER
+# define FMT_SNPRINTF snprintf
+#else  // _MSC_VER
 inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
   va_list args;
   va_start(args, format);
@@ -112 +116 @@
   va_end(args);
   return result;
 }
-#define FMT_SNPRINTF fmt_snprintf
-
+# define FMT_SNPRINTF fmt_snprintf
 #endif  // _MSC_VER
 
-template <typename T>
-struct IsLongDouble { enum {VALUE = 0}; };
-
-template <>
-struct IsLongDouble<long double> { enum {VALUE = 1}; };
+#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
+# define FMT_SWPRINTF snwprintf
+#else
+# define FMT_SWPRINTF swprintf
+#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
 
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
@@ -131 +134 @@
     unsigned max = INT_MAX;
     return value <= max;
   }
+  static bool fits_in_int(bool) { return true; }
 };
 
 template <>
@@ -139 +143 @@
   static bool fits_in_int(T value) {
     return value >= INT_MIN && value <= INT_MAX;
   }
+  static bool fits_in_int(int) { return true; }
 };
 
 const char RESET_COLOR[] = "\x1b[0m";
 
-typedef void (*FormatFunc)(fmt::Writer &, int , fmt::StringRef);
+typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
+
+// Portable thread-safe version of strerror.
+// Sets buffer to point to a string describing the error code.
+// This can be either a pointer to a string stored in buffer,
+// or a pointer to some static immutable string.
+// Returns one of the following values:
+//   0      - success
+//   ERANGE - buffer is not large enough to store the error message
+//   other  - failure
+// Buffer should be at least of size 1.
+int safe_strerror(
+    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
+  FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");
+
+  class StrError {
+   private:
+    int error_code_;
+    char *&buffer_;
+    std::size_t buffer_size_;
 
-void report_error(FormatFunc func,
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) {
-  try {
-    fmt::Writer full_message;
-    func(full_message, error_code, message); // TODO: make sure this doesn't throw
-    std::fwrite(full_message.c_str(), full_message.size(), 1, stderr);
-    std::fputc('\n', stderr);
-  } catch (...) {}
+    // A noop assignment operator to avoid bogus warnings.
+    void operator=(const StrError &) {}
+
+    // Handle the result of XSI-compliant version of strerror_r.
+    int handle(int result) {
+      // glibc versions before 2.13 return result in errno.
+      return result == -1 ? errno : result;
+    }
+
+    // Handle the result of GNU-specific version of strerror_r.
+    int handle(char *message) {
+      // If the buffer is full then the message is probably truncated.
+      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
+        return ERANGE;
+      buffer_ = message;
+      return 0;
+    }
+
+    // Handle the case when strerror_r is not available.
+    int handle(fmt::internal::Null<>) {
+      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
+    }
+
+    // Fallback to strerror_s when strerror_r is not available.
+    int fallback(int result) {
+      // If the buffer is full then the message is probably truncated.
+      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
+            ERANGE : result;
+    }
+
+    // Fallback to strerror if strerror_r and strerror_s are not available.
+    int fallback(fmt::internal::Null<>) {
+      errno = 0;
+      buffer_ = strerror(error_code_);
+      return errno;
+    }
+
+   public:
+    StrError(int err_code, char *&buf, std::size_t buf_size)
+      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
+
+    int run() {
+      strerror_r(0, 0, "");  // Suppress a warning about unused strerror_r.
+      return handle(strerror_r(error_code_, buffer_, buffer_size_));
+    }
+  };
+  return StrError(error_code, buffer, buffer_size).run();
 }
 
-const Arg DUMMY_ARG = {Arg::INT, {0}};
+void format_error_code(fmt::Writer &out, int error_code,
+                       fmt::StringRef message) FMT_NOEXCEPT {
+  // Report error code making sure that the output fits into
+  // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
+  // bad_alloc.
+  out.clear();
+  static const char SEP[] = ": ";
+  static const char ERROR_STR[] = "error ";
+  fmt::internal::IntTraits<int>::MainType ec_value = error_code;
+  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
+  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
+  error_code_size += fmt::internal::count_digits(ec_value);
+  if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)
+    out << message << SEP;
+  out << ERROR_STR << error_code;
+  assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);
+}
+
+void report_error(FormatFunc func,
+    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
+  fmt::MemoryWriter full_message;
+  func(full_message, error_code, message);
+  // Use Writer::data instead of Writer::c_str to avoid potential memory
+  // allocation.
+  std::fwrite(full_message.data(), full_message.size(), 1, stderr);
+  std::fputc('\n', stderr);
+}
 
 // IsZeroInt::visit(arg) returns true iff arg is a zero integer.
 class IsZeroInt : public fmt::internal::ArgVisitor<IsZeroInt, bool> {
@@ -167 +256 @@
 // Parses an unsigned integer advancing s to the end of the parsed input.
 // This function assumes that the first character of s is a digit.
 template <typename Char>
-int parse_nonnegative_int(
-    const Char *&s, const char *&error) FMT_NOEXCEPT(true) {
+int parse_nonnegative_int(const Char *&s) {
   assert('0' <= *s && *s <= '9');
   unsigned value = 0;
   do {
     unsigned new_value = value * 10 + (*s++ - '0');
     // Check if value wrapped around.
-    value = new_value >= value ? new_value : UINT_MAX;
+    if (new_value < value) {
+      value = UINT_MAX;
+      break;
+    }
+    value = new_value;
   } while ('0' <= *s && *s <= '9');
-  if (value > INT_MAX) {
-    if (!error)
-      error = "number is too big in format";
-    return 0;
-  }
+  if (value > INT_MAX)
+    FMT_THROW(fmt::FormatError("number is too big"));
   return value;
 }
 
 template <typename Char>
-const Char *find_closing_brace(const Char *s, int num_open_braces = 1) {
-  for (int n = num_open_braces; *s; ++s) {
-    if (*s == '{') {
-      ++n;
-    } else if (*s == '}') {
-      if (--n == 0)
-        return s;
-    }
+inline bool is_name_start(Char c) {
+  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
+}
+
+inline void require_numeric_argument(const Arg &arg, char spec) {
+  if (arg.type > Arg::LAST_NUMERIC_TYPE) {
+    std::string message =
+        fmt::format("format specifier '{}' requires numeric argument", spec);
+    FMT_THROW(fmt::FormatError(message));
   }
-  throw fmt::FormatError("unmatched '{' in format");
+}
+
+template <typename Char>
+void check_sign(const Char *&s, const Arg &arg) {
+  char sign = static_cast<char>(*s);
+  require_numeric_argument(arg, sign);
+  if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
+    FMT_THROW(fmt::FormatError(fmt::format(
+      "format specifier '{}' requires signed argument", sign)));
+  }
+  ++s;
 }
 
 // Checks if an argument is a valid printf width specifier and sets
@@ -203 +303 @@
  private:
   fmt::FormatSpec &spec_;
 
+  FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
+
  public:
   explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}
 
-  unsigned visit_unhandled_arg() {
-    throw fmt::FormatError("width is not integer");
+  void report_unhandled_arg() {
+    FMT_THROW(fmt::FormatError("width is not integer"));
   }
 
   template <typename T>
@@ -219 +321 @@
       width = 0 - width;
     }
     if (width > INT_MAX)
-      throw fmt::FormatError("number is too big in format");
+      FMT_THROW(fmt::FormatError("number is too big"));
     return static_cast<unsigned>(width);
   }
 };
@@ -227 +329 @@
 class PrecisionHandler :
     public fmt::internal::ArgVisitor<PrecisionHandler, int> {
  public:
-  unsigned visit_unhandled_arg() {
-    throw fmt::FormatError("precision is not integer");
+  void report_unhandled_arg() {
+    FMT_THROW(fmt::FormatError("precision is not integer"));
   }
 
   template <typename T>
   int visit_any_int(T value) {
     if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      throw fmt::FormatError("number is too big in format");
+      FMT_THROW(fmt::FormatError("number is too big"));
     return static_cast<int>(value);
   }
 };
 
-// Converts an integer argument to type T.
+// Converts an integer argument to an integral type T for printf.
 template <typename T>
 class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
  private:
   fmt::internal::Arg &arg_;
   wchar_t type_;
 
+  FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
+
  public:
   ArgConverter(fmt::internal::Arg &arg, wchar_t type)
     : arg_(arg), type_(type) {}
 
+  void visit_bool(bool value) {
+    if (type_ != 's')
+      visit_any_int(value);
+  }
+
   template <typename U>
   void visit_any_int(U value) {
     bool is_signed = type_ == 'd' || type_ == 'i';
     using fmt::internal::Arg;
     if (sizeof(T) <= sizeof(int)) {
+      // Extra casts are used to silence warnings.
       if (is_signed) {
         arg_.type = Arg::INT;
         arg_.int_value = static_cast<int>(static_cast<T>(value));
@@ -277 +387 @@
   }
 };
 
-// Converts an integer argument to char.
+// Converts an integer argument to char for printf.
 class CharConverter : public fmt::internal::ArgVisitor<CharConverter, void> {
  private:
   fmt::internal::Arg &arg_;
 
+  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
+
  public:
   explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}
 
@@ -291 +403 @@
     arg_.int_value = static_cast<char>(value);
   }
 };
+}  // namespace
+
+namespace internal {
+
+template <typename Impl, typename Char>
+class BasicArgFormatter : public ArgVisitor<Impl, void> {
+ private:
+  BasicWriter<Char> &writer_;
+  FormatSpec &spec_;
+
+  FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter);
+
+  void write_pointer(const void *p) {
+    spec_.flags_ = HASH_FLAG;
+    spec_.type_ = 'x';
+    writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
+  }
+
+ protected:
+  BasicWriter<Char> &writer() { return writer_; }
+  FormatSpec &spec() { return spec_; }
+
+  void write(bool value) {
+    const char *str_value = value ? "true" : "false";
+    Arg::StringValue<char> str = { str_value, strlen(str_value) };
+    writer_.write_str(str, spec_);
+  }
+
+  void write(const char *value) {
+    Arg::StringValue<char> str = {value, value != 0 ? strlen(value) : 0};
+    writer_.write_str(str, spec_);
+  }
+
+ public:
+  BasicArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
+  : writer_(w), spec_(s) {}
+
+  template <typename T>
+  void visit_any_int(T value) { writer_.write_int(value, spec_); }
+
+  template <typename T>
+  void visit_any_double(T value) { writer_.write_double(value, spec_); }
+
+  void visit_bool(bool value) {
+    if (spec_.type_)
+      return visit_any_int(value);
+    write(value);
+  }
+
+  void visit_char(int value) {
+    if (spec_.type_ && spec_.type_ != 'c') {
+      spec_.flags_ |= CHAR_FLAG;
+      writer_.write_int(value, spec_);
+      return;
+    }
+    if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
+      FMT_THROW(FormatError("invalid format specifier for char"));
+    typedef typename BasicWriter<Char>::CharPtr CharPtr;
+    Char fill = internal::CharTraits<Char>::cast(spec_.fill());
+    CharPtr out = CharPtr();
+    const unsigned CHAR_WIDTH = 1;
+    if (spec_.width_ > CHAR_WIDTH) {
+      out = writer_.grow_buffer(spec_.width_);
+      if (spec_.align_ == ALIGN_RIGHT) {
+        std::fill_n(out, spec_.width_ - CHAR_WIDTH, fill);
+        out += spec_.width_ - CHAR_WIDTH;
+      } else if (spec_.align_ == ALIGN_CENTER) {
+        out = writer_.fill_padding(out, spec_.width_,
+                                   internal::check(CHAR_WIDTH), fill);
+      } else {
+        std::fill_n(out + CHAR_WIDTH, spec_.width_ - CHAR_WIDTH, fill);
+      }
+    } else {
+      out = writer_.grow_buffer(CHAR_WIDTH);
+    }
+    *out = internal::CharTraits<Char>::cast(value);
+  }
+
+  void visit_cstring(const char *value) {
+    if (spec_.type_ == 'p')
+      return write_pointer(value);
+    write(value);
+  }
+
+  void visit_string(Arg::StringValue<char> value) {
+    writer_.write_str(value, spec_);
+  }
+
+  using ArgVisitor<Impl, void>::visit_wstring;
+
+  void visit_wstring(Arg::StringValue<Char> value) {
+    writer_.write_str(value, spec_);
+  }
+
+  void visit_pointer(const void *value) {
+    if (spec_.type_ && spec_.type_ != 'p')
+      report_unknown_type(spec_.type_, "pointer");
+    write_pointer(value);
+  }
+};
 
-// This function template is used to prevent compile errors when handling
-// incompatible string arguments, e.g. handling a wide string in a narrow
-// string formatter.
+// An argument formatter.
 template <typename Char>
-Arg::StringValue<Char> ignore_incompatible_str(Arg::StringValue<wchar_t>);
+class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char> {
+ private:
+  BasicFormatter<Char> &formatter_;
+  const Char *format_;
 
-template <>
-inline Arg::StringValue<char> ignore_incompatible_str(
-    Arg::StringValue<wchar_t>) { return Arg::StringValue<char>(); }
+ public:
+  ArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)
+  : BasicArgFormatter<ArgFormatter<Char>, Char>(f.writer(), s),
+    formatter_(f), format_(fmt) {}
 
-template <>
-inline Arg::StringValue<wchar_t> ignore_incompatible_str(
-    Arg::StringValue<wchar_t> s) { return s; }
-}  // namespace
+  void visit_custom(Arg::CustomValue c) {
+    c.format(&formatter_, c.value, &format_);
+  }
+};
+
+template <typename Char>
+class PrintfArgFormatter :
+    public BasicArgFormatter<PrintfArgFormatter<Char>, Char> {
+
+  void write_null_pointer() {
+    this->spec().type_ = 0;
+    this->write("(nil)");
+  }
+
+  typedef BasicArgFormatter<PrintfArgFormatter<Char>, Char> Base;
+
+ public:
+  PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
+  : BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}
+
+  void visit_bool(bool value) {
+    FormatSpec &fmt_spec = this->spec();
+    if (fmt_spec.type_ != 's')
+      return this->visit_any_int(value);
+    fmt_spec.type_ = 0;
+    this->write(value);
+  }
+
+  void visit_char(int value) {
+    const FormatSpec &fmt_spec = this->spec();
+    BasicWriter<Char> &w = this->writer();
+    if (fmt_spec.type_ && fmt_spec.type_ != 'c')
+      w.write_int(value, fmt_spec);
+    typedef typename BasicWriter<Char>::CharPtr CharPtr;
+    CharPtr out = CharPtr();
+    if (fmt_spec.width_ > 1) {
+      Char fill = ' ';
+      out = w.grow_buffer(fmt_spec.width_);
+      if (fmt_spec.align_ != ALIGN_LEFT) {
+        std::fill_n(out, fmt_spec.width_ - 1, fill);
+        out += fmt_spec.width_ - 1;
+      } else {
+        std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
+      }
+    } else {
+      out = w.grow_buffer(1);
+    }
+    *out = static_cast<Char>(value);
+  }
 
-void fmt::SystemError::init(
-    int error_code, StringRef format_str, const ArgList &args) {
-  error_code_ = error_code;
-  Writer w;
-  internal::format_system_error(w, error_code, format(format_str, args));
+  void visit_cstring(const char *value) {
+    if (value)
+      Base::visit_cstring(value);
+    else if (this->spec().type_ == 'p')
+      write_null_pointer();
+    else
+      this->write("(null)");
+  }
+
+  void visit_pointer(const void *value) {
+    if (value)
+      return Base::visit_pointer(value);
+    this->spec().type_ = 0;
+    write_null_pointer();
+  }
+
+  void visit_custom(Arg::CustomValue c) {
+    BasicFormatter<Char> formatter(ArgList(), this->writer());
+    const Char format_str[] = {'}', 0};
+    const Char *format = format_str;
+    c.format(&formatter, c.value, &format);
+  }
+};
+}  // namespace internal
+}  // namespace fmt
+
+FMT_FUNC void fmt::SystemError::init(
+    int err_code, CStringRef format_str, ArgList args) {
+  error_code_ = err_code;
+  MemoryWriter w;
+  internal::format_system_error(w, err_code, format(format_str, args));
   std::runtime_error &base = *this;
   base = std::runtime_error(w.str());
 }
@@ -336 +621 @@
     unsigned width, int precision, T value) {
   if (width == 0) {
     return precision < 0 ?
-        swprintf(buffer, size, format, value) :
-        swprintf(buffer, size, format, precision, value);
+        FMT_SWPRINTF(buffer, size, format, value) :
+        FMT_SWPRINTF(buffer, size, format, precision, value);
   }
   return precision < 0 ?
-      swprintf(buffer, size, format, width, value) :
-      swprintf(buffer, size, format, width, precision, value);
+      FMT_SWPRINTF(buffer, size, format, width, value) :
+      FMT_SWPRINTF(buffer, size, format, width, precision, value);
 }
 
-const char fmt::internal::DIGITS[] =
+template <typename T>
+const char fmt::internal::BasicData<T>::DIGITS[] =
     "0001020304050607080910111213141516171819"
     "2021222324252627282930313233343536373839"
     "4041424344454647484950515253545556575859"
@@ -362 +648 @@
   factor * 100000000, \
   factor * 1000000000
 
-const uint32_t fmt::internal::POWERS_OF_10_32[] = {0, FMT_POWERS_OF_10(1)};
-const uint64_t fmt::internal::POWERS_OF_10_64[] = {
+template <typename T>
+const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
+  0, FMT_POWERS_OF_10(1)
+};
+
+template <typename T>
+const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
   0,
   FMT_POWERS_OF_10(1),
-  FMT_POWERS_OF_10(ULongLong(1000000000)),
+  FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),
   // Multiply several constants instead of using a single long long constant
   // to avoid warnings about C++98 not supporting long long.
-  ULongLong(1000000000) * ULongLong(1000000000) * 10
+  fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10
 };
 
-void fmt::internal::report_unknown_type(char code, const char *type) {
+FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) {
+  (void)type;
   if (std::isprint(static_cast<unsigned char>(code))) {
-    throw fmt::FormatError(
-        fmt::format("unknown format code '{}' for {}", code, type));
+    FMT_THROW(fmt::FormatError(
+        fmt::format("unknown format code '{}' for {}", code, type)));
   }
-  throw fmt::FormatError(
+  FMT_THROW(fmt::FormatError(
       fmt::format("unknown format code '\\x{:02x}' for {}",
-        static_cast<unsigned>(code), type));
+        static_cast<unsigned>(code), type)));
 }
 
-#ifdef _WIN32
+#if FMT_USE_WINDOWS_H
 
-fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
+FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
+  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
+  if (s.size() > INT_MAX)
+    FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
+  int s_size = static_cast<int>(s.size());
   int length = MultiByteToWideChar(
-      CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, 0, 0);
-  static const char ERROR[] = "cannot convert string from UTF-8 to UTF-16";
+      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);
   if (length == 0)
-    throw WindowsError(GetLastError(), ERROR);
-  buffer_.resize(length);
+    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
+  buffer_.resize(length + 1);
   length = MultiByteToWideChar(
-    CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, &buffer_[0], length);
+    CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
   if (length == 0)
-    throw WindowsError(GetLastError(), ERROR);
+    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
+  buffer_[length] = 0;
 }
 
-fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) {
+FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) {
   if (int error_code = convert(s)) {
-    throw WindowsError(error_code,
-        "cannot convert string from UTF-16 to UTF-8");
+    FMT_THROW(WindowsError(error_code,
+        "cannot convert string from UTF-16 to UTF-8"));
   }
 }
 
-int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
-  int length = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), -1, 0, 0, 0, 0);
+FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
+  if (s.size() > INT_MAX)
+    return ERROR_INVALID_PARAMETER;
+  int s_size = static_cast<int>(s.size());
+  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);
   if (length == 0)
     return GetLastError();
-  buffer_.resize(length);
+  buffer_.resize(length + 1);
   length = WideCharToMultiByte(
-    CP_UTF8, 0, s.c_str(), -1, &buffer_[0], length, 0, 0);
+    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);
   if (length == 0)
     return GetLastError();
+  buffer_[length] = 0;
   return 0;
 }
 
-void fmt::WindowsError::init(
-    int error_code, StringRef format_str, const ArgList &args) {
-  error_code_ = error_code;
-  Writer w;
-  internal::format_windows_error(w, error_code, format(format_str, args));
+FMT_FUNC void fmt::WindowsError::init(
+    int err_code, CStringRef format_str, ArgList args) {
+  error_code_ = err_code;
+  MemoryWriter w;
+  internal::format_windows_error(w, err_code, format(format_str, args));
   std::runtime_error &base = *this;
   base = std::runtime_error(w.str());
 }
 
-#endif
-
-int fmt::internal::safe_strerror(
-    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT(true) {
-  assert(buffer != 0 && buffer_size != 0);
-  int result = 0;
-#if defined(_GNU_SOURCE) && !defined(__BIONIC__)
-  char *message = strerror_r(error_code, buffer, buffer_size);
-  // If the buffer is full then the message is probably truncated.
-  if (message == buffer && strlen(buffer) == buffer_size - 1)
-    result = ERANGE;
-  buffer = message;
-#elif defined(__MINGW32__)
-  errno = 0;
-  (void)buffer_size;
-  buffer = strerror(error_code);
-  result = errno;
-#elif defined(_WIN32)
-  result = strerror_s(buffer, buffer_size, error_code);
-  // If the buffer is full then the message is probably truncated.
-  if (result == 0 && std::strlen(buffer) == buffer_size - 1)
-    result = ERANGE;
-#else
-  result = strerror_r(error_code, buffer, buffer_size);
-  if (result == -1)
-    result = errno;  // glibc versions before 2.13 return result in errno.
-#endif
-  return result;
-}
-
-void fmt::internal::format_system_error(
-    fmt::Writer &out, int error_code, fmt::StringRef message) {
-  Array<char, INLINE_BUFFER_SIZE> buffer;
-  buffer.resize(INLINE_BUFFER_SIZE);
-  char *system_message = 0;
-  for (;;) {
-    system_message = &buffer[0];
-    int result = safe_strerror(error_code, system_message, buffer.size());
-    if (result == 0)
-      break;
-    if (result != ERANGE) {
-      // Can't get error message, report error code instead.
-      out << message << ": error code = " << error_code;
-      return;
-    }
-    buffer.resize(buffer.size() * 2);
-  }
-  out << message << ": " << system_message;
-}
-
-#ifdef _WIN32
-void fmt::internal::format_windows_error(
-    fmt::Writer &out, int error_code, fmt::StringRef message) {
+FMT_FUNC void fmt::internal::format_windows_error(
+    fmt::Writer &out, int error_code,
+    fmt::StringRef message) FMT_NOEXCEPT {
   class String {
    private:
     LPWSTR str_;
@@ -488 +738 @@
     LPWSTR *ptr() { return &str_; }
     LPCWSTR c_str() const { return str_; }
   };
-  String system_message;
-  if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
-      error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-      reinterpret_cast<LPWSTR>(system_message.ptr()), 0, 0)) {
-    UTF16ToUTF8 utf8_message;
-    if (!utf8_message.convert(system_message.c_str())) {
-      out << message << ": " << utf8_message;
-      return;
+  FMT_TRY {
+    String system_message;
+    if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
+        error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        reinterpret_cast<LPWSTR>(system_message.ptr()), 0, 0)) {
+      UTF16ToUTF8 utf8_message;
+      if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) {
+        out << message << ": " << utf8_message;
+        return;
+      }
     }
-  }
-  // Can't get error message, report error code instead.
-  out << message << ": error code = " << error_code;
+  } FMT_CATCH(...) {}
+  fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
 }
-#endif
-
-// An argument formatter.
-template <typename Char>
-class fmt::internal::ArgFormatter :
-    public fmt::internal::ArgVisitor<fmt::internal::ArgFormatter<Char>, void> {
- private:
-  fmt::BasicFormatter<Char> &formatter_;
-  fmt::BasicWriter<Char> &writer_;
-  fmt::FormatSpec &spec_;
-  const Char *format_;
-
- public:
-  ArgFormatter(
-      fmt::BasicFormatter<Char> &f,fmt::FormatSpec &s, const Char *fmt)
-  : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {}
-
-  template <typename T>
-  void visit_any_int(T value) { writer_.write_int(value, spec_); }
 
-  template <typename T>
-  void visit_any_double(T value) { writer_.write_double(value, spec_); }
-
-  void visit_char(int value) {
-    if (spec_.type_ && spec_.type_ != 'c') {
-      spec_.flags_ |= CHAR_FLAG;
-      writer_.write_int(value, spec_);
-      return;
-    }
-    if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
-      throw FormatError("invalid format specifier for char");
-    typedef typename fmt::BasicWriter<Char>::CharPtr CharPtr;
-    CharPtr out = CharPtr();
-    if (spec_.width_ > 1) {
-      Char fill = static_cast<Char>(spec_.fill());
-      out = writer_.grow_buffer(spec_.width_);
-      if (spec_.align_ == fmt::ALIGN_RIGHT) {
-        std::fill_n(out, spec_.width_ - 1, fill);
-        out += spec_.width_ - 1;
-      } else if (spec_.align_ == fmt::ALIGN_CENTER) {
-        out = writer_.fill_padding(out, spec_.width_, 1, fill);
-      } else {
-        std::fill_n(out + 1, spec_.width_ - 1, fill);
+#endif  // FMT_USE_WINDOWS_H
+
+FMT_FUNC void fmt::internal::format_system_error(
+    fmt::Writer &out, int error_code,
+    fmt::StringRef message) FMT_NOEXCEPT {
+  FMT_TRY {
+    MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
+    buffer.resize(INLINE_BUFFER_SIZE);
+    for (;;) {
+      char *system_message = &buffer[0];
+      int result = safe_strerror(error_code, system_message, buffer.size());
+      if (result == 0) {
+        out << message << ": " << system_message;
+        return;
       }
-    } else {
-      out = writer_.grow_buffer(1);
+      if (result != ERANGE)
+        break;  // Can't get error message, report error code instead.
+      buffer.resize(buffer.size() * 2);
     }
-    *out = static_cast<Char>(value);
-  }
-
-  void visit_string(Arg::StringValue<char> value) {
-    writer_.write_str(value, spec_);
-  }
-  void visit_wstring(Arg::StringValue<wchar_t> value) {
-    writer_.write_str(ignore_incompatible_str<Char>(value), spec_);
-  }
-
-  void visit_pointer(const void *value) {
-    if (spec_.type_ && spec_.type_ != 'p')
-      fmt::internal::report_unknown_type(spec_.type_, "pointer");
-    spec_.flags_ = fmt::HASH_FLAG;
-    spec_.type_ = 'x';
-    writer_.write_int(reinterpret_cast<uintptr_t>(value), spec_);
-  }
-
-  void visit_custom(Arg::CustomValue c) {
-    c.format(&formatter_, c.value, format_);
-  }
-};
-
-template <typename Char>
-void fmt::internal::FormatErrorReporter<Char>::operator()(
-        const Char *s, fmt::StringRef message) const {
-  if (find_closing_brace(s, num_open_braces))
-    throw fmt::FormatError(message);
+  } FMT_CATCH(...) {}
+  fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
 }
 
-// Fills the padding around the content and returns the pointer to the
-// content area.
 template <typename Char>
-typename fmt::BasicWriter<Char>::CharPtr
-  fmt::BasicWriter<Char>::fill_padding(CharPtr buffer,
-    unsigned total_size, std::size_t content_size, wchar_t fill) {
-  std::size_t padding = total_size - content_size;
-  std::size_t left_padding = padding / 2;
-  Char fill_char = static_cast<Char>(fill);
-  std::fill_n(buffer, left_padding, fill_char);
-  buffer += left_padding;
-  CharPtr content = buffer;
-  std::fill_n(buffer + content_size, padding - left_padding, fill_char);
-  return content;
-}
-
-template <typename Char>
-template <typename T>
-void fmt::BasicWriter<Char>::write_double(T value, const FormatSpec &spec) {
-  // Check type.
-  char type = spec.type();
-  bool upper = false;
-  switch (type) {
-  case 0:
-    type = 'g';
-    break;
-  case 'e': case 'f': case 'g': case 'a':
-    break;
-  case 'F':
-#ifdef _MSC_VER
-    // MSVC's printf doesn't support 'F'.
-    type = 'f';
-#endif
-    // Fall through.
-  case 'E': case 'G': case 'A':
-    upper = true;
-    break;
-  default:
-    internal::report_unknown_type(type, "double");
-    break;
-  }
-
-  char sign = 0;
-  // Use getsign instead of value < 0 because the latter is always
-  // false for NaN.
-  if (getsign(static_cast<double>(value))) {
-    sign = '-';
-    value = -value;
-  } else if (spec.flag(SIGN_FLAG)) {
-    sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
-  }
-
-  if (value != value) {
-    // Format NaN ourselves because sprintf's output is not consistent
-    // across platforms.
-    std::size_t size = 4;
-    const char *nan = upper ? " NAN" : " nan";
-    if (!sign) {
-      --size;
-      ++nan;
-    }
-    CharPtr out = write_str(nan, size, spec);
-    if (sign)
-      *out = sign;
+void fmt::internal::ArgMap<Char>::init(const ArgList &args) {
+  if (!map_.empty())
     return;
-  }
-
-  if (isinfinity(value)) {
-    // Format infinity ourselves because sprintf's output is not consistent
-    // across platforms.
-    std::size_t size = 4;
-    const char *inf = upper ? " INF" : " inf";
-    if (!sign) {
-      --size;
-      ++inf;
+  typedef internal::NamedArg<Char> NamedArg;
+  const NamedArg *named_arg = 0;
+  bool use_values =
+      args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
+  if (use_values) {
+    for (unsigned i = 0;/*nothing*/; ++i) {
+      internal::Arg::Type arg_type = args.type(i);
+      switch (arg_type) {
+      case internal::Arg::NONE:
+        return;
+      case internal::Arg::NAMED_ARG:
+        named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
+        map_.insert(Pair(named_arg->name, *named_arg));
+        break;
+      default:
+        /*nothing*/;
+      }
     }
-    CharPtr out = write_str(inf, size, spec);
-    if (sign)
-      *out = sign;
     return;
   }
-
-  std::size_t offset = buffer_.size();
-  unsigned width = spec.width();
-  if (sign) {
-    buffer_.reserve(buffer_.size() + (std::max)(width, 1u));
-    if (width > 0)
-      --width;
-    ++offset;
-  }
-
-  // Build format string.
-  enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
-  Char format[MAX_FORMAT_SIZE];
-  Char *format_ptr = format;
-  *format_ptr++ = '%';
-  unsigned width_for_sprintf = width;
-  if (spec.flag(HASH_FLAG))
-    *format_ptr++ = '#';
-  if (spec.align() == ALIGN_CENTER) {
-    width_for_sprintf = 0;
-  } else {
-    if (spec.align() == ALIGN_LEFT)
-      *format_ptr++ = '-';
-    if (width != 0)
-      *format_ptr++ = '*';
-  }
-  if (spec.precision() >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
-  if (IsLongDouble<T>::VALUE)
-    *format_ptr++ = 'L';
-  *format_ptr++ = type;
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  Char fill = static_cast<Char>(spec.fill());
-  for (;;) {
-    std::size_t size = buffer_.capacity() - offset;
-#ifdef _MSC_VER
-    // MSVC's vsnprintf_s doesn't work with zero size, so reserve
-    // space for at least one extra character to make the size non-zero.
-    // Note that the buffer's capacity will increase by more than 1.
-    if (size == 0) {
-      buffer_.reserve(offset + 1);
-      size = buffer_.capacity() - offset;
+  for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
+    internal::Arg::Type arg_type = args.type(i);
+    if (arg_type == internal::Arg::NAMED_ARG) {
+      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
+      map_.insert(Pair(named_arg->name, *named_arg));
     }
-#endif
-    Char *start = &buffer_[offset];
-    int n = internal::CharTraits<Char>::format_float(
-        start, size, format, width_for_sprintf, spec.precision(), value);
-    if (n >= 0 && offset + n < buffer_.capacity()) {
-      if (sign) {
-        if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
-            *start != ' ') {
-          *(start - 1) = sign;
-          sign = 0;
-        } else {
-          *(start - 1) = fill;
-        }
-        ++n;
-      }
-      if (spec.align() == ALIGN_CENTER &&
-          spec.width() > static_cast<unsigned>(n)) {
-        unsigned width = spec.width();
-        CharPtr p = grow_buffer(width);
-        std::copy(p, p + n, p + (width - n) / 2);
-        fill_padding(p, spec.width(), n, fill);
-        return;
-      }
-      if (spec.fill() != ' ' || sign) {
-        while (*start == ' ')
-          *start++ = fill;
-        if (sign)
-          *(start - 1) = sign;
-      }
-      grow_buffer(n);
+  }
+  for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
+    switch (args.args_[i].type) {
+    case internal::Arg::NONE:
       return;
+    case internal::Arg::NAMED_ARG:
+      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
+      map_.insert(Pair(named_arg->name, *named_arg));
+      break;
+    default:
+      /*nothing*/;
     }
-    // If n is negative we ask to increase the capacity by at least 1,
-    // but as std::vector, the buffer grows exponentially.
-    buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
   }
 }
 
 template <typename Char>
+void fmt::internal::FixedBuffer<Char>::grow(std::size_t) {
+  FMT_THROW(std::runtime_error("buffer overflow"));
+}
+
+template <typename Char>
 template <typename StrChar>
 void fmt::BasicWriter<Char>::write_str(
-    const Arg::StringValue<StrChar> &str, const FormatSpec &spec) {
+    const Arg::StringValue<StrChar> &s, const FormatSpec &spec) {
   // Check if StrChar is convertible to Char.
   internal::CharTraits<Char>::convert(StrChar());
   if (spec.type_ && spec.type_ != 's')
     internal::report_unknown_type(spec.type_, "string");
-  const StrChar *s = str.value;
-  std::size_t size = str.size;
-  if (size == 0) {
-    if (!s) {
-      Char err[] = { '(', 'n', 'u', 'l', 'l', ')' };
-      write_str(err, sizeof(err)/sizeof(Char), spec);
+  const StrChar *str_value = s.value;
+  std::size_t str_size = s.size;
+  if (str_size == 0) {
+    if (!str_value) {
+      FMT_THROW(FormatError("string pointer is null"));
       return;
     }
-    if (*s)
-      size = std::char_traits<StrChar>::length(s);
   }
-  write_str(s, size, spec);
+  std::size_t precision = spec.precision_;
+  if (spec.precision_ >= 0 && precision < str_size)
+    str_size = spec.precision_;
+  write_str(str_value, str_size, spec);
 }
 
 template <typename Char>
-inline const Arg
-    &fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
-  unsigned arg_index = 0;
-  if (*s < '0' || *s > '9') {
-    if (*s != '}' && *s != ':')
-      report_error_(s, "invalid argument index in format string");
-    const Arg &arg = next_arg();
-    if (error_)
-      report_error_(s, error_);
-    return arg;
-  }
-  if (next_arg_index_ > 0) {
-    report_error_(s,
-        "cannot switch from automatic to manual argument indexing");
+inline Arg fmt::BasicFormatter<Char>::get_arg(
+  BasicStringRef<Char> arg_name, const char *&error) {
+  if (check_no_auto_index(error)) {
+    map_.init(args());
+    const Arg *arg = map_.find(arg_name);
+    if (arg)
+      return *arg;
+    error = "argument not found";
   }
-  next_arg_index_ = -1;
-  arg_index = parse_nonnegative_int(s, error_);
-  if (error_)
-    report_error_(s, error_); // TODO: don't use report_error_
-  if (arg_index >= args_.size())
-    report_error_(s, "argument index is out of range in format");
-  return args_[arg_index];
+  return Arg();
 }
 
 template <typename Char>
-void fmt::BasicFormatter<Char>::check_sign(
-    const Char *&s, const Arg &arg) {
-  char sign = static_cast<char>(*s);
-  if (arg.type > Arg::LAST_NUMERIC_TYPE) {
-    report_error_(s, fmt::format(
-      "format specifier '{}' requires numeric argument", sign).c_str());
-  }
-  if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
-    report_error_(s, fmt::format(
-      "format specifier '{}' requires signed argument", sign).c_str());
+inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
+  const char *error = 0;
+  Arg arg = *s < '0' || *s > '9' ?
+        next_arg(error) : get_arg(parse_nonnegative_int(s), error);
+  if (error) {
+    FMT_THROW(FormatError(
+                *s != '}' && *s != ':' ? "invalid format string" : error));
   }
-  ++s;
+  return arg;
 }
 
-const Arg &fmt::internal::FormatterBase::next_arg() {
-  if (next_arg_index_ < 0) {
-    if (!error_)
-      error_ = "cannot switch from manual to automatic argument indexing";
-    return DUMMY_ARG;
+template <typename Char>
+inline Arg fmt::BasicFormatter<Char>::parse_arg_name(const Char *&s) {
+  assert(is_name_start(*s));
+  const Char *start = s;
+  Char c;
+  do {
+    c = *++s;
+  } while (is_name_start(c) || ('0' <= c && c <= '9'));
+  const char *error = 0;
+  Arg arg = get_arg(fmt::BasicStringRef<Char>(start, s - start), error);
+  if (error)
+    FMT_THROW(fmt::FormatError(error));
+  return arg;
+}
+
+FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
+    unsigned arg_index, const char *&error) {
+  Arg arg = args_[arg_index];
+  switch (arg.type) {
+  case Arg::NONE:
+    error = "argument index out of range";
+    break;
+  case Arg::NAMED_ARG:
+    arg = *static_cast<const internal::Arg*>(arg.pointer);
+  default:
+    /*nothing*/;
   }
-  unsigned arg_index = next_arg_index_++;
-  if (arg_index < args_.size())
-    return args_[arg_index];
-  if (!error_)
-    error_ = "argument index is out of range in format";
-  return DUMMY_ARG;
+  return arg;
 }
 
-const Arg &fmt::internal::FormatterBase::handle_arg_index(unsigned arg_index) {
-  if (arg_index != UINT_MAX) {
-    if (next_arg_index_ <= 0) {
-      next_arg_index_ = -1;
-      --arg_index;
-    } else if (!error_) {
-      error_ = "cannot switch from automatic to manual argument indexing";
-    }
-    if (arg_index < args_.size())
-      return args_[arg_index];
-    if (!error_)
-      error_ = "argument index is out of range in format";
-    return DUMMY_ARG;
+inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) {
+  if (next_arg_index_ >= 0)
+    return do_get_arg(next_arg_index_++, error);
+  error = "cannot switch from manual to automatic argument indexing";
+  return Arg();
+}
+
+inline bool fmt::internal::FormatterBase::check_no_auto_index(
+    const char *&error) {
+  if (next_arg_index_ > 0) {
+    error = "cannot switch from automatic to manual argument indexing";
+    return false;
   }
-  return next_arg();
+  next_arg_index_ = -1;
+  return true;
+}
+
+inline Arg fmt::internal::FormatterBase::get_arg(
+    unsigned arg_index, const char *&error) {
+  return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
 }
 
 template <typename Char>
@@ -866 +954 @@
 }
 
 template <typename Char>
+Arg fmt::internal::PrintfFormatter<Char>::get_arg(
+    const Char *s, unsigned arg_index) {
+  (void)s;
+  const char *error = 0;
+  Arg arg = arg_index == UINT_MAX ?
+    next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
+  if (error)
+    FMT_THROW(FormatError(!*s ? "invalid format string" : error));
+  return arg;
+}
+
+template <typename Char>
 unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
   const Char *&s, FormatSpec &spec) {
   unsigned arg_index = UINT_MAX;
@@ -873 +973 @@
   if (c >= '0' && c <= '9') {
     // Parse an argument index (if followed by '$') or a width possibly
     // preceded with '0' flag(s).
-    unsigned value = parse_nonnegative_int(s, error_);
+    unsigned value = parse_nonnegative_int(s);
     if (*s == '$') {  // value is an argument index
       ++s;
       arg_index = value;
@@ -891 +991 @@
   parse_flags(spec, s);
   // Parse width.
   if (*s >= '0' && *s <= '9') {
-    spec.width_ = parse_nonnegative_int(s, error_);
+    spec.width_ = parse_nonnegative_int(s);
   } else if (*s == '*') {
     ++s;
-    spec.width_ = WidthHandler(spec).visit(handle_arg_index(UINT_MAX));
+    spec.width_ = WidthHandler(spec).visit(get_arg(s));
   }
   return arg_index;
 }
 
 template <typename Char>
 void fmt::internal::PrintfFormatter<Char>::format(
-    BasicWriter<Char> &writer, BasicStringRef<Char> format,
-    const ArgList &args) {
-  const Char *start = format.c_str();
-  args_ = args;
-  next_arg_index_ = 0;
+    BasicWriter<Char> &writer, BasicCStringRef<Char> format_str) {
+  const Char *start = format_str.c_str();
   const Char *s = start;
   while (*s) {
     Char c = *s++;
@@ -920 +1017 @@
     FormatSpec spec;
     spec.align_ = ALIGN_RIGHT;
 
-    // Reporting errors is delayed till the format specification is
-    // completely parsed. This is done to avoid potentially confusing
-    // error messages for incomplete format strings. For example, in
-    //   sprintf("%2$", 42);
-    // the format specification is incomplete. In a naive approach we
-    // would parse 2 as an argument index and report an error that the
-    // index is out of range which would be rather confusing if the
-    // use meant "%2d$" rather than "%2$d". If we delay an error, the
-    // user will get an error that the format string is invalid which
-    // is OK for both cases.
-
     // Parse argument index, flags and width.
     unsigned arg_index = parse_header(s, spec);
 
@@ -938 +1024 @@
     if (*s == '.') {
       ++s;
       if ('0' <= *s && *s <= '9') {
-        spec.precision_ = parse_nonnegative_int(s, error_);
+        spec.precision_ = parse_nonnegative_int(s);
       } else if (*s == '*') {
         ++s;
-        spec.precision_ = PrecisionHandler().visit(handle_arg_index(UINT_MAX));
+        spec.precision_ = PrecisionHandler().visit(get_arg(s));
       }
     }
 
-    Arg arg = handle_arg_index(arg_index);
+    Arg arg = get_arg(s, arg_index);
     if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg))
       spec.flags_ &= ~HASH_FLAG;
     if (spec.fill_ == '0') {
@@ -973 +1059 @@
       ArgConverter<intmax_t>(arg, *s).visit(arg);
       break;
     case 'z':
-      ArgConverter<size_t>(arg, *s).visit(arg);
+      ArgConverter<std::size_t>(arg, *s).visit(arg);
       break;
     case 't':
-      ArgConverter<ptrdiff_t>(arg, *s).visit(arg);
+      ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
       break;
     case 'L':
       // printf produces garbage when 'L' is omitted for long double, no
@@ -989 +1075 @@
 
     // Parse type.
     if (!*s)
-      throw FormatError("invalid format string");
-    if (error_)
-      throw FormatError(error_);
+      FMT_THROW(FormatError("invalid format string"));
     spec.type_ = static_cast<char>(*s++);
     if (arg.type <= Arg::LAST_INTEGER_TYPE) {
       // Normalize type.
@@ -1009 +1093 @@
     start = s;
 
     // Format argument.
-    switch (arg.type) {
-    case Arg::INT:
-      writer.write_int(arg.int_value, spec);
-      break;
-    case Arg::UINT:
-      writer.write_int(arg.uint_value, spec);
-      break;
-    case Arg::LONG_LONG:
-      writer.write_int(arg.long_long_value, spec);
-      break;
-    case Arg::ULONG_LONG:
-      writer.write_int(arg.ulong_long_value, spec);
-      break;
-    case Arg::CHAR: {
-      if (spec.type_ && spec.type_ != 'c')
-        writer.write_int(arg.int_value, spec);
-      typedef typename BasicWriter<Char>::CharPtr CharPtr;
-      CharPtr out = CharPtr();
-      if (spec.width_ > 1) {
-        Char fill = ' ';
-        out = writer.grow_buffer(spec.width_);
-        if (spec.align_ != ALIGN_LEFT) {
-          std::fill_n(out, spec.width_ - 1, fill);
-          out += spec.width_ - 1;
-        } else {
-          std::fill_n(out + 1, spec.width_ - 1, fill);
-        }
-      } else {
-        out = writer.grow_buffer(1);
-      }
-      *out = static_cast<Char>(arg.int_value);
-      break;
-    }
-    case Arg::DOUBLE:
-      writer.write_double(arg.double_value, spec);
-      break;
-    case Arg::LONG_DOUBLE:
-      writer.write_double(arg.long_double_value, spec);
-      break;
-    case Arg::STRING:
-      writer.write_str(arg.string, spec);
-      break;
-    case Arg::WSTRING:
-      writer.write_str(ignore_incompatible_str<Char>(arg.wstring), spec);
-      break;
-    case Arg::POINTER:
-      if (spec.type_ && spec.type_ != 'p')
-        internal::report_unknown_type(spec.type_, "pointer");
-      spec.flags_= HASH_FLAG;
-      spec.type_ = 'x';
-      writer.write_int(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
-      break;
-    case Arg::CUSTOM:
-      if (spec.type_)
-        internal::report_unknown_type(spec.type_, "object");
-      arg.custom.format(&writer, arg.custom.value, "s");
-      break;
-    default:
-      assert(false);
-      break;
-    }
+    internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);
   }
   write(writer, start, s);
 }
 
 template <typename Char>
 const Char *fmt::BasicFormatter<Char>::format(
-    const Char *format_str, const Arg &arg) {
+    const Char *&format_str, const Arg &arg) {
   const Char *s = format_str;
-  const char *error = 0;
   FormatSpec spec;
   if (*s == ':') {
     if (arg.type == Arg::CUSTOM) {
-      arg.custom.format(this, arg.custom.value, s);
-      return find_closing_brace(s) + 1;
+      arg.custom.format(this, arg.custom.value, &s);
+      return s;
     }
     ++s;
     // Parse fill and alignment.
@@ -1109 +1132 @@
           if (p != s) {
             if (c == '}') break;
             if (c == '{')
-              report_error_(s, "invalid fill character '{'");
+              FMT_THROW(FormatError("invalid fill character '{'"));
             s += 2;
             spec.fill_ = c;
           } else ++s;
-          if (spec.align_ == ALIGN_NUMERIC && arg.type > Arg::LAST_NUMERIC_TYPE)
-            report_error_(s, "format specifier '=' requires numeric argument");
+          if (spec.align_ == ALIGN_NUMERIC)
+            require_numeric_argument(arg, '=');
           break;
         }
       } while (--p >= s);
@@ -1137 +1160 @@
     }
 
     if (*s == '#') {
-      if (arg.type > Arg::LAST_NUMERIC_TYPE)
-        report_error_(s, "format specifier '#' requires numeric argument");
+      require_numeric_argument(arg, '#');
       spec.flags_ |= HASH_FLAG;
       ++s;
     }
 
-    // Parse width and zero flag.
+    // Parse zero flag.
+    if (*s == '0') {
+      require_numeric_argument(arg, '0');
+      spec.align_ = ALIGN_NUMERIC;
+      spec.fill_ = '0';
+      ++s;
+    }
+
+    // Parse width.
     if ('0' <= *s && *s <= '9') {
-      if (*s == '0') {
-        if (arg.type > Arg::LAST_NUMERIC_TYPE)
-          report_error_(s, "format specifier '0' requires numeric argument");
-        spec.align_ = ALIGN_NUMERIC;
-        spec.fill_ = '0';
+      spec.width_ = parse_nonnegative_int(s);
+    } else if (*s == '{') {
+      ++s;
+      Arg width_arg = is_name_start(*s) ?
+            parse_arg_name(s) : parse_arg_index(s);
+      if (*s++ != '}')
+        FMT_THROW(FormatError("invalid format string"));
+      ULongLong value = 0;
+      switch (width_arg.type) {
+      case Arg::INT:
+        if (width_arg.int_value < 0)
+          FMT_THROW(FormatError("negative width"));
+        value = width_arg.int_value;
+        break;
+      case Arg::UINT:
+        value = width_arg.uint_value;
+        break;
+      case Arg::LONG_LONG:
+        if (width_arg.long_long_value < 0)
+          FMT_THROW(FormatError("negative width"));
+        value = width_arg.long_long_value;
+        break;
+      case Arg::ULONG_LONG:
+        value = width_arg.ulong_long_value;
+        break;
+      default:
+        FMT_THROW(FormatError("width is not integer"));
       }
-      // Zero may be parsed again as a part of the width, but it is simpler
-      // and more efficient than checking if the next char is a digit.
-      spec.width_ = parse_nonnegative_int(s, error);
-      if (error)
-        report_error_(s, error);
+      if (value > INT_MAX)
+        FMT_THROW(FormatError("number is too big"));
+      spec.width_ = static_cast<int>(value);
     }
 
     // Parse precision.
@@ -1163 +1213 @@
       ++s;
       spec.precision_ = 0;
       if ('0' <= *s && *s <= '9') {
-        spec.precision_ = parse_nonnegative_int(s, error);
-        if (error)
-          report_error_(s, error);
+        spec.precision_ = parse_nonnegative_int(s);
       } else if (*s == '{') {
         ++s;
-        ++report_error_.num_open_braces;
-        const Arg &precision_arg = parse_arg_index(s);
+        Arg precision_arg =
+            is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
+        if (*s++ != '}')
+          FMT_THROW(FormatError("invalid format string"));
         ULongLong value = 0;
         switch (precision_arg.type) {
           case Arg::INT:
             if (precision_arg.int_value < 0)
-              report_error_(s, "negative precision in format");
+              FMT_THROW(FormatError("negative precision"));
             value = precision_arg.int_value;
             break;
           case Arg::UINT:
@@ -1182 +1232 @@
             break;
           case Arg::LONG_LONG:
             if (precision_arg.long_long_value < 0)
-              report_error_(s, "negative precision in format");
+              FMT_THROW(FormatError("negative precision"));
             value = precision_arg.long_long_value;
             break;
           case Arg::ULONG_LONG:
             value = precision_arg.ulong_long_value;
             break;
           default:
-            report_error_(s, "precision is not integer");
+            FMT_THROW(FormatError("precision is not integer"));
         }
         if (value > INT_MAX)
-          report_error_(s, "number is too big in format");
+          FMT_THROW(FormatError("number is too big"));
         spec.precision_ = static_cast<int>(value);
-        if (*s++ != '}')
-          throw FormatError("unmatched '{' in format");
-        --report_error_.num_open_braces;
       } else {
-        report_error_(s, "missing precision in format");
+        FMT_THROW(FormatError("missing precision specifier"));
       }
-      if (arg.type != Arg::DOUBLE && arg.type != Arg::LONG_DOUBLE) {
-        report_error_(s,
-            "precision specifier requires floating-point argument");
+      if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
+        FMT_THROW(FormatError(
+            fmt::format("precision not allowed in {} format specifier",
+            arg.type == Arg::POINTER ? "pointer" : "integer")));
       }
     }
 
@@ -1212 +1260 @@
   }
 
   if (*s++ != '}')
-    throw FormatError("unmatched '{' in format");
-  start_ = s;
+    FMT_THROW(FormatError("missing '}' in format string"));
 
   // Format argument.
   internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg);
@@ -1221 +1268 @@
 }
 
 template <typename Char>
-void fmt::BasicFormatter<Char>::format(
-    BasicStringRef<Char> format_str, const ArgList &args) {
-  const Char *s = start_ = format_str.c_str();
-  args_ = args;
-  next_arg_index_ = 0;
+void fmt::BasicFormatter<Char>::format(BasicCStringRef<Char> format_str) {
+  const Char *s = format_str.c_str();
+  const Char *start = s;
   while (*s) {
     Char c = *s++;
     if (c != '{' && c != '}') continue;
     if (*s == c) {
-      write(writer_, start_, s);
-      start_ = ++s;
+      write(writer_, start, s);
+      start = ++s;
       continue;
     }
     if (c == '}')
-      throw FormatError("unmatched '}' in format");
-    report_error_.num_open_braces = 1;
-    write(writer_, start_, s - 1);
-    Arg arg = parse_arg_index(s);
-    s = format(s, arg);
+      FMT_THROW(FormatError("unmatched '}' in format string"));
+    write(writer_, start, s - 1);
+    Arg arg = is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
+    start = s = format(s, arg);
   }
-  write(writer_, start_, s);
+  write(writer_, start, s);
 }
 
-void fmt::report_system_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) {
-  // FIXME: format_system_error may throw
-  report_error(internal::format_system_error, error_code, message);
+FMT_FUNC void fmt::report_system_error(
+    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
+  // 'fmt::' is for bcc32.
+  fmt::report_error(internal::format_system_error, error_code, message);
 }
 
-#ifdef _WIN32
-void fmt::report_windows_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) {
-  // FIXME: format_windows_error may throw
-  report_error(internal::format_windows_error, error_code, message);
+#if FMT_USE_WINDOWS_H
+FMT_FUNC void fmt::report_windows_error(
+    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
+  // 'fmt::' is for bcc32.
+  fmt::report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-void fmt::print(std::FILE *f, StringRef format_str, const ArgList &args) {
-  Writer w;
+FMT_FUNC void fmt::print(std::FILE *f, CStringRef format_str, ArgList args) {
+  MemoryWriter w;
   w.write(format_str, args);
   std::fwrite(w.data(), 1, w.size(), f);
 }
 
-void fmt::print(std::ostream &os, StringRef format_str, const ArgList &args) {
-  Writer w;
+FMT_FUNC void fmt::print(CStringRef format_str, ArgList args) {
+  print(stdout, format_str, args);
+}
+
+FMT_FUNC void fmt::print(std::ostream &os, CStringRef format_str, ArgList args) {
+  MemoryWriter w;
   w.write(format_str, args);
   os.write(w.data(), w.size());
 }
 
-void fmt::print_colored(Color c, StringRef format, const ArgList &args) {
+FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
   char escape[] = "\x1b[30m";
-  escape[3] = '0' + static_cast<char>(c);
+  escape[3] = static_cast<char>('0' + c);
   std::fputs(escape, stdout);
   print(format, args);
   std::fputs(RESET_COLOR, stdout);
 }
 
-int fmt::fprintf(std::FILE *f, StringRef format, const ArgList &args) {
-  Writer w;
+FMT_FUNC int fmt::fprintf(std::FILE *f, CStringRef format, ArgList args) {
+  MemoryWriter w;
   printf(w, format, args);
-  return std::fwrite(w.data(), 1, w.size(), f);
+  std::size_t size = w.size();
+  return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
 }
 
+#ifndef FMT_HEADER_ONLY
+
+template struct fmt::internal::BasicData<void>;
+
 // Explicit instantiations for char.
 
-template fmt::BasicWriter<char>::CharPtr
-  fmt::BasicWriter<char>::fill_padding(CharPtr buffer,
-    unsigned total_size, std::size_t content_size, wchar_t fill);
+template void fmt::internal::FixedBuffer<char>::grow(std::size_t);
+
+template const char *fmt::BasicFormatter<char>::format(
+    const char *&format_str, const fmt::internal::Arg &arg);
 
-template void fmt::BasicFormatter<char>::format(
-  BasicStringRef<char> format, const ArgList &args);
+template void fmt::BasicFormatter<char>::format(CStringRef format);
 
 template void fmt::internal::PrintfFormatter<char>::format(
-  BasicWriter<char> &writer, BasicStringRef<char> format, const ArgList &args);
+  BasicWriter<char> &writer, CStringRef format);
+
+template int fmt::internal::CharTraits<char>::format_float(
+    char *buffer, std::size_t size, const char *format,
+    unsigned width, int precision, double value);
+
+template int fmt::internal::CharTraits<char>::format_float(
+    char *buffer, std::size_t size, const char *format,
+    unsigned width, int precision, long double value);
 
 // Explicit instantiations for wchar_t.
 
-template fmt::BasicWriter<wchar_t>::CharPtr
-  fmt::BasicWriter<wchar_t>::fill_padding(CharPtr buffer,
-    unsigned total_size, std::size_t content_size, wchar_t fill);
+template void fmt::internal::FixedBuffer<wchar_t>::grow(std::size_t);
+
+template const wchar_t *fmt::BasicFormatter<wchar_t>::format(
+    const wchar_t *&format_str, const fmt::internal::Arg &arg);
 
 template void fmt::BasicFormatter<wchar_t>::format(
-    BasicStringRef<wchar_t> format, const ArgList &args);
+    BasicCStringRef<wchar_t> format);
 
 template void fmt::internal::PrintfFormatter<wchar_t>::format(
-    BasicWriter<wchar_t> &writer, BasicStringRef<wchar_t> format,
-    const ArgList &args);
+    BasicWriter<wchar_t> &writer, WCStringRef format);
+
+template int fmt::internal::CharTraits<wchar_t>::format_float(
+    wchar_t *buffer, std::size_t size, const wchar_t *format,
+    unsigned width, int precision, double value);
+
+template int fmt::internal::CharTraits<wchar_t>::format_float(
+    wchar_t *buffer, std::size_t size, const wchar_t *format,
+    unsigned width, int precision, long double value);
+
+#endif  // FMT_HEADER_ONLY
 
 #ifdef _MSC_VER
 # pragma warning(pop)

source/third_party/cppformat/format.h

@@ -1 +1 @@
 /*
- * Slightly modified version of cppformat, by Wildfire Games, for 0 A.D.
- * Based on cppformat v0.11.0 from https://github.com/cppformat/cppformat
- */
-
-/*
  Formatting library for C++
 
- Copyright (c) 2012 - 2014, Victor Zverovich
+ Copyright (c) 2012 - 2015, Victor Zverovich
  All rights reserved.
 
  Redistribution and use in source and binary forms, with or without
@@ -33 +28 @@
 #ifndef FMT_FORMAT_H_
 #define FMT_FORMAT_H_
 
+#if defined _MSC_VER && _MSC_VER <= 1500
+typedef unsigned int       uint32_t;
+typedef unsigned long long uint64_t;
+typedef long long          intmax_t;
+#else
 #include <stdint.h>
+#endif
 
 #include <cassert>
-#include <cstddef>  // for std::ptrdiff_t
+#include <cmath>
 #include <cstdio>
 #include <algorithm>
 #include <limits>
 #include <stdexcept>
 #include <string>
-#include <sstream>
+#include <map>
+
+#ifndef FMT_USE_IOSTREAMS
+# define FMT_USE_IOSTREAMS 1
+#endif
+
+#if FMT_USE_IOSTREAMS
+# include <ostream>
+#endif
+
+#ifdef _SECURE_SCL
+# define FMT_SECURE_SCL _SECURE_SCL
+#else
+# define FMT_SECURE_SCL 0
+#endif
 
-#if defined(_SECURE_SCL) && _SECURE_SCL
+#if FMT_SECURE_SCL
 # include <iterator>
 #endif
 
+#ifdef _MSC_VER
+# include <intrin.h>  // _BitScanReverse, _BitScanReverse64
+
+namespace fmt {
+namespace internal {
+# pragma intrinsic(_BitScanReverse)
+inline uint32_t clz(uint32_t x) {
+  unsigned long r = 0;
+  _BitScanReverse(&r, x);
+  return 31 - r;
+}
+# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
+
+# ifdef _WIN64
+#  pragma intrinsic(_BitScanReverse64)
+# endif
+
+inline uint32_t clzll(uint64_t x) {
+  unsigned long r = 0;
+# ifdef _WIN64
+  _BitScanReverse64(&r, x);
+# else
+  // Scan the high 32 bits.
+  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
+    return 63 - (r + 32);
+
+  // Scan the low 32 bits.
+  _BitScanReverse(&r, static_cast<uint32_t>(x));
+# endif
+  return 63 - r;
+}
+# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
+}
+}
+#endif
+
 #ifdef __GNUC__
 # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
 # define FMT_GCC_EXTENSION __extension__
-// Disable warning about "long long" which is sometimes reported even
-// when using __extension__.
 # if FMT_GCC_VERSION >= 406
 #  pragma GCC diagnostic push
+// Disable the warning about "long long" which is sometimes reported even
+// when using __extension__.
 #  pragma GCC diagnostic ignored "-Wlong-long"
+// Disable the warning about declaration shadowing because it affects too
+// many valid cases.
+#  pragma GCC diagnostic ignored "-Wshadow"
+// Disable the warning about implicit conversions that may change the sign of
+// an integer; silencing it otherwise would require many explicit casts.
+#  pragma GCC diagnostic ignored "-Wsign-conversion"
+# endif
+# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
+#  define FMT_HAS_GXX_CXX11 1
 # endif
 #else
 # define FMT_GCC_EXTENSION
 #endif
 
+#if defined(__clang__) && !defined(__INTEL_COMPILER)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wdocumentation"
+#endif
+
 #ifdef __GNUC_LIBSTD__
 # define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
 #endif
@@ -77 +142 @@
 # define FMT_HAS_BUILTIN(x) 0
 #endif
 
+#ifdef __has_cpp_attribute
+# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+# define FMT_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+
 #ifndef FMT_USE_VARIADIC_TEMPLATES
 // Variadic templates are available in GCC since version 4.4
 // (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++
 // since version 2013.
 # define FMT_USE_VARIADIC_TEMPLATES \
    (FMT_HAS_FEATURE(cxx_variadic_templates) || \
-       (FMT_GCC_VERSION >= 404 && __cplusplus >= 201103) || (defined(_MSC_VER) && _MSC_VER >= 1800))
+       (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800)
 #endif
 
 #ifndef FMT_USE_RVALUE_REFERENCES
@@ -94 +165 @@
 # else
 #  define FMT_USE_RVALUE_REFERENCES \
     (FMT_HAS_FEATURE(cxx_rvalue_references) || \
-        (FMT_GCC_VERSION >= 403 && __cplusplus >= 201103) || (defined(_MSC_VER) && _MSC_VER >= 1600))
+        (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600)
 # endif
 #endif
 
@@ -103 +174 @@
 #endif
 
 // Define FMT_USE_NOEXCEPT to make C++ Format use noexcept (C++11 feature).
-#if (defined(FMT_USE_NOEXCEPT) && FMT_USE_NOEXCEPT) || FMT_HAS_FEATURE(cxx_noexcept) || \
-  (FMT_GCC_VERSION >= 408 && __cplusplus >= 201103)
-# define FMT_NOEXCEPT(expr) noexcept(expr)
-#else
-# define FMT_NOEXCEPT(expr)
+#ifndef FMT_USE_NOEXCEPT
+# define FMT_USE_NOEXCEPT 0
+#endif
+
+#ifndef FMT_NOEXCEPT
+# if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
+   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
+   _MSC_VER >= 1900
+#  define FMT_NOEXCEPT noexcept
+# else
+#  define FMT_NOEXCEPT throw()
+# endif
 #endif
 
 // A macro to disallow the copy constructor and operator= functions
 // This should be used in the private: declarations for a class
-#define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
-  TypeName(const TypeName&); \
-  void operator=(const TypeName&)
+#ifndef FMT_USE_DELETED_FUNCTIONS
+# define FMT_USE_DELETED_FUNCTIONS 0
+#endif
+
+#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \
+  (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1800
+# define FMT_DELETED_OR_UNDEFINED  = delete
+# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+    TypeName(const TypeName&) = delete; \
+    TypeName& operator=(const TypeName&) = delete
+#else
+# define FMT_DELETED_OR_UNDEFINED
+# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+    TypeName(const TypeName&); \
+    TypeName& operator=(const TypeName&)
+#endif
+
+#ifndef FMT_USE_USER_DEFINED_LITERALS
+// All compilers which support UDLs also support variadic templates. This
+// makes the fmt::literals implementation easier. However, an explicit check
+// for variadic templates is added here just in case.
+# define FMT_USE_USER_DEFINED_LITERALS \
+   FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
+   (FMT_HAS_FEATURE(cxx_user_literals) || \
+       (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1900)
+#endif
+
+#ifndef FMT_ASSERT
+# define FMT_ASSERT(condition, message) assert((condition) && message)
+#endif
+
+namespace fmt {
+namespace internal {
+struct DummyInt {
+  int data[2];
+  operator int() const { return 0; }
+};
+typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;
+
+// Dummy implementations of system functions such as signbit and ecvt called
+// if the latter are not available.
+inline DummyInt signbit(...) { return DummyInt(); }
+inline DummyInt _ecvt_s(...) { return DummyInt(); }
+inline DummyInt isinf(...) { return DummyInt(); }
+inline DummyInt _finite(...) { return DummyInt(); }
+inline DummyInt isnan(...) { return DummyInt(); }
+inline DummyInt _isnan(...) { return DummyInt(); }
+
+// A helper function to suppress bogus "conditional expression is constant"
+// warnings.
+template <typename T>
+inline T check(T value) { return value; }
+}
+}  // namespace fmt
+
+namespace std {
+// Standard permits specialization of std::numeric_limits. This specialization
+// is used to resolve ambiguity between isinf and std::isinf in glibc:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891
+// and the same for isnan and signbit.
+template <>
+class numeric_limits<fmt::internal::DummyInt> :
+    public std::numeric_limits<int> {
+ public:
+  // Portable version of isinf.
+  template <typename T>
+  static bool isinfinity(T x) {
+    using namespace fmt::internal;
+    // The resolution "priority" is:
+    // isinf macro > std::isinf > ::isinf > fmt::internal::isinf
+    if (check(sizeof(isinf(x)) == sizeof(bool) ||
+              sizeof(isinf(x)) == sizeof(int))) {
+      return !!isinf(x);
+    }
+    return !_finite(static_cast<double>(x));
+  }
+
+  // Portable version of isnan.
+  template <typename T>
+  static bool isnotanumber(T x) {
+    using namespace fmt::internal;
+    if (check(sizeof(isnan(x)) == sizeof(bool) ||
+              sizeof(isnan(x)) == sizeof(int))) {
+      return !!isnan(x);
+    }
+    return _isnan(static_cast<double>(x)) != 0;
+  }
+
+  // Portable version of signbit.
+  static bool isnegative(double x) {
+    using namespace fmt::internal;
+    if (check(sizeof(signbit(x)) == sizeof(int)))
+      return !!signbit(x);
+    if (x < 0) return true;
+    if (!isnotanumber(x)) return false;
+    int dec = 0, sign = 0;
+    char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
+    _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
+    return sign != 0;
+  }
+};
+}  // namespace std
 
 namespace fmt {
 
@@ -137 +314 @@
 class BasicFormatter;
 
 template <typename Char, typename T>
-void format(BasicFormatter<Char> &f, const Char *format_str, const T &value);
+void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value);
 
 /**
   \rst
-  A string reference. It can be constructed from a C string or
-  ``std::string``.
-  
+  A string reference. It can be constructed from a C string or ``std::string``.
+
   You can use one of the following typedefs for common character types:
 
   +------------+-------------------------+
@@ -157 +333 @@
   This class is most useful as a parameter type to allow passing
   different types of strings to a function, for example::
 
-    template<typename... Args>
-    std::string format(StringRef format, const Args & ... args);
+    template <typename... Args>
+    std::string format(StringRef format_str, const Args & ... args);
 
     format("{}", 42);
     format(std::string("{}"), 42);
@@ -168 +344 @@
 class BasicStringRef {
  private:
   const Char *data_;
-  mutable std::size_t size_;
+  std::size_t size_;
 
  public:
+  /** Constructs a string reference object from a C string and a size. */
+  BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
+
   /**
-    Constructs a string reference object from a C string and a size.
-    If *size* is zero, which is the default, the size is computed
-    automatically.
+    \rst
+    Constructs a string reference object from a C string computing
+    the size with ``std::char_traits<Char>::length``.
+    \endrst
    */
-  BasicStringRef(const Char *s, std::size_t size = 0) : data_(s), size_(size) {}
+  BasicStringRef(const Char *s)
+    : data_(s), size_(std::char_traits<Char>::length(s)) {}
 
   /**
-    Constructs a string reference from an `std::string` object.
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
    */
   BasicStringRef(const std::basic_string<Char> &s)
   : data_(s.c_str()), size_(s.size()) {}
 
   /**
-    Converts a string reference to an `std::string` object.
+    \rst
+    Converts a string reference to an ``std::string`` object.
+    \endrst
    */
-  operator std::basic_string<Char>() const {
-    return std::basic_string<Char>(data_, size());
+  std::basic_string<Char> to_string() const {
+    return std::basic_string<Char>(data_, size_);
   }
 
-  /**
-    Returns the pointer to a C string.
-   */
-  const Char *c_str() const { return data_; }
+  /** Returns the pointer to a C string. */
+  const Char *data() const { return data_; }
 
-  /**
-    Returns the string size.
-   */
-  std::size_t size() const {
-    if (size_ == 0 && data_) size_ = std::char_traits<Char>::length(data_);
-    return size_;
+  /** Returns the string size. */
+  std::size_t size() const { return size_; }
+
+  // Lexicographically compare this string reference to other.
+  int compare(BasicStringRef other) const {
+    std::size_t size = std::min(size_, other.size_);
+    int result = std::char_traits<Char>::compare(data_, other.data_, size);
+    if (result == 0)
+      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+    return result;
   }
 
   friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.data_ == rhs.data_;
+    return lhs.compare(rhs) == 0;
   }
   friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.data_ != rhs.data_;
+    return lhs.compare(rhs) != 0;
+  }
+  friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
+    return lhs.compare(rhs) < 0;
+  }
+  friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) {
+    return lhs.compare(rhs) <= 0;
+  }
+  friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) {
+    return lhs.compare(rhs) > 0;
+  }
+  friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) {
+    return lhs.compare(rhs) >= 0;
   }
 };
 
@@ -216 +415 @@
 typedef BasicStringRef<wchar_t> WStringRef;
 
 /**
+  \rst
+  A reference to a null terminated string. It can be constructed from a C
+  string or ``std::string``.
+
+  You can use one of the following typedefs for common character types:
+
+  +-------------+--------------------------+
+  | Type        | Definition               |
+  +=============+==========================+
+  | CStringRef  | BasicCStringRef<char>    |
+  +-------------+--------------------------+
+  | WCStringRef | BasicCStringRef<wchar_t> |
+  +-------------+--------------------------+
+
+  This class is most useful as a parameter type to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(CStringRef format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
+template <typename Char>
+class BasicCStringRef {
+ private:
+  const Char *data_;
+
+ public:
+  /** Constructs a string reference object from a C string. */
+  BasicCStringRef(const Char *s) : data_(s) {}
+
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
+  BasicCStringRef(const std::basic_string<Char> &s) : data_(s.c_str()) {}
+
+  /** Returns the pointer to a C string. */
+  const Char *c_str() const { return data_; }
+};
+
+typedef BasicCStringRef<char> CStringRef;
+typedef BasicCStringRef<wchar_t> WCStringRef;
+
+/**
   A formatting error such as invalid format string.
 */
 class FormatError : public std::runtime_error {
-public:
-  explicit FormatError(const std::string &message)
-  : std::runtime_error(message) {}
+ public:
+  explicit FormatError(CStringRef message)
+  : std::runtime_error(message.c_str()) {}
 };
 
 namespace internal {
-
-// The number of characters to store in the Array object, representing the
-// output buffer, itself to avoid dynamic memory allocation.
+// The number of characters to store in the MemoryBuffer object itself
+// to avoid dynamic memory allocation.
 enum { INLINE_BUFFER_SIZE = 500 };
 
-#if defined(_SECURE_SCL) && _SECURE_SCL
+#if FMT_SECURE_SCL
 // Use checked iterator to avoid warnings on MSVC.
 template <typename T>
 inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size) {
@@ -240 +486 @@
 template <typename T>
 inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
 #endif
+}  // namespace internal
 
-// A simple array for POD types with the first SIZE elements stored in
-// the object itself. It supports a subset of std::vector's operations.
-template <typename T, std::size_t SIZE>
-class Array {
+/**
+  \rst
+  A buffer supporting a subset of ``std::vector``'s operations.
+  \endrst
+ */
+template <typename T>
+class Buffer {
  private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
+
+ protected:
+  T *ptr_;
   std::size_t size_;
   std::size_t capacity_;
-  T *ptr_;
-  T data_[SIZE];
-
-  void grow(std::size_t size);
-
-  // Free memory allocated by the array.
-  void free() {
-    if (ptr_ != data_) delete [] ptr_;
-  }
 
-  // Move data from other to this array.
-  void move(Array &other) {
-    size_ = other.size_;
-    capacity_ = other.capacity_;
-    if (other.ptr_ == other.data_) {
-      ptr_ = data_;
-      std::copy(other.data_, other.data_ + size_, make_ptr(data_, capacity_));
-    } else {
-      ptr_ = other.ptr_;
-      // Set pointer to the inline array so that delete is not called
-      // when freeing.
-      other.ptr_ = other.data_;
-    }
-  }
+  Buffer(T *ptr = 0, std::size_t capacity = 0)
+    : ptr_(ptr), size_(0), capacity_(capacity) {}
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(Array);
+  /**
+    \rst
+    Increases the buffer capacity to hold at least *size* elements updating
+    ``ptr_`` and ``capacity_``.
+    \endrst
+   */
+  virtual void grow(std::size_t size) = 0;
 
  public:
-  explicit Array(std::size_t size = 0)
-    : size_(size), capacity_(SIZE), ptr_(data_) {}
-  ~Array() { free(); }
+  virtual ~Buffer() {}
 
-#if FMT_USE_RVALUE_REFERENCES
-  Array(Array &&other) {
-    move(other);
-  }
-
-  Array& operator=(Array &&other) {
-    assert(this != &other);
-    free();
-    move(other);
-    return *this;
-  }
-#endif
-
-  // Returns the size of this array.
+  /** Returns the size of this buffer. */
   std::size_t size() const { return size_; }
 
-  // Returns the capacity of this array.
+  /** Returns the capacity of this buffer. */
   std::size_t capacity() const { return capacity_; }
 
-  // Resizes the array. If T is a POD type new elements are not initialized.
+  /**
+    Resizes the buffer. If T is a POD type new elements may not be initialized.
+   */
   void resize(std::size_t new_size) {
     if (new_size > capacity_)
       grow(new_size);
     size_ = new_size;
   }
 
-  // Reserves space to store at least capacity elements.
+  /**
+    \rst
+    Reserves space to store at least *capacity* elements.
+    \endrst
+   */
   void reserve(std::size_t capacity) {
     if (capacity > capacity_)
       grow(capacity);
   }
 
-  void clear() { size_ = 0; }
+  void clear() FMT_NOEXCEPT { size_ = 0; }
 
   void push_back(const T &value) {
     if (size_ == capacity_)
@@ -320 +550 @@
     ptr_[size_++] = value;
   }
 
-  // Appends data to the end of the array.
-  void append(const T *begin, const T *end);
+  /** Appends data to the end of the buffer. */
+  template <typename U>
+  void append(const U *begin, const U *end);
 
   T &operator[](std::size_t index) { return ptr_[index]; }
   const T &operator[](std::size_t index) const { return ptr_[index]; }
 };
 
-template <typename T, std::size_t SIZE>
-void Array<T, SIZE>::grow(std::size_t size) {
-  capacity_ = (std::max)(size, capacity_ + capacity_ / 2);
-  T *p = new T[capacity_];
-  std::copy(ptr_, ptr_ + size_, make_ptr(p, capacity_));
-  if (ptr_ != data_)
-    delete [] ptr_;
-  ptr_ = p;
+template <typename T>
+template <typename U>
+void Buffer<T>::append(const U *begin, const U *end) {
+  assert(begin <= end);
+  std::size_t new_size = size_ + (end - begin);
+  if (new_size > capacity_)
+    grow(new_size);
+  std::copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_);
+  size_ = new_size;
 }
 
-template <typename T, std::size_t SIZE>
-void Array<T, SIZE>::append(const T *begin, const T *end) {
-  std::ptrdiff_t num_elements = end - begin;
-  if (size_ + num_elements > capacity_)
-    grow(size_ + num_elements);
-  std::copy(begin, end, make_ptr(ptr_, capacity_) + size_);
-  size_ += num_elements;
+namespace internal {
+
+// A memory buffer for POD types with the first SIZE elements stored in
+// the object itself.
+template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
+class MemoryBuffer : private Allocator, public Buffer<T> {
+ private:
+  T data_[SIZE];
+
+  // Deallocate memory allocated by the buffer.
+  void deallocate() {
+    if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
+  }
+
+ protected:
+  void grow(std::size_t size);
+
+ public:
+  explicit MemoryBuffer(const Allocator &alloc = Allocator())
+      : Allocator(alloc), Buffer<T>(data_, SIZE) {}
+  ~MemoryBuffer() { deallocate(); }
+
+#if FMT_USE_RVALUE_REFERENCES
+ private:
+  // Move data from other to this buffer.
+  void move(MemoryBuffer &other) {
+    Allocator &this_alloc = *this, &other_alloc = other;
+    this_alloc = std::move(other_alloc);
+    this->size_ = other.size_;
+    this->capacity_ = other.capacity_;
+    if (other.ptr_ == other.data_) {
+      this->ptr_ = data_;
+      std::copy(other.data_,
+                other.data_ + this->size_, make_ptr(data_, this->capacity_));
+    } else {
+      this->ptr_ = other.ptr_;
+      // Set pointer to the inline array so that delete is not called
+      // when deallocating.
+      other.ptr_ = other.data_;
+    }
+  }
+
+ public:
+  MemoryBuffer(MemoryBuffer &&other) {
+    move(other);
+  }
+
+  MemoryBuffer &operator=(MemoryBuffer &&other) {
+    assert(this != &other);
+    deallocate();
+    move(other);
+    return *this;
+  }
+#endif
+
+  // Returns a copy of the allocator associated with this buffer.
+  Allocator get_allocator() const { return *this; }
+};
+
+template <typename T, std::size_t SIZE, typename Allocator>
+void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
+  std::size_t new_capacity =
+      (std::max)(size, this->capacity_ + this->capacity_ / 2);
+  T *new_ptr = this->allocate(new_capacity);
+  // The following code doesn't throw, so the raw pointer above doesn't leak.
+  std::copy(this->ptr_,
+            this->ptr_ + this->size_, make_ptr(new_ptr, new_capacity));
+  std::size_t old_capacity = this->capacity_;
+  T *old_ptr = this->ptr_;
+  this->capacity_ = new_capacity;
+  this->ptr_ = new_ptr;
+  // deallocate may throw (at least in principle), but it doesn't matter since
+  // the buffer already uses the new storage and will deallocate it in case
+  // of exception.
+  if (old_ptr != data_)
+    Allocator::deallocate(old_ptr, old_capacity);
 }
 
+// A fixed-size buffer.
+template <typename Char>
+class FixedBuffer : public fmt::Buffer<Char> {
+ public:
+  FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
+
+ protected:
+  void grow(std::size_t size);
+};
+
 template <typename Char>
 class BasicCharTraits {
  public:
-#if defined(_SECURE_SCL) && _SECURE_SCL
+#if FMT_SECURE_SCL
   typedef stdext::checked_array_iterator<Char*> CharPtr;
 #else
   typedef Char *CharPtr;
 #endif
+  static Char cast(wchar_t value) { return static_cast<Char>(value); }
 };
 
 template <typename Char>
@@ -365 +677 @@
   // Conversion from wchar_t to char is not allowed.
   static char convert(wchar_t);
 
-public:
-  typedef const wchar_t *UnsupportedStrType;
-
+ public:
   static char convert(char value) { return value; }
 
   // Formats a floating-point number.
@@ -379 +689 @@
 template <>
 class CharTraits<wchar_t> : public BasicCharTraits<wchar_t> {
  public:
-  typedef const char *UnsupportedStrType;
-
   static wchar_t convert(char value) { return value; }
   static wchar_t convert(wchar_t value) { return value; }
 
@@ -389 +697 @@
       const wchar_t *format, unsigned width, int precision, T value);
 };
 
-// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
-template <bool FitsIn32Bits>
-struct TypeSelector { typedef uint32_t Type; };
-
-template <>
-struct TypeSelector<false> { typedef uint64_t Type; };
-
 // Checks if a number is negative - used to avoid warnings.
 template <bool IsSigned>
 struct SignChecker {
   template <typename T>
-  static bool is_negative(T) { return false; }
+  static bool is_negative(T value) { return value < 0; }
 };
 
 template <>
-struct SignChecker<true> {
+struct SignChecker<false> {
   template <typename T>
-  static bool is_negative(T value) { return value < 0; }
+  static bool is_negative(T) { return false; }
 };
 
 // Returns true if value is negative, false otherwise.
@@ -416 +717 @@
   return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
 }
 
+// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
+template <bool FitsIn32Bits>
+struct TypeSelector { typedef uint32_t Type; };
+
+template <>
+struct TypeSelector<false> { typedef uint64_t Type; };
+
 template <typename T>
 struct IntTraits {
   // Smallest of uint32_t and uint64_t that is large enough to represent
@@ -441 +749 @@
 
 void report_unknown_type(char code, const char *type);
 
-extern const uint32_t POWERS_OF_10_32[];
-extern const uint64_t POWERS_OF_10_64[];
+// Static data is placed in this class template to allow header-only
+// configuration.
+template <typename T = void>
+struct BasicData {
+  static const uint32_t POWERS_OF_10_32[];
+  static const uint64_t POWERS_OF_10_64[];
+  static const char DIGITS[];
+};
+
+typedef BasicData<> Data;
+
+#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
+# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
+#endif
 
 #if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
+# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
+#endif
+
+#ifdef FMT_BUILTIN_CLZLL
 // Returns the number of decimal digits in n. Leading zeros are not counted
 // except for n == 0 in which case count_digits returns 1.
 inline unsigned count_digits(uint64_t n) {
   // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
   // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
-  unsigned t = (64 - __builtin_clzll(n | 1)) * 1233 >> 12;
-  return t - (n < POWERS_OF_10_64[t]) + 1;
+  unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
+  return t - (n < Data::POWERS_OF_10_64[t]) + 1;
 }
-# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
-// Optional version of count_digits for better performance on 32-bit platforms.
-inline unsigned count_digits(uint32_t n) {
-  uint32_t t = (32 - __builtin_clz(n | 1)) * 1233 >> 12;
-  return t - (n < POWERS_OF_10_32[t]) + 1;
-}
-# endif
 #else
-// Slower version of count_digits used when __builtin_clz is not available.
+// Fallback version of count_digits used when __builtin_clz is not available.
 inline unsigned count_digits(uint64_t n) {
   unsigned count = 1;
   for (;;) {
@@ -478 +795 @@
 }
 #endif
 
-extern const char DIGITS[];
+#ifdef FMT_BUILTIN_CLZ
+// Optional version of count_digits for better performance on 32-bit platforms.
+inline unsigned count_digits(uint32_t n) {
+  uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
+  return t - (n < Data::POWERS_OF_10_32[t]) + 1;
+}
+#endif
 
 // Formats a decimal unsigned integer value writing into buffer.
 template <typename UInt, typename Char>
 inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
-  --num_digits;
+  buffer += num_digits;
   while (value >= 100) {
     // Integer division is slow so do it for a group of two digits instead
     // of for every digit. The idea comes from the talk by Alexandrescu
     // "Three Optimization Tips for C++". See speed-test for a comparison.
-    unsigned index = (value % 100) * 2;
+    unsigned index = static_cast<unsigned>((value % 100) * 2);
     value /= 100;
-    buffer[num_digits] = DIGITS[index + 1];
-    buffer[num_digits - 1] = DIGITS[index];
-    num_digits -= 2;
+    *--buffer = Data::DIGITS[index + 1];
+    *--buffer = Data::DIGITS[index];
   }
   if (value < 10) {
-    *buffer = static_cast<char>('0' + value);
+    *--buffer = static_cast<char>('0' + value);
     return;
   }
   unsigned index = static_cast<unsigned>(value * 2);
-  buffer[1] = DIGITS[index + 1];
-  buffer[0] = DIGITS[index];
+  *--buffer = Data::DIGITS[index + 1];
+  *--buffer = Data::DIGITS[index];
 }
 
-#ifdef _WIN32
+#ifndef _WIN32
+# define FMT_USE_WINDOWS_H 0
+#elif !defined(FMT_USE_WINDOWS_H)
+# define FMT_USE_WINDOWS_H 1
+#endif
+
+// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
+// All the functionality that relies on it will be disabled too.
+#if FMT_USE_WINDOWS_H
 // A converter from UTF-8 to UTF-16.
-// It is only provided for Windows since other systems use UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
 class UTF8ToUTF16 {
  private:
-  Array<wchar_t, INLINE_BUFFER_SIZE> buffer_;
+  MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
 
  public:
   explicit UTF8ToUTF16(StringRef s);
@@ -519 +849 @@
 };
 
 // A converter from UTF-16 to UTF-8.
-// It is only provided for Windows since other systems use UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
 class UTF16ToUTF8 {
  private:
-  Array<char, INLINE_BUFFER_SIZE> buffer_;
+  MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
 
  public:
   UTF16ToUTF8() {}
@@ -533 +863 @@
   std::string str() const { return std::string(&buffer_[0], size()); }
 
   // Performs conversion returning a system error code instead of
-  // throwing exception on error.
+  // throwing exception on conversion error. This method may still throw
+  // in case of memory allocation error.
   int convert(WStringRef s);
 };
-#endif
 
-// Portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-//   0      - success
-//   ERANGE - buffer is not large enough to store the error message
-//   other  - failure
-// Buffer should be at least of size 1.
-int safe_strerror(int error_code,
-    char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT(true);
-
-void format_system_error(
-    fmt::Writer &out, int error_code, fmt::StringRef message);
-
-#ifdef _WIN32
-void format_windows_error(
-    fmt::Writer &out, int error_code, fmt::StringRef message);
+void format_windows_error(fmt::Writer &out, int error_code,
+                          fmt::StringRef message) FMT_NOEXCEPT;
 #endif
 
-// Throws Exception(message) if format contains '}', otherwise throws
-// FormatError reporting unmatched '{'. The idea is that unmatched '{'
-// should override other errors.
-template <typename Char>
-struct FormatErrorReporter {
-  int num_open_braces;
-  void operator()(const Char *s, fmt::StringRef message) const;
-};
-
-// Computes max(Arg, 1) at compile time. It is used to avoid errors about
-// allocating an array of 0 size.
-template <unsigned Arg>
-struct NonZero {
-  enum { VALUE = Arg };
-};
-
-template <>
-struct NonZero<0> {
-  enum { VALUE = 1 };
-};
-
-// A formatting argument. It is a POD type to allow storage in internal::Array.
-struct Arg {
-  enum Type {
-    // Integer types should go first,
-    INT, UINT, LONG_LONG, ULONG_LONG, CHAR, LAST_INTEGER_TYPE = CHAR,
-    // followed by floating-point types.
-    DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
-    STRING, WSTRING, POINTER, CUSTOM
-  };
-  Type type;
+void format_system_error(fmt::Writer &out, int error_code,
+                         fmt::StringRef message) FMT_NOEXCEPT;
 
+// A formatting argument value.
+struct Value {
   template <typename Char>
   struct StringValue {
     const Char *value;
@@ -597 +884 @@
   };
 
   typedef void (*FormatFunc)(
-      void *formatter, const void *arg, const void *format_str);
+      void *formatter, const void *arg, void *format_str_ptr);
 
   struct CustomValue {
     const void *value;
@@ -611 +898 @@
     ULongLong ulong_long_value;
     double double_value;
     long double long_double_value;
-    const void *pointer_value;
+    const void *pointer;
     StringValue<char> string;
+    StringValue<signed char> sstring;
+    StringValue<unsigned char> ustring;
     StringValue<wchar_t> wstring;
     CustomValue custom;
   };
+
+  enum Type {
+    NONE, NAMED_ARG,
+    // Integer types should go first,
+    INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
+    // followed by floating-point types.
+    DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
+    CSTRING, STRING, WSTRING, POINTER, CUSTOM
+  };
+};
+
+// A formatting argument. It is a POD type to allow storage in
+// internal::MemoryBuffer.
+struct Arg : Value {
+  Type type;
+};
+
+template <typename Char>
+struct NamedArg;
+
+template <typename T = void>
+struct Null {};
+
+// A helper class template to enable or disable overloads taking wide
+// characters and strings in MakeValue.
+template <typename T, typename Char>
+struct WCharHelper {
+  typedef Null<T> Supported;
+  typedef T Unsupported;
+};
+
+template <typename T>
+struct WCharHelper<T, wchar_t> {
+  typedef T Supported;
+  typedef Null<T> Unsupported;
+};
+
+typedef char Yes[1];
+typedef char No[2];
+
+// These are non-members to workaround an overload resolution bug in bcc32.
+Yes &convert(fmt::ULongLong);
+Yes &convert(std::ostream &);
+No &convert(...);
+
+template <typename T>
+T &get();
+
+struct DummyStream : std::ostream {
+  // Hide all operator<< overloads from std::ostream.
+  void operator<<(Null<>);
+};
+
+No &operator<<(std::ostream &, int);
+
+template<typename T, bool ENABLE_CONVERSION>
+struct ConvertToIntImpl {
+  enum { value = false };
+};
+
+template<typename T>
+struct ConvertToIntImpl<T, true> {
+  // Convert to int only if T doesn't have an overloaded operator<<.
+  enum {
+    value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
+  };
+};
+
+template<typename T, bool ENABLE_CONVERSION>
+struct ConvertToIntImpl2 {
+  enum { value = false };
+};
+
+template<typename T>
+struct ConvertToIntImpl2<T, true> {
+  enum {
+    // Don't convert numeric types.
+    value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
+  };
+};
+
+template<typename T>
+struct ConvertToInt {
+  enum { enable_conversion = sizeof(convert(get<T>())) == sizeof(Yes) };
+  enum { value = ConvertToIntImpl2<T, enable_conversion>::value };
 };
 
+#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
+  template <> \
+  struct ConvertToInt<Type> {  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<bool B, class T = void>
+struct EnableIf {};
+
+template<class T>
+struct EnableIf<true, T> { typedef T type; };
+
+template<bool B, class T, class F>
+struct Conditional { typedef T type; };
+
+template<class T, class F>
+struct Conditional<false, T, F> { typedef F type; };
+
+// For bcc32 which doesn't understand ! in template arguments.
+template<bool>
+struct Not { enum { value = 0 }; };
+
+template<>
+struct Not<false> { enum { value = 1 }; };
+
 // Makes an Arg object from any type.
 template <typename Char>
-class MakeArg : public Arg {
+class MakeValue : public Arg {
  private:
   // The following two methods are private to disallow formatting of
   // arbitrary pointers. If you want to output a pointer cast it to
@@ -628 +1030 @@
   // of "[const] volatile char *" which is printed as bool by iostreams.
   // Do not implement!
   template <typename T>
-  MakeArg(const T *value);
+  MakeValue(const T *value);
   template <typename T>
-  MakeArg(T *value);
+  MakeValue(T *value);
+
+  // The following methods are private to disallow formatting of wide
+  // characters and strings into narrow strings as in
+  //   fmt::format("{}", L"test");
+  // To fix this, use a wide format string: fmt::format(L"{}", L"test").
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+  MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
+#endif
+  MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
+  MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
+  MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
+  MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
 
   void set_string(StringRef str) {
-    type = STRING;
-    string.value = str.c_str();
+    string.value = str.data();
     string.size = str.size();
   }
 
   void set_string(WStringRef str) {
-    type = WSTRING;
-    CharTraits<Char>::convert(wchar_t());
-    wstring.value = str.c_str();
+    wstring.value = str.data();
     wstring.size = str.size();
   }
 
   // Formats an argument of a custom type, such as a user-defined class.
   template <typename T>
   static void format_custom_arg(
-      void *formatter, const void *arg, const void *format_str) {
+      void *formatter, const void *arg, void *format_str_ptr) {
     format(*static_cast<BasicFormatter<Char>*>(formatter),
-        static_cast<const Char*>(format_str), *static_cast<const T*>(arg));
+           *static_cast<const Char**>(format_str_ptr),
+           *static_cast<const T*>(arg));
   }
 
-public:
-  MakeArg() {}
-  MakeArg(bool value) { type = INT; int_value = value; }
-  MakeArg(short value) { type = INT; int_value = value; }
-  MakeArg(unsigned short value) { type = UINT; uint_value = value; }
-  MakeArg(int value) { type = INT; int_value = value; }
-  MakeArg(unsigned value) { type = UINT; uint_value = value; }
-  MakeArg(long value) {
+ public:
+  MakeValue() {}
+
+#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
+  MakeValue(Type value) { field = rhs; } \
+  static uint64_t type(Type) { return Arg::TYPE; }
+
+#define FMT_MAKE_VALUE(Type, field, TYPE) \
+  FMT_MAKE_VALUE_(Type, field, TYPE, value)
+
+  FMT_MAKE_VALUE(bool, int_value, BOOL)
+  FMT_MAKE_VALUE(short, int_value, INT)
+  FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
+  FMT_MAKE_VALUE(int, int_value, INT)
+  FMT_MAKE_VALUE(unsigned, uint_value, UINT)
+
+  MakeValue(long value) {
     // To minimize the number of types we need to deal with, long is
     // translated either to int or to long long depending on its size.
-    if (sizeof(long) == sizeof(int)) {
-      type = INT;
+    if (check(sizeof(long) == sizeof(int)))
       int_value = static_cast<int>(value);
-    } else {
-      type = LONG_LONG;
+    else
       long_long_value = value;
-    }
   }
-  MakeArg(unsigned long value) {
-    if (sizeof(unsigned long) == sizeof(unsigned)) {
-      type = UINT;
+  static uint64_t type(long) {
+    return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
+  }
+
+  MakeValue(unsigned long value) {
+    if (check(sizeof(unsigned long) == sizeof(unsigned)))
       uint_value = static_cast<unsigned>(value);
-    } else {
-      type = ULONG_LONG;
+    else
       ulong_long_value = value;
-    }
   }
-  MakeArg(LongLong value) { type = LONG_LONG; long_long_value = value; }
-  MakeArg(ULongLong value) { type = ULONG_LONG; ulong_long_value = value; }
-  MakeArg(float value) { type = DOUBLE; double_value = value; }
-  MakeArg(double value) { type = DOUBLE; double_value = value; }
-  MakeArg(long double value) { type = LONG_DOUBLE; long_double_value = value; }
-  MakeArg(signed char value) { type = CHAR; int_value = value; }
-  MakeArg(unsigned char value) { type = CHAR; int_value = value; }
-  MakeArg(char value) { type = CHAR; int_value = value; }
-  MakeArg(wchar_t value) {
-    type = CHAR;
-    int_value = internal::CharTraits<Char>::convert(value);
-  }
-
-  MakeArg(char *value) { set_string(value); }
-  MakeArg(const char *value) { set_string(value); }
-  MakeArg(const std::string &value) { set_string(value); }
-  MakeArg(StringRef value) { set_string(value); }
-
-  MakeArg(wchar_t *value) { set_string(value); }
-  MakeArg(const wchar_t *value) { set_string(value); }
-  MakeArg(const std::wstring &value) { set_string(value); }
-  MakeArg(WStringRef value) { set_string(value); }
-
-  MakeArg(void *value) { type = POINTER; pointer_value = value; }
-  MakeArg(const void *value) { type = POINTER; pointer_value = value; }
-
-#if 0
-  // WFG: Removed this because otherwise you can pass a CStr8 or an enum etc
-  // into fmt::sprintf, and it will be interpreted as a CUSTOM type and then
-  // will throw an exception at runtime, which is terrible behaviour.
+  static uint64_t type(unsigned long) {
+    return sizeof(unsigned long) == sizeof(unsigned) ?
+          Arg::UINT : Arg::ULONG_LONG;
+  }
+
+  FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
+  FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
+  FMT_MAKE_VALUE(float, double_value, DOUBLE)
+  FMT_MAKE_VALUE(double, double_value, DOUBLE)
+  FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
+  FMT_MAKE_VALUE(signed char, int_value, INT)
+  FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
+  FMT_MAKE_VALUE(char, int_value, CHAR)
+
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+  MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
+    int_value = value;
+  }
+  static uint64_t type(wchar_t) { return Arg::CHAR; }
+#endif
+
+#define FMT_MAKE_STR_VALUE(Type, TYPE) \
+  MakeValue(Type value) { set_string(value); } \
+  static uint64_t type(Type) { return Arg::TYPE; }
+
+  FMT_MAKE_VALUE(char *, string.value, CSTRING)
+  FMT_MAKE_VALUE(const char *, string.value, CSTRING)
+  FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
+  FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
+  FMT_MAKE_STR_VALUE(const std::string &, STRING)
+  FMT_MAKE_STR_VALUE(StringRef, STRING)
+  FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
+
+#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
+  MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
+    set_string(value); \
+  } \
+  static uint64_t type(Type) { return Arg::TYPE; }
+
+  FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
+  FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
+  FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
+  FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
+
+  FMT_MAKE_VALUE(void *, pointer, POINTER)
+  FMT_MAKE_VALUE(const void *, pointer, POINTER)
+
   template <typename T>
-  MakeArg(const T &value) {
-    type = CUSTOM;
+  MakeValue(const T &value,
+            typename EnableIf<Not<
+              ConvertToInt<T>::value>::value, int>::type = 0) {
     custom.value = &value;
     custom.format = &format_custom_arg<T>;
   }
-#endif
+
+  template <typename T>
+  MakeValue(const T &value,
+            typename EnableIf<ConvertToInt<T>::value, int>::type = 0) {
+    int_value = value;
+  }
+
+  template <typename T>
+  static uint64_t type(const T &) {
+    return ConvertToInt<T>::value ? Arg::INT : Arg::CUSTOM;
+  }
+
+  // Additional template param `Char_` is needed here because make_type always
+  // uses MakeValue<char>.
+  template <typename Char_>
+  MakeValue(const NamedArg<Char_> &value) { pointer = &value; }
+
+  template <typename Char_>
+  static uint64_t type(const NamedArg<Char_> &) { return Arg::NAMED_ARG; }
+};
+
+template <typename Char>
+struct NamedArg : Arg {
+  BasicStringRef<Char> name;
+
+  template <typename T>
+  NamedArg(BasicStringRef<Char> argname, const T &value)
+  : Arg(MakeValue<Char>(value)), name(argname) {
+    type = static_cast<internal::Arg::Type>(MakeValue<Char>::type(value));
+  }
 };
 
 #define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
@@ -744 +1210 @@
 template <typename Impl, typename Result>
 class ArgVisitor {
  public:
-  Result visit_unhandled_arg() { return Result(); }
+  void report_unhandled_arg() {}
+
+  Result visit_unhandled_arg() {
+    FMT_DISPATCH(report_unhandled_arg());
+    return Result();
+  }
 
   Result visit_int(int value) {
     return FMT_DISPATCH(visit_any_int(value));
@@ -758 +1229 @@
   Result visit_ulong_long(ULongLong value) {
     return FMT_DISPATCH(visit_any_int(value));
   }
+  Result visit_bool(bool value) {
+    return FMT_DISPATCH(visit_any_int(value));
+  }
   Result visit_char(int value) {
     return FMT_DISPATCH(visit_any_int(value));
   }
@@ -777 +1251 @@
     return FMT_DISPATCH(visit_unhandled_arg());
   }
 
+  Result visit_cstring(const char *) {
+    return FMT_DISPATCH(visit_unhandled_arg());
+  }
   Result visit_string(Arg::StringValue<char>) {
     return FMT_DISPATCH(visit_unhandled_arg());
   }
@@ -793 +1270 @@
   Result visit(const Arg &arg) {
     switch (arg.type) {
     default:
-      assert(false);
-      // Fall through.
+      FMT_ASSERT(false, "invalid argument type");
+      return Result();
     case Arg::INT:
       return FMT_DISPATCH(visit_int(arg.int_value));
     case Arg::UINT:
@@ -803 +1280 @@
       return FMT_DISPATCH(visit_long_long(arg.long_long_value));
     case Arg::ULONG_LONG:
       return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
+    case Arg::BOOL:
+      return FMT_DISPATCH(visit_bool(arg.int_value != 0));
+    case Arg::CHAR:
+      return FMT_DISPATCH(visit_char(arg.int_value));
     case Arg::DOUBLE:
       return FMT_DISPATCH(visit_double(arg.double_value));
     case Arg::LONG_DOUBLE:
       return FMT_DISPATCH(visit_long_double(arg.long_double_value));
-    case Arg::CHAR:
-      return FMT_DISPATCH(visit_char(arg.int_value));
+    case Arg::CSTRING:
+      return FMT_DISPATCH(visit_cstring(arg.string.value));
     case Arg::STRING:
       return FMT_DISPATCH(visit_string(arg.string));
     case Arg::WSTRING:
       return FMT_DISPATCH(visit_wstring(arg.wstring));
     case Arg::POINTER:
-      return FMT_DISPATCH(visit_pointer(arg.pointer_value));
+      return FMT_DISPATCH(visit_pointer(arg.pointer));
     case Arg::CUSTOM:
       return FMT_DISPATCH(visit_custom(arg.custom));
     }
@@ -826 +1307 @@
   RuntimeError() : std::runtime_error("") {}
 };
 
+template <typename Impl, typename Char>
+class BasicArgFormatter;
+
 template <typename Char>
-class ArgFormatter;
+class PrintfArgFormatter;
+
+template <typename Char>
+class ArgMap;
 }  // namespace internal
 
-/**
-  An argument list.
- */
+/** An argument list. */
 class ArgList {
  private:
-  const internal::Arg *args_;
-  std::size_t size_;
+  // To reduce compiled code size per formatting function call, types of first
+  // MAX_PACKED_ARGS arguments are passed in the types_ field.
+  uint64_t types_;
+  union {
+    // If the number of arguments is less than MAX_PACKED_ARGS, the argument
+    // values are stored in values_, otherwise they are stored in args_.
+    // This is done to reduce compiled code size as storing larger objects
+    // may require more code (at least on x86-64) even if the same amount of
+    // data is actually copied to stack. It saves ~10% on the bloat test.
+    const internal::Value *values_;
+    const internal::Arg *args_;
+  };
 
- public:
-  ArgList() : size_(0) {}
-  ArgList(const internal::Arg *args, std::size_t size)
-  : args_(args), size_(size) {}
+  internal::Arg::Type type(unsigned index) const {
+    unsigned shift = index * 4;
+    uint64_t mask = 0xf;
+    return static_cast<internal::Arg::Type>(
+          (types_ & (mask << shift)) >> shift);
+  }
 
-  /**
-    Returns the list size (the number of arguments).
-   */
-  std::size_t size() const { return size_; }
+  template <typename Char>
+  friend class internal::ArgMap;
 
-  /**
-    Returns the argument at specified index.
-   */
-  const internal::Arg &operator[](std::size_t index) const {
+ public:
+  // Maximum number of arguments with packed types.
+  enum { MAX_PACKED_ARGS = 16 };
+
+  ArgList() : types_(0) {}
+
+  ArgList(ULongLong types, const internal::Value *values)
+  : types_(types), values_(values) {}
+  ArgList(ULongLong types, const internal::Arg *args)
+  : types_(types), args_(args) {}
+
+  /** Returns the argument at specified index. */
+  internal::Arg operator[](unsigned index) const {
+    using internal::Arg;
+    Arg arg;
+    bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
+    if (index < MAX_PACKED_ARGS) {
+      Arg::Type arg_type = type(index);
+      internal::Value &val = arg;
+      if (arg_type != Arg::NONE)
+        val = use_values ? values_[index] : args_[index];
+      arg.type = arg_type;
+      return arg;
+    }
+    if (use_values) {
+      // The index is greater than the number of arguments that can be stored
+      // in values, so return a "none" argument.
+      arg.type = Arg::NONE;
+      return arg;
+    }
+    for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) {
+      if (args_[i].type == Arg::NONE)
+        return args_[i];
+    }
     return args_[index];
   }
 };
@@ -860 +1385 @@
 
 namespace internal {
 
+template <typename Char>
+class ArgMap {
+ private:
+  typedef std::map<fmt::BasicStringRef<Char>, internal::Arg> MapType;
+  typedef typename MapType::value_type Pair;
+
+  MapType map_;
+
+ public:
+  void init(const ArgList &args);
+
+  const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const {
+    typename MapType::const_iterator it = map_.find(name);
+    return it != map_.end() ? &it->second : 0;
+  }
+};
+
 class FormatterBase {
-protected:
+ private:
   ArgList args_;
   int next_arg_index_;
-  const char *error_;
 
-  FormatterBase() : error_(0) {}
+  // Returns the argument with specified index.
+  Arg do_get_arg(unsigned arg_index, const char *&error);
 
-  const Arg &next_arg();
+ protected:
+  const ArgList &args() const { return args_; }
+
+  explicit FormatterBase(const ArgList &args) {
+    args_ = args;
+    next_arg_index_ = 0;
+  }
 
-  const Arg &handle_arg_index(unsigned arg_index);
+  // Returns the next argument.
+  Arg next_arg(const char *&error);
+
+  // Checks if manual indexing is used and returns the argument with
+  // specified index.
+  Arg get_arg(unsigned arg_index, const char *&error);
+
+  bool check_no_auto_index(const char *&error);
 
   template <typename Char>
   void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
     if (start != end)
       w << BasicStringRef<Char>(start, end - start);
   }
-
-  // TODO
 };
 
 // A printf formatter.
@@ -887 +1440 @@
  private:
   void parse_flags(FormatSpec &spec, const Char *&s);
 
-  // Parses argument index, flags and width and returns the parsed
-  // argument index.
+  // Returns the argument with specified index or, if arg_index is equal
+  // to the maximum unsigned value, the next argument.
+  Arg get_arg(const Char *s,
+      unsigned arg_index = (std::numeric_limits<unsigned>::max)());
+
+  // Parses argument index, flags and width and returns the argument index.
   unsigned parse_header(const Char *&s, FormatSpec &spec);
 
  public:
-  void format(BasicWriter<Char> &writer,
-    BasicStringRef<Char> format, const ArgList &args);
+  explicit PrintfFormatter(const ArgList &args) : FormatterBase(args) {}
+  void format(BasicWriter<Char> &writer, BasicCStringRef<Char> format_str);
 };
 }  // namespace internal
 
 // A formatter.
 template <typename Char>
 class BasicFormatter : private internal::FormatterBase {
-private:
+ private:
   BasicWriter<Char> &writer_;
-  const Char *start_;
-  internal::FormatErrorReporter<Char> report_error_;
+  internal::ArgMap<Char> map_;
+
+  FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
+
+  using internal::FormatterBase::get_arg;
+
+  // Checks if manual indexing is used and returns the argument with
+  // specified name.
+  internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
 
-  // Parses argument index and returns an argument with this index.
-  const internal::Arg &parse_arg_index(const Char *&s);
+  // Parses argument index and returns corresponding argument.
+  internal::Arg parse_arg_index(const Char *&s);
 
-  void check_sign(const Char *&s, const internal::Arg &arg);
+  // Parses argument name and returns corresponding argument.
+  internal::Arg parse_arg_name(const Char *&s);
 
-public:
-  explicit BasicFormatter(BasicWriter<Char> &w) : writer_(w) {}
+ public:
+  BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
+    : internal::FormatterBase(args), writer_(w) {}
 
   BasicWriter<Char> &writer() { return writer_; }
 
-  void format(BasicStringRef<Char> format_str, const ArgList &args);
+  void format(BasicCStringRef<Char> format_str);
 
-  const Char *format(const Char *format_str, const internal::Arg &arg);
+  const Char *format(const Char *&format_str, const internal::Arg &arg);
 };
 
 enum Alignment {
@@ -1000 +1566 @@
   T value_;
 
  public:
-  IntFormatSpec(T value, const SpecT &spec = SpecT())
-  : SpecT(spec), value_(value) {}
+  IntFormatSpec(T val, const SpecT &spec = SpecT())
+  : SpecT(spec), value_(val) {}
 
   T value() const { return value_; }
 };
 
 // A string format specifier.
-template <typename T>
+template <typename Char>
 class StrFormatSpec : public AlignSpec {
  private:
-  const T *str_;
+  const Char *str_;
 
  public:
-  StrFormatSpec(const T *str, unsigned width, wchar_t fill)
-  : AlignSpec(width, fill), str_(str) {}
+  template <typename FillChar>
+  StrFormatSpec(const Char *str, unsigned width, FillChar fill)
+  : AlignSpec(width, fill), str_(str) {
+    internal::CharTraits<Char>::convert(FillChar());
+  }
 
-  const T *str() const { return str_; }
+  const Char *str() const { return str_; }
 };
 
 /**
@@ -1049 +1618 @@
 
   **Example**::
 
-    Writer out;
+    MemoryWriter out;
     out << pad(hex(0xcafe), 8, '0');
     // out.str() == "0000cafe"
 
@@ -1122 +1691 @@
 
   **Example**::
 
-    std::string s = str(Writer() << pad("abc", 8));
+    std::string s = str(MemoryWriter() << pad("abc", 8));
     // s == "abc     "
 
   \endrst
@@ -1138 +1707 @@
   return StrFormatSpec<wchar_t>(str, width, fill);
 }
 
-// Generates a comma-separated list with results of applying f to numbers 0..n-1.
+// Generates a comma-separated list with results of applying f to
+// numbers 0..n-1.
 # define FMT_GEN(n, f) FMT_GEN##n(f)
 # define FMT_GEN1(f)  f(0)
-# define FMT_GEN2(f)  FMT_GEN1(f), f(1)
-# define FMT_GEN3(f)  FMT_GEN2(f), f(2)
-# define FMT_GEN4(f)  FMT_GEN3(f), f(3)
-# define FMT_GEN5(f)  FMT_GEN4(f), f(4)
-# define FMT_GEN6(f)  FMT_GEN5(f), f(5)
-# define FMT_GEN7(f)  FMT_GEN6(f), f(6)
-# define FMT_GEN8(f)  FMT_GEN7(f), f(7)
-# define FMT_GEN9(f)  FMT_GEN8(f), f(8)
-# define FMT_GEN10(f) FMT_GEN9(f), f(9)
+# define FMT_GEN2(f)  FMT_GEN1(f),  f(1)
+# define FMT_GEN3(f)  FMT_GEN2(f),  f(2)
+# define FMT_GEN4(f)  FMT_GEN3(f),  f(3)
+# define FMT_GEN5(f)  FMT_GEN4(f),  f(4)
+# define FMT_GEN6(f)  FMT_GEN5(f),  f(5)
+# define FMT_GEN7(f)  FMT_GEN6(f),  f(6)
+# define FMT_GEN8(f)  FMT_GEN7(f),  f(7)
+# define FMT_GEN9(f)  FMT_GEN8(f),  f(8)
+# define FMT_GEN10(f) FMT_GEN9(f),  f(9)
+# define FMT_GEN11(f) FMT_GEN10(f), f(10)
+# define FMT_GEN12(f) FMT_GEN11(f), f(11)
+# define FMT_GEN13(f) FMT_GEN12(f), f(12)
+# define FMT_GEN14(f) FMT_GEN13(f), f(13)
+# define FMT_GEN15(f) FMT_GEN14(f), f(14)
+
+namespace internal {
+inline uint64_t make_type() { return 0; }
+
+template <typename T>
+inline uint64_t make_type(const T &arg) { return MakeValue<char>::type(arg); }
+
+template <unsigned N>
+struct ArgArray {
+  // Computes the argument array size by adding 1 to N, which is the number of
+  // arguments, if N is zero, because array of zero size is invalid, or if N
+  // is greater than ArgList::MAX_PACKED_ARGS to accommodate for an extra
+  // argument that marks the end of the list.
+  enum { SIZE = N + (N == 0 || N >= ArgList::MAX_PACKED_ARGS ? 1 : 0) };
+
+  typedef typename Conditional<
+    (N < ArgList::MAX_PACKED_ARGS), Value, Arg>::type Type[SIZE];
+};
+
+#if FMT_USE_VARIADIC_TEMPLATES
+template <typename Arg, typename... Args>
+inline uint64_t make_type(const Arg &first, const Args & ... tail) {
+  return make_type(first) | (make_type(tail...) << 4);
+}
+
+inline void do_set_types(Arg *) {}
+
+template <typename T, typename... Args>
+inline void do_set_types(Arg *args, const T &arg, const Args & ... tail) {
+  args->type = static_cast<Arg::Type>(MakeValue<T>::type(arg));
+  do_set_types(args + 1, tail...);
+}
+
+template <typename... Args>
+inline void set_types(Arg *array, const Args & ... args) {
+  if (check(sizeof...(Args) > ArgList::MAX_PACKED_ARGS))
+    do_set_types(array, args...);
+  array[sizeof...(Args)].type = Arg::NONE;
+}
+
+template <typename... Args>
+inline void set_types(Value *, const Args & ...) {
+  // Do nothing as types are passed separately from values.
+}
+
+template <typename Char, typename Value>
+inline void store_args(Value *) {}
+
+template <typename Char, typename Arg, typename T, typename... Args>
+inline void store_args(Arg *args, const T &arg, const Args & ... tail) {
+  // Assign only the Value subobject of Arg and don't overwrite type (if any)
+  // that is assigned by set_types.
+  Value &value = *args;
+  value = MakeValue<Char>(arg);
+  store_args<Char>(args + 1, tail...);
+}
+
+template <typename Char, typename... Args>
+ArgList make_arg_list(typename ArgArray<sizeof...(Args)>::Type array,
+                      const Args & ... args) {
+  if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS))
+    set_types(array, args...);
+  store_args<Char>(array, args...);
+  return ArgList(make_type(args...), array);
+}
+#else
+
+struct ArgType {
+  uint64_t type;
+
+  ArgType() : type(0) {}
+
+  template <typename T>
+  ArgType(const T &arg) : type(make_type(arg)) {}
+};
+
+# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
+
+inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
+  return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
+      (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
+      (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
+      (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
+}
+#endif
+
+template <class Char>
+class FormatBuf : public std::basic_streambuf<Char> {
+ private:
+  typedef typename std::basic_streambuf<Char>::int_type int_type;
+  typedef typename std::basic_streambuf<Char>::traits_type traits_type;
+
+  Buffer<Char> &buffer_;
+  Char *start_;
+
+ public:
+  FormatBuf(Buffer<Char> &buffer) : buffer_(buffer), start_(&buffer[0]) {
+    this->setp(start_, start_ + buffer_.capacity());
+  }
+
+  int_type overflow(int_type ch = traits_type::eof()) {
+    if (!traits_type::eq_int_type(ch, traits_type::eof())) {
+      size_t size = this->pptr() - start_;
+      buffer_.resize(size);
+      buffer_.reserve(size * 2);
+
+      start_ = &buffer_[0];
+      start_[size] = traits_type::to_char_type(ch);
+      this->setp(start_+ size + 1, start_ + size * 2);
+    }
+    return ch;
+  }
+
+  size_t size() const {
+    return this->pptr() - start_;
+  }
+};
+}  // namespace internal
 
 # define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
+# define FMT_MAKE_ARG_TYPE(n) T##n
 # define FMT_MAKE_ARG(n) const T##n &v##n
-# define FMT_MAKE_REF_char(n) fmt::internal::MakeArg<char>(v##n)
-# define FMT_MAKE_REF_wchar_t(n) fmt::internal::MakeArg<wchar_t>(v##n)
+# define FMT_ASSIGN_char(n) arr[n] = fmt::internal::MakeValue<char>(v##n)
+# define FMT_ASSIGN_wchar_t(n) arr[n] = fmt::internal::MakeValue<wchar_t>(v##n)
 
 #if FMT_USE_VARIADIC_TEMPLATES
 // Defines a variadic function returning void.
 # define FMT_VARIADIC_VOID(func, arg_type) \
-  template<typename... Args> \
-  void func(arg_type arg1, const Args & ... args) { \
-    using fmt::internal::Arg; \
-    const Arg arg_array[fmt::internal::NonZero<sizeof...(Args)>::VALUE] = { \
-      fmt::internal::MakeArg<Char>(args)... \
-    }; \
-    func(arg1, ArgList(arg_array, sizeof...(Args))); \
+  template <typename... Args> \
+  void func(arg_type arg0, const Args & ... args) { \
+    typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
+    func(arg0, fmt::internal::make_arg_list<Char>(array, args...)); \
   }
 
 // Defines a variadic constructor.
 # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
-  template<typename... Args> \
+  template <typename... Args> \
   ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
-    using fmt::internal::Arg; \
-    const Arg arg_array[fmt::internal::NonZero<sizeof...(Args)>::VALUE] = { \
-      fmt::internal::MakeArg<Char>(args)... \
-    }; \
-    func(arg0, arg1, ArgList(arg_array, sizeof...(Args))); \
+    typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
+    func(arg0, arg1, fmt::internal::make_arg_list<Char>(array, args...)); \
   }
 
 #else
 
-# define FMT_MAKE_REF(n) fmt::internal::MakeArg<Char>(v##n)
+# define FMT_MAKE_REF(n) fmt::internal::MakeValue<Char>(v##n)
+# define FMT_MAKE_REF2(n) v##n
+
 // Defines a wrapper for a function taking one argument of type arg_type
 // and n additional arguments of arbitrary types.
 # define FMT_WRAP1(func, arg_type, n) \
   template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
   inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
-    const fmt::internal::Arg args[] = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    func(arg1, fmt::ArgList(args, sizeof(args) / sizeof(*args))); \
+    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
+    func(arg1, fmt::ArgList( \
+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
   }
 
 // Emulates a variadic function returning void on a pre-C++11 compiler.
 # define FMT_VARIADIC_VOID(func, arg_type) \
+  inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
   FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
   FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
   FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
@@ -1202 +1894 @@
 # define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
   template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
   ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
-    const fmt::internal::Arg args[] = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    func(arg0, arg1, fmt::ArgList(args, sizeof(args) / sizeof(*args))); \
+    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
+    func(arg0, arg1, fmt::ArgList( \
+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
   }
 
 // Emulates a variadic constructor on a pre-C++11 compiler.
@@ -1243 +1936 @@
   FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)
 
 /**
-An error returned by an operating system or a language runtime,
-for example a file opening error.
+ An error returned by an operating system or a language runtime,
+ for example a file opening error.
 */
 class SystemError : public internal::RuntimeError {
  private:
-  void init(int error_code, StringRef format_str, const ArgList &args);
+  void init(int err_code, CStringRef format_str, ArgList args);
 
  protected:
   int error_code_;
@@ -1260 +1953 @@
  public:
   /**
    \rst
-   Constructs a :cpp:class:`fmt::SystemError` object with the description
-   of the form "*<message>*: *<system-message>*", where *<message>* is the
-   formatted message and *<system-message>* is the system message corresponding
-   to the error code.
+   Constructs a :class:`fmt::SystemError` object with the description
+   of the form
+
+   .. parsed-literal::
+     *<message>*: *<system-message>*
+
+   where *<message>* is the formatted message and *<system-message>* is
+   the system message corresponding to the error code.
    *error_code* is a system error code as given by ``errno``.
+   If *error_code* is not a valid error code such as -1, the system message
+   may look like "Unknown error -1" and is platform-dependent.
+
+   **Example**::
+
+     // This throws a SystemError with the description
+     //   cannot open file 'madeup': No such file or directory
+     // or similar (system message may vary).
+     const char *filename = "madeup";
+     std::FILE *file = std::fopen(filename, "r");
+     if (!file)
+       throw fmt::SystemError(errno, "cannot open file '{}'", filename);
    \endrst
   */
-  SystemError(int error_code, StringRef message) {
+  SystemError(int error_code, CStringRef message) {
     init(error_code, message, ArgList());
   }
-  FMT_VARIADIC_CTOR(SystemError, init, int, StringRef)
+  FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)
 
   int error_code() const { return error_code_; }
 };
@@ -1278 +1987 @@
 /**
   \rst
   This template provides operations for formatting and writing data into
-  a character stream. The output is stored in a memory buffer that grows
-  dynamically.
+  a character stream. The output is stored in a buffer provided by a subclass
+  such as :class:`fmt::BasicMemoryWriter`.
 
   You can use one of the following typedefs for common character types:
 
@@ -1291 +2000 @@
   | WWriter | BasicWriter<wchar_t> |
   +---------+----------------------+
 
-  **Example**::
-
-     Writer out;
-     out << "The answer is " << 42 << "\n";
-     out.write("({:+f}, {:+f})", -3.14, 3.14);
-
-  This will write the following output to the ``out`` object:
-
-  .. code-block:: none
-
-     The answer is 42
-     (-3.140000, +3.140000)
-
-  The output can be converted to an ``std::string`` with ``out.str()`` or
-  accessed as a C string with ``out.c_str()``.
   \endrst
  */
 template <typename Char>
 class BasicWriter {
  private:
   // Output buffer.
-  mutable internal::Array<Char, internal::INLINE_BUFFER_SIZE> buffer_;
+  Buffer<Char> &buffer_;
+
+  FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
 
   typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
 
-#if defined(_SECURE_SCL) && _SECURE_SCL
+#if FMT_SECURE_SCL
   // Returns pointer value.
   static Char *get(CharPtr p) { return p.base(); }
 #else
   static Char *get(Char *p) { return p; }
 #endif
 
+  // Fills the padding around the content and returns the pointer to the
+  // content area.
   static CharPtr fill_padding(CharPtr buffer,
       unsigned total_size, std::size_t content_size, wchar_t fill);
 
@@ -1334 +2032 @@
     return internal::make_ptr(&buffer_[size], n);
   }
 
+  // Writes an unsigned decimal integer.
+  template <typename UInt>
+  Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) {
+    unsigned num_digits = internal::count_digits(value);
+    Char *ptr = get(grow_buffer(prefix_size + num_digits));
+    internal::format_decimal(ptr + prefix_size, value, num_digits);
+    return ptr;
+  }
+
+  // Writes a decimal integer.
+  template <typename Int>
+  void write_decimal(Int value) {
+    typename internal::IntTraits<Int>::MainType abs_value = value;
+    if (internal::is_negative(value)) {
+      abs_value = 0 - abs_value;
+      *write_unsigned_decimal(abs_value, 1) = '-';
+    } else {
+      write_unsigned_decimal(abs_value, 0);
+    }
+  }
+
   // Prepare a buffer for integer formatting.
   CharPtr prepare_int_buffer(unsigned num_digits,
       const EmptySpec &, const char *prefix, unsigned prefix_size) {
@@ -1349 +2068 @@
 
   // Formats an integer.
   template <typename T, typename Spec>
-  void write_int(T value, const Spec &spec);
+  void write_int(T value, Spec spec);
 
   // Formats a floating-point number (double or long double).
   template <typename T>
@@ -1364 +2083 @@
   void write_str(
       const internal::Arg::StringValue<StrChar> &str, const FormatSpec &spec);
 
-  // This method is private to disallow writing a wide string to a
-  // char stream and vice versa. If you want to print a wide string
-  // as a pointer as std::ostream does, cast it to const void*.
+  // This following methods are private to disallow writing wide characters
+  // and strings to a char stream. If you want to print a wide string as a
+  // pointer as std::ostream does, cast it to const void*.
   // Do not implement!
-  void operator<<(typename internal::CharTraits<Char>::UnsupportedStrType);
+  void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
+  void operator<<(
+      typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
 
-  friend class internal::ArgFormatter<Char>;
-  friend class internal::PrintfFormatter<Char>;
+  // Appends floating-point length specifier to the format string.
+  // The second argument is only used for overload resolution.
+  void append_float_length(Char *&format_ptr, long double) {
+    *format_ptr++ = 'L';
+  }
 
- public:
-  /**
-    Constructs a ``BasicWriter`` object.
-   */
-  BasicWriter() {}
+  template<typename T>
+  void append_float_length(Char *&, T) {}
 
-#if FMT_USE_RVALUE_REFERENCES
+  template <typename Impl, typename Char_>
+  friend class internal::BasicArgFormatter;
+
+  friend class internal::PrintfArgFormatter<Char>;
+
+ protected:
   /**
-    Constructs a ``BasicWriter`` object moving the content of the other
-    object to it.
+    Constructs a ``BasicWriter`` object.
    */
-  BasicWriter(BasicWriter &&other) : buffer_(std::move(other.buffer_)) {}
+  explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
 
+ public:
   /**
-    Moves the content of the other ``BasicWriter`` object to this one.
+    \rst
+    Destroys a ``BasicWriter`` object.
+    \endrst
    */
-  BasicWriter& operator=(BasicWriter &&other) {
-    assert(this != &other);
-    buffer_ = std::move(other.buffer_);
-    return *this;
-  }
-#endif
+  virtual ~BasicWriter() {}
 
   /**
     Returns the total number of characters written.
@@ -1405 +2128 @@
     Returns a pointer to the output buffer content. No terminating null
     character is appended.
    */
-  const Char *data() const { return &buffer_[0]; }
+  const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; }
 
   /**
     Returns a pointer to the output buffer content with terminating null
@@ -1419 +2142 @@
   }
 
   /**
+    \rst
     Returns the content of the output buffer as an `std::string`.
+    \endrst
    */
   std::basic_string<Char> str() const {
     return std::basic_string<Char>(&buffer_[0], buffer_.size());
@@ -1428 +2153 @@
   /**
     \rst
     Writes formatted data.
-    
+
     *args* is an argument list representing arbitrary arguments.
 
     **Example**::
 
-       Writer out;
+       MemoryWriter out;
        out.write("Current point:\n");
        out.write("({:+f}, {:+f})", -3.14, 3.14);
 
@@ -1444 +2169 @@
        Current point:
        (-3.140000, +3.140000)
 
-    The output can be accessed using :meth:`data`, :meth:`c_str` or :meth:`str`
-    methods.
+    The output can be accessed using :func:`data()`, :func:`c_str` or
+    :func:`str` methods.
 
-    See also `Format String Syntax`_.
+    See also :ref:`syntax`.
     \endrst
    */
-  void write(BasicStringRef<Char> format, const ArgList &args) {
-    BasicFormatter<Char>(*this).format(format, args);
+  void write(BasicCStringRef<Char> format, ArgList args) {
+    BasicFormatter<Char>(args, *this).format(format);
   }
-  FMT_VARIADIC_VOID(write, fmt::BasicStringRef<Char>)
+  FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
 
   BasicWriter &operator<<(int value) {
-    return *this << IntFormatSpec<int>(value);
+    write_decimal(value);
+    return *this;
   }
   BasicWriter &operator<<(unsigned value) {
     return *this << IntFormatSpec<unsigned>(value);
   }
   BasicWriter &operator<<(long value) {
-    return *this << IntFormatSpec<long>(value);
+    write_decimal(value);
+    return *this;
   }
   BasicWriter &operator<<(unsigned long value) {
     return *this << IntFormatSpec<unsigned long>(value);
   }
   BasicWriter &operator<<(LongLong value) {
-    return *this << IntFormatSpec<LongLong>(value);
+    write_decimal(value);
+    return *this;
   }
 
   /**
+    \rst
     Formats *value* and writes it to the stream.
+    \endrst
    */
   BasicWriter &operator<<(ULongLong value) {
     return *this << IntFormatSpec<ULongLong>(value);
@@ -1484 +2214 @@
   }
 
   /**
+    \rst
     Formats *value* using the general format for floating-point numbers
     (``'g'``) and writes it to the stream.
+    \endrst
    */
   BasicWriter &operator<<(long double value) {
     write_double(value, FormatSpec());
@@ -1500 +2232 @@
     return *this;
   }
 
-  BasicWriter &operator<<(wchar_t value) {
-    buffer_.push_back(internal::CharTraits<Char>::convert(value));
+  BasicWriter &operator<<(
+      typename internal::WCharHelper<wchar_t, Char>::Supported value) {
+    buffer_.push_back(value);
     return *this;
   }
 
   /**
+    \rst
     Writes *value* to the stream.
+    \endrst
    */
   BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
-    const Char *str = value.c_str();
+    const Char *str = value.data();
+    buffer_.append(str, str + value.size());
+    return *this;
+  }
+
+  BasicWriter &operator<<(
+      typename internal::WCharHelper<StringRef, Char>::Supported value) {
+    const char *str = value.data();
     buffer_.append(str, str + value.size());
     return *this;
   }
 
   template <typename T, typename Spec, typename FillChar>
-  BasicWriter &operator<<(const IntFormatSpec<T, Spec, FillChar> &spec) {
+  BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
     internal::CharTraits<Char>::convert(FillChar());
     write_int(spec.value(), spec);
     return *this;
@@ -1524 +2266 @@
   template <typename StrChar>
   BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) {
     const StrChar *s = spec.str();
-    // TODO: error if fill is not convertible to Char
     write_str(s, std::char_traits<Char>::length(s), spec);
     return *this;
   }
 
-  void clear() { buffer_.clear(); }
+  void clear() FMT_NOEXCEPT { buffer_.clear(); }
 };
 
 template <typename Char>
 template <typename StrChar>
 typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
-    const StrChar *s, std::size_t size, const AlignSpec &spec) {
+      const StrChar *s, std::size_t size, const AlignSpec &spec) {
   CharPtr out = CharPtr();
   if (spec.width() > size) {
     out = grow_buffer(spec.width());
-    Char fill = static_cast<Char>(spec.fill());
+    Char fill = internal::CharTraits<Char>::cast(spec.fill());
     if (spec.align() == ALIGN_RIGHT) {
       std::fill_n(out, spec.width() - size, fill);
       out += spec.width() - size;
@@ -1556 +2297 @@
 }
 
 template <typename Char>
+typename BasicWriter<Char>::CharPtr
+  BasicWriter<Char>::fill_padding(
+    CharPtr buffer, unsigned total_size,
+    std::size_t content_size, wchar_t fill) {
+  std::size_t padding = total_size - content_size;
+  std::size_t left_padding = padding / 2;
+  Char fill_char = internal::CharTraits<Char>::cast(fill);
+  std::fill_n(buffer, left_padding, fill_char);
+  buffer += left_padding;
+  CharPtr content = buffer;
+  std::fill_n(buffer + content_size, padding - left_padding, fill_char);
+  return content;
+}
+
+template <typename Char>
 template <typename Spec>
-typename fmt::BasicWriter<Char>::CharPtr
-  fmt::BasicWriter<Char>::prepare_int_buffer(
+typename BasicWriter<Char>::CharPtr
+  BasicWriter<Char>::prepare_int_buffer(
     unsigned num_digits, const Spec &spec,
     const char *prefix, unsigned prefix_size) {
   unsigned width = spec.width();
   Alignment align = spec.align();
-  Char fill = static_cast<Char>(spec.fill());
+  Char fill = internal::CharTraits<Char>::cast(spec.fill());
   if (spec.precision() > static_cast<int>(num_digits)) {
     // Octal prefix '0' is counted as a digit, so ignore it if precision
     // is specified.
@@ -1620 +2376 @@
 
 template <typename Char>
 template <typename T, typename Spec>
-void BasicWriter<Char>::write_int(T value, const Spec &spec) {
+void BasicWriter<Char>::write_int(T value, Spec spec) {
   unsigned prefix_size = 0;
   typedef typename internal::IntTraits<T>::MainType UnsignedType;
   UnsignedType abs_value = value;
@@ -1674 +2430 @@
     Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
     n = abs_value;
     do {
-      *p-- = '0' + (n & 1);
+      *p-- = static_cast<Char>('0' + (n & 1));
     } while ((n >>= 1) != 0);
     break;
   }
@@ -1689 +2445 @@
     Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
     n = abs_value;
     do {
-      *p-- = '0' + (n & 7);
+      *p-- = static_cast<Char>('0' + (n & 7));
     } while ((n >>= 3) != 0);
     break;
   }
@@ -1700 +2456 @@
   }
 }
 
+template <typename Char>
+template <typename T>
+void BasicWriter<Char>::write_double(
+    T value, const FormatSpec &spec) {
+  // Check type.
+  char type = spec.type();
+  bool upper = false;
+  switch (type) {
+  case 0:
+    type = 'g';
+    break;
+  case 'e': case 'f': case 'g': case 'a':
+    break;
+  case 'F':
+#ifdef _MSC_VER
+    // MSVC's printf doesn't support 'F'.
+    type = 'f';
+#endif
+    // Fall through.
+  case 'E': case 'G': case 'A':
+    upper = true;
+    break;
+  default:
+    internal::report_unknown_type(type, "double");
+    break;
+  }
+
+  char sign = 0;
+  // Use isnegative instead of value < 0 because the latter is always
+  // false for NaN.
+  if (internal::FPUtil::isnegative(static_cast<double>(value))) {
+    sign = '-';
+    value = -value;
+  } else if (spec.flag(SIGN_FLAG)) {
+    sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
+  }
+
+  if (internal::FPUtil::isnotanumber(value)) {
+    // Format NaN ourselves because sprintf's output is not consistent
+    // across platforms.
+    std::size_t nan_size = 4;
+    const char *nan = upper ? " NAN" : " nan";
+    if (!sign) {
+      --nan_size;
+      ++nan;
+    }
+    CharPtr out = write_str(nan, nan_size, spec);
+    if (sign)
+      *out = sign;
+    return;
+  }
+
+  if (internal::FPUtil::isinfinity(value)) {
+    // Format infinity ourselves because sprintf's output is not consistent
+    // across platforms.
+    std::size_t inf_size = 4;
+    const char *inf = upper ? " INF" : " inf";
+    if (!sign) {
+      --inf_size;
+      ++inf;
+    }
+    CharPtr out = write_str(inf, inf_size, spec);
+    if (sign)
+      *out = sign;
+    return;
+  }
+
+  std::size_t offset = buffer_.size();
+  unsigned width = spec.width();
+  if (sign) {
+    buffer_.reserve(buffer_.size() + (std::max)(width, 1u));
+    if (width > 0)
+      --width;
+    ++offset;
+  }
+
+  // Build format string.
+  enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
+  Char format[MAX_FORMAT_SIZE];
+  Char *format_ptr = format;
+  *format_ptr++ = '%';
+  unsigned width_for_sprintf = width;
+  if (spec.flag(HASH_FLAG))
+    *format_ptr++ = '#';
+  if (spec.align() == ALIGN_CENTER) {
+    width_for_sprintf = 0;
+  } else {
+    if (spec.align() == ALIGN_LEFT)
+      *format_ptr++ = '-';
+    if (width != 0)
+      *format_ptr++ = '*';
+  }
+  if (spec.precision() >= 0) {
+    *format_ptr++ = '.';
+    *format_ptr++ = '*';
+  }
+
+  append_float_length(format_ptr, value);
+  *format_ptr++ = type;
+  *format_ptr = '\0';
+
+  // Format using snprintf.
+  Char fill = internal::CharTraits<Char>::cast(spec.fill());
+  for (;;) {
+    std::size_t buffer_size = buffer_.capacity() - offset;
+#ifdef _MSC_VER
+    // MSVC's vsnprintf_s doesn't work with zero size, so reserve
+    // space for at least one extra character to make the size non-zero.
+    // Note that the buffer's capacity will increase by more than 1.
+    if (buffer_size == 0) {
+      buffer_.reserve(offset + 1);
+      buffer_size = buffer_.capacity() - offset;
+    }
+#endif
+    Char *start = &buffer_[offset];
+    int n = internal::CharTraits<Char>::format_float(
+        start, buffer_size, format, width_for_sprintf, spec.precision(), value);
+    if (n >= 0 && offset + n < buffer_.capacity()) {
+      if (sign) {
+        if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
+            *start != ' ') {
+          *(start - 1) = sign;
+          sign = 0;
+        } else {
+          *(start - 1) = fill;
+        }
+        ++n;
+      }
+      if (spec.align() == ALIGN_CENTER &&
+          spec.width() > static_cast<unsigned>(n)) {
+        width = spec.width();
+        CharPtr p = grow_buffer(width);
+        std::copy(p, p + n, p + (width - n) / 2);
+        fill_padding(p, spec.width(), n, fill);
+        return;
+      }
+      if (spec.fill() != ' ' || sign) {
+        while (*start == ' ')
+          *start++ = fill;
+        if (sign)
+          *(start - 1) = sign;
+      }
+      grow_buffer(n);
+      return;
+    }
+    // If n is negative we ask to increase the capacity by at least 1,
+    // but as std::vector, the buffer grows exponentially.
+    buffer_.reserve(n >= 0 ? offset + n + 1 : buffer_.capacity() + 1);
+  }
+}
+
+/**
+  \rst
+  This class template provides operations for formatting and writing data
+  into a character stream. The output is stored in a memory buffer that grows
+  dynamically.
+
+  You can use one of the following typedefs for common character types
+  and the standard allocator:
+
+  +---------------+-----------------------------------------------------+
+  | Type          | Definition                                          |
+  +===============+=====================================================+
+  | MemoryWriter  | BasicMemoryWriter<char, std::allocator<char>>       |
+  +---------------+-----------------------------------------------------+
+  | WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
+  +---------------+-----------------------------------------------------+
+
+  **Example**::
+
+     MemoryWriter out;
+     out << "The answer is " << 42 << "\n";
+     out.write("({:+f}, {:+f})", -3.14, 3.14);
+
+  This will write the following output to the ``out`` object:
+
+  .. code-block:: none
+
+     The answer is 42
+     (-3.140000, +3.140000)
+
+  The output can be converted to an ``std::string`` with ``out.str()`` or
+  accessed as a C string with ``out.c_str()``.
+  \endrst
+ */
+template <typename Char, typename Allocator = std::allocator<Char> >
+class BasicMemoryWriter : public BasicWriter<Char> {
+ private:
+  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
+
+ public:
+  explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
+    : BasicWriter<Char>(buffer_), buffer_(alloc) {}
+
+#if FMT_USE_RVALUE_REFERENCES
+  /**
+    \rst
+    Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
+    of the other object to it.
+    \endrst
+   */
+  BasicMemoryWriter(BasicMemoryWriter &&other)
+    : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) {
+  }
+
+  /**
+    \rst
+    Moves the content of the other ``BasicMemoryWriter`` object to this one.
+    \endrst
+   */
+  BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
+    buffer_ = std::move(other.buffer_);
+    return *this;
+  }
+#endif
+};
+
+typedef BasicMemoryWriter<char> MemoryWriter;
+typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
+
+/**
+  \rst
+  This class template provides operations for formatting and writing data
+  into a fixed-size array. For writing into a dynamically growing buffer
+  use :class:`fmt::BasicMemoryWriter`.
+
+  Any write method will throw ``std::runtime_error`` if the output doesn't fit
+  into the array.
+
+  You can use one of the following typedefs for common character types:
+
+  +--------------+---------------------------+
+  | Type         | Definition                |
+  +==============+===========================+
+  | ArrayWriter  | BasicArrayWriter<char>    |
+  +--------------+---------------------------+
+  | WArrayWriter | BasicArrayWriter<wchar_t> |
+  +--------------+---------------------------+
+  \endrst
+ */
+template <typename Char>
+class BasicArrayWriter : public BasicWriter<Char> {
+ private:
+  internal::FixedBuffer<Char> buffer_;
+
+ public:
+  /**
+   \rst
+   Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
+   given size.
+   \endrst
+   */
+  BasicArrayWriter(Char *array, std::size_t size)
+    : BasicWriter<Char>(buffer_), buffer_(array, size) {}
+
+  /**
+   \rst
+   Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
+   size known at compile time.
+   \endrst
+   */
+  template <std::size_t SIZE>
+  explicit BasicArrayWriter(Char (&array)[SIZE])
+    : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
+};
+
+typedef BasicArrayWriter<char> ArrayWriter;
+typedef BasicArrayWriter<wchar_t> WArrayWriter;
+
 // Formats a value.
 template <typename Char, typename T>
-void format(BasicFormatter<Char> &f, const Char *format_str, const T &value) {
-  std::basic_ostringstream<Char> os;
-  os << value;
-  f.format(format_str, internal::MakeArg<Char>(os.str()));
+void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value) {
+  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
+
+  internal::FormatBuf<Char> format_buf(buffer);
+  std::basic_ostream<Char> output(&format_buf);
+  output << value;
+
+  BasicStringRef<Char> str(&buffer[0], format_buf.size());
+  internal::Arg arg = internal::MakeValue<Char>(str);
+  arg.type = static_cast<internal::Arg::Type>(
+        internal::MakeValue<Char>::type(str));
+  format_str = f.format(format_str, arg);
 }
 
 // Reports a system error without throwing an exception.
 // Can be used to report errors from destructors.
-void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT(true);
+void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT;
 
-#ifdef _WIN32
+#if FMT_USE_WINDOWS_H
 
-/**
- A Windows error.
-*/
+/** A Windows error. */
 class WindowsError : public SystemError {
  private:
-  void init(int error_code, StringRef format_str, const ArgList &args);
+  void init(int error_code, CStringRef format_str, ArgList args);
 
  public:
   /**
    \rst
-   Constructs a :cpp:class:`fmt::WindowsError` object with the description
-   of the form "*<message>*: *<system-message>*", where *<message>* is the
-   formatted message and *<system-message>* is the system message corresponding
-   to the error code.
+   Constructs a :class:`fmt::WindowsError` object with the description
+   of the form
+
+   .. parsed-literal::
+     *<message>*: *<system-message>*
+
+   where *<message>* is the formatted message and *<system-message>* is the
+   system message corresponding to the error code.
    *error_code* is a Windows error code as given by ``GetLastError``.
+   If *error_code* is not a valid error code such as -1, the system message
+   will look like "error -1".
+
+   **Example**::
+
+     // This throws a WindowsError with the description
+     //   cannot open file 'madeup': The system cannot find the file specified.
+     // or similar (system message may vary).
+     const char *filename = "madeup";
+     LPOFSTRUCT of = LPOFSTRUCT();
+     HFILE file = OpenFile(filename, &of, OF_READ);
+     if (file == HFILE_ERROR) {
+       throw fmt::WindowsError(GetLastError(),
+                               "cannot open file '{}'", filename);
+     }
    \endrst
   */
-  WindowsError(int error_code, StringRef message) {
+  WindowsError(int error_code, CStringRef message) {
     init(error_code, message, ArgList());
   }
-  FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef)
+  FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
 };
 
 // Reports a Windows error without throwing an exception.
 // Can be used to report errors from destructors.
-void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT(true);
+void report_windows_error(int error_code, StringRef message) FMT_NOEXCEPT;
 
 #endif
 
@@ -1749 +2799 @@
   Formats a string and prints it to stdout using ANSI escape sequences
   to specify color (experimental).
   Example:
-    PrintColored(fmt::RED, "Elapsed time: {0:.2f} seconds") << 1.23;
+    print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
  */
-void print_colored(Color c, StringRef format, const ArgList &args);
+void print_colored(Color c, CStringRef format, ArgList args);
 
 /**
   \rst
@@ -1762 +2812 @@
     std::string message = format("The answer is {}", 42);
   \endrst
 */
-inline std::string format(StringRef format_str, const ArgList &args) {
-  Writer w;
+inline std::string format(CStringRef format_str, ArgList args) {
+  MemoryWriter w;
   w.write(format_str, args);
   return w.str();
 }
 
-inline std::wstring format(WStringRef format_str, const ArgList &args) {
-  WWriter w;
+inline std::wstring format(WCStringRef format_str, ArgList args) {
+  WMemoryWriter w;
   w.write(format_str, args);
   return w.str();
 }
@@ -1783 +2833 @@
     print(stderr, "Don't {}!", "panic");
   \endrst
  */
-void print(std::FILE *f, StringRef format_str, const ArgList &args);
+void print(std::FILE *f, CStringRef format_str, ArgList args);
 
 /**
   \rst
@@ -1794 +2844 @@
     print("Elapsed time: {0:.2f} seconds", 1.23);
   \endrst
  */
-inline void print(StringRef format_str, const ArgList &args) {
-  print(stdout, format_str, args);
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    print(cerr, "Don't {}!", "panic");
-  \endrst
- */
-void print(std::ostream &os, StringRef format_str, const ArgList &args);
+void print(CStringRef format_str, ArgList args);
 
 template <typename Char>
-void printf(BasicWriter<Char> &w,
-    BasicStringRef<Char> format, const ArgList &args) {
-  internal::PrintfFormatter<Char>().format(w, format, args);
+void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args) {
+  internal::PrintfFormatter<Char>(args).format(w, format);
 }
 
 /**
@@ -1824 +2860 @@
     std::string message = fmt::sprintf("The answer is %d", 42);
   \endrst
 */
-inline std::string sprintf(StringRef format, const ArgList &args) {
-  Writer w;
+inline std::string sprintf(CStringRef format, ArgList args) {
+  MemoryWriter w;
+  printf(w, format, args);
+  return w.str();
+}
+
+inline std::wstring sprintf(WCStringRef format, ArgList args) {
+  WMemoryWriter w;
   printf(w, format, args);
   return w.str();
 }
@@ -1839 +2881 @@
     fmt::fprintf(stderr, "Don't %s!", "panic");
   \endrst
  */
-int fprintf(std::FILE *f, StringRef format, const ArgList &args);
+int fprintf(std::FILE *f, CStringRef format, ArgList args);
 
 /**
   \rst
@@ -1850 +2892 @@
     fmt::printf("Elapsed time: %.2f seconds", 1.23);
   \endrst
  */
-inline int printf(StringRef format, const ArgList &args) {
+inline int printf(CStringRef format, ArgList args) {
   return fprintf(stdout, format, args);
 }
 
@@ -1872 +2914 @@
       // Integer division is slow so do it for a group of two digits instead
       // of for every digit. The idea comes from the talk by Alexandrescu
       // "Three Optimization Tips for C++". See speed-test for a comparison.
-      unsigned index = (value % 100) * 2;
+      unsigned index = static_cast<unsigned>((value % 100) * 2);
       value /= 100;
-      *--buffer_end = internal::DIGITS[index + 1];
-      *--buffer_end = internal::DIGITS[index];
+      *--buffer_end = internal::Data::DIGITS[index + 1];
+      *--buffer_end = internal::Data::DIGITS[index];
     }
     if (value < 10) {
       *--buffer_end = static_cast<char>('0' + value);
       return buffer_end;
     }
     unsigned index = static_cast<unsigned>(value * 2);
-    *--buffer_end = internal::DIGITS[index + 1];
-    *--buffer_end = internal::DIGITS[index];
+    *--buffer_end = internal::Data::DIGITS[index + 1];
+    *--buffer_end = internal::Data::DIGITS[index];
     return buffer_end;
   }
 
@@ -1926 +2968 @@
   }
 
   /**
-    Returns the content of the output buffer as an `std::string`.
+    \rst
+    Returns the content of the output buffer as an ``std::string``.
+    \endrst
    */
   std::string str() const { return std::string(str_, size()); }
 };
@@ -1947 +2991 @@
       return;
     }
     unsigned index = static_cast<unsigned>(abs_value * 2);
-    *buffer++ = internal::DIGITS[index];
-    *buffer++ = internal::DIGITS[index + 1];
+    *buffer++ = internal::Data::DIGITS[index];
+    *buffer++ = internal::Data::DIGITS[index + 1];
     return;
   }
   unsigned num_digits = internal::count_digits(abs_value);
   internal::format_decimal(buffer, abs_value, num_digits);
   buffer += num_digits;
 }
+
+/**
+  \rst
+  Returns a named argument for formatting functions.
+
+  **Example**::
+
+    print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
+
+  \endrst
+ */
+template <typename T>
+inline internal::NamedArg<char> arg(StringRef name, const T &arg) {
+  return internal::NamedArg<char>(name, arg);
+}
+
+template <typename T>
+inline internal::NamedArg<wchar_t> arg(WStringRef name, const T &arg) {
+  return internal::NamedArg<wchar_t>(name, arg);
+}
+
+// The following two functions are deleted intentionally to disable
+// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``.
+template <typename Char>
+void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
+template <typename Char>
+void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
 }
 
 #if FMT_GCC_VERSION
@@ -1986 +3057 @@
 
 #if FMT_USE_VARIADIC_TEMPLATES
 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
-  template<typename... Args> \
+  template <typename... Args> \
   ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
       const Args & ... args) { \
-    using fmt::internal::Arg; \
-    const Arg array[fmt::internal::NonZero<sizeof...(Args)>::VALUE] = { \
-      fmt::internal::MakeArg<Char>(args)... \
-    }; \
+    typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
     call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
-      fmt::ArgList(array, sizeof...(Args))); \
+      fmt::internal::make_arg_list<Char>(array, args...)); \
   }
 #else
 // Defines a wrapper for a function taking __VA_ARGS__ arguments
@@ -2003 +3071 @@
   template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
   inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
       FMT_GEN(n, FMT_MAKE_ARG)) { \
-    const fmt::internal::Arg args[] = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \
-    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
-      fmt::ArgList(args, sizeof(args) / sizeof(*args))); \
+    fmt::internal::ArgArray<n>::Type arr; \
+    FMT_GEN(n, FMT_ASSIGN_##Char); \
+    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
   }
 
 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
@@ -2021 +3090 @@
   FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \
   FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \
   FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__)
+  FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \
+  FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \
+  FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \
+  FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \
+  FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \
+  FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)
 #endif  // FMT_USE_VARIADIC_TEMPLATES
 
 /**
@@ -2032 +3106 @@
   **Example**::
 
     void print_error(const char *file, int line, const char *format,
-                     const fmt::ArgList &args) {
+                     fmt::ArgList args) {
       fmt::print("{}: {}: ", file, line);
       fmt::print(format, args);
     }
@@ -2043 +3117 @@
   you don't need legacy compiler support and can use variadic templates
   directly::
 
-    template<typename... Args>
+    template <typename... Args>
     void print_error(const char *file, int line, const char *format,
                      const Args & ... args) {
       fmt::print("{}: {}: ", file, line);
@@ -2057 +3131 @@
 #define FMT_VARIADIC_W(ReturnType, func, ...) \
   FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
 
+#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)
+
+#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)
+
+/**
+  \rst
+  Convenient macro to capture the arguments' names and values into several
+  ``fmt::arg(name, value)``.
+
+  **Example**::
+
+    int x = 1, y = 2;
+    print("point: ({x}, {y})", FMT_CAPTURE(x, y));
+    // same as:
+    // print("point: ({x}, {y})", arg("x", x), arg("y", y));
+
+  \endrst
+ */
+#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)
+
+#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)
+
 namespace fmt {
-FMT_VARIADIC(std::string, format, StringRef)
-FMT_VARIADIC_W(std::wstring, format, WStringRef)
-FMT_VARIADIC(void, print, StringRef)
-FMT_VARIADIC(void, print, std::FILE *, StringRef)
-FMT_VARIADIC(void, print, std::ostream &, StringRef)
-FMT_VARIADIC(void, print_colored, Color, StringRef)
-FMT_VARIADIC(std::string, sprintf, StringRef)
-FMT_VARIADIC(int, printf, StringRef)
-FMT_VARIADIC(int, fprintf, std::FILE *, StringRef)
-}
+FMT_VARIADIC(std::string, format, CStringRef)
+FMT_VARIADIC_W(std::wstring, format, WCStringRef)
+FMT_VARIADIC(void, print, CStringRef)
+FMT_VARIADIC(void, print, std::FILE *, CStringRef)
+
+FMT_VARIADIC(void, print_colored, Color, CStringRef)
+FMT_VARIADIC(std::string, sprintf, CStringRef)
+FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)
+FMT_VARIADIC(int, printf, CStringRef)
+FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
+
+#if FMT_USE_IOSTREAMS
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
+void print(std::ostream &os, CStringRef format_str, ArgList args);
+FMT_VARIADIC(void, print, std::ostream &, CStringRef)
+#endif
+}  // namespace fmt
+
+#if FMT_USE_USER_DEFINED_LITERALS
+namespace fmt {
+namespace internal {
+
+template <typename Char>
+struct UdlFormat {
+  const Char *str;
+
+  template <typename... Args>
+  auto operator()(Args && ... args) const
+                  -> decltype(format(str, std::forward<Args>(args)...)) {
+    return format(str, std::forward<Args>(args)...);
+  }
+};
+
+template <typename Char>
+struct UdlArg {
+  const Char *str;
+
+  template <typename T>
+  NamedArg<Char> operator=(T &&value) const {
+    return {str, std::forward<T>(value)};
+  }
+};
+
+} // namespace internal
+
+inline namespace literals {
+
+/**
+  \rst
+  C++11 literal equivalent of :func:`fmt::format`.
+
+  **Example**::
+
+    using namespace fmt::literals;
+    std::string message = "The answer is {}"_format(42);
+  \endrst
+ */
+inline internal::UdlFormat<char>
+operator"" _format(const char *s, std::size_t) { return {s}; }
+inline internal::UdlFormat<wchar_t>
+operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
+
+/**
+  \rst
+  C++11 literal equivalent of :func:`fmt::arg`.
+
+  **Example**::
+
+    using namespace fmt::literals;
+    print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
+  \endrst
+ */
+inline internal::UdlArg<char>
+operator"" _a(const char *s, std::size_t) { return {s}; }
+inline internal::UdlArg<wchar_t>
+operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
+
+} // inline namespace literals
+} // namespace fmt
+#endif // FMT_USE_USER_DEFINED_LITERALS
 
 // Restore warnings.
 #if FMT_GCC_VERSION >= 406
 # pragma GCC diagnostic pop
 #endif
 
+#if defined(__clang__) && !defined(__INTEL_COMPILER)
+# pragma clang diagnostic pop
+#endif
+
+#ifdef FMT_HEADER_ONLY
+# include "format.cc"
+#endif
+
 #endif  // FMT_FORMAT_H_