Fixed not being able to use class methods for hook callbacks

Removed the possibility to use add_pre_hook etc. as a decorator. PreHook
and PostHook are the prefered options.

Author: Ayuto

addons/source-python/packages/source-python/memory/__init__.py

@@ -105,21 +105,19 @@ def __init__(self, convention, arg_types, return_type):
         super().__init__(
             alloc(8, False).address, convention, arg_types, return_type)
 
-        # A little hack to access the "self" argument
-        def hook(args):
-            """Call the callback and get the return value."""
-            return_value = self.callback(args)
-            if return_value is not None:
-                return return_value
+        self.add_pre_hook(self._hook)
 
-            if return_type == DataType.VOID:
-                return 0
+    def _hook(self, args):
+        """Call the callback and get the return value."""
+        return_value = self.callback(args)
+        if return_value is not None:
+            return return_value
 
-            # We will crash now :(
-            raise ValueError('Return value is not allowed to be None.')
+        if self.return_type == DataType.VOID:
+            return 0
 
-        # Hook the function and make sure the callback doesn't go out of scope
-        self._hook = self.add_pre_hook(hook)
+        # We will crash now :(
+        raise ValueError('Return value is not allowed to be None.')
 
     def __call__(self, *args, **kw):
         """Store the given callback on the first call.

src/core/modules/memory/memory_function.cpp

@@ -47,7 +47,7 @@
 // ============================================================================
 // >> EXTERNALS
 // ============================================================================
-extern std::map<CHook *, std::map<HookType_t, std::list<PyObject *> > > g_mapCallbacks;
+extern std::map<CHook *, std::map<HookType_t, std::list<object> > > g_mapCallbacks;
 
 
 // ============================================================================
@@ -312,7 +312,7 @@ CHook* HookFunctionHelper(void* addr, ICallingConvention* pConv)
 	return result;
 }
 
-handle<> CFunction::AddHook(HookType_t eType, PyObject* pCallable)
+void CFunction::AddHook(HookType_t eType, PyObject* pCallable)
 {
 	if (!IsHookable())
 		BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Function is not hookable.")
@@ -325,10 +325,7 @@ handle<> CFunction::AddHook(HookType_t eType, PyObject* pCallable)
 
 	// Add the hook handler. If it's already added, it won't be added twice
 	pHook->AddCallback(eType, (HookHandlerFn *) (void *) &SP_HookHandler);
-	g_mapCallbacks[pHook][eType].push_back(pCallable);
-	
-	// Return the callback, so we can use this method as a decorator
-	return handle<>(borrowed(pCallable));
+	g_mapCallbacks[pHook][eType].push_back(object(handle<>(borrowed(pCallable))));
 }
 
 void CFunction::RemoveHook(HookType_t eType, PyObject* pCallable)
@@ -338,7 +335,7 @@ void CFunction::RemoveHook(HookType_t eType, PyObject* pCallable)
 	if (!pHook)
 		return;
 
-	g_mapCallbacks[pHook][eType].remove(pCallable);
+	g_mapCallbacks[pHook][eType].remove(object(handle<>(borrowed(pCallable))));
 }
 
 void CFunction::DeleteHook()

src/core/modules/memory/memory_function.h

@@ -69,13 +69,13 @@ class CFunction: public CPointer
 	object CallTrampoline(boost::python::tuple args, dict kw);
 	object SkipHooks(boost::python::tuple args, dict kw);
 
-	handle<> AddHook(HookType_t eType, PyObject* pCallable);
+	void AddHook(HookType_t eType, PyObject* pCallable);
 	void RemoveHook(HookType_t eType, PyObject* pCallable);
 
-	handle<> AddPreHook(PyObject* pCallable)
+	void AddPreHook(PyObject* pCallable)
 	{ return AddHook(HOOKTYPE_PRE, pCallable); }
 
-	handle<> AddPostHook(PyObject* pCallable)
+	void AddPostHook(PyObject* pCallable)
 	{ return AddHook(HOOKTYPE_POST, pCallable); }
 
 	void RemovePreHook(PyObject* pCallable)

src/core/modules/memory/memory_hooks.cpp

@@ -40,8 +40,8 @@ using namespace boost::python;
 // ============================================================================
 // >> GLOBAL VARIABLES
 // ============================================================================
-// g_mapCallbacks[<CHook *>][<HookType_t>] -> [<PyObject *>, <PyObject *>, ...]
-std::map<CHook *, std::map<HookType_t, std::list<PyObject *> > > g_mapCallbacks;
+// g_mapCallbacks[<CHook *>][<HookType_t>] -> [<object>, <object>, ...]
+std::map<CHook *, std::map<HookType_t, std::list<object> > > g_mapCallbacks;
 
 
 // ============================================================================
@@ -79,7 +79,7 @@ object GetArgument(CHook* pHook, int iIndex)
 // ============================================================================
 bool SP_HookHandler(HookType_t eHookType, CHook* pHook)
 {
-	std::list<PyObject *> callbacks = g_mapCallbacks[pHook][eHookType];
+	std::list<object> callbacks = g_mapCallbacks[pHook][eHookType];
 
 	// No need to do all this stuff, if there is no callback registered
 	if (callbacks.empty())
@@ -112,14 +112,14 @@ bool SP_HookHandler(HookType_t eHookType, CHook* pHook)
 
 	CStackData stackdata = CStackData(pHook);
 	bool bOverride = false;
-	for (std::list<PyObject *>::iterator it=callbacks.begin(); it != callbacks.end(); it++)
+	for (std::list<object>::iterator it=callbacks.begin(); it != callbacks.end(); it++)
 	{
 		BEGIN_BOOST_PY()
 			object pyretval;
 			if (eHookType == HOOKTYPE_PRE)
-				pyretval = CALL_PY_FUNC(*it, stackdata);
+				pyretval = CALL_PY_FUNC((*it).ptr(), stackdata);
 			else
-				pyretval = CALL_PY_FUNC(*it, stackdata, retval);
+				pyretval = CALL_PY_FUNC((*it).ptr(), stackdata, retval);
 
 			if (!pyretval.is_none())
 			{

src/core/modules/memory/memory_wrap.cpp

@@ -484,6 +484,10 @@ void export_function(scope _memory)
 		)
 
 		.def_readonly("return_type",
+			&CFunction::m_eReturnType
+		)
+
+		.def_readonly("converter",
 			&CFunction::m_oConverter
 		)