Add safe variants of std::isalpha and std::isdigit

These STL methods result in undefined behavior if the given value
cannot be represented by an unsigned char. Add methods to BasicString
that do not have this restriction.

Author: trflynn89

build/win/libfly/libfly.vcxproj

@@ -219,6 +219,7 @@
     <ClInclude Include="..\..\..\fly\types\numeric\detail\literal_parser.hpp" />
     <ClInclude Include="..\..\..\fly\types\numeric\endian.hpp" />
     <ClInclude Include="..\..\..\fly\types\numeric\literals.hpp" />
+    <ClInclude Include="..\..\..\fly\types\string\detail\string_classifier.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\string_converter.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\string_formatter.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\string_streamer.hpp" />

build/win/libfly/libfly.vcxproj.filters

@@ -268,6 +268,9 @@
     <ClInclude Include="..\..\..\fly\types\string\string_literal.hpp">
       <Filter>types\string</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\..\fly\types\string\detail\string_classifier.hpp">
+      <Filter>types\string\detail</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\..\fly\types\string\detail\string_converter.hpp">
       <Filter>types\string\detail</Filter>
     </ClInclude>

build/win/libfly_unit_tests/libfly_unit_tests.vcxproj

@@ -242,6 +242,7 @@
     <ClCompile Include="..\..\..\test\types\json_traits.cpp" />
     <ClCompile Include="..\..\..\test\types\literals.cpp" />
     <ClCompile Include="..\..\..\test\types\string.cpp" />
+    <ClCompile Include="..\..\..\test\types\string_classifier.cpp" />
     <ClCompile Include="..\..\..\test\types\string_converter.cpp" />
     <ClCompile Include="..\..\..\test\types\string_formatter.cpp" />
     <ClCompile Include="..\..\..\test\types\string_traits.cpp" />

build/win/libfly_unit_tests/libfly_unit_tests.vcxproj.filters

@@ -127,6 +127,9 @@
     <ClCompile Include="..\..\..\test\types\string.cpp">
       <Filter>types</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\..\test\types\string_classifier.cpp">
+      <Filter>types</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\..\test\types\string_converter.cpp">
       <Filter>types</Filter>
     </ClCompile>

fly/types/string/detail/string_classifier.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "fly/types/string/detail/string_traits.hpp"
+#include "fly/types/string/string_literal.hpp"
+
+namespace fly::detail {
+
+/**
+ * Helper class to provide safe alernatives to the STL's <cctype> methods.
+ *
+ * @author Timothy Flynn ([email protected])
+ * @version January 3, 2021
+ */
+template <typename StringType>
+class BasicStringClassifier
+{
+    using traits = detail::BasicStringTraits<StringType>;
+    using char_type = typename traits::char_type;
+    using int_type = typename traits::int_type;
+
+public:
+    /**
+     * Checks if the given character is an alphabetic character as classified by the default C
+     * locale.
+     *
+     * The STL's std::isalpha and std::iswalpha require that the provided character fits into an
+     * unsigned char and unsigned wchar_t, respectively. Other values result in undefined behavior.
+     * This method has no such restriction.
+     *
+     * @param ch The character to classify.
+     *
+     * @return True if the character is an alphabetic character.
+     */
+    static bool is_alpha(char_type ch);
+
+    /**
+     * Checks if the given character is a decimal digit character.
+     *
+     * The STL's std::isdigit and std::iswdigit require that the provided character fits into an
+     * unsigned char and unsigned wchar_t, respectively. Other values result in undefined behavior.
+     * This method has no such restriction.
+     *
+     * @param ch The character to classify.
+     *
+     * @return True if the character is a decimal digit character.
+     */
+    static bool is_digit(char_type ch);
+
+private:
+    static constexpr const char_type s_zero = FLY_CHR(char_type, '0');
+    static constexpr const char_type s_upper_a = FLY_CHR(char_type, 'A');
+    static constexpr const char_type s_upper_z = FLY_CHR(char_type, 'Z');
+
+    static constexpr const int_type s_case_mask = static_cast<int_type>(~0x20);
+};
+
+//==================================================================================================
+template <typename StringType>
+inline bool BasicStringClassifier<StringType>::is_alpha(char_type ch)
+{
+    // Remove the 0x20 bit, converting the a-z range of characters to the A-Z range.
+    ch &= s_case_mask;
+
+    return (ch >= s_upper_a) && (ch <= s_upper_z);
+}
+
+//==================================================================================================
+template <typename StringType>
+inline bool BasicStringClassifier<StringType>::is_digit(char_type ch)
+{
+    return (ch ^ s_zero) < 10;
+}
+
+} // namespace fly::detail

fly/types/string/detail/string_traits.hpp

@@ -101,6 +101,7 @@ struct BasicStringTraits
     using size_type = typename StringType::size_type;
     using char_type = typename StringType::value_type;
     using view_type = std::basic_string_view<char_type>;
+    using int_type = typename std::char_traits<char_type>::int_type;
 
     using codepoint_type = std::uint32_t;
 

fly/types/string/string.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "fly/traits/traits.hpp"
+#include "fly/types/string/detail/string_classifier.hpp"
 #include "fly/types/string/detail/string_converter.hpp"
 #include "fly/types/string/detail/string_formatter.hpp"
 #include "fly/types/string/detail/string_streamer.hpp"
@@ -51,6 +52,7 @@ using String32Traits = detail::BasicStringTraits<std::u32string>;
 template <typename StringType>
 class BasicString
 {
+    using classifier = detail::BasicStringClassifier<StringType>;
     using formatter = detail::BasicStringFormatter<StringType>;
     using streamer = detail::BasicStringStreamer<StringType>;
     using traits = detail::BasicStringTraits<StringType>;
@@ -61,6 +63,7 @@ class BasicString
     using size_type = typename traits::size_type;
     using char_type = typename traits::char_type;
     using view_type = typename traits::view_type;
+    using int_type = typename traits::int_type;
     using codepoint_type = typename traits::codepoint_type;
     using ostream_type = typename traits::ostream_type;
     using streamed_type = typename traits::streamed_type;
@@ -78,6 +81,33 @@ class BasicString
     template <typename T, enable_if<detail::is_like_supported_string<T>> = 0>
     static size_type size(const T &value);
 
+    /**
+     * Checks if the given character is an alphabetic character as classified by the default C
+     * locale.
+     *
+     * The STL's std::isalpha and std::iswalpha require that the provided character fits into an
+     * unsigned char and unsigned wchar_t, respectively. Other values result in undefined behavior.
+     * This method has no such restriction.
+     *
+     * @param ch The character to classify.
+     *
+     * @return True if the character is an alphabetic character.
+     */
+    static bool is_alpha(char_type ch);
+
+    /**
+     * Checks if the given character is a decimal digit character.
+     *
+     * The STL's std::isdigit and std::iswdigit require that the provided character fits into an
+     * unsigned char and unsigned wchar_t, respectively. Other values result in undefined behavior.
+     * This method has no such restriction.
+     *
+     * @param ch The character to classify.
+     *
+     * @return True if the character is a decimal digit character.
+     */
+    static bool is_digit(char_type ch);
+
     /**
      * Split a string into a vector of strings.
      *
@@ -421,6 +451,20 @@ auto BasicString<StringType>::size(const T &value) -> size_type
     }
 }
 
+//==================================================================================================
+template <typename StringType>
+inline bool BasicString<StringType>::is_alpha(char_type ch)
+{
+    return classifier::is_alpha(ch);
+}
+
+//==================================================================================================
+template <typename StringType>
+inline bool BasicString<StringType>::is_digit(char_type ch)
+{
+    return classifier::is_digit(ch);
+}
+
 //==================================================================================================
 template <typename StringType>
 std::vector<StringType> BasicString<StringType>::split(const StringType &input, char_type delimiter)

test/types/string_classifier.cpp

@@ -0,0 +1,66 @@
+#include "fly/types/string/string.hpp"
+
+#include "catch2/catch.hpp"
+
+#include <cctype>
+#include <string>
+
+CATCH_TEMPLATE_TEST_CASE(
+    "BasicStringClassifier",
+    "[string]",
+    std::string,
+    std::wstring,
+    std::u8string,
+    std::u16string,
+    std::u32string)
+{
+    using StringType = TestType;
+    using BasicString = fly::BasicString<StringType>;
+    using char_type = typename BasicString::char_type;
+
+    CATCH_SECTION("Check if a character is an alphabetic character")
+    {
+        for (int i = 0; i < 0x80; ++i)
+        {
+            const auto ch = static_cast<char_type>(i);
+            CATCH_CHECK(BasicString::is_alpha(ch) == static_cast<bool>(std::isalpha(i)));
+        }
+
+        if constexpr (sizeof(char_type) > 1)
+        {
+            // Spot check some values that incorrectly result in std::isalpha returning true when
+            // cast to unsigned char (which is how the spec suggests to avoid undefined behavior).
+            for (int i = 0xaa41; i <= 0xaa5a; ++i)
+            {
+                CATCH_CHECK(std::isalpha(static_cast<unsigned char>(i)));
+                CATCH_CHECK_FALSE(BasicString::is_alpha(static_cast<char_type>(i)));
+            }
+
+            for (int i = 0xaa61; i <= 0xaa7a; ++i)
+            {
+                CATCH_CHECK(std::isalpha(static_cast<unsigned char>(i)));
+                CATCH_CHECK_FALSE(BasicString::is_alpha(static_cast<char_type>(i)));
+            }
+        }
+    }
+
+    CATCH_SECTION("Check if a character is a decimal digit character")
+    {
+        for (int i = 0; i < 0x80; ++i)
+        {
+            const auto ch = static_cast<char_type>(i);
+            CATCH_CHECK(BasicString::is_digit(ch) == static_cast<bool>(std::isdigit(i)));
+        }
+
+        if constexpr (sizeof(char_type) > 1)
+        {
+            // Spot check some values that incorrectly result in std::isdigit returning true when
+            // cast to unsigned char (which is how the spec suggests to avoid undefined behavior).
+            for (int i = 0xaa30; i <= 0xaa39; ++i)
+            {
+                CATCH_CHECK(std::isdigit(static_cast<unsigned char>(i)));
+                CATCH_CHECK_FALSE(BasicString::is_digit(static_cast<char_type>(i)));
+            }
+        }
+    }
+}