Add opaque pointer support for python port in order to support invalid types as a workaround.

Author: viferga

source/loaders/py_loader/source/py_loader_impl.c

@@ -102,6 +102,8 @@ static int py_loader_impl_discover_func_args_count(PyObject * func);
 
 static int py_loader_impl_discover_func(loader_impl impl, PyObject * func, function f);
 
+static void py_loader_impl_value_owner_finalize(value v, void * owner);
+
 static PyMethodDef py_loader_impl_function_type_invoke_defs[] =
 {
 	{
@@ -126,6 +128,21 @@ static struct PyModuleDef py_loader_impl_function_type_invoke_module =
 	NULL
 };
 
+static void * py_loader_impl_value_ownership = NULL;
+
+void py_loader_impl_value_owner_finalize(value v, void * owner)
+{
+	type_id id = value_type_id(v);
+
+	if (owner == &py_loader_impl_value_ownership)
+	{
+		if (id == TYPE_PTR)
+		{
+			Py_XDECREF(value_to_ptr(v));
+		}
+	}
+}
+
 int type_py_interface_create(type t, type_impl impl)
 {
 	(void)t;
@@ -498,7 +515,19 @@ value py_loader_impl_capi_to_value(loader_impl impl, PyObject * obj, type_id id)
 	}
 	else
 	{
-		log_write("metacall", LOG_LEVEL_ERROR, "Unrecognized python type");
+		/* Return the value as opaque pointer */
+		v = value_create_ptr(obj);
+
+		/* Set up the ownership to python loader */
+		value_own(v, &py_loader_impl_value_ownership);
+
+		/* Create reference to the value so it does not get garbage collected */
+		Py_INCREF(obj);
+
+		/* Set up finalizer in order to free the value */
+		value_finalizer(v, &py_loader_impl_value_owner_finalize);
+
+		log_write("metacall", LOG_LEVEL_WARNING, "Unrecognized python type");
 	}
 
 	return v;
@@ -598,13 +627,21 @@ PyObject * py_loader_impl_value_to_capi(loader_impl impl, loader_impl_py py_impl
 	{
 		void * ptr = value_to_ptr(v);
 
-		#if PY_MAJOR_VERSION == 2
+		if (value_owner(v) == &py_loader_impl_value_ownership)
+		{
+			return ptr;
+		}
+		else
+		{
+			#if PY_MAJOR_VERSION == 2
 
-			/* TODO */
+				/* TODO */
+
+			#elif PY_MAJOR_VERSION == 3
+				return PyCapsule_New(ptr, NULL, NULL);
+			#endif
+		}
 
-		#elif PY_MAJOR_VERSION == 3
-			return PyCapsule_New(ptr, NULL, NULL);
-		#endif
 	}
 	else if (id == TYPE_FUNCTION)
 	{

source/reflect/include/reflect/reflect_value.h

@@ -43,6 +43,8 @@ extern "C" {
 
 typedef void * value;
 
+typedef void (*value_finalizer_cb)(value, void *);
+
 /* -- Methods -- */
 
 /**
@@ -114,6 +116,44 @@ REFLECT_API void value_ref_inc(value v);
 */
 REFLECT_API void value_ref_dec(value v);
 
+/**
+*  @brief
+*    Returns the owner of the value, useful for lifecycles
+*
+*  @param[in] v
+*    Reference to the value
+*
+*  @return
+*    Pointer to the owner of the value,
+*    null means the value is not owned by anybody
+*/
+REFLECT_API void * value_owner(value v);
+
+/**
+*  @brief
+*    Set up the value ownership, overwrites the previous owner
+*
+*  @param[in] v
+*    Reference to the value
+*
+*  @param[in] owner
+*    Reference to the new owner
+*/
+REFLECT_API void value_own(value v, void * owner);
+
+/**
+*  @brief
+*    Set up the value finalizer, a callback that
+*    will be executed when the value life ends
+*
+*  @param[in] v
+*    Reference to the value
+*
+*  @param[in] finalizer
+*    Reference to the callback
+*/
+REFLECT_API void value_finalizer(value v, value_finalizer_cb finalizer);
+
 /**
 *  @brief
 *    Get pointer reference to value data

source/reflect/source/reflect_value.c

@@ -39,6 +39,8 @@ struct value_impl_type
 {
 	size_t bytes;
 	size_t ref_count;
+	void * owner;
+	value_finalizer_cb finalizer;
 };
 
 /* -- Private Methods -- */
@@ -77,8 +79,9 @@ value value_alloc(size_t bytes)
 	}
 
 	impl->bytes = bytes;
-
 	impl->ref_count = 1;
+	impl->owner = NULL;
+	impl->finalizer = NULL;
 
 	return (value)(((uintptr_t)impl) + sizeof(struct value_impl_type));
 }
@@ -150,6 +153,38 @@ void value_ref_dec(value v)
 	}
 }
 
+void * value_owner(value v)
+{
+	value_impl impl = value_descriptor(v);
+
+	if (impl == NULL)
+	{
+		return NULL;
+	}
+
+	return impl->owner;
+}
+
+void value_own(value v, void * owner)
+{
+	value_impl impl = value_descriptor(v);
+
+	if (impl != NULL)
+	{
+		impl->owner = owner;
+	}
+}
+
+void value_finalizer(value v, value_finalizer_cb finalizer)
+{
+	value_impl impl = value_descriptor(v);
+
+	if (impl != NULL)
+	{
+		impl->finalizer = finalizer;
+	}
+}
+
 void * value_data(value v)
 {
 	if (v == NULL)
@@ -195,6 +230,11 @@ void value_destroy(value v)
 
 	if (impl != NULL && impl->ref_count <= 1)
 	{
+		if (impl->finalizer != NULL)
+		{
+			impl->finalizer(v, impl->owner);
+		}
+
 		free(impl);
 	}
 }

source/scripts/python/function/source/function.py

@@ -37,3 +37,13 @@ def function_chain(x):
 def function_factorial(x):
 	return lambda n: 1 if n == 0 else n * x(x)(n - 1);
 
+class MyClass:
+	def f(self):
+		return 'hello world';
+
+def function_capsule_new_class():
+	return MyClass();
+
+def function_capsule_method(klass):
+	print('Executing class method with instance passed as opaque pointer:', klass.f());
+	return klass.f();

source/tests/metacall_function_test/source/metacall_function_test.cpp

@@ -160,6 +160,33 @@ TEST_F(metacall_function_test, DefaultConstructor)
 		EXPECT_EQ((void *) NULL, (void *) metacall_value_to_null(ret));
 
 		metacall_value_destroy(ret);
+
+		/* TODO: This is a workaround to achieve class / object callbacks between languages. */
+		/* It provides interoperatibility but without proper reflection. */
+		/* Enough to implement callbacks with opaque pointers between languages. */
+
+		ret = metacallv("function_capsule_new_class", metacall_null_args);
+
+		EXPECT_NE((void *) NULL, (void *) ret);
+
+		EXPECT_EQ((enum metacall_value_id) METACALL_PTR, (enum metacall_value_id) metacall_value_id(ret));
+
+		void * function_capsule_method_args[] =
+		{
+			ret
+		};
+
+		ret = metacallv("function_capsule_method", function_capsule_method_args);
+
+		EXPECT_NE((void *) NULL, (void *) ret);
+
+		EXPECT_EQ((enum metacall_value_id) METACALL_STRING, (enum metacall_value_id) metacall_value_id(ret));
+
+		EXPECT_EQ((int) 0, (int) strcmp("hello world", metacall_value_to_string(ret)));
+
+		metacall_value_destroy(ret);
+
+		metacall_value_destroy(function_capsule_method_args[0]);
 	}
 	#endif /* OPTION_BUILD_LOADERS_PY */
 

source/tests/metacall_python_class_test/source/metacall_python_class_test.cpp

@@ -43,6 +43,8 @@ TEST_F(metacall_python_class_test, DefaultConstructor)
 		};
 
 		EXPECT_EQ((int) 0, (int) metacall_load_from_file("py", py_scripts, sizeof(py_scripts) / sizeof(py_scripts[0]), NULL));
+
+		/* TODO: Implement properly class and object reflection and methods */
 	}
 	#endif /* OPTION_BUILD_LOADERS_PY */