+ enum class _Term_char : unsigned char {
+ _Tc_quote = 12,
+ _Tc_apos = 15
+ };
+
+ template<typename _CharT>
+ struct _Escapes
+ {
+ using _Str_view = basic_string_view<_CharT>;
+
+ static consteval
+ _Str_view _S_all()
+ { return _GLIBCXX_WIDEN("\t\\t\n\\n\r\\r\\\\\\\"\\\"'\\'\\u\\x"); }
+
+ static constexpr
+ _CharT _S_term(_Term_char __term)
+ { return _S_all()[static_cast<unsigned char>(__term)]; }
+
+ static consteval
+ _Str_view _S_tab()
+ { return _S_all().substr(0, 3); }
+
+ static consteval
+ _Str_view _S_newline()
+ { return _S_all().substr(3, 3); }
+
+ static consteval
+ _Str_view _S_return()
+ { return _S_all().substr(6, 3); }
+
+ static consteval
+ _Str_view _S_bslash()
+ { return _S_all().substr(9, 3); }
+
+ static consteval
+ _Str_view _S_quote()
+ { return _S_all().substr(12, 3); }
+
+ static consteval
+ _Str_view _S_apos()
+ { return _S_all().substr(15, 3); }
+
+ static consteval
+ _Str_view _S_u()
+ { return _S_all().substr(18, 2); }
+
+ static consteval
+ _Str_view _S_x()
+ { return _S_all().substr(20, 2); }
+ };
+
+ template<typename _CharT>
+ struct _Separators
+ {
+ using _Str_view = basic_string_view<_CharT>;
+
+ static consteval
+ _Str_view _S_all()
+ { return _GLIBCXX_WIDEN("{}"); }
+
+ static consteval
+ _Str_view _S_braces()
+ { return _S_all().substr(0, 2); }
+ };
+
+ template<typename _CharT>
+ constexpr bool __should_escape_ascii(_CharT __c, _Term_char __term)
+ {
+ using _Esc = _Escapes<_CharT>;
+ switch (__c)
+ {
+ case _Esc::_S_tab()[0]:
+ case _Esc::_S_newline()[0]:
+ case _Esc::_S_return()[0]:
+ case _Esc::_S_bslash()[0]:
+ return true;
+ case _Esc::_S_quote()[0]:
+ return __term == _Term_char::_Tc_quote;
+ case _Esc::_S_apos()[0]:
+ return __term == _Term_char::_Tc_apos;
+ default:
+ return (__c >= 0 && __c < 0x20) || __c == 0x7f;
+ };
+ }
+
+ // @pre __c <= 0x10FFFF
+ constexpr bool __should_escape_unicode(char32_t __c, bool __prev_esc)
+ {
+ if (__unicode::__should_escape_category(__c))
+ return __c != U' ';
+ if (!__prev_esc)
+ return false;
+ return __unicode::__grapheme_cluster_break_property(__c)
+ == __unicode::_Gcb_property::_Gcb_Extend;
+ }
+
+ using uint_least32_t = __UINT_LEAST32_TYPE__;
+ template<typename _Out, typename _CharT>
+ _Out
+ __write_escape_seq(_Out __out, uint_least32_t __val,
+ basic_string_view<_CharT> __prefix)
+ {
+ using _Str_view = basic_string_view<_CharT>;
+ constexpr size_t __max = 8;
+ char __buf[__max];
+ const string_view __narrow(
+ __buf,
+ std::__to_chars_i<uint_least32_t>(__buf, __buf + __max, __val, 16).ptr);
+
+ __out = __format::__write(__out, __prefix);
+ *__out = _Separators<_CharT>::_S_braces()[0];
+ ++__out;
+ if constexpr (is_same_v<char, _CharT>)
+ __out = __format::__write(__out, __narrow);
+#ifdef _GLIBCXX_USE_WCHAR_T
+ else
+ {
+ _CharT __wbuf[__max];
+ const size_t __n = __narrow.size();
+ std::__to_wstring_numeric(__narrow.data(), __n, __wbuf);
+ __out = __format::__write(__out, _Str_view(__wbuf, __n));
+ }
+#endif
+ *__out = _Separators<_CharT>::_S_braces()[1];
+ return ++__out;
+ }
+
+ template<typename _Out, typename _CharT>
+ _Out
+ __write_escaped_char(_Out __out, _CharT __c)
+ {
+ using _UChar = make_unsigned_t<_CharT>;
+ using _Esc = _Escapes<_CharT>;
+ switch (__c)
+ {
+ case _Esc::_S_tab()[0]:
+ return __format::__write(__out, _Esc::_S_tab().substr(1, 2));
+ case _Esc::_S_newline()[0]:
+ return __format::__write(__out, _Esc::_S_newline().substr(1, 2));
+ case _Esc::_S_return()[0]:
+ return __format::__write(__out, _Esc::_S_return().substr(1, 2));
+ case _Esc::_S_bslash()[0]:
+ return __format::__write(__out, _Esc::_S_bslash().substr(1, 2));
+ case _Esc::_S_quote()[0]:
+ return __format::__write(__out, _Esc::_S_quote().substr(1, 2));
+ case _Esc::_S_apos()[0]:
+ return __format::__write(__out, _Esc::_S_apos().substr(1, 2));
+ default:
+ return __format::__write_escape_seq(__out,
+ static_cast<_UChar>(__c),
+ _Esc::_S_u());
+ }
+ }
+
+ template<typename _CharT, typename _Out>
+ _Out
+ __write_escaped_ascii(_Out __out,
+ basic_string_view<_CharT> __str,
+ _Term_char __term)
+ {
+ using _Str_view = basic_string_view<_CharT>;
+ auto __first = __str.begin();
+ auto const __last = __str.end();
+ while (__first != __last)
+ {
+ auto __print = __first;
+ // assume anything outside ASCII is printable
+ while (__print != __last
+ && !__format::__should_escape_ascii(*__print, __term))
+ ++__print;
+
+ if (__print != __first)
+ __out = __format::__write(__out, _Str_view(__first, __print));
+
+ if (__print == __last)
+ return __out;
+
+ __first = __print;
+ __out = __format::__write_escaped_char(__out, *__first);
+ ++__first;
+ }
+ return __out;
+ }
+
+ template<typename _CharT, typename _Out>
+ _Out
+ __write_escaped_unicode(_Out __out,
+ basic_string_view<_CharT> __str,
+ _Term_char __term)
+ {
+ using _Str_view = basic_string_view<_CharT>;
+ using _UChar = make_unsigned_t<_CharT>;
+ using _Esc = _Escapes<_CharT>;
+
+ static constexpr char32_t __replace = U'\uFFFD';
+ static constexpr _Str_view __replace_rep = []
+ {
+ // N.B. "\uFFFD" is ill-formed if encoding is not unicode.
+ if constexpr (is_same_v<char, _CharT>)
+ return "\xEF\xBF\xBD";
+ else
+ return L"\xFFFD";
+ }();
+
+ __unicode::_Utf_view<char32_t, _Str_view> __v(std::move(__str));
+ auto __first = __v.begin();
+ auto const __last = __v.end();
+
+ bool __prev_esc = true;
+ while (__first != __last)
+ {
+ bool __esc_ascii = false;
+ bool __esc_unicode = false;
+ bool __esc_replace = false;
+ auto __should_escape = [&](auto const& __it)
+ {
+ if (*__it <= 0x7f)
+ return __esc_ascii
+ = __format::__should_escape_ascii(*__it.base(),
__term);
+ if (__format::__should_escape_unicode(*__it, __prev_esc))
+ return __esc_unicode = true;
+ if (*__it == __replace)
+ {
+ _Str_view __units(__it.base(), __it._M_units());
+ return __esc_replace = (__units != __replace_rep);
+ }
+ return false;
+ };
+
+ auto __print = __first;
+ while (__print != __last && !__should_escape(__print))
+ {
+ __prev_esc = false;
+ ++__print;
+ }
+
+ if (__print != __first)
+ __out = __format::__write(__out, _Str_view(__first.base(),
__print.base()));
+
+ if (__print == __last)
+ return __out;
+
+ __first = __print;
+ if (__esc_ascii)
+ __out = __format::__write_escaped_char(__out, *__first.base());
+ else if (__esc_unicode)
+ __out = __format::__write_escape_seq(__out, *__first, _Esc::_S_u());
+ else // __esc_replace
+ for (_CharT __c : _Str_view(__first.base(), __first._M_units()))
+ __out = __format::__write_escape_seq(__out,
+ static_cast<_UChar>(__c),
+ _Esc::_S_x());
+ __prev_esc = true;
+ ++__first;
+
+ }
+ return __out;
+ }
+
+ template<typename _CharT, typename _Out>
+ _Out
+ __write_escaped(_Out __out, basic_string_view<_CharT> __str, _Term_char
__term)
+ {
+ *__out = _Escapes<_CharT>::_S_term(__term);
+ ++__out;
+
+ if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
+ __out = __format::__write_escaped_unicode(__out, __str, __term);
+ else if constexpr (is_same_v<char, _CharT>
+ && __unicode::__literal_encoding_is_extended_ascii())
+ __out = __format::__write_escaped_ascii(__out, __str, __term);
+ else
+ // TODO Handle non-ascii extended encoding
+ __out = __format::__write_escaped_ascii(__out, __str, __term);
+
+ *__out = _Escapes<_CharT>::_S_term(__term);
+ return ++__out;
+ }
+
// A lightweight optional<locale>.
struct _Optional_locale
{
@@ -961,7 +1268,7 @@ namespace __format
if (*__first == 's')
++__first;
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
else if (*__first == '?')
{
__spec._M_type = _Pres_esc;
@@ -980,43 +1287,71 @@ namespace __format
format(basic_string_view<_CharT> __s,
basic_format_context<_Out, _CharT>& __fc) const
{
- if (_M_spec._M_type == _Pres_esc)
+ constexpr auto __term = __format::_Term_char::_Tc_quote;
+ const auto __write_direct = [&]
{
- // TODO: C++23 escaped string presentation
- }
+ if (_M_spec._M_type == _Pres_esc)
+ return __format::__write_escaped(__fc.out(), __s, __term);
+ else
+ return __format::__write(__fc.out(), __s);
+ };
if (_M_spec._M_width_kind == _WP_none
&& _M_spec._M_prec_kind == _WP_none)
- return __format::__write(__fc.out(), __s);
+ return __write_direct();
- size_t __estimated_width;
- if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
- {
- if (_M_spec._M_prec_kind != _WP_none)
- {
- size_t __prec = _M_spec._M_get_precision(__fc);
- __estimated_width = __unicode::__truncate(__s, __prec);
- }
- else
- __estimated_width = __unicode::__field_width(__s);
- }
- else
- {
- __s = __s.substr(0, _M_spec._M_get_precision(__fc));
- __estimated_width = __s.size();
- }
+ const size_t __prec =
+ _M_spec._M_prec_kind != _WP_none
+ ? _M_spec._M_get_precision(__fc)
+ : basic_string_view<_CharT>::npos;
- return __format::__write_padded_as_spec(__s, __estimated_width,
+ const size_t __estimated_width = _S_trunc(__s, __prec);
+ // N.B. Escaping only increases width
+ if (_M_spec._M_get_width(__fc) <= __estimated_width
+ && _M_spec._M_prec_kind == _WP_none)
+ return __write_direct();
+
+ if (_M_spec._M_type != _Pres_esc)
+ return __format::__write_padded_as_spec(__s, __estimated_width,
+ __fc, _M_spec);
+
+ __format::_Str_sink<_CharT> __sink;
+ __format::_Sink_iter<_CharT> __out(__sink);
+ __format::__write_escaped(__out, __s, __term);
+ basic_string_view<_CharT> __escaped(__sink.view().data(),
+ __sink.view().size());
+ const size_t __escaped_width = _S_trunc(__escaped, __prec);
+ // N.B. [tab:format.type.string] defines '?' as
+ // Copies the escaped string ([format.string.escaped]) to the output,
+ // so precision seem to appy to escaped string.
+ return __format::__write_padded_as_spec(__escaped, __escaped_width,
__fc, _M_spec);
}
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void
set_debug_format() noexcept
{ _M_spec._M_type = _Pres_esc; }
#endif
private:
+ static size_t
+ _S_trunc(basic_string_view<_CharT>& __s, size_t __prec)
+ {
+ if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
+ {
+ if (__prec != basic_string_view<_CharT>::npos)
+ return __unicode::__truncate(__s, __prec);
+ else
+ return __unicode::__field_width(__s);
+ }
+ else
+ {
+ __s = __s.substr(0, __prec);
+ return __s.size();
+ }
+ }
+
_Spec<_CharT> _M_spec{};
};
@@ -1120,7 +1455,7 @@ namespace __format
++__first;
}
break;
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
case '?':
if (__type == _AsChar)
{
@@ -1272,7 +1607,7 @@ namespace __format
_S_character_width(_CharT __c)
{
// N.B. single byte cannot encode charcter of width greater than 1
- if constexpr (sizeof(_CharT) > 1u &&
+ if constexpr (sizeof(_CharT) > 1u &&
__unicode::__literal_encoding_is_unicode<_CharT>())
return __unicode::__field_width(__c);
else
@@ -1286,7 +1621,34 @@ namespace __format
{
return __format::__write_padded_as_spec({&__c, 1u},
_S_character_width(__c),
- __fc, _M_spec);
+ __fc, _M_spec);
+ }
+
+ template<typename _Out>
+ typename basic_format_context<_Out, _CharT>::iterator
+ _M_format_character_escaped(_CharT __c,
+ basic_format_context<_Out, _CharT>& __fc)
const
+ {
+ using _Esc = _Escapes<_CharT>;
+ constexpr auto __term = __format::_Term_char::_Tc_apos;
+ const basic_string_view<_CharT> __in(&__c, 1u);
+ if (_M_spec._M_get_width(__fc) <= 3u)
+ return __format::__write_escaped(__fc.out(), __in, __term);
+
+ _CharT __buf[12];
+ __format::_Fixedbuf_sink<_CharT> __sink(__buf);
+ __format::_Sink_iter<_CharT> __out(__sink);
+ __format::__write_escaped(__out, __in, __term);
+
+ const basic_string_view<_CharT> __escaped = __sink.view();
+ size_t __estimated_width;
+ if (__escaped[1] == _Esc::_S_bslash()[0]) // escape sequence
+ __estimated_width = __escaped.size();
+ else
+ __estimated_width = 2 + _S_character_width(__c);
+ return __format::__write_padded_as_spec(__escaped,
+ __estimated_width,
+ __fc, _M_spec);
}
template<typename _Int>
@@ -1973,15 +2335,12 @@ namespace __format
|| _M_f._M_spec._M_type == __format::_Pres_c)
return _M_f._M_format_character(__u, __fc);
else if (_M_f._M_spec._M_type == __format::_Pres_esc)
- {
- // TODO
- return __fc.out();
- }
+ return _M_f._M_format_character_escaped(__u, __fc);
else
return _M_f.format(static_cast<make_unsigned_t<_CharT>>(__u), __fc);
}
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void
set_debug_format() noexcept
{ _M_f._M_spec._M_type = __format::_Pres_esc; }
@@ -2012,15 +2371,12 @@ namespace __format
|| _M_f._M_spec._M_type == __format::_Pres_c)
return _M_f._M_format_character(__u, __fc);
else if (_M_f._M_spec._M_type == __format::_Pres_esc)
- {
- // TODO
- return __fc.out();
- }
+ return _M_f._M_format_character_escaped(__u, __fc);
else
return _M_f.format(static_cast<unsigned char>(__u), __fc);
}
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void
set_debug_format() noexcept
{ _M_f._M_spec._M_type = __format::_Pres_esc; }
@@ -2050,7 +2406,7 @@ namespace __format
format(_CharT* __u, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format(__u, __fc); }
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
#endif
@@ -2075,7 +2431,7 @@ namespace __format
basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format(__u, __fc); }
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
#endif
@@ -2099,7 +2455,7 @@ namespace __format
basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format({__u, _Nm}, __fc); }
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
#endif
@@ -2123,7 +2479,7 @@ namespace __format
basic_format_context<_Out, char>& __fc) const
{ return _M_f.format(__u, __fc); }
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
#endif
@@ -2148,7 +2504,7 @@ namespace __format
basic_format_context<_Out, wchar_t>& __fc) const
{ return _M_f.format(__u, __fc); }
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
#endif
@@ -2173,7 +2529,7 @@ namespace __format
basic_format_context<_Out, char>& __fc) const
{ return _M_f.format(__u, __fc); }
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
#endif
@@ -2198,7 +2554,7 @@ namespace __format
basic_format_context<_Out, wchar_t>& __fc) const
{ return _M_f.format(__u, __fc); }
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges // C++ >= 23 && HOSTED
constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
#endif
@@ -2859,6 +3215,32 @@ namespace __format
{ return _Sink_iter<_CharT>(*this); }
};
+
+ template<typename _CharT>
+ class _Fixedbuf_sink final : public _Sink<_CharT>
+ {
+ void
+ _M_overflow() override
+ {
+ __glibcxx_assert(false);
+ this->_M_rewind();
+ }
+
+ public:
+ [[__gnu__::__always_inline__]]
+ constexpr explicit
+ _Fixedbuf_sink(span<_CharT> __buf)
+ : _Sink<_CharT>(__buf)
+ { }
+
+ constexpr basic_string_view<_CharT>
+ view() const
+ {
+ auto __s = this->_M_used();
+ return basic_string_view<_CharT>(__s.data(), __s.size());
+ }
+ };
+
// A sink with an internal buffer. This is used to implement concrete sinks.
template<typename _CharT>
class _Buf_sink : public _Sink<_CharT>
@@ -2993,13 +3375,6 @@ namespace __format
}
};
- template<typename _CharT, typename _Alloc = allocator<_CharT>>
- using _Str_sink
- = _Seq_sink<basic_string<_CharT, char_traits<_CharT>, _Alloc>>;
-
- // template<typename _CharT, typename _Alloc = allocator<_CharT>>
- // using _Vec_sink = _Seq_sink<vector<_CharT, _Alloc>>;
-
// A sink that writes to an output iterator.
// Writes to a fixed-size buffer and then flushes to the output iterator
// when the buffer fills up.
@@ -3675,17 +4050,17 @@ namespace __format
return _M_visit([&__vis]<typename _Tp>(_Tp& __val) -> decltype(auto)
{
constexpr bool __user_facing = __is_one_of<_Tp,
- monostate, bool, _CharT,
- int, unsigned int, long long int, unsigned long long int,
- float, double, long double,
- const _CharT*, basic_string_view<_CharT>,
- const void*, handle>::value;
+ monostate, bool, _CharT,
+ int, unsigned int, long long int, unsigned long long int,
+ float, double, long double,
+ const _CharT*, basic_string_view<_CharT>,
+ const void*, handle>::value;
if constexpr (__user_facing)
return std::forward<_Visitor>(__vis)(__val);
else
{
- handle __h(__val);
- return std::forward<_Visitor>(__vis)(__h);
+ handle __h(__val);
+ return std::forward<_Visitor>(__vis)(__h);
}
}, __type);
}
@@ -4781,6 +5156,7 @@ namespace __format
: __format::__range_default_formatter<format_kind<_Rg>, _Rg, _CharT>
{ };
#endif // C++23 formatting ranges
+#undef _GLIBCXX_WIDEN
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
diff --git a/libstdc++-v3/testsuite/23_containers/vector/bool/format.cc
b/libstdc++-v3/testsuite/23_containers/vector/bool/format.cc
index 16f6e86dcee..2586225dd05 100644
--- a/libstdc++-v3/testsuite/23_containers/vector/bool/format.cc
+++ b/libstdc++-v3/testsuite/23_containers/vector/bool/format.cc
@@ -3,7 +3,6 @@
#include <format>
#include <vector>
-#include <chrono> // For _Widen
#include <testsuite_hooks.h>
static_assert(!std::formattable<std::vector<bool>::reference, int>);
@@ -21,7 +20,7 @@ is_format_string_for(const char* str, Args&&... args)
}
}
-#define WIDEN_(C, S) ::std::chrono::__detail::_Widen<C>(S, L##S)
+#define WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
#define WIDEN(S) WIDEN_(_CharT, S)
void
diff --git a/libstdc++-v3/testsuite/std/format/debug.cc
b/libstdc++-v3/testsuite/std/format/debug.cc
new file mode 100644
index 00000000000..07cd1e0e349
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/format/debug.cc
@@ -0,0 +1,454 @@
+// { dg-options "-fexec-charset=UTF-8 -fwide-exec-charset=UTF-32LE
-DUNICODE_ENC" }
+// { dg-do run { target c++23 } }
+// { dg-add-options no_pch }
+
+#include <format>
+#include <testsuite_hooks.h>
+
+std::string
+fdebug(char t)
+{ return std::format("{:?}", t); }
+
+std::wstring
+fdebug(wchar_t t)
+{ return std::format(L"{:?}", t); }
+
+std::string
+fdebug(std::string_view t)
+{ return std::format("{:?}", t); }
+
+std::wstring
+fdebug(std::wstring_view t)
+{ return std::format(L"{:?}", t); }
+
+
+#define WIDEN_(C, S) ::std::__format::_Widen<C>(S, L##S)
+#define WIDEN(S) WIDEN_(_CharT, S)
+
+template<typename _CharT>
+void
+test_basic_escapes()
+{
+ std::basic_string<_CharT> res;
+
+ const auto tab = WIDEN("\t");
+ res = fdebug(tab);
+ VERIFY( res == WIDEN(R"("\t")") );
+ res = fdebug(tab[0]);
+ VERIFY( res == WIDEN(R"('\t')") );
+
+ const auto nline = WIDEN("\n");
+ res = fdebug(nline);
+ VERIFY( res == WIDEN(R"("\n")") );
+ res = fdebug(nline[0]);
+ VERIFY( res == WIDEN(R"('\n')") );
+
+ const auto carret = WIDEN("\r");
+ res = fdebug(carret);
+ VERIFY( res == WIDEN(R"("\r")") );
+ res = fdebug(carret[0]);
+ VERIFY( res == WIDEN(R"('\r')") );
+
+ const auto bslash = WIDEN("\\");
+ res = fdebug(bslash);
+ VERIFY( res == WIDEN(R"("\\")") );
+ res = fdebug(bslash[0]);
+ VERIFY( res == WIDEN(R"('\\')") );
+
+ const auto quote = WIDEN("\"");
+ res = fdebug(quote);
+ VERIFY( res == WIDEN(R"("\"")") );
+ res = fdebug(quote[0]);
+ VERIFY( res == WIDEN(R"('"')") );
+
+ const auto apos = WIDEN("\'");
+ res = fdebug(apos);
+ VERIFY( res == WIDEN(R"("'")") );
+ res = fdebug(apos[0]);
+ VERIFY( res == WIDEN(R"('\'')") );
+}
+
+template<typename _CharT>
+void
+test_ascii_escapes()
+{
+ std::basic_string<_CharT> res;
+
+ const auto in = WIDEN("\x10 abcde\x7f\t0123");
+ res = fdebug(in);
+ VERIFY( res == WIDEN(R"("\u{10} abcde\u{7f}\t0123")") );
+ res = fdebug(in[0]);
+ VERIFY( res == WIDEN(R"('\u{10}')") );
+ res = fdebug(in[1]);
+ VERIFY( res == WIDEN(R"(' ')") );
+ res = fdebug(in[2]);
+ VERIFY( res == WIDEN(R"('a')") );
+}
+
+template<typename _CharT>
+void
+test_extended_ascii()
+{
+ std::basic_string<_CharT> res;
+
+ const auto in = WIDEN("Åëÿ");
+ res = fdebug(in);
+ VERIFY( res == WIDEN(R"("Åëÿ")") );
+
+ static constexpr bool __test_characters
+#if UNICODE_ENC
+ = sizeof(_CharT) >= 2;
+#else // ISO8859-1
+ = true;
+#endif // UNICODE_ENC
+
+ if constexpr (__test_characters)
+ {
+ res = fdebug(in[0]);
+ VERIFY( res == WIDEN(R"('Å')") );
+ res = fdebug(in[1]);
+ VERIFY( res == WIDEN(R"('ë')") );
+ res = fdebug(in[2]);
+ VERIFY( res == WIDEN(R"('ÿ')") );
+ }
+}
+
+#if UNICODE_ENC
+template<typename _CharT>
+void
+test_unicode_escapes()
+{
+ std::basic_string<_CharT> res;
+
+ const auto in = WIDEN(
+ "\u008a" // Cc, Control, Line Tabulation Set,
+ "\u00ad" // Cf, Format, Soft Hyphen
+ "\u1d3d" // Lm, Modifier letter, Modifier Letter Capital Ou
+ "\u00a0" // Zs, Space Separator, No-Break Space (NBSP)
+ "\u2029" // Zp, Paragraph Separator, Paragraph Separator
+ "\U0001f984" // So, Other Symbol, Unicorn Face
+ );
+ const auto out = WIDEN("\""
+ R"(\u{8a})"
+ R"(\u{ad})"
+ "\u1d3d"
+ R"(\u{a0})"
+ R"(\u{2029})"
+ "\U0001f984"
+ "\"");
+
+ res = fdebug(in);
+ VERIFY( res == out );
+
+ if constexpr (sizeof(_CharT) >= 2)
+ {
+ res = fdebug(in[0]);
+ VERIFY( res == WIDEN(R"('\u{8a}')") );
+ res = fdebug(in[1]);
+ VERIFY( res == WIDEN(R"('\u{ad}')") );
+ res = fdebug(in[2]);
+ VERIFY( res == WIDEN("'\u1d3d'") );
+ res = fdebug(in[3]);
+ VERIFY( res == WIDEN(R"('\u{a0}')") );
+ res = fdebug(in[4]);
+ VERIFY( res == WIDEN(R"('\u{2029}')") );
+ }
+
+ if constexpr (sizeof(_CharT) >= 4)
+ {
+ res = fdebug(in[5]);
+ VERIFY( res == WIDEN("'\U0001f984'") );
+ }
+}
+
+template<typename _CharT>
+void
+test_grapheme_extend()
+{
+ std::basic_string<_CharT> res;
+
+ const auto vin = WIDEN("o\u0302\u0323");
+ res = fdebug(vin);
+ VERIFY( res == WIDEN("\"o\u0302\u0323\"") );
+
+ std::basic_string_view<_CharT> in = WIDEN("\t\u0302\u0323");
+ res = fdebug(in);
+ VERIFY( res == WIDEN(R"("\t\u{302}\u{323}")") );
+
+ res = fdebug(in.substr(1));
+ VERIFY( res == WIDEN(R"("\u{302}\u{323}")") );
+
+ if constexpr (sizeof(_CharT) >= 2)
+ {
+ res = fdebug(in[1]);
+ VERIFY( res == WIDEN(R"('\u{302}')") );
+ }
+}
+
+template<typename _CharT>
+void
+test_replacement_char()
+{
+ std::basic_string<_CharT> repl = WIDEN("\uFFFD");
+ std::basic_string<_CharT> res = fdebug(repl);
+ VERIFY( res == WIDEN("\"\uFFFD\"") );
+
+ repl = WIDEN("\uFFFD\uFFFD");
+ res = fdebug(repl);
+ VERIFY( res == WIDEN("\"\uFFFD\uFFFD\"") );
+}
+
+void
+test_ill_formed_utf8_seq()
+{
+ std::string_view seq = "\xf0\x9f\xa6\x84"; // \U0001F984
+ std::string res;
+
+ res = fdebug(seq);
+ VERIFY( res == "\"\U0001F984\"" );
+
+ res = fdebug(seq.substr(1));
+ VERIFY( res == R"("\x{9f}\x{a6}\x{84}")" );
+
+ res = fdebug(seq.substr(2));
+ VERIFY( res == R"("\x{a6}\x{84}")" );
+
+ res = fdebug(seq[0]);
+ VERIFY( res == R"('\x{f0}')" );
+ res = fdebug(seq.substr(0, 1));
+ VERIFY( res == R"("\x{f0}")" );
+
+ res = fdebug(seq[1]);
+ VERIFY( res == R"('\x{9f}')" );
+ res = fdebug(seq.substr(1, 1));
+ VERIFY( res == R"("\x{9f}")" );
+
+ res = fdebug(seq[2]);
+ VERIFY( res == R"('\x{a6}')" );
+ res = fdebug(seq.substr(2, 1));
+ VERIFY( res == R"("\x{a6}")" );
+
+ res = fdebug(seq[3]);
+ VERIFY( res == R"('\x{84}')" );
+ res = fdebug(seq.substr(3, 1));
+ VERIFY( res == R"("\x{84}")" );
+}
+
+void
+test_ill_formed_utf32()
+{
+ std::wstring res;
+
+ wchar_t ic1 = static_cast<wchar_t>(0xff'ffff);
+ res = fdebug(ic1);
+ VERIFY( res == LR"('\x{ffffff}')" );
+
+ std::wstring is1(1, ic1);
+ res = fdebug(is1);
+ VERIFY( res == LR"("\x{ffffff}")" );
+
+ wchar_t ic2 = static_cast<wchar_t>(0xffff'ffff);
+ res = fdebug(ic2);
+ VERIFY( res == LR"('\x{ffffffff}')" );
+
+ std::wstring is2(1, ic2);
+ res = fdebug(is2);
+ VERIFY( res == LR"("\x{ffffffff}")" );
+}
+#endif // UNICODE_ENC
+
+template<typename _CharT>
+void
+test_fill()
+{
+ std::basic_string<_CharT> res;
+
+ std::basic_string_view<_CharT> in = WIDEN("a\t\x10\u00ad");
+ res = std::format(WIDEN("{:10?}"), in.substr(0, 1));
+ VERIFY( res == WIDEN(R"("a" )") );
+
+ res = std::format(WIDEN("{:->10?}"), in.substr(1, 1));
+ VERIFY( res == WIDEN(R"(------"\t")") );
+
+ res = std::format(WIDEN("{:+<10?}"), in.substr(2, 1));
+ VERIFY( res == WIDEN(R"("\u{10}"++)") );
+
+
+ res = std::format(WIDEN("{:10?}"), in[0]);
+ VERIFY( res == WIDEN(R"('a' )") );
+
+ res = std::format(WIDEN("{:->10?}"), in[1]);
+ VERIFY( res == WIDEN(R"(------'\t')") );
+
+ res = std::format(WIDEN("{:+<10?}"), in[2]);
+ VERIFY( res == WIDEN(R"('\u{10}'++)") );
+
+#if UNICODE_ENC
+ res = std::format(WIDEN("{:=^10?}"), in.substr(3));
+ VERIFY( res == WIDEN(R"(="\u{ad}"=)") );
+
+ // width is 2
+ std::basic_string_view<_CharT> in2 = WIDEN("\u1100");
+ res = std::format(WIDEN("{:*^10?}"), in2);
+ VERIFY( res == WIDEN("***\"\u1100\"***") );
+
+ if constexpr (sizeof(_CharT) >= 2)
+ {
+ res = std::format(WIDEN("{:=^10?}"), in[3]);
+ VERIFY( res == WIDEN(R"(='\u{ad}'=)") );
+
+ res = std::format(WIDEN("{:*^10?}"), in2[0]);
+ VERIFY( res == WIDEN("***'\u1100'***") );
+ }
+#endif // UNICODE_ENC
+}
+
+template<typename _CharT>
+void
+test_prec()
+{
+ std::basic_string<_CharT> res;
+ // with ? escpaed presentation is copied to ouput, same as source
+
+ std::basic_string_view<_CharT> in = WIDEN("a\t\x10\u00ad");
+ res = std::format(WIDEN("{:.2?}"), in.substr(0, 1));
+ VERIFY( res == WIDEN(R"("a)") );
+
+ res = std::format(WIDEN("{:.4?}"), in.substr(1, 1));
+ VERIFY( res == WIDEN(R"("\t")") );
+
+ res = std::format(WIDEN("{:.5?}"), in.substr(2, 1));
+ VERIFY( res == WIDEN(R"("\u{1)") );
+
+#if UNICODE_ENC
+ res = std::format(WIDEN("{:.10?}"), in.substr(3));
+ VERIFY( res == WIDEN(R"("\u{ad}")") );
+
+ std::basic_string_view<_CharT> in2 = WIDEN("\u1100");
+ res = std::format(WIDEN("{:.3?}"), in2);
+ VERIFY( res == WIDEN("\"\u1100") );
+#endif // UNICODE_ENC
+}
+
+void test_char_as_wchar()
+{
+ std::wstring res;
+
+ res = std::format(L"{:?}", 'a');
+ VERIFY( res == LR"('a')" );
+
+ res = std::format(L"{:?}", '\t');
+ VERIFY( res == LR"('\t')" );
+
+ res = std::format(L"{:+<10?}", '\x10');
+ VERIFY( res == LR"('\u{10}'++)" );
+}
+
+template<typename T>
+struct DebugWrapper
+{
+ T val;
+};
+
+template<typename T, typename CharT>
+struct std::formatter<DebugWrapper<T>, CharT>
+{
+ constexpr std::basic_format_parse_context<CharT>::iterator
+ parse(std::basic_format_parse_context<CharT>& pc)
+ {
+ auto out = under.parse(pc);
+ under.set_debug_format();
+ return out;
+ }
+
+ template<typename Out>
+ Out format(DebugWrapper<T> const& t,
+ std::basic_format_context<Out, CharT>& fc) const
+ { return under.format(t.val, fc); }
+
+private:
+ std::formatter<T, CharT> under;
+};
+
+template<typename _CharT, typename StrT>
+void
+test_formatter_str()
+{
+ _CharT buf[]{ 'a', 'b', 'c', 0 };
+ DebugWrapper<StrT> in{ buf };
+ std::basic_string<_CharT> res = std::format(WIDEN("{:?}"), in );
+ VERIFY( res == WIDEN(R"("abc")") );
+}
+
+template<typename _CharT>
+void
+test_formatter_arr()
+{
+ std::basic_string<_CharT> res;
+
+ DebugWrapper<_CharT[3]> in3{ 'a', 'b', 'c' };
+ res = std::format(WIDEN("{:?}"), in3 );
+ VERIFY( res == WIDEN(R"("abc")") );
+
+ // We print all characters, including null-terminator
+ DebugWrapper<_CharT[4]> in4{ 'a', 'b', 'c', 0 };
+ res = std::format(WIDEN("{:?}"), in4 );
+ VERIFY( res == WIDEN(R"("abc\u{0}")") );
+}
+
+template<typename _CharT, typename SrcT>
+void
+test_formatter_char()
+{
+ DebugWrapper<SrcT> in{ 'a' };
+ std::basic_string<_CharT> res = std::format(WIDEN("{:?}"), in);
+ VERIFY( res == WIDEN(R"('a')") );
+}
+
+template<typename CharT>
+void
+test_formatters()
+{
+ test_formatter_char<CharT, CharT>();
+ test_formatter_str<CharT, CharT*>();
+ test_formatter_str<CharT, const CharT*>();
+ test_formatter_str<CharT, std::basic_string<CharT>>();
+ test_formatter_str<CharT, std::basic_string_view<CharT>>();
+ test_formatter_arr<CharT>();
+}
+
+void
+test_formatters_c()
+{
+ test_formatters<char>();
+ test_formatters<wchar_t>();
+ test_formatter_char<wchar_t, char>();
+}
+
+int main()
+{
+ test_basic_escapes<char>();
+ test_basic_escapes<wchar_t>();
+ test_ascii_escapes<char>();
+ test_ascii_escapes<wchar_t>();
+ test_extended_ascii<char>();
+ test_extended_ascii<wchar_t>();
+
+#if UNICODE_ENC
+ test_unicode_escapes<char>();
+ test_unicode_escapes<wchar_t>();
+ test_grapheme_extend<char>();
+ test_grapheme_extend<wchar_t>();
+ test_replacement_char<char>();
+ test_replacement_char<wchar_t>();
+ test_ill_formed_utf8_seq();
+ test_ill_formed_utf32();
+#endif // UNICODE_ENC
+
+ test_fill<char>();
+ test_fill<wchar_t>();
+ test_prec<char>();
+ test_prec<wchar_t>();
+
+ test_formatters_c();
+}
diff --git a/libstdc++-v3/testsuite/std/format/debug_nounicode.cc
b/libstdc++-v3/testsuite/std/format/debug_nounicode.cc
new file mode 100644
index 00000000000..5c03171d71a
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/format/debug_nounicode.cc
@@ -0,0 +1,5 @@
+// { dg-options "-fexec-charset=ISO8859-1 -fwide-exec-charset=UTF-32LE" }
+// { dg-do run { target c++23 } }
+// { dg-add-options no_pch }
+
+#include "debug.cc"
diff --git a/libstdc++-v3/testsuite/std/format/parse_ctx.cc
b/libstdc++-v3/testsuite/std/format/parse_ctx.cc
index b5dd7cdba78..b338ac7b762 100644
--- a/libstdc++-v3/testsuite/std/format/parse_ctx.cc
+++ b/libstdc++-v3/testsuite/std/format/parse_ctx.cc
@@ -108,7 +108,7 @@ is_std_format_spec_for(std::string_view spec)
}
}
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges
constexpr bool escaped_strings_supported = true;
#else
constexpr bool escaped_strings_supported = false;
diff --git a/libstdc++-v3/testsuite/std/format/string.cc
b/libstdc++-v3/testsuite/std/format/string.cc
index ee987a15ec3..76614d4bc3e 100644
--- a/libstdc++-v3/testsuite/std/format/string.cc
+++ b/libstdc++-v3/testsuite/std/format/string.cc
@@ -62,7 +62,7 @@ test_indexing()
VERIFY( ! is_format_string_for("{} {0}", 1) );
}
-#if __cpp_lib_format_ranges
+#if __glibcxx_format_ranges
constexpr bool escaped_strings_supported = true;
#else
constexpr bool escaped_strings_supported = false;
--
2.49.0
