/**

 * 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$

 */

#include "extension.h"

#include "CallWrapper.h"

#include "CallMaker.h"

CallWrapper::CallWrapper(const SourceHook::ProtoInfo *protoInfo)

{

	m_AddrCodeBase = NULL;

	m_AddrCallee = NULL;

	unsigned int argnum = protoInfo->numOfParams;

	m_Info = *protoInfo;

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

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

	if (argnum)

	{

		m_Params = new PassEncode[argnum];

		for (size_t i=0; i<argnum; i++)

		{

			GetSMPassInfo(&(m_Params[i].info), &(m_Info.paramsPassInfo[i+1]));

		}

	} else {

		m_Params = NULL;

	}

	if (m_Info.retPassInfo.size != 0)

	{

		m_RetParam = new PassInfo;

		GetSMPassInfo(m_RetParam, &(m_Info.retPassInfo));

	} else {

		m_RetParam = NULL;

	}

	/* Calculate virtual stack offsets for each parameter */

	size_t offs = 0;

	if (m_Info.convention == SourceHook::ProtoInfo::CallConv_ThisCall)

	{

		offs += sizeof(void *);

	}

	for (size_t i=0; i<argnum; i++)

	{

		m_Params[i].offset = offs;

		offs += m_Params[i].info.size;

	}

}

CallWrapper::~CallWrapper()

{

	delete [] m_Params;

	delete m_RetParam;

	delete [] m_Info.paramsPassInfo;

}

void CallWrapper::Destroy()

{

	if (m_AddrCodeBase != NULL)

	{

		g_SPEngine->FreePageMemory(m_AddrCodeBase);

		m_AddrCodeBase = NULL;

	}

	delete this;

}

CallConvention CallWrapper::GetCallConvention()

{

	/* Need to convert to a SourceMod convention for bcompat */

	return GetSMCallConvention((SourceHook::ProtoInfo::CallConvention)m_Info.convention);

}

const PassEncode *CallWrapper::GetParamInfo(unsigned int num)

{

	if (num + 1 > GetParamCount() || num < 0)

	{

		return NULL;

	}

	return &m_Params[num];

}

const PassInfo *CallWrapper::GetReturnInfo()

{

	return m_RetParam;

}

unsigned int CallWrapper::GetParamCount()

{

	return m_Info.numOfParams;

}

void CallWrapper::Execute(void *vParamStack, void *retBuffer)

{

	typedef void (*CALL_EXECUTE)(void *, void *);

	CALL_EXECUTE fn = (CALL_EXECUTE)GetCodeBaseAddr();

	fn(vParamStack, retBuffer);

}

void CallWrapper::SetMemFuncInfo(const SourceHook::MemFuncInfo *funcInfo)

{

	m_FuncInfo = *funcInfo;

}

SourceHook::MemFuncInfo *CallWrapper::GetMemFuncInfo()

{

	return &m_FuncInfo;

}

void CallWrapper::SetCalleeAddr(void *addr)

{

	m_AddrCallee = addr;

}

void CallWrapper::SetCodeBaseAddr(void *addr)

{

	m_AddrCodeBase = addr;

}

void *CallWrapper::GetCalleeAddr()

{

	return m_AddrCallee;

}

void *CallWrapper::GetCodeBaseAddr()

{

	return m_AddrCodeBase;

}

const SourceHook::PassInfo *CallWrapper::GetSHReturnInfo()

{

	return &(m_Info.retPassInfo);

}

SourceHook::ProtoInfo::CallConvention CallWrapper::GetSHCallConvention()

{

	return (SourceHook::ProtoInfo::CallConvention)m_Info.convention;

}

const SourceHook::PassInfo * CallWrapper::GetSHParamInfo(unsigned int num)

{

	if (num + 1 > GetParamCount() || num < 0)

	{

		return NULL;

	}

	return &(m_Info.paramsPassInfo[num+1]);

}

unsigned int CallWrapper::GetParamOffset(unsigned int num)

{

	assert(num <= GetParamCount() && num > 0);

	return m_Params[num].offset;

}