Merge pull request #3 from jordanbriere/add_default_callingconvention

Added post-construction initialization support.

Author: CookStar

src/core/modules/memory/memory_function.cpp

@@ -154,26 +154,11 @@ CFunction::CFunction(unsigned long ulAddr, object oCallingConvention, object oAr
 
 		// A custom calling convention will be used...
 		m_eCallingConvention = CONV_CUSTOM;
-
-		// Check if default_convention is defined.
-		if (PyObject_HasAttrString(oCallingConvention.ptr(), "default_convention"))
-		{
-			// Extract default_convention and pass it to oCallingConvention.
-			Convention_t eCallingConvention = extract<Convention_t>(oCallingConvention.attr("default_convention"));
-			m_oCallingConvention = oCallingConvention(m_tArgs, m_eReturnType, 4, eCallingConvention);
-		}
-		else
-		{
-			m_oCallingConvention = oCallingConvention(m_tArgs, m_eReturnType);
-		}
-
+		m_oCallingConvention = oCallingConvention(m_tArgs, m_eReturnType);
 		m_pCallingConvention = extract<ICallingConvention*>(m_oCallingConvention);
 
 		// Reserve a Python reference for DynamicHooks.
 		Py_INCREF(m_oCallingConvention.ptr());
-
-		// Initialize our wrapper so that Python overrides are properly resolved.
-		detail::initialize_wrapper(m_oCallingConvention.ptr(), get_pointer((ICallingConventionWrapper *)m_pCallingConvention));
 	}
 
 	// Step 4: Get the DynCall calling convention
@@ -196,8 +181,11 @@ CFunction::CFunction(unsigned long ulAddr, Convention_t eCallingConvention,
 
 CFunction::~CFunction()
 {
+	if (!m_pCallingConvention)
+		return;
+
 	// If the convention isn't flagged as hooked, then we need to take care of it.
-	if (m_pCallingConvention && !m_pCallingConvention->m_bHooked)
+	if (!m_pCallingConvention->m_bHooked)
 	{
 		// If we don't have a Python instance, then we can safely delete it.
 		if (m_oCallingConvention.is_none())
@@ -206,6 +194,10 @@ CFunction::~CFunction()
 		else if (Py_REFCNT(m_oCallingConvention.ptr()) > 1)
 			Py_DECREF(m_oCallingConvention.ptr());
 	}
+	// If we are using a built-in convention that is currently hooked, let's flag it as no longer hooked
+	// so that we know we are not bound to a CFunction anymore and can be deleted.
+	else if (m_eCallingConvention != CONV_CUSTOM && !dynamic_cast<ICallingConventionWrapper *>(m_pCallingConvention))
+		m_pCallingConvention->m_bHooked = false;
 
 	m_pCallingConvention = NULL;
 }
@@ -439,17 +431,24 @@ void CFunction::DeleteHook()
 
 	g_mapCallbacks.erase(pHook);
 
-	// Flag the convention as no longer hooked and being taken care of by DynamicHooks.
-	pHook->m_pCallingConvention->m_bHooked = false;
-
-	// Release the Python reference we reserved for DynamicHooks.
 	ICallingConventionWrapper *pConv = dynamic_cast<ICallingConventionWrapper *>(pHook->m_pCallingConvention);
 	if (pConv)
 	{
-		PyObject *pOwner = detail::wrapper_base_::owner(pConv);
-		if (pOwner && Py_REFCNT(pOwner))
-			Py_DECREF(pOwner);
+		if (pConv->m_bHooked)
+		{
+			// Flag the convention as no longer hooked and being taken care of by DynamicHooks.
+			pHook->m_pCallingConvention->m_bHooked = false;
+
+			// Release the Python reference we reserved for DynamicHooks.
+			PyObject *pOwner = detail::wrapper_base_::owner(pConv);
+			if (pOwner && Py_REFCNT(pOwner))
+				Py_DECREF(pOwner);
+		}
 	}
+	// If we are a built-in convention bound to a CHook instance but not flagged as hooked anymore, then that
+	// means we are no longer bound to a CFunction instance and can be safely deleted.
+	else if (!pHook->m_pCallingConvention->m_bHooked)
+		delete pHook->m_pCallingConvention;
 
 	// Set the calling convention to NULL, because DynamicHooks will delete it otherwise.
 	pHook->m_pCallingConvention = NULL;

src/core/modules/memory/memory_wrap.cpp

@@ -839,9 +839,18 @@ void export_calling_convention(scope _memory)
 		no_init)
 
 		.def("__init__",
-			make_constructor(&ICallingConventionWrapper::__init__,
-				default_call_policies(),
-				(arg("arg_types"), arg("return_type"), arg("alignment")=4, arg("default_convention")=CONV_CUSTOM)
+			make_constructor(
+				&ICallingConventionWrapper::__init__,
+				post_constructor_policies<
+					initialize_wrapper_policies<boost::shared_ptr<ICallingConventionWrapper> >
+				>(
+					make_function(
+						&ICallingConventionWrapper::Initialize,
+						default_call_policies(),
+						args("self", "arg_types", "return_type", "alignment", "default_convention")
+					)
+				),
+				("arg_types", "return_type", arg("alignment")=4, arg("default_convention")=CONV_CUSTOM)
 			),
 			"Initialize the calling convention.\n"
 			"\n"

src/core/modules/memory/memory_wrap.h

@@ -95,6 +95,27 @@ class ICallingConventionWrapper: public ICallingConvention, public wrapper<ICall
 		);
 	}
 
+	void Initialize(object self, object oArgTypes, DataType_t returnType, int iAlignment, Convention_t eDefaultConv)
+	{
+		// If we didn't receive a default convention on construction, try to resolve one from the Python instance.
+		if (!m_pDefaultCallingConvention)
+		{
+			try
+			{
+				m_pDefaultCallingConvention = MakeDynamicHooksConvention(
+					extract<Convention_t>(self.attr("default_convention")), m_vecArgTypes, m_returnType, m_iAlignment
+				);
+			}
+			catch (error_already_set &)
+			{
+				if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+					throw_error_already_set();
+
+				PyErr_Clear();
+			}
+		}
+	}
+
 	virtual std::list<Register_t> GetRegisters()
 	{
 		override get_registers = get_override("get_registers");

src/core/utilities/wrap_macros.h

@@ -248,4 +248,54 @@ typedef return_value_policy<copy_const_reference> copy_const_reference_policy;
 
 typedef return_value_policy<return_by_value> return_by_value_policy;
 
+//---------------------------------------------------------------------------------
+// Call policies that initializes the wrapper hierarchy.
+//---------------------------------------------------------------------------------
+template<typename HeldType, typename BasePolicies = default_call_policies, int iSelf = -1>
+struct initialize_wrapper_policies : BasePolicies
+{
+	template<typename ArgumentPackage>
+	static PyObject *postcall(const ArgumentPackage &args, PyObject *pResult)
+	{
+		PyObject *pSelf = detail::get(boost::mpl::int_<iSelf>(), args);
+		detail::initialize_wrapper(
+			pSelf,
+			get_pointer((HeldType)extract<HeldType>(pSelf))
+		);
+
+		return BasePolicies::postcall(args, pResult);
+	}
+};
+
+//---------------------------------------------------------------------------------
+// Provides post-construction initialization support of the Python instances.
+//---------------------------------------------------------------------------------
+template<typename BasePolicies = default_call_policies, int iSelf = -1>
+struct post_constructor_policies : BasePolicies
+{
+public:
+	post_constructor_policies(object initializer):
+		m_initializer(initializer)
+	{
+	}
+
+	template<typename ArgumentPackage>
+	PyObject *postcall(const ArgumentPackage &args, PyObject *pResult)
+	{
+		BasePolicies::postcall(args, pResult);
+		m_initializer(
+			*(make_tuple(
+				object(handle<>(incref(detail::get(boost::mpl::int_<iSelf>(), args))))) +
+				boost::python::tuple(handle<>(args.base))
+			)
+		);
+
+		decref(pResult);
+		return incref(Py_None); // __init__ should always return None
+	}
+
+private:
+	object m_initializer;
+};
+
 #endif // _WRAP_MACROS_H