#include "config.h"

#include "JSCValue.h"

#include "APICast.h"

#include "APIUtils.h"

#include "JSArrayBuffer.h"

#include "JSCCallbackFunction.h"

#include "JSCClassPrivate.h"

#include "JSCContextPrivate.h"

#include "JSCInlines.h"

#include "JSCValuePrivate.h"

#include "JSStringRef.h"

#include "JSTypedArray.h"

#include "LiteralParser.h"

#include "MarkedVector.h"

#include "OpaqueJSString.h"

#include "TypedArrayType.h"

#include <array>

#include <gobject/gvaluecollector.h>

#include <wtf/glib/GLibExtras.h>

#include <wtf/glib/GRefPtr.h>

#include <wtf/glib/GSpanExtras.h>

#include <wtf/glib/GUniquePtr.h>

#include <wtf/glib/WTFGType.h>

#include <wtf/text/MakeString.h>

enum {

PROP_0,

PROP_CONTEXT,

};

struct _JSCValuePrivate {

GRefPtr<JSCContext> context;

JSValueRef jsValue;

};

WEBKIT_DEFINE_FINAL_TYPE(JSCValue, jsc_value, G_TYPE_OBJECT, GObject)

static void jscValueGetProperty(GObject* object, guint propID, GValue* value, GParamSpec* paramSpec)

}

static void jscValueSetProperty(GObject* object, guint propID, const GValue* value, GParamSpec* paramSpec)

}

static void jscValueDispose(GObject* object)

}

static void jsc_value_class_init(JSCValueClass* klass)

}

JSValueRef jscValueGetJSValue(JSCValue* value)

{

return value->priv->jsValue;

}

JSCValue* jscValueCreate(JSCContext* context, JSValueRef jsValue)

{

auto* value = JSC_VALUE(g_object_new(JSC_TYPE_VALUE, "context", context, nullptr));

JSValueProtect(jscContextGetJSContext(context), jsValue);

value->priv->jsValue = jsValue;

return value;

}

JSCContext* jsc_value_get_context(JSCValue* value)

{

g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);

return value->priv->context.get();

}

JSCValue* jsc_value_new_undefined(JSCContext* context)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

return jscContextGetOrCreateValue(context, JSValueMakeUndefined(jscContextGetJSContext(context))).leakRef();

}

gboolean jsc_value_is_undefined(JSCValue* value)

}

JSCValue* jsc_value_new_null(JSCContext* context)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

return jscContextGetOrCreateValue(context, JSValueMakeNull(jscContextGetJSContext(context))).leakRef();

}

gboolean jsc_value_is_null(JSCValue* value)

}

JSCValue* jsc_value_new_number(JSCContext* context, double number)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

return jscContextGetOrCreateValue(context, JSValueMakeNumber(jscContextGetJSContext(context), number)).leakRef();

}

gboolean jsc_value_is_number(JSCValue* value)

}

double jsc_value_to_double(JSCValue* value)

}

gint32 jsc_value_to_int32(JSCValue* value)

{

return JSC::toInt32(jsc_value_to_double(value));

}

JSCValue* jsc_value_new_boolean(JSCContext* context, gboolean value)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

return jscContextGetOrCreateValue(context, JSValueMakeBoolean(jscContextGetJSContext(context), value)).leakRef();

}

gboolean jsc_value_is_boolean(JSCValue* value)

}

gboolean jsc_value_to_boolean(JSCValue* value)

}

JSCValue* jsc_value_new_string(JSCContext* context, const char* string)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

JSValueRef jsStringValue;

if (string) {

RefPtr jsString = adoptRef(JSStringCreateWithUTF8CString(string));

jsStringValue = JSValueMakeString(jscContextGetJSContext(context), jsString.get());

} else

jsStringValue = JSValueMakeString(jscContextGetJSContext(context), nullptr);

return jscContextGetOrCreateValue(context, jsStringValue).leakRef();

}

JSCValue* jsc_value_new_string_from_bytes(JSCContext* context, GBytes* bytes)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

if (!bytes)

return jsc_value_new_string(context, nullptr);

auto string = String::fromUTF8(span(bytes));

RefPtr jsString = OpaqueJSString::tryCreate(WTF::move(string));

return jscContextGetOrCreateValue(context, JSValueMakeString(jscContextGetJSContext(context), jsString.get())).leakRef();

}

gboolean jsc_value_is_string(JSCValue* value)

}

char* jsc_value_to_string(JSCValue* value)

{

g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);

JSCValuePrivate* priv = value->priv;

JSValueRef exception = nullptr;

RefPtr jsString = adoptRef(JSValueToStringCopy(jscContextGetJSContext(priv->context.get()), priv->jsValue, &exception));

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return nullptr;

if (!jsString)

return nullptr;

size_t maxSize = JSStringGetMaximumUTF8CStringSize(jsString.get());

auto* string = static_cast<char*>(g_malloc(maxSize));

if (!JSStringGetUTF8CString(jsString.get(), string, maxSize)) {

g_free(string);

return nullptr;

}

return string;

}

GBytes* jsc_value_to_string_as_bytes(JSCValue* value)

{

g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);

JSCValuePrivate* priv = value->priv;

JSValueRef exception = nullptr;

RefPtr jsString = adoptRef(JSValueToStringCopy(jscContextGetJSContext(priv->context.get()), priv->jsValue, &exception));

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return nullptr;

if (!jsString)

return nullptr;

size_t maxSize = JSStringGetMaximumUTF8CStringSize(jsString.get());

if (maxSize == 1)

return gBytesNewStatic(""_span).leakRef();

auto* string = static_cast<char*>(fastMalloc(maxSize));

auto stringSize = JSStringGetUTF8CString(jsString.get(), string, maxSize);

if (!stringSize) {

fastFree(string);

return nullptr;

}

// Ignore the null character added by JSStringGetUTF8CString.

return g_bytes_new_with_free_func(string, stringSize - 1, fastFreeCallback, string);

}

JSCValue* jsc_value_new_array(JSCContext* context, GType firstItemType, ...)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

auto* jsContext = jscContextGetJSContext(context);

JSC::JSGlobalObject* globalObject = toJS(jsContext);

JSC::JSLockHolder locker(globalObject);

JSValueRef exception = nullptr;

auto* jsArray = JSObjectMakeArray(jsContext, 0, nullptr, &exception);

if (jscContextHandleExceptionIfNeeded(context, exception))

return nullptr;

auto* jsArrayObject = JSValueToObject(jsContext, jsArray, &exception);

if (jscContextHandleExceptionIfNeeded(context, exception))

return nullptr;

unsigned index = 0;

va_list args;

va_start(args, firstItemType);

GType itemType = firstItemType;

while (itemType != G_TYPE_NONE) {

GValue item;

GUniqueOutPtr<char> error;

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN // GLib port

G_VALUE_COLLECT_INIT(&item, itemType, args, G_VALUE_NOCOPY_CONTENTS, &error.outPtr());

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END

if (error) {

}

auto* jsValue = jscContextGValueToJSValue(context, &item, &exception);

g_value_unset(&item);

if (jscContextHandleExceptionIfNeeded(context, exception)) {

jsArray = nullptr;

break;

}

JSObjectSetPropertyAtIndex(jsContext, jsArrayObject, index, jsValue, &exception);

if (jscContextHandleExceptionIfNeeded(context, exception)) {

jsArray = nullptr;

break;

}

itemType = va_arg(args, GType);

index++;

}

va_end(args);

return jsArray ? jscContextGetOrCreateValue(context, jsArray).leakRef() : nullptr;

}

JSCValue* jsc_value_new_array_from_garray(JSCContext* context, GPtrArray* gArray)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

if (!gArray || !gArray->len)

return jsc_value_new_array(context, G_TYPE_NONE);

JSValueRef exception = nullptr;

auto* jsArray = jscContextGArrayToJSArray(context, gArray, &exception);

if (jscContextHandleExceptionIfNeeded(context, exception))

return nullptr;

return jscContextGetOrCreateValue(context, jsArray).leakRef();

}

JSCValue* jsc_value_new_array_from_strv(JSCContext* context, const char* const* strv)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

auto elements = span(strv);

if (!elements.size())

return jsc_value_new_array(context, G_TYPE_NONE);

GRefPtr<GPtrArray> gArray = adoptGRef(g_ptr_array_new_full(elements.size(), g_object_unref));

for (auto* string : elements)

g_ptr_array_add(gArray.get(), jsc_value_new_string(context, string));

return jsc_value_new_array_from_garray(context, gArray.get());

}

gboolean jsc_value_is_array(JSCValue* value)

}

JSCValue* jsc_value_new_object(JSCContext* context, gpointer instance, JSCClass* jscClass)

{

g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);

g_return_val_if_fail(!instance || JSC_IS_CLASS(jscClass), nullptr);

return jscContextGetOrCreateValue(context, instance ? toRef(jscClassGetOrCreateJSWrapper(jscClass, context, instance)) : JSObjectMake(jscContextGetJSContext(context), nullptr, nullptr)).leakRef();

}

gboolean jsc_value_is_object(JSCValue* value)

}

gboolean jsc_value_object_is_instance_of(JSCValue* value, const char* name)

}

void jsc_value_object_set_property(JSCValue* value, const char* name, JSCValue* property)

}

JSCValue* jsc_value_object_get_property(JSCValue* value, const char* name)

{

g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);

g_return_val_if_fail(name, nullptr);

JSCValuePrivate* priv = value->priv;

auto* jsContext = jscContextGetJSContext(priv->context.get());

JSValueRef exception = nullptr;

JSObjectRef object = JSValueToObject(jsContext, priv->jsValue, &exception);

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return jsc_value_new_undefined(priv->context.get());

RefPtr propertyName = adoptRef(JSStringCreateWithUTF8CString(name));

JSValueRef result = JSObjectGetProperty(jsContext, object, propertyName.get(), &exception);

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return jsc_value_new_undefined(priv->context.get());

return jscContextGetOrCreateValue(priv->context.get(), result).leakRef();

}

void jsc_value_object_set_property_at_index(JSCValue* value, unsigned index, JSCValue* property)

}

JSCValue* jsc_value_object_get_property_at_index(JSCValue* value, unsigned index)

{

g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);

JSCValuePrivate* priv = value->priv;

auto* jsContext = jscContextGetJSContext(priv->context.get());

JSValueRef exception = nullptr;

JSObjectRef object = JSValueToObject(jsContext, priv->jsValue, &exception);

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return jsc_value_new_undefined(priv->context.get());

JSValueRef result = JSObjectGetPropertyAtIndex(jsContext, object, index, &exception);

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return jsc_value_new_undefined(priv->context.get());

return jscContextGetOrCreateValue(priv->context.get(), result).leakRef();

}

gboolean jsc_value_object_has_property(JSCValue* value, const char* name)

}

gboolean jsc_value_object_delete_property(JSCValue* value, const char* name)

}

char** jsc_value_object_enumerate_properties(JSCValue* value)

{

g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);

JSCValuePrivate* priv = value->priv;

auto* jsContext = jscContextGetJSContext(priv->context.get());

JSValueRef exception = nullptr;

JSObjectRef object = JSValueToObject(jsContext, priv->jsValue, &exception);

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return nullptr;

auto* propertiesArray = JSObjectCopyPropertyNames(jsContext, object);

if (!propertiesArray)

return nullptr;

auto propertiesArraySize = JSPropertyNameArrayGetCount(propertiesArray);

if (!propertiesArraySize) {

JSPropertyNameArrayRelease(propertiesArray);

return nullptr;

}

auto resultSizeInBytes = checkedSum<size_t>(propertiesArraySize, 1);

resultSizeInBytes *= sizeof(char*);

if (resultSizeInBytes.hasOverflowed())

return nullptr;

auto result = GMallocSpan<char*>::malloc(resultSizeInBytes);

for (unsigned i = 0; i < propertiesArraySize; ++i) {

RefPtr jsString = JSPropertyNameArrayGetNameAtIndex(propertiesArray, i);

size_t maxSize = JSStringGetMaximumUTF8CStringSize(jsString.get());

auto string = GMallocSpan<char>::malloc(maxSize);

JSStringGetUTF8CString(jsString.get(), string.mutableSpan().data(), string.mutableSpan().size());

result[i] = string.leakSpan().data();

}

result.mutableSpan().back() = nullptr;

JSPropertyNameArrayRelease(propertiesArray);

return result.leakSpan().data();

}

static JSValueRef jsObjectCall(JSGlobalContextRef jsContext, JSObjectRef function, JSC::JSCCallbackFunction::Type functionType, JSObjectRef thisObject, std::span<const JSValueRef> arguments, JSValueRef* exception)

}

static GRefPtr<JSCValue> jscValueCallFunction(JSCValue* value, JSObjectRef function, JSC::JSCCallbackFunction::Type functionType, JSObjectRef thisObject, GType firstParameterType, va_list args)

}

JSCValue* jsc_value_object_invoke_method(JSCValue* value, const char* name, GType firstParameterType, ...)

{

g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);

g_return_val_if_fail(name, nullptr);

JSCValuePrivate* priv = value->priv;

auto* jsContext = jscContextGetJSContext(priv->context.get());

JSValueRef exception = nullptr;

JSObjectRef object = JSValueToObject(jsContext, priv->jsValue, &exception);

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return jsc_value_new_undefined(priv->context.get());

RefPtr methodName = adoptRef(JSStringCreateWithUTF8CString(name));

JSValueRef functionValue = JSObjectGetProperty(jsContext, object, methodName.get(), &exception);

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return jsc_value_new_undefined(priv->context.get());

JSObjectRef function = JSValueToObject(jsContext, functionValue, &exception);

if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))

return jsc_value_new_undefined(priv->context.get());

va_list args;

va_start(args, firstParameterType);

auto result = jscValueCallFunction(value, function, JSC::JSCCallbackFunction::Type::Method, object, firstParameterType, args);

va_end(args);

return result.leakRef();

}

JSCValue* jsc_value_object_invoke_methodv(JSCValue* value, const char* name, unsigned parametersCount, JSCValue** parameters)

{

g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);

g_return_val_if_fail(name, nullptr);

g_return_val_if_fail(!parametersCount || parameters, nullptr);