Refactor <limits> usage

stl/inc/__msvc_int128.hpp

@@ -1415,6 +1415,32 @@ struct common_type<_Unsigned128, _Signed128> {
  using type = _Unsigned128;
 };
 
+template <class _Ty>
+_NODISCARD constexpr _Ty _Min_limit() noexcept;
+
+template <>
+_NODISCARD constexpr _Unsigned128 _Min_limit<_Unsigned128>() noexcept {
+ return 0;
+}
+
+template <>
+_NODISCARD constexpr _Signed128 _Min_limit<_Signed128>() noexcept {
+ return _Signed128{0ull, 1ull << 63};
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty _Max_limit() noexcept;
+
+template <>
+_NODISCARD constexpr _Unsigned128 _Max_limit<_Unsigned128>() noexcept {
+ return _Unsigned128{~0ull, ~0ull};
+}
+
+template <>
+_NODISCARD constexpr _Signed128 _Max_limit<_Signed128>() noexcept {
+ return _Signed128{~0ull, ~0ull >> 1};
+}
+
 #undef _STL_128_INTRINSICS
 #undef _STL_128_DIV_INTRINSICS
 

stl/inc/algorithm

@@ -2219,7 +2219,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt search_n(
  return _First;
  }
 
- if (static_cast<uintmax_t>(_Count) > static_cast<uintmax_t>((numeric_limits<_Iter_diff_t<_FwdIt>>::max)())) {
+ if (static_cast<uintmax_t>(_Count) > static_cast<uintmax_t>(_STD _Max_limit<_Iter_diff_t<_FwdIt>>())) {
  // if the number of _Vals searched for is larger than the longest possible sequence, we can't find it
  return _Last;
  }

stl/inc/bitset

@@ -325,7 +325,7 @@ public:
  }
  }
 
- if (_Array[0] > ULONG_MAX) {
+ if (!_STD _In_range<unsigned long>(_Array[0])) {
  _Xoflo();
  }
 

stl/inc/chrono

@@ -58,7 +58,7 @@ _NODISCARD basic_string<typename _Traits::char_type, _Traits, _Alloc> _Convert_w
  basic_string<typename _Traits::char_type, _Traits, _Alloc> _Output(_Al);
 
  if (!_Input.empty()) {
- if (_Input.size() > static_cast<size_t>(INT_MAX)) {
+ if (!_STD _In_range<int>(_Input.size())) {
  _Throw_system_error(errc::invalid_argument);
  }
 
@@ -4790,7 +4790,7 @@ private:
  _ParseContext& _Parse_ctx;
 
  _NODISCARD static constexpr int _Verify_dynamic_arg_index_in_range(const size_t _Idx) {
- if (_Idx > static_cast<size_t>((numeric_limits<int>::max)())) {
+ if (!_STD in_range<int>(_Idx)) {
  _Throw_format_error("Dynamic width or precision index too large.");
  }
 

stl/inc/deque

@@ -962,8 +962,7 @@ public:
  }
 
  _NODISCARD size_type max_size() const noexcept {
- return (_STD min)(
- static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alty_traits::max_size(_Getal()));
+ return (_STD min)(static_cast<size_type>(_STD _Max_limit<difference_type>()), _Alty_traits::max_size(_Getal()));
  }
 
  void resize(_CRT_GUARDOVERFLOW size_type _Newsize) {

stl/inc/execution

@@ -2279,7 +2279,7 @@ _NODISCARD _FwdIt search_n(_ExPo&&, const _FwdIt _First, _FwdIt _Last, const _Di
  return _Last;
  }
 
- if (static_cast<uintmax_t>(_Count) > static_cast<uintmax_t>((numeric_limits<_Iter_diff_t<_FwdIt>>::max)())) {
+ if (static_cast<uintmax_t>(_Count) > static_cast<uintmax_t>(_STD _Max_limit<_Iter_diff_t<_FwdIt>>())) {
  // if the number of _Vals searched for is larger than the longest possible sequence, we can't find it
  return _Last;
  }

stl/inc/filesystem

@@ -40,7 +40,7 @@ namespace filesystem {
  wstring _Output;
 
  if (!_Input.empty()) {
- if (_Input.size() > static_cast<size_t>(INT_MAX)) {
+ if (!_STD _In_range<int>(_Input.size())) {
  _Throw_system_error(errc::invalid_argument);
  }
 
@@ -64,7 +64,7 @@ namespace filesystem {
  basic_string<typename _Traits::char_type, _Traits, _Alloc> _Output(_Al);
 
  if (!_Input.empty()) {
- if (_Input.size() > static_cast<size_t>(INT_MAX)) {
+ if (!_STD _In_range<int>(_Input.size())) {
  _Throw_system_error(errc::invalid_argument);
  }
 

stl/inc/format

@@ -50,7 +50,6 @@ _EMIT_STL_WARNING(STL4038, "The contents of <format> are available only with C++
 #include <concepts>
 #include <cstdint>
 #include <iterator>
-#include <limits>
 #include <locale>
 #include <stdexcept>
 #include <xcall_once.h>
@@ -936,7 +935,7 @@ _NODISCARD constexpr const _CharT* _Parse_nonnegative_integer(
  const _CharT* _First, const _CharT* _Last, unsigned int& _Value) {
  _STL_INTERNAL_CHECK(_First != _Last && '0' <= *_First && *_First <= '9');
 
- constexpr auto _Max_int = static_cast<unsigned int>((numeric_limits<int>::max)());
+ constexpr auto _Max_int = static_cast<unsigned int>(_STD _Max_limit<int>());
  constexpr auto _Big_int = _Max_int / 10u;
 
  _Value = 0;
@@ -1660,7 +1659,7 @@ template <class _Handler, class _FormatArg>
 _NODISCARD constexpr int _Get_dynamic_specs(const _FormatArg _Arg) {
  _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_Handler, _Width_checker, _Precision_checker>);
  const unsigned long long _Val = _STD visit_format_arg(_Handler{}, _Arg);
- if (_Val > static_cast<unsigned long long>((numeric_limits<int>::max)())) {
+ if (!_STD in_range<int>(_Val)) {
  _Throw_format_error("Number is too big.");
  }
 
@@ -1740,7 +1739,7 @@ private:
  _ParseContext& _Parse_ctx;
 
  _NODISCARD static constexpr int _Verify_dynamic_arg_index_in_range(const size_t _Idx) {
- if (_Idx > static_cast<size_t>((numeric_limits<int>::max)())) {
+ if (!_STD in_range<int>(_Idx)) {
  _Throw_format_error("Dynamic width or precision index too large.");
  }
 
@@ -1823,7 +1822,7 @@ public:
 
  template <class _CharT>
  constexpr void _On_type(_CharT _Type) {
- if (_Type < 0 || _Type > (numeric_limits<signed char>::max)()) {
+ if (_Type < 0 || _Type > _STD _Max_limit<signed char>()) {
  _Throw_format_error("Invalid type specification.");
  }
  const char _Narrow_type = static_cast<char>(_Type);
@@ -3350,7 +3349,7 @@ _NODISCARD const _CharT* _Measure_string_prefix(const basic_string_view<_CharT>
  _Measure_string_prefix_iterator<_CharT> _Pfx_iter(_First, _Last);
  int _Estimated_width = 0; // the estimated width of [_First, _Pfx_iter)
 
- constexpr auto _Max_int = (numeric_limits<int>::max)();
+ constexpr auto _Max_int = _STD _Max_limit<int>();
 
  while (_Pfx_iter != default_sentinel) {
  if (_Estimated_width == _Max_width && _Max_width >= 0) {

stl/inc/forward_list

@@ -888,7 +888,7 @@ public:
 
  _NODISCARD size_type max_size() const noexcept {
  return (_STD min)(
- static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alnode_traits::max_size(_Getal()));
+ static_cast<size_type>(_STD _Max_limit<difference_type>()), _Alnode_traits::max_size(_Getal()));
  }
 
  _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {

stl/inc/functional

@@ -2638,7 +2638,7 @@ void _Build_boyer_moore_delta_2_table(_Iter_diff_t<_RanItPat>* const _Shifts, co
  return;
  }
 
- if ((numeric_limits<_Diff>::max)() - _Pat_size < _Pat_size) {
+ if (_STD _Max_limit<_Diff>() - _Pat_size < _Pat_size) {
  _Xlength_error("Boyer-Moore pattern is too long");
  }
 

stl/inc/istream

@@ -210,7 +210,7 @@ private:
 
  template <class = void>
  void _Increment_gcount() noexcept {
- if (_Chcount != (numeric_limits<streamsize>::max)()) {
+ if (_Chcount != _STD _Max_limit<streamsize>()) {
  ++_Chcount;
  }
  }
@@ -492,7 +492,7 @@ public:
  _TRY_IO_BEGIN
  for (;;) { // get a metacharacter if more room in buffer
  int_type _Meta;
- if (_Count != (numeric_limits<streamsize>::max)() && --_Count < 0) {
+ if (_Count != _STD _Max_limit<streamsize>() && --_Count < 0) {
  break; // buffer full, quit
  } else if (_Traits::eq_int_type(_Traits::eof(),
  _Meta = _Myios::rdbuf()->sbumpc())) { // end of file, quit

stl/inc/list

@@ -1193,7 +1193,7 @@ public:
 
  _NODISCARD size_type max_size() const noexcept {
  return (_STD min)(
- static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alnode_traits::max_size(_Getal()));
+ static_cast<size_type>(_STD _Max_limit<difference_type>()), _Alnode_traits::max_size(_Getal()));
  }
 
  _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {

stl/inc/mdspan

@@ -11,7 +11,6 @@
 _EMIT_STL_WARNING(STL4038, "The contents of <mdspan> are available only with C++23 or later.");
 #else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
 #include <array>
-#include <limits>
 #include <span>
 #include <tuple>
 #include <type_traits>
@@ -213,7 +212,7 @@ public:
  requires (sizeof...(_OtherExtents) == rank())
  && ((_OtherExtents == dynamic_extent || _Extents == dynamic_extent || _OtherExtents == _Extents) && ...)
  constexpr explicit(((_Extents != dynamic_extent && _OtherExtents == dynamic_extent) || ...)
- || (numeric_limits<index_type>::max)() < (numeric_limits<_OtherIndexType>::max)())
+ || _STD _Max_limit<index_type>() < _STD _Max_limit<_OtherIndexType>())
  extents(const extents<_OtherIndexType, _OtherExtents...>& _Other) noexcept
  : extents(_Other, make_index_sequence<rank_dynamic()>{}) {}
 

stl/inc/regex

@@ -567,7 +567,7 @@ int _Iter_compare(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Las
 
 inline bool _Is_word(unsigned char _UCh) {
  // special casing char to avoid branches for std::regex in this path
- static constexpr bool _Is_word_table[(numeric_limits<unsigned char>::max)() + 1] = {
+ static constexpr bool _Is_word_table[_STD _Max_limit<unsigned char>() + 1] = {
  // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 XA XB XC XD XE XF
  /* 0X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  /* 1X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -2958,7 +2958,7 @@ void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_named_class(typename _Regex_traits
  bool _Negate) { // add contents of named class to bracket expression
  _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
  _Add_elts(_Node, _Cl, _Negate);
- if (_Bmp_max < static_cast<unsigned int>((numeric_limits<_Elem>::max)())) {
+ if (_Bmp_max < static_cast<unsigned int>(_STD _Max_limit<_Elem>())) {
  _Node->_Classes = static_cast<_Regex_traits_base::char_class_type>(_Node->_Classes | _Cl);
  }
 }
@@ -3005,7 +3005,7 @@ void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_equiv(_FwdIt _First, _FwdIt _Last,
  _Node->_Small->_Mark(_Ch);
  }
  }
- if (_Bmp_max < static_cast<unsigned int>((numeric_limits<_Elem>::max)())) { // map range
+ if (_Bmp_max < static_cast<unsigned int>(_STD _Max_limit<_Elem>())) { // map range
  _Sequence<_Elem>** _Cur = _STD addressof(_Node->_Equiv);
  _Char_to_elts(_First, _Last, _Diff, _Cur);
  }
@@ -4330,7 +4330,7 @@ bool _Parser<_FwdIt, _Elem, _RxTraits>::_CharacterEscape() { // check for valid
  return _IdentityEscape();
  }
 
- if ((numeric_limits<typename _RxTraits::_Uelem>::max)() < static_cast<unsigned int>(_Val)) {
+ if (_STD _Max_limit<typename _RxTraits::_Uelem>() < static_cast<unsigned int>(_Val)) {
  _Error(regex_constants::error_escape);
  }
 

stl/inc/semaphore

@@ -43,8 +43,8 @@ _NODISCARD unsigned long _Semaphore_remaining_timeout(const chrono::time_point<_
  }
 
  const auto _Rel_time = chrono::ceil<chrono::milliseconds>(_Abs_time - _Now);
- static constexpr chrono::milliseconds _Ten_days{chrono::hours{24 * 10}};
- static_assert(_Ten_days.count() < ULONG_MAX, "Bad sizing assumption");
+ constexpr chrono::milliseconds _Ten_days{chrono::hours{24 * 10}};
+ _STL_INTERNAL_STATIC_ASSERT(_STD in_range<unsigned long>(_Ten_days.count()));
  if (_Rel_time >= _Ten_days) {
  return static_cast<unsigned long>(_Ten_days.count());
  }

stl/inc/spanstream

@@ -123,7 +123,7 @@ protected:
  const auto _Baseoff = (_Mode & ios_base::out) && !(_Mode & ios_base::in)
  ? static_cast<off_type>(_Mysb::pptr() - _Mysb::pbase())
  : static_cast<off_type>(_Buf.size());
- if (_Off > (numeric_limits<off_type>::max)() - _Baseoff) { // overflow, _Baseoff is always non-negative
+ if (_Off > _STD _Max_limit<off_type>() - _Baseoff) { // overflow, _Baseoff is always non-negative
  return pos_type{off_type{-1}}; // report failure
  }
 

stl/inc/utility

@@ -840,7 +840,7 @@ _NODISCARD constexpr bool _Cmp_greater_equal(const _Ty1 _Left, const _Ty2 _Right
 
 template <class _Ty>
 _NODISCARD constexpr _Ty _Min_limit() noexcept { // same as (numeric_limits<_Ty>::min)(), less throughput cost
- _STL_INTERNAL_STATIC_ASSERT(_Is_standard_integer<_Ty>); // doesn't attempt to handle all types
+ _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_Ty>); // doesn't attempt to handle all types
  if constexpr (is_signed_v<_Ty>) {
  constexpr auto _Unsigned_max = static_cast<make_unsigned_t<_Ty>>(-1);
  return static_cast<_Ty>((_Unsigned_max >> 1) + 1); // well-defined, N4950 [conv.integral]/3
@@ -851,7 +851,7 @@ _NODISCARD constexpr _Ty _Min_limit() noexcept { // same as (numeric_limits<_Ty>
 
 template <class _Ty>
 _NODISCARD constexpr _Ty _Max_limit() noexcept { // same as (numeric_limits<_Ty>::max)(), less throughput cost
- _STL_INTERNAL_STATIC_ASSERT(_Is_standard_integer<_Ty>); // doesn't attempt to handle all types
+ _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_Ty>); // doesn't attempt to handle all types
  if constexpr (is_signed_v<_Ty>) {
  constexpr auto _Unsigned_max = static_cast<make_unsigned_t<_Ty>>(-1);
  return static_cast<_Ty>(_Unsigned_max >> 1);

stl/inc/vector

@@ -1874,8 +1874,7 @@ public:
  }
 
  _NODISCARD _CONSTEXPR20 size_type max_size() const noexcept {
- return (_STD min)(
- static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alty_traits::max_size(_Getal()));
+ return (_STD min)(static_cast<size_type>(_STD _Max_limit<difference_type>()), _Alty_traits::max_size(_Getal()));
  }
 
  _NODISCARD _CONSTEXPR20 size_type capacity() const noexcept {
@@ -3149,7 +3148,7 @@ public:
  }
 
  _NODISCARD _CONSTEXPR20 size_type max_size() const noexcept {
- constexpr auto _Diff_max = static_cast<size_type>((numeric_limits<difference_type>::max)());
+ constexpr auto _Diff_max = static_cast<size_type>(_STD _Max_limit<difference_type>());
  const size_type _Ints_max = this->_Myvec.max_size();
  if (_Ints_max > _Diff_max / _VBITS) { // max_size bound by difference_type limits
  return _Diff_max;

stl/inc/xhash

@@ -271,8 +271,8 @@ struct _Hash_vec {
  }
 
  _NODISCARD size_type max_size() const noexcept {
- return (_STD min)(static_cast<size_type>((numeric_limits<difference_type>::max)()),
- _Aliter_traits::max_size(_Mypair._Get_first()));
+ return (_STD min)(
+ static_cast<size_type>(_STD _Max_limit<difference_type>()), _Aliter_traits::max_size(_Mypair._Get_first()));
  }
 
  _NODISCARD size_type capacity() const noexcept {

stl/inc/xlocnum

@@ -7,6 +7,7 @@
 #define _XLOCNUM_
 #include <yvals_core.h>
 #if _STL_COMPILER_PREPROCESSOR
+#include <cfloat>
 #include <climits>
 #include <cmath>
 #include <cstdio>

stl/inc/xmemory

@@ -9,7 +9,6 @@
 #if _STL_COMPILER_PREPROCESSOR
 #include <cstdint>
 #include <cstdlib>
-#include <limits>
 #include <new>
 #include <xatomic.h>
 #include <xutility>
@@ -18,6 +17,10 @@
 #include <tuple>
 #endif // _HAS_CXX20
 
+#ifdef _LEGACY_CODE_ASSUMES_XMEMORY_INCLUDES_LIMITS
+#include <limits>
+#endif
+
 #pragma pack(push, _CRT_PACKING)
 #pragma warning(push, _STL_WARNING_LEVEL)
 #pragma warning(disable : _STL_DISABLED_WARNINGS)
@@ -606,7 +609,7 @@ struct _Normal_allocator_traits { // defines traits for allocators
  if constexpr (_Has_max_size<_Alloc>::value) {
  return _Al.max_size();
  } else {
- return (numeric_limits<size_type>::max)() / sizeof(value_type);
+ return _STD _Max_limit<size_type>() / sizeof(value_type);
  }
  }
 
@@ -1087,7 +1090,7 @@ _NODISCARD constexpr _Size_type _Convert_size(const _Unsigned_type _Len) noexcep
  _STL_INTERNAL_STATIC_ASSERT(_Size_type(-1) > 0);
 
  if constexpr (sizeof(_Unsigned_type) > sizeof(_Size_type)) {
- if (_Len > (numeric_limits<_Size_type>::max)()) {
+ if (_Len > _STD _Max_limit<_Size_type>()) {
  _Xlength_error("size is too long for _Size_type");
  }
  }

stl/inc/xstring

@@ -4151,7 +4151,7 @@ public:
  const size_type _Alloc_max = _Alty_traits::max_size(_Getal());
  const size_type _Storage_max = // can always store small string
  (_STD max)(_Alloc_max, static_cast<size_type>(_BUF_SIZE));
- return (_STD min)(static_cast<size_type>((numeric_limits<difference_type>::max)()),
+ return (_STD min)(static_cast<size_type>(_STD _Max_limit<difference_type>()),
  _Storage_max - 1 // -1 is for null terminator and/or npos
  );
  }

stl/inc/xtree

@@ -1187,7 +1187,7 @@ public:
 
  _NODISCARD size_type max_size() const noexcept {
  return (_STD min)(
- static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alnode_traits::max_size(_Getal()));
+ static_cast<size_type>(_STD _Max_limit<difference_type>()), _Alnode_traits::max_size(_Getal()));
  }
 
  _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {