/**

  * vim: set ts=4 :

  * =============================================================================

  * SourceMod BinTools Extension

  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

  * =============================================================================

  *

  * This program is free software; you can redistribute it and/or modify it under

  * the terms of the GNU General Public License, version 3.0, as published by the

  * Free Software Foundation.

  * 

  * This program is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

  * details.

  *

  * You should have received a copy of the GNU General Public License along with

  * this program.  If not, see <http://www.gnu.org/licenses/>.

  *

  * As a special exception, AlliedModders LLC gives you permission to link the

  * code of this program (as well as its derivative works) to "Half-Life 2," the

  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

  * by the Valve Corporation.  You must obey the GNU General Public License in

  * all respects for all other code used.  Additionally, AlliedModders LLC grants

  * this exception to all derivative works.  AlliedModders LLC defines further

  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

  * or <http://www.sourcemod.net/license.php>.

  *

  * Version: $Id: CallMaker.h 1964 2008-03-27 04:54:56Z damagedsoul $

  */

 #if defined HOOKING_ENABLED

 #include "HookWrapper.h"

 #include "jit_compile.h"

 /******************************

  * HookWrapper Implementation *

  ******************************/

 HookWrapper::HookWrapper(SourceHook::ISourceHook *pSH, 

 						 const SourceHook::ProtoInfo *proto, 

 						 SourceHook::MemFuncInfo *memfunc, 

 						 void *addr) : m_ParamOffs(NULL), m_ParamSize(0), m_RetSize(0)

 {

 	unsigned int argnum = proto->numOfParams;

 	m_pSH = pSH;

 	m_ProtoInfo = *proto;

 	m_ProtoInfo.paramsPassInfo = new SourceHook::PassInfo[argnum + 1];

 	memcpy((void *)m_ProtoInfo.paramsPassInfo, proto->paramsPassInfo, sizeof(SourceHook::PassInfo) * (argnum+1));

 	m_MemFuncInfo = *memfunc;

 	m_FuncAddr = addr;

 	m_HookWrapper = NULL;

 	/* If the function has parameters calculate the parameter buffer size and offsets */

 	if (argnum > 0)

 	{

 		const SourceHook::PassInfo *info = m_ProtoInfo.paramsPassInfo;

 		m_ParamOffs = new unsigned int[argnum];

 		m_ParamOffs[0] = 0;

 		for (unsigned int i=1; i<=argnum; i++)

 		{

 			/* The stack should be at least aligned to a 4 byte boundary 

 			* and byref params have the size of pointers 

 			*/

 			if (((info[i].type == SourceHook::PassInfo::PassType_Basic) &&

 				(info[i].flags & SourceHook::PassInfo::PassFlag_ByVal) && 

 				(info[i].size < sizeof(void *))) ||

 				(info[i].flags & SourceHook::PassInfo::PassFlag_ByRef))

 			{

 				m_ParamSize += sizeof(void *);

 			}

 			else

 			{

 				m_ParamSize += info[i].size;

 			}

 			//:TODO: fix this!

 			if (i < argnum)

 			{

 				m_ParamOffs[i] = m_ParamSize;

 			}

 		}

 	}

 	/* Finally calculate the retval size if any */

 	size_t retsize = m_ProtoInfo.retPassInfo.size;

 	if (retsize != 0)

 	{

 		if (m_ProtoInfo.retPassInfo.flags & SourceHook::PassInfo::PassFlag_ByRef)

 		{

 			m_RetSize = sizeof(void *);

 		}

 		else

 		{

 			m_RetSize = (retsize < sizeof(void *)) ? sizeof(void *) : retsize;

 		}

 	}

 }

 ISMDelegate *HookWrapper::CreateDelegate(void *data)

 {

 	SMDelegate *pDeleg = new SMDelegate(data);

 	pDeleg->PatchVtable(m_HookWrapper);

 	return pDeleg;

 }

 unsigned int HookWrapper::GetParamCount()

 {

 	return m_ProtoInfo.numOfParams;

 }

 unsigned int HookWrapper::GetParamOffset(unsigned int argnum, unsigned int *size)

 {

 	assert(m_ParamOffs && argnum < (unsigned int)m_ProtoInfo.numOfParams);

 	if (size)

 	{

 		*size = m_ProtoInfo.paramsPassInfo[argnum+1].size;

 	}

 	return m_ParamOffs[argnum];

 }

 void HookWrapper::PerformRecall(void *params, void *retval)

 {

 	/* Notify SourceHook of the upcoming recall */

 	SH_GLOB_SHPTR->DoRecall();

 	/* Add thisptr into params buffer */

 	unsigned char *newparams = new unsigned char[sizeof(void *) + m_ParamSize];

 	*(void **)newparams = META_IFACEPTR(void);

 	memcpy(newparams + sizeof(void *), params, m_ParamSize);

 	/* Execute the call */

 	m_CallWrapper->Execute(newparams, retval);

 	SET_META_RESULT(MRES_SUPERCEDE);

 	return;

 }

 void HookWrapper::Destroy()

 {

 	if (m_HookWrapper != NULL)

 	{

 		JIT_FreeHook(m_HookWrapper);

 	}

 	if (m_CallWrapper != NULL)

 	{

 		m_CallWrapper->Destroy();

 	}

 	delete this;

 }

 unsigned int HookWrapper::GetParamSize()

 {

 	return m_ParamSize;

 }

 SourceHook::ProtoInfo * HookWrapper::GetProtoInfo()

 {

 	return &m_ProtoInfo;

 }

 unsigned int HookWrapper::GetRetSize()

 {

 	return m_RetSize;

 }

 void * HookWrapper::GetHandlerAddr()

 {

 	return m_FuncAddr;

 }

 void HookWrapper::SetCallWrapperAddr( ICallWrapper *wrap )

 {

 	m_CallWrapper = wrap;

 }

 void HookWrapper::SetHookWrpAddr( void *addr )

 {

 	m_HookWrapper = addr;

 }

 HookWrapper::~HookWrapper()

 {

 	delete [] m_ProtoInfo.paramsPassInfo;

 	delete [] m_ParamOffs;

 }

 /*****************************

  * SMDelegate Implementation *

  *****************************/

 SMDelegate::SMDelegate(void *data)

 {

 	m_Data = data;

 }

 bool SMDelegate::IsEqual(ISHDelegate *pOtherDeleg)

 {

 	return false;

 }

 void SMDelegate::DeleteThis()

 {

 	/* Remove our allocated vtable */

 	delete [] *reinterpret_cast<void ***>(this);

 	delete this;

 }

 void SMDelegate::Call()

 {

 }

 void *SMDelegate::GetUserData()

 {

 	return m_Data;

 }

 /** 

  * This duplicates the vtable (so each instance has a unique table) and patches SMDelgate::Call to point to our allocated function 

  */

 void SMDelegate::PatchVtable(void *addr)

 {

 	void **new_vtptr = new void *[4];

 	void **cur_vtptr = *reinterpret_cast<void ***>(this);

 	memcpy(new_vtptr, cur_vtptr, sizeof(void *)*4);

 	*reinterpret_cast<void ***>(this) = new_vtptr;

 	void *cur_vfnptr = reinterpret_cast<void *>(new_vtptr + VTABLE_PATCH_OFFS);

 	*reinterpret_cast<void **>(cur_vfnptr) = addr;

 }

 #endif