format.cc

/*
 String formatting library for C++

 Copyright (c) 2012, Victor Zverovich
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

// 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 <cctype>
#include <cmath>

namespace {

#ifndef _MSC_VER

inline int SignBit(double value) {
  // When compiled in C++11 mode signbit is no longer a macro but a function
  // defined in namespace std and the macro is undefined.
  using namespace std;
  return signbit(value);
}

inline int IsInf(double x) {
#ifdef isinf
  return isinf(x);
#else
  return std::isinf(x);
#endif
}

#define FMT_SNPRINTF snprintf

#else

inline int SignBit(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;
}

inline int IsInf(double x) { return !_finite(x); }

#define FMT_SNPRINTF sprintf_s

#endif  // _MSC_VER
}

template <typename T>
int fmt::internal::CharTraits<char>::FormatFloat(
    char *buffer, std::size_t size, const char *format,
    unsigned width, int precision, T value) {
  if (width == 0) {
    return precision < 0 ?
        FMT_SNPRINTF(buffer, size, format, value) :
        FMT_SNPRINTF(buffer, size, format, precision, value);
  }
  return precision < 0 ?
      FMT_SNPRINTF(buffer, size, format, width, value) :
      FMT_SNPRINTF(buffer, size, format, width, precision, value);
}

template <typename T>
int fmt::internal::CharTraits<wchar_t>::FormatFloat(
    wchar_t *buffer, std::size_t size, const wchar_t *format,
    unsigned width, int precision, T value) {
  if (width == 0) {
    return precision < 0 ?
        swprintf(buffer, size, format, value) :
        swprintf(buffer, size, format, precision, value);
  }
  return precision < 0 ?
      swprintf(buffer, size, format, width, value) :
      swprintf(buffer, size, format, width, precision, value);
}

const char fmt::internal::DIGITS[] =
    "0001020304050607080910111213141516171819"
    "2021222324252627282930313233343536373839"
    "4041424344454647484950515253545556575859"
    "6061626364656667686970717273747576777879"
    "8081828384858687888990919293949596979899";

void fmt::internal::ReportUnknownType(char code, const char *type) {
  if (std::isprint(static_cast<unsigned char>(code))) {
    throw fmt::FormatError(fmt::str(
        fmt::Format("unknown format code '{}' for {}") << code << type));
  }
  throw fmt::FormatError(
      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, 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>
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();
  Char fill = static_cast<Char>(spec.fill());
  if (align == ALIGN_LEFT) {
    *p = sign;
    p += size;
    std::fill(p, end, fill);
  } else if (align == ALIGN_CENTER) {
    p = FillPadding(p, width, size, fill);
    *p = sign;
    p += size;
  } else {
    if (align == ALIGN_NUMERIC) {
      if (sign) {
        *p++ = sign;
        --size;
      }
    } else {
      *(end - size) = sign;
    }
    std::fill(p, end - size, 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 (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 (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.
  Char fill = static_cast<Char>(spec.fill());
  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) = 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, fill);
        return;
      }
      if (spec.fill() != ' ' || sign) {
        while (*start == ' ')
          *start++ = 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) {
  char sign = static_cast<char>(*s);
  if (arg.type > LAST_NUMERIC_TYPE) {
    ReportError(s,
        Format("format specifier '{}' requires numeric argument") << sign);
  }
  if (arg.type == UINT || arg.type == ULONG || arg.type == ULONG_LONG) {
    ReportError(s,
        Format("format specifier '{}' requires signed argument") << sign);
  }
  ++s;
}

template <typename Char>
void fmt::BasicFormatter<Char>::DoFormat() {
  const Char *start = format_;
  const Char *original = format_; // capture the format string before it is reset
  format_ = 0;
  next_arg_index_ = 0;
  const Char *s = start;
  BasicWriter<Char> &writer = *writer_;
  try {
    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);
            ULongLong 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;
            case LONG_LONG:
              if (precision_arg.long_long_value < 0)
                ReportError(s, "negative precision in format");
              value = precision_arg.long_long_value;
              break;
            case ULONG_LONG:
              value = precision_arg.ulong_long_value;
              break;
            default:
              ReportError(s, "precision is not integer");
            }
            if (value > INT_MAX)
              ReportError(s, "number is too big in format");
            precision = static_cast<int>(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_ = static_cast<char>(*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 LONG_LONG:
        writer.FormatInt(arg.long_long_value, spec);
        break;
      case ULONG_LONG:
        writer.FormatInt(arg.ulong_long_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) {
          Char fill = static_cast<Char>(spec.fill());
          out = writer.GrowBuffer(spec.width_);
          if (spec.align_ == ALIGN_RIGHT) {
            std::fill_n(out, spec.width_ - 1, fill);
            out += spec.width_ - 1;
          } else if (spec.align_ == ALIGN_CENTER) {
            out = writer.FillPadding(out, spec.width_, 1, fill);
          } else {
            std::fill_n(out + 1, spec.width_ - 1, 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;
      }
    }  
  } catch (const FormatError &e) {
    // rethrow FormatError with the format string pointed to by start
    throw BasicFormatError<Char>(e.what(), original);
  }
  writer.buffer_.append(start, s);
}

// Explicit instantiations for char.

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, wchar_t 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();

#ifdef FMT_FORMAT_STRING_IN_ERRORS
std::string fmt::FormatErrorMessage(const std::string &message, const char *format) {
    fmt::Writer w;    
    w << "error: " << message << " while parsing format string " << format;
    return w.str();
}
#else
std::string fmt::FormatErrorMessage(const std::string &message, const char *format) {
    return message;
}
#endif

// Explicit instantiations for wchar_t.

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, wchar_t 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();

#ifdef FMT_FORMAT_STRING_IN_ERRORS
std::string fmt::FormatErrorMessage(const std::string &message, const wchar_t *format) {

    int size = FMT_SNPRINTF(NULL, 0, "%ls", format);
    char* buf = (char*)malloc(size+1);
    FMT_SNPRINTF(buf, size+1, "%ls", format);
    
    fmt::Writer w;    
    w << "error: " << message << " while parsing format string " << buf;
    free(buf);
    return w.str();
}
#else
std::string fmt::FormatErrorMessage(const std::string &message, const wchar_t *format) {
    return message;
}
#endif