@ugo-studio/jspp 0.3.0 → 0.3.1

package/src/prelude/values/number.cpp

@@ -0,0 +1,176 @@
+#include "jspp.hpp"
+#include "values/prototypes/number.hpp"
+
+namespace jspp {
+
+namespace NumberPrototypes {
+
+std::string number_to_radix_string(double value, int radix)
+{
+    if (std::isnan(value))
+        return "NaN";
+    if (!std::isfinite(value))
+        return value > 0 ? "Infinity" : "-Infinity";
+
+    long long intPart = static_cast<long long>(value);
+
+    if (radix == 10)
+    {
+        return AnyValue::make_number(value).to_std_string();
+    }
+
+    bool negative = intPart < 0;
+    if (negative)
+        intPart = -intPart;
+
+    std::string chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+    std::string res = "";
+
+    if (intPart == 0)
+        res = "0";
+    else
+    {
+        while (intPart > 0)
+        {
+            res += chars[intPart % radix];
+            intPart /= radix;
+        }
+    }
+    if (negative)
+        res += "-";
+    std::reverse(res.begin(), res.end());
+    return res;
+}
+
+AnyValue &get_toExponential_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     double self = thisVal.as_double();
+                                                     int digits = -1;
+                                                     if (!args.empty() && !args[0].is_undefined())
+                                                     {
+                                                         digits = Operators_Private::ToInt32(args[0]);
+                                                         if (digits < 0 || digits > 100)
+                                                         {
+                                                             throw Exception::make_exception("toExponential() digits argument must be between 0 and 100", "RangeError");
+                                                         }
+                                                     }
+
+                                                     std::ostringstream ss;
+                                                     if (digits >= 0)
+                                                     {
+                                                         ss << std::scientific << std::setprecision(digits) << self;
+                                                     }
+                                                     else
+                                                     {
+                                                         ss << std::scientific << self;
+                                                     }
+
+                                                     std::string res = ss.str();
+                                                     return AnyValue::make_string(res); },
+                                                 "toExponential");
+    return fn;
+}
+
+AnyValue &get_toFixed_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     double self = thisVal.as_double();
+                                                     int digits = 0;
+                                                     if (!args.empty() && !args[0].is_undefined())
+                                                     {
+                                                         digits = Operators_Private::ToInt32(args[0]);
+                                                     }
+                                                     if (digits < 0 || digits > 100)
+                                                     {
+                                                         throw Exception::make_exception("toFixed() digits argument must be between 0 and 100", "RangeError");
+                                                     }
+
+                                                     std::ostringstream ss;
+                                                     ss << std::fixed << std::setprecision(digits) << self;
+                                                     return AnyValue::make_string(ss.str()); },
+                                                 "toFixed");
+    return fn;
+}
+
+AnyValue &get_toPrecision_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     double self = thisVal.as_double();
+                                                     if (args.empty() || args[0].is_undefined())
+                                                     {
+                                                         return AnyValue::make_number(self).get_own_property("toString").call(AnyValue::make_number(self), {}, "toString");
+                                                     }
+                                                     int precision = Operators_Private::ToInt32(args[0]);
+                                                     if (precision < 1 || precision > 100)
+                                                     {
+                                                         throw Exception::make_exception("toPrecision() precision argument must be between 1 and 100", "RangeError");
+                                                     }
+
+                                                     std::ostringstream ss;
+                                                     ss << std::setprecision(precision) << self;
+                                                     return AnyValue::make_string(ss.str()); },
+                                                 "toPrecision");
+    return fn;
+}
+
+AnyValue &get_toString_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                 {
+                                                     double self = thisVal.as_double();
+                                                     int radix = 10;
+                                                     if (!args.empty() && !args[0].is_undefined())
+                                                     {
+                                                         radix = Operators_Private::ToInt32(args[0]);
+                                                     }
+                                                     if (radix < 2 || radix > 36)
+                                                     {
+                                                         throw Exception::make_exception("toString() radix argument must be between 2 and 36", "RangeError");
+                                                     }
+
+                                                     return AnyValue::make_string(number_to_radix_string(self, radix)); },
+                                                 "toString");
+    return fn;
+}
+
+AnyValue &get_valueOf_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                 { return AnyValue::make_number(thisVal.as_double()); },
+                                                 "valueOf");
+    return fn;
+}
+
+AnyValue &get_toLocaleString_fn()
+{
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                 { return AnyValue::make_string(AnyValue::make_number(thisVal.as_double()).to_std_string()); },
+                                                 "toLocaleString");
+    return fn;
+}
+
+std::optional<AnyValue> get(const std::string &key)
+{
+    if (key == "toExponential") return get_toExponential_fn();
+    if (key == "toFixed") return get_toFixed_fn();
+    if (key == "toPrecision") return get_toPrecision_fn();
+    if (key == "toString") return get_toString_fn();
+    if (key == "valueOf") return get_valueOf_fn();
+    if (key == "toLocaleString") return get_toLocaleString_fn();
+    return std::nullopt;
+}
+
+std::optional<AnyValue> get(const AnyValue &key)
+{
+    if (key == "toString" || key == AnyValue::from_symbol(WellKnownSymbols::toStringTag)) return get_toString_fn();
+    if (key == "valueOf") return get_valueOf_fn();
+    return std::nullopt;
+}
+
+} // namespace NumberPrototypes
+
+} // namespace jspp

package/src/prelude/values/object.cpp

@@ -0,0 +1,159 @@
+#include "jspp.hpp"
+#include "values/object.hpp"
+#include "values/prototypes/object.hpp"
+
+namespace jspp {
+
+// --- JsObject Implementation ---
+
+JsObject::JsObject() : shape(Shape::empty_shape()), proto(Constants::Null) {}
+
+JsObject::JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, AnyValue pr) : proto(pr) {
+    shape = Shape::empty_shape();
+    storage.reserve(p.size());
+    for (const auto& pair : p) {
+        shape = shape->transition(pair.first);
+        storage.push_back(pair.second);
+    }
+}
+
+JsObject::JsObject(const std::map<std::string, AnyValue> &p, AnyValue pr) : proto(pr) {
+    shape = Shape::empty_shape();
+    storage.reserve(p.size());
+    for (const auto& pair : p) {
+        shape = shape->transition(pair.first);
+        storage.push_back(pair.second);
+    }
+}
+
+std::string JsObject::to_std_string() const {
+    return "[Object Object]";
+}
+
+bool JsObject::has_property(const std::string &key) const {
+    if (deleted_keys.count(key)) return false;
+
+    if (shape->get_offset(key).has_value())
+        return true;
+    if (!proto.is_null() && !proto.is_undefined()) {
+        if (proto.has_property(key))
+            return true;
+    }
+    if (ObjectPrototypes::get(key).has_value())
+        return true;
+    return false;
+}
+
+bool JsObject::has_symbol_property(const AnyValue &key) const {
+    if (symbol_props.count(key))
+        return true;
+    if (!proto.is_null() && !proto.is_undefined()) {
+        if (proto.has_property(key)) return true;
+    }
+    if (ObjectPrototypes::get(key).has_value())
+        return true;
+    return false;
+}
+
+AnyValue JsObject::get_property(const std::string &key, const AnyValue &thisVal) {
+    if (deleted_keys.count(key)) return Constants::UNDEFINED;
+
+    auto offset = shape->get_offset(key);
+    if (!offset.has_value()) {
+        if (!proto.is_null() && !proto.is_undefined()) {
+            if (proto.has_property(key)) {
+                return proto.get_property_with_receiver(key, thisVal);
+            }
+        }
+
+        auto proto_it = ObjectPrototypes::get(key);
+        if (proto_it.has_value()) {
+            return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+        }
+        return Constants::UNDEFINED;
+    }
+    return AnyValue::resolve_property_for_read(storage[offset.value()], thisVal, key);
+}
+
+AnyValue JsObject::get_symbol_property(const AnyValue &key, const AnyValue &thisVal) {
+    auto it = symbol_props.find(key);
+    if (it == symbol_props.end()) {
+        if (!proto.is_null() && !proto.is_undefined()) {
+            auto res = proto.get_symbol_property_with_receiver(key, thisVal);
+            if (!res.is_undefined()) return res;
+        }
+
+        auto proto_it = ObjectPrototypes::get(key);
+        if (proto_it.has_value()) {
+            return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key.to_std_string());
+        }
+        return Constants::UNDEFINED;
+    }
+    return AnyValue::resolve_property_for_read(it->second, thisVal, key.to_std_string());
+}
+
+AnyValue JsObject::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal) {
+    auto proto_it = ObjectPrototypes::get(key);
+    if (proto_it.has_value()) {
+        auto proto_value = proto_it.value();
+        if (proto_value.is_accessor_descriptor()) {
+            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+        }
+        if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable) {
+            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+        }
+    }
+
+    if (deleted_keys.count(key)) deleted_keys.erase(key);
+
+    auto offset = shape->get_offset(key);
+    if (offset.has_value()) {
+        return AnyValue::resolve_property_for_write(storage[offset.value()], thisVal, value, key);
+    } else {
+        shape = shape->transition(key);
+        storage.push_back(value);
+        return value;
+    }
+}
+
+AnyValue JsObject::set_symbol_property(const AnyValue &key, const AnyValue &value, const AnyValue &thisVal) {
+    auto it = symbol_props.find(key);
+    if (it != symbol_props.end()) {
+        return AnyValue::resolve_property_for_write(it->second, thisVal, value, key.to_std_string());
+    } else {
+        symbol_props[key] = value;
+        return value;
+    }
+}
+
+// --- ObjectPrototypes Implementation ---
+
+namespace ObjectPrototypes {
+
+AnyValue& get_toString_fn() {
+    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
+                                                 { return AnyValue::make_string(thisVal.to_std_string()); },
+                                                 "toString");
+    return fn;
+}
+
+std::optional<AnyValue> get(const std::string &key) {
+    if (key == "toString") {
+        return get_toString_fn();
+    }
+    return std::nullopt;
+}
+
+std::optional<AnyValue> get(const AnyValue &key) {
+    if (key.is_string())
+        return get(key.as_string()->value);
+
+    if (key == AnyValue::from_symbol(WellKnownSymbols::toStringTag)) {
+        return get_toString_fn();
+    }
+    return std::nullopt;
+}
+
+} // namespace ObjectPrototypes
+
+} // namespace jspp

package/src/prelude/values/object.hpp

@@ -16,6 +16,7 @@ namespace jspp
         std::vector<AnyValue> storage;
         AnyValue proto;
         std::unordered_set<std::string> deleted_keys;
+        std::map<AnyValue, AnyValue> symbol_props;
 
         JsObject();
         JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, AnyValue pr);
@@ -25,7 +26,10 @@ namespace jspp
 
         std::string to_std_string() const;
         bool has_property(const std::string &key) const;
+        bool has_symbol_property(const AnyValue &key) const;
         AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+        AnyValue get_symbol_property(const AnyValue &key, const AnyValue &thisVal);
         AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
+        AnyValue set_symbol_property(const AnyValue &key, const AnyValue &value, const AnyValue &thisVal);
     };
 }