leavelet/fmt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

internal -> detail (#1538)

Browse Source
This commit is contained in:
Victor Zverovich
2020-05-10 07:34:30 -07:00
parent 963ee08310
commit 8069265373
25 changed files with 738 additions and 762 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/fmt/core.h
+127 -130
View File
@@ -272,7 +272,7 @@ struct monostate {};
// to workaround a bug in MSVC 2019 (see #1140 and #1186).
#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
namespace internal {
namespace detail {
// A helper function to suppress bogus "conditional expression is constant"
// warnings.
@@ -292,7 +292,7 @@ FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
# define FMT_ASSERT(condition, message) \
((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
? (void)0 \
: ::fmt::internal::assert_fail(__FILE__, __LINE__, (message)))
: ::fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
# endif
#endif
@@ -338,10 +338,12 @@ using char8_type = char8_t;
#else
enum char8_type : unsigned char {};
#endif
} // namespace internal
} // namespace detail
namespace internal = detail; // DEPRECATED
template <typename... Ts>
using void_t = typename internal::void_t_impl<Ts...>::type;
using void_t = typename detail::void_t_impl<Ts...>::type;
/**
An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
@@ -385,9 +387,8 @@ template <typename Char> class basic_string_view {
: data_(s.data()),
size_(s.size()) {}
template <
typename S,
FMT_ENABLE_IF(std::is_same<S, internal::std_string_view<Char>>::value)>
template <typename S, FMT_ENABLE_IF(std::is_same<
S, detail::std_string_view<Char>>::value)>
FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),
size_(s.size()) {}
@@ -443,7 +444,7 @@ using wstring_view = basic_string_view<wchar_t>;
template <typename T> struct is_char : std::false_type {};
template <> struct is_char<char> : std::true_type {};
template <> struct is_char<wchar_t> : std::true_type {};
template <> struct is_char<internal::char8_type> : std::true_type {};
template <> struct is_char<detail::char8_type> : std::true_type {};
template <> struct is_char<char16_t> : std::true_type {};
template <> struct is_char<char32_t> : std::true_type {};
@@ -480,9 +481,8 @@ inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
}
template <typename Char,
FMT_ENABLE_IF(!std::is_empty<internal::std_string_view<Char>>::value)>
inline basic_string_view<Char> to_string_view(
internal::std_string_view<Char> s) {
FMT_ENABLE_IF(!std::is_empty<detail::std_string_view<Char>>::value)>
inline basic_string_view<Char> to_string_view(detail::std_string_view<Char> s) {
return s;
}
@@ -498,7 +498,7 @@ constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
return s;
}
namespace internal {
namespace detail {
void to_string_view(...);
using fmt::v6::to_string_view;
@@ -522,10 +522,10 @@ struct error_handler {
// This function is intentionally not constexpr to give a compile-time error.
FMT_NORETURN FMT_API void on_error(const char* message);
};
} // namespace internal
} // namespace detail
/** String's character type. */
template <typename S> using char_t = typename internal::char_t_impl<S>::type;
template <typename S> using char_t = typename detail::char_t_impl<S>::type;
/**
\rst
@@ -543,7 +543,7 @@ template <typename S> using char_t = typename internal::char_t_impl<S>::type;
+-----------------------+-------------------------------------+
\endrst
*/
template <typename Char, typename ErrorHandler = internal::error_handler>
template <typename Char, typename ErrorHandler = detail::error_handler>
class basic_format_parse_context : private ErrorHandler {
private:
basic_string_view<Char> format_str_;
@@ -570,7 +570,7 @@ class basic_format_parse_context : private ErrorHandler {
/** Advances the begin iterator to ``it``. */
FMT_CONSTEXPR void advance_to(iterator it) {
format_str_.remove_prefix(internal::to_unsigned(it - begin()));
format_str_.remove_prefix(detail::to_unsigned(it - begin()));
}
/**
@@ -625,7 +625,7 @@ template <typename T, typename Context>
using has_formatter =
std::is_constructible<typename Context::template formatter_type<T>>;
namespace internal {
namespace detail {
/** A contiguous memory buffer with an optional growing ability. */
template <typename T> class buffer {
@@ -749,8 +749,7 @@ using has_fallback_formatter =
struct view {};
template <typename Char, typename T>
struct named_arg : view {
template <typename Char, typename T> struct named_arg : view {
const Char* name;
const T& value;
named_arg(const Char* n, const T& v) : name(n), value(v) {}
@@ -1094,17 +1093,17 @@ enum { packed_arg_bits = 4 };
enum { max_packed_args = 62 / packed_arg_bits };
enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
enum : unsigned long long { has_named_args_bit = 1ULL << 62 };
} // namespace internal
} // namespace detail
// A formatting argument. It is a trivially copyable/constructible type to
// allow storage in basic_memory_buffer.
template <typename Context> class basic_format_arg {
private:
internal::value<Context> value_;
internal::type type_;
detail::value<Context> value_;
detail::type type_;
template <typename ContextType, typename T>
friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(
friend FMT_CONSTEXPR basic_format_arg<ContextType> detail::make_arg(
const T& value);
template <typename Visitor, typename Ctx>
@@ -1118,15 +1117,15 @@ template <typename Context> class basic_format_arg {
using char_type = typename Context::char_type;
template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
friend struct internal::arg_data;
friend struct detail::arg_data;
basic_format_arg(const internal::named_arg_info<char_type>* args, size_t size)
basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
: value_(args, size) {}
public:
class handle {
public:
explicit handle(internal::custom_value<Context> custom) : custom_(custom) {}
explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}
void format(typename Context::parse_context_type& parse_ctx,
Context& ctx) const {
@@ -1134,19 +1133,19 @@ template <typename Context> class basic_format_arg {
}
private:
internal::custom_value<Context> custom_;
detail::custom_value<Context> custom_;
};
constexpr basic_format_arg() : type_(internal::type::none_type) {}
constexpr basic_format_arg() : type_(detail::type::none_type) {}
constexpr explicit operator bool() const FMT_NOEXCEPT {
return type_ != internal::type::none_type;
return type_ != detail::type::none_type;
}
internal::type type() const { return type_; }
detail::type type() const { return type_; }
bool is_integral() const { return internal::is_integral_type(type_); }
bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }
bool is_integral() const { return detail::is_integral_type(type_); }
bool is_arithmetic() const { return detail::is_arithmetic_type(type_); }
};
/**
@@ -1162,50 +1161,50 @@ FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
-> decltype(vis(0)) {
using char_type = typename Context::char_type;
switch (arg.type_) {
case internal::type::none_type:
case detail::type::none_type:
break;
case internal::type::int_type:
case detail::type::int_type:
return vis(arg.value_.int_value);
case internal::type::uint_type:
case detail::type::uint_type:
return vis(arg.value_.uint_value);
case internal::type::long_long_type:
case detail::type::long_long_type:
return vis(arg.value_.long_long_value);
case internal::type::ulong_long_type:
case detail::type::ulong_long_type:
return vis(arg.value_.ulong_long_value);
#if FMT_USE_INT128
case internal::type::int128_type:
case detail::type::int128_type:
return vis(arg.value_.int128_value);
case internal::type::uint128_type:
case detail::type::uint128_type:
return vis(arg.value_.uint128_value);
#else
case internal::type::int128_type:
case internal::type::uint128_type:
case detail::type::int128_type:
case detail::type::uint128_type:
break;
#endif
case internal::type::bool_type:
case detail::type::bool_type:
return vis(arg.value_.bool_value);
case internal::type::char_type:
case detail::type::char_type:
return vis(arg.value_.char_value);
case internal::type::float_type:
case detail::type::float_type:
return vis(arg.value_.float_value);
case internal::type::double_type:
case detail::type::double_type:
return vis(arg.value_.double_value);
case internal::type::long_double_type:
case detail::type::long_double_type:
return vis(arg.value_.long_double_value);
case internal::type::cstring_type:
case detail::type::cstring_type:
return vis(arg.value_.string.data);
case internal::type::string_type:
case detail::type::string_type:
return vis(basic_string_view<char_type>(arg.value_.string.data,
arg.value_.string.size));
case internal::type::pointer_type:
case detail::type::pointer_type:
return vis(arg.value_.pointer);
case internal::type::custom_type:
case detail::type::custom_type:
return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
}
return vis(monostate());
}
namespace internal {
namespace detail {
// A type-erased reference to an std::locale to avoid heavy <locale> include.
class locale_ref {
private:
@@ -1291,7 +1290,7 @@ class dynamic_arg_list {
return value;
}
};
} // namespace internal
} // namespace detail
// Formatting context.
template <typename OutputIt, typename Char> class basic_format_context {
@@ -1302,7 +1301,7 @@ template <typename OutputIt, typename Char> class basic_format_context {
private:
OutputIt out_;
basic_format_args<basic_format_context> args_;
internal::locale_ref loc_;
detail::locale_ref loc_;
public:
using iterator = OutputIt;
@@ -1318,7 +1317,7 @@ template <typename OutputIt, typename Char> class basic_format_context {
*/
basic_format_context(OutputIt out,
basic_format_args<basic_format_context> ctx_args,
internal::locale_ref loc = internal::locale_ref())
detail::locale_ref loc = detail::locale_ref())
: out_(out), args_(ctx_args), loc_(loc) {}
format_arg arg(int id) const { return args_.get(id); }
@@ -1327,7 +1326,7 @@ template <typename OutputIt, typename Char> class basic_format_context {
// specified name.
format_arg arg(basic_string_view<char_type> name) { return args_.get(name); }
internal::error_handler error_handler() { return {}; }
detail::error_handler error_handler() { return {}; }
void on_error(const char* message) { error_handler().on_error(message); }
// Returns an iterator to the beginning of the output range.
@@ -1336,13 +1335,12 @@ template <typename OutputIt, typename Char> class basic_format_context {
// Advances the begin iterator to ``it``.
void advance_to(iterator it) { out_ = it; }
internal::locale_ref locale() { return loc_; }
detail::locale_ref locale() { return loc_; }
};
template <typename Char>
using buffer_context =
basic_format_context<std::back_insert_iterator<internal::buffer<Char>>,
Char>;
basic_format_context<std::back_insert_iterator<detail::buffer<Char>>, Char>;
using format_context = buffer_context<char>;
using wformat_context = buffer_context<wchar_t>;
@@ -1362,23 +1360,23 @@ class format_arg_store
{
private:
static const size_t num_args = sizeof...(Args);
static const size_t num_named_args = internal::count_named_args<Args...>();
static const bool is_packed = num_args <= internal::max_packed_args;
static const size_t num_named_args = detail::count_named_args<Args...>();
static const bool is_packed = num_args <= detail::max_packed_args;
using value_type = conditional_t<is_packed, internal::value<Context>,
using value_type = conditional_t<is_packed, detail::value<Context>,
basic_format_arg<Context>>;
internal::arg_data<value_type, typename Context::char_type, num_args,
num_named_args>
detail::arg_data<value_type, typename Context::char_type, num_args,
num_named_args>
data_;
friend class basic_format_args<Context>;
static constexpr unsigned long long desc =
(is_packed ? internal::encode_types<Context, Args...>()
: internal::is_unpacked_bit | num_args) |
(is_packed ? detail::encode_types<Context, Args...>()
: detail::is_unpacked_bit | num_args) |
(num_named_args != 0
? static_cast<unsigned long long>(internal::has_named_args_bit)
? static_cast<unsigned long long>(detail::has_named_args_bit)
: 0);
public:
@@ -1387,10 +1385,10 @@ class format_arg_store
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
basic_format_args<Context>(*this),
#endif
data_{internal::make_arg<
data_{detail::make_arg<
is_packed, Context,
internal::mapped_type_constant<Args, Context>::value>(args)...} {
internal::init_named_args(data_.named_args(), 0, 0, args...);
detail::mapped_type_constant<Args, Context>::value>(args)...} {
detail::init_named_args(data_.named_args(), 0, 0, args...);
}
};
@@ -1419,8 +1417,8 @@ inline format_arg_store<Context, Args...> make_format_args(
\endrst
*/
template <typename Char, typename T>
inline internal::named_arg<Char, T> arg(const Char* name, const T& arg) {
static_assert(!internal::is_named_arg<T>(), "nested named arguments");
inline detail::named_arg<Char, T> arg(const Char* name, const T& arg) {
static_assert(!detail::is_named_arg<T>(), "nested named arguments");
return {name, arg};
}
@@ -1445,38 +1443,38 @@ class dynamic_format_arg_store
using char_type = typename Context::char_type;
template <typename T> struct need_copy {
static constexpr internal::type mapped_type =
internal::mapped_type_constant<T, Context>::value;
static constexpr detail::type mapped_type =
detail::mapped_type_constant<T, Context>::value;
enum {
value = !(internal::is_reference_wrapper<T>::value ||
value = !(detail::is_reference_wrapper<T>::value ||
std::is_same<T, basic_string_view<char_type>>::value ||
std::is_same<T, internal::std_string_view<char_type>>::value ||
(mapped_type != internal::type::cstring_type &&
mapped_type != internal::type::string_type &&
mapped_type != internal::type::custom_type))
std::is_same<T, detail::std_string_view<char_type>>::value ||
(mapped_type != detail::type::cstring_type &&
mapped_type != detail::type::string_type &&
mapped_type != detail::type::custom_type))
};
};
template <typename T>
using stored_type = conditional_t<internal::is_string<T>::value,
using stored_type = conditional_t<detail::is_string<T>::value,
std::basic_string<char_type>, T>;
// Storage of basic_format_arg must be contiguous.
std::vector<basic_format_arg<Context>> data_;
std::vector<internal::named_arg_info<char_type>> named_info_;
std::vector<detail::named_arg_info<char_type>> named_info_;
// Storage of arguments not fitting into basic_format_arg must grow
// without relocation because items in data_ refer to it.
internal::dynamic_arg_list dynamic_args_;
detail::dynamic_arg_list dynamic_args_;
friend class basic_format_args<Context>;
unsigned long long get_types() const {
return internal::is_unpacked_bit | data_.size() |
(named_info_.empty() ? 0ULL
: static_cast<unsigned long long>(
internal::has_named_args_bit));
return detail::is_unpacked_bit | data_.size() |
(named_info_.empty()
? 0ULL
: static_cast<unsigned long long>(detail::has_named_args_bit));
}
const basic_format_arg<Context>* data() const {
@@ -1484,17 +1482,16 @@ class dynamic_format_arg_store
}
template <typename T> void emplace_arg(const T& arg) {
data_.emplace_back(internal::make_arg<Context>(arg));
data_.emplace_back(detail::make_arg<Context>(arg));
}
template <typename T>
void emplace_arg(const internal::named_arg<char_type, T>& arg) {
void emplace_arg(const detail::named_arg<char_type, T>& arg) {
if (named_info_.empty()) {
constexpr const internal::named_arg_info<char_type>* zero_ptr{nullptr};
constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
data_.insert(data_.begin(), {zero_ptr, 0});
}
data_.emplace_back(
internal::make_arg<Context>(internal::unwrap(arg.value)));
data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
data->pop_back();
};
@@ -1524,10 +1521,10 @@ class dynamic_format_arg_store
\endrst
*/
template <typename T> void push_back(const T& arg) {
if (internal::const_check(need_copy<T>::value))
if (detail::const_check(need_copy<T>::value))
emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
else
emplace_arg(internal::unwrap(arg));
emplace_arg(detail::unwrap(arg));
}
/**
@@ -1553,7 +1550,7 @@ class dynamic_format_arg_store
*/
template <typename T> void push_back(std::reference_wrapper<T> arg) {
static_assert(
internal::is_named_arg<typename std::remove_cv<T>::type>::value ||
detail::is_named_arg<typename std::remove_cv<T>::type>::value ||
need_copy<T>::value,
"objects of built-in types and string views are always copied");
emplace_arg(arg.get());
@@ -1565,10 +1562,10 @@ class dynamic_format_arg_store
argument.
*/
template <typename T>
void push_back(const internal::named_arg<char_type, T>& arg) {
void push_back(const detail::named_arg<char_type, T>& arg) {
const char_type* arg_name =
dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
if (internal::const_check(need_copy<T>::value)) {
if (detail::const_check(need_copy<T>::value)) {
emplace_arg(
fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
} else {
@@ -1604,23 +1601,23 @@ template <typename Context> class basic_format_args {
// locality and reduce compiled code size since storing larger objects
// may require more code (at least on x86-64) even if the same amount of
// data is actually copied to stack. It saves ~10% on the bloat test.
const internal::value<Context>* values_;
const detail::value<Context>* values_;
const format_arg* args_;
};
bool is_packed() const { return (desc_ & internal::is_unpacked_bit) == 0; }
bool is_packed() const { return (desc_ & detail::is_unpacked_bit) == 0; }
bool has_named_args() const {
return (desc_ & internal::has_named_args_bit) != 0;
return (desc_ & detail::has_named_args_bit) != 0;
}
internal::type type(int index) const {
int shift = index * internal::packed_arg_bits;
unsigned int mask = (1 << internal::packed_arg_bits) - 1;
return static_cast<internal::type>((desc_ >> shift) & mask);
detail::type type(int index) const {
int shift = index * detail::packed_arg_bits;
unsigned int mask = (1 << detail::packed_arg_bits) - 1;
return static_cast<detail::type>((desc_ >> shift) & mask);
}
basic_format_args(unsigned long long desc,
const internal::value<Context>* values)
const detail::value<Context>* values)
: desc_(desc), values_(values) {}
basic_format_args(unsigned long long desc, const format_arg* args)
: desc_(desc), args_(args) {}
@@ -1652,8 +1649,8 @@ template <typename Context> class basic_format_args {
\endrst
*/
basic_format_args(const format_arg* args, int count)
: basic_format_args(
internal::is_unpacked_bit | internal::to_unsigned(count), args) {}
: basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count),
args) {}
/** Returns the argument with the specified id. */
format_arg get(int id) const {
@@ -1662,9 +1659,9 @@ template <typename Context> class basic_format_args {
if (id < max_size()) arg = args_[id];
return arg;
}
if (id >= internal::max_packed_args) return arg;
if (id >= detail::max_packed_args) return arg;
arg.type_ = type(id);
if (arg.type_ == internal::type::none_type) return arg;
if (arg.type_ == detail::type::none_type) return arg;
arg.value_ = values_[id];
return arg;
}
@@ -1680,9 +1677,9 @@ template <typename Context> class basic_format_args {
}
int max_size() const {
unsigned long long max_packed = internal::max_packed_args;
unsigned long long max_packed = detail::max_packed_args;
return static_cast<int>(is_packed() ? max_packed
: desc_ & ~internal::is_unpacked_bit);
: desc_ & ~detail::is_unpacked_bit);
}
};
@@ -1702,9 +1699,9 @@ template <typename Char>
struct is_contiguous<std::basic_string<Char>> : std::true_type {};
template <typename Char>
struct is_contiguous<internal::buffer<Char>> : std::true_type {};
struct is_contiguous<detail::buffer<Char>> : std::true_type {};
namespace internal {
namespace detail {
template <typename OutputIt>
struct is_contiguous_back_insert_iterator : std::false_type {};
@@ -1753,38 +1750,38 @@ FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
#ifndef _WIN32
inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
#endif
} // namespace internal
} // namespace detail
/** Formats a string and writes the output to ``out``. */
// GCC 8 and earlier cannot handle std::back_insert_iterator<Container> with
// vformat_to<ArgFormatter>(...) overload, so SFINAE on iterator type instead.
template <typename OutputIt, typename S, typename Char = char_t<S>,
FMT_ENABLE_IF(
internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
template <
typename OutputIt, typename S, typename Char = char_t<S>,
FMT_ENABLE_IF(detail::is_contiguous_back_insert_iterator<OutputIt>::value)>
OutputIt vformat_to(
OutputIt out, const S& format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
auto& c = internal::get_container(out);
internal::container_buffer<remove_reference_t<decltype(c)>> buf(c);
internal::vformat_to(buf, to_string_view(format_str), args);
auto& c = detail::get_container(out);
detail::container_buffer<remove_reference_t<decltype(c)>> buf(c);
detail::vformat_to(buf, to_string_view(format_str), args);
return out;
}
template <typename Container, typename S, typename... Args,
FMT_ENABLE_IF(
is_contiguous<Container>::value&& internal::is_string<S>::value)>
is_contiguous<Container>::value&& detail::is_string<S>::value)>
inline std::back_insert_iterator<Container> format_to(
std::back_insert_iterator<Container> out, const S& format_str,
Args&&... args) {
return vformat_to(out, to_string_view(format_str),
internal::make_args_checked<Args...>(format_str, args...));
detail::make_args_checked<Args...>(format_str, args...));
}
template <typename S, typename Char = char_t<S>>
FMT_INLINE std::basic_string<Char> vformat(
const S& format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
return internal::vformat(to_string_view(format_str), args);
return detail::vformat(to_string_view(format_str), args);
}
/**
@@ -1801,8 +1798,8 @@ FMT_INLINE std::basic_string<Char> vformat(
// std::basic_string<char_t<S>> to reduce the symbol size.
template <typename S, typename... Args, typename Char = char_t<S>>
FMT_INLINE std::basic_string<Char> format(const S& format_str, Args&&... args) {
const auto& vargs = internal::make_args_checked<Args...>(format_str, args...);
return internal::vformat(to_string_view(format_str), vargs);
const auto& vargs = detail::make_args_checked<Args...>(format_str, args...);
return detail::vformat(to_string_view(format_str), vargs);
}
FMT_API void vprint(string_view, format_args);
@@ -1821,10 +1818,10 @@ FMT_API void vprint(std::FILE*, string_view, format_args);
*/
template <typename S, typename... Args, typename Char = char_t<S>>
inline void print(std::FILE* f, const S& format_str, Args&&... args) {
const auto& vargs = internal::make_args_checked<Args...>(format_str, args...);
return internal::is_unicode<Char>()
const auto& vargs = detail::make_args_checked<Args...>(format_str, args...);
return detail::is_unicode<Char>()
? vprint(f, to_string_view(format_str), vargs)
: internal::vprint_mojibake(f, to_string_view(format_str), vargs);
: detail::vprint_mojibake(f, to_string_view(format_str), vargs);
}
/**
@@ -1840,11 +1837,11 @@ inline void print(std::FILE* f, const S& format_str, Args&&... args) {
*/
template <typename S, typename... Args, typename Char = char_t<S>>
inline void print(const S& format_str, Args&&... args) {
const auto& vargs = internal::make_args_checked<Args...>(format_str, args...);
return internal::is_unicode<Char>()
const auto& vargs = detail::make_args_checked<Args...>(format_str, args...);
return detail::is_unicode<Char>()
? vprint(to_string_view(format_str), vargs)
: internal::vprint_mojibake(stdout, to_string_view(format_str),
vargs);
: detail::vprint_mojibake(stdout, to_string_view(format_str),
vargs);
}
FMT_END_NAMESPACE