Add more value casting functions

Author: adazem009

include/scratchcpp/value_functions.h

@@ -36,8 +36,14 @@ extern "C"
     LIBSCRATCHCPP_EXPORT double value_toDouble(const ValueData *v);
     LIBSCRATCHCPP_EXPORT bool value_toBool(const ValueData *v);
     LIBSCRATCHCPP_EXPORT void value_toString(const ValueData *v, std::string *dst);
+    LIBSCRATCHCPP_EXPORT char *value_toCString(const ValueData *v);
     LIBSCRATCHCPP_EXPORT void value_toUtf16(const ValueData *v, std::u16string *dst);
 
+    LIBSCRATCHCPP_EXPORT char *value_doubleToCString(double v);
+    LIBSCRATCHCPP_EXPORT const char *value_boolToCString(bool v);
+    LIBSCRATCHCPP_EXPORT double value_stringToDouble(const char *s);
+    LIBSCRATCHCPP_EXPORT bool value_stringToBool(const char *s);
+
     LIBSCRATCHCPP_EXPORT void value_add(const ValueData *v1, const ValueData *v2, ValueData *dst);
     LIBSCRATCHCPP_EXPORT void value_subtract(const ValueData *v1, const ValueData *v2, ValueData *dst);
     LIBSCRATCHCPP_EXPORT void value_multiply(const ValueData *v1, const ValueData *v2, ValueData *dst);

src/scratch/value_functions.cpp

@@ -330,7 +330,7 @@ extern "C"
         } else if (v->type == ValueType::Number) {
             return v->numberValue != 0;
         } else if (v->type == ValueType::String) {
-            return strlen(v->stringValue) != 0 && !value_stringsEqual(v->stringValue, "false") && strcmp(v->stringValue, "0") != 0;
+            return value_stringToBool(v->stringValue);
         } else if (v->type == ValueType::Infinity || v->type == ValueType::NegativeInfinity) {
             return true;
         } else if (v->type == ValueType::NaN) {
@@ -346,7 +346,7 @@ extern "C"
         if (v->type == ValueType::String)
             dst->assign(v->stringValue);
         else if (v->type == ValueType::Number)
-            dst->assign(value_doubleToString(v->numberValue));
+            value_doubleToString(v->numberValue, dst);
         else if (v->type == ValueType::Bool)
             dst->assign(v->boolValue ? "true" : "false");
         else if (v->type == ValueType::Infinity)
@@ -359,6 +359,19 @@ extern "C"
             dst->clear();
     }
 
+    /*!
+     * Returns the string representation of the given value.
+     * \note It is the caller's responsibility to free allocated memory.
+     */
+    char *value_toCString(const ValueData *v)
+    {
+        std::string out;
+        value_toString(v, &out);
+        char *ret = (char *)malloc((out.size() + 1) * sizeof(char));
+        strncpy(ret, out.c_str(), out.size() + 1);
+        return ret;
+    }
+
     /*! Writes the UTF-16 representation of the given value to dst. */
     void value_toUtf16(const libscratchcpp::ValueData *v, std::u16string *dst)
     {
@@ -367,6 +380,51 @@ extern "C"
         dst->assign(utf8::utf8to16(s));
     }
 
+    /*!
+     * Converts the given number to string.
+     * \note It is the caller's responsibility to free allocated memory.
+     */
+    char *value_doubleToCString(double v)
+    {
+        std::string out;
+        value_doubleToString(v, &out);
+        char *ret = (char *)malloc((out.size() + 1) * sizeof(char));
+        strncpy(ret, out.c_str(), out.size() + 1);
+        return ret;
+    }
+
+    /*!
+     * Converts the given boolean to string.
+     * \note Do not free allocated memory!
+     */
+    const char *value_boolToCString(bool v)
+    {
+        if (v) {
+            static const char *ret = "true";
+            return ret;
+        } else {
+            static const char *ret = "false";
+            return ret;
+        }
+    }
+
+    /*! Converts the given string to double. */
+    double value_stringToDouble(const char *s)
+    {
+        if (strcmp(s, "Infinity") == 0)
+            return std::numeric_limits<double>::infinity();
+        else if (strcmp(s, "-Infinity") == 0)
+            return -std::numeric_limits<double>::infinity();
+
+        return value_stringToDoubleImpl(s);
+    }
+
+    /*! Converts the given string to boolean. */
+    bool value_stringToBool(const char *s)
+    {
+        return strlen(s) != 0 && !value_stringsEqual(s, "false") && strcmp(s, "0") != 0;
+    }
+
     /* operations */
 
     /*! Adds the given values and writes the result to dst. */

src/scratch/value_functions_p.h

@@ -227,7 +227,7 @@ extern "C"
         }
     }
 
-    inline double value_stringToDouble(const char *s, bool *ok = nullptr)
+    inline double value_stringToDoubleImpl(const char *s, bool *ok = nullptr)
     {
         if (ok)
             *ok = false;
@@ -392,7 +392,7 @@ extern "C"
 
     inline long value_stringToLong(const char *s, bool *ok = nullptr)
     {
-        return value_stringToDouble(s, ok);
+        return value_stringToDoubleImpl(s, ok);
     }
 
     inline bool value_stringIsInt(const char *s, int n)
@@ -410,7 +410,7 @@ extern "C"
     }
 }
 
-inline std::string value_doubleToString(double v)
+inline void value_doubleToString(double v, std::string *dst)
 {
     std::stringstream stream;
 
@@ -424,22 +424,20 @@ inline std::string value_doubleToString(double v)
     } else
         stream << std::setprecision(std::max(16u, value_digitCount(v))) << v;
 
-    std::string s = stream.str();
+    dst->assign(stream.str());
     std::size_t index;
 
     for (int i = 0; i < 2; i++) {
         if (i == 0)
-            index = s.find("e+");
+            index = dst->find("e+");
         else
-            index = s.find("e-");
+            index = dst->find("e-");
 
         if (index != std::string::npos) {
-            while ((s.size() >= index + 3) && (s[index + 2] == '0'))
-                s.erase(index + 2, 1);
+            while ((dst->size() >= index + 3) && ((*dst)[index + 2] == '0'))
+                dst->erase(index + 2, 1);
         }
     }
-
-    return s;
 }
 
 extern "C"
@@ -459,7 +457,7 @@ extern "C"
             value_stringToLong(str, &ok);
             return ok ? 1 : 0;
         } else {
-            value_stringToDouble(str, &ok);
+            value_stringToDoubleImpl(str, &ok);
             return ok ? 2 : 0;
         }
     }
@@ -473,7 +471,7 @@ extern "C"
         // Since functions calling this already prioritize int, double and bool,
         // we can optimize by prioritizing the other types here.
         if (v->type == ValueType::String)
-            return value_stringToDouble(v->stringValue, ok);
+            return value_stringToDoubleImpl(v->stringValue, ok);
         else if (v->type == ValueType::Infinity)
             return std::numeric_limits<double>::infinity();
         else if (v->type == ValueType::NegativeInfinity)