Merge pull request #167 from boostorg/166

mborland · web-flow · commit f5e197177b43 · 2024-02-20T09:58:50.000+01:00
diff --git a/doc/charconv/to_chars.adoc b/doc/charconv/to_chars.adoc
@@ -10,7 +10,7 @@ https://www.boost.org/LICENSE_1_0.txt
 == to_chars overview
 
 `to_chars` is a set of functions that attempts to convert `value` into a character buffer specified by `[first, last)`.
-The result of `to_chars` is `to_chars_result` which on success returns `ptr` equal to one-past-the-end of the characters written and `ec == std::errc()` and on failure returns `std::errc::result_out_of_range` and `ptr == last`.
+The result of `to_chars` is `to_chars_result` which on success returns `ptr` equal to one-past-the-end of the characters written and `ec == std::errc()` and on failure returns `std::errc::value_too_large` and `ptr == last`.
 `to_chars` does not null-terminate the returned characters.
 
 == Definitions
@@ -55,7 +55,7 @@ See <<chars_format overview>> for description.
 |===
 |Return Value | Description
 |`std::errc()` | Successful Parsing
-| `std::errc::result_out_of_range` | 1) Overflow
+| `std::errc::value_too_large` | 1) Overflow
 
 2) Underflow
 |===
@@ -138,14 +138,14 @@ std::cout << "U: " << buffer_u << "\nV: " << buffer_v << std::endl;
 
 ----
 
-=== std::errc::result_out_of_range
+=== std::errc::value_too_large
 ==== Integral
 [source, c++]
 ----
 char buffer[3] {};
 int v = -1234;
 to_chars_result r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer) - 1, v, 16);
-assert(r.ec == std::errc::result_out_of_range);
+assert(r.ec == std::errc::value_too_large);
 assert(!r); // Same as above but less verbose. Added in C++26.
 ----
 ==== Floating Point
@@ -154,8 +154,8 @@ assert(!r); // Same as above but less verbose. Added in C++26.
 char buffer[3] {};
 double v = 1.2345;
 auto r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer) - 1, v);
-assert(r.ec == std::errc::result_out_of_range);
+assert(r.ec == std::errc::value_too_large);
 assert(!r); // Same as above but less verbose. Added in C++26.
 ----
 
-In the event of `std::errc::result_out_of_range`, to_chars_result.ptr is equal to `last`
+In the event of `std::errc::value_too_large`, to_chars_result.ptr is equal to `last`
diff --git a/include/boost/charconv/detail/dragonbox/dragonbox.hpp b/include/boost/charconv/detail/dragonbox/dragonbox.hpp
@@ -2605,7 +2605,7 @@ namespace to_chars_detail {
                 }
                 else
                 {
-                    return {last, std::errc::result_out_of_range};
+                    return {last, std::errc::value_too_large};
                 }
             }
         }
@@ -2628,7 +2628,7 @@ namespace to_chars_detail {
                 }
                 else
                 {
-                    return {last, std::errc::result_out_of_range};
+                    return {last, std::errc::value_too_large};
                 }
             }
             else 
@@ -2677,7 +2677,7 @@ namespace to_chars_detail {
                         }
                         else
                         {
-                            return {last, std::errc::result_out_of_range};
+                            return {last, std::errc::value_too_large};
                         }
                     }
                     else
@@ -2689,7 +2689,7 @@ namespace to_chars_detail {
                         }
                         else
                         {
-                            return {last, std::errc::result_out_of_range};
+                            return {last, std::errc::value_too_large};
                         }
                     }
                 }
@@ -2702,7 +2702,7 @@ namespace to_chars_detail {
                     }
                     else
                     {
-                        return {last, std::errc::result_out_of_range};
+                        return {last, std::errc::value_too_large};
                     }
                 }
             }
diff --git a/include/boost/charconv/detail/dragonbox/floff.hpp b/include/boost/charconv/detail/dragonbox/floff.hpp
@@ -1308,7 +1308,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci
 {
     if (first >= last)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     auto buffer_size = static_cast<std::size_t>(last - first);
@@ -1339,7 +1339,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci
 
             if (buffer_size < inf_chars)
             {
-                return {last, std::errc::result_out_of_range};
+                return {last, std::errc::value_too_large};
             }
 
             std::memcpy(buffer, "inf", inf_chars); // NOLINT : Specifically not null-terminating
@@ -1359,7 +1359,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci
 
                     if (buffer_size < nan_chars)
                     {
-                        return {last, std::errc::result_out_of_range};
+                        return {last, std::errc::value_too_large};
                     }
 
                     std::memcpy(buffer, "nan", nan_chars); // NOLINT : Specifically not null-terminating
@@ -1371,7 +1371,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci
 
                     if (buffer_size < neg_nan_chars)
                     {
-                        return {last, std::errc::result_out_of_range};
+                        return {last, std::errc::value_too_large};
                     }
 
                     std::memcpy(buffer, "nan(ind)", neg_nan_chars); // NOLINT : Specifically not null-terminating
@@ -1384,7 +1384,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci
 
                 if (buffer_size < snan_chars)
                 {
-                    return {last, std::errc::result_out_of_range};
+                    return {last, std::errc::value_too_large};
                 }
 
                 std::memcpy(buffer, "nan(snan)", snan_chars); // NOLINT : Specifically not null-terminating
@@ -1419,7 +1419,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci
 
                     if (buffer_size < zero_chars)
                     {
-                        return {last, std::errc::result_out_of_range};
+                        return {last, std::errc::value_too_large};
                     }
 
                     std::memcpy(buffer, "0e+00", zero_chars);
@@ -1429,7 +1429,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci
                 {
                     if (buffer_size < static_cast<std::size_t>(precision) + 6U)
                     {
-                        return {last, std::errc::result_out_of_range};
+                        return {last, std::errc::value_too_large};
                     }
 
                     std::memcpy(buffer, "0.", 2); // NOLINT : Specifically not null-terminating
@@ -1460,7 +1460,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci
 
     if (buffer_size < static_cast<std::size_t>(remaining_digits))
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     /////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/boost/charconv/detail/ryu/ryu_generic_128.hpp b/include/boost/charconv/detail/ryu/ryu_generic_128.hpp
@@ -401,7 +401,7 @@ static inline int generic_to_chars_fixed(const struct floating_decimal_128 v, ch
         // Option 2: Append 0s to the end of the number until we get the proper output
         if (current_len + v.exponent > result_size)
         {
-            return -static_cast<int>(std::errc::result_out_of_range);
+            return -static_cast<int>(std::errc::value_too_large);
         }
 
         memset(r.ptr, '0', static_cast<std::size_t>(v.exponent));
@@ -419,7 +419,7 @@ static inline int generic_to_chars_fixed(const struct floating_decimal_128 v, ch
         // Option 4: Leading 0s
         if (-v.exponent + 2 > result_size)
         {
-            return -static_cast<int>(std::errc::result_out_of_range);
+            return -static_cast<int>(std::errc::value_too_large);
         }
 
         memmove(result - v.exponent - current_len + 2, result, static_cast<std::size_t>(current_len));
@@ -480,7 +480,7 @@ static inline int generic_to_chars(const struct floating_decimal_128 v, char* re
 
     if (index + olength > static_cast<size_t>(result_size))
     {
-        return -static_cast<int>(std::errc::result_out_of_range);
+        return -static_cast<int>(std::errc::value_too_large);
     }
     else if (olength == 0)
     {
diff --git a/include/boost/charconv/detail/to_chars_integer_impl.hpp b/include/boost/charconv/detail/to_chars_integer_impl.hpp
@@ -130,7 +130,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
 
         if (converted_value_digits > user_buffer_size)
         {
-            return {last, std::errc::result_out_of_range};
+            return {last, std::errc::value_too_large};
         }
 
         decompose32(converted_value, buffer);
@@ -151,7 +151,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
 
         if (converted_value_digits > user_buffer_size)
         {
-            return {last, std::errc::result_out_of_range};
+            return {last, std::errc::value_too_large};
         }
 
         if (is_negative)
@@ -258,7 +258,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_128integer_impl(char* first, c
 
     if (converted_value_digits > user_buffer_size)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     if (is_negative)
@@ -409,7 +409,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
 
     if (num_chars > output_length)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     boost::charconv::detail::memcpy(first, buffer + (buffer_size - static_cast<unsigned long>(num_chars)),
diff --git a/src/to_chars.cpp b/src/to_chars.cpp
@@ -272,7 +272,7 @@ namespace boost { namespace charconv { namespace detail { namespace to_chars_det
         const std::ptrdiff_t total_length = total_buffer_length(9, exponent, false);
         if (total_length > (last - first))
         {
-            return {last, std::errc::result_out_of_range};
+            return {last, std::errc::value_too_large};
         }
 
         // Print significand.
@@ -315,7 +315,7 @@ namespace boost { namespace charconv { namespace detail { namespace to_chars_det
         const std::ptrdiff_t total_length = total_buffer_length(17, exponent, false);
         if (total_length > (last - first))
         {
-            return {last, std::errc::result_out_of_range};
+            return {last, std::errc::value_too_large};
         }
 
         // Print significand by decomposing it into a 9-digit block and a 8-digit block.
@@ -593,7 +593,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la
         }
         else
         {
-            return {last, std::errc::result_out_of_range};
+            return {last, std::errc::value_too_large};
         }
     }
     #endif
@@ -603,7 +603,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la
     auto real_precision = boost::charconv::detail::get_real_precision<long double>(precision);
     if (buffer_size < real_precision || first > last)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     if (fmt == boost::charconv::chars_format::general || fmt == boost::charconv::chars_format::scientific)
@@ -629,9 +629,9 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la
         {
             return { first + num_chars, std::errc() };
         }
-        else if (num_chars == -static_cast<int>(std::errc::result_out_of_range))
+        else if (num_chars == -static_cast<int>(std::errc::value_too_large))
         {
-            return { last, std::errc::result_out_of_range };
+            return { last, std::errc::value_too_large };
         }
     }
 
@@ -686,7 +686,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la
     // Sanity check our bounds
     if (first >= last)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     char* const original_first = first;
@@ -705,7 +705,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la
     auto real_precision = boost::charconv::detail::get_real_precision<__float128>(precision);
     if (buffer_size < real_precision || first > last)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     if ((fmt == boost::charconv::chars_format::general || fmt == boost::charconv::chars_format::scientific))
@@ -719,7 +719,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la
         }
         else if (num_chars == -1)
         {
-            return {last, std::errc::result_out_of_range};
+            return {last, std::errc::value_too_large};
         }
     }
     else if (fmt == boost::charconv::chars_format::hex)
@@ -735,9 +735,9 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la
         {
             return { first + num_chars, std::errc() };
         }
-        else if (num_chars == -static_cast<int>(std::errc::result_out_of_range))
+        else if (num_chars == -static_cast<int>(std::errc::value_too_large))
         {
-            return { last, std::errc::result_out_of_range };
+            return { last, std::errc::value_too_large };
         }
     }
 
diff --git a/src/to_chars_float_impl.hpp b/src/to_chars_float_impl.hpp
@@ -87,7 +87,7 @@ inline to_chars_result to_chars_nonfinite(char* first, char* last, Real value, i
         else
         {
             // Avoid buffer overflow
-            return { first, std::errc::result_out_of_range };
+            return { first, std::errc::value_too_large };
         }
 
     }
@@ -107,7 +107,7 @@ inline to_chars_result to_chars_nonfinite(char* first, char* last, Real value, i
         else
         {
             // Avoid buffer overflow
-            return { first, std::errc::result_out_of_range };
+            return { first, std::errc::value_too_large };
         }
     }
     else
@@ -165,7 +165,7 @@ inline to_chars_result to_chars_nonfinite<__float128>(char* first, char* last, _
         else
         {
             // Avoid buffer overflow
-            return { first, std::errc::result_out_of_range };
+            return { first, std::errc::value_too_large };
         }
 
     }
@@ -184,7 +184,7 @@ inline to_chars_result to_chars_nonfinite<__float128>(char* first, char* last, _
         else
         {
             // Avoid buffer overflow
-            return { first, std::errc::result_out_of_range };
+            return { first, std::errc::value_too_large };
         }
     }
     else
@@ -258,7 +258,7 @@ to_chars_result to_chars_hex(char* first, char* last, Real value, int precision)
 
     if (buffer_size < real_precision || first > last)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     // Extract the significand and the exponent
@@ -374,7 +374,7 @@ to_chars_result to_chars_hex(char* first, char* last, Real value, int precision)
     const std::ptrdiff_t total_length = total_buffer_length(real_precision, abs_unbiased_exponent, (value < 0));
     if (total_length > buffer_size)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     // Round if required
@@ -483,7 +483,7 @@ to_chars_result to_chars_fixed_impl(char* first, char* last, Real value, chars_f
     auto real_precision = get_real_precision<Real>(precision);
     if (buffer_size < real_precision || first > last)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     auto abs_value = std::abs(value);
@@ -534,7 +534,7 @@ to_chars_result to_chars_fixed_impl(char* first, char* last, Real value, chars_f
     const std::ptrdiff_t total_length = total_buffer_length(num_dig, value_struct.exponent, (value < 0));
     if (total_length > buffer_size)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     auto r = to_chars_integer_impl(first, last, value_struct.significand);
@@ -598,7 +598,7 @@ to_chars_result to_chars_float_impl(char* first, char* last, Real value, chars_f
     // Sanity check our bounds
     if (first >= last)
     {
-        return {last, std::errc::result_out_of_range};
+        return {last, std::errc::value_too_large};
     }
 
     auto abs_value = std::abs(value);
diff --git a/test/github_issue_152.cpp b/test/github_issue_152.cpp
diff --git a/test/github_issue_152_float128.cpp b/test/github_issue_152_float128.cpp
diff --git a/test/to_chars.cpp b/test/to_chars.cpp

Original file line number	Diff line number	Diff line change
`@@ -2605,7 +2605,7 @@ namespace to_chars_detail {`
`2605`	`2605`	`}`
`2606`	`2606`	`else`
`2607`	`2607`	`{`
`2608`		`- return {last, std::errc::result_out_of_range};`
	`2608`	`+ return {last, std::errc::value_too_large};`
`2609`	`2609`	`}`
`2610`	`2610`	`}`
`2611`	`2611`	`}`
`@@ -2628,7 +2628,7 @@ namespace to_chars_detail {`
`2628`	`2628`	`}`
`2629`	`2629`	`else`
`2630`	`2630`	`{`
`2631`		`- return {last, std::errc::result_out_of_range};`
	`2631`	`+ return {last, std::errc::value_too_large};`
`2632`	`2632`	`}`
`2633`	`2633`	`}`
`2634`	`2634`	`else`
`@@ -2677,7 +2677,7 @@ namespace to_chars_detail {`
`2677`	`2677`	`}`
`2678`	`2678`	`else`
`2679`	`2679`	`{`
`2680`		`- return {last, std::errc::result_out_of_range};`
	`2680`	`+ return {last, std::errc::value_too_large};`
`2681`	`2681`	`}`
`2682`	`2682`	`}`
`2683`	`2683`	`else`
`@@ -2689,7 +2689,7 @@ namespace to_chars_detail {`
`2689`	`2689`	`}`
`2690`	`2690`	`else`
`2691`	`2691`	`{`
`2692`		`- return {last, std::errc::result_out_of_range};`
	`2692`	`+ return {last, std::errc::value_too_large};`
`2693`	`2693`	`}`
`2694`	`2694`	`}`
`2695`	`2695`	`}`
`@@ -2702,7 +2702,7 @@ namespace to_chars_detail {`
`2702`	`2702`	`}`
`2703`	`2703`	`else`
`2704`	`2704`	`{`
`2705`		`- return {last, std::errc::result_out_of_range};`
	`2705`	`+ return {last, std::errc::value_too_large};`
`2706`	`2706`	`}`
`2707`	`2707`	`}`
`2708`	`2708`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1308,7 +1308,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci`
`1308`	`1308`	`{`
`1309`	`1309`	`if (first >= last)`
`1310`	`1310`	`{`
`1311`		`- return {last, std::errc::result_out_of_range};`
	`1311`	`+ return {last, std::errc::value_too_large};`
`1312`	`1312`	`}`
`1313`	`1313`
`1314`	`1314`	`auto buffer_size = static_cast<std::size_t>(last - first);`
`@@ -1339,7 +1339,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci`
`1339`	`1339`
`1340`	`1340`	`if (buffer_size < inf_chars)`
`1341`	`1341`	`{`
`1342`		`- return {last, std::errc::result_out_of_range};`
	`1342`	`+ return {last, std::errc::value_too_large};`
`1343`	`1343`	`}`
`1344`	`1344`
`1345`	`1345`	`std::memcpy(buffer, "inf", inf_chars); // NOLINT : Specifically not null-terminating`
`@@ -1359,7 +1359,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci`
`1359`	`1359`
`1360`	`1360`	`if (buffer_size < nan_chars)`
`1361`	`1361`	`{`
`1362`		`- return {last, std::errc::result_out_of_range};`
	`1362`	`+ return {last, std::errc::value_too_large};`
`1363`	`1363`	`}`
`1364`	`1364`
`1365`	`1365`	`std::memcpy(buffer, "nan", nan_chars); // NOLINT : Specifically not null-terminating`
`@@ -1371,7 +1371,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci`
`1371`	`1371`
`1372`	`1372`	`if (buffer_size < neg_nan_chars)`
`1373`	`1373`	`{`
`1374`		`- return {last, std::errc::result_out_of_range};`
	`1374`	`+ return {last, std::errc::value_too_large};`
`1375`	`1375`	`}`
`1376`	`1376`
`1377`	`1377`	`std::memcpy(buffer, "nan(ind)", neg_nan_chars); // NOLINT : Specifically not null-terminating`
`@@ -1384,7 +1384,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci`
`1384`	`1384`
`1385`	`1385`	`if (buffer_size < snan_chars)`
`1386`	`1386`	`{`
`1387`		`- return {last, std::errc::result_out_of_range};`
	`1387`	`+ return {last, std::errc::value_too_large};`
`1388`	`1388`	`}`
`1389`	`1389`
`1390`	`1390`	`std::memcpy(buffer, "nan(snan)", snan_chars); // NOLINT : Specifically not null-terminating`
`@@ -1419,7 +1419,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci`
`1419`	`1419`
`1420`	`1420`	`if (buffer_size < zero_chars)`
`1421`	`1421`	`{`
`1422`		`- return {last, std::errc::result_out_of_range};`
	`1422`	`+ return {last, std::errc::value_too_large};`
`1423`	`1423`	`}`
`1424`	`1424`
`1425`	`1425`	`std::memcpy(buffer, "0e+00", zero_chars);`
`@@ -1429,7 +1429,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci`
`1429`	`1429`	`{`
`1430`	`1430`	`if (buffer_size < static_cast<std::size_t>(precision) + 6U)`
`1431`	`1431`	`{`
`1432`		`- return {last, std::errc::result_out_of_range};`
	`1432`	`+ return {last, std::errc::value_too_large};`
`1433`	`1433`	`}`
`1434`	`1434`
`1435`	`1435`	`std::memcpy(buffer, "0.", 2); // NOLINT : Specifically not null-terminating`
`@@ -1460,7 +1460,7 @@ BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, const int preci`
`1460`	`1460`
`1461`	`1461`	`if (buffer_size < static_cast<std::size_t>(remaining_digits))`
`1462`	`1462`	`{`
`1463`		`- return {last, std::errc::result_out_of_range};`
	`1463`	`+ return {last, std::errc::value_too_large};`
`1464`	`1464`	`}`
`1465`	`1465`
`1466`	`1466`	`/////////////////////////////////////////////////////////////////////////////////////////////////`
Original file line number	Diff line number	Diff line change
`@@ -401,7 +401,7 @@ static inline int generic_to_chars_fixed(const struct floating_decimal_128 v, ch`
`401`	`401`	`// Option 2: Append 0s to the end of the number until we get the proper output`
`402`	`402`	`if (current_len + v.exponent > result_size)`
`403`	`403`	`{`
`404`		`- return -static_cast<int>(std::errc::result_out_of_range);`
	`404`	`+ return -static_cast<int>(std::errc::value_too_large);`
`405`	`405`	`}`
`406`	`406`
`407`	`407`	`memset(r.ptr, '0', static_cast<std::size_t>(v.exponent));`
`@@ -419,7 +419,7 @@ static inline int generic_to_chars_fixed(const struct floating_decimal_128 v, ch`
`419`	`419`	`// Option 4: Leading 0s`
`420`	`420`	`if (-v.exponent + 2 > result_size)`
`421`	`421`	`{`
`422`		`- return -static_cast<int>(std::errc::result_out_of_range);`
	`422`	`+ return -static_cast<int>(std::errc::value_too_large);`
`423`	`423`	`}`
`424`	`424`
`425`	`425`	`memmove(result - v.exponent - current_len + 2, result, static_cast<std::size_t>(current_len));`
`@@ -480,7 +480,7 @@ static inline int generic_to_chars(const struct floating_decimal_128 v, char* re`
`480`	`480`
`481`	`481`	`if (index + olength > static_cast<size_t>(result_size))`
`482`	`482`	`{`
`483`		`- return -static_cast<int>(std::errc::result_out_of_range);`
	`483`	`+ return -static_cast<int>(std::errc::value_too_large);`
`484`	`484`	`}`
`485`	`485`	`else if (olength == 0)`
`486`	`486`	`{`
Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char`
`130`	`130`
`131`	`131`	`if (converted_value_digits > user_buffer_size)`
`132`	`132`	`{`
`133`		`- return {last, std::errc::result_out_of_range};`
	`133`	`+ return {last, std::errc::value_too_large};`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`decompose32(converted_value, buffer);`
`@@ -151,7 +151,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char`
`151`	`151`
`152`	`152`	`if (converted_value_digits > user_buffer_size)`
`153`	`153`	`{`
`154`		`- return {last, std::errc::result_out_of_range};`
	`154`	`+ return {last, std::errc::value_too_large};`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`if (is_negative)`
`@@ -258,7 +258,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_128integer_impl(char* first, c`
`258`	`258`
`259`	`259`	`if (converted_value_digits > user_buffer_size)`
`260`	`260`	`{`
`261`		`- return {last, std::errc::result_out_of_range};`
	`261`	`+ return {last, std::errc::value_too_large};`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`if (is_negative)`
`@@ -409,7 +409,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char`
`409`	`409`
`410`	`410`	`if (num_chars > output_length)`
`411`	`411`	`{`
`412`		`- return {last, std::errc::result_out_of_range};`
	`412`	`+ return {last, std::errc::value_too_large};`
`413`	`413`	`}`
`414`	`414`
`415`	`415`	`boost::charconv::detail::memcpy(first, buffer + (buffer_size - static_cast<unsigned long>(num_chars)),`
Original file line number	Diff line number	Diff line change
`@@ -272,7 +272,7 @@ namespace boost { namespace charconv { namespace detail { namespace to_chars_det`
`272`	`272`	`const std::ptrdiff_t total_length = total_buffer_length(9, exponent, false);`
`273`	`273`	`if (total_length > (last - first))`
`274`	`274`	`{`
`275`		`- return {last, std::errc::result_out_of_range};`
	`275`	`+ return {last, std::errc::value_too_large};`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`// Print significand.`
`@@ -315,7 +315,7 @@ namespace boost { namespace charconv { namespace detail { namespace to_chars_det`
`315`	`315`	`const std::ptrdiff_t total_length = total_buffer_length(17, exponent, false);`
`316`	`316`	`if (total_length > (last - first))`
`317`	`317`	`{`
`318`		`- return {last, std::errc::result_out_of_range};`
	`318`	`+ return {last, std::errc::value_too_large};`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`// Print significand by decomposing it into a 9-digit block and a 8-digit block.`
`@@ -593,7 +593,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la`
`593`	`593`	`}`
`594`	`594`	`else`
`595`	`595`	`{`
`596`		`- return {last, std::errc::result_out_of_range};`
	`596`	`+ return {last, std::errc::value_too_large};`
`597`	`597`	`}`
`598`	`598`	`}`
`599`	`599`	`#endif`
`@@ -603,7 +603,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la`
`603`	`603`	`auto real_precision = boost::charconv::detail::get_real_precision<long double>(precision);`
`604`	`604`	`if (buffer_size < real_precision \|\| first > last)`
`605`	`605`	`{`
`606`		`- return {last, std::errc::result_out_of_range};`
	`606`	`+ return {last, std::errc::value_too_large};`
`607`	`607`	`}`
`608`	`608`
`609`	`609`	`if (fmt == boost::charconv::chars_format::general \|\| fmt == boost::charconv::chars_format::scientific)`
`@@ -629,9 +629,9 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la`
`629`	`629`	`{`
`630`	`630`	`return { first + num_chars, std::errc() };`
`631`	`631`	`}`
`632`		`- else if (num_chars == -static_cast<int>(std::errc::result_out_of_range))`
	`632`	`+ else if (num_chars == -static_cast<int>(std::errc::value_too_large))`
`633`	`633`	`{`
`634`		`- return { last, std::errc::result_out_of_range };`
	`634`	`+ return { last, std::errc::value_too_large };`
`635`	`635`	`}`
`636`	`636`	`}`
`637`	`637`
`@@ -686,7 +686,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la`
`686`	`686`	`// Sanity check our bounds`
`687`	`687`	`if (first >= last)`
`688`	`688`	`{`
`689`		`- return {last, std::errc::result_out_of_range};`
	`689`	`+ return {last, std::errc::value_too_large};`
`690`	`690`	`}`
`691`	`691`
`692`	`692`	`char* const original_first = first;`
`@@ -705,7 +705,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la`
`705`	`705`	`auto real_precision = boost::charconv::detail::get_real_precision<__float128>(precision);`
`706`	`706`	`if (buffer_size < real_precision \|\| first > last)`
`707`	`707`	`{`
`708`		`- return {last, std::errc::result_out_of_range};`
	`708`	`+ return {last, std::errc::value_too_large};`
`709`	`709`	`}`
`710`	`710`
`711`	`711`	`if ((fmt == boost::charconv::chars_format::general \|\| fmt == boost::charconv::chars_format::scientific))`
`@@ -719,7 +719,7 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la`
`719`	`719`	`}`
`720`	`720`	`else if (num_chars == -1)`
`721`	`721`	`{`
`722`		`- return {last, std::errc::result_out_of_range};`
	`722`	`+ return {last, std::errc::value_too_large};`
`723`	`723`	`}`
`724`	`724`	`}`
`725`	`725`	`else if (fmt == boost::charconv::chars_format::hex)`
`@@ -735,9 +735,9 @@ boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* la`
`735`	`735`	`{`
`736`	`736`	`return { first + num_chars, std::errc() };`
`737`	`737`	`}`
`738`		`- else if (num_chars == -static_cast<int>(std::errc::result_out_of_range))`
	`738`	`+ else if (num_chars == -static_cast<int>(std::errc::value_too_large))`
`739`	`739`	`{`
`740`		`- return { last, std::errc::result_out_of_range };`
	`740`	`+ return { last, std::errc::value_too_large };`
`741`	`741`	`}`
`742`	`742`	`}`
`743`	`743`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ inline to_chars_result to_chars_nonfinite(char* first, char* last, Real value, i`
`87`	`87`	`else`
`88`	`88`	`{`
`89`	`89`	`// Avoid buffer overflow`
`90`		`- return { first, std::errc::result_out_of_range };`
	`90`	`+ return { first, std::errc::value_too_large };`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`}`
`@@ -107,7 +107,7 @@ inline to_chars_result to_chars_nonfinite(char* first, char* last, Real value, i`
`107`	`107`	`else`
`108`	`108`	`{`
`109`	`109`	`// Avoid buffer overflow`
`110`		`- return { first, std::errc::result_out_of_range };`
	`110`	`+ return { first, std::errc::value_too_large };`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`	`else`
`@@ -165,7 +165,7 @@ inline to_chars_result to_chars_nonfinite<__float128>(char* first, char* last, _`
`165`	`165`	`else`
`166`	`166`	`{`
`167`	`167`	`// Avoid buffer overflow`
`168`		`- return { first, std::errc::result_out_of_range };`
	`168`	`+ return { first, std::errc::value_too_large };`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`}`
`@@ -184,7 +184,7 @@ inline to_chars_result to_chars_nonfinite<__float128>(char* first, char* last, _`
`184`	`184`	`else`
`185`	`185`	`{`
`186`	`186`	`// Avoid buffer overflow`
`187`		`- return { first, std::errc::result_out_of_range };`
	`187`	`+ return { first, std::errc::value_too_large };`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`	`else`
`@@ -258,7 +258,7 @@ to_chars_result to_chars_hex(char* first, char* last, Real value, int precision)`
`258`	`258`
`259`	`259`	`if (buffer_size < real_precision \|\| first > last)`
`260`	`260`	`{`
`261`		`- return {last, std::errc::result_out_of_range};`
	`261`	`+ return {last, std::errc::value_too_large};`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`// Extract the significand and the exponent`
`@@ -374,7 +374,7 @@ to_chars_result to_chars_hex(char* first, char* last, Real value, int precision)`
`374`	`374`	`const std::ptrdiff_t total_length = total_buffer_length(real_precision, abs_unbiased_exponent, (value < 0));`
`375`	`375`	`if (total_length > buffer_size)`
`376`	`376`	`{`
`377`		`- return {last, std::errc::result_out_of_range};`
	`377`	`+ return {last, std::errc::value_too_large};`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`// Round if required`
`@@ -483,7 +483,7 @@ to_chars_result to_chars_fixed_impl(char* first, char* last, Real value, chars_f`
`483`	`483`	`auto real_precision = get_real_precision<Real>(precision);`
`484`	`484`	`if (buffer_size < real_precision \|\| first > last)`
`485`	`485`	`{`
`486`		`- return {last, std::errc::result_out_of_range};`
	`486`	`+ return {last, std::errc::value_too_large};`
`487`	`487`	`}`
`488`	`488`
`489`	`489`	`auto abs_value = std::abs(value);`
`@@ -534,7 +534,7 @@ to_chars_result to_chars_fixed_impl(char* first, char* last, Real value, chars_f`
`534`	`534`	`const std::ptrdiff_t total_length = total_buffer_length(num_dig, value_struct.exponent, (value < 0));`
`535`	`535`	`if (total_length > buffer_size)`
`536`	`536`	`{`
`537`		`- return {last, std::errc::result_out_of_range};`
	`537`	`+ return {last, std::errc::value_too_large};`
`538`	`538`	`}`
`539`	`539`
`540`	`540`	`auto r = to_chars_integer_impl(first, last, value_struct.significand);`
`@@ -598,7 +598,7 @@ to_chars_result to_chars_float_impl(char* first, char* last, Real value, chars_f`
`598`	`598`	`// Sanity check our bounds`
`599`	`599`	`if (first >= last)`
`600`	`600`	`{`
`601`		`- return {last, std::errc::result_out_of_range};`
	`601`	`+ return {last, std::errc::value_too_large};`
`602`	`602`	`}`
`603`	`603`
`604`	`604`	`auto abs_value = std::abs(value);`