Flummi/amxmodx
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

added SinglePlugin forwards

Browse Source
This commit is contained in:
Pavol Marko 2004-05-05 18:42:16 +00:00
parent 7c4324b963
commit e9e4b380cb
2 changed files with 296 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

232
amxmodx/CForward.cpp
View File

@ -53,14 +53,14 @@ CForward::CForward(const char *name, ForwardExecType et, int numParams, const Fo
}
}
int CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
{
cell realParams[FORWARD_MAX_PARAMS];
cell *physAddrs[FORWARD_MAX_PARAMS];
const int STRINGEX_MAXLENGTH = 128;
int globRetVal = 0;
cell globRetVal = 0;
for (CList<AMXForward>::iterator iter = m_Funcs.begin(); iter; ++iter)
{
@ -159,28 +159,179 @@ int CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
return globRetVal;
}
void CSPForward::Set(int func, AMX *amx, int numParams, const ForwardParam *paramTypes)
{
m_Func = func;
m_Amx = amx;
m_NumParams = numParams;
memcpy((void *)m_ParamTypes, paramTypes, numParams * sizeof(ForwardParam));
m_HasFunc = true;
}
void CSPForward::Set(const char *funcName, AMX *amx, int numParams, const ForwardParam *paramTypes)
{
m_Amx = amx;
m_NumParams = numParams;
memcpy((void *)m_ParamTypes, paramTypes, numParams * sizeof(ForwardParam));
m_HasFunc = (amx_FindPublic(amx, funcName, &m_Func) == AMX_ERR_NONE);
}
cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
{
const int STRINGEX_MAXLENGTH = 128;
cell realParams[FORWARD_MAX_PARAMS];
cell *physAddrs[FORWARD_MAX_PARAMS];
if (!m_HasFunc)
return 0;
CPluginMngr::CPlugin *pPlugin = g_plugins.findPluginFast(m_Amx);
if (!pPlugin->isExecutable(m_Func))
return 0;
// handle strings & arrays
int i;
for (i = 0; i < m_NumParams; ++i)
{
if (m_ParamTypes[i] == FP_STRING || m_ParamTypes[i] == FP_STRINGEX)
{
cell *tmp;
amx_Allot(m_Amx,
(m_ParamTypes[i] == FP_STRING) ? strlen(reinterpret_cast<const char*>(params[i]))+1 : STRINGEX_MAXLENGTH,
&realParams[i], &tmp);
amx_SetString(tmp, (const char *)(params[i]), 0, 0);
physAddrs[i] = tmp;
}
else if (m_ParamTypes[i] == FP_ARRAY)
{
cell *tmp;
amx_Allot(m_Amx, preparedArrays[params[i]].size,
&realParams[i], &tmp);
physAddrs[i] = tmp;
if (preparedArrays[params[i]].type == Type_Cell)
{
memcpy(tmp, preparedArrays[params[i]].ptr, preparedArrays[params[i]].size * sizeof(cell));
}
else
{
char *data = (char*)preparedArrays[params[i]].ptr;
for (unsigned int j = 0; j < preparedArrays[params[i]].size; ++j)
*tmp++ = (static_cast<cell>(*data++)) & 0xFF;
}
}
else
{
realParams[i] = params[i];
}
}
// exec
cell retVal;
amx_Execv(m_Amx, &retVal, m_Func, m_NumParams, realParams);
// cleanup strings & arrays
for (i = 0; i < m_NumParams; ++i)
{
if (m_ParamTypes[i] == FP_STRING)
{
amx_Release(m_Amx, realParams[i]);
}
else if (m_ParamTypes[i] == FP_STRINGEX)
{
// copy back
amx_GetString(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
amx_Release(m_Amx, realParams[i]);
}
else if (m_ParamTypes[i] == FP_ARRAY)
{
// copy back
cell *tmp = physAddrs[i];
if (preparedArrays[params[i]].type == Type_Cell)
{
memcpy(preparedArrays[params[i]].ptr, tmp, preparedArrays[params[i]].size * sizeof(cell));
}
else
{
char *data = (char*)preparedArrays[params[i]].ptr;
for (unsigned int j = 0; j < preparedArrays[params[i]].size; ++j)
*data++ = static_cast<char>(*tmp++ & 0xFF);
}
amx_Release(m_Amx, realParams[i]);
}
}
return retVal;
}
int CForwardMngr::registerForward(const char *funcName, ForwardExecType et, int numParams, const ForwardParam * paramTypes)
{
int retVal = m_Forwards.size();
int retVal = m_Forwards.size() << 1;
m_Forwards.push_back(new CForward(funcName, et, numParams, paramTypes));
return retVal;
}
int CForwardMngr::registerSPForward(int func, AMX *amx, int numParams, const ForwardParam *paramTypes)
{
int retVal = (m_SPForwards.size() << 1) | 1;
CSPForward *pForward;
if (m_FreeSPForwards.size())
{
pForward = m_SPForwards[m_FreeSPForwards.back()];
m_FreeSPForwards.pop_back();
pForward->Set(func, amx, numParams, paramTypes);
}
else
{
pForward = new CSPForward();
if (!pForward)
return -1;
pForward->Set(func, amx, numParams, paramTypes);
m_SPForwards.push_back(pForward);
}
return retVal;
}
int CForwardMngr::registerSPForward(const char *funcName, AMX *amx, int numParams, const ForwardParam *paramTypes)
{
int retVal = (m_SPForwards.size() << 1) | 1;
CSPForward *pForward;
if (m_FreeSPForwards.size())
{
pForward = m_SPForwards[m_FreeSPForwards.back()];
m_FreeSPForwards.pop_back();
pForward->Set(funcName, amx, numParams, paramTypes);
}
else
{
pForward = new CSPForward();
if (!pForward)
return -1;
pForward->Set(funcName, amx, numParams, paramTypes);
m_SPForwards.push_back(pForward);
}
return retVal;
}
bool CForwardMngr::isIdValid(int id) const
{
return (id >= 0) && (static_cast<size_t>(id) < m_Forwards.size());
return (id >= 0) && ((id & 1) ?
(static_cast<size_t>(id >> 1) < m_SPForwards.size()) :
(static_cast<size_t>(id >> 1) < m_Forwards.size()));
}
int CForwardMngr::executeForwards(int id, cell *params)
cell CForwardMngr::executeForwards(int id, cell *params)
{
int retVal = m_Forwards[id]->execute(params, m_TmpArrays);
int retVal = (id & 1) ? m_SPForwards[id >> 1]->execute(params, m_TmpArrays) :
m_Forwards[id >> 1]->execute(params, m_TmpArrays);
m_TmpArraysNum = 0;
return retVal;
}
int CForwardMngr::getParamsNum(int id) const
{
return m_Forwards[id]->getParamsNum();
return (id & 1) ? m_SPForwards[id >> 1]->getParamsNum() :
m_Forwards[id >> 1]->getParamsNum();
}
void CForwardMngr::clear()
@ -189,10 +340,28 @@ void CForwardMngr::clear()
{
delete (*iter);
}
SPForwardVec::iterator spIter;
for (spIter = m_SPForwards.begin(); spIter != m_SPForwards.end(); ++spIter)
{
delete (*spIter);
}
m_Forwards.clear();
m_SPForwards.clear();
m_FreeSPForwards.clear();
m_TmpArraysNum = 0;
}
bool CForwardMngr::isSPForward(int id) const
{
return ((id & 1) == 0) ? false : true;
}
void CForwardMngr::unregisterSPForward(int id)
{
m_FreeSPForwards.push_back(id);
}
int registerForward(const char *funcName, ForwardExecType et, ...)
{
int curParam = 0;
@ -214,7 +383,49 @@ int registerForward(const char *funcName, ForwardExecType et, ...)
return g_forwards.registerForward(funcName, et, curParam, params);
}
int executeForwards(int id, ...)
int registerSPForwardByName(AMX *amx, const char *funcName, ...)
{
int curParam = 0;
va_list argptr;
va_start(argptr, funcName);
ForwardParam params[FORWARD_MAX_PARAMS];
ForwardParam tmp;
while (true)
{
if (curParam == FORWARD_MAX_PARAMS)
break;
tmp = (ForwardParam)va_arg(argptr, int);
if (tmp == FP_DONE)
break;
params[curParam] = tmp;
++curParam;
}
va_end(argptr);
return g_forwards.registerSPForward(funcName, amx, curParam, params);
}
int registerSPForward(AMX *amx, int func, ...)
{
int curParam = 0;
va_list argptr;
va_start(argptr, func);
ForwardParam params[FORWARD_MAX_PARAMS];
ForwardParam tmp;
while (true)
{
if (curParam == FORWARD_MAX_PARAMS)
break;
tmp = (ForwardParam)va_arg(argptr, int);
if (tmp == FP_DONE)
break;
params[curParam] = tmp;
++curParam;
}
va_end(argptr);
return g_forwards.registerSPForward(func, amx, curParam, params);
}
cell executeForwards(int id, ...)
{
if (!g_forwards.isIdValid(id))
return -1;
@ -253,3 +464,8 @@ cell prepareCharArray(char *ptr, unsigned int size)
{
return g_forwards.prepareArray((void*)ptr, size, Type_Char);
}
void unregisterSPForward(int id)
{
g_forwards.unregisterSPForward(id);
}

84
amxmodx/CForward.h
View File

@ -29,13 +29,23 @@
* version.
*/
/*
CForward.h
forwards
1) normal forwards: called in all plugins
2) single plugin (sp) forwards: called in one plugin
The SP Forwards are handled differently because they are expected to be created / deleted
often, but the "normal" forwards are expected to be initialized at start up.
Note about forward ids:
for normal forwards: <index to vector> << 1
for sp forwards: (<index to vector> << 1) | 1
*/
#ifndef FORWARD_H
#define FORWARD_H
// *****************************************************
// class CmdMngr
// *****************************************************
const int FORWARD_MAX_PARAMS = 16;
enum ForwardExecType
@ -57,6 +67,7 @@ enum ForwardParam
FP_ARRAY, // array; use the return value of prepareArray.
};
// for prepareArray
enum ForwardArrayElemType
{
Type_Cell = 0,
@ -65,12 +76,12 @@ enum ForwardArrayElemType
struct ForwardPreparedArray
{
void *ptr;
ForwardArrayElemType type;
unsigned int size;
};
// Normal forward
class CForward
{
const char *m_FuncName;
@ -88,17 +99,53 @@ public:
CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam * paramTypes);
CForward()
{ } // leaves everything unitialized
int execute(cell *params, ForwardPreparedArray *preparedArrays);
cell execute(cell *params, ForwardPreparedArray *preparedArrays);
int getParamsNum() const
{
return m_NumParams;
}
int getFuncsNum() const
{
return m_Funcs.size();
}
};
// Single plugin forward
class CSPForward
{
const char *m_FuncName;
int m_NumParams;
ForwardParam m_ParamTypes[FORWARD_MAX_PARAMS];
AMX *m_Amx;
int m_Func;
bool m_HasFunc;
public:
CSPForward() { m_HasFunc = false; }
void Set(const char *funcName, AMX *amx, int numParams, const ForwardParam * paramTypes);
void Set(int func, AMX *amx, int numParams, const ForwardParam * paramTypes);
cell execute(cell *params, ForwardPreparedArray *preparedArrays);
int getParamsNum() const
{
return m_NumParams;
}
int getFuncsNum() const
{
return (m_HasFunc) ? 1 : 0;
}
};
class CForwardMngr
{
typedef CVector<CForward*> ForwardVec;
typedef CVector<CSPForward*> SPForwardVec;
typedef CVector<int> FreeSPVec; // Free SP Forwards
ForwardVec m_Forwards;
SPForwardVec m_SPForwards;
FreeSPVec m_FreeSPForwards; // so we don't have to free memory
ForwardPreparedArray m_TmpArrays[FORWARD_MAX_PARAMS]; // used by prepareArray
int m_TmpArraysNum;
public:
@ -109,18 +156,31 @@ public:
{ }
// Interface
// Register normal forward
int registerForward(const char *funcName, ForwardExecType et, int numParams, const ForwardParam *paramTypes);
int executeForwards(int id, cell *params);
// Register single plugin forward
int registerSPForward(const char *funcName, AMX *amx, int numParams, const ForwardParam * paramTypes);
int registerSPForward(int func, AMX *amx, int numParams, const ForwardParam * paramTypes);
// Unregister single plugin forward
void unregisterSPForward(int id);
// execute forward
cell executeForwards(int id, cell *params);
void clear(); // delete all forwards
bool isIdValid(int id) const;
int getParamsNum(int id) const;
cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type);
bool isIdValid(int id) const; // check whether forward id is valid
bool isSPForward(int id) const; // check whether forward is single plugin
int getParamsNum(int id) const; // get num of params of a forward
int getFuncsNum(int id) const; // get num of found functions of a forward
cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type); // prepare array
};
// register forward
// (un)register forward
int registerForward(const char *funcName, ForwardExecType et, ...);
int registerSPForwardByName(AMX *amx, const char *funcName, ...);
int registerSPForward(AMX *amx, int func, ...);
void unregisterSPForward(int id);
// execute forwards
int executeForwards(int id, ...);
cell executeForwards(int id, ...);
// prepare array
cell prepareCellArray(cell *ptr, unsigned int size);
cell prepareCharArray(char *ptr, unsigned int size);