mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-09-05 01:11:17 +00:00
d5d60c6e64
Allows us to migrate off of printf specifiers and have more type-safe formatting facilities. It also allows for custom type support as well. fmt is also on track to have part of it standardized within C++2a, so this will also lessen the transitional work necessary later on by allowing new code to use it. This simply adds the library but doesn't do anything with it yet.
972 lines
32 KiB
C++
Executable file
972 lines
32 KiB
C++
Executable file
// Formatting library for C++
|
|
//
|
|
// Copyright (c) 2012 - 2016, Victor Zverovich
|
|
// All rights reserved.
|
|
//
|
|
// For the license information refer to format.h.
|
|
|
|
#ifndef FMT_FORMAT_INL_H_
|
|
#define FMT_FORMAT_INL_H_
|
|
|
|
#include "format.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include <cctype>
|
|
#include <cerrno>
|
|
#include <climits>
|
|
#include <cmath>
|
|
#include <cstdarg>
|
|
#include <cstddef> // for std::ptrdiff_t
|
|
#include <cstring> // for std::memmove
|
|
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
|
|
# include <locale>
|
|
#endif
|
|
|
|
#if FMT_USE_WINDOWS_H
|
|
# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
|
|
# define WIN32_LEAN_AND_MEAN
|
|
# endif
|
|
# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
|
|
# include <windows.h>
|
|
# else
|
|
# define NOMINMAX
|
|
# include <windows.h>
|
|
# undef NOMINMAX
|
|
# endif
|
|
#endif
|
|
|
|
#if FMT_EXCEPTIONS
|
|
# define FMT_TRY try
|
|
# define FMT_CATCH(x) catch (x)
|
|
#else
|
|
# define FMT_TRY if (true)
|
|
# define FMT_CATCH(x) if (false)
|
|
#endif
|
|
|
|
#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
|
|
|
|
// Dummy implementations of strerror_r and strerror_s called if corresponding
|
|
// system functions are not available.
|
|
inline fmt::internal::null<> strerror_r(int, char *, ...) {
|
|
return fmt::internal::null<>();
|
|
}
|
|
inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) {
|
|
return fmt::internal::null<>();
|
|
}
|
|
|
|
FMT_BEGIN_NAMESPACE
|
|
|
|
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);
|
|
int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
|
|
va_end(args);
|
|
return result;
|
|
}
|
|
# define FMT_SNPRINTF fmt_snprintf
|
|
#endif // _MSC_VER
|
|
|
|
#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)
|
|
|
|
typedef void (*FormatFunc)(internal::buffer &, int, string_view);
|
|
|
|
// 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 != FMT_NULL && buffer_size != 0, "invalid buffer");
|
|
|
|
class dispatcher {
|
|
private:
|
|
int error_code_;
|
|
char *&buffer_;
|
|
std::size_t buffer_size_;
|
|
|
|
// A noop assignment operator to avoid bogus warnings.
|
|
void operator=(const dispatcher &) {}
|
|
|
|
// 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(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;
|
|
}
|
|
|
|
#if !FMT_MSC_VER
|
|
// Fallback to strerror if strerror_r and strerror_s are not available.
|
|
int fallback(internal::null<>) {
|
|
errno = 0;
|
|
buffer_ = strerror(error_code_);
|
|
return errno;
|
|
}
|
|
#endif
|
|
|
|
public:
|
|
dispatcher(int err_code, char *&buf, std::size_t buf_size)
|
|
: error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
|
|
|
|
int run() {
|
|
return handle(strerror_r(error_code_, buffer_, buffer_size_));
|
|
}
|
|
};
|
|
return dispatcher(error_code, buffer, buffer_size).run();
|
|
}
|
|
|
|
void format_error_code(internal::buffer &out, int error_code,
|
|
string_view message) FMT_NOEXCEPT {
|
|
// Report error code making sure that the output fits into
|
|
// inline_buffer_size to avoid dynamic memory allocation and potential
|
|
// bad_alloc.
|
|
out.resize(0);
|
|
static const char SEP[] = ": ";
|
|
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 internal::int_traits<int>::main_type main_type;
|
|
main_type abs_value = static_cast<main_type>(error_code);
|
|
if (internal::is_negative(error_code)) {
|
|
abs_value = 0 - abs_value;
|
|
++error_code_size;
|
|
}
|
|
error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
|
|
writer w(out);
|
|
if (message.size() <= inline_buffer_size - error_code_size) {
|
|
w.write(message);
|
|
w.write(SEP);
|
|
}
|
|
w.write(ERROR_STR);
|
|
w.write(error_code);
|
|
assert(out.size() <= inline_buffer_size);
|
|
}
|
|
|
|
void report_error(FormatFunc func, int error_code,
|
|
string_view message) FMT_NOEXCEPT {
|
|
memory_buffer 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);
|
|
}
|
|
} // namespace
|
|
|
|
FMT_FUNC size_t internal::count_code_points(basic_string_view<char8_t> s) {
|
|
const char8_t *data = s.data();
|
|
size_t num_code_points = 0;
|
|
for (size_t i = 0, size = s.size(); i != size; ++i) {
|
|
if ((data[i] & 0xc0) != 0x80)
|
|
++num_code_points;
|
|
}
|
|
return num_code_points;
|
|
}
|
|
|
|
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
|
|
namespace internal {
|
|
|
|
template <typename Locale>
|
|
locale_ref::locale_ref(const Locale &loc) : locale_(&loc) {
|
|
static_assert(std::is_same<Locale, std::locale>::value, "");
|
|
}
|
|
|
|
template <typename Locale>
|
|
Locale locale_ref::get() const {
|
|
static_assert(std::is_same<Locale, std::locale>::value, "");
|
|
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
|
|
}
|
|
|
|
template <typename Char>
|
|
FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
|
|
return std::use_facet<std::numpunct<Char> >(
|
|
loc.get<std::locale>()).thousands_sep();
|
|
}
|
|
}
|
|
#else
|
|
template <typename Char>
|
|
FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
|
|
return FMT_STATIC_THOUSANDS_SEPARATOR;
|
|
}
|
|
#endif
|
|
|
|
FMT_FUNC void system_error::init(
|
|
int err_code, string_view format_str, format_args args) {
|
|
error_code_ = err_code;
|
|
memory_buffer buffer;
|
|
format_system_error(buffer, err_code, vformat(format_str, args));
|
|
std::runtime_error &base = *this;
|
|
base = std::runtime_error(to_string(buffer));
|
|
}
|
|
|
|
namespace internal {
|
|
template <typename T>
|
|
int char_traits<char>::format_float(
|
|
char *buf, std::size_t size, const char *format, int precision, T value) {
|
|
return precision < 0 ?
|
|
FMT_SNPRINTF(buf, size, format, value) :
|
|
FMT_SNPRINTF(buf, size, format, precision, value);
|
|
}
|
|
|
|
template <typename T>
|
|
int char_traits<wchar_t>::format_float(
|
|
wchar_t *buf, std::size_t size, const wchar_t *format, int precision,
|
|
T value) {
|
|
return precision < 0 ?
|
|
FMT_SWPRINTF(buf, size, format, value) :
|
|
FMT_SWPRINTF(buf, size, format, precision, value);
|
|
}
|
|
|
|
template <typename T>
|
|
const char basic_data<T>::DIGITS[] =
|
|
"0001020304050607080910111213141516171819"
|
|
"2021222324252627282930313233343536373839"
|
|
"4041424344454647484950515253545556575859"
|
|
"6061626364656667686970717273747576777879"
|
|
"8081828384858687888990919293949596979899";
|
|
|
|
#define FMT_POWERS_OF_10(factor) \
|
|
factor * 10, \
|
|
factor * 100, \
|
|
factor * 1000, \
|
|
factor * 10000, \
|
|
factor * 100000, \
|
|
factor * 1000000, \
|
|
factor * 10000000, \
|
|
factor * 100000000, \
|
|
factor * 1000000000
|
|
|
|
template <typename T>
|
|
const uint32_t basic_data<T>::POWERS_OF_10_32[] = {
|
|
1, FMT_POWERS_OF_10(1)
|
|
};
|
|
|
|
template <typename T>
|
|
const uint32_t basic_data<T>::ZERO_OR_POWERS_OF_10_32[] = {
|
|
0, FMT_POWERS_OF_10(1)
|
|
};
|
|
|
|
template <typename T>
|
|
const uint64_t basic_data<T>::ZERO_OR_POWERS_OF_10_64[] = {
|
|
0,
|
|
FMT_POWERS_OF_10(1),
|
|
FMT_POWERS_OF_10(1000000000ull),
|
|
10000000000000000000ull
|
|
};
|
|
|
|
// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
|
|
// These are generated by support/compute-powers.py.
|
|
template <typename T>
|
|
const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {
|
|
0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
|
|
0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
|
|
0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
|
|
0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
|
|
0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
|
|
0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
|
|
0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
|
|
0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
|
|
0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
|
|
0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
|
|
0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
|
|
0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
|
|
0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
|
|
0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
|
|
0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
|
|
0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
|
|
0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
|
|
0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
|
|
0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
|
|
0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
|
|
0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
|
|
0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
|
|
0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
|
|
0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
|
|
0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
|
|
0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
|
|
0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
|
|
0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
|
|
0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
|
|
};
|
|
|
|
// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
|
|
// to significands above.
|
|
template <typename T>
|
|
const int16_t basic_data<T>::POW10_EXPONENTS[] = {
|
|
-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
|
|
-927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661,
|
|
-635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369,
|
|
-343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77,
|
|
-50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216,
|
|
242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508,
|
|
534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800,
|
|
827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066
|
|
};
|
|
|
|
template <typename T> const char basic_data<T>::FOREGROUND_COLOR[] = "\x1b[38;2;";
|
|
template <typename T> const char basic_data<T>::BACKGROUND_COLOR[] = "\x1b[48;2;";
|
|
template <typename T> const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
|
|
template <typename T> const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
|
|
|
|
// A handmade floating-point number f * pow(2, e).
|
|
class fp {
|
|
private:
|
|
typedef uint64_t significand_type;
|
|
|
|
// All sizes are in bits.
|
|
static FMT_CONSTEXPR_DECL const int char_size =
|
|
std::numeric_limits<unsigned char>::digits;
|
|
// Subtract 1 to account for an implicit most significant bit in the
|
|
// normalized form.
|
|
static FMT_CONSTEXPR_DECL const int double_significand_size =
|
|
std::numeric_limits<double>::digits - 1;
|
|
static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
|
|
1ull << double_significand_size;
|
|
|
|
public:
|
|
significand_type f;
|
|
int e;
|
|
|
|
static FMT_CONSTEXPR_DECL const int significand_size =
|
|
sizeof(significand_type) * char_size;
|
|
|
|
fp(): f(0), e(0) {}
|
|
fp(uint64_t f_val, int e_val): f(f_val), e(e_val) {}
|
|
|
|
// Constructs fp from an IEEE754 double. It is a template to prevent compile
|
|
// errors on platforms where double is not IEEE754.
|
|
template <typename Double>
|
|
explicit fp(Double d) {
|
|
// Assume double is in the format [sign][exponent][significand].
|
|
typedef std::numeric_limits<Double> limits;
|
|
const int double_size = static_cast<int>(sizeof(Double) * char_size);
|
|
const int exponent_size =
|
|
double_size - double_significand_size - 1; // -1 for sign
|
|
const uint64_t significand_mask = implicit_bit - 1;
|
|
const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
|
|
const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
|
|
auto u = bit_cast<uint64_t>(d);
|
|
auto biased_e = (u & exponent_mask) >> double_significand_size;
|
|
f = u & significand_mask;
|
|
if (biased_e != 0)
|
|
f += implicit_bit;
|
|
else
|
|
biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
|
|
e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
|
|
}
|
|
|
|
// Normalizes the value converted from double and multiplied by (1 << SHIFT).
|
|
template <int SHIFT = 0>
|
|
void normalize() {
|
|
// Handle subnormals.
|
|
auto shifted_implicit_bit = implicit_bit << SHIFT;
|
|
while ((f & shifted_implicit_bit) == 0) {
|
|
f <<= 1;
|
|
--e;
|
|
}
|
|
// Subtract 1 to account for hidden bit.
|
|
auto offset = significand_size - double_significand_size - SHIFT - 1;
|
|
f <<= offset;
|
|
e -= offset;
|
|
}
|
|
|
|
// Compute lower and upper boundaries (m^- and m^+ in the Grisu paper), where
|
|
// a boundary is a value half way between the number and its predecessor
|
|
// (lower) or successor (upper). The upper boundary is normalized and lower
|
|
// has the same exponent but may be not normalized.
|
|
void compute_boundaries(fp &lower, fp &upper) const {
|
|
lower = f == implicit_bit ?
|
|
fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
|
|
upper = fp((f << 1) + 1, e - 1);
|
|
upper.normalize<1>(); // 1 is to account for the exponent shift above.
|
|
lower.f <<= lower.e - upper.e;
|
|
lower.e = upper.e;
|
|
}
|
|
};
|
|
|
|
// Returns an fp number representing x - y. Result may not be normalized.
|
|
inline fp operator-(fp x, fp y) {
|
|
FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
|
|
return fp(x.f - y.f, x.e);
|
|
}
|
|
|
|
// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
|
|
// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be normalized.
|
|
FMT_API fp operator*(fp x, fp y);
|
|
|
|
// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its
|
|
// (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 3.
|
|
FMT_API fp get_cached_power(int min_exponent, int &pow10_exponent);
|
|
|
|
FMT_FUNC fp operator*(fp x, fp y) {
|
|
// Multiply 32-bit parts of significands.
|
|
uint64_t mask = (1ULL << 32) - 1;
|
|
uint64_t a = x.f >> 32, b = x.f & mask;
|
|
uint64_t c = y.f >> 32, d = y.f & mask;
|
|
uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
|
|
// Compute mid 64-bit of result and round.
|
|
uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
|
|
return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64);
|
|
}
|
|
|
|
FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
|
|
const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10)
|
|
int index = static_cast<int>(std::ceil(
|
|
(min_exponent + fp::significand_size - 1) * one_over_log2_10));
|
|
// Decimal exponent of the first (smallest) cached power of 10.
|
|
const int first_dec_exp = -348;
|
|
// Difference between 2 consecutive decimal exponents in cached powers of 10.
|
|
const int dec_exp_step = 8;
|
|
index = (index - first_dec_exp - 1) / dec_exp_step + 1;
|
|
pow10_exponent = first_dec_exp + index * dec_exp_step;
|
|
return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
|
|
}
|
|
|
|
FMT_FUNC bool grisu2_round(
|
|
char *buf, int &size, int max_digits, uint64_t delta,
|
|
uint64_t remainder, uint64_t exp, uint64_t diff, int &exp10) {
|
|
while (remainder < diff && delta - remainder >= exp &&
|
|
(remainder + exp < diff || diff - remainder > remainder + exp - diff)) {
|
|
--buf[size - 1];
|
|
remainder += exp;
|
|
}
|
|
if (size > max_digits) {
|
|
--size;
|
|
++exp10;
|
|
if (buf[size] >= '5')
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Generates output using Grisu2 digit-gen algorithm.
|
|
FMT_FUNC bool grisu2_gen_digits(
|
|
char *buf, int &size, uint32_t hi, uint64_t lo, int &exp,
|
|
uint64_t delta, const fp &one, const fp &diff, int max_digits) {
|
|
// Generate digits for the most significant part (hi).
|
|
while (exp > 0) {
|
|
uint32_t digit = 0;
|
|
// This optimization by miloyip reduces the number of integer divisions by
|
|
// one per iteration.
|
|
switch (exp) {
|
|
case 10: digit = hi / 1000000000; hi %= 1000000000; break;
|
|
case 9: digit = hi / 100000000; hi %= 100000000; break;
|
|
case 8: digit = hi / 10000000; hi %= 10000000; break;
|
|
case 7: digit = hi / 1000000; hi %= 1000000; break;
|
|
case 6: digit = hi / 100000; hi %= 100000; break;
|
|
case 5: digit = hi / 10000; hi %= 10000; break;
|
|
case 4: digit = hi / 1000; hi %= 1000; break;
|
|
case 3: digit = hi / 100; hi %= 100; break;
|
|
case 2: digit = hi / 10; hi %= 10; break;
|
|
case 1: digit = hi; hi = 0; break;
|
|
default:
|
|
FMT_ASSERT(false, "invalid number of digits");
|
|
}
|
|
if (digit != 0 || size != 0)
|
|
buf[size++] = static_cast<char>('0' + digit);
|
|
--exp;
|
|
uint64_t remainder = (static_cast<uint64_t>(hi) << -one.e) + lo;
|
|
if (remainder <= delta || size > max_digits) {
|
|
return grisu2_round(
|
|
buf, size, max_digits, delta, remainder,
|
|
static_cast<uint64_t>(data::POWERS_OF_10_32[exp]) << -one.e,
|
|
diff.f, exp);
|
|
}
|
|
}
|
|
// Generate digits for the least significant part (lo).
|
|
for (;;) {
|
|
lo *= 10;
|
|
delta *= 10;
|
|
char digit = static_cast<char>(lo >> -one.e);
|
|
if (digit != 0 || size != 0)
|
|
buf[size++] = static_cast<char>('0' + digit);
|
|
lo &= one.f - 1;
|
|
--exp;
|
|
if (lo < delta || size > max_digits) {
|
|
return grisu2_round(buf, size, max_digits, delta, lo, one.f,
|
|
diff.f * data::POWERS_OF_10_32[-exp], exp);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if FMT_CLANG_VERSION
|
|
# define FMT_FALLTHROUGH [[clang::fallthrough]];
|
|
#elif FMT_GCC_VERSION >= 700
|
|
# define FMT_FALLTHROUGH [[gnu::fallthrough]];
|
|
#else
|
|
# define FMT_FALLTHROUGH
|
|
#endif
|
|
|
|
struct gen_digits_params {
|
|
int num_digits;
|
|
bool fixed;
|
|
bool upper;
|
|
bool trailing_zeros;
|
|
};
|
|
|
|
struct prettify_handler {
|
|
char *data;
|
|
ptrdiff_t size;
|
|
buffer &buf;
|
|
|
|
explicit prettify_handler(buffer &b, ptrdiff_t n)
|
|
: data(b.data()), size(n), buf(b) {}
|
|
~prettify_handler() {
|
|
assert(buf.size() >= to_unsigned(size));
|
|
buf.resize(to_unsigned(size));
|
|
}
|
|
|
|
template <typename F>
|
|
void insert(ptrdiff_t pos, ptrdiff_t n, F f) {
|
|
std::memmove(data + pos + n, data + pos, to_unsigned(size - pos));
|
|
f(data + pos);
|
|
size += n;
|
|
}
|
|
|
|
void insert(ptrdiff_t pos, char c) {
|
|
std::memmove(data + pos + 1, data + pos, to_unsigned(size - pos));
|
|
data[pos] = c;
|
|
++size;
|
|
}
|
|
|
|
void append(ptrdiff_t n, char c) {
|
|
std::uninitialized_fill_n(data + size, n, c);
|
|
size += n;
|
|
}
|
|
|
|
void append(char c) { data[size++] = c; }
|
|
|
|
void remove_trailing(char c) {
|
|
while (data[size - 1] == c) --size;
|
|
}
|
|
};
|
|
|
|
// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
|
|
template <typename Handler>
|
|
FMT_FUNC void write_exponent(int exp, Handler &&h) {
|
|
FMT_ASSERT(-1000 < exp && exp < 1000, "exponent out of range");
|
|
if (exp < 0) {
|
|
h.append('-');
|
|
exp = -exp;
|
|
} else {
|
|
h.append('+');
|
|
}
|
|
if (exp >= 100) {
|
|
h.append(static_cast<char>('0' + exp / 100));
|
|
exp %= 100;
|
|
const char *d = data::DIGITS + exp * 2;
|
|
h.append(d[0]);
|
|
h.append(d[1]);
|
|
} else {
|
|
const char *d = data::DIGITS + exp * 2;
|
|
h.append(d[0]);
|
|
h.append(d[1]);
|
|
}
|
|
}
|
|
|
|
struct fill {
|
|
size_t n;
|
|
void operator()(char *buf) const {
|
|
buf[0] = '0';
|
|
buf[1] = '.';
|
|
std::uninitialized_fill_n(buf + 2, n, '0');
|
|
}
|
|
};
|
|
|
|
// The number is given as v = f * pow(10, exp), where f has size digits.
|
|
template <typename Handler>
|
|
FMT_FUNC void grisu2_prettify(const gen_digits_params ¶ms,
|
|
int size, int exp, Handler &&handler) {
|
|
if (!params.fixed) {
|
|
// Insert a decimal point after the first digit and add an exponent.
|
|
handler.insert(1, '.');
|
|
exp += size - 1;
|
|
if (size < params.num_digits)
|
|
handler.append(params.num_digits - size, '0');
|
|
handler.append(params.upper ? 'E' : 'e');
|
|
write_exponent(exp, handler);
|
|
return;
|
|
}
|
|
// pow(10, full_exp - 1) <= v <= pow(10, full_exp).
|
|
int full_exp = size + exp;
|
|
const int exp_threshold = 21;
|
|
if (size <= full_exp && full_exp <= exp_threshold) {
|
|
// 1234e7 -> 12340000000[.0+]
|
|
handler.append(full_exp - size, '0');
|
|
int num_zeros = params.num_digits - full_exp;
|
|
if (num_zeros > 0 && params.trailing_zeros) {
|
|
handler.append('.');
|
|
handler.append(num_zeros, '0');
|
|
}
|
|
} else if (full_exp > 0) {
|
|
// 1234e-2 -> 12.34[0+]
|
|
handler.insert(full_exp, '.');
|
|
if (!params.trailing_zeros) {
|
|
// Remove trailing zeros.
|
|
handler.remove_trailing('0');
|
|
} else if (params.num_digits > size) {
|
|
// Add trailing zeros.
|
|
ptrdiff_t num_zeros = params.num_digits - size;
|
|
handler.append(num_zeros, '0');
|
|
}
|
|
} else {
|
|
// 1234e-6 -> 0.001234
|
|
handler.insert(0, 2 - full_exp, fill{to_unsigned(-full_exp)});
|
|
}
|
|
}
|
|
|
|
struct char_counter {
|
|
ptrdiff_t size;
|
|
|
|
template <typename F>
|
|
void insert(ptrdiff_t, ptrdiff_t n, F) { size += n; }
|
|
void insert(ptrdiff_t, char) { ++size; }
|
|
void append(ptrdiff_t n, char) { size += n; }
|
|
void append(char) { ++size; }
|
|
void remove_trailing(char) {}
|
|
};
|
|
|
|
// Converts format specifiers into parameters for digit generation and computes
|
|
// output buffer size for a number in the range [pow(10, exp - 1), pow(10, exp)
|
|
// or 0 if exp == 1.
|
|
FMT_FUNC gen_digits_params process_specs(const core_format_specs &specs,
|
|
int exp, buffer &buf) {
|
|
auto params = gen_digits_params();
|
|
int num_digits = specs.precision >= 0 ? specs.precision : 6;
|
|
switch (specs.type) {
|
|
case 'G':
|
|
params.upper = true;
|
|
FMT_FALLTHROUGH
|
|
case '\0': case 'g':
|
|
params.trailing_zeros = (specs.flags & HASH_FLAG) != 0;
|
|
if (-4 <= exp && exp < num_digits + 1) {
|
|
params.fixed = true;
|
|
if (!specs.type && params.trailing_zeros && exp >= 0)
|
|
num_digits = exp + 1;
|
|
}
|
|
break;
|
|
case 'F':
|
|
params.upper = true;
|
|
FMT_FALLTHROUGH
|
|
case 'f': {
|
|
params.fixed = true;
|
|
params.trailing_zeros = true;
|
|
int adjusted_min_digits = num_digits + exp;
|
|
if (adjusted_min_digits > 0)
|
|
num_digits = adjusted_min_digits;
|
|
break;
|
|
}
|
|
case 'E':
|
|
params.upper = true;
|
|
FMT_FALLTHROUGH
|
|
case 'e':
|
|
++num_digits;
|
|
break;
|
|
}
|
|
params.num_digits = num_digits;
|
|
char_counter counter{num_digits};
|
|
grisu2_prettify(params, params.num_digits, exp - num_digits, counter);
|
|
buf.resize(to_unsigned(counter.size));
|
|
return params;
|
|
}
|
|
|
|
template <typename Double>
|
|
FMT_FUNC typename std::enable_if<sizeof(Double) == sizeof(uint64_t), bool>::type
|
|
grisu2_format(Double value, buffer &buf, core_format_specs specs) {
|
|
FMT_ASSERT(value >= 0, "value is negative");
|
|
if (value == 0) {
|
|
gen_digits_params params = process_specs(specs, 1, buf);
|
|
const size_t size = 1;
|
|
buf[0] = '0';
|
|
grisu2_prettify(params, size, 0, prettify_handler(buf, size));
|
|
return true;
|
|
}
|
|
|
|
fp fp_value(value);
|
|
fp lower, upper; // w^- and w^+ in the Grisu paper.
|
|
fp_value.compute_boundaries(lower, upper);
|
|
|
|
// Find a cached power of 10 close to 1 / upper and use it to scale upper.
|
|
const int min_exp = -60; // alpha in Grisu.
|
|
int cached_exp = 0; // K in Grisu.
|
|
auto cached_pow = get_cached_power( // \tilde{c}_{-k} in Grisu.
|
|
min_exp - (upper.e + fp::significand_size), cached_exp);
|
|
cached_exp = -cached_exp;
|
|
upper = upper * cached_pow; // \tilde{M}^+ in Grisu.
|
|
--upper.f; // \tilde{M}^+ - 1 ulp -> M^+_{\downarrow}.
|
|
fp one(1ull << -upper.e, upper.e);
|
|
// hi (p1 in Grisu) contains the most significant digits of scaled_upper.
|
|
// hi = floor(upper / one).
|
|
uint32_t hi = static_cast<uint32_t>(upper.f >> -one.e);
|
|
int exp = count_digits(hi); // kappa in Grisu.
|
|
gen_digits_params params = process_specs(specs, cached_exp + exp, buf);
|
|
fp_value.normalize();
|
|
fp scaled_value = fp_value * cached_pow;
|
|
lower = lower * cached_pow; // \tilde{M}^- in Grisu.
|
|
++lower.f; // \tilde{M}^- + 1 ulp -> M^-_{\uparrow}.
|
|
uint64_t delta = upper.f - lower.f;
|
|
fp diff = upper - scaled_value; // wp_w in Grisu.
|
|
// lo (p2 in Grisu) contains the least significants digits of scaled_upper.
|
|
// lo = supper % one.
|
|
uint64_t lo = upper.f & (one.f - 1);
|
|
int size = 0;
|
|
if (!grisu2_gen_digits(buf.data(), size, hi, lo, exp, delta, one, diff,
|
|
params.num_digits)) {
|
|
buf.clear();
|
|
return false;
|
|
}
|
|
grisu2_prettify(params, size, cached_exp + exp, prettify_handler(buf, size));
|
|
return true;
|
|
}
|
|
|
|
template <typename Double>
|
|
void sprintf_format(Double value, internal::buffer &buf,
|
|
core_format_specs spec) {
|
|
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
|
|
FMT_ASSERT(buf.capacity() != 0, "empty buffer");
|
|
|
|
// Build format string.
|
|
enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
|
|
char format[MAX_FORMAT_SIZE];
|
|
char *format_ptr = format;
|
|
*format_ptr++ = '%';
|
|
if (spec.has(HASH_FLAG))
|
|
*format_ptr++ = '#';
|
|
if (spec.precision >= 0) {
|
|
*format_ptr++ = '.';
|
|
*format_ptr++ = '*';
|
|
}
|
|
if (std::is_same<Double, long double>::value)
|
|
*format_ptr++ = 'L';
|
|
*format_ptr++ = spec.type;
|
|
*format_ptr = '\0';
|
|
|
|
// Format using snprintf.
|
|
char *start = FMT_NULL;
|
|
for (;;) {
|
|
std::size_t buffer_size = buf.capacity();
|
|
start = &buf[0];
|
|
int result = internal::char_traits<char>::format_float(
|
|
start, buffer_size, format, spec.precision, value);
|
|
if (result >= 0) {
|
|
unsigned n = internal::to_unsigned(result);
|
|
if (n < buf.capacity()) {
|
|
buf.resize(n);
|
|
break; // The buffer is large enough - continue with formatting.
|
|
}
|
|
buf.reserve(n + 1);
|
|
} else {
|
|
// If result is negative we ask to increase the capacity by at least 1,
|
|
// but as std::vector, the buffer grows exponentially.
|
|
buf.reserve(buf.capacity() + 1);
|
|
}
|
|
}
|
|
}
|
|
} // namespace internal
|
|
|
|
#if FMT_USE_WINDOWS_H
|
|
|
|
FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
|
|
static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
|
|
if (s.size() > INT_MAX)
|
|
FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
|
|
int s_size = static_cast<int>(s.size());
|
|
if (s_size == 0) {
|
|
// MultiByteToWideChar does not support zero length, handle separately.
|
|
buffer_.resize(1);
|
|
buffer_[0] = 0;
|
|
return;
|
|
}
|
|
|
|
int length = MultiByteToWideChar(
|
|
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
|
|
if (length == 0)
|
|
FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
|
|
buffer_.resize(length + 1);
|
|
length = MultiByteToWideChar(
|
|
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
|
|
if (length == 0)
|
|
FMT_THROW(windows_error(GetLastError(), ERROR_MSG));
|
|
buffer_[length] = 0;
|
|
}
|
|
|
|
FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
|
|
if (int error_code = convert(s)) {
|
|
FMT_THROW(windows_error(error_code,
|
|
"cannot convert string from UTF-16 to UTF-8"));
|
|
}
|
|
}
|
|
|
|
FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
|
|
if (s.size() > INT_MAX)
|
|
return ERROR_INVALID_PARAMETER;
|
|
int s_size = static_cast<int>(s.size());
|
|
if (s_size == 0) {
|
|
// WideCharToMultiByte does not support zero length, handle separately.
|
|
buffer_.resize(1);
|
|
buffer_[0] = 0;
|
|
return 0;
|
|
}
|
|
|
|
int length = WideCharToMultiByte(
|
|
CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
|
|
if (length == 0)
|
|
return GetLastError();
|
|
buffer_.resize(length + 1);
|
|
length = WideCharToMultiByte(
|
|
CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
|
|
if (length == 0)
|
|
return GetLastError();
|
|
buffer_[length] = 0;
|
|
return 0;
|
|
}
|
|
|
|
FMT_FUNC void windows_error::init(
|
|
int err_code, string_view format_str, format_args args) {
|
|
error_code_ = err_code;
|
|
memory_buffer buffer;
|
|
internal::format_windows_error(buffer, err_code, vformat(format_str, args));
|
|
std::runtime_error &base = *this;
|
|
base = std::runtime_error(to_string(buffer));
|
|
}
|
|
|
|
FMT_FUNC void internal::format_windows_error(
|
|
internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
|
|
FMT_TRY {
|
|
wmemory_buffer buf;
|
|
buf.resize(inline_buffer_size);
|
|
for (;;) {
|
|
wchar_t *system_message = &buf[0];
|
|
int result = FormatMessageW(
|
|
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
|
|
if (result != 0) {
|
|
utf16_to_utf8 utf8_message;
|
|
if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
|
|
writer w(out);
|
|
w.write(message);
|
|
w.write(": ");
|
|
w.write(utf8_message);
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
|
|
break; // Can't get error message, report error code instead.
|
|
buf.resize(buf.size() * 2);
|
|
}
|
|
} FMT_CATCH(...) {}
|
|
format_error_code(out, error_code, message);
|
|
}
|
|
|
|
#endif // FMT_USE_WINDOWS_H
|
|
|
|
FMT_FUNC void format_system_error(
|
|
internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
|
|
FMT_TRY {
|
|
memory_buffer buf;
|
|
buf.resize(inline_buffer_size);
|
|
for (;;) {
|
|
char *system_message = &buf[0];
|
|
int result = safe_strerror(error_code, system_message, buf.size());
|
|
if (result == 0) {
|
|
writer w(out);
|
|
w.write(message);
|
|
w.write(": ");
|
|
w.write(system_message);
|
|
return;
|
|
}
|
|
if (result != ERANGE)
|
|
break; // Can't get error message, report error code instead.
|
|
buf.resize(buf.size() * 2);
|
|
}
|
|
} FMT_CATCH(...) {}
|
|
format_error_code(out, error_code, message);
|
|
}
|
|
|
|
FMT_FUNC void internal::error_handler::on_error(const char *message) {
|
|
FMT_THROW(format_error(message));
|
|
}
|
|
|
|
FMT_FUNC void report_system_error(
|
|
int error_code, fmt::string_view message) FMT_NOEXCEPT {
|
|
report_error(format_system_error, error_code, message);
|
|
}
|
|
|
|
#if FMT_USE_WINDOWS_H
|
|
FMT_FUNC void report_windows_error(
|
|
int error_code, fmt::string_view message) FMT_NOEXCEPT {
|
|
report_error(internal::format_windows_error, error_code, message);
|
|
}
|
|
#endif
|
|
|
|
FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) {
|
|
memory_buffer buffer;
|
|
internal::vformat_to(buffer, format_str,
|
|
basic_format_args<buffer_context<char>::type>(args));
|
|
std::fwrite(buffer.data(), 1, buffer.size(), f);
|
|
}
|
|
|
|
FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) {
|
|
wmemory_buffer buffer;
|
|
internal::vformat_to(buffer, format_str, args);
|
|
std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f);
|
|
}
|
|
|
|
FMT_FUNC void vprint(string_view format_str, format_args args) {
|
|
vprint(stdout, format_str, args);
|
|
}
|
|
|
|
FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
|
|
vprint(stdout, format_str, args);
|
|
}
|
|
|
|
FMT_END_NAMESPACE
|
|
|
|
#ifdef _MSC_VER
|
|
# pragma warning(pop)
|
|
#endif
|
|
|
|
#endif // FMT_FORMAT_INL_H_
|