Impleplement support in metacall_load_from_{file, memory, package}, for passing handle as in parameter, refactor extension interfaces in order to support handles and propagate symbols to existing handle being loaded by the extension.

Author: viferga

source/extensions/plugin_extension/include/plugin_extension/plugin_extension.h

@@ -29,7 +29,7 @@
 extern "C" {
 #endif
 
-PLUGIN_EXTENSION_API int plugin_extension(void *loader, void *context);
+PLUGIN_EXTENSION_API int plugin_extension(void *loader, void *handle, void *context);
 
 DYNLINK_SYMBOL_EXPORT(plugin_extension);
 

source/extensions/plugin_extension/source/plugin_extension.cpp

@@ -67,10 +67,13 @@ static int plugin_extension_get_path(std::string &ext_path)
 	return 0;
 }
 
-int plugin_extension(void *, void *)
+int plugin_extension(void *loader, void *handle, void *context)
 {
 	std::string ext_path;
 
+	(void)loader;
+	(void)context;
+
 	if (plugin_extension_get_path(ext_path) != 0)
 	{
 		log_write("metacall", LOG_LEVEL_ERROR, "Define the extension path with the environment variable " METACALL_PLUGIN_PATH);
@@ -102,7 +105,7 @@ int plugin_extension(void *, void *)
 			{
 				log_write("metacall", LOG_LEVEL_DEBUG, "Loading extension: %s", dir.path().filename().c_str());
 
-				if (metacall_load_from_configuration(dir.path().c_str(), NULL, config_allocator) != 0)
+				if (metacall_load_from_configuration(dir.path().c_str(), &handle, config_allocator) != 0)
 				{
 					log_write("metacall", LOG_LEVEL_ERROR, "Failed to load extension: %s", dir.path().c_str());
 					return 1;

source/loader/include/loader/loader_impl.h

@@ -75,6 +75,8 @@ LOADER_API value loader_impl_handle_export(void *handle);
 
 LOADER_API context loader_impl_handle_context(void *handle);
 
+LOADER_API void *loader_impl_handle_container_of(void *impl);
+
 LOADER_API int loader_impl_handle_validate(void *handle);
 
 LOADER_API value loader_impl_metadata(loader_impl impl);

source/loader/source/loader_impl.c

@@ -519,6 +519,7 @@ loader_handle_impl loader_impl_load_handle(loader_impl impl, loader_impl_interfa
 		{
 			handle_impl->magic = (uintptr_t)loader_handle_impl_magic_free;
 			free(handle_impl);
+			return NULL;
 		}
 
 		handle_impl->magic = (uintptr_t)loader_handle_impl_magic_alloc;
@@ -671,6 +672,7 @@ int loader_impl_handle_register_cb_iterate(plugin_manager manager, plugin p, voi
 
 int loader_impl_handle_register(plugin_manager manager, loader_impl impl, const char *path, loader_handle_impl handle_impl, void **handle_ptr)
 {
+	/* If there's no handle input/output pointer passed as input parameter, then propagate the handle symbols to the loader context */
 	if (handle_ptr == NULL)
 	{
 		/* This case handles the global scope (shared scope between all loaders, there is no out reference to a handle) */
@@ -694,7 +696,27 @@ int loader_impl_handle_register(plugin_manager manager, loader_impl impl, const
 	}
 	else
 	{
-		return loader_impl_handle_init(impl, path, handle_impl, handle_ptr, 1);
+		/* Otherwise, if there's a handle pointer and it is different from NULL, it means we are passing a handle as input parameter, so propagate symbols to this handle */
+		if (*handle_ptr != NULL)
+		{
+			loader_handle_impl target_handle = (loader_handle_impl)*handle_ptr;
+			char *duplicated_key;
+
+			if (context_contains(handle_impl->ctx, target_handle->ctx, &duplicated_key) == 0 && duplicated_key != NULL)
+			{
+				log_write("metacall", LOG_LEVEL_ERROR, "Duplicated symbol found named '%s' already defined in the handle scope by handle: %s", duplicated_key, path);
+				return 1;
+			}
+			else if (context_append(impl->ctx, handle_impl->ctx) == 0)
+			{
+				return loader_impl_handle_init(impl, path, handle_impl, NULL, 1);
+			}
+		}
+		else
+		{
+			/* Otherwise, initialize the handle and do not propagate the symbols, keep it private to the handle instance */
+			return loader_impl_handle_init(impl, path, handle_impl, handle_ptr, 1);
+		}
 	}
 
 	return 1;
@@ -997,6 +1019,16 @@ context loader_impl_handle_context(void *handle)
 	return handle_impl->ctx;
 }
 
+void *loader_impl_handle_container_of(void *impl)
+{
+	loader_handle handle = impl;
+
+#define container_of(ptr, type, member) \
+	(type *)((char *)(ptr) - (char *)&((type *)0)->member)
+
+	return container_of(handle, struct loader_handle_impl_type, module);
+}
+
 int loader_impl_handle_validate(void *handle)
 {
 	loader_handle_impl handle_impl = handle;

source/loaders/ext_loader/source/ext_loader_impl.cpp

@@ -62,7 +62,7 @@ typedef struct loader_impl_ext_handle_type
 union loader_impl_function_cast
 {
 	void *ptr;
-	int (*fn)(void *, void *);
+	int (*fn)(void *, void *, void *);
 };
 
 dynlink ext_loader_impl_load_from_file_dynlink(loader_impl_ext ext_impl, const loader_path path);
@@ -296,7 +296,7 @@ int ext_loader_impl_discover(loader_impl impl, loader_handle handle, context ctx
 
 		function_cast.ptr = static_cast<void *>(ext.addr);
 
-		if (function_cast.fn(impl, ctx) != 0)
+		if (function_cast.fn(impl, loader_impl_handle_container_of(handle), ctx) != 0)
 		{
 			return 1;
 		}

source/metacall/include/metacall/metacall.h

@@ -238,8 +238,14 @@ METACALL_API int metacall_execution_path_s(const char *tag, size_t tag_length, c
 *  @param[in] size
 *    Size of the array @paths
 *
-*  @param[out] handle
-*    Optional pointer to reference of loaded handle
+*  @param[inout] handle
+*    Optional pointer to reference of loaded handle. If the parameter is NULL, the symbols loaded are
+*    propagated to the loader scope (i.e they will share the scope between all previously loaded files and they can collide).
+*    Otherwise, if we pass a void* pointer set to NULL, it will behave as output parameter, obtaining the reference to the
+*    created handle, which can be later on used for calling to functions of that handle. The symbols will not be propagated
+*    to the loader scope and they will be private (this prevents collisions). The last case is if we pass an already allocated
+*    handle (i.e a void* pointer pointing to an previously loaded handle), then in this case, the symbols loaded will be propagated
+*    to the previously allocated handle, and it will behave as a in parameter.
 *
 *  @return
 *    Zero if success, different from zero otherwise
@@ -259,8 +265,14 @@ METACALL_API int metacall_load_from_file(const char *tag, const char *paths[], s
 *  @param[in] size
 *    Memory block representing the string of the script
 *
-*  @param[out] handle
-*    Optional pointer to reference of loaded handle
+*  @param[inout] handle
+*    Optional pointer to reference of loaded handle. If the parameter is NULL, the symbols loaded are
+*    propagated to the loader scope (i.e they will share the scope between all previously loaded files and they can collide).
+*    Otherwise, if we pass a void* pointer set to NULL, it will behave as output parameter, obtaining the reference to the
+*    created handle, which can be later on used for calling to functions of that handle. The symbols will not be propagated
+*    to the loader scope and they will be private (this prevents collisions). The last case is if we pass an already allocated
+*    handle (i.e a void* pointer pointing to an previously loaded handle), then in this case, the symbols loaded will be propagated
+*    to the previously allocated handle, and it will behave as a in parameter.
 *
 *  @return
 *    Zero if success, different from zero otherwise
@@ -277,8 +289,14 @@ METACALL_API int metacall_load_from_memory(const char *tag, const char *buffer,
 *  @param[in] path
 *    Path of the package
 *
-*  @param[out] handle
-*    Optional pointer to reference of loaded handle
+*  @param[inout] handle
+*    Optional pointer to reference of loaded handle. If the parameter is NULL, the symbols loaded are
+*    propagated to the loader scope (i.e they will share the scope between all previously loaded files and they can collide).
+*    Otherwise, if we pass a void* pointer set to NULL, it will behave as output parameter, obtaining the reference to the
+*    created handle, which can be later on used for calling to functions of that handle. The symbols will not be propagated
+*    to the loader scope and they will be private (this prevents collisions). The last case is if we pass an already allocated
+*    handle (i.e a void* pointer pointing to an previously loaded handle), then in this case, the symbols loaded will be propagated
+*    to the previously allocated handle, and it will behave as a in parameter.
 *
 *  @return
 *    Zero if success, different from zero otherwise
@@ -298,8 +316,14 @@ METACALL_API int metacall_load_from_package(const char *tag, const char *path, v
 *  @param[in] path
 *    Path of the configuration
 *
-*  @param[out] handle
-*    Optional pointer to reference of loaded handle
+*  @param[inout] handle
+*    Optional pointer to reference of loaded handle. If the parameter is NULL, the symbols loaded are
+*    propagated to the loader scope (i.e they will share the scope between all previously loaded files and they can collide).
+*    Otherwise, if we pass a void* pointer set to NULL, it will behave as output parameter, obtaining the reference to the
+*    created handle, which can be later on used for calling to functions of that handle. The symbols will not be propagated
+*    to the loader scope and they will be private (this prevents collisions). The last case is if we pass an already allocated
+*    handle (i.e a void* pointer pointing to an previously loaded handle), then in this case, the symbols loaded will be propagated
+*    to the previously allocated handle, and it will behave as a in parameter.
 *
 *  @param[in] allocator
 *    Pointer to allocator will allocate the configuration

source/scripts/extension/sum_extension/include/sum_extension/sum_extension.h

@@ -29,7 +29,7 @@
 extern "C" {
 #endif
 
-SUM_EXTENSION_API int sum_extension(void *loader, void *context);
+SUM_EXTENSION_API int sum_extension(void *loader, void *handle, void *context);
 
 DYNLINK_SYMBOL_EXPORT(sum_extension);
 

source/scripts/extension/sum_extension/source/sum_extension.cpp

@@ -34,8 +34,9 @@ void *sum(size_t argc, void *args[], void *data)
 	return metacall_value_create_long(result);
 }
 
-int sum_extension(void *loader, void *context)
+int sum_extension(void *loader, void *handle, void *context)
 {
 	enum metacall_value_id arg_types[] = { METACALL_LONG, METACALL_LONG };
+	(void)handle;
 	return metacall_register_loaderv(loader, context, "sum", sum, METACALL_LONG, sizeof(arg_types) / sizeof(arg_types[0]), arg_types);
 }

source/tests/metacall_ext_test/source/metacall_ext_test.cpp

@@ -35,10 +35,15 @@ TEST_F(metacall_ext_test, DefaultConstructor)
 	const char *ext_scripts[] = {
 		"sum_extension" /* The library extension (dll, so, dylib) is crossplatform so we should not add it here */
 	};
+
 	void *handle = NULL;
+
+	/* Test reload of the extension */
 	EXPECT_EQ((int)0, (int)metacall_load_from_file("ext", ext_scripts, sizeof(ext_scripts) / sizeof(ext_scripts[0]), &handle));
+
 	EXPECT_EQ((int)0, (int)metacall_clear(handle));
 
+	/* Test extension load and call */
 	EXPECT_EQ((int)0, (int)metacall_load_from_file("ext", ext_scripts, sizeof(ext_scripts) / sizeof(ext_scripts[0]), NULL));
 
 	void *ret = metacall("sum", 3, 4);

source/tests/metacall_handle_get_test/source/metacall_handle_get_test.cpp

@@ -99,17 +99,17 @@ TEST_F(metacall_handle_get_test, DefaultConstructor)
 			"s1.py"
 		};
 
-		void *handle = NULL;
+		void *handle1 = NULL;
 
-		EXPECT_EQ((int)0, (int)metacall_load_from_file("py", py_scripts_s1, sizeof(py_scripts_s1) / sizeof(py_scripts_s1[0]), &handle));
+		EXPECT_EQ((int)0, (int)metacall_load_from_file("py", py_scripts_s1, sizeof(py_scripts_s1) / sizeof(py_scripts_s1[0]), &handle1));
 
-		ASSERT_NE((void *)NULL, (void *)handle);
+		ASSERT_NE((void *)NULL, (void *)handle1);
 
-		void *func = metacall_handle_function(handle, "shared_in_s1_and_s2");
+		void *func = metacall_handle_function(handle1, "shared_in_s1_and_s2");
 
 		ASSERT_NE((void *)NULL, (void *)func);
 
-		void *ret = metacallhv_s(handle, "shared_in_s1_and_s2", metacall_null_args, 0);
+		void *ret = metacallhv_s(handle1, "shared_in_s1_and_s2", metacall_null_args, 0);
 
 		EXPECT_NE((void *)NULL, (void *)ret);
 
@@ -121,15 +121,17 @@ TEST_F(metacall_handle_get_test, DefaultConstructor)
 			"s2.py"
 		};
 
-		EXPECT_EQ((int)0, (int)metacall_load_from_file("py", py_scripts_s2, sizeof(py_scripts_s2) / sizeof(py_scripts_s2[0]), &handle));
+		void *handle2 = NULL;
 
-		ASSERT_NE((void *)NULL, (void *)handle);
+		EXPECT_EQ((int)0, (int)metacall_load_from_file("py", py_scripts_s2, sizeof(py_scripts_s2) / sizeof(py_scripts_s2[0]), &handle2));
+
+		ASSERT_NE((void *)NULL, (void *)handle2);
 
-		func = metacall_handle_function(handle, "shared_in_s1_and_s2");
+		func = metacall_handle_function(handle2, "shared_in_s1_and_s2");
 
 		ASSERT_NE((void *)NULL, (void *)func);
 
-		ret = metacallhv_s(handle, "shared_in_s1_and_s2", metacall_null_args, 0);
+		ret = metacallhv_s(handle2, "shared_in_s1_and_s2", metacall_null_args, 0);
 
 		EXPECT_NE((void *)NULL, (void *)ret);