Cast character data to char8_t

Author: jimporter

include/bencode.hpp

@@ -403,33 +403,33 @@ namespace bencode {
       for(int i = 0; i != std::numeric_limits<Integer>::digits10; i++) {
         if(begin == end)
           throw end_of_input_error();
-        if(!std::isdigit(*begin))
+        if(!std::isdigit(static_cast<char>(*begin)))
           return value;
 
         if constexpr(std::is_signed_v<Integer>)
-          value = value * 10 + (*begin++ - u8'0') * sgn;
+          value = value * 10 + (static_cast<char8_t>(*begin++) - u8'0') * sgn;
         else
-          value = value * 10 + (*begin++ - u8'0');
+          value = value * 10 + (static_cast<char8_t>(*begin++) - u8'0');
       }
       if(begin == end)
         throw end_of_input_error();
 
       // We're approaching the limits of what `Integer` can hold. Check for
       // overflow.
-      if(std::isdigit(*begin)) {
+      if(std::isdigit(static_cast<char>(*begin))) {
         Integer digit;
         if constexpr(std::is_signed_v<Integer>) {
-          digit = (*begin++ - u8'0') * sgn;
+          digit = (static_cast<char8_t>(*begin++) - u8'0') * sgn;
           check_over_underflow(value, digit, sgn);
         } else {
-          digit = (*begin++ - u8'0');
+          digit = (static_cast<char8_t>(*begin++) - u8'0');
           check_overflow(value, digit);
         }
         value = value * 10 + digit;
       }
 
       // Still more digits? That's too many!
-      if(std::isdigit(*begin)) {
+      if(std::isdigit(static_cast<char>(*begin))) {
         if(sgn == 1)
           throw std::overflow_error("integer overflow");
         else
@@ -441,10 +441,10 @@ namespace bencode {
 
     template<std::integral Integer, std::input_iterator Iter>
     Integer decode_int(Iter &begin, Iter end) {
-      assert(*begin == u8'i');
+      assert(static_cast<char8_t>(*begin) == u8'i');
       ++begin;
       Integer sgn = 1;
-      if(*begin == u8'-') {
+      if(static_cast<char8_t>(*begin) == u8'-') {
         if constexpr(std::is_unsigned_v<Integer>) {
           throw std::underflow_error("expected unsigned integer");
         } else {
@@ -454,7 +454,7 @@ namespace bencode {
       }
 
       Integer value = decode_digits<Integer>(begin, end, sgn);
-      if(*begin != u8'e')
+      if(static_cast<char8_t>(*begin) != u8'e')
         throw syntax_error("expected 'e' token");
 
       ++begin;
@@ -498,11 +498,11 @@ namespace bencode {
 
     template<typename String, std::input_iterator Iter>
     String decode_str(Iter &begin, Iter end) {
-      assert(std::isdigit(*begin));
+      assert(std::isdigit(static_cast<char>(*begin)));
       std::size_t len = decode_digits<std::size_t>(begin, end);
       if(begin == end)
         throw end_of_input_error();
-      if(*begin != u8':')
+      if(static_cast<char8_t>(*begin) != u8':')
         throw syntax_error("expected ':' token");
       ++begin;
 
@@ -555,7 +555,7 @@ namespace bencode {
           if(begin == end)
             throw end_of_input_error();
 
-          if(*begin == u8'e') {
+          if(static_cast<char8_t>(*begin) == u8'e') {
             if(!state.empty()) {
               ++begin;
               state.pop();
@@ -564,22 +564,22 @@ namespace bencode {
             }
           } else {
             if(!state.empty() && Traits::index(*state.top()) == 3 /* dict */) {
-              if(!std::isdigit(*begin))
+              if(!std::isdigit(static_cast<char>(*begin)))
                 throw syntax_error("expected string start token for dict key");
               dict_key = detail::decode_str<String>(begin, end);
               if(begin == end)
                 throw end_of_input_error();
             }
 
-            if(*begin == u8'i') {
+            if(static_cast<char8_t>(*begin) == u8'i') {
               store(detail::decode_int<Integer>(begin, end));
-            } else if(*begin == u8'l') {
+            } else if(static_cast<char8_t>(*begin) == u8'l') {
               ++begin;
               state.push(store( List{} ));
-            } else if(*begin == u8'd') {
+            } else if(static_cast<char8_t>(*begin) == u8'd') {
               ++begin;
               state.push(store( Dict{} ));
-            } else if(std::isdigit(*begin)) {
+            } else if(std::isdigit(static_cast<char>(*begin))) {
               store(detail::decode_str<String>(begin, end));
             } else {
               throw syntax_error("unexpected type token");