Skip to content

S
spdlog
Commit 7b3fc4ba authored by gabime's avatar gabime
Browse files
Options

updated to latest cppformat

parent cbc8ba72
Hide whitespace changes
Inline Side-by-side
Showing with 969 additions and 877 deletions
include/spdlog/details/format.cc
View file @ 7b3fc4ba
/* /*
Formatting library for C++ Formatting library for C++
Copyright (c) 2012 - 2015, Victor Zverovich Copyright (c) 2012 - 2015, Victor Zverovich
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, with or without Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met: modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this 1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer. list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, 2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution. and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 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 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 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 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "format.h" #include "format.h"
...@@ -34,6 +34,7 @@ ...@@ -34,6 +34,7 @@
#include <climits> #include <climits>
#include <cmath> #include <cmath>
#include <cstdarg> #include <cstdarg>
#include <cstddef> // for std::ptrdiff_t
#if defined(_WIN32) && defined(__MINGW32__) #if defined(_WIN32) && defined(__MINGW32__)
# include <cstring> # include <cstring>
...@@ -96,10 +97,10 @@ using fmt::internal::Arg; ...@@ -96,10 +97,10 @@ using fmt::internal::Arg;
// Dummy implementations of strerror_r and strerror_s called if corresponding // Dummy implementations of strerror_r and strerror_s called if corresponding
// system functions are not available. // system functions are not available.
static inline fmt::internal::Null<> strerror_r(int, char *, ...) { static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
return fmt::internal::Null<>(); return fmt::internal::Null<>();
} }
static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) { static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
return fmt::internal::Null<>(); return fmt::internal::Null<>();
} }
namespace fmt { namespace fmt {
...@@ -109,11 +110,11 @@ namespace { ...@@ -109,11 +110,11 @@ namespace {
# define FMT_SNPRINTF snprintf # define FMT_SNPRINTF snprintf
#else // _MSC_VER #else // _MSC_VER
inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) { inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
va_end(args); va_end(args);
return result; return result;
} }
# define FMT_SNPRINTF fmt_snprintf # define FMT_SNPRINTF fmt_snprintf
#endif // _MSC_VER #endif // _MSC_VER
...@@ -128,26 +129,30 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) { ...@@ -128,26 +129,30 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
// signed and unsigned integers. // signed and unsigned integers.
template <bool IsSigned> template <bool IsSigned>
struct IntChecker { struct IntChecker {
template <typename T> template <typename T>
static bool fits_in_int(T value) { static bool fits_in_int(T value) {
unsigned max = INT_MAX; unsigned max = INT_MAX;
return value <= max; return value <= max;
} }
static bool fits_in_int(bool) { return true; } static bool fits_in_int(bool) {
return true;
}
}; };
template <> template <>
struct IntChecker<true> { struct IntChecker<true> {
template <typename T> template <typename T>
static bool fits_in_int(T value) { static bool fits_in_int(T value) {
return value >= INT_MIN && value <= INT_MAX; return value >= INT_MIN && value <= INT_MAX;
} }
static bool fits_in_int(int) { return true; } static bool fits_in_int(int) {
return true;
}
}; };
const char RESET_COLOR[] = "\x1b[0m"; const char RESET_COLOR[] = "\x1b[0m";
typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef); typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
// Portable thread-safe version of strerror. // Portable thread-safe version of strerror.
// Sets buffer to point to a string describing the error code. // Sets buffer to point to a string describing the error code.
...@@ -159,243 +164,253 @@ typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef); ...@@ -159,243 +164,253 @@ typedef void (*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
// other - failure // other - failure
// Buffer should be at least of size 1. // Buffer should be at least of size 1.
int safe_strerror( int safe_strerror(
int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT { int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT{
FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer"); FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");
class StrError { class StrError {
private: private:
int error_code_; int error_code_;
char *&buffer_; char *&buffer_;
std::size_t buffer_size_; std::size_t buffer_size_;
// A noop assignment operator to avoid bogus warnings. // A noop assignment operator to avoid bogus warnings.
void operator=(const StrError &) {} void operator=(const StrError &) {}
// Handle the result of XSI-compliant version of strerror_r. // Handle the result of XSI-compliant version of strerror_r.
int handle(int result) { int handle(int result) {
// glibc versions before 2.13 return result in errno. // glibc versions before 2.13 return result in errno.
return result == -1 ? errno : result; return result == -1 ? errno : result;
} }
// Handle the result of GNU-specific version of strerror_r. // Handle the result of GNU-specific version of strerror_r.
int handle(char *message) { int handle(char *message) {
// If the buffer is full then the message is probably truncated. // If the buffer is full then the message is probably truncated.
if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1) if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
return ERANGE; return ERANGE;
buffer_ = message; buffer_ = message;
return 0; return 0;
} }
// Handle the case when strerror_r is not available. // Handle the case when strerror_r is not available.
int handle(fmt::internal::Null<>) { int handle(fmt::internal::Null<>) {
return fallback(strerror_s(buffer_, buffer_size_, error_code_)); return fallback(strerror_s(buffer_, buffer_size_, error_code_));
} }
// Fallback to strerror_s when strerror_r is not available. // Fallback to strerror_s when strerror_r is not available.
int fallback(int result) { int fallback(int result) {
// If the buffer is full then the message is probably truncated. // If the buffer is full then the message is probably truncated.
return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
ERANGE : result; ERANGE : result;
} }
// Fallback to strerror if strerror_r and strerror_s are not available. // Fallback to strerror if strerror_r and strerror_s are not available.
int fallback(fmt::internal::Null<>) { int fallback(fmt::internal::Null<>) {
errno = 0; errno = 0;
buffer_ = strerror(error_code_); buffer_ = strerror(error_code_);
return errno; return errno;
} }
public: public:
StrError(int err_code, char *&buf, std::size_t buf_size) StrError(int err_code, char *&buf, std::size_t buf_size)
: error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {} : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
int run() { int run() {
strerror_r(0, 0, ""); // Suppress a warning about unused strerror_r. strerror_r(0, 0, ""); // Suppress a warning about unused strerror_r.
return handle(strerror_r(error_code_, buffer_, buffer_size_)); return handle(strerror_r(error_code_, buffer_, buffer_size_));
} }
}; };
return StrError(error_code, buffer, buffer_size).run(); return StrError(error_code, buffer, buffer_size).run();
} }
void format_error_code(fmt::Writer &out, int error_code, void format_error_code(fmt::Writer &out, int error_code,
fmt::StringRef message) FMT_NOEXCEPT { fmt::StringRef message) FMT_NOEXCEPT{
// Report error code making sure that the output fits into // Report error code making sure that the output fits into
// INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
// bad_alloc. // bad_alloc.
out.clear(); out.clear();
static const char SEP[] = ": "; static const char SEP[] = ": ";
static const char ERROR_STR[] = "error "; static const char ERROR_STR[] = "error ";
fmt::internal::IntTraits<int>::MainType ec_value = error_code; fmt::internal::IntTraits<int>::MainType ec_value = error_code;
// Subtract 2 to account for terminating null characters in SEP and ERROR_STR. // 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; std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
error_code_size += fmt::internal::count_digits(ec_value); error_code_size += fmt::internal::count_digits(ec_value);
if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size) if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)
out << message << SEP; out << message << SEP;
out << ERROR_STR << error_code; out << ERROR_STR << error_code;
assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE); assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);
} }
void report_error(FormatFunc func, void report_error(FormatFunc func,
int error_code, fmt::StringRef message) FMT_NOEXCEPT { int error_code, fmt::StringRef message) FMT_NOEXCEPT{
fmt::MemoryWriter full_message; fmt::MemoryWriter full_message;
func(full_message, error_code, message); func(full_message, error_code, message);
// Use Writer::data instead of Writer::c_str to avoid potential memory // Use Writer::data instead of Writer::c_str to avoid potential memory
// allocation. // allocation.
std::fwrite(full_message.data(), full_message.size(), 1, stderr); std::fwrite(full_message.data(), full_message.size(), 1, stderr);
std::fputc('\n', stderr); std::fputc('\n', stderr);
} }
// IsZeroInt::visit(arg) returns true iff arg is a zero integer. // IsZeroInt::visit(arg) returns true iff arg is a zero integer.
class IsZeroInt : public fmt::internal::ArgVisitor<IsZeroInt, bool> { class IsZeroInt : public fmt::internal::ArgVisitor<IsZeroInt, bool> {
public: public:
template <typename T> template <typename T>
bool visit_any_int(T value) { return value == 0; } bool visit_any_int(T value) {
return value == 0;
}
}; };
// Parses an unsigned integer advancing s to the end of the parsed input. // 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. // This function assumes that the first character of s is a digit.
template <typename Char> template <typename Char>
int parse_nonnegative_int(const Char *&s) { int parse_nonnegative_int(const Char *&s) {
assert('0' <= *s && *s <= '9'); assert('0' <= *s && *s <= '9');
unsigned value = 0; unsigned value = 0;
do { do {
unsigned new_value = value * 10 + (*s++ - '0'); unsigned new_value = value * 10 + (*s++ - '0');
// Check if value wrapped around. // Check if value wrapped around.
if (new_value < value) { if (new_value < value) {
value = UINT_MAX; value = UINT_MAX;
break; break;
} }
value = new_value; value = new_value;
} while ('0' <= *s && *s <= '9'); } while ('0' <= *s && *s <= '9');
if (value > INT_MAX) if (value > INT_MAX)
FMT_THROW(fmt::FormatError("number is too big")); FMT_THROW(fmt::FormatError("number is too big"));
return value; return value;
} }
template <typename Char> template <typename Char>
inline bool is_name_start(Char c) { inline bool is_name_start(Char c) {
return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
} }
inline void require_numeric_argument(const Arg &arg, char spec) { inline void require_numeric_argument(const Arg &arg, char spec) {
if (arg.type > Arg::LAST_NUMERIC_TYPE) { if (arg.type > Arg::LAST_NUMERIC_TYPE) {
std::string message = std::string message =
fmt::format("format specifier '{}' requires numeric argument", spec); fmt::format("format specifier '{}' requires numeric argument", spec);
FMT_THROW(fmt::FormatError(message)); FMT_THROW(fmt::FormatError(message));
} }
} }
template <typename Char> template <typename Char>
void check_sign(const Char *&s, const Arg &arg) { void check_sign(const Char *&s, const Arg &arg) {
char sign = static_cast<char>(*s); char sign = static_cast<char>(*s);
require_numeric_argument(arg, sign); require_numeric_argument(arg, sign);
if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) { if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
FMT_THROW(fmt::FormatError(fmt::format( FMT_THROW(fmt::FormatError(fmt::format(
"format specifier '{}' requires signed argument", sign))); "format specifier '{}' requires signed argument", sign)));
} }
++s; ++s;
} }
// Checks if an argument is a valid printf width specifier and sets // Checks if an argument is a valid printf width specifier and sets
// left alignment if it is negative. // left alignment if it is negative.
class WidthHandler : public fmt::internal::ArgVisitor<WidthHandler, unsigned> { class WidthHandler : public fmt::internal::ArgVisitor<WidthHandler, unsigned> {
private: private:
fmt::FormatSpec &spec_; fmt::FormatSpec &spec_;
FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler); FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
public: public:
explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {} explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}
void report_unhandled_arg() { void report_unhandled_arg() {
FMT_THROW(fmt::FormatError("width is not integer")); FMT_THROW(fmt::FormatError("width is not integer"));
} }
template <typename T> template <typename T>
unsigned visit_any_int(T value) { unsigned visit_any_int(T value) {
typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType; typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType;
UnsignedType width = value; UnsignedType width = value;
if (fmt::internal::is_negative(value)) { if (fmt::internal::is_negative(value)) {
spec_.align_ = fmt::ALIGN_LEFT; spec_.align_ = fmt::ALIGN_LEFT;
width = 0 - width; width = 0 - width;
}
if (width > INT_MAX)
FMT_THROW(fmt::FormatError("number is too big"));
return static_cast<unsigned>(width);
} }
if (width > INT_MAX)
FMT_THROW(fmt::FormatError("number is too big"));
return static_cast<unsigned>(width);
}
}; };
class PrecisionHandler : class PrecisionHandler :
public fmt::internal::ArgVisitor<PrecisionHandler, int> { public fmt::internal::ArgVisitor<PrecisionHandler, int> {
public: public:
void report_unhandled_arg() { void report_unhandled_arg() {
FMT_THROW(fmt::FormatError("precision is not integer")); FMT_THROW(fmt::FormatError("precision is not integer"));
} }
template <typename T> template <typename T>
int visit_any_int(T value) { int visit_any_int(T value) {
if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value)) if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
FMT_THROW(fmt::FormatError("number is too big")); FMT_THROW(fmt::FormatError("number is too big"));
return static_cast<int>(value); return static_cast<int>(value);
} }
}; };
// Converts an integer argument to an integral type T for printf. // Converts an integer argument to an integral type T for printf.
template <typename T> template <typename T>
class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> { class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
private: private:
fmt::internal::Arg &arg_; fmt::internal::Arg &arg_;
wchar_t type_; wchar_t type_;
FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter); FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
public: public:
ArgConverter(fmt::internal::Arg &arg, wchar_t type) ArgConverter(fmt::internal::Arg &arg, wchar_t type)
: arg_(arg), type_(type) {} : arg_(arg), type_(type) {}
template <typename U> void visit_bool(bool value) {
void visit_any_int(U value) { if (type_ != 's')
bool is_signed = type_ == 'd' || type_ == 'i'; visit_any_int(value);
using fmt::internal::Arg; }
if (sizeof(T) <= sizeof(int)) {
// Extra casts are used to silence warnings. template <typename U>
if (is_signed) { void visit_any_int(U value) {
arg_.type = Arg::INT; bool is_signed = type_ == 'd' || type_ == 'i';
arg_.int_value = static_cast<int>(static_cast<T>(value)); using fmt::internal::Arg;
} else { if (sizeof(T) <= sizeof(int)) {
arg_.type = Arg::UINT; // Extra casts are used to silence warnings.
arg_.uint_value = static_cast<unsigned>( if (is_signed) {
static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value)); arg_.type = Arg::INT;
} arg_.int_value = static_cast<int>(static_cast<T>(value));
} else { }
if (is_signed) { else {
arg_.type = Arg::LONG_LONG; arg_.type = Arg::UINT;
arg_.long_long_value = arg_.uint_value = static_cast<unsigned>(
static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value); static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));
} else { }
arg_.type = Arg::ULONG_LONG; }
arg_.ulong_long_value = else {
static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value); if (is_signed) {
} arg_.type = Arg::LONG_LONG;
arg_.long_long_value =
static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
}
else {
arg_.type = Arg::ULONG_LONG;
arg_.ulong_long_value =
static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
}
}
} }
}
}; };
// Converts an integer argument to char for printf. // Converts an integer argument to char for printf.
class CharConverter : public fmt::internal::ArgVisitor<CharConverter, void> { class CharConverter : public fmt::internal::ArgVisitor<CharConverter, void> {
private: private:
fmt::internal::Arg &arg_; fmt::internal::Arg &arg_;
FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter); FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
public: public:
explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {} explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}
template <typename T> template <typename T>
void visit_any_int(T value) { void visit_any_int(T value) {
arg_.type = Arg::CHAR; arg_.type = Arg::CHAR;
arg_.int_value = static_cast<char>(value); arg_.int_value = static_cast<char>(value);
} }
}; };
} // namespace } // namespace
...@@ -403,175 +418,237 @@ namespace internal { ...@@ -403,175 +418,237 @@ namespace internal {
template <typename Impl, typename Char> template <typename Impl, typename Char>
class BasicArgFormatter : public ArgVisitor<Impl, void> { class BasicArgFormatter : public ArgVisitor<Impl, void> {
private: private:
BasicWriter<Char> &writer_; BasicWriter<Char> &writer_;
FormatSpec &spec_; FormatSpec &spec_;
FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter);
void write_pointer(const void *p) {
spec_.flags_ = HASH_FLAG;
spec_.type_ = 'x';
writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
}
protected:
BasicWriter<Char> &writer() {
return writer_;
}
FormatSpec &spec() {
return spec_;
}
void write(bool value) {
const char *str_value = value ? "true" : "false";
Arg::StringValue<char> str = { str_value, strlen(str_value) };
writer_.write_str(str, spec_);
}
void write(const char *value) {
Arg::StringValue<char> str = { value, value != 0 ? strlen(value) : 0 };
writer_.write_str(str, spec_);
}
public:
BasicArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
: writer_(w), spec_(s) {}
FMT_DISALLOW_COPY_AND_ASSIGN(BasicArgFormatter); template <typename T>
void visit_any_int(T value) {
writer_.write_int(value, spec_);
}
protected: template <typename T>
BasicWriter<Char> &writer() { return writer_; } void visit_any_double(T value) {
const FormatSpec &spec() const { return spec_; } writer_.write_double(value, spec_);
}
public: void visit_bool(bool value) {
BasicArgFormatter(BasicWriter<Char> &w, FormatSpec &s) if (spec_.type_)
: writer_(w), spec_(s) {} return visit_any_int(value);
write(value);
}
template <typename T> void visit_char(int value) {
void visit_any_int(T value) { writer_.write_int(value, spec_); } if (spec_.type_ && spec_.type_ != 'c') {
spec_.flags_ |= CHAR_FLAG;
writer_.write_int(value, spec_);
return;
}
if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
FMT_THROW(FormatError("invalid format specifier for char"));
typedef typename BasicWriter<Char>::CharPtr CharPtr;
Char fill = internal::CharTraits<Char>::cast(spec_.fill());
CharPtr out = CharPtr();
const unsigned CHAR_WIDTH = 1;
if (spec_.width_ > CHAR_WIDTH) {
out = writer_.grow_buffer(spec_.width_);
if (spec_.align_ == ALIGN_RIGHT) {
std::fill_n(out, spec_.width_ - CHAR_WIDTH, fill);
out += spec_.width_ - CHAR_WIDTH;
}
else if (spec_.align_ == ALIGN_CENTER) {
out = writer_.fill_padding(out, spec_.width_,
internal::check(CHAR_WIDTH), fill);
}
else {
std::fill_n(out + CHAR_WIDTH, spec_.width_ - CHAR_WIDTH, fill);
}
}
else {
out = writer_.grow_buffer(CHAR_WIDTH);
}
*out = internal::CharTraits<Char>::cast(value);
}
template <typename T> void visit_cstring(const char *value) {
void visit_any_double(T value) { writer_.write_double(value, spec_); } if (spec_.type_ == 'p')
return write_pointer(value);
write(value);
}
void visit_bool(bool value) { void visit_string(Arg::StringValue<char> value) {
if (spec_.type_) { writer_.write_str(value, spec_);
writer_.write_int(value, spec_);
return;
} }
const char *str_value = value ? "true" : "false";
Arg::StringValue<char> str = { str_value, strlen(str_value) }; using ArgVisitor<Impl, void>::visit_wstring;
writer_.write_str(str, spec_);
} void visit_wstring(Arg::StringValue<Char> value) {
writer_.write_str(value, spec_);
void visit_char(int value) {
if (spec_.type_ && spec_.type_ != 'c') {
spec_.flags_ |= CHAR_FLAG;
writer_.write_int(value, spec_);
return;
} }
if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
FMT_THROW(FormatError("invalid format specifier for char")); void visit_pointer(const void *value) {
typedef typename BasicWriter<Char>::CharPtr CharPtr; if (spec_.type_ && spec_.type_ != 'p')
Char fill = internal::CharTraits<Char>::cast(spec_.fill()); report_unknown_type(spec_.type_, "pointer");
CharPtr out = CharPtr(); write_pointer(value);
const unsigned CHAR_WIDTH = 1;
if (spec_.width_ > CHAR_WIDTH) {
out = writer_.grow_buffer(spec_.width_);
if (spec_.align_ == ALIGN_RIGHT) {
std::fill_n(out, spec_.width_ - CHAR_WIDTH, fill);
out += spec_.width_ - CHAR_WIDTH;
} else if (spec_.align_ == ALIGN_CENTER) {
out = writer_.fill_padding(out, spec_.width_,
internal::check(CHAR_WIDTH), fill);
} else {
std::fill_n(out + CHAR_WIDTH, spec_.width_ - CHAR_WIDTH, fill);
}
} else {
out = writer_.grow_buffer(CHAR_WIDTH);
} }
*out = internal::CharTraits<Char>::cast(value);
}
void visit_string(Arg::StringValue<char> value) {
writer_.write_str(value, spec_);
}
using ArgVisitor<Impl, void>::visit_wstring;
void visit_wstring(Arg::StringValue<Char> value) {
writer_.write_str(value, spec_);
}
void visit_pointer(const void *value) {
if (spec_.type_ && spec_.type_ != 'p')
report_unknown_type(spec_.type_, "pointer");
spec_.flags_ = HASH_FLAG;
spec_.type_ = 'x';
writer_.write_int(reinterpret_cast<uintptr_t>(value), spec_);
}
}; };
// An argument formatter. // An argument formatter.
template <typename Char> template <typename Char>
class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char> { class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char> {
private: private:
BasicFormatter<Char> &formatter_; BasicFormatter<Char> &formatter_;
const Char *format_; const Char *format_;
public: public:
ArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt) ArgFormatter(BasicFormatter<Char> &f, FormatSpec &s, const Char *fmt)
: BasicArgFormatter<ArgFormatter<Char>, Char>(f.writer(), s), : BasicArgFormatter<ArgFormatter<Char>, Char>(f.writer(), s),
formatter_(f), format_(fmt) {} formatter_(f), format_(fmt) {}
void visit_custom(Arg::CustomValue c) { void visit_custom(Arg::CustomValue c) {
c.format(&formatter_, c.value, &format_); c.format(&formatter_, c.value, &format_);
} }
}; };
template <typename Char> template <typename Char>
class PrintfArgFormatter : class PrintfArgFormatter :
public BasicArgFormatter<PrintfArgFormatter<Char>, Char> { public BasicArgFormatter<PrintfArgFormatter<Char>, Char> {
public:
PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s) void write_null_pointer() {
: BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {} this->spec().type_ = 0;
this->write("(nil)");
void visit_char(int value) { }
const FormatSpec &fmt_spec = this->spec();
BasicWriter<Char> &w = this->writer(); typedef BasicArgFormatter<PrintfArgFormatter<Char>, Char> Base;
if (fmt_spec.type_ && fmt_spec.type_ != 'c')
w.write_int(value, fmt_spec); public:
typedef typename BasicWriter<Char>::CharPtr CharPtr; PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
CharPtr out = CharPtr(); : BasicArgFormatter<PrintfArgFormatter<Char>, Char>(w, s) {}
if (fmt_spec.width_ > 1) {
Char fill = ' '; void visit_bool(bool value) {
out = w.grow_buffer(fmt_spec.width_); FormatSpec &fmt_spec = this->spec();
if (fmt_spec.align_ != ALIGN_LEFT) { if (fmt_spec.type_ != 's')
std::fill_n(out, fmt_spec.width_ - 1, fill); return this->visit_any_int(value);
out += fmt_spec.width_ - 1; fmt_spec.type_ = 0;
} else { this->write(value);
std::fill_n(out + 1, fmt_spec.width_ - 1, fill); }
}
} else { void visit_char(int value) {
out = w.grow_buffer(1); const FormatSpec &fmt_spec = this->spec();
BasicWriter<Char> &w = this->writer();
if (fmt_spec.type_ && fmt_spec.type_ != 'c')
w.write_int(value, fmt_spec);
typedef typename BasicWriter<Char>::CharPtr CharPtr;
CharPtr out = CharPtr();
if (fmt_spec.width_ > 1) {
Char fill = ' ';
out = w.grow_buffer(fmt_spec.width_);
if (fmt_spec.align_ != ALIGN_LEFT) {
std::fill_n(out, fmt_spec.width_ - 1, fill);
out += fmt_spec.width_ - 1;
}
else {
std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
}
}
else {
out = w.grow_buffer(1);
}
*out = static_cast<Char>(value);
}
void visit_cstring(const char *value) {
if (value)
Base::visit_cstring(value);
else if (this->spec().type_ == 'p')
write_null_pointer();
else
this->write("(null)");
}
void visit_pointer(const void *value) {
if (value)
return Base::visit_pointer(value);
this->spec().type_ = 0;
write_null_pointer();
}
void visit_custom(Arg::CustomValue c) {
BasicFormatter<Char> formatter(ArgList(), this->writer());
const Char format_str[] = { '}', 0 };
const Char *format = format_str;
c.format(&formatter, c.value, &format);
} }
*out = static_cast<Char>(value);
}
void visit_custom(Arg::CustomValue c) {
BasicFormatter<Char> formatter(ArgList(), this->writer());
const Char format_str[] = {'}', 0};
const Char *format = format_str;
c.format(&formatter, c.value, &format);
}
}; };
} // namespace internal } // namespace internal
} // namespace fmt } // namespace fmt
FMT_FUNC void fmt::SystemError::init( FMT_FUNC void fmt::SystemError::init(
int err_code, CStringRef format_str, ArgList args) { int err_code, CStringRef format_str, ArgList args) {
error_code_ = err_code; error_code_ = err_code;
MemoryWriter w; MemoryWriter w;
internal::format_system_error(w, err_code, format(format_str, args)); internal::format_system_error(w, err_code, format(format_str, args));
std::runtime_error &base = *this; std::runtime_error &base = *this;
base = std::runtime_error(w.str()); base = std::runtime_error(w.str());
} }
template <typename T> template <typename T>
int fmt::internal::CharTraits<char>::format_float( int fmt::internal::CharTraits<char>::format_float(
char *buffer, std::size_t size, const char *format, char *buffer, std::size_t size, const char *format,
unsigned width, int precision, T value) { unsigned width, int precision, T value) {
if (width == 0) { if (width == 0) {
return precision < 0 ?
FMT_SNPRINTF(buffer, size, format, value) :
FMT_SNPRINTF(buffer, size, format, precision, value);
}
return precision < 0 ? return precision < 0 ?
FMT_SNPRINTF(buffer, size, format, value) : FMT_SNPRINTF(buffer, size, format, width, value) :
FMT_SNPRINTF(buffer, size, format, precision, value); FMT_SNPRINTF(buffer, size, format, width, precision, value);
}
return precision < 0 ?
FMT_SNPRINTF(buffer, size, format, width, value) :
FMT_SNPRINTF(buffer, size, format, width, precision, value);
} }
template <typename T> template <typename T>
int fmt::internal::CharTraits<wchar_t>::format_float( int fmt::internal::CharTraits<wchar_t>::format_float(
wchar_t *buffer, std::size_t size, const wchar_t *format, wchar_t *buffer, std::size_t size, const wchar_t *format,
unsigned width, int precision, T value) { unsigned width, int precision, T value) {
if (width == 0) { if (width == 0) {
return precision < 0 ?
FMT_SWPRINTF(buffer, size, format, value) :
FMT_SWPRINTF(buffer, size, format, precision, value);
}
return precision < 0 ? return precision < 0 ?
FMT_SWPRINTF(buffer, size, format, value) : FMT_SWPRINTF(buffer, size, format, width, value) :
FMT_SWPRINTF(buffer, size, format, precision, value); FMT_SWPRINTF(buffer, size, format, width, precision, value);
}
return precision < 0 ?
FMT_SWPRINTF(buffer, size, format, width, value) :
FMT_SWPRINTF(buffer, size, format, width, precision, value);
} }
template <typename T> template <typename T>
...@@ -595,687 +672,702 @@ const char fmt::internal::BasicData<T>::DIGITS[] = ...@@ -595,687 +672,702 @@ const char fmt::internal::BasicData<T>::DIGITS[] =
template <typename T> template <typename T>
const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = { const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
0, FMT_POWERS_OF_10(1) 0, FMT_POWERS_OF_10(1)
}; };
template <typename T> template <typename T>
const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = { const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
0, 0,
FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1),
FMT_POWERS_OF_10(fmt::ULongLong(1000000000)), FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),
// Multiply several constants instead of using a single long long constant // Multiply several constants instead of using a single long long constant
// to avoid warnings about C++98 not supporting long long. // to avoid warnings about C++98 not supporting long long.
fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10 fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10
}; };
FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) { FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) {
(void)type; (void)type;
if (std::isprint(static_cast<unsigned char>(code))) { if (std::isprint(static_cast<unsigned char>(code))) {
FMT_THROW(fmt::FormatError(
fmt::format("unknown format code '{}' for {}", code, type)));
}
FMT_THROW(fmt::FormatError( FMT_THROW(fmt::FormatError(
fmt::format("unknown format code '{}' for {}", code, type))); fmt::format("unknown format code '\\x{:02x}' for {}",
} static_cast<unsigned>(code), type)));
FMT_THROW(fmt::FormatError(
fmt::format("unknown format code '\\x{:02x}' for {}",
static_cast<unsigned>(code), type)));
} }
#if FMT_USE_WINDOWS_H #if FMT_USE_WINDOWS_H
FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) { FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
if (s.size() > INT_MAX) if (s.size() > INT_MAX)
FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG)); FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
int s_size = static_cast<int>(s.size()); int s_size = static_cast<int>(s.size());
int length = MultiByteToWideChar( int length = MultiByteToWideChar(
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0); CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);
if (length == 0) if (length == 0)
FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
buffer_.resize(length + 1); buffer_.resize(length + 1);
length = MultiByteToWideChar( length = MultiByteToWideChar(
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length); CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
if (length == 0) if (length == 0)
FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
buffer_[length] = 0; buffer_[length] = 0;
} }
FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) { FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) {
if (int error_code = convert(s)) { if (int error_code = convert(s)) {
FMT_THROW(WindowsError(error_code, FMT_THROW(WindowsError(error_code,
"cannot convert string from UTF-16 to UTF-8")); "cannot convert string from UTF-16 to UTF-8"));
} }
} }
FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) { FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
if (s.size() > INT_MAX) if (s.size() > INT_MAX)
return ERROR_INVALID_PARAMETER; return ERROR_INVALID_PARAMETER;
int s_size = static_cast<int>(s.size()); int s_size = static_cast<int>(s.size());
int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0); int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);
if (length == 0) if (length == 0)
return GetLastError(); return GetLastError();
buffer_.resize(length + 1); buffer_.resize(length + 1);
length = WideCharToMultiByte( length = WideCharToMultiByte(
CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0); CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);
if (length == 0) if (length == 0)
return GetLastError(); return GetLastError();
buffer_[length] = 0; buffer_[length] = 0;
return 0; return 0;
} }
FMT_FUNC void fmt::WindowsError::init( FMT_FUNC void fmt::WindowsError::init(
int err_code, CStringRef format_str, ArgList args) { int err_code, CStringRef format_str, ArgList args) {
error_code_ = err_code; error_code_ = err_code;
MemoryWriter w; MemoryWriter w;
internal::format_windows_error(w, err_code, format(format_str, args)); internal::format_windows_error(w, err_code, format(format_str, args));
std::runtime_error &base = *this; std::runtime_error &base = *this;
base = std::runtime_error(w.str()); base = std::runtime_error(w.str());
} }
FMT_FUNC void fmt::internal::format_windows_error( FMT_FUNC void fmt::internal::format_windows_error(
fmt::Writer &out, int error_code, fmt::Writer &out, int error_code,
fmt::StringRef message) FMT_NOEXCEPT { fmt::StringRef message) FMT_NOEXCEPT{
class String { class String {
private: private:
LPWSTR str_; LPWSTR str_;
public: public:
String() : str_() {} String() : str_() {}
~String() { LocalFree(str_); } ~String() {
LPWSTR *ptr() { return &str_; } LocalFree(str_);
LPCWSTR c_str() const { return str_; } }
}; LPWSTR *ptr() {
FMT_TRY { return &str_;
String system_message; }
if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | LPCWSTR c_str() const { return str_; }
};
FMT_TRY{
String system_message;
if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
reinterpret_cast<LPWSTR>(system_message.ptr()), 0, 0)) { reinterpret_cast<LPWSTR>(system_message.ptr()), 0, 0)) {
UTF16ToUTF8 utf8_message; UTF16ToUTF8 utf8_message;
if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) { if (utf8_message.convert(system_message.c_str()) == ERROR_SUCCESS) {
out << message << ": " << utf8_message; out << message << ": " << utf8_message;
return; return;
} }
} }
} FMT_CATCH(...) {} } FMT_CATCH(...) {}
format_error_code(out, error_code, message); fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32.
} }
#endif // FMT_USE_WINDOWS_H #endif // FMT_USE_WINDOWS_H
FMT_FUNC void fmt::internal::format_system_error( FMT_FUNC void fmt::internal::format_system_error(
fmt::Writer &out, int error_code, fmt::Writer &out, int error_code,
fmt::StringRef message) FMT_NOEXCEPT { fmt::StringRef message) FMT_NOEXCEPT{
FMT_TRY { FMT_TRY{
MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer; MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
buffer.resize(INLINE_BUFFER_SIZE); buffer.resize(INLINE_BUFFER_SIZE);
for (;;) { for (;;) {
char *system_message = &buffer[0]; char *system_message = &buffer[0];
int result = safe_strerror(error_code, system_message, buffer.size()); int result = safe_strerror(error_code, system_message, buffer.size());
if (result == 0) { if (result == 0) {
out << message << ": " << system_message; out << message << ": " << system_message;
return; return;
} }
if (result != ERANGE) if (result != ERANGE)
break; // Can't get error message, report error code instead. break; // Can't get error message, report error code instead.
buffer.resize(buffer.size() * 2); buffer.resize(buffer.size() * 2);
} }
} FMT_CATCH(...) {} } FMT_CATCH(...) {}
format_error_code(out, error_code, message); fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32.
} }
template <typename Char> template <typename Char>
void fmt::internal::ArgMap<Char>::init(const ArgList &args) { void fmt::internal::ArgMap<Char>::init(const ArgList &args) {
if (!map_.empty()) if (!map_.empty())
return; return;
typedef internal::NamedArg<Char> NamedArg; typedef internal::NamedArg<Char> NamedArg;
const NamedArg *named_arg = 0; const NamedArg *named_arg = 0;
bool use_values = bool use_values =
args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE; args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
if (use_values) { if (use_values) {
for (unsigned i = 0;/*nothing*/; ++i) { for (unsigned i = 0;/*nothing*/; ++i) {
internal::Arg::Type arg_type = args.type(i); internal::Arg::Type arg_type = args.type(i);
switch (arg_type) { switch (arg_type) {
case internal::Arg::NONE: case internal::Arg::NONE:
return;
case internal::Arg::NAMED_ARG:
named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
map_.insert(Pair(named_arg->name, *named_arg));
break;
default:
/*nothing*/
;
}
}
return; return;
case internal::Arg::NAMED_ARG:
named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
map_.insert(Pair(named_arg->name, *named_arg));
break;
default:
/*nothing*/;
}
} }
return; for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
} internal::Arg::Type arg_type = args.type(i);
for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) { if (arg_type == internal::Arg::NAMED_ARG) {
internal::Arg::Type arg_type = args.type(i); named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
if (arg_type == internal::Arg::NAMED_ARG) { map_.insert(Pair(named_arg->name, *named_arg));
named_arg = static_cast<const NamedArg*>(args.args_[i].pointer); }
map_.insert(Pair(named_arg->name, *named_arg));
} }
} for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) { switch (args.args_[i].type) {
switch (args.args_[i].type) { case internal::Arg::NONE:
case internal::Arg::NONE: return;
return; case internal::Arg::NAMED_ARG:
case internal::Arg::NAMED_ARG: named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
named_arg = static_cast<const NamedArg*>(args.args_[i].pointer); map_.insert(Pair(named_arg->name, *named_arg));
map_.insert(Pair(named_arg->name, *named_arg)); break;
break; default:
default: /*nothing*/
/*nothing*/; ;
}
} }
}
} }
template <typename Char> template <typename Char>
void fmt::internal::FixedBuffer<Char>::grow(std::size_t) { void fmt::internal::FixedBuffer<Char>::grow(std::size_t) {
FMT_THROW(std::runtime_error("buffer overflow")); FMT_THROW(std::runtime_error("buffer overflow"));
} }
template <typename Char> template <typename Char>
template <typename StrChar> template <typename StrChar>
void fmt::BasicWriter<Char>::write_str( void fmt::BasicWriter<Char>::write_str(
const Arg::StringValue<StrChar> &s, const FormatSpec &spec) { const Arg::StringValue<StrChar> &s, const FormatSpec &spec) {
// Check if StrChar is convertible to Char. // Check if StrChar is convertible to Char.
internal::CharTraits<Char>::convert(StrChar()); internal::CharTraits<Char>::convert(StrChar());
if (spec.type_ && spec.type_ != 's') if (spec.type_ && spec.type_ != 's')
internal::report_unknown_type(spec.type_, "string"); internal::report_unknown_type(spec.type_, "string");
const StrChar *str_value = s.value; const StrChar *str_value = s.value;
std::size_t str_size = s.size; std::size_t str_size = s.size;
if (str_size == 0) { if (str_size == 0) {
if (!str_value) { if (!str_value) {
FMT_THROW(FormatError("string pointer is null")); FMT_THROW(FormatError("string pointer is null"));
return; return;
}
} }
if (*str_value) std::size_t precision = spec.precision_;
str_size = std::char_traits<StrChar>::length(str_value); if (spec.precision_ >= 0 && precision < str_size)
} str_size = spec.precision_;
std::size_t precision = spec.precision_; write_str(str_value, str_size, spec);
if (spec.precision_ >= 0 && precision < str_size)
str_size = spec.precision_;
write_str(str_value, str_size, spec);
} }
template <typename Char> template <typename Char>
inline Arg fmt::BasicFormatter<Char>::get_arg( inline Arg fmt::BasicFormatter<Char>::get_arg(
BasicStringRef<Char> arg_name, const char *&error) { BasicStringRef<Char> arg_name, const char *&error) {
if (check_no_auto_index(error)) { if (check_no_auto_index(error)) {
map_.init(args()); map_.init(args());
const Arg *arg = map_.find(arg_name); const Arg *arg = map_.find(arg_name);
if (arg) if (arg)
return *arg; return *arg;
error = "argument not found"; error = "argument not found";
} }
return Arg(); return Arg();
} }
template <typename Char> template <typename Char>
inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) { inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
const char *error = 0; const char *error = 0;
Arg arg = *s < '0' || *s > '9' ? Arg arg = *s < '0' || *s > '9' ?
next_arg(error) : get_arg(parse_nonnegative_int(s), error); next_arg(error) : get_arg(parse_nonnegative_int(s), error);
if (error) { if (error) {
FMT_THROW(FormatError( FMT_THROW(FormatError(
*s != '}' && *s != ':' ? "invalid format string" : error)); *s != '}' && *s != ':' ? "invalid format string" : error));
} }
return arg; return arg;
} }
template <typename Char> template <typename Char>
inline Arg fmt::BasicFormatter<Char>::parse_arg_name(const Char *&s) { inline Arg fmt::BasicFormatter<Char>::parse_arg_name(const Char *&s) {
assert(is_name_start(*s)); assert(is_name_start(*s));
const Char *start = s; const Char *start = s;
Char c; Char c;
do { do {
c = *++s; c = *++s;
} while (is_name_start(c) || ('0' <= c && c <= '9')); } while (is_name_start(c) || ('0' <= c && c <= '9'));
const char *error = 0; const char *error = 0;
Arg arg = get_arg(fmt::BasicStringRef<Char>(start, s - start), error); Arg arg = get_arg(fmt::BasicStringRef<Char>(start, s - start), error);
if (error) if (error)
FMT_THROW(fmt::FormatError(error)); FMT_THROW(fmt::FormatError(error));
return arg; return arg;
} }
FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg( FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
unsigned arg_index, const char *&error) { unsigned arg_index, const char *&error) {
Arg arg = args_[arg_index]; Arg arg = args_[arg_index];
switch (arg.type) { switch (arg.type) {
case Arg::NONE: case Arg::NONE:
error = "argument index out of range"; error = "argument index out of range";
break; break;
case Arg::NAMED_ARG: case Arg::NAMED_ARG:
arg = *static_cast<const internal::Arg*>(arg.pointer); arg = *static_cast<const internal::Arg*>(arg.pointer);
default: default:
/*nothing*/; /*nothing*/
} ;
return arg; }
return arg;
} }
inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) { inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) {
if (next_arg_index_ >= 0) if (next_arg_index_ >= 0)
return do_get_arg(next_arg_index_++, error); return do_get_arg(next_arg_index_++, error);
error = "cannot switch from manual to automatic argument indexing"; error = "cannot switch from manual to automatic argument indexing";
return Arg(); return Arg();
} }
inline bool fmt::internal::FormatterBase::check_no_auto_index( inline bool fmt::internal::FormatterBase::check_no_auto_index(
const char *&error) { const char *&error) {
if (next_arg_index_ > 0) { if (next_arg_index_ > 0) {
error = "cannot switch from automatic to manual argument indexing"; error = "cannot switch from automatic to manual argument indexing";
return false; return false;
} }
next_arg_index_ = -1; next_arg_index_ = -1;
return true; return true;
} }
inline Arg fmt::internal::FormatterBase::get_arg( inline Arg fmt::internal::FormatterBase::get_arg(
unsigned arg_index, const char *&error) { unsigned arg_index, const char *&error) {
return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg(); return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
} }
template <typename Char> template <typename Char>
void fmt::internal::PrintfFormatter<Char>::parse_flags( void fmt::internal::PrintfFormatter<Char>::parse_flags(
FormatSpec &spec, const Char *&s) { FormatSpec &spec, const Char *&s) {
for (;;) { for (;;) {
switch (*s++) { switch (*s++) {
case '-': case '-':
spec.align_ = ALIGN_LEFT; spec.align_ = ALIGN_LEFT;
break; break;
case '+': case '+':
spec.flags_ |= SIGN_FLAG | PLUS_FLAG; spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
break; break;
case '0': case '0':
spec.fill_ = '0'; spec.fill_ = '0';
break; break;
case ' ': case ' ':
spec.flags_ |= SIGN_FLAG; spec.flags_ |= SIGN_FLAG;
break; break;
case '#': case '#':
spec.flags_ |= HASH_FLAG; spec.flags_ |= HASH_FLAG;
break; break;
default: default:
--s; --s;
return; return;
}
} }
}
} }
template <typename Char> template <typename Char>
Arg fmt::internal::PrintfFormatter<Char>::get_arg( Arg fmt::internal::PrintfFormatter<Char>::get_arg(
const Char *s, unsigned arg_index) { const Char *s, unsigned arg_index) {
(void)s; (void)s;
const char *error = 0; const char *error = 0;
Arg arg = arg_index == UINT_MAX ? Arg arg = arg_index == UINT_MAX ?
next_arg(error) : FormatterBase::get_arg(arg_index - 1, error); next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
if (error) if (error)
FMT_THROW(FormatError(!*s ? "invalid format string" : error)); FMT_THROW(FormatError(!*s ? "invalid format string" : error));
return arg; return arg;
} }
template <typename Char> template <typename Char>
unsigned fmt::internal::PrintfFormatter<Char>::parse_header( unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
const Char *&s, FormatSpec &spec) { const Char *&s, FormatSpec &spec) {
unsigned arg_index = UINT_MAX; unsigned arg_index = UINT_MAX;
Char c = *s; Char c = *s;
if (c >= '0' && c <= '9') { if (c >= '0' && c <= '9') {
// Parse an argument index (if followed by '$') or a width possibly // Parse an argument index (if followed by '$') or a width possibly
// preceded with '0' flag(s). // preceded with '0' flag(s).
unsigned value = parse_nonnegative_int(s); unsigned value = parse_nonnegative_int(s);
if (*s == '$') { // value is an argument index if (*s == '$') { // value is an argument index
++s; ++s;
arg_index = value; arg_index = value;
} else { }
if (c == '0') else {
spec.fill_ = '0'; if (c == '0')
if (value != 0) { spec.fill_ = '0';
// Nonzero value means that we parsed width and don't need to if (value != 0) {
// parse it or flags again, so return now. // Nonzero value means that we parsed width and don't need to
spec.width_ = value; // parse it or flags again, so return now.
return arg_index; spec.width_ = value;
} return arg_index;
}
}
} }
} parse_flags(spec, s);
parse_flags(spec, s); // Parse width.
// Parse width. if (*s >= '0' && *s <= '9') {
if (*s >= '0' && *s <= '9') { spec.width_ = parse_nonnegative_int(s);
spec.width_ = parse_nonnegative_int(s); }
} else if (*s == '*') { else if (*s == '*') {
++s; ++s;
spec.width_ = WidthHandler(spec).visit(get_arg(s)); spec.width_ = WidthHandler(spec).visit(get_arg(s));
} }
return arg_index; return arg_index;
} }
template <typename Char> template <typename Char>
void fmt::internal::PrintfFormatter<Char>::format( void fmt::internal::PrintfFormatter<Char>::format(
BasicWriter<Char> &writer, BasicCStringRef<Char> format_str) { BasicWriter<Char> &writer, BasicCStringRef<Char> format_str) {
const Char *start = format_str.c_str(); const Char *start = format_str.c_str();
const Char *s = start; const Char *s = start;
while (*s) { while (*s) {
Char c = *s++; Char c = *s++;
if (c != '%') continue; if (c != '%') continue;
if (*s == c) { if (*s == c) {
write(writer, start, s); write(writer, start, s);
start = ++s; start = ++s;
continue; continue;
} }
write(writer, start, s - 1); write(writer, start, s - 1);
FormatSpec spec; FormatSpec spec;
spec.align_ = ALIGN_RIGHT; spec.align_ = ALIGN_RIGHT;
// Parse argument index, flags and width.
unsigned arg_index = parse_header(s, spec);
// Parse precision.
if (*s == '.') {
++s;
if ('0' <= *s && *s <= '9') {
spec.precision_ = parse_nonnegative_int(s);
}
else if (*s == '*') {
++s;
spec.precision_ = PrecisionHandler().visit(get_arg(s));
}
}
// Parse argument index, flags and width. Arg arg = get_arg(s, arg_index);
unsigned arg_index = parse_header(s, spec); if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg))
spec.flags_ &= ~HASH_FLAG;
if (spec.fill_ == '0') {
if (arg.type <= Arg::LAST_NUMERIC_TYPE)
spec.align_ = ALIGN_NUMERIC;
else
spec.fill_ = ' '; // Ignore '0' flag for non-numeric types.
}
// Parse precision. // Parse length and convert the argument to the required type.
if (*s == '.') { switch (*s++) {
++s; case 'h':
if ('0' <= *s && *s <= '9') { if (*s == 'h')
spec.precision_ = parse_nonnegative_int(s); ArgConverter<signed char>(arg, *++s).visit(arg);
} else if (*s == '*') { else
++s; ArgConverter<short>(arg, *s).visit(arg);
spec.precision_ = PrecisionHandler().visit(get_arg(s)); break;
} case 'l':
} if (*s == 'l')
ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
else
ArgConverter<long>(arg, *s).visit(arg);
break;
case 'j':
ArgConverter<intmax_t>(arg, *s).visit(arg);
break;
case 'z':
ArgConverter<std::size_t>(arg, *s).visit(arg);
break;
case 't':
ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
break;
case 'L':
// printf produces garbage when 'L' is omitted for long double, no
// need to do the same.
break;
default:
--s;
ArgConverter<int>(arg, *s).visit(arg);
}
Arg arg = get_arg(s, arg_index); // Parse type.
if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg)) if (!*s)
spec.flags_ &= ~HASH_FLAG; FMT_THROW(FormatError("invalid format string"));
if (spec.fill_ == '0') { spec.type_ = static_cast<char>(*s++);
if (arg.type <= Arg::LAST_NUMERIC_TYPE) if (arg.type <= Arg::LAST_INTEGER_TYPE) {
spec.align_ = ALIGN_NUMERIC; // Normalize type.
else switch (spec.type_) {
spec.fill_ = ' '; // Ignore '0' flag for non-numeric types. case 'i':
} case 'u':
spec.type_ = 'd';
break;
case 'c':
// TODO: handle wchar_t
CharConverter(arg).visit(arg);
break;
}
}
// Parse length and convert the argument to the required type. start = s;
switch (*s++) {
case 'h':
if (*s == 'h')
ArgConverter<signed char>(arg, *++s).visit(arg);
else
ArgConverter<short>(arg, *s).visit(arg);
break;
case 'l':
if (*s == 'l')
ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
else
ArgConverter<long>(arg, *s).visit(arg);
break;
case 'j':
ArgConverter<intmax_t>(arg, *s).visit(arg);
break;
case 'z':
ArgConverter<size_t>(arg, *s).visit(arg);
break;
case 't':
ArgConverter<ptrdiff_t>(arg, *s).visit(arg);
break;
case 'L':
// printf produces garbage when 'L' is omitted for long double, no
// need to do the same.
break;
default:
--s;
ArgConverter<int>(arg, *s).visit(arg);
}
// Parse type. // Format argument.
if (!*s) internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);
FMT_THROW(FormatError("invalid format string"));
spec.type_ = static_cast<char>(*s++);
if (arg.type <= Arg::LAST_INTEGER_TYPE) {
// Normalize type.
switch (spec.type_) {
case 'i': case 'u':
spec.type_ = 'd';
break;
case 'c':
// TODO: handle wchar_t
CharConverter(arg).visit(arg);
break;
}
} }
write(writer, start, s);
start = s;
// Format argument.
internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);
}
write(writer, start, s);
} }
template <typename Char> template <typename Char>
const Char *fmt::BasicFormatter<Char>::format( const Char *fmt::BasicFormatter<Char>::format(
const Char *&format_str, const Arg &arg) { const Char *&format_str, const Arg &arg) {
const Char *s = format_str; const Char *s = format_str;
FormatSpec spec; FormatSpec spec;
if (*s == ':') { if (*s == ':') {
if (arg.type == Arg::CUSTOM) { if (arg.type == Arg::CUSTOM) {
arg.custom.format(this, arg.custom.value, &s); arg.custom.format(this, arg.custom.value, &s);
return s; return s;
} }
++s; ++s;
// Parse fill and alignment. // Parse fill and alignment.
if (Char c = *s) { if (Char c = *s) {
const Char *p = s + 1; const Char *p = s + 1;
spec.align_ = ALIGN_DEFAULT; spec.align_ = ALIGN_DEFAULT;
do { do {
switch (*p) { switch (*p) {
case '<': case '<':
spec.align_ = ALIGN_LEFT; spec.align_ = ALIGN_LEFT;
break; break;
case '>': case '>':
spec.align_ = ALIGN_RIGHT; 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 == '{')
FMT_THROW(FormatError("invalid fill character '{'"));
s += 2;
spec.fill_ = c;
}
else ++s;
if (spec.align_ == ALIGN_NUMERIC)
require_numeric_argument(arg, '=');
break;
}
} while (--p >= s);
}
// Parse sign.
switch (*s) {
case '+':
check_sign(s, arg);
spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
break; break;
case '=': case '-':
spec.align_ = ALIGN_NUMERIC; check_sign(s, arg);
spec.flags_ |= MINUS_FLAG;
break; break;
case '^': case ' ':
spec.align_ = ALIGN_CENTER; check_sign(s, arg);
spec.flags_ |= SIGN_FLAG;
break; break;
} }
if (spec.align_ != ALIGN_DEFAULT) {
if (p != s) {
if (c == '}') break;
if (c == '{')
FMT_THROW(FormatError("invalid fill character '{'"));
s += 2;
spec.fill_ = c;
} else ++s;
if (spec.align_ == ALIGN_NUMERIC)
require_numeric_argument(arg, '=');
break;
}
} while (--p >= s);
}
// Parse sign. if (*s == '#') {
switch (*s) { require_numeric_argument(arg, '#');
case '+': spec.flags_ |= HASH_FLAG;
check_sign(s, arg); ++s;
spec.flags_ |= SIGN_FLAG | PLUS_FLAG; }
break;
case '-':
check_sign(s, arg);
spec.flags_ |= MINUS_FLAG;
break;
case ' ':
check_sign(s, arg);
spec.flags_ |= SIGN_FLAG;
break;
}
if (*s == '#') { // Parse zero flag.
require_numeric_argument(arg, '#'); if (*s == '0') {
spec.flags_ |= HASH_FLAG; require_numeric_argument(arg, '0');
++s; spec.align_ = ALIGN_NUMERIC;
} spec.fill_ = '0';
++s;
}
// Parse zero flag. // Parse width.
if (*s == '0') { if ('0' <= *s && *s <= '9') {
require_numeric_argument(arg, '0'); spec.width_ = parse_nonnegative_int(s);
spec.align_ = ALIGN_NUMERIC; }
spec.fill_ = '0'; else if (*s == '{') {
++s; ++s;
} Arg width_arg = is_name_start(*s) ?
parse_arg_name(s) : parse_arg_index(s);
// Parse width. if (*s++ != '}')
if ('0' <= *s && *s <= '9') { FMT_THROW(FormatError("invalid format string"));
spec.width_ = parse_nonnegative_int(s); ULongLong value = 0;
} else if (*s == '{') { switch (width_arg.type) {
++s; case Arg::INT:
Arg width_arg = is_name_start(*s) ? if (width_arg.int_value < 0)
parse_arg_name(s) : parse_arg_index(s); FMT_THROW(FormatError("negative width"));
if (*s++ != '}') value = width_arg.int_value;
FMT_THROW(FormatError("invalid format string")); break;
ULongLong value = 0; case Arg::UINT:
switch (width_arg.type) { value = width_arg.uint_value;
case Arg::INT: break;
if (width_arg.int_value < 0) case Arg::LONG_LONG:
FMT_THROW(FormatError("negative width")); if (width_arg.long_long_value < 0)
value = width_arg.int_value; FMT_THROW(FormatError("negative width"));
break; value = width_arg.long_long_value;
case Arg::UINT: break;
value = width_arg.uint_value; case Arg::ULONG_LONG:
break; value = width_arg.ulong_long_value;
case Arg::LONG_LONG: break;
if (width_arg.long_long_value < 0) default:
FMT_THROW(FormatError("negative width")); FMT_THROW(FormatError("width is not integer"));
value = width_arg.long_long_value; }
break; if (value > INT_MAX)
case Arg::ULONG_LONG: FMT_THROW(FormatError("number is too big"));
value = width_arg.ulong_long_value; spec.width_ = static_cast<int>(value);
break; }
default:
FMT_THROW(FormatError("width is not integer"));
}
if (value > INT_MAX)
FMT_THROW(FormatError("number is too big"));
spec.width_ = static_cast<int>(value);
}
// Parse precision. // Parse precision.
if (*s == '.') { if (*s == '.') {
++s; ++s;
spec.precision_ = 0; spec.precision_ = 0;
if ('0' <= *s && *s <= '9') { if ('0' <= *s && *s <= '9') {
spec.precision_ = parse_nonnegative_int(s); spec.precision_ = parse_nonnegative_int(s);
} else if (*s == '{') { }
++s; else if (*s == '{') {
Arg precision_arg = ++s;
is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s); Arg precision_arg =
if (*s++ != '}') is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
FMT_THROW(FormatError("invalid format string")); if (*s++ != '}')
ULongLong value = 0; FMT_THROW(FormatError("invalid format string"));
switch (precision_arg.type) { ULongLong value = 0;
case Arg::INT: switch (precision_arg.type) {
if (precision_arg.int_value < 0) case Arg::INT:
FMT_THROW(FormatError("negative precision")); if (precision_arg.int_value < 0)
value = precision_arg.int_value; FMT_THROW(FormatError("negative precision"));
break; value = precision_arg.int_value;
case Arg::UINT: break;
value = precision_arg.uint_value; case Arg::UINT:
break; value = precision_arg.uint_value;
case Arg::LONG_LONG: break;
if (precision_arg.long_long_value < 0) case Arg::LONG_LONG:
FMT_THROW(FormatError("negative precision")); if (precision_arg.long_long_value < 0)
value = precision_arg.long_long_value; FMT_THROW(FormatError("negative precision"));
break; value = precision_arg.long_long_value;
case Arg::ULONG_LONG: break;
value = precision_arg.ulong_long_value; case Arg::ULONG_LONG:
break; value = precision_arg.ulong_long_value;
default: break;
FMT_THROW(FormatError("precision is not integer")); default:
FMT_THROW(FormatError("precision is not integer"));
}
if (value > INT_MAX)
FMT_THROW(FormatError("number is too big"));
spec.precision_ = static_cast<int>(value);
}
else {
FMT_THROW(FormatError("missing precision specifier"));
}
if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
FMT_THROW(FormatError(
fmt::format("precision not allowed in {} format specifier",
arg.type == Arg::POINTER ? "pointer" : "integer")));
}
} }
if (value > INT_MAX)
FMT_THROW(FormatError("number is too big"));
spec.precision_ = static_cast<int>(value);
} else {
FMT_THROW(FormatError("missing precision specifier"));
}
if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
FMT_THROW(FormatError(
fmt::format("precision not allowed in {} format specifier",
arg.type == Arg::POINTER ? "pointer" : "integer")));
}
}
// Parse type. // Parse type.
if (*s != '}' && *s) if (*s != '}' && *s)
spec.type_ = static_cast<char>(*s++); spec.type_ = static_cast<char>(*s++);
} }
if (*s++ != '}') if (*s++ != '}')
FMT_THROW(FormatError("missing '}' in format string")); FMT_THROW(FormatError("missing '}' in format string"));
// Format argument. // Format argument.
internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg); internal::ArgFormatter<Char>(*this, spec, s - 1).visit(arg);
return s; return s;
} }
template <typename Char> template <typename Char>
void fmt::BasicFormatter<Char>::format(BasicCStringRef<Char> format_str) { void fmt::BasicFormatter<Char>::format(BasicCStringRef<Char> format_str) {
const Char *s = format_str.c_str(); const Char *s = format_str.c_str();
const Char *start = s; const Char *start = s;
while (*s) { while (*s) {
Char c = *s++; Char c = *s++;
if (c != '{' && c != '}') continue; if (c != '{' && c != '}') continue;
if (*s == c) { if (*s == c) {
write(writer_, start, s); write(writer_, start, s);
start = ++s; start = ++s;
continue; continue;
}
if (c == '}')
FMT_THROW(FormatError("unmatched '}' in format string"));
write(writer_, start, s - 1);
Arg arg = is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
start = s = format(s, arg);
} }
if (c == '}') write(writer_, start, s);
FMT_THROW(FormatError("unmatched '}' in format string"));
write(writer_, start, s - 1);
Arg arg = is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
start = s = format(s, arg);
}
write(writer_, start, s);
} }
FMT_FUNC void fmt::report_system_error( FMT_FUNC void fmt::report_system_error(
int error_code, fmt::StringRef message) FMT_NOEXCEPT { int error_code, fmt::StringRef message) FMT_NOEXCEPT{
report_error(internal::format_system_error, error_code, message); // 'fmt::' is for bcc32.
fmt::report_error(internal::format_system_error, error_code, message);
} }
#if FMT_USE_WINDOWS_H #if FMT_USE_WINDOWS_H
FMT_FUNC void fmt::report_windows_error( FMT_FUNC void fmt::report_windows_error(
int error_code, fmt::StringRef message) FMT_NOEXCEPT { int error_code, fmt::StringRef message) FMT_NOEXCEPT{
report_error(internal::format_windows_error, error_code, message); // 'fmt::' is for bcc32.
fmt::report_error(internal::format_windows_error, error_code, message);
} }
#endif #endif
FMT_FUNC void fmt::print(std::FILE *f, CStringRef format_str, ArgList args) { FMT_FUNC void fmt::print(std::FILE *f, CStringRef format_str, ArgList args) {
MemoryWriter w; MemoryWriter w;
w.write(format_str, args); w.write(format_str, args);
std::fwrite(w.data(), 1, w.size(), f); std::fwrite(w.data(), 1, w.size(), f);
} }
FMT_FUNC void fmt::print(CStringRef format_str, ArgList args) { FMT_FUNC void fmt::print(CStringRef format_str, ArgList args) {
print(stdout, format_str, args); print(stdout, format_str, args);
} }
FMT_FUNC void fmt::print(std::ostream &os, CStringRef format_str, ArgList args) { FMT_FUNC void fmt::print(std::ostream &os, CStringRef format_str, ArgList args) {
MemoryWriter w; MemoryWriter w;
w.write(format_str, args); w.write(format_str, args);
os.write(w.data(), w.size()); os.write(w.data(), w.size());
} }
FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) { FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
char escape[] = "\x1b[30m"; char escape[] = "\x1b[30m";
escape[3] = static_cast<char>('0' + c); escape[3] = static_cast<char>('0' + c);
std::fputs(escape, stdout); std::fputs(escape, stdout);
print(format, args); print(format, args);
std::fputs(RESET_COLOR, stdout); std::fputs(RESET_COLOR, stdout);
} }
FMT_FUNC int fmt::fprintf(std::FILE *f, CStringRef format, ArgList args) { FMT_FUNC int fmt::fprintf(std::FILE *f, CStringRef format, ArgList args) {
MemoryWriter w; MemoryWriter w;
printf(w, format, args); printf(w, format, args);
std::size_t size = w.size(); std::size_t size = w.size();
return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size); return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
} }
#ifndef FMT_HEADER_ONLY #ifndef FMT_HEADER_ONLY
...@@ -1292,7 +1384,7 @@ template const char *fmt::BasicFormatter<char>::format( ...@@ -1292,7 +1384,7 @@ template const char *fmt::BasicFormatter<char>::format(
template void fmt::BasicFormatter<char>::format(CStringRef format); template void fmt::BasicFormatter<char>::format(CStringRef format);
template void fmt::internal::PrintfFormatter<char>::format( template void fmt::internal::PrintfFormatter<char>::format(
BasicWriter<char> &writer, CStringRef format); BasicWriter<char> &writer, CStringRef format);
template int fmt::internal::CharTraits<char>::format_float( template int fmt::internal::CharTraits<char>::format_float(
char *buffer, std::size_t size, const char *format, char *buffer, std::size_t size, const char *format,
......
include/spdlog/details/format.h
View file @ 7b3fc4ba
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment