249 lines
7.2 KiB
C++
249 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
|