Move code from header to source.

format.cc

@@ -51,3 +51,561 @@ void fmt::internal::ReportUnknownType(char code, const char *type) {
       fmt::str(fmt::Format("unknown format code '\\x{:02x}' for {}")
         << static_cast<unsigned>(code) << type));
 }
+
+
+// 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>::FillPadding(
+    CharPtr buffer, unsigned total_size, std::size_t content_size, char fill) {
+  std::size_t padding = total_size - content_size;
+  std::size_t left_padding = padding / 2;
+  std::fill_n(buffer, left_padding, fill);
+  buffer += left_padding;
+  CharPtr content = buffer;
+  std::fill_n(buffer + content_size, padding - left_padding, fill);
+  return content;
+}
+
+template <typename Char>
+void fmt::BasicWriter<Char>::FormatDecimal(
+    CharPtr buffer, uint64_t value, unsigned num_digits) {
+  --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;
+    value /= 100;
+    buffer[num_digits] = internal::DIGITS[index + 1];
+    buffer[num_digits - 1] = internal::DIGITS[index];
+    num_digits -= 2;
+  }
+  if (value < 10) {
+    *buffer = static_cast<char>('0' + value);
+    return;
+  }
+  unsigned index = static_cast<unsigned>(value * 2);
+  buffer[1] = internal::DIGITS[index + 1];
+  buffer[0] = internal::DIGITS[index];
+}
+
+template <typename Char>
+typename fmt::BasicWriter<Char>::CharPtr
+  fmt::BasicWriter<Char>::PrepareFilledBuffer(
+    unsigned size, const AlignSpec &spec, char sign) {
+  unsigned width = spec.width();
+  if (width <= size) {
+    CharPtr p = GrowBuffer(size);
+    *p = sign;
+    return p + size - 1;
+  }
+  CharPtr p = GrowBuffer(width);
+  CharPtr end = p + width;
+  Alignment align = spec.align();
+  if (align == ALIGN_LEFT) {
+    *p = sign;
+    p += size;
+    std::fill(p, end, spec.fill());
+  } else if (align == ALIGN_CENTER) {
+    p = FillPadding(p, width, size, spec.fill());
+    *p = sign;
+    p += size;
+  } else {
+    if (align == ALIGN_NUMERIC) {
+      if (sign) {
+        *p++ = sign;
+        --size;
+      }
+    } else {
+      *(end - size) = sign;
+    }
+    std::fill(p, end - size, spec.fill());
+    p = end;
+  }
+  return p - 1;
+}
+
+template <typename Char>
+template <typename T>
+void fmt::BasicWriter<Char>::FormatDouble(
+    T value, const FormatSpec &spec, int precision) {
+  // Check type.
+  char type = spec.type();
+  bool upper = false;
+  switch (type) {
+  case 0:
+    type = 'g';
+    break;
+  case 'e': case 'f': case 'g':
+    break;
+  case 'F':
+#ifdef _MSC_VER
+    // MSVC's printf doesn't support 'F'.
+    type = 'f';
+#endif
+    // Fall through.
+  case 'E': case 'G':
+    upper = true;
+    break;
+  default:
+    internal::ReportUnknownType(type, "double");
+    break;
+  }
+
+  char sign = 0;
+  // Use SignBit instead of value < 0 because the latter is always
+  // false for NaN.
+  if (internal::SignBit(value)) {
+    sign = '-';
+    value = -value;
+  } else if (spec.sign_flag()) {
+    sign = spec.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 = FormatString(nan, size, spec);
+    if (sign)
+      *out = sign;
+    return;
+  }
+
+  if (internal::IsInf(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;
+    }
+    CharPtr out = FormatString(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.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 (precision >= 0) {
+    *format_ptr++ = '.';
+    *format_ptr++ = '*';
+  }
+  if (internal::IsLongDouble<T>::VALUE)
+    *format_ptr++ = 'L';
+  *format_ptr++ = type;
+  *format_ptr = '\0';
+
+  // Format using snprintf.
+  for (;;) {
+    std::size_t size = buffer_.capacity() - offset;
+    Char *start = &buffer_[offset];
+    int n = internal::CharTraits<Char>::FormatFloat(
+        start, size, format, width_for_sprintf, 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) = spec.fill();
+        }
+        ++n;
+      }
+      if (spec.align() == ALIGN_CENTER &&
+          spec.width() > static_cast<unsigned>(n)) {
+        unsigned width = spec.width();
+        CharPtr p = GrowBuffer(width);
+        std::copy(p, p + n, p + (width - n) / 2);
+        FillPadding(p, spec.width(), n, spec.fill());
+        return;
+      }
+      if (spec.fill() != ' ' || sign) {
+        while (*start == ' ')
+          *start++ = spec.fill();
+        if (sign)
+          *(start - 1) = sign;
+      }
+      GrowBuffer(n);
+      return;
+    }
+    buffer_.reserve(n >= 0 ? offset + n + 1 : 2 * buffer_.capacity());
+  }
+}
+
+// Throws Exception(message) if format contains '}', otherwise throws
+// FormatError reporting unmatched '{'. The idea is that unmatched '{'
+// should override other errors.
+template <typename Char>
+void fmt::BasicFormatter<Char>::ReportError(
+    const Char *s, StringRef message) const {
+  for (int num_open_braces = num_open_braces_; *s; ++s) {
+    if (*s == '{') {
+      ++num_open_braces;
+    } else if (*s == '}') {
+      if (--num_open_braces == 0)
+        throw fmt::FormatError(message);
+    }
+  }
+  throw fmt::FormatError("unmatched '{' in format");
+}
+
+// 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>
+unsigned fmt::BasicFormatter<Char>::ParseUInt(const Char *&s) const {
+  assert('0' <= *s && *s <= '9');
+  unsigned value = 0;
+  do {
+    unsigned new_value = value * 10 + (*s++ - '0');
+    if (new_value < value)  // Check if value wrapped around.
+      ReportError(s, "number is too big in format");
+    value = new_value;
+  } while ('0' <= *s && *s <= '9');
+  return value;
+}
+
+template <typename Char>
+inline const typename fmt::BasicFormatter<Char>::Arg
+    &fmt::BasicFormatter<Char>::ParseArgIndex(const Char *&s) {
+  unsigned arg_index = 0;
+  if (*s < '0' || *s > '9') {
+    if (*s != '}' && *s != ':')
+      ReportError(s, "invalid argument index in format string");
+    if (next_arg_index_ < 0) {
+      ReportError(s,
+          "cannot switch from manual to automatic argument indexing");
+    }
+    arg_index = next_arg_index_++;
+  } else {
+    if (next_arg_index_ > 0) {
+      ReportError(s,
+          "cannot switch from automatic to manual argument indexing");
+    }
+    next_arg_index_ = -1;
+    arg_index = ParseUInt(s);
+  }
+  if (arg_index >= args_.size())
+    ReportError(s, "argument index is out of range in format");
+  return *args_[arg_index];
+}
+
+template <typename Char>
+void fmt::BasicFormatter<Char>::CheckSign(const Char *&s, const Arg &arg) {
+  if (arg.type > LAST_NUMERIC_TYPE) {
+    ReportError(s,
+        Format("format specifier '{0}' requires numeric argument") << *s);
+  }
+  if (arg.type == UINT || arg.type == ULONG) {
+    ReportError(s,
+        Format("format specifier '{0}' requires signed argument") << *s);
+  }
+  ++s;
+}
+
+template <typename Char>
+void fmt::BasicFormatter<Char>::DoFormat() {
+  const Char *start = format_;
+  format_ = 0;
+  next_arg_index_ = 0;
+  const Char *s = start;
+  typedef internal::Array<Char, BasicWriter<Char>::INLINE_BUFFER_SIZE> Buffer;
+  BasicWriter<Char> &writer = *writer_;
+  while (*s) {
+    char c = *s++;
+    if (c != '{' && c != '}') continue;
+    if (*s == c) {
+      writer.buffer_.append(start, s);
+      start = ++s;
+      continue;
+    }
+    if (c == '}')
+      throw FormatError("unmatched '}' in format");
+    num_open_braces_= 1;
+    writer.buffer_.append(start, s - 1);
+
+    const Arg &arg = ParseArgIndex(s);
+
+    FormatSpec spec;
+    int precision = -1;
+    if (*s == ':') {
+      ++s;
+
+      // Parse fill and alignment.
+      if (char c = *s) {
+        const Char *p = s + 1;
+        spec.align_ = ALIGN_DEFAULT;
+        do {
+          switch (*p) {
+          case '<':
+            spec.align_ = ALIGN_LEFT;
+            break;
+          case '>':
+            spec.align_ = ALIGN_RIGHT;
+            break;
+          case '=':
+            spec.align_ = ALIGN_NUMERIC;
+            break;
+          case '^':
+            spec.align_ = ALIGN_CENTER;
+            break;
+          }
+          if (spec.align_ != ALIGN_DEFAULT) {
+            if (p != s) {
+              if (c == '}') break;
+              if (c == '{')
+                ReportError(s, "invalid fill character '{'");
+              s += 2;
+              spec.fill_ = c;
+            } else ++s;
+            if (spec.align_ == ALIGN_NUMERIC && arg.type > LAST_NUMERIC_TYPE)
+              ReportError(s, "format specifier '=' requires numeric argument");
+            break;
+          }
+        } while (--p >= s);
+      }
+
+      // Parse sign.
+      switch (*s) {
+      case '+':
+        CheckSign(s, arg);
+        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
+        break;
+      case '-':
+        CheckSign(s, arg);
+        break;
+      case ' ':
+        CheckSign(s, arg);
+        spec.flags_ |= SIGN_FLAG;
+        break;
+      }
+
+      if (*s == '#') {
+        if (arg.type > LAST_NUMERIC_TYPE)
+          ReportError(s, "format specifier '#' requires numeric argument");
+        spec.flags_ |= HASH_FLAG;
+        ++s;
+      }
+
+      // Parse width and zero flag.
+      if ('0' <= *s && *s <= '9') {
+        if (*s == '0') {
+          if (arg.type > LAST_NUMERIC_TYPE)
+            ReportError(s, "format specifier '0' requires numeric argument");
+          spec.align_ = ALIGN_NUMERIC;
+          spec.fill_ = '0';
+        }
+        // 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.
+        unsigned value = ParseUInt(s);
+        if (value > INT_MAX)
+          ReportError(s, "number is too big in format");
+        spec.width_ = value;
+      }
+
+      // Parse precision.
+      if (*s == '.') {
+        ++s;
+        precision = 0;
+        if ('0' <= *s && *s <= '9') {
+          unsigned value = ParseUInt(s);
+          if (value > INT_MAX)
+            ReportError(s, "number is too big in format");
+          precision = value;
+        } else if (*s == '{') {
+          ++s;
+          ++num_open_braces_;
+          const Arg &precision_arg = ParseArgIndex(s);
+          unsigned long value = 0;
+          switch (precision_arg.type) {
+          case INT:
+            if (precision_arg.int_value < 0)
+              ReportError(s, "negative precision in format");
+            value = precision_arg.int_value;
+            break;
+          case UINT:
+            value = precision_arg.uint_value;
+            break;
+          case LONG:
+            if (precision_arg.long_value < 0)
+              ReportError(s, "negative precision in format");
+            value = precision_arg.long_value;
+            break;
+          case ULONG:
+            value = precision_arg.ulong_value;
+            break;
+          default:
+            ReportError(s, "precision is not integer");
+          }
+          if (value > INT_MAX)
+            ReportError(s, "number is too big in format");
+          precision = value;
+          if (*s++ != '}')
+            throw FormatError("unmatched '{' in format");
+          --num_open_braces_;
+        } else {
+          ReportError(s, "missing precision in format");
+        }
+        if (arg.type != DOUBLE && arg.type != LONG_DOUBLE) {
+          ReportError(s,
+              "precision specifier requires floating-point argument");
+        }
+      }
+
+      // Parse type.
+      if (*s != '}' && *s)
+        spec.type_ = *s++;
+    }
+
+    if (*s++ != '}')
+      throw FormatError("unmatched '{' in format");
+    start = s;
+
+    // Format argument.
+    switch (arg.type) {
+    case INT:
+      writer.FormatInt(arg.int_value, spec);
+      break;
+    case UINT:
+      writer.FormatInt(arg.uint_value, spec);
+      break;
+    case LONG:
+      writer.FormatInt(arg.long_value, spec);
+      break;
+    case ULONG:
+      writer.FormatInt(arg.ulong_value, spec);
+      break;
+    case DOUBLE:
+      writer.FormatDouble(arg.double_value, spec, precision);
+      break;
+    case LONG_DOUBLE:
+      writer.FormatDouble(arg.long_double_value, spec, precision);
+      break;
+    case CHAR: {
+      if (spec.type_ && spec.type_ != 'c')
+        internal::ReportUnknownType(spec.type_, "char");
+      typedef typename BasicWriter<Char>::CharPtr CharPtr;
+      CharPtr out = CharPtr();
+      if (spec.width_ > 1) {
+        out = writer.GrowBuffer(spec.width_);
+        if (spec.align_ == ALIGN_RIGHT) {
+          std::fill_n(out, spec.width_ - 1, spec.fill_);
+          out += spec.width_ - 1;
+        } else if (spec.align_ == ALIGN_CENTER) {
+          out = writer.FillPadding(out, spec.width_, 1, spec.fill_);
+        } else {
+          std::fill_n(out + 1, spec.width_ - 1, spec.fill_);
+        }
+      } else {
+        out = writer.GrowBuffer(1);
+      }
+      *out = arg.int_value;
+      break;
+    }
+    case STRING: {
+      if (spec.type_ && spec.type_ != 's')
+        internal::ReportUnknownType(spec.type_, "string");
+      const Char *str = arg.string.value;
+      std::size_t size = arg.string.size;
+      if (size == 0) {
+        if (!str)
+          throw FormatError("string pointer is null");
+        if (*str)
+          size = std::char_traits<Char>::length(str);
+      }
+      writer.FormatString(str, size, spec);
+      break;
+    }
+    case POINTER:
+      if (spec.type_ && spec.type_ != 'p')
+        internal::ReportUnknownType(spec.type_, "pointer");
+      spec.flags_= HASH_FLAG;
+      spec.type_ = 'x';
+      writer.FormatInt(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
+      break;
+    case CUSTOM:
+      if (spec.type_)
+        internal::ReportUnknownType(spec.type_, "object");
+      arg.custom.format(writer, arg.custom.value, spec);
+      break;
+    default:
+      assert(false);
+      break;
+    }
+  }
+  writer.buffer_.append(start, s);
+}
+
+template void fmt::BasicWriter<char>::FormatDouble<double>(
+    double value, const FormatSpec &spec, int precision);
+template void fmt::BasicWriter<char>::FormatDouble<long double>(
+    long double value, const FormatSpec &spec, int precision);
+template fmt::BasicWriter<char>::CharPtr fmt::BasicWriter<char>::FillPadding(
+    CharPtr buffer, unsigned total_size, std::size_t content_size, char fill);
+template void fmt::BasicWriter<char>::FormatDecimal(
+    CharPtr buffer, uint64_t value, unsigned num_digits);
+template fmt::BasicWriter<char>::CharPtr
+  fmt::BasicWriter<char>::PrepareFilledBuffer(
+    unsigned size, const AlignSpec &spec, char sign);
+template void fmt::BasicFormatter<char>::ReportError(
+    const char *s, StringRef message) const;
+template unsigned fmt::BasicFormatter<char>::ParseUInt(const char *&s) const;
+template const fmt::BasicFormatter<char>::Arg
+    &fmt::BasicFormatter<char>::ParseArgIndex(const char *&s);
+template void fmt::BasicFormatter<char>::CheckSign(
+    const char *&s, const Arg &arg);
+template void fmt::BasicFormatter<char>::DoFormat();
+
+template void fmt::BasicWriter<wchar_t>::FormatDouble<double>(
+    double value, const FormatSpec &spec, int precision);
+template void fmt::BasicWriter<wchar_t>::FormatDouble<long double>(
+    long double value, const FormatSpec &spec, int precision);
+template fmt::BasicWriter<wchar_t>::CharPtr
+  fmt::BasicWriter<wchar_t>::FillPadding(
+    CharPtr buffer, unsigned total_size, std::size_t content_size, char fill);
+template void fmt::BasicWriter<wchar_t>::FormatDecimal(
+    CharPtr buffer, uint64_t value, unsigned num_digits);
+template fmt::BasicWriter<wchar_t>::CharPtr
+  fmt::BasicWriter<wchar_t>::PrepareFilledBuffer(
+    unsigned size, const AlignSpec &spec, char sign);
+template void fmt::BasicFormatter<wchar_t>::ReportError(
+    const wchar_t *s, StringRef message) const;
+template unsigned fmt::BasicFormatter<wchar_t>::ParseUInt(
+    const wchar_t *&s) const;
+template const fmt::BasicFormatter<wchar_t>::Arg
+    &fmt::BasicFormatter<wchar_t>::ParseArgIndex(const wchar_t *&s);
+template void fmt::BasicFormatter<wchar_t>::CheckSign(
+    const wchar_t *&s, const Arg &arg);
+template void fmt::BasicFormatter<wchar_t>::DoFormat();

format.h

@@ -623,217 +623,6 @@ class BasicWriter {
   }
 };
 
-// Fills the padding around the content and returns the pointer to the
-// content area.
-template <typename Char>
-typename BasicWriter<Char>::CharPtr BasicWriter<Char>::FillPadding(
-    CharPtr buffer, unsigned total_size, std::size_t content_size, char fill) {
-  std::size_t padding = total_size - content_size;
-  std::size_t left_padding = padding / 2;
-  std::fill_n(buffer, left_padding, fill);
-  buffer += left_padding;
-  CharPtr content = buffer;
-  std::fill_n(buffer + content_size, padding - left_padding, fill);
-  return content;
-}
-
-template <typename Char>
-void BasicWriter<Char>::FormatDecimal(
-    CharPtr buffer, uint64_t value, unsigned num_digits) {
-  --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;
-    value /= 100;
-    buffer[num_digits] = internal::DIGITS[index + 1];
-    buffer[num_digits - 1] = internal::DIGITS[index];
-    num_digits -= 2;
-  }
-  if (value < 10) {
-    *buffer = static_cast<char>('0' + value);
-    return;
-  }
-  unsigned index = static_cast<unsigned>(value * 2);
-  buffer[1] = internal::DIGITS[index + 1];
-  buffer[0] = internal::DIGITS[index];
-}
-
-template <typename Char>
-typename BasicWriter<Char>::CharPtr BasicWriter<Char>::PrepareFilledBuffer(
-    unsigned size, const AlignSpec &spec, char sign) {
-  unsigned width = spec.width();
-  if (width <= size) {
-    CharPtr p = GrowBuffer(size);
-    *p = sign;
-    return p + size - 1;
-  }
-  CharPtr p = GrowBuffer(width);
-  CharPtr end = p + width;
-  Alignment align = spec.align();
-  if (align == ALIGN_LEFT) {
-    *p = sign;
-    p += size;
-    std::fill(p, end, spec.fill());
-  } else if (align == ALIGN_CENTER) {
-    p = FillPadding(p, width, size, spec.fill());
-    *p = sign;
-    p += size;
-  } else {
-    if (align == ALIGN_NUMERIC) {
-      if (sign) {
-        *p++ = sign;
-        --size;
-      }
-    } else {
-      *(end - size) = sign;
-    }
-    std::fill(p, end - size, spec.fill());
-    p = end;
-  }
-  return p - 1;
-}
-
-template <typename Char>
-template <typename T>
-void BasicWriter<Char>::FormatDouble(
-    T value, const FormatSpec &spec, int precision) {
-  // Check type.
-  char type = spec.type();
-  bool upper = false;
-  switch (type) {
-  case 0:
-    type = 'g';
-    break;
-  case 'e': case 'f': case 'g':
-    break;
-  case 'F':
-#ifdef _MSC_VER
-    // MSVC's printf doesn't support 'F'.
-    type = 'f';
-#endif
-    // Fall through.
-  case 'E': case 'G':
-    upper = true;
-    break;
-  default:
-    internal::ReportUnknownType(type, "double");
-    break;
-  }
-
-  char sign = 0;
-  // Use SignBit instead of value < 0 because the latter is always
-  // false for NaN.
-  if (internal::SignBit(value)) {
-    sign = '-';
-    value = -value;
-  } else if (spec.sign_flag()) {
-    sign = spec.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 = FormatString(nan, size, spec);
-    if (sign)
-      *out = sign;
-    return;
-  }
-
-  if (internal::IsInf(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;
-    }
-    CharPtr out = FormatString(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.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 (precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
-  if (internal::IsLongDouble<T>::VALUE)
-    *format_ptr++ = 'L';
-  *format_ptr++ = type;
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  for (;;) {
-    std::size_t size = buffer_.capacity() - offset;
-    Char *start = &buffer_[offset];
-    int n = internal::CharTraits<Char>::FormatFloat(
-        start, size, format, width_for_sprintf, 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) = spec.fill();
-        }
-        ++n;
-      }
-      if (spec.align() == ALIGN_CENTER &&
-          spec.width() > static_cast<unsigned>(n)) {
-        unsigned width = spec.width();
-        CharPtr p = GrowBuffer(width);
-        std::copy(p, p + n, p + (width - n) / 2);
-        FillPadding(p, spec.width(), n, spec.fill());
-        return;
-      }
-      if (spec.fill() != ' ' || sign) {
-        while (*start == ' ')
-          *start++ = spec.fill();
-        if (sign)
-          *(start - 1) = sign;
-      }
-      GrowBuffer(n);
-      return;
-    }
-    buffer_.reserve(n >= 0 ? offset + n + 1 : 2 * buffer_.capacity());
-  }
-}
-
 template <typename Char>
 template <typename StringChar>
 typename BasicWriter<Char>::CharPtr BasicWriter<Char>::FormatString(
@@ -1335,308 +1124,6 @@ class Write {
 inline Formatter<Write> Print(StringRef format) {
   return Formatter<Write>(format);
 }
-
-// Throws Exception(message) if format contains '}', otherwise throws
-// FormatError reporting unmatched '{'. The idea is that unmatched '{'
-// should override other errors.
-template <typename Char>
-void BasicFormatter<Char>::ReportError(const Char *s, StringRef message) const {
-  for (int num_open_braces = num_open_braces_; *s; ++s) {
-    if (*s == '{') {
-      ++num_open_braces;
-    } else if (*s == '}') {
-      if (--num_open_braces == 0)
-        throw fmt::FormatError(message);
-    }
-  }
-  throw fmt::FormatError("unmatched '{' in format");
-}
-
-// 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>
-unsigned BasicFormatter<Char>::ParseUInt(const Char *&s) const {
-  assert('0' <= *s && *s <= '9');
-  unsigned value = 0;
-  do {
-    unsigned new_value = value * 10 + (*s++ - '0');
-    if (new_value < value)  // Check if value wrapped around.
-      ReportError(s, "number is too big in format");
-    value = new_value;
-  } while ('0' <= *s && *s <= '9');
-  return value;
-}
-
-template <typename Char>
-inline const typename BasicFormatter<Char>::Arg
-    &BasicFormatter<Char>::ParseArgIndex(const Char *&s) {
-  unsigned arg_index = 0;
-  if (*s < '0' || *s > '9') {
-    if (*s != '}' && *s != ':')
-      ReportError(s, "invalid argument index in format string");
-    if (next_arg_index_ < 0) {
-      ReportError(s,
-          "cannot switch from manual to automatic argument indexing");
-    }
-    arg_index = next_arg_index_++;
-  } else {
-    if (next_arg_index_ > 0) {
-      ReportError(s,
-          "cannot switch from automatic to manual argument indexing");
-    }
-    next_arg_index_ = -1;
-    arg_index = ParseUInt(s);
-  }
-  if (arg_index >= args_.size())
-    ReportError(s, "argument index is out of range in format");
-  return *args_[arg_index];
-}
-
-template <typename Char>
-void BasicFormatter<Char>::CheckSign(const Char *&s, const Arg &arg) {
-  if (arg.type > LAST_NUMERIC_TYPE) {
-    ReportError(s,
-        Format("format specifier '{0}' requires numeric argument") << *s);
-  }
-  if (arg.type == UINT || arg.type == ULONG) {
-    ReportError(s,
-        Format("format specifier '{0}' requires signed argument") << *s);
-  }
-  ++s;
-}
-
-template <typename Char>
-void BasicFormatter<Char>::DoFormat() {
-  const Char *start = format_;
-  format_ = 0;
-  next_arg_index_ = 0;
-  const Char *s = start;
-  typedef internal::Array<Char, BasicWriter<Char>::INLINE_BUFFER_SIZE> Buffer;
-  BasicWriter<Char> &writer = *writer_;
-  while (*s) {
-    char c = *s++;
-    if (c != '{' && c != '}') continue;
-    if (*s == c) {
-      writer.buffer_.append(start, s);
-      start = ++s;
-      continue;
-    }
-    if (c == '}')
-      throw FormatError("unmatched '}' in format");
-    num_open_braces_= 1;
-    writer.buffer_.append(start, s - 1);
-
-    const Arg &arg = ParseArgIndex(s);
-
-    FormatSpec spec;
-    int precision = -1;
-    if (*s == ':') {
-      ++s;
-
-      // Parse fill and alignment.
-      if (char c = *s) {
-        const Char *p = s + 1;
-        spec.align_ = ALIGN_DEFAULT;
-        do {
-          switch (*p) {
-          case '<':
-            spec.align_ = ALIGN_LEFT;
-            break;
-          case '>':
-            spec.align_ = ALIGN_RIGHT;
-            break;
-          case '=':
-            spec.align_ = ALIGN_NUMERIC;
-            break;
-          case '^':
-            spec.align_ = ALIGN_CENTER;
-            break;
-          }
-          if (spec.align_ != ALIGN_DEFAULT) {
-            if (p != s) {
-              if (c == '}') break;
-              if (c == '{')
-                ReportError(s, "invalid fill character '{'");
-              s += 2;
-              spec.fill_ = c;
-            } else ++s;
-            if (spec.align_ == ALIGN_NUMERIC && arg.type > LAST_NUMERIC_TYPE)
-              ReportError(s, "format specifier '=' requires numeric argument");
-            break;
-          }
-        } while (--p >= s);
-      }
-
-      // Parse sign.
-      switch (*s) {
-      case '+':
-        CheckSign(s, arg);
-        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
-        break;
-      case '-':
-        CheckSign(s, arg);
-        break;
-      case ' ':
-        CheckSign(s, arg);
-        spec.flags_ |= SIGN_FLAG;
-        break;
-      }
-
-      if (*s == '#') {
-        if (arg.type > LAST_NUMERIC_TYPE)
-          ReportError(s, "format specifier '#' requires numeric argument");
-        spec.flags_ |= HASH_FLAG;
-        ++s;
-      }
-
-      // Parse width and zero flag.
-      if ('0' <= *s && *s <= '9') {
-        if (*s == '0') {
-          if (arg.type > LAST_NUMERIC_TYPE)
-            ReportError(s, "format specifier '0' requires numeric argument");
-          spec.align_ = ALIGN_NUMERIC;
-          spec.fill_ = '0';
-        }
-        // 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.
-        unsigned value = ParseUInt(s);
-        if (value > INT_MAX)
-          ReportError(s, "number is too big in format");
-        spec.width_ = value;
-      }
-
-      // Parse precision.
-      if (*s == '.') {
-        ++s;
-        precision = 0;
-        if ('0' <= *s && *s <= '9') {
-          unsigned value = ParseUInt(s);
-          if (value > INT_MAX)
-            ReportError(s, "number is too big in format");
-          precision = value;
-        } else if (*s == '{') {
-          ++s;
-          ++num_open_braces_;
-          const Arg &precision_arg = ParseArgIndex(s);
-          unsigned long value = 0;
-          switch (precision_arg.type) {
-          case INT:
-            if (precision_arg.int_value < 0)
-              ReportError(s, "negative precision in format");
-            value = precision_arg.int_value;
-            break;
-          case UINT:
-            value = precision_arg.uint_value;
-            break;
-          case LONG:
-            if (precision_arg.long_value < 0)
-              ReportError(s, "negative precision in format");
-            value = precision_arg.long_value;
-            break;
-          case ULONG:
-            value = precision_arg.ulong_value;
-            break;
-          default:
-            ReportError(s, "precision is not integer");
-          }
-          if (value > INT_MAX)
-            ReportError(s, "number is too big in format");
-          precision = value;
-          if (*s++ != '}')
-            throw FormatError("unmatched '{' in format");
-          --num_open_braces_;
-        } else {
-          ReportError(s, "missing precision in format");
-        }
-        if (arg.type != DOUBLE && arg.type != LONG_DOUBLE) {
-          ReportError(s,
-              "precision specifier requires floating-point argument");
-        }
-      }
-
-      // Parse type.
-      if (*s != '}' && *s)
-        spec.type_ = *s++;
-    }
-
-    if (*s++ != '}')
-      throw FormatError("unmatched '{' in format");
-    start = s;
-
-    // Format argument.
-    switch (arg.type) {
-    case INT:
-      writer.FormatInt(arg.int_value, spec);
-      break;
-    case UINT:
-      writer.FormatInt(arg.uint_value, spec);
-      break;
-    case LONG:
-      writer.FormatInt(arg.long_value, spec);
-      break;
-    case ULONG:
-      writer.FormatInt(arg.ulong_value, spec);
-      break;
-    case DOUBLE:
-      writer.FormatDouble(arg.double_value, spec, precision);
-      break;
-    case LONG_DOUBLE:
-      writer.FormatDouble(arg.long_double_value, spec, precision);
-      break;
-    case CHAR: {
-      if (spec.type_ && spec.type_ != 'c')
-        internal::ReportUnknownType(spec.type_, "char");
-      typedef typename BasicWriter<Char>::CharPtr CharPtr;
-      CharPtr out = CharPtr();
-      if (spec.width_ > 1) {
-        out = writer.GrowBuffer(spec.width_);
-        if (spec.align_ == ALIGN_RIGHT) {
-          std::fill_n(out, spec.width_ - 1, spec.fill_);
-          out += spec.width_ - 1;
-        } else if (spec.align_ == ALIGN_CENTER) {
-          out = writer.FillPadding(out, spec.width_, 1, spec.fill_);
-        } else {
-          std::fill_n(out + 1, spec.width_ - 1, spec.fill_);
-        }
-      } else {
-        out = writer.GrowBuffer(1);
-      }
-      *out = arg.int_value;
-      break;
-    }
-    case STRING: {
-      if (spec.type_ && spec.type_ != 's')
-        internal::ReportUnknownType(spec.type_, "string");
-      const Char *str = arg.string.value;
-      std::size_t size = arg.string.size;
-      if (size == 0) {
-        if (!str)
-          throw FormatError("string pointer is null");
-        if (*str)
-          size = std::char_traits<Char>::length(str);
-      }
-      writer.FormatString(str, size, spec);
-      break;
-    }
-    case POINTER:
-      if (spec.type_ && spec.type_ != 'p')
-        internal::ReportUnknownType(spec.type_, "pointer");
-      spec.flags_= HASH_FLAG;
-      spec.type_ = 'x';
-      writer.FormatInt(reinterpret_cast<uintptr_t>(arg.pointer_value), spec);
-      break;
-    case CUSTOM:
-      if (spec.type_)
-        internal::ReportUnknownType(spec.type_, "object");
-      arg.custom.format(writer, arg.custom.value, spec);
-      break;
-    default:
-      assert(false);
-      break;
-    }
-  }
-  writer.buffer_.append(start, s);
-}
 }
 
 #endif  // FORMAT_H_