danny
/
spdlog
mirror of https://github.com/gabime/spdlog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updated fmto to version def687462c32ec40757e49eb6069f109d50236d6

Browse Source
pull/302/merge
gabime 9 years ago
parent e12916c070
commit d142f13551
5 changed files with 5126 additions and 5110 deletions
Show Stats Download Patch File Download Diff File

875
include/spdlog/fmt/bundled/format.cc
Unescape Escape View File

@ -25,9 +25,7 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
// commented out by spdlog #include "format.h"
// #include "format.h"
// #include "printf.h"
#include <string.h> #include <string.h>
@ -73,31 +71,37 @@ 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 {
FMT_FUNC internal::RuntimeError::~RuntimeError() throw() {} FMT_FUNC internal::RuntimeError::~RuntimeError() FMT_DTOR_NOEXCEPT
FMT_FUNC FormatError::~FormatError() throw() {} {}
FMT_FUNC SystemError::~SystemError() throw() {} FMT_FUNC FormatError::~FormatError() FMT_DTOR_NOEXCEPT
{}
FMT_FUNC SystemError::~SystemError() FMT_DTOR_NOEXCEPT
{}
namespace { namespace {
#ifndef _MSC_VER #ifndef _MSC_VER
# 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_start(args, format); va_list args;
int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); va_start(args, format);
va_end(args); int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
return result; va_end(args);
} return result;
}
# define FMT_SNPRINTF fmt_snprintf # define FMT_SNPRINTF fmt_snprintf
#endif // _MSC_VER #endif // _MSC_VER
@ -107,166 +111,183 @@ inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
# define FMT_SWPRINTF swprintf # define FMT_SWPRINTF swprintf
#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) #endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
const char RESET_COLOR[] = "\x1b[0m"; const char RESET_COLOR[] = "\x1b[0m";
typedef void(*FormatFunc)(Writer &, int, StringRef); typedef void(*FormatFunc)(Writer &, int, 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.
// This can be either a pointer to a string stored in buffer, // This can be either a pointer to a string stored in buffer,
// or a pointer to some static immutable string. // or a pointer to some static immutable string.
// Returns one of the following values: // Returns one of the following values:
// 0 - success // 0 - success
// ERANGE - buffer is not large enough to store the error message // ERANGE - buffer is not large enough to store the error message
// 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 {
private: class StrError
int error_code_; {
char *&buffer_; private:
std::size_t buffer_size_; int error_code_;
char *&buffer_;
// A noop assignment operator to avoid bogus warnings. std::size_t buffer_size_;
void operator=(const StrError &) {}
// A noop assignment operator to avoid bogus warnings.
// Handle the result of XSI-compliant version of strerror_r. void operator=(const StrError &)
int handle(int result) { {}
// glibc versions before 2.13 return result in errno.
return result == -1 ? errno : result; // Handle the result of XSI-compliant version of strerror_r.
} int handle(int result)
{
// Handle the result of GNU-specific version of strerror_r. // glibc versions before 2.13 return result in errno.
int handle(char *message) { return result == -1 ? errno : result;
// If the buffer is full then the message is probably truncated. }
if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
return ERANGE; // Handle the result of GNU-specific version of strerror_r.
buffer_ = message; int handle(char *message)
return 0; {
} // If the buffer is full then the message is probably truncated.
if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
// Handle the case when strerror_r is not available. return ERANGE;
int handle(internal::Null<>) { buffer_ = message;
return fallback(strerror_s(buffer_, buffer_size_, error_code_)); return 0;
} }
// Fallback to strerror_s when strerror_r is not available. // Handle the case when strerror_r is not available.
int fallback(int result) { int handle(internal::Null<>)
// If the buffer is full then the message is probably truncated. {
return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? return fallback(strerror_s(buffer_, buffer_size_, error_code_));
ERANGE : result; }
}
// Fallback to strerror_s when strerror_r is not available.
// Fallback to strerror if strerror_r and strerror_s are not available. int fallback(int result)
int fallback(internal::Null<>) { {
errno = 0; // If the buffer is full then the message is probably truncated.
buffer_ = strerror(error_code_); return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
return errno; ERANGE : result;
} }
public: // Fallback to strerror if strerror_r and strerror_s are not available.
StrError(int err_code, char *&buf, std::size_t buf_size) int fallback(internal::Null<>)
: error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {} {
errno = 0;
int run() { buffer_ = strerror(error_code_);
strerror_r(0, 0, ""); // Suppress a warning about unused strerror_r. return errno;
return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
}
}; public:
return StrError(error_code, buffer, buffer_size).run(); StrError(int err_code, char *&buf, std::size_t buf_size)
} : error_code_(err_code), buffer_(buf), buffer_size_(buf_size)
{}
void format_error_code(Writer &out, int error_code,
StringRef message) FMT_NOEXCEPT{ int run()
// Report error code making sure that the output fits into {
// INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential // Suppress a warning about unused strerror_r.
// bad_alloc. strerror_r(0, FMT_NULL, "");
out.clear(); return handle(strerror_r(error_code_, buffer_, buffer_size_));
static const char SEP[] = ": "; }
static const char ERROR_STR[] = "error "; };
// Subtract 2 to account for terminating null characters in SEP and ERROR_STR. return StrError(error_code, buffer, buffer_size).run();
std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; }
typedef internal::IntTraits<int>::MainType MainType;
MainType abs_value = static_cast<MainType>(error_code); void format_error_code(Writer &out, int error_code,
if (internal::is_negative(error_code)) { StringRef message) FMT_NOEXCEPT
abs_value = 0 - abs_value; {
++error_code_size; // Report error code making sure that the output fits into
} // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
error_code_size += internal::count_digits(abs_value); // bad_alloc.
if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size) out.clear();
out << message << SEP; static const char SEP[] = ": ";
out << ERROR_STR << error_code; static const char ERROR_STR[] = "error ";
assert(out.size() <= internal::INLINE_BUFFER_SIZE); // 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::IntTraits<int>::MainType MainType;
void report_error(FormatFunc func, int error_code, MainType abs_value = static_cast<MainType>(error_code);
StringRef message) FMT_NOEXCEPT{ if (internal::is_negative(error_code)) {
MemoryWriter full_message; abs_value = 0 - abs_value;
func(full_message, error_code, message); ++error_code_size;
// Use Writer::data instead of Writer::c_str to avoid potential memory }
// allocation. error_code_size += internal::count_digits(abs_value);
std::fwrite(full_message.data(), full_message.size(), 1, stderr); if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size)
std::fputc('\n', stderr); out << message << SEP;
} out << ERROR_STR << error_code;
} // namespace assert(out.size() <= internal::INLINE_BUFFER_SIZE);
}
namespace internal {
void report_error(FormatFunc func, int error_code,
// This method is used to preserve binary compatibility with fmt 3.0. StringRef message) FMT_NOEXCEPT
// It can be removed in 4.0. {
FMT_FUNC void format_system_error( MemoryWriter full_message;
Writer &out, int error_code, StringRef message) FMT_NOEXCEPT{ func(full_message, error_code, message);
fmt::format_system_error(out, error_code, message); // Use Writer::data instead of Writer::c_str to avoid potential memory
} // allocation.
} // namespace internal std::fwrite(full_message.data(), full_message.size(), 1, stderr);
std::fputc('\n', stderr);
FMT_FUNC void SystemError::init( }
int err_code, CStringRef format_str, ArgList args) { } // namespace
error_code_ = err_code;
MemoryWriter w; namespace internal {
format_system_error(w, err_code, format(format_str, args));
std::runtime_error &base = *this; // This method is used to preserve binary compatibility with fmt 3.0.
base = std::runtime_error(w.str()); // It can be removed in 4.0.
} FMT_FUNC void format_system_error(
Writer &out, int error_code, StringRef message) FMT_NOEXCEPT
template <typename T> {
int internal::CharTraits<char>::format_float( fmt::format_system_error(out, error_code, message);
char *buffer, std::size_t size, const char *format, }
unsigned width, int precision, T value) { } // namespace internal
if (width == 0) {
return precision < 0 ? FMT_FUNC void SystemError::init(
FMT_SNPRINTF(buffer, size, format, value) : int err_code, CStringRef format_str, ArgList args)
FMT_SNPRINTF(buffer, size, format, precision, value); {
} error_code_ = err_code;
return precision < 0 ? MemoryWriter w;
FMT_SNPRINTF(buffer, size, format, width, value) : format_system_error(w, err_code, format(format_str, args));
FMT_SNPRINTF(buffer, size, format, width, precision, value); std::runtime_error &base = *this;
} base = std::runtime_error(w.str());
}
template <typename T>
int internal::CharTraits<wchar_t>::format_float( template <typename T>
wchar_t *buffer, std::size_t size, const wchar_t *format, int internal::CharTraits<char>::format_float(
unsigned width, int precision, T value) { char *buffer, std::size_t size, const char *format,
if (width == 0) { unsigned width, int precision, T value)
return precision < 0 ? {
FMT_SWPRINTF(buffer, size, format, value) : if (width == 0) {
FMT_SWPRINTF(buffer, size, format, precision, value); return precision < 0 ?
} FMT_SNPRINTF(buffer, size, format, value) :
return precision < 0 ? FMT_SNPRINTF(buffer, size, format, precision, value);
FMT_SWPRINTF(buffer, size, format, width, value) : }
FMT_SWPRINTF(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> }
const char internal::BasicData<T>::DIGITS[] =
"0001020304050607080910111213141516171819" template <typename T>
"2021222324252627282930313233343536373839" int internal::CharTraits<wchar_t>::format_float(
"4041424344454647484950515253545556575859" wchar_t *buffer, std::size_t size, const wchar_t *format,
"6061626364656667686970717273747576777879" unsigned width, int precision, T value)
"8081828384858687888990919293949596979899"; {
if (width == 0) {
return precision < 0 ?
FMT_SWPRINTF(buffer, size, format, value) :
FMT_SWPRINTF(buffer, size, format, precision, value);
}
return precision < 0 ?
FMT_SWPRINTF(buffer, size, format, width, value) :
FMT_SWPRINTF(buffer, size, format, width, precision, value);
}
template <typename T>
const char internal::BasicData<T>::DIGITS[] =
"0001020304050607080910111213141516171819"
"2021222324252627282930313233343536373839"
"4041424344454647484950515253545556575859"
"6061626364656667686970717273747576777879"
"8081828384858687888990919293949596979899";
#define FMT_POWERS_OF_10(factor) \ #define FMT_POWERS_OF_10(factor) \
factor * 10, \ factor * 10, \
@ -279,277 +300,279 @@ const char internal::BasicData<T>::DIGITS[] =
factor * 100000000, \ factor * 100000000, \
factor * 1000000000 factor * 1000000000
template <typename T> template <typename T>
const uint32_t internal::BasicData<T>::POWERS_OF_10_32[] = { const uint32_t 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 internal::BasicData<T>::POWERS_OF_10_64[] = { const uint64_t internal::BasicData<T>::POWERS_OF_10_64[] = {
0, 0,
FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1),
FMT_POWERS_OF_10(ULongLong(1000000000)), FMT_POWERS_OF_10(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.
ULongLong(1000000000) * ULongLong(1000000000) * 10 ULongLong(1000000000) * ULongLong(1000000000) * 10
}; };
FMT_FUNC void internal::report_unknown_type(char code, const char *type) { FMT_FUNC void internal::report_unknown_type(char code, const char *type)
(void)type; {
if (std::isprint(static_cast<unsigned char>(code))) { (void)type;
FMT_THROW(FormatError( if (std::isprint(static_cast<unsigned char>(code))) {
format("unknown format code '{}' for {}", code, type))); FMT_THROW(FormatError(
} format("unknown format code '{}' for {}", code, type)));
FMT_THROW(FormatError( }
format("unknown format code '\\x{:02x}' for {}", FMT_THROW(FormatError(
static_cast<unsigned>(code), type))); format("unknown format code '\\x{:02x}' for {}",
} static_cast<unsigned>(code), type)));
}
#if FMT_USE_WINDOWS_H #if FMT_USE_WINDOWS_H
FMT_FUNC internal::UTF8ToUTF16::UTF8ToUTF16(StringRef s) { FMT_FUNC internal::UTF8ToUTF16::UTF8ToUTF16(StringRef s)
static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; {
if (s.size() > INT_MAX) static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG)); if (s.size() > INT_MAX)
int s_size = static_cast<int>(s.size()); FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
int length = MultiByteToWideChar( int s_size = static_cast<int>(s.size());
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0); int length = MultiByteToWideChar(
if (length == 0) CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); if (length == 0)
buffer_.resize(length + 1); FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
length = MultiByteToWideChar( buffer_.resize(length + 1);
CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length); length = MultiByteToWideChar(
if (length == 0) CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
FMT_THROW(WindowsError(GetLastError(), ERROR_MSG)); if (length == 0)
buffer_[length] = 0; FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
} buffer_[length] = 0;
}
FMT_FUNC internal::UTF16ToUTF8::UTF16ToUTF8(WStringRef s) {
if (int error_code = convert(s)) { FMT_FUNC internal::UTF16ToUTF8::UTF16ToUTF8(WStringRef s)
FMT_THROW(WindowsError(error_code, {
"cannot convert string from UTF-16 to UTF-8")); if (int error_code = convert(s)) {
} FMT_THROW(WindowsError(error_code,
} "cannot convert string from UTF-16 to UTF-8"));
}
FMT_FUNC int internal::UTF16ToUTF8::convert(WStringRef s) { }
if (s.size() > INT_MAX)
return ERROR_INVALID_PARAMETER; FMT_FUNC int internal::UTF16ToUTF8::convert(WStringRef s)
int s_size = static_cast<int>(s.size()); {
int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0); if (s.size() > INT_MAX)
if (length == 0) return ERROR_INVALID_PARAMETER;
return GetLastError(); int s_size = static_cast<int>(s.size());
buffer_.resize(length + 1); int length = WideCharToMultiByte(
length = WideCharToMultiByte( CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0); if (length == 0)
if (length == 0) return GetLastError();
return GetLastError(); buffer_.resize(length + 1);
buffer_[length] = 0; length = WideCharToMultiByte(
return 0; CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
} if (length == 0)
return GetLastError();
FMT_FUNC void WindowsError::init( buffer_[length] = 0;
int err_code, CStringRef format_str, ArgList args) { return 0;
error_code_ = err_code; }
MemoryWriter w;
internal::format_windows_error(w, err_code, format(format_str, args)); FMT_FUNC void WindowsError::init(
std::runtime_error &base = *this; int err_code, CStringRef format_str, ArgList args)
base = std::runtime_error(w.str()); {
} error_code_ = err_code;
MemoryWriter w;
FMT_FUNC void internal::format_windows_error( internal::format_windows_error(w, err_code, format(format_str, args));
Writer &out, int error_code, StringRef message) FMT_NOEXCEPT{ std::runtime_error &base = *this;
FMT_TRY{ base = std::runtime_error(w.str());
MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer; }
buffer.resize(INLINE_BUFFER_SIZE);
for (;;) { FMT_FUNC void internal::format_windows_error(
wchar_t *system_message = &buffer[0]; Writer &out, int error_code, StringRef message) FMT_NOEXCEPT
int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, {
0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), FMT_TRY{
system_message, static_cast<uint32_t>(buffer.size()), 0); MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;
if (result != 0) { buffer.resize(INLINE_BUFFER_SIZE);
UTF16ToUTF8 utf8_message; for (;;) {
if (utf8_message.convert(system_message) == ERROR_SUCCESS) { wchar_t *system_message = &buffer[0];
out << message << ": " << utf8_message; int result = FormatMessageW(
return; FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
} FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
break; system_message, static_cast<uint32_t>(buffer.size()), FMT_NULL);
} if (result != 0) {
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) UTF16ToUTF8 utf8_message;
break; // Can't get error message, report error code instead. if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
buffer.resize(buffer.size() * 2); out << message << ": " << utf8_message;
} return;
} FMT_CATCH(...) {} }
fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32. break;
} }
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
break; // Can't get error message, report error code instead.
buffer.resize(buffer.size() * 2);
}
} FMT_CATCH(...)
{}
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 format_system_error( FMT_FUNC void format_system_error(
Writer &out, int error_code, StringRef message) FMT_NOEXCEPT{ Writer &out, int error_code, StringRef message) FMT_NOEXCEPT
FMT_TRY{ {
internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer; FMT_TRY{
buffer.resize(internal::INLINE_BUFFER_SIZE); internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> buffer;
for (;;) { buffer.resize(internal::INLINE_BUFFER_SIZE);
char *system_message = &buffer[0]; for (;;) {
int result = safe_strerror(error_code, system_message, buffer.size()); char *system_message = &buffer[0];
if (result == 0) { int result = safe_strerror(error_code, system_message, buffer.size());
out << message << ": " << system_message; if (result == 0) {
return; out << message << ": " << system_message;
} return;
if (result != ERANGE) }
break; // Can't get error message, report error code instead. if (result != ERANGE)
buffer.resize(buffer.size() * 2); break; // Can't get error message, report error code instead.
} buffer.resize(buffer.size() * 2);
} FMT_CATCH(...) {} }
fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32. } FMT_CATCH(...)
} {}
fmt::format_error_code(out, error_code, message); // 'fmt::' is for bcc32.
template <typename Char> }
void internal::ArgMap<Char>::init(const ArgList &args) {
if (!map_.empty()) template <typename Char>
return; void internal::ArgMap<Char>::init(const ArgList &args)
typedef internal::NamedArg<Char> NamedArg; {
const NamedArg *named_arg = 0; if (!map_.empty())
bool use_values = return;
args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE; typedef internal::NamedArg<Char> NamedArg;
if (use_values) { const NamedArg *named_arg = FMT_NULL;
for (unsigned i = 0;/*nothing*/; ++i) { bool use_values =
internal::Arg::Type arg_type = args.type(i); args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
switch (arg_type) { if (use_values) {
case internal::Arg::NONE: for (unsigned i = 0;/*nothing*/; ++i) {
return; internal::Arg::Type arg_type = args.type(i);
case internal::Arg::NAMED_ARG: switch (arg_type) {
named_arg = static_cast<const NamedArg*>(args.values_[i].pointer); case internal::Arg::NONE:
map_.push_back(Pair(named_arg->name, *named_arg)); return;
break; case internal::Arg::NAMED_ARG:
default: named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
/*nothing*/ map_.push_back(Pair(named_arg->name, *named_arg));
; break;
} default:
} /*nothing*/;
return; }
} }
for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) { return;
internal::Arg::Type arg_type = args.type(i); }
if (arg_type == internal::Arg::NAMED_ARG) { for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
named_arg = static_cast<const NamedArg*>(args.args_[i].pointer); internal::Arg::Type arg_type = args.type(i);
map_.push_back(Pair(named_arg->name, *named_arg)); if (arg_type == internal::Arg::NAMED_ARG) {
} named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
} map_.push_back(Pair(named_arg->name, *named_arg));
for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) { }
switch (args.args_[i].type) { }
case internal::Arg::NONE: for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
return; switch (args.args_[i].type) {
case internal::Arg::NAMED_ARG: case internal::Arg::NONE:
named_arg = static_cast<const NamedArg*>(args.args_[i].pointer); return;
map_.push_back(Pair(named_arg->name, *named_arg)); case internal::Arg::NAMED_ARG:
break; named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
default: map_.push_back(Pair(named_arg->name, *named_arg));
/*nothing*/ break;
; default:
} /*nothing*/;
} }
} }
}
template <typename Char>
void internal::FixedBuffer<Char>::grow(std::size_t) { template <typename Char>
FMT_THROW(std::runtime_error("buffer overflow")); void internal::FixedBuffer<Char>::grow(std::size_t)
} {
FMT_THROW(std::runtime_error("buffer overflow"));
FMT_FUNC Arg internal::FormatterBase::do_get_arg( }
unsigned arg_index, const char *&error) {
Arg arg = args_[arg_index]; FMT_FUNC Arg internal::FormatterBase::do_get_arg(
switch (arg.type) { unsigned arg_index, const char *&error)
case Arg::NONE: {
error = "argument index out of range"; Arg arg = args_[arg_index];
break; switch (arg.type) {
case Arg::NAMED_ARG: case Arg::NONE:
arg = *static_cast<const internal::Arg*>(arg.pointer); error = "argument index out of range";
break; break;
default: case Arg::NAMED_ARG:
/*nothing*/ arg = *static_cast<const internal::Arg*>(arg.pointer);
; break;
} default:
return arg; /*nothing*/;
} }
return arg;
FMT_FUNC void report_system_error( }
int error_code, fmt::StringRef message) FMT_NOEXCEPT{
// 'fmt::' is for bcc32. FMT_FUNC void report_system_error(
report_error(format_system_error, error_code, message); int error_code, fmt::StringRef message) FMT_NOEXCEPT
} {
// 'fmt::' is for bcc32.
report_error(format_system_error, error_code, message);
}
#if FMT_USE_WINDOWS_H #if FMT_USE_WINDOWS_H
FMT_FUNC void report_windows_error( FMT_FUNC void report_windows_error(
int error_code, fmt::StringRef message) FMT_NOEXCEPT{ int error_code, fmt::StringRef message) FMT_NOEXCEPT
// 'fmt::' is for bcc32. {
report_error(internal::format_windows_error, error_code, message); // 'fmt::' is for bcc32.
} report_error(internal::format_windows_error, error_code, message);
}
#endif #endif
FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args) { FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args)
MemoryWriter w; {
w.write(format_str, args); MemoryWriter w;
std::fwrite(w.data(), 1, w.size(), f); w.write(format_str, args);
} std::fwrite(w.data(), 1, w.size(), f);
}
FMT_FUNC void print(CStringRef format_str, ArgList args) {
print(stdout, format_str, args); FMT_FUNC void print(CStringRef format_str, ArgList args)
} {
print(stdout, format_str, args);
FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args) { }
char escape[] = "\x1b[30m";
escape[3] = static_cast<char>('0' + c); FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args)
std::fputs(escape, stdout); {
print(format, args); char escape[] = "\x1b[30m";
std::fputs(RESET_COLOR, stdout); escape[3] = static_cast<char>('0' + c);
} std::fputs(escape, stdout);
print(format, args);
template <typename Char> std::fputs(RESET_COLOR, stdout);
void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args); }
FMT_FUNC int fprintf(std::FILE *f, CStringRef format, ArgList args) {
MemoryWriter w;
printf(w, format, args);
std::size_t size = w.size();
return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
}
#ifndef FMT_HEADER_ONLY #ifndef FMT_HEADER_ONLY
template struct internal::BasicData<void>; template struct internal::BasicData<void>;
// Explicit instantiations for char.
template void internal::FixedBuffer<char>::grow(std::size_t);
template void internal::ArgMap<char>::init(const ArgList &args); // Explicit instantiations for char.
template void PrintfFormatter<char>::format(CStringRef format); template void internal::FixedBuffer<char>::grow(std::size_t);
template int internal::CharTraits<char>::format_float( template void internal::ArgMap<char>::init(const ArgList &args);
char *buffer, std::size_t size, const char *format,
unsigned width, int precision, double value);
template int internal::CharTraits<char>::format_float( template int 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, long double value); unsigned width, int precision, double value);
// Explicit instantiations for wchar_t. template int internal::CharTraits<char>::format_float(
char *buffer, std::size_t size, const char *format,
unsigned width, int precision, long double value);
template void internal::FixedBuffer<wchar_t>::grow(std::size_t); // Explicit instantiations for wchar_t.
template void internal::ArgMap<wchar_t>::init(const ArgList &args); template void internal::FixedBuffer<wchar_t>::grow(std::size_t);
template void PrintfFormatter<wchar_t>::format(WCStringRef format); template void internal::ArgMap<wchar_t>::init(const ArgList &args);
template int internal::CharTraits<wchar_t>::format_float( template int 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, double value); unsigned width, int precision, double value);
template int internal::CharTraits<wchar_t>::format_float( template int 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, long double value); unsigned width, int precision, long double value);
#endif // FMT_HEADER_ONLY #endif // FMT_HEADER_ONLY

7597
include/spdlog/fmt/bundled/format.h
View File

File diff suppressed because it is too large Load Diff

42
include/spdlog/fmt/bundled/ostream.cc
Unescape Escape View File

@ -11,25 +11,27 @@ For the license information refer to format.h.
namespace fmt { namespace fmt {
namespace internal { namespace internal {
FMT_FUNC void write(std::ostream &os, Writer &w) { FMT_FUNC void write(std::ostream &os, Writer &w)
const char *data = w.data(); {
typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize; const char *data = w.data();
UnsignedStreamSize size = w.size(); typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
UnsignedStreamSize max_size = UnsignedStreamSize size = w.size();
internal::to_unsigned((std::numeric_limits<std::streamsize>::max)()); UnsignedStreamSize max_size =
do { internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
UnsignedStreamSize n = size <= max_size ? size : max_size; do {
os.write(data, static_cast<std::streamsize>(n)); UnsignedStreamSize n = size <= max_size ? size : max_size;
data += n; os.write(data, static_cast<std::streamsize>(n));
size -= n; data += n;
} while (size != 0); size -= n;
} } while (size != 0);
} }
}
FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) { FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args)
MemoryWriter w; {
w.write(format_str, args); MemoryWriter w;
internal::write(os, w); w.write(format_str, args);
} internal::write(os, w);
}
} // namespace fmt } // namespace fmt

189
include/spdlog/fmt/bundled/ostream.h
Unescape Escape View File

@ -11,104 +11,101 @@ For the license information refer to format.h.
#define FMT_OSTREAM_H_ #define FMT_OSTREAM_H_
// commented out by spdlog // commented out by spdlog
//#include "format.h" // #include "format.h"
#include <ostream> #include <ostream>
namespace fmt namespace fmt {
{
namespace internal {
namespace internal
{ template <class Char>
class FormatBuf: public std::basic_streambuf<Char>
template <class Char> {
class FormatBuf : public std::basic_streambuf<Char> private:
{ typedef typename std::basic_streambuf<Char>::int_type int_type;
private: typedef typename std::basic_streambuf<Char>::traits_type traits_type;
typedef typename std::basic_streambuf<Char>::int_type int_type;
typedef typename std::basic_streambuf<Char>::traits_type traits_type; Buffer<Char> &buffer_;
Char *start_;
Buffer<Char> &buffer_;
Char *start_; public:
FormatBuf(Buffer<Char> &buffer): buffer_(buffer), start_(&buffer[0])
public: {
FormatBuf(Buffer<Char> &buffer) : buffer_(buffer), start_(&buffer[0]) this->setp(start_, start_ + buffer_.capacity());
{ }
this->setp(start_, start_ + buffer_.capacity());
} int_type overflow(int_type ch = traits_type::eof())
{
int_type overflow(int_type ch = traits_type::eof()) if (!traits_type::eq_int_type(ch, traits_type::eof())) {
{ size_t buf_size = size();
if (!traits_type::eq_int_type(ch, traits_type::eof())) buffer_.resize(buf_size);
{ buffer_.reserve(buf_size * 2);
size_t buf_size = size();
buffer_.resize(buf_size); start_ = &buffer_[0];
buffer_.reserve(buf_size * 2); start_[buf_size] = traits_type::to_char_type(ch);
this->setp(start_ + buf_size + 1, start_ + buf_size * 2);
start_ = &buffer_[0]; }
start_[buf_size] = traits_type::to_char_type(ch); return ch;
this->setp(start_ + buf_size + 1, start_ + buf_size * 2); }
}
return ch; size_t size() const
} {
return to_unsigned(this->pptr() - start_);
size_t size() const }
{ };
return to_unsigned(this->pptr() - start_);
} Yes &convert(std::ostream &);
};
struct DummyStream: std::ostream
Yes &convert(std::ostream &); {
DummyStream(); // Suppress a bogus warning in MSVC.
struct DummyStream : std::ostream // Hide all operator<< overloads from std::ostream.
{ void operator<<(Null<>);
DummyStream(); // Suppress a bogus warning in MSVC. };
// Hide all operator<< overloads from std::ostream.
void operator<<(Null<>); No &operator<<(std::ostream &, int);
};
template<typename T>
No &operator<<(std::ostream &, int); struct ConvertToIntImpl<T, true>
{
template<typename T> // Convert to int only if T doesn't have an overloaded operator<<.
struct ConvertToIntImpl<T, true> enum
{ {
// Convert to int only if T doesn't have an overloaded operator<<. value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
enum };
{ };
value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
}; // Write the content of w to os.
}; void write(std::ostream &os, Writer &w);
} // namespace internal
// Write the content of w to os.
void write(std::ostream &os, Writer &w); // Formats a value.
} // namespace internal template <typename Char, typename ArgFormatter, typename T>
void format_arg(BasicFormatter<Char, ArgFormatter> &f,
// Formats a value. const Char *&format_str, const T &value)
template <typename Char, typename ArgFormatter, typename T> {
void format_arg(BasicFormatter<Char, ArgFormatter> &f, internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
const Char *&format_str, const T &value)
{ internal::FormatBuf<Char> format_buf(buffer);
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer; std::basic_ostream<Char> output(&format_buf);
output << value;
internal::FormatBuf<Char> format_buf(buffer);
std::basic_ostream<Char> output(&format_buf); BasicStringRef<Char> str(&buffer[0], format_buf.size());
output << value; typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
format_str = f.format(format_str, MakeArg(str));
BasicStringRef<Char> str(&buffer[0], format_buf.size()); }
typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
format_str = f.format(format_str, MakeArg(str)); /**
} \rst
Prints formatted data to the stream *os*.
/**
\rst **Example**::
Prints formatted data to the stream *os*.
print(cerr, "Don't {}!", "panic");
**Example**:: \endrst
*/
print(cerr, "Don't {}!", "panic"); FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
\endrst FMT_VARIADIC(void, print, std::ostream &, CStringRef)
*/
FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
FMT_VARIADIC(void, print, std::ostream &, CStringRef)
} // namespace fmt } // namespace fmt
#ifdef FMT_HEADER_ONLY #ifdef FMT_HEADER_ONLY

1229
include/spdlog/fmt/bundled/printf.h
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save