Update the format library to the latest version.

2026-07-09 01:57:09 +02:00 · 2016-05-22 23:37:55 +03:00
parent edf4d6cd38
commit 49a9983799
13 changed files with 711 additions and 1106 deletions
@@ -1,7 +1,7 @@
 /*
 Formatting library for C++

- Copyright (c) 2012 - 2015, Victor Zverovich
+ Copyright (c) 2012 - 2016, Victor Zverovich
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
@@ -60,12 +60,6 @@ using fmt::internal::Arg;
 # define FMT_CATCH(x) if (false)
 #endif

-#ifdef FMT_HEADER_ONLY
-# define FMT_FUNC inline
-#else
-# define FMT_FUNC
-#endif
-
 #ifdef _MSC_VER
 # pragma warning(push)
 # pragma warning(disable: 4127)  // conditional expression is constant
@@ -129,7 +123,7 @@ struct IntChecker<true> {

 const char RESET_COLOR[] = "\x1b[0m";

-typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
+typedef void (*FormatFunc)(Writer &, int, StringRef);

 // Portable thread-safe version of strerror.
 // Sets buffer to point to a string describing the error code.
@@ -169,7 +163,7 @@ int safe_strerror(
    }

    // Handle the case when strerror_r is not available.
-    int handle(fmt::internal::Null<>) {
+    int handle(internal::Null<>) {
      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
    }

@@ -181,7 +175,7 @@ int safe_strerror(
    }

    // Fallback to strerror if strerror_r and strerror_s are not available.
-    int fallback(fmt::internal::Null<>) {
+    int fallback(internal::Null<>) {
      errno = 0;
      buffer_ = strerror(error_code_);
      return errno;
@@ -199,8 +193,8 @@ int safe_strerror(
  return StrError(error_code, buffer, buffer_size).run();
 }

-void format_error_code(fmt::Writer &out, int error_code,
-                       fmt::StringRef message) FMT_NOEXCEPT {
+void format_error_code(Writer &out, int error_code,
+                       StringRef message) FMT_NOEXCEPT {
  // Report error code making sure that the output fits into
  // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
  // bad_alloc.
@@ -209,22 +203,22 @@ void format_error_code(fmt::Writer &out, int error_code,
  static const char ERROR_STR[] = "error ";
  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-  typedef fmt::internal::IntTraits<int>::MainType MainType;
+  typedef internal::IntTraits<int>::MainType MainType;
  MainType abs_value = static_cast<MainType>(error_code);
  if (internal::is_negative(error_code)) {
    abs_value = 0 - abs_value;
    ++error_code_size;
  }
-  error_code_size += fmt::internal::count_digits(abs_value);
-  if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)
+  error_code_size += internal::count_digits(abs_value);
+  if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size)
    out << message << SEP;
  out << ERROR_STR << error_code;
-  assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);
+  assert(out.size() <= internal::INLINE_BUFFER_SIZE);
 }

-void report_error(FormatFunc func,
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
-  fmt::MemoryWriter full_message;
+void report_error(FormatFunc func, int error_code,
+                  StringRef message) FMT_NOEXCEPT {
+  MemoryWriter full_message;
  func(full_message, error_code, message);
  // Use Writer::data instead of Writer::c_str to avoid potential memory
  // allocation.
@@ -233,7 +227,7 @@ void report_error(FormatFunc func,
 }

 // IsZeroInt::visit(arg) returns true iff arg is a zero integer.
-class IsZeroInt : public fmt::internal::ArgVisitor<IsZeroInt, bool> {
+class IsZeroInt : public ArgVisitor<IsZeroInt, bool> {
 public:
  template <typename T>
  bool visit_any_int(T value) { return value == 0; }
@@ -241,44 +235,43 @@ class IsZeroInt : public fmt::internal::ArgVisitor<IsZeroInt, bool> {

 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-class WidthHandler : public fmt::internal::ArgVisitor<WidthHandler, unsigned> {
+class WidthHandler : public ArgVisitor<WidthHandler, unsigned> {
 private:
-  fmt::FormatSpec &spec_;
+  FormatSpec &spec_;

  FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);

 public:
-  explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}
+  explicit WidthHandler(FormatSpec &spec) : spec_(spec) {}

  void report_unhandled_arg() {
-    FMT_THROW(fmt::FormatError("width is not integer"));
+    FMT_THROW(FormatError("width is not integer"));
  }

  template <typename T>
  unsigned visit_any_int(T value) {
-    typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType;
+    typedef typename internal::IntTraits<T>::MainType UnsignedType;
    UnsignedType width = static_cast<UnsignedType>(value);
-    if (fmt::internal::is_negative(value)) {
-      spec_.align_ = fmt::ALIGN_LEFT;
+    if (internal::is_negative(value)) {
+      spec_.align_ = ALIGN_LEFT;
      width = 0 - width;
    }
    if (width > INT_MAX)
-      FMT_THROW(fmt::FormatError("number is too big"));
+      FMT_THROW(FormatError("number is too big"));
    return static_cast<unsigned>(width);
  }
 };

-class PrecisionHandler :
-    public fmt::internal::ArgVisitor<PrecisionHandler, int> {
+class PrecisionHandler : public ArgVisitor<PrecisionHandler, int> {
 public:
  void report_unhandled_arg() {
-    FMT_THROW(fmt::FormatError("precision is not integer"));
+    FMT_THROW(FormatError("precision is not integer"));
  }

  template <typename T>
  int visit_any_int(T value) {
    if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(fmt::FormatError("number is too big"));
+      FMT_THROW(FormatError("number is too big"));
    return static_cast<int>(value);
  }
 };
@@ -298,15 +291,15 @@ struct is_same<T, T> {
 // corresponding signed or unsigned type depending on the type specifier:
 // 'd' and 'i' - signed, other - unsigned)
 template <typename T = void>
-class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
+class ArgConverter : public ArgVisitor<ArgConverter<T>, void> {
 private:
-  fmt::internal::Arg &arg_;
+  internal::Arg &arg_;
  wchar_t type_;

  FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);

 public:
-  ArgConverter(fmt::internal::Arg &arg, wchar_t type)
+  ArgConverter(internal::Arg &arg, wchar_t type)
    : arg_(arg), type_(type) {}

  void visit_bool(bool value) {
@@ -317,8 +310,8 @@ class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
  template <typename U>
  void visit_any_int(U value) {
    bool is_signed = type_ == 'd' || type_ == 'i';
-    using fmt::internal::Arg;
-    typedef typename fmt::internal::Conditional<
+    using internal::Arg;
+    typedef typename internal::Conditional<
        is_same<T, void>::value, U, T>::type TargetType;
    if (sizeof(TargetType) <= sizeof(int)) {
      // Extra casts are used to silence warnings.
@@ -327,7 +320,7 @@ class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
        arg_.int_value = static_cast<int>(static_cast<TargetType>(value));
      } else {
        arg_.type = Arg::UINT;
-        typedef typename fmt::internal::MakeUnsigned<TargetType>::Type Unsigned;
+        typedef typename internal::MakeUnsigned<TargetType>::Type Unsigned;
        arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));
      }
    } else {
@@ -336,51 +329,43 @@ class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
        // glibc's printf doesn't sign extend arguments of smaller types:
        //   std::printf("%lld", -42);  // prints "4294967254"
        // but we don't have to do the same because it's a UB.
-        arg_.long_long_value = static_cast<fmt::LongLong>(value);
+        arg_.long_long_value = static_cast<LongLong>(value);
      } else {
        arg_.type = Arg::ULONG_LONG;
        arg_.ulong_long_value =
-            static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
+            static_cast<typename internal::MakeUnsigned<U>::Type>(value);
      }
    }
  }
 };

 // Converts an integer argument to char for printf.
-class CharConverter : public fmt::internal::ArgVisitor<CharConverter, void> {
+class CharConverter : public ArgVisitor<CharConverter, void> {
 private:
-  fmt::internal::Arg &arg_;
+  internal::Arg &arg_;

  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);

 public:
-  explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}
+  explicit CharConverter(internal::Arg &arg) : arg_(arg) {}

  template <typename T>
  void visit_any_int(T value) {
-    arg_.type = Arg::CHAR;
+    arg_.type = internal::Arg::CHAR;
    arg_.int_value = static_cast<char>(value);
  }
 };
-
-// Write the content of w to os.
-void write(std::ostream &os, fmt::Writer &w) {
-  const char *data = w.data();
-  typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
-  UnsignedStreamSize size = w.size();
-  UnsignedStreamSize max_size =
-      internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
-  do {
-    UnsignedStreamSize n = size <= max_size ? size : max_size;
-    os.write(data, static_cast<std::streamsize>(n));
-    data += n;
-    size -= n;
-  } while (size != 0);
-}
 }  // namespace

 namespace internal {

+// This method is used to preserve binary compatibility with fmt 3.0.
+// It can be removed in 4.0.
+FMT_FUNC void format_system_error(
+  Writer &out, int error_code, StringRef message) FMT_NOEXCEPT {
+  fmt::format_system_error(out, error_code, message);
+}
+
 template <typename Char>
 class PrintfArgFormatter :
    public ArgFormatterBase<PrintfArgFormatter<Char>, Char> {
@@ -456,7 +441,7 @@ FMT_FUNC void fmt::SystemError::init(
    int err_code, CStringRef format_str, ArgList args) {
  error_code_ = err_code;
  MemoryWriter w;
-  internal::format_system_error(w, err_code, format(format_str, args));
+  format_system_error(w, err_code, format(format_str, args));
  std::runtime_error &base = *this;
  base = std::runtime_error(w.str());
 }
@@ -614,12 +599,12 @@ FMT_FUNC void fmt::internal::format_windows_error(

 #endif  // FMT_USE_WINDOWS_H

-FMT_FUNC void fmt::internal::format_system_error(
+FMT_FUNC void fmt::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);
+    internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer;
+    buffer.resize(internal::INLINE_BUFFER_SIZE);
    for (;;) {
      char *system_message = &buffer[0];
      int result = safe_strerror(error_code, system_message, buffer.size());
@@ -876,7 +861,7 @@ void fmt::internal::PrintfFormatter<Char>::format(
 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);
+  fmt::report_error(format_system_error, error_code, message);
 }

 #if FMT_USE_WINDOWS_H
@@ -897,13 +882,6 @@ 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);
-  write(os, w);
-}
-
 FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
  char escape[] = "\x1b[30m";
  escape[3] = static_cast<char>('0' + c);
@@ -919,13 +897,6 @@ FMT_FUNC int fmt::fprintf(std::FILE *f, CStringRef format, ArgList args) {
  return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
 }

-FMT_FUNC int fmt::fprintf(std::ostream &os, CStringRef format, ArgList args) {
-  MemoryWriter w;
-  printf(w, format, args);
-  write(os, w);
-  return static_cast<int>(w.size());
-}
-
 #ifndef FMT_HEADER_ONLY

 template struct fmt::internal::BasicData<void>;