Improve C loader ptr and tests.

Author: viferga

source/loaders/c_loader/source/c_loader_impl.cpp

@@ -52,6 +52,7 @@ namespace fs = std::experimental::filesystem;
 #endif
 
 #include <map>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -779,18 +780,19 @@ function_return function_c_interface_invoke(function func, function_impl impl, f
 
 			closures.push_back(closure);
 		}
-		else if (id == TYPE_STRING || id == TYPE_BUFFER || id == TYPE_PTR)
+		else if (id == TYPE_STRING || id == TYPE_BUFFER)
 		{
-			/*
-			String, buffer requires to be pointer to a string
-			Pointer requires to be pointer to pointer
-			*/
+			/* String, buffer requires to be pointer to a string */
 
 			/* In order to work, this must be true */
 			assert(args[args_count] == value_data(args[args_count]));
 
 			c_function->values[args_count] = (void *)&args[args_count];
 		}
+		else if (id == TYPE_PTR)
+		{
+			c_function->values[args_count] = args[args_count];
+		}
 		else if (id == TYPE_ARRAY)
 		{
 			c_loader_array_type *array = static_cast<c_loader_array_type *>(type_derived(t));

source/scripts/c/loadtest/source/loadtest.cpp

@@ -13,6 +13,9 @@ int pair_list_init(pair_list **t)
 {
 	static const uint32_t size = 3;
 
+	std::cout << "pair_list_init: " << t << std::endl;
+	std::cout << "pair_list_init: *(" << *t << ")" << std::endl;
+
 	*t = new pair_list();
 
 	(*t)->size = size;
@@ -37,6 +40,7 @@ double pair_list_value(pair_list *t, uint32_t id)
 
 void pair_list_destroy(pair_list *t)
 {
+	std::cout << "pair_list_destroy: *(" << t << ")" << std::endl;
 	delete[] t->pairs;
 	delete t;
 }

source/tests/metacall_c_lib_test/source/metacall_c_lib_test.cpp

@@ -43,14 +43,20 @@ TEST_F(metacall_c_lib_test, DefaultConstructor)
 
 	metacall_value_destroy(ret);
 
-	void *pair_list = NULL;
+	void *pair_list_ptr = metacall_value_create_ptr(NULL);
 
 	void *args_init[] = {
-		metacall_value_create_ptr(&pair_list),
+		metacall_value_create_ptr(pair_list_ptr),
 	};
 
+	std::cout << "pair_list_ptr: " << pair_list_ptr << std::endl;
+	std::cout << "pair_list_ptr: *(" << metacall_value_to_ptr(pair_list_ptr) << ")" << std::endl;
+
 	ret = metacallv("pair_list_init", args_init);
 
+	std::cout << "pair_list_ptr: " << pair_list_ptr << std::endl;
+	std::cout << "pair_list_ptr: *(" << metacall_value_to_ptr(pair_list_ptr) << ")" << std::endl;
+
 	EXPECT_NE((void *)NULL, (void *)ret);
 
 	EXPECT_EQ((enum metacall_value_id)metacall_value_id(ret), (enum metacall_value_id)METACALL_INT);
@@ -62,7 +68,7 @@ TEST_F(metacall_c_lib_test, DefaultConstructor)
 	metacall_value_destroy(args_init[0]);
 
 	void *args_value[] = {
-		metacall_value_create_ptr(pair_list),
+		pair_list_ptr,
 		metacall_value_create_int(2)
 	};
 
@@ -76,11 +82,10 @@ TEST_F(metacall_c_lib_test, DefaultConstructor)
 
 	metacall_value_destroy(ret);
 
-	metacall_value_destroy(args_value[0]);
 	metacall_value_destroy(args_value[1]);
 
 	void *args_destroy[] = {
-		metacall_value_create_ptr(pair_list),
+		pair_list_ptr,
 	};
 
 	ret = metacallv("pair_list_destroy", args_destroy);
@@ -91,7 +96,7 @@ TEST_F(metacall_c_lib_test, DefaultConstructor)
 
 	metacall_value_destroy(ret);
 
-	metacall_value_destroy(args_destroy[0]);
+	metacall_value_destroy(pair_list_ptr);
 
 	metacall_destroy();
 }

source/tests/metacall_c_test/source/metacall_c_test.cpp

@@ -41,6 +41,37 @@ void *sum_callback(size_t argc, void *args[], void *data)
 	return metacall_value_create_int(result);
 }
 
+void *test_string_reference(size_t argc, void *args[], void *data)
+{
+	printf("ptr %p\n", args[0]);
+	fflush(stdout);
+
+	void *string_value = metacall_value_to_ptr(args[0]);
+
+	printf("string ptr %p\n", string_value);
+	printf("type id %s\n", metacall_value_type_name(string_value));
+	fflush(stdout);
+
+	char *str = metacall_value_to_string(string_value);
+
+	(void)argc;
+	(void)data;
+
+	printf("native string %s\n", str);
+
+	EXPECT_STREQ("asd", str);
+
+	static const char yeet[] = "yeet";
+
+	metacall_value_from_string(string_value, yeet, sizeof(yeet) - 1);
+
+	printf("type id %s\n", metacall_value_type_name(string_value));
+	printf("native string %s\n", str);
+	fflush(stdout);
+
+	return metacall_value_create_null();
+}
+
 TEST_F(metacall_c_test, DefaultConstructor)
 {
 	ASSERT_EQ((int)0, (int)metacall_initialize());
@@ -196,6 +227,79 @@ TEST_F(metacall_c_test, DefaultConstructor)
 
 	// metacall_value_destroy(ret);
 
+	/* References (Native) */
+	{
+		static const char str[] = "asd";
+		void *str_value = metacall_value_create_string(str, sizeof(str) - 1);
+		void *str_value_ref = metacall_value_reference(str_value);
+
+		printf("ptr %p\n", str_value_ref);
+		printf("string %p\n", str_value);
+		printf("string str %s\n", metacall_value_to_string(str_value));
+		fflush(stdout);
+
+		{
+			void *new_str_value = metacall_value_to_ptr(str_value_ref);
+			char *new_str = metacall_value_to_string(new_str_value);
+
+			EXPECT_STREQ("asd", new_str);
+		}
+
+		void *args[] = {
+			str_value_ref
+		};
+
+		metacall_register("test_string_reference", test_string_reference, NULL, METACALL_NULL, 1, METACALL_PTR);
+
+		ret = metacallv_s("test_string_reference", args, 1);
+
+		EXPECT_NE((void *)NULL, (void *)ret);
+
+		EXPECT_EQ((enum metacall_value_id)metacall_value_id(ret), (enum metacall_value_id)METACALL_NULL);
+
+		metacall_value_destroy(ret);
+
+		printf("type id %s\n", metacall_value_type_name(str_value));
+		fflush(stdout);
+
+		// It chops the string because it has a fixed size from 'asd'
+		EXPECT_STREQ(metacall_value_to_string(str_value), "yee");
+
+		metacall_value_destroy(str_value);
+		metacall_value_destroy(str_value_ref);
+	}
+
+	/* References (C) */
+	{
+		static const char str[] = "asd";
+		void *str_value = metacall_value_create_string(str, sizeof(str) - 1);
+		void *str_value_ref = metacall_value_reference(str_value);
+
+		printf("(R) ptr %p\n", str_value_ref);
+		printf("(R) string ptr %p\n", str_value);
+		printf("(R) string str %s\n", metacall_value_to_string(str_value));
+		fflush(stdout);
+
+		void *args[] = {
+			str_value_ref
+		};
+
+		ret = metacallv_s("modify_str_ptr", args, 1);
+
+		EXPECT_NE((void *)NULL, (void *)ret);
+
+		EXPECT_EQ((enum metacall_value_id)metacall_value_id(ret), (enum metacall_value_id)METACALL_NULL);
+
+		metacall_value_destroy(ret);
+
+		char *str_value_deref = static_cast<char *>(metacall_value_dereference(str_value_ref));
+
+		EXPECT_STREQ(str_value_deref, "yeet");
+
+		metacall_value_destroy(str_value);
+		metacall_value_destroy(str_value_ref);
+	}
+
 	/* Print inspect information */
 	{
 		size_t size = 0;