514 lines
16 KiB
C
514 lines
16 KiB
C
/**
|
|
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
* SPDX-License-Identifier: Apache-2.0.
|
|
*/
|
|
|
|
#include "class_binder.h"
|
|
|
|
#ifdef _MSC_VER
|
|
# pragma warning(disable : 4204)
|
|
#endif /* _MSC_VER */
|
|
|
|
struct aws_napi_class_info_impl {
|
|
const struct aws_napi_method_info *ctor_method;
|
|
|
|
napi_ref constructor;
|
|
|
|
struct {
|
|
void *instance;
|
|
napi_finalize finalizer;
|
|
bool is_wrapping;
|
|
} wrapping;
|
|
};
|
|
|
|
/* Make sure our static storage is big enough */
|
|
AWS_STATIC_ASSERT(sizeof(struct aws_napi_class_info) >= sizeof(struct aws_napi_class_info_impl));
|
|
|
|
/*
|
|
* Populates an aws_napi_argument object from a napi value.
|
|
*
|
|
* \param env The node environment.
|
|
* \param value The value to pull the value from.
|
|
* \param expected_type The type you expect the value to be. Pass napi_undefined to accept anything.
|
|
* \param accept_undefined Whether or not to accept expected_type OR undefined
|
|
* \param out_value The argument object to populate.
|
|
*/
|
|
static napi_status s_argument_parse(
|
|
napi_env env,
|
|
napi_value value,
|
|
napi_valuetype expected_type,
|
|
bool accept_undefined,
|
|
struct aws_napi_argument *out_value) {
|
|
|
|
out_value->node = value;
|
|
AWS_NAPI_CALL(env, napi_typeof(env, value, &out_value->type), { return status; });
|
|
|
|
if (expected_type != napi_undefined && out_value->type != expected_type &&
|
|
!(accept_undefined && out_value->type == napi_undefined)) {
|
|
switch (expected_type) {
|
|
case napi_string:
|
|
napi_throw_type_error(env, NULL, "Class binder argument expected a string");
|
|
return napi_string_expected;
|
|
|
|
case napi_number:
|
|
napi_throw_type_error(env, NULL, "Class binder argument expected a number");
|
|
return napi_number_expected;
|
|
|
|
default:
|
|
napi_throw_type_error(env, NULL, "Class binder argument wrong type");
|
|
return napi_generic_failure;
|
|
}
|
|
}
|
|
|
|
switch (out_value->type) {
|
|
case napi_boolean: {
|
|
AWS_NAPI_CALL(env, napi_get_value_bool(env, value, &out_value->native.boolean), { return status; });
|
|
|
|
break;
|
|
}
|
|
|
|
case napi_string: {
|
|
AWS_NAPI_CALL(env, aws_byte_buf_init_from_napi(&out_value->native.string, env, value), { return status; });
|
|
|
|
break;
|
|
}
|
|
|
|
case napi_number: {
|
|
AWS_NAPI_CALL(env, napi_get_value_int64(env, value, &out_value->native.number), {
|
|
napi_throw_type_error(env, NULL, "Class binder argument expected a number");
|
|
return status;
|
|
});
|
|
|
|
break;
|
|
}
|
|
|
|
case napi_external: {
|
|
AWS_NAPI_CALL(env, napi_get_value_external(env, value, &out_value->native.external), {
|
|
napi_throw_type_error(env, NULL, "Class binder argument expected an external");
|
|
return status;
|
|
});
|
|
|
|
break;
|
|
}
|
|
|
|
case napi_object: {
|
|
/* Attempt to unwrap the object, just in case */
|
|
napi_status result = napi_unwrap(env, value, &out_value->native.external);
|
|
if (result != napi_ok) {
|
|
out_value->native.external = NULL;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
/* Don't process, just leave as node value */
|
|
break;
|
|
}
|
|
|
|
return napi_ok;
|
|
}
|
|
|
|
/*
|
|
* Cleans up an aws_napi_argument object populated by s_argument_parse.
|
|
*
|
|
* \param env The node environment.
|
|
* \param value The value to clean up.
|
|
*/
|
|
static void s_argument_cleanup(napi_env env, struct aws_napi_argument *value) {
|
|
(void)env;
|
|
|
|
switch (value->type) {
|
|
case napi_string:
|
|
aws_byte_buf_clean_up(&value->native.string);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Used as the class's constructor
|
|
*/
|
|
static napi_value s_constructor(napi_env env, napi_callback_info info) {
|
|
|
|
napi_value node_args[AWS_NAPI_METHOD_MAX_ARGS];
|
|
napi_value node_this = NULL;
|
|
size_t num_args = AWS_ARRAY_SIZE(node_args);
|
|
struct aws_napi_class_info_impl *class_info = NULL;
|
|
AWS_NAPI_CALL(env, napi_get_cb_info(env, info, &num_args, node_args, &node_this, (void **)&class_info), {
|
|
napi_throw_error(env, NULL, "Failed to retreive callback information");
|
|
return NULL;
|
|
});
|
|
if (num_args > AWS_NAPI_METHOD_MAX_ARGS) {
|
|
num_args = AWS_NAPI_METHOD_MAX_ARGS;
|
|
}
|
|
|
|
napi_value result = NULL;
|
|
|
|
/* Check if we're wrapping an existing object or creating a new one */
|
|
if (class_info->wrapping.is_wrapping) {
|
|
AWS_FATAL_ASSERT(num_args == 0);
|
|
|
|
AWS_NAPI_CALL(
|
|
env,
|
|
napi_wrap(env, node_this, class_info->wrapping.instance, class_info->wrapping.finalizer, class_info, NULL),
|
|
{
|
|
napi_throw_error(env, NULL, "Failed to wrap http_request");
|
|
return NULL;
|
|
});
|
|
|
|
} else {
|
|
const struct aws_napi_method_info *method = class_info->ctor_method;
|
|
|
|
/* If there is no ctor method, don't both doing anything more, just return the empty object */
|
|
if (method->method) {
|
|
struct aws_napi_argument args[AWS_NAPI_METHOD_MAX_ARGS];
|
|
AWS_ZERO_ARRAY(args);
|
|
|
|
if (num_args < method->num_arguments) {
|
|
napi_throw_error(env, NULL, "Class binder constructor given incorrect number of arguments");
|
|
return NULL;
|
|
}
|
|
|
|
for (size_t i = 0; i < num_args; ++i) {
|
|
if (s_argument_parse(env, node_args[i], method->arg_types[i], i >= method->num_arguments, &args[i])) {
|
|
goto cleanup_arguments;
|
|
}
|
|
}
|
|
|
|
struct aws_napi_callback_info cb_info = {
|
|
.node_this = node_this,
|
|
.native_this = node_this,
|
|
.num_args = num_args,
|
|
};
|
|
cb_info.arguments = args;
|
|
|
|
method->method(env, &cb_info);
|
|
|
|
cleanup_arguments:
|
|
for (size_t i = 0; i < method->num_arguments; ++i) {
|
|
s_argument_cleanup(env, &args[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Callback used to return the value of a property. Expects 0 arguments.
|
|
*/
|
|
static napi_value s_property_getter(napi_env env, napi_callback_info info) {
|
|
|
|
void *native_this = NULL;
|
|
|
|
napi_value node_this = NULL;
|
|
size_t num_args = 0;
|
|
void *data = NULL;
|
|
AWS_NAPI_CALL(env, napi_get_cb_info(env, info, &num_args, NULL, &node_this, &data), {
|
|
napi_throw_error(env, NULL, "Failed to retreive callback information");
|
|
return NULL;
|
|
});
|
|
if (num_args != 0) {
|
|
napi_throw_error(env, NULL, "Class binder getter needs exactly 0 arguments");
|
|
return NULL;
|
|
}
|
|
|
|
AWS_NAPI_CALL(env, napi_unwrap(env, node_this, &native_this), {
|
|
napi_throw_error(env, NULL, "Class binder property getter must be called on a wrapped object");
|
|
return NULL;
|
|
});
|
|
|
|
const struct aws_napi_property_info *property = data;
|
|
|
|
if (!property->getter) {
|
|
napi_throw_error(env, NULL, "Property is not readable");
|
|
return NULL;
|
|
}
|
|
|
|
napi_value result = property->getter(env, native_this);
|
|
|
|
#if DEBUG_BUILD
|
|
/* In debug builds, validate that getters are returning the correct type */
|
|
napi_valuetype result_type = napi_undefined;
|
|
AWS_NAPI_CALL(env, napi_typeof(env, result, &result_type), { return NULL; });
|
|
AWS_FATAL_ASSERT(property->type == napi_undefined || property->type == result_type);
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Callback used to set the value of a property. Expects 1 argument.
|
|
*/
|
|
static napi_value s_property_setter(napi_env env, napi_callback_info info) {
|
|
|
|
void *native_this = NULL;
|
|
|
|
napi_value node_this = NULL;
|
|
napi_value node_value;
|
|
size_t num_args = 1;
|
|
void *data = NULL;
|
|
AWS_NAPI_CALL(env, napi_get_cb_info(env, info, &num_args, &node_value, &node_this, &data), {
|
|
napi_throw_error(env, NULL, "Failed to retreive callback information");
|
|
return NULL;
|
|
});
|
|
if (num_args != 1) {
|
|
napi_throw_error(env, NULL, "Class binder setter needs exactly 1 arguments");
|
|
return NULL;
|
|
}
|
|
|
|
AWS_NAPI_CALL(env, napi_unwrap(env, node_this, &native_this), {
|
|
napi_throw_error(env, NULL, "Class binder setter must be called on instance of a wrapped object");
|
|
return NULL;
|
|
});
|
|
|
|
const struct aws_napi_property_info *property = data;
|
|
|
|
if (!property->setter) {
|
|
napi_throw_error(env, NULL, "Property is not writable");
|
|
return NULL;
|
|
}
|
|
|
|
struct aws_napi_argument new_value;
|
|
if (s_argument_parse(env, node_value, property->type, false, &new_value)) {
|
|
return NULL;
|
|
}
|
|
|
|
property->setter(env, native_this, &new_value);
|
|
|
|
s_argument_cleanup(env, &new_value);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Callback used to call a method on a bound object.
|
|
*/
|
|
static napi_value s_method_call(napi_env env, napi_callback_info info) {
|
|
|
|
void *native_this = NULL;
|
|
struct aws_napi_argument args[AWS_NAPI_METHOD_MAX_ARGS];
|
|
AWS_ZERO_ARRAY(args);
|
|
|
|
napi_value node_this = NULL;
|
|
napi_value node_args[AWS_NAPI_METHOD_MAX_ARGS];
|
|
size_t num_args = AWS_ARRAY_SIZE(node_args);
|
|
void *data = NULL;
|
|
AWS_NAPI_CALL(env, napi_get_cb_info(env, info, &num_args, node_args, &node_this, &data), {
|
|
napi_throw_error(env, NULL, "Failed to retreive callback information");
|
|
return NULL;
|
|
});
|
|
if (num_args > AWS_NAPI_METHOD_MAX_ARGS) {
|
|
num_args = AWS_NAPI_METHOD_MAX_ARGS;
|
|
}
|
|
|
|
struct aws_napi_method_info *method = data;
|
|
if (num_args < method->num_arguments) {
|
|
napi_throw_error(env, NULL, "Bound class's method requires more arguments");
|
|
return NULL;
|
|
}
|
|
|
|
if ((method->attributes & napi_static) == 0) {
|
|
AWS_NAPI_CALL(env, napi_unwrap(env, node_this, &native_this), {
|
|
napi_throw_error(env, NULL, "Bound class's method must be called on instance of the class");
|
|
return NULL;
|
|
});
|
|
}
|
|
|
|
napi_value result = NULL;
|
|
|
|
for (size_t i = 0; i < num_args; ++i) {
|
|
if (s_argument_parse(env, node_args[i], method->arg_types[i], i >= method->num_arguments, &args[i])) {
|
|
goto cleanup_arguments;
|
|
}
|
|
}
|
|
|
|
struct aws_napi_callback_info cb_info = {
|
|
.node_this = node_this,
|
|
.native_this = native_this,
|
|
.num_args = num_args,
|
|
};
|
|
cb_info.arguments = args;
|
|
|
|
result = method->method(env, &cb_info);
|
|
|
|
cleanup_arguments:
|
|
for (size_t i = 0; i < num_args; ++i) {
|
|
s_argument_cleanup(env, &args[i]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool aws_napi_method_next_argument(
|
|
napi_valuetype expected_type,
|
|
const struct aws_napi_callback_info *cb_info,
|
|
const struct aws_napi_argument **next_arg) {
|
|
|
|
if (!*next_arg) {
|
|
*next_arg = cb_info->arguments;
|
|
} else {
|
|
(*next_arg)++;
|
|
}
|
|
|
|
const size_t current_index = (*next_arg) - cb_info->arguments;
|
|
return current_index <= cb_info->num_args &&
|
|
((expected_type == napi_undefined && (*next_arg)->type != napi_undefined) ||
|
|
(expected_type == (*next_arg)->type));
|
|
}
|
|
|
|
static napi_status s_get_symbol(napi_env env, const char *symbol_name, napi_value *result) {
|
|
napi_value global = NULL;
|
|
AWS_NAPI_CALL(env, napi_get_global(env, &global), { return status; });
|
|
|
|
napi_value symbol = NULL;
|
|
AWS_NAPI_CALL(env, napi_get_named_property(env, global, "Symbol", &symbol), { return status; });
|
|
AWS_NAPI_CALL(env, napi_get_named_property(env, symbol, symbol_name, result), { return status; });
|
|
|
|
return napi_ok;
|
|
}
|
|
|
|
napi_status aws_napi_define_class(
|
|
napi_env env,
|
|
napi_value exports,
|
|
const struct aws_napi_method_info *constructor,
|
|
const struct aws_napi_property_info *properties,
|
|
size_t num_properties,
|
|
const struct aws_napi_method_info *methods,
|
|
size_t num_methods,
|
|
struct aws_napi_class_info *class_info) {
|
|
|
|
AWS_FATAL_ASSERT(constructor->name);
|
|
AWS_FATAL_ASSERT(constructor->attributes == napi_default);
|
|
|
|
struct aws_napi_class_info_impl *impl = (struct aws_napi_class_info_impl *)class_info;
|
|
impl->ctor_method = constructor;
|
|
|
|
struct aws_allocator *allocator = aws_napi_get_allocator();
|
|
|
|
const size_t num_descriptors = num_properties + num_methods;
|
|
napi_property_descriptor *descriptors =
|
|
aws_mem_calloc(allocator, num_descriptors, sizeof(napi_property_descriptor));
|
|
|
|
size_t desc_i = 0;
|
|
|
|
for (size_t prop_i = 0; prop_i < num_properties; ++prop_i) {
|
|
napi_property_descriptor *desc = &descriptors[desc_i++];
|
|
const struct aws_napi_property_info *property = &properties[prop_i];
|
|
|
|
AWS_FATAL_ASSERT(property->name || property->symbol);
|
|
AWS_FATAL_ASSERT(property->getter || property->setter);
|
|
|
|
if (property->symbol) {
|
|
AWS_NAPI_CALL(env, s_get_symbol(env, property->symbol, &desc->name), { return status; });
|
|
} else {
|
|
desc->utf8name = property->name;
|
|
}
|
|
desc->data = (void *)property;
|
|
desc->getter = s_property_getter;
|
|
desc->setter = s_property_setter;
|
|
desc->attributes = property->attributes;
|
|
}
|
|
|
|
for (size_t method_i = 0; method_i < num_methods; ++method_i) {
|
|
napi_property_descriptor *desc = &descriptors[desc_i++];
|
|
const struct aws_napi_method_info *method = &methods[method_i];
|
|
|
|
AWS_FATAL_ASSERT(method->name || method->symbol);
|
|
AWS_FATAL_ASSERT(method->method);
|
|
|
|
if (method->symbol) {
|
|
AWS_NAPI_CALL(env, s_get_symbol(env, method->symbol, &desc->name), { return status; });
|
|
} else {
|
|
desc->utf8name = method->name;
|
|
}
|
|
desc->data = (void *)method;
|
|
desc->method = s_method_call;
|
|
desc->attributes = method->attributes;
|
|
}
|
|
|
|
napi_value node_constructor = NULL;
|
|
AWS_NAPI_CALL(
|
|
env,
|
|
napi_define_class(
|
|
env,
|
|
constructor->name,
|
|
NAPI_AUTO_LENGTH,
|
|
s_constructor,
|
|
class_info,
|
|
num_descriptors,
|
|
descriptors,
|
|
&node_constructor),
|
|
{ return status; });
|
|
|
|
/* Don't need descriptors anymore */
|
|
aws_mem_release(allocator, descriptors);
|
|
|
|
/* Reference the constructor for later user */
|
|
AWS_NAPI_CALL(env, napi_create_reference(env, node_constructor, 1, &impl->constructor), { return status; });
|
|
|
|
AWS_NAPI_CALL(env, napi_set_named_property(env, exports, constructor->name, node_constructor), { return status; });
|
|
|
|
return napi_ok;
|
|
}
|
|
|
|
napi_status aws_napi_wrap(
|
|
napi_env env,
|
|
struct aws_napi_class_info *class_info,
|
|
void *native,
|
|
napi_finalize finalizer,
|
|
napi_value *result) {
|
|
|
|
struct aws_napi_class_info_impl *impl = (struct aws_napi_class_info_impl *)class_info;
|
|
|
|
/* Retrieve the constructor */
|
|
napi_value constructor = NULL;
|
|
AWS_NAPI_CALL(env, napi_get_reference_value(env, impl->constructor, &constructor), {
|
|
napi_throw_error(env, NULL, "Failed to dereference constructor value");
|
|
return status;
|
|
});
|
|
|
|
/* Set our handy-dandy global state */
|
|
impl->wrapping.is_wrapping = true;
|
|
impl->wrapping.instance = native;
|
|
impl->wrapping.finalizer = finalizer;
|
|
AWS_NAPI_CALL(env, napi_new_instance(env, constructor, 0, NULL, result), {
|
|
napi_throw_error(env, NULL, "Failed to construct class-bound object");
|
|
return status;
|
|
});
|
|
AWS_ZERO_STRUCT(impl->wrapping);
|
|
|
|
/* The constructor function will have called napi_wrap onto result */
|
|
|
|
return napi_ok;
|
|
}
|
|
|
|
napi_status aws_napi_define_function(napi_env env, napi_value exports, struct aws_napi_method_info *method) {
|
|
|
|
/* Set static attribute so that s_method_call doesn't try to unwrap the this object */
|
|
method->attributes = napi_static;
|
|
|
|
/* Create the function object */
|
|
napi_value node_function = NULL;
|
|
AWS_NAPI_CALL(
|
|
env, napi_create_function(env, method->name, NAPI_AUTO_LENGTH, s_method_call, method, &node_function), {
|
|
return status;
|
|
});
|
|
|
|
/* Initialize the name from the symbol if necessary, otherwise use the utf8 name */
|
|
napi_value node_name = NULL;
|
|
if (method->symbol) {
|
|
AWS_NAPI_CALL(env, s_get_symbol(env, method->symbol, &node_name), { return status; });
|
|
} else {
|
|
AWS_NAPI_CALL(
|
|
env, napi_create_string_utf8(env, method->name, NAPI_AUTO_LENGTH, &node_name), { return status; });
|
|
}
|
|
|
|
/* Export the function */
|
|
AWS_NAPI_CALL(env, napi_set_property(env, exports, node_name, node_function), { return status; });
|
|
|
|
return napi_ok;
|
|
}
|