225 lines
7.2 KiB
C++
225 lines
7.2 KiB
C++
//
|
|
// Copyright(c) 2015 Gabi Melman.
|
|
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
|
|
//
|
|
|
|
#pragma once
|
|
|
|
#include <cctype>
|
|
#include <spdlog/common.h>
|
|
|
|
#if defined(__has_include)
|
|
#if __has_include(<version>)
|
|
#include <version>
|
|
#endif
|
|
#endif
|
|
|
|
#if __cpp_lib_span >= 202002L
|
|
#include <span>
|
|
#endif
|
|
|
|
//
|
|
// Support for logging binary data as hex
|
|
// format flags, any combination of the following:
|
|
// {:X} - print in uppercase.
|
|
// {:s} - don't separate each byte with space.
|
|
// {:p} - don't print the position on each line start.
|
|
// {:n} - don't split the output to lines.
|
|
// {:a} - show ASCII if :n is not set
|
|
|
|
//
|
|
// Examples:
|
|
//
|
|
// std::vector<char> v(200, 0x0b);
|
|
// logger->info("Some buffer {}", spdlog::to_hex(v));
|
|
// char buf[128];
|
|
// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf)));
|
|
// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf), 16));
|
|
|
|
namespace spdlog {
|
|
namespace details {
|
|
|
|
template <typename It>
|
|
class dump_info {
|
|
public:
|
|
dump_info(It range_begin, It range_end, size_t size_per_line)
|
|
: begin_(range_begin),
|
|
end_(range_end),
|
|
size_per_line_(size_per_line) {}
|
|
|
|
// do not use begin() and end() to avoid collision with fmt/ranges
|
|
It get_begin() const { return begin_; }
|
|
It get_end() const { return end_; }
|
|
size_t size_per_line() const { return size_per_line_; }
|
|
|
|
private:
|
|
It begin_, end_;
|
|
size_t size_per_line_;
|
|
};
|
|
} // namespace details
|
|
|
|
// create a dump_info that wraps the given container
|
|
template <typename Container>
|
|
inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container,
|
|
size_t size_per_line = 32) {
|
|
static_assert(sizeof(typename Container::value_type) == 1,
|
|
"sizeof(Container::value_type) != 1");
|
|
using Iter = typename Container::const_iterator;
|
|
return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
|
|
}
|
|
|
|
#if __cpp_lib_span >= 202002L
|
|
|
|
template <typename Value, size_t Extent>
|
|
inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex(
|
|
const std::span<Value, Extent> &container, size_t size_per_line = 32) {
|
|
using Container = std::span<Value, Extent>;
|
|
static_assert(sizeof(typename Container::value_type) == 1,
|
|
"sizeof(Container::value_type) != 1");
|
|
using Iter = typename Container::iterator;
|
|
return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line);
|
|
}
|
|
|
|
#endif
|
|
|
|
// create dump_info from ranges
|
|
template <typename It>
|
|
inline details::dump_info<It> to_hex(const It range_begin,
|
|
const It range_end,
|
|
size_t size_per_line = 32) {
|
|
return details::dump_info<It>(range_begin, range_end, size_per_line);
|
|
}
|
|
|
|
} // namespace spdlog
|
|
|
|
namespace
|
|
#ifdef SPDLOG_USE_STD_FORMAT
|
|
std
|
|
#else
|
|
fmt
|
|
#endif
|
|
{
|
|
|
|
template <typename T>
|
|
struct formatter<spdlog::details::dump_info<T>, char> {
|
|
const char delimiter = ' ';
|
|
bool put_newlines = true;
|
|
bool put_delimiters = true;
|
|
bool use_uppercase = false;
|
|
bool put_positions = true; // position on start of each line
|
|
bool show_ascii = false;
|
|
|
|
// parse the format string flags
|
|
template <typename ParseContext>
|
|
SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
|
|
auto it = ctx.begin();
|
|
while (it != ctx.end() && *it != '}') {
|
|
switch (*it) {
|
|
case 'X':
|
|
use_uppercase = true;
|
|
break;
|
|
case 's':
|
|
put_delimiters = false;
|
|
break;
|
|
case 'p':
|
|
put_positions = false;
|
|
break;
|
|
case 'n':
|
|
put_newlines = false;
|
|
show_ascii = false;
|
|
break;
|
|
case 'a':
|
|
if (put_newlines) {
|
|
show_ascii = true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
++it;
|
|
}
|
|
return it;
|
|
}
|
|
|
|
// format the given bytes range as hex
|
|
template <typename FormatContext, typename Container>
|
|
auto format(const spdlog::details::dump_info<Container> &the_range, FormatContext &ctx) const
|
|
-> decltype(ctx.out()) {
|
|
SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF";
|
|
SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef";
|
|
const char *hex_chars = use_uppercase ? hex_upper : hex_lower;
|
|
|
|
#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION < 60000
|
|
auto inserter = ctx.begin();
|
|
#else
|
|
auto inserter = ctx.out();
|
|
#endif
|
|
|
|
int size_per_line = static_cast<int>(the_range.size_per_line());
|
|
auto start_of_line = the_range.get_begin();
|
|
for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) {
|
|
auto ch = static_cast<unsigned char>(*i);
|
|
|
|
if (put_newlines &&
|
|
(i == the_range.get_begin() || i - start_of_line >= size_per_line)) {
|
|
if (show_ascii && i != the_range.get_begin()) {
|
|
*inserter++ = delimiter;
|
|
*inserter++ = delimiter;
|
|
for (auto j = start_of_line; j < i; j++) {
|
|
auto pc = static_cast<unsigned char>(*j);
|
|
*inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
|
|
}
|
|
}
|
|
|
|
put_newline(inserter, static_cast<size_t>(i - the_range.get_begin()));
|
|
|
|
// put first byte without delimiter in front of it
|
|
*inserter++ = hex_chars[(ch >> 4) & 0x0f];
|
|
*inserter++ = hex_chars[ch & 0x0f];
|
|
start_of_line = i;
|
|
continue;
|
|
}
|
|
|
|
if (put_delimiters && i != the_range.get_begin()) {
|
|
*inserter++ = delimiter;
|
|
}
|
|
|
|
*inserter++ = hex_chars[(ch >> 4) & 0x0f];
|
|
*inserter++ = hex_chars[ch & 0x0f];
|
|
}
|
|
if (show_ascii) // add ascii to last line
|
|
{
|
|
if (the_range.get_end() - the_range.get_begin() > size_per_line) {
|
|
auto blank_num = size_per_line - (the_range.get_end() - start_of_line);
|
|
while (blank_num-- > 0) {
|
|
*inserter++ = delimiter;
|
|
*inserter++ = delimiter;
|
|
if (put_delimiters) {
|
|
*inserter++ = delimiter;
|
|
}
|
|
}
|
|
}
|
|
*inserter++ = delimiter;
|
|
*inserter++ = delimiter;
|
|
for (auto j = start_of_line; j != the_range.get_end(); j++) {
|
|
auto pc = static_cast<unsigned char>(*j);
|
|
*inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.';
|
|
}
|
|
}
|
|
return inserter;
|
|
}
|
|
|
|
// put newline(and position header)
|
|
template <typename It>
|
|
void put_newline(It inserter, std::size_t pos) const {
|
|
#ifdef _WIN32
|
|
*inserter++ = '\r';
|
|
#endif
|
|
*inserter++ = '\n';
|
|
|
|
if (put_positions) {
|
|
spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos);
|
|
}
|
|
}
|
|
};
|
|
} // namespace std
|