@ugo-studio/jspp 0.1.0

package/src/prelude/operators.hpp

@@ -0,0 +1,256 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include <cstdint> // For int32_t
+#include <cmath>   // For fmod, isnan, isinf, floor, abs, pow
+
+namespace jspp
+{
+    // Private namespace for helper functions that implement JS type conversions.
+    namespace Operators_Private
+    {
+        // Implements the ToNumber abstract operation from ECMA-262.
+        inline double ToNumber(const AnyValue &val)
+        {
+            if (val.is_number())
+                return val.as_double();
+            if (val.is_null())
+                return 0.0;
+            if (val.is_undefined() || val.is_uninitialized())
+                return std::numeric_limits<double>::quiet_NaN();
+            if (val.is_boolean())
+                return val.as_boolean() ? 1.0 : 0.0;
+            if (val.is_string())
+            {
+                const std::string &s = *val.as_string();
+                // JS considers empty or whitespace-only strings as 0.
+                if (s.empty() || std::all_of(s.begin(), s.end(), isspace))
+                    return 0.0;
+                try
+                {
+                    size_t pos;
+                    double num = std::stod(s, &pos);
+                    // Ensure the entire string was parsed, allowing for trailing whitespace.
+                    while (pos < s.length() && std::isspace(s[pos]))
+                        pos++;
+                    if (pos != s.length())
+                        return std::numeric_limits<double>::quiet_NaN();
+                    return num;
+                }
+                catch (...)
+                {
+                    return std::numeric_limits<double>::quiet_NaN();
+                }
+            }
+            // In a full engine, objects would be converted via valueOf/toString.
+            // Here we simplify and return NaN.
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+        // Implements the ToInt32 abstract operation from ECMA-262.
+        inline int32_t ToInt32(const AnyValue &val)
+        {
+            double num = ToNumber(val);
+
+            if (std::isnan(num) || std::isinf(num) || num == 0)
+                return 0;
+
+            double posInt = std::signbit(num) ? -std::floor(std::abs(num)) : std::floor(std::abs(num));
+            double int32bit = fmod(posInt, 4294967296.0); // 2^32
+
+            if (int32bit >= 2147483648.0) // 2^31
+                return static_cast<int32_t>(int32bit - 4294967296.0);
+            else
+                return static_cast<int32_t>(int32bit);
+        }
+    }
+
+    // --- BASIC ARITHEMETIC
+    inline AnyValue operator+(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        // Special case for addition: string concatenation has priority
+        if (lhs.is_string() || rhs.is_string())
+            return AnyValue::make_string(lhs.to_std_string() + rhs.to_std_string());
+        if (lhs.is_number() && rhs.is_number())
+            return AnyValue::make_number(lhs.as_double() + rhs.as_double());
+        // Fallback to numeric conversion
+        return AnyValue::make_number(Operators_Private::ToNumber(lhs) + Operators_Private::ToNumber(rhs));
+    }
+    inline AnyValue operator-(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_number(Operators_Private::ToNumber(lhs) - Operators_Private::ToNumber(rhs));
+    }
+    inline AnyValue operator*(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_number(Operators_Private::ToNumber(lhs) * Operators_Private::ToNumber(rhs));
+    }
+    inline AnyValue operator/(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_number(Operators_Private::ToNumber(lhs) / Operators_Private::ToNumber(rhs));
+    }
+    inline AnyValue operator%(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_number(std::fmod(Operators_Private::ToNumber(lhs), Operators_Private::ToNumber(rhs)));
+    }
+
+    // --- UNARY OPERATORS
+    inline AnyValue operator-(const AnyValue &val)
+    {
+        return AnyValue::make_number(-Operators_Private::ToNumber(val));
+    }
+    inline AnyValue operator~(const AnyValue &val)
+    {
+        return AnyValue::make_number(~Operators_Private::ToInt32(val));
+    }
+
+    // --- EXPONENTIATION
+    inline AnyValue pow(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        double base = Operators_Private::ToNumber(lhs);
+        double exp = Operators_Private::ToNumber(rhs);
+        return AnyValue::make_number(std::pow(base, exp));
+    }
+
+    // --- COMPARISON OPERATORS
+    inline AnyValue operator<(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        // Simplified Abstract Relational Comparison
+        if (lhs.is_string() && rhs.is_string())
+            return AnyValue::make_boolean(*lhs.as_string() < *rhs.as_string());
+
+        double l = Operators_Private::ToNumber(lhs);
+        double r = Operators_Private::ToNumber(rhs);
+
+        if (std::isnan(l) || std::isnan(r))
+            return AnyValue::make_boolean(false); // Comparison with NaN is false
+
+        return AnyValue::make_boolean(l < r);
+    }
+    inline AnyValue operator>(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return rhs < lhs;
+    }
+    inline AnyValue operator<=(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        // a <= b is equivalent to !(b < a)
+        AnyValue result = rhs < lhs;
+        return AnyValue::make_boolean(!result.as_boolean());
+    }
+    inline AnyValue operator>=(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        // a >= b is equivalent to !(a < b)
+        AnyValue result = lhs < rhs;
+        return AnyValue::make_boolean(!result.as_boolean());
+    }
+    inline AnyValue operator==(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_boolean(lhs.is_equal_to(rhs));
+    }
+    inline AnyValue operator!=(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_boolean(!lhs.is_equal_to(rhs));
+    }
+
+    // --- BITWISE OPERATORS
+    inline AnyValue operator^(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_number(Operators_Private::ToInt32(lhs) ^ Operators_Private::ToInt32(rhs));
+    }
+    inline AnyValue operator&(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_number(Operators_Private::ToInt32(lhs) & Operators_Private::ToInt32(rhs));
+    }
+    inline AnyValue operator|(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_number(Operators_Private::ToInt32(lhs) | Operators_Private::ToInt32(rhs));
+    }
+
+    // --- SHIFT OPERATORS
+    inline AnyValue operator<<(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        // The right operand is treated as an unsigned 32-bit integer, and only the lower 5 bits are used.
+        return AnyValue::make_number(Operators_Private::ToInt32(lhs) << (Operators_Private::ToInt32(rhs) & 0x1F));
+    }
+    inline AnyValue operator>>(const AnyValue &lhs, const AnyValue &rhs)
+    {
+        return AnyValue::make_number(Operators_Private::ToInt32(lhs) >> (Operators_Private::ToInt32(rhs) & 0x1F));
+    }
+
+    // --- INCREMENT / DECREMENT
+    inline AnyValue &operator++(AnyValue &val) // pre-increment
+    {
+        double num = Operators_Private::ToNumber(val);
+        val = AnyValue::make_number(num + 1.0);
+        return val;
+    }
+    inline AnyValue operator++(AnyValue &val, int) // post-increment
+    {
+        AnyValue old = AnyValue::make_number(Operators_Private::ToNumber(val));
+        ++val;
+        return old;
+    }
+    inline AnyValue &operator--(AnyValue &val) // pre-decrement
+    {
+        double num = Operators_Private::ToNumber(val);
+        val = AnyValue::make_number(num - 1.0);
+        return val;
+    }
+    inline AnyValue operator--(AnyValue &val, int) // post-decrement
+    {
+        AnyValue old = AnyValue::make_number(Operators_Private::ToNumber(val));
+        --val;
+        return old;
+    }
+
+    // --- COMPOUND ASSIGNMENT
+    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs + rhs;
+        return lhs;
+    }
+    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs - rhs;
+        return lhs;
+    }
+    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs * rhs;
+        return lhs;
+    }
+    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs / rhs;
+        return lhs;
+    }
+    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs % rhs;
+        return lhs;
+    }
+    inline AnyValue &operator^=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs ^ rhs;
+        return lhs;
+    }
+    inline AnyValue &operator&=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs & rhs;
+        return lhs;
+    }
+    inline AnyValue &operator|=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs | rhs;
+        return lhs;
+    }
+    inline AnyValue &operator<<=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs << rhs;
+        return lhs;
+    }
+    inline AnyValue &operator>>=(AnyValue &lhs, const AnyValue &rhs)
+    {
+        lhs = lhs >> rhs;
+        return lhs;
+    }
+}

package/src/prelude/types.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <variant>
+#include <functional>
+#include <memory>
+#include <unordered_map>
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+#include <set>
+#include <cmath>
+#include <optional>
+
+// JSPP standard library
+namespace jspp
+{
+    // Forward declarations
+    struct JsUndefined;     // cannot set property
+    struct JsNull;          // cannot set property
+    struct JsUninitialized; // cannot set property
+    struct JsObject;        // can set property
+    struct JsArray;         // can set property
+    struct JsFunction;      // can set property
+
+    // Object property configuration forward declarations
+    struct DataDescriptor;
+    struct AccessorDescriptor;
+
+    // Dynamic AnyValue
+    class AnyValue;
+
+    // Custom runtime exception
+    struct RuntimeError;
+
+    // Arithemetic operators
+    inline AnyValue pow(const AnyValue &lhs, const AnyValue &rhs);
+
+    // AnyValue prototypes
+    namespace StringPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, const std::unique_ptr<std::string> &self);
+    }
+    namespace ArrayPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsArray *self);
+    }
+}

package/src/prelude/values/array.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "types.hpp"
+#include <optional>
+
+namespace jspp
+{
+    class AnyValue;
+
+    struct JsArray
+    {
+        std::vector<std::optional<AnyValue>> dense;                   // dense storage for small/contiguous indices
+        std::unordered_map<uint32_t, std::optional<AnyValue>> sparse; // sparse indices (very large indices)
+        std::unordered_map<std::string, AnyValue> props;              // non-index string properties
+        uint64_t length = 0;
+
+        JsArray() = default;
+        explicit JsArray(const std::vector<std::optional<AnyValue>> &items) : dense(items), length(items.size()) {}
+
+        std::string to_std_string() const;
+
+        AnyValue get_property(const std::string &key);
+        AnyValue get_property(uint32_t idx);
+        AnyValue set_property(const std::string &key, const AnyValue &value);
+        AnyValue set_property(uint32_t idx, const AnyValue &value);
+
+        static bool is_array_index(const std::string &s)
+        {
+            if (s.empty())
+                return false;
+            // must be all digits
+            for (char c : s)
+                if (!std::isdigit(static_cast<unsigned char>(c)))
+                    return false;
+            // reject the special 2^32-1 string
+            if (s == "4294967295")
+                return false;
+            // parse without overflow up to 2^32-1
+            uint64_t v = 0;
+            for (char c : s)
+            {
+                v = v * 10 + (c - '0');
+                if (v >= (1ULL << 32))
+                    return false;
+            }
+            // ToString(ToUint32(v)) === s?
+            return std::to_string(static_cast<uint32_t>(v)) == s;
+        }
+    };
+}

package/src/prelude/values/function.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "types.hpp"
+
+namespace jspp
+{
+    class AnyValue;
+
+    struct JsFunction
+    {
+        std::function<AnyValue(const std::vector<AnyValue> &)> call;
+        std::string name;
+        std::unordered_map<std::string, AnyValue> props;
+
+        std::string to_std_string() const;
+        AnyValue get_property(const std::string &key);
+        AnyValue set_property(const std::string &key, const AnyValue &value);
+    };
+}

package/src/prelude/values/non_values.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "types.hpp"
+
+namespace jspp
+{
+
+    struct JsUndefined
+    {
+    };
+
+    struct JsNull
+    {
+    };
+
+    struct JsUninitialized
+    {
+    };
+
+}

package/src/prelude/values/object.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "types.hpp"
+
+namespace jspp
+{
+    class AnyValue;
+
+    struct JsObject
+    {
+        std::unordered_map<std::string, AnyValue> props;
+
+        std::string to_std_string() const;
+        AnyValue get_property(const std::string &key);
+        AnyValue set_property(const std::string &key, const AnyValue &value);
+    };
+}

package/src/prelude/values/operators/array.hpp

@@ -0,0 +1,165 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/array.hpp"
+#include "error.hpp"
+#include "any_value.hpp"
+#include "values/prototypes/array.hpp"
+
+std::string jspp::JsArray::to_std_string() const
+{
+    if (length == 0)
+    {
+        return "";
+    }
+
+    std::string result = "";
+    for (uint64_t i = 0; i < length; ++i)
+    {
+        std::optional<AnyValue> itemVal;
+        if (i < dense.size())
+        {
+            itemVal = dense[i];
+        }
+        else
+        {
+            auto it = sparse.find(static_cast<uint32_t>(i));
+            if (it != sparse.end())
+            {
+                itemVal = it->second;
+            }
+        }
+
+        if (itemVal.has_value())
+        {
+            const auto &item = itemVal.value();
+            if (!item.is_undefined() && !item.is_null())
+            {
+                result += item.to_std_string();
+            }
+        }
+
+        if (i < length - 1)
+        {
+            result += ",";
+        }
+    }
+    return result;
+}
+
+jspp::AnyValue jspp::JsArray::get_property(const std::string &key)
+{
+    if (
+        !key.empty() && std::isdigit(static_cast<unsigned char>(key[0])) // Quick check: if the first character is not a digit, it can't be a standard index.
+        && is_array_index(key))
+    {
+        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
+        return get_property(idx);
+    }
+    else
+    {
+        auto it = props.find(key);
+        if (it == props.end())
+        {
+            // check prototype
+            auto proto_it = ArrayPrototypes::get(key, this);
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value());
+            }
+            // not found
+            return AnyValue::make_undefined();
+        }
+        return AnyValue::resolve_property_for_read(it->second);
+    }
+}
+
+jspp::AnyValue jspp::JsArray::get_property(uint32_t idx)
+{
+    if (idx < dense.size())
+    {
+        return AnyValue::resolve_property_for_read(dense[idx].value_or(AnyValue::make_undefined()));
+    }
+    const auto &it = sparse.find(idx);
+    if (it != sparse.end())
+    {
+        return AnyValue::resolve_property_for_read(it->second.value_or(AnyValue::make_undefined()));
+    }
+    return AnyValue::make_undefined();
+}
+
+jspp::AnyValue jspp::JsArray::set_property(const std::string &key, const AnyValue &value)
+{
+    if (
+        !key.empty() && std::isdigit(static_cast<unsigned char>(key[0])) // Quick check: if the first character is not a digit, it can't be a standard index.
+        && is_array_index(key))
+    {
+        uint32_t idx = static_cast<uint32_t>(std::stoull(key));
+        return set_property(idx, value);
+    }
+    else
+    {
+        // set prototype property if accessor descriptor
+        auto proto_it = ArrayPrototypes::get(key, this);
+        if (proto_it.has_value())
+        {
+            auto proto_value = proto_it.value();
+            if (proto_value.is_accessor_descriptor())
+            {
+                return AnyValue::resolve_property_for_write(proto_it.value(), value);
+            }
+        }
+
+        // set own property
+        auto it = props.find(key);
+        if (it != props.end())
+        {
+            return AnyValue::resolve_property_for_write(it->second, value);
+        }
+        else
+        {
+            props[key] = value;
+            return value;
+        }
+    }
+}
+
+jspp::AnyValue jspp::JsArray::set_property(uint32_t idx, const AnyValue &value)
+{
+    uint64_t newLen = static_cast<uint64_t>(idx) + 1;
+    if (newLen > length)
+        length = newLen;
+
+    const uint32_t DENSE_GROW_THRESHOLD = 1024;
+    if (idx < dense.size())
+    {
+        if (!dense[idx].has_value())
+        {
+            dense[idx] = AnyValue::make_undefined();
+        }
+        return AnyValue::resolve_property_for_write(dense[idx].value(), value);
+    }
+    else if (idx <= dense.size() + DENSE_GROW_THRESHOLD)
+    {
+        dense.resize(idx + 1);
+        dense[idx] = value;
+        return value;
+    }
+    else
+    {
+        auto it = sparse.find(idx);
+        if (it != sparse.end())
+        {
+            if (!it->second.has_value())
+            {
+                it->second = AnyValue::make_undefined();
+            }
+            return AnyValue::resolve_property_for_write(it->second.value(), value);
+        }
+        else
+        {
+            sparse[idx] = value;
+            return value;
+        }
+    }
+}

package/src/prelude/values/operators/function.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/function.hpp"
+#include "any_value.hpp"
+
+std::string jspp::JsFunction::to_std_string() const
+{
+    return "function " + name + "() { [native code] }";
+}
+
+jspp::AnyValue jspp::JsFunction::get_property(const std::string &key)
+{
+    auto it = props.find(key);
+    if (it != props.end())
+    {
+        return jspp::AnyValue::resolve_property_for_read(it->second);
+    }
+    return jspp::AnyValue::make_undefined();
+}
+
+jspp::AnyValue jspp::JsFunction::set_property(const std::string &key, const AnyValue &value)
+{
+    auto it = props.find(key);
+    if (it != props.end())
+    {
+        return jspp::AnyValue::resolve_property_for_write(it->second, value);
+    }
+    else
+    {
+        props[key] = value;
+        return value;
+    }
+}

package/src/prelude/values/operators/object.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/object.hpp"
+#include "any_value.hpp"
+
+std::string jspp::JsObject::to_std_string() const
+{
+    return "[Object Object]";
+}
+
+jspp::AnyValue jspp::JsObject::get_property(const std::string &key)
+{
+    auto it = props.find(key);
+    if (it != props.end())
+    {
+        return jspp::AnyValue::resolve_property_for_read(it->second);
+    }
+    return jspp::AnyValue::make_undefined();
+}
+
+jspp::AnyValue jspp::JsObject::set_property(const std::string &key, const AnyValue &value)
+{
+    auto it = props.find(key);
+    if (it != props.end())
+    {
+        return jspp::AnyValue::resolve_property_for_write(it->second, value);
+    }
+    else
+    {
+        props[key] = value;
+        return value;
+    }
+}