Add test for reconstructing out parameters on arguments of functions in c loader.

Author: viferga

source/loaders/c_loader/source/c_loader_impl.cpp

@@ -516,6 +516,19 @@ class c_loader_closure_value
 	}
 };
 
+class c_loader_pointer_type : public c_loader_type_impl
+{
+protected:
+	loader_impl impl;
+	CXType cx_type;
+
+public:
+	c_loader_pointer_type(loader_impl impl, CXType cx_type) :
+		impl(impl), cx_type(cx_type) {}
+
+	~c_loader_pointer_type() {}
+};
+
 std::string c_loader_impl_cxstring_to_str(const CXString &s)
 {
 	std::string result = clang_getCString(s);
@@ -662,6 +675,7 @@ function_return function_c_interface_invoke(function func, function_impl impl, f
 	for (size_t args_count = 0; args_count < args_size; ++args_count)
 	{
 		type t = signature_get_type(s, args_count);
+		type_impl impl_type = type_derived(t);
 		type_id id = type_index(t);
 		type_id value_id = value_type_id((value)args[args_count]);
 
@@ -687,13 +701,22 @@ function_return function_c_interface_invoke(function func, function_impl impl, f
 
 			closures.push_back(closure);
 		}
-		else if (id == TYPE_STRING)
+		else if (id == TYPE_STRING || (id == TYPE_PTR && impl_type != nullptr))
 		{
-			/* String requires to be pointer to a string */
+			/* String requires to be pointer to a string and
+			Pointer requires to be pointer to pointer */
 			c_function->values[args_count] = value_create_ptr((value)args[args_count]);
 		}
 		else
 		{
+			/* In case of (id == TYPE_PTR && impl_type == nullptr it means that
+			the parameter is normally int*, long*, etc... we just let the pointer
+			be passed as it is because it cannot output a pointer, only modify the contents
+			*/
+
+			/* TODO: Check if types are not equal and do a casting?
+			Note: It will involve destroying the new casted values */
+
 			c_function->values[args_count] = value_data((value)args[args_count]);
 		}
 	}
@@ -741,9 +764,27 @@ function_return function_c_interface_invoke(function func, function_impl impl, f
 	for (size_t args_count = 0; args_count < args_size; ++args_count)
 	{
 		type t = signature_get_type(s, args_count);
+		type_impl impl_type = type_derived(t);
 		type_id id = type_index(t);
 
-		if (id == TYPE_STRING)
+		/* This is very tricky, if the type was a pointer to pointer, if it
+		replaced the target pointer we have to update it in the MetaCall value,
+		for example:
+			void f(char **str_ptr)
+			{
+				*str_ptr = "aaa";
+			}
+		In order to make it work we have to recreate the metacall value, this is
+		highly unsafe if we mix types because we will use the type info of the
+		underlaying type in order to recreate it, in this example, a string
+		*/
+		if (id == TYPE_PTR && impl_type != nullptr)
+		{
+			// TODO: Reconstruct the pointer value from the type info
+
+			value_type_destroy(c_function->values[args_count]);
+		}
+		else if (id == TYPE_STRING)
 		{
 			/* Clear the pointer to string allocated before */
 			value_type_destroy(c_function->values[args_count]);
@@ -978,6 +1019,13 @@ static type_id c_loader_impl_clang_type(loader_impl impl, CXCursor cursor, CXTyp
 			{
 				return c_loader_impl_clang_type(impl, cursor, pointee_type, impl_type);
 			}
+			/* Check for pointers to pointers, in this case we need the type info for reconstructing the data */
+			else if (pointee_type.kind == CXType_Pointer)
+			{
+				c_loader_pointer_type *pointer_type = new c_loader_pointer_type(impl, cx_type);
+
+				*impl_type = static_cast<c_loader_pointer_type *>(pointer_type);
+			}
 
 			return TYPE_PTR;
 		}

source/tests/metacall_node_port_c_test/source/metacall_node_port_c_test.cpp

@@ -38,7 +38,7 @@ TEST_F(metacall_node_port_c_test, DefaultConstructor)
 	static const char buffer[] =
 		"const assert = require('assert');\n"
 		"const { metacall_load_from_file_export, metacall_value_create_ptr, metacall_value_reference, metacall_value_dereference } = require('" METACALL_NODE_PORT_PATH "');\n"
-		"const { return_text, process_text, modify_int_ptr, compare_data_value, alloc_data, alloc_data_args, set_data_value, get_data_value, free_data } = metacall_load_from_file_export('c', ['compiled.c']);\n"
+		"const { return_text, process_text, modify_double_ptr, modify_str_ptr, compare_data_value, alloc_data, alloc_data_args, set_data_value, get_data_value, free_data } = metacall_load_from_file_export('c', ['compiled.c']);\n"
 		// Test strings
 		"const result = return_text();\n"
 		"console.log(`'${result}'`);\n"
@@ -52,11 +52,19 @@ TEST_F(metacall_node_port_c_test, DefaultConstructor)
 		"assert(get_data_value(data_ptr) == 12);\n"
 		"free_data(data_ptr);\n"
 		// Test passing reference by arguments
-		"int_val = 324444;\n"
-		"int_val_ref = metacall_value_reference(int_val);\n"
-		"modify_int_ptr(int_val_ref);\n"
-		"int_val_deref = metacall_value_dereference(int_val_ref);\n"
-		"assert(int_val_deref == 111);\n"
+		"double_val = 324444.0;\n"
+		"double_val_ref = metacall_value_reference(double_val);\n"
+		"modify_double_ptr(double_val_ref);\n"
+		"double_val_deref = metacall_value_dereference(double_val_ref);\n"
+		"assert(double_val_deref == 111.0);\n"
+		// Test passing reference by arguments string
+		"str_val = 'asd';\n"
+		"str_val_ref = metacall_value_reference(str_val);\n"
+		"console.log(str_val);\n"
+		"console.log(str_val_ref);\n"
+		"modify_str_ptr(str_val_ref);\n"
+		"str_val_deref = metacall_value_dereference(str_val_ref);\n"
+		"assert(str_val_deref == 'yeet');\n"
 		// Test passing reference of structs by arguments (with no args on create ptr)
 		"data_ptr = metacall_value_create_ptr();\n"
 		"data_ptr_ref = metacall_value_reference(data_ptr);\n"

source/tests/metacall_python_port_pointer_test/source/metacall_python_port_pointer_test.cpp

@@ -60,8 +60,9 @@ TEST_F(metacall_python_port_pointer_test, DefaultConstructor)
 	static const char buffer[] =
 		"import sys\n"
 		"sys.path.insert(0, '" METACALL_PYTHON_PORT_PATH "')\n"
-		"from metacall import metacall_load_from_package, metacall, metacall_value_create_ptr, metacall_value_reference, metacall_value_dereference\n"
+		"from metacall import metacall_load_from_package, metacall_load_from_file, metacall, metacall_value_create_ptr, metacall_value_reference, metacall_value_dereference\n"
 		"metacall_load_from_package('c', 'loadtest')\n"
+		"metacall_load_from_file('c', ['compiled.c'])\n"
 
 		"def test_int_ptr() -> int:\n"
 		"	print('Test start')\n"
@@ -81,6 +82,24 @@ TEST_F(metacall_python_port_pointer_test, DefaultConstructor)
 
 		"	return int_val_deref\n"
 
+		"def test_str_ptr() -> str:\n"
+		"	print('Test start')\n"
+		"	sys.stdout.flush()\n"
+
+		"	str_val = 'asd'\n"
+		"	str_val_ref = metacall_value_reference(str_val)\n"
+
+		"	print(str_val_ref)\n"
+		"	sys.stdout.flush()\n"
+
+		"	metacall('modify_str_ptr', str_val_ref)\n"
+		"	str_val_deref = metacall_value_dereference(str_val_ref)\n"
+
+		"	print(str_val, '!=', str_val_deref)\n"
+		"	sys.stdout.flush()\n"
+
+		"	return str_val_deref\n"
+
 		"def test_struct_ptr() -> float:\n"
 		"	print('Test start')\n"
 		"	sys.stdout.flush()\n"
@@ -110,6 +129,14 @@ TEST_F(metacall_python_port_pointer_test, DefaultConstructor)
 
 	metacall_value_destroy(ret);
 
+	ret = metacall("test_str_ptr");
+
+	ASSERT_EQ((enum metacall_value_id)METACALL_STRING, (enum metacall_value_id)metacall_value_id(ret));
+
+	EXPECT_STREQ("yeet", metacall_value_to_string(ret));
+
+	metacall_value_destroy(ret);
+
 	ret = metacall("test_struct_ptr");
 
 	ASSERT_EQ((enum metacall_value_id)METACALL_DOUBLE, (enum metacall_value_id)metacall_value_id(ret));