Don't use std::list at all in DynamicHooks

Switch to amtl Vector.

DynamicHooks/convention.h

@@ -34,11 +34,8 @@
 // ============================================================================
 // >> INCLUDES
 // ============================================================================
-#include <list>
-#include <vector>
-#include <stdio.h>
-
 #include "registers.h"
+#include <am-vector.h>
 
 // ============================================================================
 // >> DataType_t
@@ -150,13 +147,13 @@ public:
 	@param <returnType>:
 	The return type of the function.
 	*/
-	ICallingConvention(std::vector<DataTypeSized_t> vecArgTypes, DataTypeSized_t returnType, int iAlignment=4)
+	ICallingConvention(ke::Vector<DataTypeSized_t> &vecArgTypes, DataTypeSized_t returnType, int iAlignment=4)
 	{
-		m_vecArgTypes = vecArgTypes;
+		m_vecArgTypes = ke::Move(vecArgTypes);
-		std::vector<DataTypeSized_t>::iterator it = m_vecArgTypes.begin();
+		
-		for (; it != m_vecArgTypes.end(); it++)
+		for (size_t i=0; i < m_vecArgTypes.length(); i++)
 		{
-			DataTypeSized_t &type = *it;
+			DataTypeSized_t &type = m_vecArgTypes[i];
 			if (!type.size)
 				type.size = GetDataTypeSize(type);
 		}
@@ -170,7 +167,7 @@ public:
 	This should return a list of Register_t values. These registers will be
 	saved for later access.
 	*/
-	virtual std::list<Register_t> GetRegisters() = 0;
+	virtual ke::Vector<Register_t> GetRegisters() = 0;
 
 	/*
 	Returns the number of bytes that should be added to the stack to clean up.
@@ -208,7 +205,7 @@ public:
 	virtual void ReturnPtrChanged(CRegisters* pRegisters, void* pReturnPtr) = 0;
 
 public:
-	std::vector<DataTypeSized_t> m_vecArgTypes;
+	ke::Vector<DataTypeSized_t> m_vecArgTypes;
 	DataTypeSized_t m_returnType;
 	int m_iAlignment;
 };

DynamicHooks/conventions/x86MsCdecl.cpp

@@ -38,7 +38,7 @@
 // ============================================================================
 // >> x86MsCdecl
 // ============================================================================
-x86MsCdecl::x86MsCdecl(std::vector<DataTypeSized_t> vecArgTypes, DataTypeSized_t returnType, int iAlignment) :
+x86MsCdecl::x86MsCdecl(ke::Vector<DataTypeSized_t> &vecArgTypes, DataTypeSized_t returnType, int iAlignment) :
 	ICallingConvention(vecArgTypes, returnType, iAlignment)
 {
 	if (m_returnType.size > 4)
@@ -59,22 +59,22 @@ x86MsCdecl::~x86MsCdecl()
 	}
 }
 
-std::list<Register_t> x86MsCdecl::GetRegisters()
+ke::Vector<Register_t> x86MsCdecl::GetRegisters()
 {
-	std::list<Register_t> registers;
+	ke::Vector<Register_t> registers;
 
-	registers.push_back(ESP);
+	registers.append(ESP);
 
 	if (m_returnType.type == DATA_TYPE_FLOAT || m_returnType.type == DATA_TYPE_DOUBLE)
 	{
-		registers.push_back(ST0);
+		registers.append(ST0);
 	}
 	else
 	{
-		registers.push_back(EAX);
+		registers.append(EAX);
 		if (m_pReturnBuffer)
 		{
-			registers.push_back(EDX);
+			registers.append(EDX);
 		}
 	}
 
@@ -90,7 +90,7 @@ int x86MsCdecl::GetArgStackSize()
 {
 	int iArgStackSize = 0;
 
-	for (unsigned int i = 0; i < m_vecArgTypes.size(); i++)
+	for (unsigned int i = 0; i < m_vecArgTypes.length(); i++)
 	{
 		iArgStackSize += m_vecArgTypes[i].size;
 	}

DynamicHooks/conventions/x86MsCdecl.h

@@ -63,10 +63,10 @@ Return values:
 class x86MsCdecl: public ICallingConvention
 {	
 public:
-	x86MsCdecl(std::vector<DataTypeSized_t> vecArgTypes, DataTypeSized_t returnType, int iAlignment=4);
+	x86MsCdecl(ke::Vector<DataTypeSized_t> &vecArgTypes, DataTypeSized_t returnType, int iAlignment=4);
 	~x86MsCdecl();
 
-	virtual std::list<Register_t> GetRegisters();
+	virtual ke::Vector<Register_t> GetRegisters();
 	virtual int GetPopSize();
 	virtual int GetArgStackSize();
 	virtual void** GetStackArgumentPtr(CRegisters* pRegisters);

DynamicHooks/conventions/x86MsStdcall.cpp

@@ -38,7 +38,7 @@
 // ============================================================================
 // >> x86MsStdcall
 // ============================================================================
-x86MsStdcall::x86MsStdcall(std::vector<DataTypeSized_t> vecArgTypes, DataTypeSized_t returnType, int iAlignment) :
+x86MsStdcall::x86MsStdcall(ke::Vector<DataTypeSized_t> &vecArgTypes, DataTypeSized_t returnType, int iAlignment) :
 	ICallingConvention(vecArgTypes, returnType, iAlignment)
 {
 	if (m_returnType.size > 4)
@@ -59,22 +59,22 @@ x86MsStdcall::~x86MsStdcall()
 	}
 }
 
-std::list<Register_t> x86MsStdcall::GetRegisters()
+ke::Vector<Register_t> x86MsStdcall::GetRegisters()
 {
-	std::list<Register_t> registers;
+	ke::Vector<Register_t> registers;
 
-	registers.push_back(ESP);
+	registers.append(ESP);
 
 	if (m_returnType.type == DATA_TYPE_FLOAT || m_returnType.type == DATA_TYPE_DOUBLE)
 	{
-		registers.push_back(ST0);
+		registers.append(ST0);
 	}
 	else
 	{
-		registers.push_back(EAX);
+		registers.append(EAX);
 		if (m_pReturnBuffer)
 		{
-			registers.push_back(EDX);
+			registers.append(EDX);
 		}
 	}
 
@@ -85,7 +85,7 @@ int x86MsStdcall::GetPopSize()
 {
 	int iPopSize = 0;
 
-	for(unsigned int i=0; i < m_vecArgTypes.size(); i++)
+	for(unsigned int i=0; i < m_vecArgTypes.length(); i++)
 	{
 		iPopSize += m_vecArgTypes[i].size;
 	}
@@ -97,7 +97,7 @@ int x86MsStdcall::GetArgStackSize()
 {
 	int iArgStackSize = 0;
 
-	for (unsigned int i = 0; i < m_vecArgTypes.size(); i++)
+	for (unsigned int i = 0; i < m_vecArgTypes.length(); i++)
 	{
 		iArgStackSize += m_vecArgTypes[i].size;
 	}

DynamicHooks/conventions/x86MsStdcall.h

@@ -63,10 +63,10 @@ Return values:
 class x86MsStdcall: public ICallingConvention
 {	
 public:
-	x86MsStdcall(std::vector<DataTypeSized_t> vecArgTypes, DataTypeSized_t returnType, int iAlignment=4);
+	x86MsStdcall(ke::Vector<DataTypeSized_t> &vecArgTypes, DataTypeSized_t returnType, int iAlignment=4);
 	~x86MsStdcall();
 
-	virtual std::list<Register_t> GetRegisters();
+	virtual ke::Vector<Register_t> GetRegisters();
 	virtual int GetPopSize();
 	virtual int GetArgStackSize();
 	virtual void** GetStackArgumentPtr(CRegisters* pRegisters);

DynamicHooks/conventions/x86MsThiscall.cpp

@@ -38,7 +38,7 @@
 // ============================================================================
 // >> x86MsThiscall
 // ============================================================================
-x86MsThiscall::x86MsThiscall(std::vector<DataTypeSized_t> vecArgTypes, DataTypeSized_t returnType, int iAlignment) :
+x86MsThiscall::x86MsThiscall(ke::Vector<DataTypeSized_t> &vecArgTypes, DataTypeSized_t returnType, int iAlignment) :
 	ICallingConvention(vecArgTypes, returnType, iAlignment)
 {
 	if (m_returnType.size > 4)
@@ -59,23 +59,23 @@ x86MsThiscall::~x86MsThiscall()
 	}
 }
 
-std::list<Register_t> x86MsThiscall::GetRegisters()
+ke::Vector<Register_t> x86MsThiscall::GetRegisters()
 {
-	std::list<Register_t> registers;
+	ke::Vector<Register_t> registers;
 	
-	registers.push_back(ESP);
+	registers.append(ESP);
-	registers.push_back(ECX);
+	registers.append(ECX);
 
 	if (m_returnType.type == DATA_TYPE_FLOAT || m_returnType.type == DATA_TYPE_DOUBLE)
 	{
-		registers.push_back(ST0);
+		registers.append(ST0);
 	}
 	else
 	{
-		registers.push_back(EAX);
+		registers.append(EAX);
 		if (m_pReturnBuffer)
 		{
-			registers.push_back(EDX);
+			registers.append(EDX);
 		}
 	}
 
@@ -89,7 +89,7 @@ int x86MsThiscall::GetPopSize()
 	//int iPopSize = GetDataTypeSize(DATA_TYPE_POINTER, m_iAlignment);
 	int iPopSize = 0;
 
-	for(unsigned int i=0; i < m_vecArgTypes.size(); i++)
+	for(unsigned int i=0; i < m_vecArgTypes.length(); i++)
 	{
 		iPopSize += m_vecArgTypes[i].size;
 	}
@@ -101,7 +101,7 @@ int x86MsThiscall::GetArgStackSize()
 {
 	int iArgStackSize = 0;
 
-	for (unsigned int i = 0; i < m_vecArgTypes.size(); i++)
+	for (unsigned int i = 0; i < m_vecArgTypes.length(); i++)
 	{
 		iArgStackSize += m_vecArgTypes[i].size;
 	}

DynamicHooks/conventions/x86MsThiscall.h

@@ -64,10 +64,10 @@ Return values:
 class x86MsThiscall: public ICallingConvention
 {	
 public:
-	x86MsThiscall(std::vector<DataTypeSized_t> vecArgTypes, DataTypeSized_t returnType, int iAlignment=4);
+	x86MsThiscall(ke::Vector<DataTypeSized_t> &vecArgTypes, DataTypeSized_t returnType, int iAlignment=4);
 	~x86MsThiscall();
 
-	virtual std::list<Register_t> GetRegisters();
+	virtual ke::Vector<Register_t> GetRegisters();
 	virtual int GetPopSize();
 	virtual int x86MsThiscall::GetArgStackSize();
 	virtual void** GetStackArgumentPtr(CRegisters* pRegisters);

DynamicHooks/hook.cpp

@@ -316,10 +316,10 @@ void CHook::Write_CallHandler(sp::MacroAssembler& masm, HookType_t type)
 
 void CHook::Write_SaveRegisters(sp::MacroAssembler& masm)
 {
-	std::list<Register_t> vecRegistersToSave = m_pCallingConvention->GetRegisters();
+	ke::Vector<Register_t> vecRegistersToSave = m_pCallingConvention->GetRegisters();
-	for(std::list<Register_t>::iterator it=vecRegistersToSave.begin(); it != vecRegistersToSave.end(); it++)
+	for(size_t i = 0; i < vecRegistersToSave.length(); i++)
 	{
-		switch(*it)
+		switch(vecRegistersToSave[i])
 		{
 		// ========================================================================
 		// >> 8-bit General purpose registers
@@ -378,10 +378,10 @@ void CHook::Write_SaveRegisters(sp::MacroAssembler& masm)
 
 void CHook::Write_RestoreRegisters(sp::MacroAssembler& masm)
 {
-	std::list<Register_t> vecRegistersToSave = m_pCallingConvention->GetRegisters();
+	ke::Vector<Register_t> vecRegistersToSave = m_pCallingConvention->GetRegisters();
-	for(std::list<Register_t>::iterator it=vecRegistersToSave.begin(); it != vecRegistersToSave.end(); it++)
+	for (size_t i = 0; i < vecRegistersToSave.length(); i++)
 	{
-		switch(*it)
+		switch (vecRegistersToSave[i])
 		{
 		// ========================================================================
 		// >> 8-bit General purpose registers

DynamicHooks/manager.cpp

@@ -50,17 +50,24 @@ CHook* CHookManager::HookFunction(void* pFunc, ICallingConvention* pConvention)
 	}
 	
 	pHook = new CHook(pFunc, pConvention);
-	m_Hooks.push_back(pHook);
+	m_Hooks.append(pHook);
 	return pHook;
 }
 
 void CHookManager::UnhookFunction(void* pFunc)
 {
-	CHook* pHook = FindHook(pFunc);
+	if (!pFunc)
-	if (pHook)
+		return;
+
+	for (size_t i = 0; i < m_Hooks.length(); i++)
 	{
-		m_Hooks.remove(pHook);
+		CHook* pHook = m_Hooks[i];
+		if (pHook->m_pFunc == pFunc)
+		{
+			m_Hooks.remove(i);
 			delete pHook;
+			return;
+		}
 	}
 }
 
@@ -69,9 +76,9 @@ CHook* CHookManager::FindHook(void* pFunc)
 	if (!pFunc)
 		return NULL;
 
-	for(std::list<CHook *>::iterator it=m_Hooks.begin(); it != m_Hooks.end(); it++)
+	for(size_t i = 0; i < m_Hooks.length(); i++)
 	{
-		CHook* pHook = *it;
+		CHook* pHook = m_Hooks[i];
 		if (pHook->m_pFunc == pFunc)
 			return pHook;
 	}
@@ -80,8 +87,8 @@ CHook* CHookManager::FindHook(void* pFunc)
 
 void CHookManager::UnhookAllFunctions()
 {
-	for(std::list<CHook *>::iterator it=m_Hooks.begin(); it != m_Hooks.end(); it++)
+	for(size_t i = 0; i < m_Hooks.length(); i++)
-		delete *it;
+		delete m_Hooks[i];
 
 	m_Hooks.clear();
 }

DynamicHooks/manager.h

@@ -34,9 +34,9 @@
 // ============================================================================
 // >> INCLUDES
 // ============================================================================
-#include <list>
 #include "hook.h"
 #include "convention.h"
+#include <am-vector.h>
 
 
 // ============================================================================
@@ -68,7 +68,7 @@ public:
 	void UnhookAllFunctions();
 
 public:
-	std::list<CHook *> m_Hooks;
+	ke::Vector<CHook *> m_Hooks;
 };
 
 

DynamicHooks/registers.cpp

@@ -30,7 +30,7 @@
 
 #include "registers.h"
 
-CRegisters::CRegisters(std::list<Register_t> registers)
+CRegisters::CRegisters(ke::Vector<Register_t> registers)
 {	
 	// ========================================================================
 	// >> 8-bit General purpose registers
@@ -360,11 +360,11 @@ CRegisters::~CRegisters()
 	DeleteRegister(m_st7);
 }
 
-CRegister* CRegisters::CreateRegister(std::list<Register_t>& registers, Register_t reg, int iSize)
+CRegister* CRegisters::CreateRegister(ke::Vector<Register_t>& registers, Register_t reg, int iSize)
 {
-	for(std::list<Register_t>::iterator it=registers.begin(); it != registers.end(); it++)
+	for(size_t i = 0; i < registers.length(); i++)
 	{
-		if ((*it) == reg)
+		if (registers[i] == reg)
 		{
 			return new CRegister(iSize);
 		}

DynamicHooks/registers.h

@@ -35,8 +35,7 @@
 // ============================================================================
 // >> INCLUDES
 // ============================================================================
-#include <stdlib.h>
+#include <am-vector.h>
-#include <list>
 
 
 // ============================================================================
@@ -261,11 +260,11 @@ public:
 class CRegisters
 {
 public:
-	CRegisters(std::list<Register_t> registers);
+	CRegisters(ke::Vector<Register_t> registers);
 	~CRegisters();
 
 private:
-	CRegister* CreateRegister(std::list<Register_t>& registers, Register_t reg, int iSize);
+	CRegister* CreateRegister(ke::Vector<Register_t>& registers, Register_t reg, int iSize);
 	void DeleteRegister(CRegister* pRegister);
 
 public:

dynhooks_sourcepawn.cpp

@@ -182,14 +182,14 @@ void CleanupDetours()
 
 ICallingConvention *ConstructCallingConvention(HookSetup *setup)
 {
-	std::vector<DataTypeSized_t> vecArgTypes;
+	ke::Vector<DataTypeSized_t> vecArgTypes;
 	for (size_t i = 0; i < setup->params.size(); i++)
 	{
 		ParamInfo &info = setup->params[i];
 		DataTypeSized_t type;
 		type.type = DynamicHooks_ConvertParamTypeFrom(info.type);
 		type.size = info.size;
-		vecArgTypes.push_back(type);
+		vecArgTypes.append(type);
 	}
 
 	DataTypeSized_t returnType;
@@ -235,7 +235,7 @@ bool HandleDetour(HookType_t hookType, CHook* pDetour)
 	HookParamsStruct *paramStruct = NULL;
 	Handle_t pHndl = BAD_HANDLE;
 
-	int argNum = pDetour->m_pCallingConvention->m_vecArgTypes.size();
+	int argNum = pDetour->m_pCallingConvention->m_vecArgTypes.length();
 	MRESReturn finalRet = MRES_Ignored;
 	ke::AutoPtr<void> finalRetBuf(new uint8_t[pDetour->m_pCallingConvention->m_returnType.size]);
 
@@ -338,8 +338,6 @@ bool HandleDetour(HookType_t hookType, CHook* pDetour)
 					break;
 				}
 			}
-			// TODO: Introduce that override concept in dyndetours.
-			// This doesn't call the original function at the moment, but just returns the given return value.
 			tempRet = MRES_Override;
 			pWrapper->UpdateParamsFromStruct(paramStruct);
 			break;
@@ -348,8 +346,6 @@ bool HandleDetour(HookType_t hookType, CHook* pDetour)
 			{
 				if (returnStruct->isChanged)
 				{
-					// TODO: Introduce that override concept in dyndetours.
-					// This doesn't call the original function at the moment, but just returns the given return value.
 					tempRet = MRES_Override;
 					if (pWrapper->returnType == ReturnType_String || pWrapper->returnType == ReturnType_Int || pWrapper->returnType == ReturnType_Bool)
 					{
@@ -429,6 +425,7 @@ bool HandleDetour(HookType_t hookType, CHook* pDetour)
 		}
 	}
 
+	// If we want to use our own return value, write it back.
 	if (finalRet >= MRES_Override)
 	{
 		void* pPtr = pDetour->m_pCallingConvention->GetReturnPtr(pDetour->m_pRegisters);
@@ -540,8 +537,8 @@ HookParamsStruct *CDynamicHooksSourcePawn::GetParamStruct()
 	params->dg = this;
 	
 	size_t paramsSize = this->m_pDetour->m_pCallingConvention->GetArgStackSize();
-	std::vector<DataTypeSized_t> &argTypes = m_pDetour->m_pCallingConvention->m_vecArgTypes;
+	ke::Vector<DataTypeSized_t> &argTypes = m_pDetour->m_pCallingConvention->m_vecArgTypes;
-	int numArgs = argTypes.size();
+	int numArgs = argTypes.length();
 
 	params->orgParams = (void **)malloc(paramsSize);
 	params->newParams = (void **)malloc(paramsSize);
@@ -568,8 +565,8 @@ void CDynamicHooksSourcePawn::UpdateParamsFromStruct(HookParamsStruct *params)
 	if (!params)
 		return;
 
-	std::vector<DataTypeSized_t> &argTypes = m_pDetour->m_pCallingConvention->m_vecArgTypes;
+	ke::Vector<DataTypeSized_t> &argTypes = m_pDetour->m_pCallingConvention->m_vecArgTypes;
-	int numArgs = argTypes.size();
+	int numArgs = argTypes.length();
 
 	int firstArg = 0;
 	if (callConv == CallConv_THISCALL)