Add base for supporting callbacks in node port. Refactor of many functionality from reflect function and signature in order to support it, this should not be done in this way, the correct way should be moving all ports to the loaders and merge both with the proper abstraction. Exposing metacall internals should not be the way to go. Meanwhile with this patch we can have callbacks temporally until we solve these design errors.

Author: viferga

source/loader/include/loader/loader.h

@@ -46,7 +46,7 @@ struct loader_type;
 
 /* -- Type Definitions -- */
 
-typedef value (*loader_register_invoke)(void * []);
+typedef value (*loader_register_invoke)(size_t, void * [], void *);
 
 typedef void * loader_data;
 

source/loader/source/loader.c

@@ -161,9 +161,13 @@ function_return loader_register_invoke_proxy(function func, function_impl func_i
 {
 	loader_host_invoke host_invoke = (loader_host_invoke)func_impl;
 
-	(void)func;
+	signature s = function_signature(func);
+
+	const size_t args_size = signature_count(s);
+
+	void * data = function_closure(func);
 
-	return host_invoke->invoke(args);
+	return host_invoke->invoke(args_size, args, data);
 }
 
 function_return loader_register_await_proxy(function func, function_impl impl, function_args args, function_resolve_callback resolve_callback, function_reject_callback reject_callback, void * context)

source/loaders/py_loader/source/py_loader_impl.c

@@ -791,7 +791,7 @@ static PyObject * py_loader_impl_function_type_invoke(PyObject * self, PyObject
 
 	if (args_size != (size_t)callee_args_size)
 	{
-		log_write("metacall", LOG_LEVEL_WARNING, "Callback being executed without different number of arguments %ul != %ul", args_size, callee_args_size);
+		log_write("metacall", LOG_LEVEL_WARNING, "Callback being executed without different number of arguments %u != %u", args_size, callee_args_size);
 	}
 
 	value_args = malloc(sizeof(void *) * min_args_size);

source/metacall/include/metacall/metacall.h

@@ -327,6 +327,21 @@ METACALL_API void * metacall_function(const char * name);
 */
 METACALL_API size_t metacall_function_size(void * func);
 
+/**
+*  @brief
+*    Resize the mumber of arguments accepted by function @func
+*
+*  @param[in] func
+*    Function reference
+*
+*  @param[in] count
+*    Number of arguments that the function will accept
+*
+*  @return
+*    Zero if function could be resized, different from zero otherwise
+*/
+METACALL_API int metacall_function_resize(void * func, size_t count);
+
 /**
 *  @brief
 *    Get the handle by @name
@@ -461,7 +476,7 @@ METACALL_API void * metacallfms(void * func, const char * buffer, size_t size, v
 *    Name of the function
 *
 *  @param[in] invoke
-*    Pointer to function invoke interface
+*    Pointer to function invoke interface (argc, argv, data)
 *
 *  @param[in] return_type
 *    Type of return value
@@ -475,7 +490,7 @@ METACALL_API void * metacallfms(void * func, const char * buffer, size_t size, v
 *  @return
 *    Pointer to value containing the result of the call
 */
-METACALL_API int metacall_register(const char * name, void * (*invoke)(void *[]), enum metacall_value_id return_type, size_t size, ...);
+METACALL_API int metacall_register(const char * name, void * (*invoke)(size_t, void * [], void *), enum metacall_value_id return_type, size_t size, ...);
 
 /**
 *  @brief

source/metacall/include/metacall/metacall_value.h

@@ -245,6 +245,21 @@ METACALL_API void * metacall_value_create_future(void * f);
 */
 METACALL_API void * metacall_value_create_function(void * f);
 
+/**
+*  @brief
+*    Create a value from function @f binding a closure @c to it
+*
+*  @param[in] f
+*    Pointer to constant data will be copied into value
+*
+*  @param[in] c
+*    Pointer to closure that will be binded into function @f
+*
+*  @return
+*    Pointer to value if success, null otherwhise
+*/
+METACALL_API void * metacall_value_create_function_closure(void * f, void * c);
+
 /**
 *  @brief
 *    Create a value of type null

source/metacall/source/metacall.c

@@ -475,6 +475,18 @@ size_t metacall_function_size(void * func)
 	return 0;
 }
 
+int metacall_function_resize(void * func, size_t count)
+{
+	function f = (function)func;
+
+	if (f == NULL)
+	{
+		return 1;
+	}
+
+	return function_resize(f, count);
+}
+
 void * metacall_handle(const char * tag, const char * name)
 {
 	return (void *)loader_get_handle(tag, name);
@@ -962,7 +974,7 @@ void * metacallfms(void * func, const char * buffer, size_t size, void * allocat
 	return NULL;
 }
 
-int metacall_register(const char * name, void * (*invoke)(void * []), enum metacall_value_id return_type, size_t size, ...)
+int metacall_register(const char * name, void * (*invoke)(size_t, void * [], void *), enum metacall_value_id return_type, size_t size, ...)
 {
 	type_id types[METACALL_ARGS_SIZE];
 

source/metacall/source/metacall_value.c

@@ -147,6 +147,11 @@ void * metacall_value_create_function(void * f)
 	return value_create_function(f);
 }
 
+void * metacall_value_create_function_closure(void * f, void * c)
+{
+	return value_create_function_closure(f, c);
+}
+
 void * metacall_value_create_null()
 {
 	return value_create_null();

source/ports/node_port/source/node_port.cpp

@@ -40,12 +40,69 @@
 
 static inline void metacall_node_exception(napi_env env, napi_status status);
 
-static void * metacall_node_napi_to_value(/* loader_impl_node node_impl,*/ napi_env env, napi_value v);
+static void * metacall_node_napi_to_value(/* loader_impl_node node_impl,*/ napi_env env, napi_value recv, napi_value v);
 
 static napi_value metacall_node_value_to_napi(/* loader_impl_node node_impl,*/ napi_env env, void * arg);
 
+static void * metacall_node_callback(size_t argc, void * args[], void * data);
+
+typedef struct metacall_node_callback_closure_type
+{
+	napi_env env;
+	napi_value callback;
+	napi_value recv;
+
+} * metacall_node_callback_closure;
+
 /* -- Methods -- */
 
+/* BEGIN-TODO: (Maybe) Implement this in the loader, then remove it from here */
+
+void * metacall_node_callback(size_t argc, void * args[], void * data)
+{
+	metacall_node_callback_closure closure = static_cast<metacall_node_callback_closure>(data);
+	napi_value ret;
+	napi_status status;
+	napi_value * argv = NULL;
+
+	if (closure == NULL)
+	{
+		return NULL;
+	}
+
+	if (argc > 0)
+	{
+		argv = static_cast<napi_value *>(malloc(sizeof(napi_value *) * argc));
+
+		if (argv == NULL)
+		{
+			free(closure);
+			return NULL;
+		}
+
+		for (uint32_t args_count = 0; args_count < argc; ++args_count)
+		{
+			argv[args_count] = metacall_node_value_to_napi(closure->env, args[args_count]);
+		}
+	}
+
+	status = napi_call_function(closure->env, closure->recv, closure->callback, argc, argv, &ret);
+
+	metacall_node_exception(closure->env, status);
+
+	free(closure);
+
+	if (argv != NULL)
+	{
+		free(argv);
+	}
+
+	/*return metacall_node_napi_to_value(closure->env, closure->recv, ret);*/
+	return NULL;
+}
+
+/* END-TODO */
+
 /* BEGIN-TODO: Remove this, it is duplicated code copied from node loader */
 
 inline void metacall_node_exception(napi_env env, napi_status status)
@@ -132,7 +189,7 @@ inline void metacall_node_exception(napi_env env, napi_status status)
 	}
 }
 
-void * metacall_node_napi_to_value(/*loader_impl_node node_impl,*/ napi_env env, napi_value v)
+void * metacall_node_napi_to_value(/*loader_impl_node node_impl,*/ napi_env env, napi_value recv, napi_value v)
 {
 	void * ret = NULL;
 
@@ -220,7 +277,7 @@ void * metacall_node_napi_to_value(/*loader_impl_node node_impl,*/ napi_env env,
 				metacall_node_exception(env, status);
 
 				/* TODO: Review recursion overflow */
-				array_value[iterator] = metacall_node_napi_to_value(/*node_impl,*/ env, element);
+				array_value[iterator] = metacall_node_napi_to_value(/*node_impl,*/ env, recv, element);
 			}
 		}
 		else if (napi_is_buffer(env, v, &result) == napi_ok && result == true)
@@ -340,15 +397,36 @@ void * metacall_node_napi_to_value(/*loader_impl_node node_impl,*/ napi_env env,
 					metacall_node_exception(env, status);
 
 					/* TODO: Review recursion overflow */
-					tupla[1] = metacall_node_napi_to_value(/* node_impl,*/ env, element);
+					tupla[1] = metacall_node_napi_to_value(/* node_impl,*/ env, recv, element);
 				}
 			}
 
 		}
 	}
 	else if (valuetype == napi_function)
 	{
-		/* TODO */
+		void * f = metacall_function("__metacall_node_callback__");
+		metacall_node_callback_closure closure = static_cast<metacall_node_callback_closure>(malloc(sizeof(struct metacall_node_callback_closure_type)));
+		napi_value length;
+		uint32_t argc;
+
+		closure->env = env;
+		closure->callback = v;
+		closure->recv = recv;
+
+		// Get number of arguments to the callback (this workaround should be reviewed)
+		status = napi_get_named_property(env, v, "length", &length);
+
+		metacall_node_exception(env, status);
+
+		status = napi_get_value_uint32(env, length, &argc);
+
+		metacall_node_exception(env, status);
+
+		// Workaround for accepting variable arguments
+		metacall_function_resize(f, (size_t)argc);
+
+		return metacall_value_create_function_closure(f, (void *)closure);
 	}
 	else if (valuetype == napi_external)
 	{
@@ -503,6 +581,18 @@ napi_value metacall_node_value_to_napi(/* loader_impl_node node_impl,*/ napi_env
 	{
 		/* TODO: Implement promise properly for await */
 	}
+	else if (id == METACALL_FUNCTION)
+	{
+		/* TODO: Implement function to pass callbacks through the callback again */
+		/*
+		void * f = metacall_value_to_function(arg_value);
+
+		// TODO:
+		status = napi_create_double(env, double_value, &v);
+
+		metacall_node_exception(env, status);
+		*/
+	}
 	else
 	{
 		status = napi_get_undefined(env, &v);
@@ -519,22 +609,37 @@ napi_value metacall_node_value_to_napi(/* loader_impl_node node_impl,*/ napi_env
 napi_value metacall_node_call(napi_env env, napi_callback_info info)
 {
 	size_t argc = 0;
+
 	napi_get_cb_info(env, info, &argc, NULL, NULL, NULL);
+
 	napi_value argv[argc];
-	void *metacallArgs[argc - 1];
-	napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
-	char functionName[FUNCTION_NAME_LENGTH];
-	size_t writeNumber;
-	napi_get_value_string_utf8(env, argv[0], functionName, FUNCTION_NAME_LENGTH, &writeNumber);
+	void * args[argc - 1];
+	napi_value recv;
+
+	napi_get_cb_info(env, info, &argc, argv, &recv, NULL);
+
+	char name[FUNCTION_NAME_LENGTH];
+	size_t name_length;
+
+	napi_get_value_string_utf8(env, argv[0], name, FUNCTION_NAME_LENGTH, &name_length);
+
 	for (size_t i = 1; i < argc; i++)
 	{
-		metacallArgs[i - 1] = metacall_node_napi_to_value(env, argv[i]);
+		args[i - 1] = metacall_node_napi_to_value(env, recv, argv[i]);
+	}
+
+	void * ret = metacallv(name, args);
+
+	for (size_t args_count = 0; args_count < argc - 1; ++args_count)
+	{
+		metacall_value_destroy(args[args_count]);
 	}
 
-	// Phew!!!.... after we are done converting JS types to Metacall Type into a single Array Above
-	void * ptr = metacallv(functionName, metacallArgs);
+	napi_value result = metacall_node_value_to_napi(env, ret);
 
-	return metacall_node_value_to_napi(env, ptr);
+	metacall_value_destroy(ret);
+
+	return result;
 }
 
 // this function is the handler of the "metacall_load_from_file"
@@ -732,6 +837,14 @@ napi_value metacall_node_initialize(napi_env env, napi_value exports)
 		return NULL;
 	}
 
+	if (metacall_register("__metacall_node_callback__", metacall_node_callback, METACALL_INVALID, 0) != 0)
+	{
+		/* TODO: Show error message (when error handling is properly implemented in the core lib) */
+		napi_throw_error(env, NULL, "MetaCall failed to initialize callback support");
+
+		return NULL;
+	}
+
 	metacall_node_exports(env, exports);
 
 	return exports;

source/ports/node_port/test/index.js

@@ -106,4 +106,17 @@ describe('metacall', () => {
 			assert.strictEqual(metacall('get_second', 5, 12), 12);
 		});
 	});
+
+	describe('callback', () => {
+		it('callback (py)', () => {
+			const f = require('function.py');
+			const c = 5;
+			assert.notStrictEqual(f, undefined);
+			assert.strictEqual(f.function_with_args((a, b) => {
+				const result = a + b + c;
+				console.log(`${a} + ${b} + ${c} = ${result}`);
+				return result;
+			}, 2, 3), 10);
+		});
+	});
 });

source/reflect/include/reflect/reflect_function.h

@@ -62,11 +62,17 @@ typedef struct function_interface_type
 typedef function_interface (*function_impl_interface_singleton)(void);
 
 REFLECT_API function function_create(const char * name, size_t args_count, function_impl impl, function_impl_interface_singleton singleton);
+
+REFLECT_API int function_resize(function func, size_t count);
 
 REFLECT_API int function_increment_reference(function func);
 
 REFLECT_API int function_decrement_reference(function func);
 
+REFLECT_API void function_bind(function func, void * data);
+
+REFLECT_API void * function_closure(function func);
+
 REFLECT_API const char * function_name(function func);
 
 REFLECT_API signature function_signature(function func);