More size limit fixes

Author: gershnik

doc/Usage.md

@@ -142,9 +142,8 @@ sys_string result = S("a") + U'b' + "cd" + "ef"s + u"gh"sv + U"ij" + std::vector
 assert(result == S("abcdefghijkl"));
 ```
 
-[!WARNING]
-
-You must not use `auto` for the addition result. The result of an addition is a special temporary that only performs actual concatenation when converted to `sys_string_t`. Using `auto` declares a variable of that temporary type which will result in dangling pointers.
+> [!WARNING]
+> You must not use `auto` to declare the addition result. The result of an addition is a special temporary that only performs actual concatenation when converted to `sys_string_t`. Using `auto` declares a variable of that temporary type which will result in dangling pointers.
 
 ```cpp
 auto res = sys_string("abc") + sys_string("xyz"); //Bad!
@@ -527,8 +526,8 @@ friend auto operator<<(std::ostream & str, const sys_string & val) -> std::ostre
 
 Prints the string content **as UTF-8** into `std::ostream`. 
 
-[!WARNING] 
-Note that if your output goes somewhere that doesn't use UTF-8 encoding (Windows console or Unix terminal with non UTF-8 locale, for example) the output will be garbled.
+> [!WARNING] 
+> Note that if your output goes somewhere that doesn't use UTF-8 encoding (Windows console or Unix terminal with non UTF-8 locale, for example) the output will be garbled.
 
 On Windows or on any platform that defines `__STDC_ISO_10646__` macro there is also
 
@@ -538,9 +537,9 @@ friend auto operator<<(std::wostream & str, const sys_string & val) -> std::wost
 
 That prints out UTF-16 or UTF-32 views of the string.
 
-[!NOTE]
-The `operator<<` currently completely ignores width, precision and fill settings of the stream - the entire string
-is printed out as is. This might change in future versions.
+> [!NOTE]
+> The `operator<<` currently completely ignores width, precision and fill settings of the stream - the entire string
+> is printed out as is. This might change in future versions.
 
 ### Formatting with `std::format`
 

lib/inc/sys_string/impl/addition.h

@@ -68,7 +68,7 @@ namespace sysstr::util
         auto storage_size() const -> typename sys_string_t<Storage>::size_type
         { 
             size_t count = m_view.size();
-            if (count > size_t(std::numeric_limits<typename sys_string_t<Storage>::size_type>::max()))
+            if (count > size_t(Storage::max_size))
                 throw std::bad_alloc();
             return static_cast<typename sys_string_t<Storage>::size_type>(count);
         }
@@ -112,7 +112,7 @@ namespace sysstr::util
                                             utf_encoding_of<typename sys_string_t<Storage>::storage_type>>;
                 count = converter::converted_length(this->m_range);
             }
-            if (count > size_t(std::numeric_limits<typename sys_string_t<Storage>::size_type>::max()))
+            if (count > size_t(Storage::max_size))
                 throw std::bad_alloc();
             return static_cast<typename sys_string_t<Storage>::size_type>(count);
         }
@@ -181,7 +181,7 @@ namespace sysstr::util
         { 
             auto s1 = this->m_first.storage_size();
             auto s2 = this->m_second.storage_size();
-            if (std::numeric_limits<typename sys_string_t<Storage>::size_type>::max() - s1 < s2)
+            if (Storage::max_size - s1 < s2)
                 throw std::bad_alloc();
             return s1 + s2; 
         }

lib/inc/sys_string/impl/builder.h

@@ -52,7 +52,7 @@ namespace sysstr
         {
             if constexpr (std::ranges::contiguous_range<Range>)
             {
-                impl.append(std::ranges::data(range), std::ranges::size(range));
+                impl.append(std::ranges::data(range), limit_size(std::ranges::size(range)));
             }
             else
             {
@@ -78,7 +78,7 @@ namespace sysstr
         {
             if constexpr (std::ranges::contiguous_range<Range>)
             {
-                return impl.insert(where, std::ranges::data(range), std::ranges::size(range));
+                return impl.insert(where, std::ranges::data(range), limit_size(std::ranges::size(range)));
             }
             else
             {

lib/inc/sys_string/sys_string.h

@@ -660,6 +660,12 @@ namespace sysstr
             { return m_impl; }
 
     private:
+        static size_type limit_size(size_t len)
+        {
+            if (len > size_t(Storage::max_size))
+                throw std::bad_alloc();
+            return size_type(len);
+        }
         static void append_one(impl_type & impl, char32_t c);
 
         static typename impl_type::iterator insert_one(impl_type & impl, typename impl_type::iterator where, char32_t c);