sourcemod/extensions/sdktools/vcallbuilder.cpp

#include "vcallbuilder.h"
#include "extension.h"

ValveCall::~ValveCall()
{
	while (!stk.empty())
	{
		unsigned char *ptr = stk.front();
		delete [] ptr;
		stk.pop();
	}
	call->Destroy();
	delete [] retbuf;
	delete [] vparams;
}

unsigned char *ValveCall::stk_get()
{
	unsigned char *ptr;
	if (stk.empty())
	{
		ptr = new unsigned char[stackSize];
	} else {
		ptr = stk.front();
		stk.pop();
	}
	return ptr;
}

void ValveCall::stk_put(unsigned char *ptr)
{
	stk.push(ptr);
}

ValveCall *CreateValveVCall(unsigned int vtableIdx,
							ValveCallType vcalltype,
							const ValvePassInfo *retInfo,
							const ValvePassInfo *params,
							unsigned int numParams)
{
	if (numParams > 32)
	{
		return NULL;
	}

	ValveCall *vc = new ValveCall;

	size_t size = 0;
	vc->stackSize = 0;

	/* Get return information - encode only*/
	PassInfo retBuf;
	size_t retBufSize = 0;
	if (retInfo)
	{
		if ((size = ValveParamToBinParam(retInfo->vtype, retInfo->type, retInfo->flags, &retBuf)) == 0)
		{
			delete vc;
			return NULL;
		}
		retBufSize = size;
	}

	/* Get parameter info */
	PassInfo paramBuf[32];
	for (unsigned int i=0; i<numParams; i++)
	{
		if ((size = ValveParamToBinParam(params[i].vtype, params[i].type, params[i].flags, &paramBuf[i])) == 0)
		{
			delete vc;
			return NULL;
		}
		vc->stackSize += size;
	}

	/* Now we can try creating the call */
	if ((vc->call = g_pBinTools->CreateVCall(vtableIdx, 
		0, 
		0, 
		(retInfo ? &retBuf : NULL),
		paramBuf,
		numParams))
		== NULL)
	{
		if (!vc->call)
		{
			delete vc;
			return NULL;
		}
	}

	/* Allocate extra space for thisptr AND ret buffer, even if we don't use it */
	vc->vparams = new ValvePassInfo[numParams + 2];

	/* We've got the call and everything is encoded.
	 * It's time to save the valve specific information and helper variables.
	 */
	if (retInfo)
	{
		/* Allocate and copy */
		vc->retinfo = &(vc->vparams[numParams]);
		*vc->retinfo = *retInfo;
		vc->retinfo->offset = 0;
		/* Allocate stack space */
		vc->retbuf = new unsigned char[retBufSize];
	} else {
		vc->retinfo = NULL;
		vc->retbuf = NULL;
	}

	/* Save the this info for the dynamic decoder */
	vc->thisinfo = &(vc->vparams[numParams + 1]);
	vc->thisinfo->type = PassType_Basic;
	if (vcalltype == ValveCall_Entity)
	{
		vc->thisinfo->vtype = Valve_CBaseEntity;
		vc->thisinfo->decflags |= VDECODE_FLAG_ALLOWWORLD;
	} else if (vcalltype == ValveCall_Player) {
		vc->thisinfo->vtype = Valve_CBasePlayer;
		vc->thisinfo->decflags = 0;
	}
	vc->thisinfo->encflags = 0;
	vc->thisinfo->flags = PASSFLAG_BYVAL;
	vc->thisinfo->offset = 0;
	vc->stackSize += sizeof(void *);

	/* Now, save info about each parameter. */
	for (unsigned int i=0; i<numParams; i++)
	{
		/* Copy */
		vc->vparams[i] = params[i];
		vc->vparams[i].offset = vc->call->GetParamInfo(i)->offset;
	}

	return vc;
}