Added automatically deallocating of pointers and callbacks

Ayuto · Ayuto · commit 04583a6dc54a · 2014-03-01T14:18:01.000+01:00
- Fixed and extended PythonLog()
- Renamed get_address() to get_pointer()
diff --git a/src/core/modules/engine/engine_wrap_python.cpp b/src/core/modules/engine/engine_wrap_python.cpp
@@ -979,7 +979,7 @@ bool CGameTrace::DidHitWorld() const
 int CGameTrace::GetEntityIndex() const
 {
 	// TODO: Use a more efficient way
-	return m_pEnt ? IndexFromPointer(object(CPointer((unsigned long) m_pEnt))) : -1;
+	return m_pEnt ? IndexFromPointer(object(ptr(new CPointer((unsigned long) m_pEnt)))) : -1;
 }
 
 
diff --git a/src/core/modules/memory/memory_callback.cpp b/src/core/modules/memory/memory_callback.cpp
@@ -53,6 +53,7 @@ CCallback::CCallback(object oCallback, Convention_t eConv, tuple args, ReturnTyp
     : CFunction(NULL, eConv, args, return_type)
 {
     m_oCallback = oCallback;
+	m_bAutoDealloc = true;
 
     // Find the proper callback caller function
     void* pCallCallbackFunc = NULL;
@@ -101,6 +102,18 @@ CCallback::CCallback(object oCallback, Convention_t eConv, tuple args, ReturnTyp
     m_ulAddr = (unsigned long) a.make();
 }
 
+CCallback::~CCallback()
+{	
+	if (m_bAutoDealloc)
+	{
+		PythonLog(4, "[SP] Automatically deallocating callback at %u.", m_ulAddr);
+		Dealloc();
+
+		// This prevents ~CPointer from calling CPointer::Dealloc() again
+		m_bAutoDealloc = false;
+	}
+}
+
 int CCallback::GetPopSize()
 {
 	/*
@@ -201,18 +214,18 @@ object CallCallback(CCallback* pCallback, unsigned long ulEBP, unsigned long ulE
                 case SIGCHAR_ULONGLONG: val = object(GetArgument<unsigned long long>(pCallback, ulEBP, ulECX, i)); break;
                 case SIGCHAR_FLOAT:     val = object(GetArgument<float>(pCallback, ulEBP, ulECX, i)); break;
                 case SIGCHAR_DOUBLE:    val = object(GetArgument<double>(pCallback, ulEBP, ulECX, i)); break;
-                case SIGCHAR_POINTER:   val = object(CPointer(GetArgument<unsigned long>(pCallback, ulEBP, ulECX, i))); break;
+                case SIGCHAR_POINTER:   val = object(ptr(new CPointer(GetArgument<unsigned long>(pCallback, ulEBP, ulECX, i)))); break;
                 case SIGCHAR_STRING:    val = object(GetArgument<const char*>(pCallback, ulEBP, ulECX, i)); break;
                 default: BOOST_RAISE_EXCEPTION(PyExc_TypeError, "Unknown argument type."); break;
             }
             arg_list.append(val);
         }
-        arg_list.append(CPointer((unsigned long) ulEBP));
+        arg_list.append(ptr(new CPointer((unsigned long) ulEBP)));
         return eval("lambda func, args: func(*args)")(pCallback->m_oCallback, arg_list);
 
     END_BOOST_PY_NORET()
 
-	PythonLog(0, "An exception occured while calling the Python callback. The server will now crash!");
+	PythonLog(0, "[SP] An exception occured while calling the Python callback. The server will now crash!");
 
     // Throw an exception. We will crash now :(
     throw;
diff --git a/src/core/modules/memory/memory_callback.h b/src/core/modules/memory/memory_callback.h
@@ -68,6 +68,7 @@ class CCallback: public CFunction
 {
 public:
     CCallback(object oCallback, Convention_t eConv, tuple args, ReturnType_t return_type);
+	virtual ~CCallback();
 
     int          GetPopSize();
     int          GetArgumentOffset(int iIndex);
diff --git a/src/core/modules/memory/memory_hooks.cpp b/src/core/modules/memory/memory_hooks.cpp
@@ -78,7 +78,7 @@ bool SP_HookHandler(DynamicHooks::HookType_t eHookType, CHook* pHook)
 			case SIGCHAR_ULONGLONG:	retval = GetReturnValue<unsigned long long>(pHook); break;
 			case SIGCHAR_FLOAT:		retval = GetReturnValue<float>(pHook); break;
 			case SIGCHAR_DOUBLE:	retval = GetReturnValue<double>(pHook); break;
-			case SIGCHAR_POINTER:	retval = object(CPointer(pHook->GetReturnValue<unsigned long>())); break;
+			case SIGCHAR_POINTER:	retval = object(ptr(new CPointer(pHook->GetReturnValue<unsigned long>()))); break;
 			case SIGCHAR_STRING:	retval = GetReturnValue<const char *>(pHook); break;
 			default: BOOST_RAISE_EXCEPTION(PyExc_TypeError, "Unknown type.");
 		}
@@ -162,7 +162,7 @@ object CStackData::GetItem(unsigned int iIndex)
 		case SIGCHAR_ULONGLONG: retval = GetArgument<unsigned long long>(m_pHook, iIndex); break;
 		case SIGCHAR_FLOAT:     retval = GetArgument<float>(m_pHook, iIndex); break;
 		case SIGCHAR_DOUBLE:    retval = GetArgument<double>(m_pHook, iIndex); break;
-		case SIGCHAR_POINTER:   retval = object(CPointer(m_pHook->GetArgument<unsigned long>(iIndex))); break;
+		case SIGCHAR_POINTER:   retval = object(ptr(new CPointer(m_pHook->GetArgument<unsigned long>(iIndex)))); break;
 		case SIGCHAR_STRING:    retval = GetArgument<const char *>(m_pHook, iIndex); break;
 		default: BOOST_RAISE_EXCEPTION(PyExc_TypeError, "Unknown type.") break;
 	}
diff --git a/src/core/modules/memory/memory_hooks.h b/src/core/modules/memory/memory_hooks.h
@@ -22,11 +22,11 @@ class CStackData
 public:
 	CStackData(CHook* pHook);
 
-	object   GetItem(unsigned int iIndex);
-	void     SetItem(unsigned int iIndex, object value);
+	object    GetItem(unsigned int iIndex);
+	void      SetItem(unsigned int iIndex, object value);
 
-	CPointer GetESP()
-	{ return CPointer((unsigned long) m_pHook->m_pESP); }
+	CPointer* GetESP()
+	{ return new CPointer((unsigned long) m_pHook->m_pESP); }
 
 protected:
 	CHook*                m_pHook;
diff --git a/src/core/modules/memory/memory_tools.cpp b/src/core/modules/memory/memory_tools.cpp
@@ -36,6 +36,7 @@
 #include "memory_tools.h"
 #include "utility/wrap_macros.h"
 #include "utility/sp_util.h"
+#include "utility/call_python.h"
 
 
 DCCallVM* g_pCallVM = dcNewCallVM(4096);
@@ -46,9 +47,19 @@ CHookManager* g_pHookMngr = new CHookManager;
 //-----------------------------------------------------------------------------
 // CPointer class
 //-----------------------------------------------------------------------------
-CPointer::CPointer(unsigned long ulAddr /* = 0 */)
+CPointer::CPointer(unsigned long ulAddr /* = 0 */, bool bAutoDealloc /* false */)
 {
 	m_ulAddr = ulAddr;
+	m_bAutoDealloc = bAutoDealloc;
+}
+
+CPointer::~CPointer()
+{
+	if (m_bAutoDealloc)
+	{
+		PythonLog(4, "[SP] Automatically deallocating pointer at %u.", m_ulAddr);
+		Dealloc();
+	}
 }
 
 void CPointer::SetStringPtr(char* szText, int iOffset /* = 0 */)
@@ -83,12 +94,13 @@ CPointer* CPointer::GetPtr(int iOffset /* = 0 */)
 	return new CPointer(*(unsigned long *) (m_ulAddr + iOffset));
 }
 
-void CPointer::SetPtr(CPointer* ptr, int iOffset /* = 0 */)
+void CPointer::SetPtr(object ptr, int iOffset /* = 0 */)
 {
 	if (!IsValid())
 		BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Pointer is NULL.")
-
-	*(unsigned long *) m_ulAddr = ptr->m_ulAddr;
+		
+	unsigned long ulAddr = ExtractPyPtr(ptr);
+	*(unsigned long *) m_ulAddr = m_ulAddr;
 }
 
 int CPointer::Compare(object oOther, unsigned long ulNum)
@@ -193,8 +205,8 @@ CFunction* CPointer::MakeVirtualFunction(int iIndex, Convention_t eConv, tuple a
 // CFunction class
 //-----------------------------------------------------------------------------
 CFunction::CFunction(unsigned long ulAddr, Convention_t eConv, tuple args, ReturnType_t return_type)
+	: CPointer(ulAddr)
 {
-	m_ulAddr = ulAddr;
 	m_eConv = eConv;
 	m_Args = args;
 	m_ReturnType = return_type;
@@ -254,7 +266,7 @@ object CFunction::Call(tuple args, dict kw)
 		case DC_SIGCHAR_ULONGLONG: return object((unsigned long long) dcCallLongLong(g_pCallVM, m_ulAddr));
 		case DC_SIGCHAR_FLOAT:     return object(dcCallFloat(g_pCallVM, m_ulAddr));
 		case DC_SIGCHAR_DOUBLE:    return object(dcCallDouble(g_pCallVM, m_ulAddr));
-		case DC_SIGCHAR_POINTER:   return object(CPointer(dcCallPointer(g_pCallVM, m_ulAddr)));
+		case DC_SIGCHAR_POINTER:   return object(ptr(new CPointer(dcCallPointer(g_pCallVM, m_ulAddr))));
 		case DC_SIGCHAR_STRING:    return object((const char *) dcCallPointer(g_pCallVM, m_ulAddr));
 		default: BOOST_RAISE_EXCEPTION(PyExc_TypeError, "Unknown return type.")
 	}
diff --git a/src/core/modules/memory/memory_tools.h b/src/core/modules/memory/memory_tools.h
@@ -159,26 +159,27 @@ class CFunction;
 class CPointer
 {
 public:
-	CPointer(unsigned long ulAddr = 0);
+	CPointer(unsigned long ulAddr = 0, bool bAutoDealloc = false);
+	virtual ~CPointer();
 
 	operator unsigned long() const { return m_ulAddr; }
 
 	// Implement some operators
 	template<class T>
-	const CPointer operator+(T const& rhs)
-	{ return CPointer(m_ulAddr + rhs); }
+	const CPointer* operator+(T const& rhs)
+	{ return new CPointer(m_ulAddr + rhs); }
 
 	template<class T>
-	const CPointer operator-(T const& rhs)
-	{ return CPointer(m_ulAddr - rhs); }
+	const CPointer* operator-(T const& rhs)
+	{ return new CPointer(m_ulAddr - rhs); }
 
 	template<class T>
-	const CPointer operator+=(T const& rhs)
-	{ m_ulAddr += rhs; return *this; }
+	const CPointer* operator+=(T const& rhs)
+	{ m_ulAddr += rhs; return this; }
 
 	template<class T>
-	const CPointer operator-=(T const& rhs)
-	{ m_ulAddr -= rhs; return *this; }
+	const CPointer* operator-=(T const& rhs)
+	{ m_ulAddr -= rhs; return this; }
 
 	bool operator!()
 	{ return !m_ulAddr; }
@@ -217,7 +218,7 @@ class CPointer
 	void                SetStringArray(char* szText, int iOffset = 0);
 
 	CPointer*           GetPtr(int iOffset = 0);
-	void                SetPtr(CPointer* ptr, int iOffset = 0);
+	void                SetPtr(object ptr, int iOffset = 0);
 
 	bool                IsOverlapping(object oOther, unsigned long ulNumBytes);
 	CPointer*           SearchBytes(object oBytes, unsigned long ulNumBytes);
@@ -241,6 +242,7 @@ class CPointer
 
 public:
 	unsigned long m_ulAddr;
+	bool          m_bAutoDealloc;
 };
 
 
@@ -315,15 +317,15 @@ inline int GetError()
 	return dcGetError(g_pCallVM);
 }
 
-inline CPointer Alloc(int iSize)
+inline CPointer* Alloc(int iSize, bool bAutoDealloc = false)
 {
-	return CPointer((unsigned long) UTIL_Alloc(iSize));
+	return new CPointer((unsigned long) UTIL_Alloc(iSize), bAutoDealloc);
 }
 
 template<class T>
-CPointer GetAddress(T* ptr)
+CPointer* GetPointer(T* ptr)
 {
-	return CPointer((unsigned long) ptr);
+	return new CPointer((unsigned long) ptr);
 }
 
 #endif // _MEMORY_TOOLS_H
diff --git a/src/core/modules/memory/memory_wrap_python.cpp b/src/core/modules/memory/memory_wrap_python.cpp
@@ -171,9 +171,12 @@ BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_ptr_overload, SetPtr, 1, 2)
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_string_ptr_overload, SetStringPtr, 1, 2)
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_string_array_overload, SetStringArray, 1, 2)
 
+
+BOOST_PYTHON_FUNCTION_OVERLOADS(alloc_overload, Alloc, 1, 2)
+
 void export_memtools()
 {
-	class_<CPointer>("Pointer", init< optional<unsigned long> >())
+	class_<CPointer, boost::noncopyable>("Pointer", init< optional<unsigned long, bool> >())
 		// get/set_<type> methods
 		EXPOSE_GET_SET_TYPE(bool, bool)
 		EXPOSE_GET_SET_TYPE(char, char)
@@ -332,15 +335,21 @@ void export_memtools()
 		.def_readwrite("address", 
 			&CPointer::m_ulAddr
 		)
+
+		.def_readwrite("auto_dealloc",
+			&CPointer::m_bAutoDealloc
+		)
 	;
 
 	def("alloc",
 		Alloc,
-		"Allocates a memory block.",
-		args("size")
+		alloc_overload(
+			"Allocates a memory block.",
+			args("size", "auto_dealloc")
+		)[manage_new_object_policy()]
 	);
 
-	class_<CFunction, bases<CPointer> >("Function", init<unsigned long, Convention_t, tuple, ReturnType_t>())
+	class_<CFunction, bases<CPointer>, boost::noncopyable >("Function", init<unsigned long, Convention_t, tuple, ReturnType_t>())
 		.def("__call__",
 			raw_method(&CFunction::Call),
 			"Calls the function dynamically."
@@ -469,7 +478,7 @@ void export_dynamichooks()
 
 		// Properties
 		.add_property("esp",
-			&CStackData::GetESP,
+			make_function(&CStackData::GetESP, manage_new_object_policy()),
 			"Stack pointer register."
 		)
 	;
@@ -480,7 +489,7 @@ void export_dynamichooks()
 //-----------------------------------------------------------------------------
 void export_callbacks()
 {
-    class_< CCallback, bases< CFunction > >("Callback", init< object, Convention_t, tuple, ReturnType_t >())
+	class_< CCallback, bases< CFunction >, boost::noncopyable >("Callback", init< object, Convention_t, tuple, ReturnType_t >())
         .def_readwrite("callback",
             &CCallback::m_oCallback,
             "The Python function that gets called by the C++ callback"
@@ -490,14 +499,15 @@ void export_callbacks()
 
 
 //-----------------------------------------------------------------------------
-// Exposes wrap/get_address/TYPE_SIZES functionality
+// Exposes wrap/get_pointer/TYPE_SIZES functionality
 //-----------------------------------------------------------------------------
 // Use this macro to add the ability to get the address of an object
-#define GET_ADDRESS(type) \
-	def("get_address", \
-		&GetAddress<type>, \
+#define GET_POINTER(type) \
+	def("get_pointer", \
+		&GetPointer<type>, \
 		"Returns the memory address of the given object.", \
-		args("object") \
+		args("object"), \
+		manage_new_object_policy() \
 	);
 
 // Use this macro to add the ability to get the size of an object
@@ -515,7 +525,7 @@ void export_callbacks()
 
 // Use this macro to call the three macros all at once
 #define ADD_ALL(type) \
-	GET_ADDRESS(type) \
+	GET_POINTER(type) \
 	WRAP_POINTER(type) \
 	ADD_SIZE(type)
 
diff --git a/src/core/utility/call_python.h b/src/core/utility/call_python.h
@@ -56,8 +56,23 @@ using namespace boost::python;
 // ----------------------------------------------------------------------------
 // Python Logging functions
 // ----------------------------------------------------------------------------
-inline void PythonLog( const char* szLevel, const char* szMessage )
+/*
+    (-1) message (should always be printed)
+    (0)  critical
+    (1)  exception
+    (2)  warning
+    (3)  info
+    (4)  debug
+*/
+inline void PythonLog( const char* szLevel, const char* szFormat, ... )
 {
+	// Format the message
+	char szMessage[2048];
+	va_list args;
+	va_start(args, szFormat);
+	vsprintf(szMessage, szFormat, args);
+	va_end(args);
+
 	// Get the std::string instance of szMessage
 	std::string szMethod = szLevel;
 
@@ -70,7 +85,7 @@ inline void PythonLog( const char* szLevel, const char* szMessage )
 		object oLogModule = import("loggers");
 
 		// Get the SPLogger instance
-		object oLogger = oLogModule.attr("SPLogger");
+		object oLogger = oLogModule.attr("_SPLogger");
 
 		// Get the PyObject instance of the SPLogger
 		PyObject* poLogger = oLogger.ptr();
@@ -81,15 +96,22 @@ inline void PythonLog( const char* szLevel, const char* szMessage )
 	END_BOOST_PY()
 }
 
-inline void PythonLog( int iLevel, const char* szMessage )
+inline void PythonLog( int iLevel, const char* szFormat, ... )
 {
+	// Format the message
+	char szMessage[2048];
+	va_list args;
+	va_start(args, szFormat);
+	vsprintf(szMessage, szFormat, args);
+	va_end(args);
+
 	BEGIN_BOOST_PY()
 
 		// Import the loggers module
 		object oLogModule = import("loggers");
 
 		// Get the SPLogger instance
-		object oLogger = oLogModule.attr("SPLogger");
+		object oLogger = oLogModule.attr("_SPLogger");
 
 		// Get the PyObject instance of the SPLogger
 		PyObject* poLogger = oLogger.ptr();

Original file line number	Diff line number	Diff line change
`@@ -979,7 +979,7 @@ bool CGameTrace::DidHitWorld() const`
`979`	`979`	`int CGameTrace::GetEntityIndex() const`
`980`	`980`	`{`
`981`	`981`	`// TODO: Use a more efficient way`
`982`		`- return m_pEnt ? IndexFromPointer(object(CPointer((unsigned long) m_pEnt))) : -1;`
	`982`	`+ return m_pEnt ? IndexFromPointer(object(ptr(new CPointer((unsigned long) m_pEnt)))) : -1;`
`983`	`983`	`}`
`984`	`984`
`985`	`985`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,7 @@ class CCallback: public CFunction`
`68`	`68`	`{`
`69`	`69`	`public:`
`70`	`70`	`CCallback(object oCallback, Convention_t eConv, tuple args, ReturnType_t return_type);`
	`71`	`+ virtual ~CCallback();`
`71`	`72`
`72`	`73`	`int GetPopSize();`
`73`	`74`	`int GetArgumentOffset(int iIndex);`