php_v8_object.cc

/*
 * This file is part of the pinepain/php-v8 PHP extension.
 *
 * Copyright (c) 2015-2018 Bogdan Padalko <pinepain@gmail.com>
 *
 * Licensed under the MIT license: http://opensource.org/licenses/MIT
 *
 * For the full copyright and license information, please view the
 * LICENSE file that was distributed with this source or visit
 * http://opensource.org/licenses/MIT
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php_v8_object.h"
#include "php_v8_exceptions.h"
#include "php_v8_function_template.h"
#include "php_v8_function.h"
#include "php_v8_string.h"
#include "php_v8_uint32.h"
#include "php_v8_name.h"
#include "php_v8_value.h"
#include "php_v8_context.h"
#include "php_v8_ext_mem_interface.h"
#include "php_v8_enums.h"
#include "php_v8.h"


zend_class_entry *php_v8_object_class_entry;
#define this_ce php_v8_object_class_entry



bool php_v8_object_delete_self_ptr(php_v8_value_t *php_v8_value, v8::Local<v8::Object> local_object) {
    PHP_V8_ENTER_STORED_ISOLATE(php_v8_value);
    PHP_V8_CONTEXT_ENTER(local_object->CreationContext());

    v8::Local<v8::Private> key = php_v8_isolate_get_key_local(php_v8_value->php_v8_isolate);
    assert(!key.IsEmpty());

    v8::Maybe<bool> maybe_res = local_object->DeletePrivate(local_object->CreationContext(), key);

    // TODO: in obj free handle we may want not to throw any exceptions
    if (maybe_res.IsNothing()) {
        PHP_V8_THROW_EXCEPTION("Internal error: Failed to delete hidden persistent");
        return false;
    }

    assert(maybe_res.FromJust());
    return maybe_res.FromMaybe(false);
}

bool php_v8_object_store_self_ptr(php_v8_value_t *php_v8_value, v8::Local<v8::Object> local_object)
{
    assert(NULL != v8::Isolate::GetCurrent());
    assert(v8::Isolate::GetCurrent()->InContext());

    v8::Local<v8::Private> key = php_v8_isolate_get_key_local(php_v8_value->php_v8_isolate);
    assert(!key.IsEmpty());

    v8::Local<v8::External> this_embedded = v8::External::New(php_v8_value->php_v8_isolate->isolate, php_v8_value);

    v8::Maybe<bool> maybe_res = local_object->SetPrivate(local_object->CreationContext(), key, this_embedded);

    if (maybe_res.IsNothing()) {
        PHP_V8_THROW_EXCEPTION("Internal error: Failed to delete hidden persistent");
        return false;
    }

    assert(maybe_res.FromJust());

    return maybe_res.FromMaybe(false);
}

php_v8_value_t * php_v8_object_get_self_ptr(php_v8_isolate_t *php_v8_isolate, v8::Local<v8::Object> local_object)
{
    assert(NULL != v8::Isolate::GetCurrent());
    assert(v8::Isolate::GetCurrent()->InContext());

    v8::Local<v8::Private> key = php_v8_isolate_get_key_local(php_v8_isolate);
    assert(!key.IsEmpty());

    v8::MaybeLocal<v8::Value> maybe_local_value = local_object->GetPrivate(local_object->CreationContext(), key);

    if (maybe_local_value.IsEmpty()) {
        return NULL;
    }

    v8::Local<v8::Value> local_value = maybe_local_value.ToLocalChecked();

    // for some reason this check fails, but value IS external
    //assert(local_value->IsExternal());

    return static_cast<php_v8_value_t *>(local_value.As<v8::External>()->Value());
}


static PHP_METHOD(Object, __construct) {
    zval rv;
    zval *php_v8_context_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &php_v8_context_zv) == FAILURE) {
        return;
    }

    PHP_V8_OBJECT_CONSTRUCT(getThis(), php_v8_context_zv, php_v8_context, php_v8_value);

    v8::Local<v8::Object> local_object = v8::Object::New(isolate);

    PHP_V8_THROW_VALUE_EXCEPTION_WHEN_EMPTY(local_object, "Failed to create Object value");

    php_v8_object_store_self_ptr(php_v8_value, local_object);

    php_v8_value->persistent->Reset(isolate, local_object);
}

static PHP_METHOD(Object, getContext) {
    zval rv;

    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);

    RETURN_ZVAL(PHP_V8_OBJECT_READ_CONTEXT(getThis()), 1, 0);
}

static PHP_METHOD(Object, set) {
    zval *php_v8_context_zv;
    zval *php_v8_key_or_index_zv;
    zval *php_v8_value_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ooo", &php_v8_context_zv, &php_v8_key_or_index_zv, &php_v8_value_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_key_or_index_zv, php_v8_key_or_index);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_value_zv, php_v8_value_value_to_set);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_key_or_index);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_value_value_to_set);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Value> local_key_or_index = php_v8_value_get_local(php_v8_key_or_index);
    v8::Local<v8::Value> local_value_to_set = php_v8_value_get_local(php_v8_value_value_to_set);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_obj->Set(context, local_key_or_index, local_value_to_set);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to set");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, createDataProperty) {
    zval *php_v8_context_zv;
    zval *php_v8_key_or_index_zv;
    zval *php_v8_value_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ooo", &php_v8_context_zv, &php_v8_key_or_index_zv, &php_v8_value_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_key_or_index_zv, php_v8_key_or_index);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_value_zv, php_v8_value_value_to_set);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_key_or_index);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_value_value_to_set);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Name> local_key_or_index = php_v8_value_get_local_as<v8::Name>(php_v8_key_or_index);
    v8::Local<v8::Value> local_value_to_set = php_v8_value_get_local(php_v8_value_value_to_set);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_obj->CreateDataProperty(context, local_key_or_index, local_value_to_set);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to create data property");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, defineOwnProperty) {
    zval *php_v8_context_zv;
    zval *php_v8_value_zv;
    zval *php_v8_key_zv;

    zend_long attributes = 0;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ooo|l", &php_v8_context_zv, &php_v8_key_zv, &php_v8_value_zv, &attributes) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_key_zv, php_v8_key);

    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_value_zv, php_v8_value_value_to_set);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_key);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_value_value_to_set);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Value> local_value_to_set = php_v8_value_get_local(php_v8_value_value_to_set);
    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    v8::Local<v8::Name> local_name = php_v8_value_get_local_as<v8::Name>(php_v8_key);

    attributes = attributes ? attributes & PHP_V8_PROPERTY_ATTRIBUTE_FLAGS : attributes;

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe = local_obj->DefineOwnProperty(context,
                                                         local_name,
                                                         local_value_to_set,
                                                         static_cast<v8::PropertyAttribute>(attributes));

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe, "Failed to define own property");

    RETURN_BOOL(maybe.FromJust())
}

static PHP_METHOD(Object, get) {
    zval *php_v8_context_zv;
    zval *php_v8_key_or_index_zv;
    v8::MaybeLocal<v8::Value> maybe_local;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_key_or_index_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_key_or_index_zv, php_v8_key_or_index);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_key_or_index);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Value> local_key_or_index = php_v8_value_get_local(php_v8_key_or_index);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    maybe_local = local_obj->Get(context, local_key_or_index);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_EMPTY(maybe_local, "Failed to get");

    v8::Local<v8::Value> local_value =  maybe_local.ToLocalChecked();

    php_v8_get_or_create_value(return_value, local_value, php_v8_value->php_v8_isolate);
}

static PHP_METHOD(Object, getPropertyAttributes) {
    zval *php_v8_context_zv;
    zval *php_v8_string_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_string_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_string_zv, php_v8_string);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_string)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::String> local_string = php_v8_value_get_local_as<v8::String>(php_v8_string);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<v8::PropertyAttribute> maybe = local_obj->GetPropertyAttributes(context, local_string);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe, "Failed to get property attributes");

    RETURN_LONG(static_cast<zend_long>(maybe.FromJust()));
}

static PHP_METHOD(Object, getOwnPropertyDescriptor) {
    zval *php_v8_context_zv;
    zval *php_v8_string_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_string_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_string_zv, php_v8_string);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_string)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::String> local_string = php_v8_value_get_local_as<v8::String>(php_v8_string);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::MaybeLocal<v8::Value> maybe_local = local_obj->GetOwnPropertyDescriptor(context, local_string);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_EMPTY(maybe_local, "Failed to get property descriptor");

    v8::Local<v8::Value> local_value = maybe_local.ToLocalChecked();

    php_v8_get_or_create_value(return_value, local_value, php_v8_value->php_v8_isolate);
}

static PHP_METHOD(Object, has) {
    zval *php_v8_context_zv;
    zval *php_v8_key_or_index_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_key_or_index_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_key_or_index_zv, php_v8_key_or_index);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_key_or_index);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Value> local_key_or_index = php_v8_value_get_local(php_v8_key_or_index);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_obj->Has(context, local_key_or_index);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to check");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, delete) {
    zval *php_v8_context_zv;
    zval *php_v8_key_or_index_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_key_or_index_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_key_or_index_zv, php_v8_key_or_index);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_key_or_index);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Value> local_key_or_index = php_v8_value_get_local(php_v8_key_or_index);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_obj->Delete(context, local_key_or_index);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to delete");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, setAccessor) {
    zval *context_zv;
    zval *php_v8_name_zv;

    zend_long attributes = 0;
    zend_long settings = 0;

    zend_fcall_info getter_fci = empty_fcall_info;
    zend_fcall_info_cache getter_fci_cache = empty_fcall_info_cache;

    zend_fcall_info setter_fci = empty_fcall_info;
    zend_fcall_info_cache setter_fci_cache = empty_fcall_info_cache;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oof|f!ll",
                              &context_zv,
                              &php_v8_name_zv,
                              &getter_fci, &getter_fci_cache,
                              &setter_fci, &setter_fci_cache,
                              &settings,
                              &attributes
                             ) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_name_zv, php_v8_name);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_name)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Name> local_name = php_v8_value_get_local_as<v8::Name>(php_v8_name);

    PHP_V8_CONVERT_FROM_V8_STRING_TO_STRING(isolate, name, local_name);

    attributes = attributes ? attributes & PHP_V8_PROPERTY_ATTRIBUTE_FLAGS : attributes;
    settings = settings ? settings & PHP_V8_ACCESS_CONTROL_FLAGS : settings;


    v8::AccessorNameGetterCallback getter;
    v8::AccessorNameSetterCallback setter = 0;
    v8::Local<v8::External> data;


    phpv8::CallbacksBucket *bucket = php_v8_value->persistent_data->bucket("accessor_", local_name->IsSymbol(), name);
    data = v8::External::New(isolate, bucket);

    bucket->add(phpv8::CallbacksBucket::Index::Getter, getter_fci, getter_fci_cache);
    getter = php_v8_callback_accessor_name_getter;

    if (setter_fci.size) {
        bucket->add(phpv8::CallbacksBucket::Index::Setter, setter_fci, setter_fci_cache);
        setter = php_v8_callback_accessor_name_setter;
    }

    v8::Maybe<bool> maybe_res = local_object->SetAccessor(context,
                                                          local_name,
                                                          getter,
                                                          setter,
                                                          data,
                                                          static_cast<v8::AccessControl>(settings),
                                                          static_cast<v8::PropertyAttribute>(attributes)
    );

    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to set");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, setAccessorProperty) {
    zval *php_v8_name_zv;
    zval *getter_zv;
    zval *setter_zv;

    zend_long attributes = 0;
    zend_long settings = 0;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo|oll", &php_v8_name_zv, &getter_zv, &setter_zv, &attributes, &settings) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_name_zv, php_v8_name);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_name)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_value);
    PHP_V8_ENTER_STORED_CONTEXT(php_v8_value);

    v8::Local<v8::Name> local_name = php_v8_value_get_local_as<v8::Name>(php_v8_name);

    attributes = attributes ? attributes & PHP_V8_PROPERTY_ATTRIBUTE_FLAGS : attributes;
    settings = settings ? settings & PHP_V8_ACCESS_CONTROL_FLAGS : settings;

    v8::Local<v8::Function> getter;
    v8::Local<v8::Function> setter;

    PHP_V8_VALUE_FETCH_WITH_CHECK(getter_zv, php_v8_getter);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_getter, php_v8_value);

    getter = php_v8_value_get_local_as<v8::Function>(php_v8_getter);

    if (Z_TYPE_P(setter_zv) != IS_NULL) {
        PHP_V8_VALUE_FETCH_WITH_CHECK(setter_zv, php_v8_setter);
        PHP_V8_DATA_ISOLATES_CHECK(php_v8_setter, php_v8_value);

        setter = php_v8_value_get_local_as<v8::Function>(php_v8_setter);
    }

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    local_object->SetAccessorProperty(local_name, getter, setter, static_cast<v8::PropertyAttribute>(attributes), static_cast<v8::AccessControl>(settings));
}

static PHP_METHOD(Object, setNativeDataProperty) {
    zval *context_zv;
    zval *php_v8_name_zv;

    zend_long attributes = 0;

    zend_fcall_info getter_fci = empty_fcall_info;
    zend_fcall_info_cache getter_fci_cache = empty_fcall_info_cache;

    zend_fcall_info setter_fci = empty_fcall_info;
    zend_fcall_info_cache setter_fci_cache = empty_fcall_info_cache;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oof|f!l",
                              &context_zv,
                              &php_v8_name_zv,
                              &getter_fci, &getter_fci_cache,
                              &setter_fci, &setter_fci_cache,
                              &attributes
                             ) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_name_zv, php_v8_name);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_name)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Name> local_name = php_v8_value_get_local_as<v8::Name>(php_v8_name);

    PHP_V8_CONVERT_FROM_V8_STRING_TO_STRING(isolate, name, local_name);

    attributes = attributes ? attributes & PHP_V8_PROPERTY_ATTRIBUTE_FLAGS : attributes;

    v8::AccessorNameGetterCallback getter;
    v8::AccessorNameSetterCallback setter = 0;
    v8::Local<v8::External> data;

    phpv8::CallbacksBucket *bucket = php_v8_value->persistent_data->bucket("native_data_property_", local_name->IsSymbol(), name);
    data = v8::External::New(isolate, bucket);

    bucket->add(phpv8::CallbacksBucket::Index::Getter, getter_fci, getter_fci_cache);
    getter = php_v8_callback_accessor_name_getter;

    if (setter_fci.size) {
        bucket->add(phpv8::CallbacksBucket::Index::Setter, setter_fci, setter_fci_cache);
        setter = php_v8_callback_accessor_name_setter;
    }

    v8::Maybe<bool> maybe_res = local_object->SetNativeDataProperty(context,
                                                                    local_name,
                                                                    getter,
                                                                    setter,
                                                                    data,
                                                                    static_cast<v8::PropertyAttribute>(attributes)
                                                                   );

    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to set native data property");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, setLazyDataProperty) {
    zval *context_zv;
    zval *php_v8_name_zv;

    zend_long attributes = 0;

    zend_fcall_info getter_fci = empty_fcall_info;
    zend_fcall_info_cache getter_fci_cache = empty_fcall_info_cache;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oof|l",
                              &context_zv,
                              &php_v8_name_zv,
                              &getter_fci, &getter_fci_cache,
                              &attributes
    ) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_name_zv, php_v8_name);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_name)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Name> local_name = php_v8_value_get_local_as<v8::Name>(php_v8_name);

    PHP_V8_CONVERT_FROM_V8_STRING_TO_STRING(isolate, name, local_name);

    attributes = attributes ? attributes & PHP_V8_PROPERTY_ATTRIBUTE_FLAGS : attributes;

    v8::AccessorNameGetterCallback getter;
    v8::Local<v8::External> data;

    phpv8::CallbacksBucket *bucket = php_v8_value->persistent_data->bucket("lazy_data_property_", local_name->IsSymbol(), name);
    data = v8::External::New(isolate, bucket);

    bucket->add(phpv8::CallbacksBucket::Index::Getter, getter_fci, getter_fci_cache);
    getter = php_v8_callback_accessor_name_getter;

    v8::Maybe<bool> maybe_res = local_object->SetLazyDataProperty(context,
                                                                    local_name,
                                                                    getter,
                                                                    data,
                                                                    static_cast<v8::PropertyAttribute>(attributes)
    );

    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to set lazy data property");

    RETURN_BOOL(maybe_res.FromJust());
}

/* NOTE: we skip functionality for private properties for now */

static PHP_METHOD(Object, getPropertyNames) {
    zval *context_zv;
    zend_long mode            = static_cast<zend_long>(v8::KeyCollectionMode::kOwnOnly);
    zend_long property_filter = static_cast<zend_long>(v8::PropertyFilter::ALL_PROPERTIES);
    zend_long index_filter    = static_cast<zend_long>(v8::IndexFilter::kIncludeIndices);
    zend_bool convert_to_strings  = '\0';

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|lllb",
                              &context_zv, &mode, &property_filter, &index_filter, &convert_to_strings) == FAILURE) {
        return;
    }

    mode = mode ? mode & PHP_V8_KEY_COLLECTION_MODE_FLAGS : mode;
    property_filter = property_filter ? property_filter & PHP_V8_PROPERTY_FILTER_FLAGS : property_filter;
    index_filter = index_filter ? index_filter & PHP_V8_INDEX_FILTER_FLAGS : index_filter;
    v8::KeyConversionMode key_conversion = convert_to_strings ? v8::KeyConversionMode::kConvertToString : v8::KeyConversionMode::kKeepNumbers;

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::MaybeLocal<v8::Array> maybe_local_array = local_object->GetPropertyNames(context,
                                                                                 static_cast<v8::KeyCollectionMode>(mode),
                                                                                 static_cast<v8::PropertyFilter >(property_filter),
                                                                                 static_cast<v8::IndexFilter>(index_filter),
                                                                                 key_conversion);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_EMPTY(maybe_local_array, "Failed to get property names")

    v8::Local<v8::Array> local_array = maybe_local_array.ToLocalChecked();

    php_v8_get_or_create_value(return_value, local_array, php_v8_value->php_v8_isolate);
}

static PHP_METHOD(Object, getOwnPropertyNames) {
    zval *context_zv;
    zend_long filter = static_cast<zend_long>(v8::PropertyFilter::ALL_PROPERTIES);
    zend_bool convert_to_strings  = '\0';

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|lb", &context_zv, &filter, &convert_to_strings) == FAILURE) {
        return;
    }
    filter = filter ? filter & PHP_V8_PROPERTY_FILTER_FLAGS : filter;
    v8::KeyConversionMode key_conversion = convert_to_strings ? v8::KeyConversionMode::kConvertToString : v8::KeyConversionMode::kKeepNumbers;

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::MaybeLocal<v8::Array> maybe_local_array = local_object->GetOwnPropertyNames(context, static_cast<v8::PropertyFilter >(filter), key_conversion);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_EMPTY(maybe_local_array, "Failed to get own property names")

    v8::Local<v8::Array> local_array = maybe_local_array.ToLocalChecked();

    php_v8_get_or_create_value(return_value, local_array, php_v8_value->php_v8_isolate);
}

static PHP_METHOD(Object, getPrototype) {
    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_ENTER_STORED_ISOLATE(php_v8_value);
    PHP_V8_ENTER_STORED_CONTEXT(php_v8_value);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Local<v8::Value> local_prototype = local_object->GetPrototype();

    PHP_V8_MAYBE_CATCH(php_v8_value->php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_EMPTY(local_prototype, "Failed to get prototype");

    php_v8_get_or_create_value(return_value, local_prototype, php_v8_value->php_v8_isolate);
}

static PHP_METHOD(Object, setPrototype) {
    zval *context_zv;
    zval *value_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &context_zv, &value_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(context_zv, php_v8_context);
    PHP_V8_VALUE_FETCH_WITH_CHECK(value_zv, php_v8_prototype);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context);
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_prototype);

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Value> local_prototype = php_v8_value_get_local(php_v8_prototype);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_object->SetPrototype(context, local_prototype);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to set prototype")

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, findInstanceInPrototypeChain) {
    zval *function_template_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &function_template_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_FETCH_FUNCTION_TEMPLATE_WITH_CHECK(function_template_zv, php_v8_function_template);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_function_template)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_value);
    PHP_V8_ENTER_STORED_CONTEXT(php_v8_value);

    v8::Local<v8::FunctionTemplate> local_function_template = php_v8_function_template_get_local(php_v8_function_template);
    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Local<v8::Object> local_found = local_object->FindInstanceInPrototypeChain(local_function_template);

    PHP_V8_MAYBE_CATCH(php_v8_value->php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_EMPTY(local_found, "Failed to find prototype")

    php_v8_get_or_create_value(return_value, local_found, php_v8_value->php_v8_isolate);
}

static PHP_METHOD(Object, objectProtoToString) {
    zval *context_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &context_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::MaybeLocal<v8::String> maybe_local_string = local_object->ObjectProtoToString(context);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_EMPTY(maybe_local_string, "Failed to get")

    v8::Local<v8::String> local_string = maybe_local_string.ToLocalChecked();

    php_v8_get_or_create_value(return_value, local_string, php_v8_value->php_v8_isolate);
}

static PHP_METHOD(Object, getConstructorName) {

    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_ENTER_ISOLATE(php_v8_value->php_v8_isolate);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    php_v8_get_or_create_value(return_value, local_object->GetConstructorName(), php_v8_value->php_v8_isolate);
}

static PHP_METHOD(Object, setIntegrityLevel) {
    zval *php_v8_context_zv;
    zend_long level;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ol", &php_v8_context_zv, &level) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    level = level ? level & PHP_V8_INTEGRITY_LEVEL_FLAGS : level;

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_obj->SetIntegrityLevel(context, static_cast<v8::IntegrityLevel>(level));

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to set integrity level");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, hasOwnProperty) {
    zval *php_v8_context_zv;
    zval *php_v8_name_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_name_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_name_zv, php_v8_name);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_name)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Name> local_name = php_v8_value_get_local_as<v8::Name>(php_v8_name);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_object->HasOwnProperty(context, local_name);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to perform check");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, hasRealNamedProperty) {
    zval *php_v8_context_zv;
    zval *php_v8_name_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_name_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_name_zv, php_v8_name);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)
    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_name)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_object = php_v8_value_get_local_as<v8::Object>(php_v8_value);
    v8::Local<v8::Name> local_name = php_v8_value_get_local_as<v8::Name>(php_v8_name);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_object->HasRealNamedProperty(context, local_name);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to perform check");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, hasRealIndexedProperty) {
    zval *php_v8_context_zv;
    zend_long index;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ol", &php_v8_context_zv, &index) == FAILURE) {
        return;
    }

    PHP_V8_CHECK_UINT32_RANGE(index, "Index value to set is out of range, should be valid uint32_t");

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)

    PHP_V8_ENTER_STORED_ISOLATE(php_v8_context);
    PHP_V8_ENTER_CONTEXT(php_v8_context);

    v8::Local<v8::Object> local_obj = php_v8_value_get_local_as<v8::Object>(php_v8_value);

    PHP_V8_TRY_CATCH(isolate);
    PHP_V8_INIT_ISOLATE_LIMITS_ON_OBJECT_VALUE(php_v8_value);

    v8::Maybe<bool> maybe_res = local_obj->HasRealIndexedProperty(context, (uint32_t) index);

    PHP_V8_MAYBE_CATCH(php_v8_context, try_catch);
    PHP_V8_THROW_EXCEPTION_WHEN_NOTHING(maybe_res, "Failed to perform check");

    RETURN_BOOL(maybe_res.FromJust());
}

static PHP_METHOD(Object, hasRealNamedCallbackProperty) {
    zval *php_v8_context_zv;
    zval *php_v8_name_zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_context_zv, &php_v8_name_zv) == FAILURE) {
        return;
    }

    PHP_V8_VALUE_FETCH_WITH_CHECK(getThis(), php_v8_value);
    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_name_zv, php_v8_name);
    PHP_V8_CONTEXT_FETCH_WITH_CHECK(php_v8_context_zv, php_v8_context);

    PHP_V8_DATA_ISOLATES_CHECK(php_v8_value, php_v8_context)