Use comparison functions in value functions

Author: adazem009

src/scratch/value_functions.cpp

@@ -112,8 +112,7 @@ extern "C"
             case ValueType::Number:
                 return value_isInf(v->numberValue);
             case ValueType::String:
-                // TODO: Use a custom comparison function
-                return utf8::utf16to8(std::u16string(v->stringValue->data)) == "Infinity";
+                return string_compare_case_sensitive(v->stringValue, &INFINITY_STR) == 0;
             default:
                 return false;
         }
@@ -126,8 +125,7 @@ extern "C"
             case ValueType::Number:
                 return value_isNegativeInf(v->numberValue);
             case ValueType::String:
-                // TODO: Use a custom comparison function
-                return utf8::utf16to8(std::u16string(v->stringValue->data)) == "-Infinity";
+                return string_compare_case_sensitive(v->stringValue, &NEGATIVE_INFINITY_STR) == 0;
             default:
                 return false;
         }
@@ -140,8 +138,7 @@ extern "C"
             case ValueType::Number:
                 return std::isnan(v->numberValue);
             case ValueType::String:
-                // TODO: Use a custom comparison function
-                return utf8::utf16to8(std::u16string(v->stringValue->data)) == "NaN";
+                return string_compare_case_sensitive(v->stringValue, &NAN_STR) == 0;
             default:
                 return false;
         }
@@ -459,10 +456,9 @@ extern "C"
     /*! Converts the given string to double. */
     double value_stringToDouble(const StringPtr *s)
     {
-        // TODO: Use a custom comparison function
-        if (utf8::utf16to8(std::u16string(s->data)) == "Infinity")
+        if (string_compare_case_sensitive(s, &INFINITY_STR) == 0)
             return std::numeric_limits<double>::infinity();
-        else if (utf8::utf16to8(std::u16string(s->data)) == "-Infinity")
+        else if (string_compare_case_sensitive(s, &NEGATIVE_INFINITY_STR) == 0)
             return -std::numeric_limits<double>::infinity();
 
         return value_stringToDoubleImpl(s->data, s->size);
@@ -471,9 +467,7 @@ extern "C"
     /*! Converts the given string to boolean. */
     bool value_stringToBool(const StringPtr *s)
     {
-        // TODO: Use a custom comparison function
-        return s->size != 0 && !value_u16StringsEqual(std::u16string(s->data), utf8::utf8to16(std::string("false"))) &&
-               !value_u16StringsEqual(std::u16string(s->data), utf8::utf8to16(std::string("0")));
+        return s->size != 0 && string_compare_case_insensitive(s, &FALSE_STR) != 0 && string_compare_case_insensitive(s, &ZERO_STR) != 0;
     }
 
     /* operations */

src/scratch/value_functions_p.h

@@ -26,6 +26,7 @@ static const StringPtr FALSE_STR("false");
 static const StringPtr INFINITY_STR("Infinity");
 static const StringPtr NEGATIVE_INFINITY_STR("-Infinity");
 static const StringPtr NAN_STR("NaN");
+static const StringPtr ZERO_STR("0");
 
 template<typename T>
 inline unsigned int value_intDigitCount(T v)
@@ -107,24 +108,6 @@ extern "C"
             return ret;
     }
 
-    inline bool value_u16StringsEqual(std::u16string s1, std::u16string s2)
-    {
-        // TODO: Rewrite this
-        std::transform(s1.begin(), s1.end(), s1.begin(), ::tolower);
-        std::transform(s2.begin(), s2.end(), s2.begin(), ::tolower);
-        return (s1.compare(s2) == 0);
-    }
-
-    inline bool value_stringsEqual(const char *s1, const char *s2)
-    {
-        // TODO: Remove this?
-        std::string str1(s1);
-        std::string str2(s2);
-        std::transform(str1.begin(), str1.end(), str1.begin(), ::tolower);
-        std::transform(str2.begin(), str2.end(), str2.begin(), ::tolower);
-        return (str1.compare(str2) == 0);
-    }
-
     inline long value_hexToDec(const char16_t *s, int n, bool *ok)
     {
         if (ok)
@@ -349,12 +332,11 @@ extern "C"
         }
 
         // Special values
-        // TODO: Use a custom comparison function
-        if (value_u16StringsEqual(std::u16string(s), utf8::utf8to16(std::string("Infinity")))) {
+        if (string_compare_raw_case_sensitive(s, n, INFINITY_STR.data, INFINITY_STR.size) == 0) {
             if (ok)
                 *ok = true;
             return std::numeric_limits<double>::infinity();
-        } else if (value_u16StringsEqual(std::u16string(s), utf8::utf8to16(std::string("-Infinity")))) {
+        } else if (string_compare_raw_case_sensitive(s, n, NEGATIVE_INFINITY_STR.data, NEGATIVE_INFINITY_STR.size) == 0) {
             if (ok)
                 *ok = true;
             return -std::numeric_limits<double>::infinity();
@@ -500,12 +482,9 @@ extern "C"
         if (!ok) {
             // At least one argument can't be converted to a number
             // Scratch compares strings as case insensitive
-            // TODO: Use a custom comparison function
             StringPtr *s1 = value_toStringPtr(v1);
             StringPtr *s2 = value_toStringPtr(v2);
-            std::string str1 = utf8::utf16to8(std::u16string(s1->data));
-            std::string str2 = utf8::utf16to8(std::u16string(s2->data));
-            int ret = strcasecmp(str1.c_str(), str2.c_str());
+            int ret = string_compare_case_insensitive(s1, s2);
             string_pool_free(s1);
             string_pool_free(s2);
             return ret;