Added post-construction initialization support.

Fixed unmanaged CallingConvention's wrapper not being initialized.
Changed retrieval priority of default_convention.

Author: jordanbriere

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

src/core/modules/memory/memory_wrap.cpp

@@ -839,9 +839,17 @@ 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_initializer(
+				make_constructor(
+					&ICallingConventionWrapper::__init__,
+					default_call_policies(),
+					("arg_types", "return_type", arg("alignment")=4, arg("default_convention")=CONV_CUSTOM)
+				),
+				make_function(
+					&ICallingConventionWrapper::Initialize,
+					initializer_call_policies<>(),
+					("self", "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,30 @@ class ICallingConventionWrapper: public ICallingConvention, public wrapper<ICall
 		);
 	}
 
+	void Initialize(object self, object oArgTypes, DataType_t returnType, int iAlignment=4, Convention_t eDefaultConv=CONV_CUSTOM)
+	{
+		// Initialize our wrapper so that Python overrides are properly resolved.
+		detail::initialize_wrapper(self.ptr(), this);
+
+		// 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,47 @@ typedef return_value_policy<copy_const_reference> copy_const_reference_policy;
 
 typedef return_value_policy<return_by_value> return_by_value_policy;
 
+//---------------------------------------------------------------------------------
+// Provides post-construction initialization support of the Python instances.
+//---------------------------------------------------------------------------------
+template<typename BasePolicies = default_call_policies>
+struct initializer_call_policies : BasePolicies
+{
+	template<typename ArgumentPackage>
+	static PyObject *postcall(const ArgumentPackage &args, PyObject *pResult)
+	{
+		return incref(Py_None); // __init__ should always return None
+	}
+};
+
+template<typename Constructor, typename Initializer>
+struct constructor_initializer
+{
+public:
+	constructor_initializer(Constructor constructor, Initializer initializer):
+		m_constructor(constructor),
+		m_initializer(initializer)
+	{
+	}
+
+	object operator()(boost::python::tuple args, dict kwargs)
+	{
+		m_constructor(*args, **kwargs);
+		return m_initializer(*(make_tuple(args[0]) + args), **kwargs);
+	}
+
+private:
+	object m_constructor;
+	object m_initializer;
+};
+
+template<typename Constructor, typename Initializer>
+object make_constructor_initializer(Constructor constructor, Initializer initializer)
+{
+	return raw_function(
+		constructor_initializer<Constructor, Initializer>(constructor, initializer),
+		1 // self
+	);
+};
+
 #endif // _WRAP_MACROS_H