Next (#1231)

* Refactor IPv6 address parsing to fix shorten notation handling and improve robustness

- Rewrote `scn_cnt_define_in6addr_4_digits_impl` to use loop-based parsing instead of manual unrolling, fixing zero-started validation issues
- Completely reimplemented `scn_cnt_define_in6addr_shorten_impl` to properly handle "::" expansion with token-based parsing
- Fixed bracket handling in `scn_cnt_define_in6addr_impl` to validate closing bracket and inner content length
- Removed unused `scn_cnt_define_in6addr_nonshorten_

* Simplify IPv6 context scanner by removing port parsing and fix EOF handling

- Removed port parsing logic from `scan_context_define` for IPv6 addresses to match single-stage parsing behavior
- Added special handling in `scn_ctx_define_in6addr_impl` to treat parse failures at buffer end as `parse_code::partial` for streaming contexts
- Set `state.size = 1` to mark unfinished IPv6 parse for proper EOF handling, aligning with IPv4 scanner behavior
- Eliminated conditional port parsing code path and simplified return

* Mark scn_ip_port example as interactive in test configuration

- Added `interactive = true` flag for `0042.scn_ip_port` test case to indicate it requires user input

* Update addrscn.h

* Update addrscn.h

* Add IPv4-mapped IPv6 address support with configurable flag for printing and scanning

- Added `ipv4_mapped_ipv6` flag to `ip_flags` and `ip_scan_flags` structures (default: true)
- Implemented `ipv6_to_ipv4_mapped_bytes` helper to detect and extract IPv4-mapped IPv6 addresses (::ffff:x.x.x.x format)
- Modified print functions to output IPv4-mapped IPv6 addresses in compact notation when flag is enabled
- Updated scan functions to validate IPv4-mapped IPv6 prefix (first 5 words zero, 6th word 0xFF

* Add `ip_scan_no_ipv4_mapped_ipv6` constant flag to disable IPv4-mapped IPv6 address parsing

- Added `ip_scan_no_ipv4_mapped_ipv6` inline constexpr flag with `requireport = true` and `ipv4_mapped_ipv6 = false`
- Provides predefined configuration to disable IPv4-mapped IPv6 address support while requiring port numbers

* Update addrscn.h

Author: MacroModel

include/fast_io_core_impl/integers/impl.h

@@ -72,8 +72,9 @@ struct ip_flags
 	bool v6shorten{true};
 	bool v6uppercase{};
 	bool v6bracket{true};
-	bool v6full{false};
+	bool v6full{};
 	bool showport{};
+	bool ipv4_mapped_ipv6{true};
 };
 
 inline constexpr ip_flags ip_default_flags{.showport = true};
@@ -104,9 +105,11 @@ struct ip_scan_flags
 	bool allowv6bracket{true};
 	bool requirev6full{false};
 	bool requireport{false};
+	bool ipv4_mapped_ipv6{true};
 };
 
 inline constexpr ip_scan_flags ip_scan_default_flags{.requireport = true};
+inline constexpr ip_scan_flags ip_scan_no_ipv4_mapped_ipv6{.requireport = true, .ipv4_mapped_ipv6 = false};
 inline constexpr ip_scan_flags ip_scan_default_inaddr_flags{};
 
 template <ip_scan_flags flags, typename T>

include/fast_io_core_impl/socket/addrprt.h

@@ -22,6 +22,40 @@ inline constexpr char_type *prtrsv_inaddr_common_define_impl(char_type *it,
 	return it;
 }
 
+inline constexpr bool ipv6_to_ipv4_mapped_bytes(::std::uint_least16_t const (&addr)[8],
+												char unsigned (&out)[4]) noexcept
+{
+	for (::std::size_t i{}; i != 5; ++i)
+	{
+		if (addr[i] != 0)
+		{
+			return false;
+		}
+	}
+
+	::std::uint_least16_t w5;
+	if constexpr (::std::numeric_limits<::std::uint_least16_t>::digits != 16)
+	{
+		w5 = ::fast_io::big_endian(addr[5]);
+	}
+	else
+	{
+		w5 = addr[5];
+	}
+
+	if (w5 != static_cast<::std::uint_least16_t>(0xFFFFu))
+	{
+		return false;
+	}
+	auto const w6{::fast_io::big_endian(addr[6])};
+	auto const w7{::fast_io::big_endian(addr[7])};
+	out[0] = static_cast<char unsigned>(w6 >> 8u);
+	out[1] = static_cast<char unsigned>(w6 & 0xFFu);
+	out[2] = static_cast<char unsigned>(w7 >> 8u);
+	out[3] = static_cast<char unsigned>(w7 & 0xFFu);
+	return true;
+}
+
 template <bool shorten, bool uppercase, bool showv6bracket, bool full, ::std::integral char_type>
 inline constexpr char_type *prtrsv_in6addr_common_define_impl(char_type *it,
 															  ::std::uint_least16_t const *__restrict start) noexcept
@@ -171,9 +205,54 @@ inline constexpr char_type *prtrsv_ipv4_define_impl(char_type *it, ::fast_io::ip
 	return it;
 }
 
-template <bool v6shorten, bool uppercase, bool showv6bracket, bool showport, bool full, ::std::integral char_type>
+template <bool v6shorten, bool uppercase, bool showv6bracket, bool showport, bool full, bool ipv4_mapped_ipv6,
+		  ::std::integral char_type>
 inline constexpr char_type *prtrsv_inaddr6_define_impl(char_type *it, ::fast_io::posix_in6_addr v) noexcept
 {
+	if constexpr (ipv4_mapped_ipv6)
+	{
+		char unsigned v4bytes[4]{};
+		if (ipv6_to_ipv4_mapped_bytes(v.address, v4bytes))
+		{
+			constexpr bool need_bracket{showport ? true : showv6bracket};
+			if constexpr (need_bracket)
+			{
+				*it = ::fast_io::char_literal_v<u8'[', char_type>;
+				++it;
+			}
+			if constexpr (::std::same_as<char_type, char>)
+			{
+				it = copy_string_literal("::ffff:", it);
+			}
+			else if constexpr (::std::same_as<char_type, wchar_t>)
+			{
+				it = copy_string_literal(L"::ffff:", it);
+			}
+			else if constexpr (::std::same_as<char_type, char16_t>)
+			{
+				it = copy_string_literal(u"::ffff:", it);
+			}
+			else if constexpr (::std::same_as<char_type, char32_t>)
+			{
+				it = copy_string_literal(U"::ffff:", it);
+			}
+			else
+			{
+				it = copy_string_literal(u8"::ffff:", it);
+			}
+			it = prtrsv_inaddr_common_define_impl(it, v4bytes);
+			if constexpr (need_bracket)
+			{
+				*it = ::fast_io::char_literal_v<u8']', char_type>;
+				++it;
+			}
+			if constexpr (showport)
+			{
+				it = prtrsv_ipport_zero_define_impl(it);
+			}
+			return it;
+		}
+	}
 	it = prtrsv_in6addr_common_define_impl<v6shorten, uppercase, showport ? true : showv6bracket, full>(it, v.address);
 	if constexpr (showport)
 	{
@@ -182,23 +261,70 @@ inline constexpr char_type *prtrsv_inaddr6_define_impl(char_type *it, ::fast_io:
 	return it;
 }
 
-template <bool v6shorten, bool uppercase, bool showv6bracket, bool showport, bool full, ::std::integral char_type>
+template <bool v6shorten, bool uppercase, bool showv6bracket, bool showport, bool full, bool ipv4_mapped_ipv6,
+		  ::std::integral char_type>
 inline constexpr char_type *prtrsv_ipv6_define_impl(char_type *it, ::fast_io::ipv6 v) noexcept
 {
-	it = prtrsv_in6addr_common_define_impl<v6shorten, uppercase, showport ? true : showv6bracket, full>(it, v.address.address);
+	if constexpr (ipv4_mapped_ipv6)
+	{
+		char unsigned v4bytes[4]{};
+		if (ipv6_to_ipv4_mapped_bytes(v.address.address, v4bytes))
+		{
+			constexpr bool need_bracket{showport ? true : showv6bracket};
+			if constexpr (need_bracket)
+			{
+				*it = ::fast_io::char_literal_v<u8'[', char_type>;
+				++it;
+			}
+			if constexpr (::std::same_as<char_type, char>)
+			{
+				it = copy_string_literal("::ffff:", it);
+			}
+			else if constexpr (::std::same_as<char_type, wchar_t>)
+			{
+				it = copy_string_literal(L"::ffff:", it);
+			}
+			else if constexpr (::std::same_as<char_type, char16_t>)
+			{
+				it = copy_string_literal(u"::ffff:", it);
+			}
+			else if constexpr (::std::same_as<char_type, char32_t>)
+			{
+				it = copy_string_literal(U"::ffff:", it);
+			}
+			else
+			{
+				it = copy_string_literal(u8"::ffff:", it);
+			}
+			it = prtrsv_inaddr_common_define_impl(it, v4bytes);
+			if constexpr (need_bracket)
+			{
+				*it = ::fast_io::char_literal_v<u8']', char_type>;
+				++it;
+			}
+			if constexpr (showport)
+			{
+				it = prtrsv_ipport_define_impl(it, v.port);
+			}
+			return it;
+		}
+	}
+	it = prtrsv_in6addr_common_define_impl<v6shorten, uppercase, showport ? true : showv6bracket, full>(it,
+																										v.address.address);
 	if constexpr (showport)
 	{
 		it = prtrsv_ipport_define_impl(it, v.port);
 	}
 	return it;
 }
 
-template <bool v6shorten, bool uppercase, bool showv6bracket, bool showport, bool full, ::std::integral char_type>
+template <bool v6shorten, bool uppercase, bool showv6bracket, bool showport, bool full, bool ipv4_mapped_ipv6,
+		  ::std::integral char_type>
 inline constexpr char_type *prtrsv_ip_address_define_impl(char_type *it, ::fast_io::ip_address v) noexcept
 {
 	if constexpr (showport)
 	{
-		it = prtrsv_ip_address_define_impl<v6shorten, uppercase, showv6bracket, false, full>(it, v);
+		it = prtrsv_ip_address_define_impl<v6shorten, uppercase, showv6bracket, false, full, ipv4_mapped_ipv6>(it, v);
 		return prtrsv_ipport_zero_define_impl(it);
 	}
 	else
@@ -209,18 +335,19 @@ inline constexpr char_type *prtrsv_ip_address_define_impl(char_type *it, ::fast_
 		}
 		else
 		{
-			it = prtrsv_in6addr_common_define_impl<v6shorten, uppercase, showport ? true : showv6bracket,
-												   full>(it, v.address.v6.address);
+			it = prtrsv_inaddr6_define_impl<v6shorten, uppercase, showv6bracket, false, full,
+											ipv4_mapped_ipv6>(it, v.address.v6);
 		}
 		return it;
 	}
 }
 
-template <bool v6shorten, bool uppercase, bool showv6bracket, bool showport, bool full, ::std::integral char_type>
+template <bool v6shorten, bool uppercase, bool showv6bracket, bool showport, bool full, bool ipv4_mapped_ipv6,
+		  ::std::integral char_type>
 inline constexpr char_type *prtrsv_ip_define_impl(char_type *it, ::fast_io::ip v) noexcept
 {
-	it = prtrsv_ip_address_define_impl<v6shorten, uppercase, (showport ? true : showv6bracket), false, full>(it,
-																											 v.address);
+	it = prtrsv_ip_address_define_impl<v6shorten, uppercase, (showport ? true : showv6bracket), false, full,
+									   ipv4_mapped_ipv6>(it, v.address);
 	if constexpr (showport)
 	{
 		it = prtrsv_ipport_define_impl(it, v.port);
@@ -343,22 +470,26 @@ print_reserve_define(::fast_io::io_reserve_type_t<char_type, ::fast_io::manipula
 	else if constexpr (::std::same_as<iptype, ::fast_io::posix_in6_addr>)
 	{
 		return ::fast_io::details::prtrsv_inaddr6_define_impl<flags.v6shorten, flags.v6uppercase,
-															  flags.showport ? true : flags.v6bracket, flags.showport, flags.v6full>(iter, val.reference);
+															  flags.showport ? true : flags.v6bracket, flags.showport, flags.v6full,
+															  flags.ipv4_mapped_ipv6>(iter, val.reference);
 	}
 	else if constexpr (::std::same_as<iptype, ::fast_io::ipv6>)
 	{
 		return ::fast_io::details::prtrsv_ipv6_define_impl<flags.v6shorten, flags.v6uppercase,
-														   flags.showport ? true : flags.v6bracket, flags.showport, flags.v6full>(iter, val.reference);
+														   flags.showport ? true : flags.v6bracket, flags.showport, flags.v6full,
+														   flags.ipv4_mapped_ipv6>(iter, val.reference);
 	}
 	else if constexpr (::std::same_as<iptype, ::fast_io::ip_address>)
 	{
 		return ::fast_io::details::prtrsv_ip_address_define_impl<flags.v6shorten, flags.v6uppercase,
-																 flags.showport ? true : flags.v6bracket, flags.showport, flags.v6full>(iter, val.reference);
+																 flags.showport ? true : flags.v6bracket, flags.showport, flags.v6full,
+																 flags.ipv4_mapped_ipv6>(iter, val.reference);
 	}
 	else
 	{
 		return ::fast_io::details::prtrsv_ip_define_impl<flags.v6shorten, flags.v6uppercase,
-														 flags.showport ? true : flags.v6bracket, flags.showport, flags.v6full>(iter, val.reference);
+														 flags.showport ? true : flags.v6bracket, flags.showport, flags.v6full,
+														 flags.ipv4_mapped_ipv6>(iter, val.reference);
 	}
 }