Fix to_chars errc value for overflow

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`

include/boost/charconv/detail/dragonbox/dragonbox.hpp

@@ -2605,7 +2605,7 @@
                 }
                 else
                 {
-                    return {last, std::errc::result_out_of_range};
+                    return {last, std::errc::value_too_large};
                 }
             }
         }
@@ -2628,7 +2628,7 @@
                 }
                 else
                 {
-                    return {last, std::errc::result_out_of_range};
+                    return {last, std::errc::value_too_large};
                 }
             }
             else 
@@ -2677,7 +2677,7 @@
                         }
                         else
                         {
-                            return {last, std::errc::result_out_of_range};
+                            return {last, std::errc::value_too_large};
                         }
                     }
                     else
@@ -2689,7 +2689,7 @@
                         }
                         else
                         {
-                            return {last, std::errc::result_out_of_range};
+                            return {last, std::errc::value_too_large};
                         }
                     }
                 }
@@ -2702,7 +2702,7 @@
                     }
                     else
                     {
-                        return {last, std::errc::result_out_of_range};
+                        return {last, std::errc::value_too_large};
                     }
                 }
             }

include/boost/charconv/detail/dragonbox/floff.hpp

@@ -1308,7 +1308,7 @@
 {
     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 @@
 
             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 @@
 
                     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 @@
 
                     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 @@
 
                 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 @@
 
                     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 @@
                 {
                     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 @@
 
     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};
     }
 
     /////////////////////////////////////////////////////////////////////////////////////////////////

include/boost/charconv/detail/ryu/ryu_generic_128.hpp

@@ -401,7 +401,7 @@
         // 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 @@
         // 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 @@
 
     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)
     {

include/boost/charconv/detail/to_chars_integer_impl.hpp

@@ -130,7 +130,7 @@
 
         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 @@
 
         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 @@
 
     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 @@
 
     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)),

src/to_chars.cpp

@@ -272,7 +272,7 @@
         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 @@
         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 @@
         }
         else
         {
-            return {last, std::errc::result_out_of_range};
+            return {last, std::errc::value_too_large};
         }
     }
     #endif
@@ -603,7 +603,7 @@
     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 @@
         {
             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 @@
     // 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 @@
     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 @@
         }
         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 @@
         {
             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 };
         }
     }
 

src/to_chars_float_impl.hpp

@@ -87,7 +87,7 @@
         else
         {
             // Avoid buffer overflow
-            return { first, std::errc::result_out_of_range };
+            return { first, std::errc::value_too_large };
         }
 
     }
@@ -107,7 +107,7 @@
         else
         {
             // Avoid buffer overflow
-            return { first, std::errc::result_out_of_range };
+            return { first, std::errc::value_too_large };
         }
     }
     else
@@ -165,7 +165,7 @@
         else
         {
             // Avoid buffer overflow
-            return { first, std::errc::result_out_of_range };
+            return { first, std::errc::value_too_large };
         }
 
     }
@@ -184,7 +184,7 @@
         else
         {
             // Avoid buffer overflow
-            return { first, std::errc::result_out_of_range };
+            return { first, std::errc::value_too_large };
         }
     }
     else
@@ -258,7 +258,7 @@
 
     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 @@
     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 @@
     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 @@
     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 @@
     // 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);