/var/runtime/node_modules/@aws-sdk/node_modules/aws-crt/source
This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.
/** * 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;}