1 Commits

Author SHA1 Message Date
a59c659d47 Tagged 0.15 2006-07-20 05:53:18 +00:00
622 changed files with 13802 additions and 203230 deletions

View File

@ -29,7 +29,9 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CCmd.h" #include "CCmd.h"
// ***************************************************** // *****************************************************
@ -56,8 +58,8 @@ CmdMngr::Command::Command( CPluginMngr::CPlugin* pplugin,const char* pcmd,
char szCmd[64], szArg[64]; char szCmd[64], szArg[64];
*szCmd = 0; *szArg=0; *szCmd = 0; *szArg=0;
sscanf(pcmd,"%s %s",szCmd,szArg); sscanf(pcmd,"%s %s",szCmd,szArg);
command.assign(szCmd); command.set(szCmd);
argument.assign(szArg); argument.set(szArg);
plugin = pplugin; plugin = pplugin;
flags = pflags; flags = pflags;
cmdtype = 0; cmdtype = 0;
@ -238,7 +240,7 @@ void CmdMngr::registerPrefix( const char* nn )
CmdMngr::CmdPrefix** CmdMngr::findPrefix( const char* nn ){ CmdMngr::CmdPrefix** CmdMngr::findPrefix( const char* nn ){
CmdPrefix** aa = &prefixHead; CmdPrefix** aa = &prefixHead;
while(*aa){ while(*aa){
if ( !strncmp( (*aa)->name.c_str(), nn, (*aa)->name.size() ) ) if ( !strncmp( (*aa)->name.str(), nn, (*aa)->name.size() ) )
break; break;
aa=&(*aa)->next; aa=&(*aa)->next;
} }

View File

@ -67,12 +67,12 @@ public:
~Command(); ~Command();
public: public:
inline const char* getCommand() { return command.c_str(); } inline const char* getCommand() const{ return command.str(); }
inline const char* getArgument() { return argument.c_str(); } inline const char* getArgument() const{ return argument.str(); }
inline const char* getCmdInfo() { return info.c_str(); } inline const char* getCmdInfo() const{ return info.str(); }
inline const char* getCmdLine() { return commandline.c_str(); } inline const char* getCmdLine() const{ return commandline.str(); }
inline bool matchCommandLine(const char* cmd, const char* arg) { return (!stricmp(command.c_str()+prefix, cmd+prefix ) && (argument.empty() || !stricmp(argument.c_str() , arg ))); } inline bool matchCommandLine(const char* cmd, const char* arg) { return (!stricmp(command.str()+prefix, cmd+prefix ) && (argument.empty() || !stricmp(argument.str() , arg ))); }
inline bool matchCommand(const char* cmd) { return (!strcmp(command.c_str(), cmd )); } inline bool matchCommand(const char* cmd) { return (!strcmp(command.str(), cmd )); }
inline int getFunction() const { return function; } inline int getFunction() const { return function; }
inline bool gotAccess(int f) const { return (!flags||((flags & f)==flags)); } inline bool gotAccess(int f) const { return (!flags||((flags & f)==flags)); }
inline CPluginMngr::CPlugin* getPlugin() { return plugin; } inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
@ -100,8 +100,8 @@ private:
CmdLink* clcmdlist; CmdLink* clcmdlist;
struct CmdPrefix { struct CmdPrefix {
String name;
CmdMngr* parent; CmdMngr* parent;
String name;
CmdLink* list; CmdLink* list;
CmdPrefix* next; CmdPrefix* next;
CmdPrefix( const char* nn , CmdMngr* pp) : name(nn),parent(pp),list(0),next(0){} CmdPrefix( const char* nn , CmdMngr* pp) : name(nn),parent(pp),list(0),next(0){}

View File

@ -29,7 +29,9 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CEvent.h" #include "CEvent.h"
// ***************************************************** // *****************************************************
@ -86,10 +88,6 @@ void EventsMngr::NextParam()
{ {
// copy to tmp // copy to tmp
tmp = new MsgDataEntry[m_ParseVaultSize]; tmp = new MsgDataEntry[m_ParseVaultSize];
if (!tmp)
{
return; // :TODO: Error report !!
}
memcpy(tmp, m_ParseVault, m_ParseVaultSize * sizeof(MsgDataEntry)); memcpy(tmp, m_ParseVault, m_ParseVaultSize * sizeof(MsgDataEntry));
tmpSize = m_ParseVaultSize; tmpSize = m_ParseVaultSize;
delete [] m_ParseVault; delete [] m_ParseVault;
@ -119,13 +117,18 @@ EventsMngr::EventsMngr()
{ {
m_ParseVault = NULL; m_ParseVault = NULL;
m_ParseVaultSize = 0; m_ParseVaultSize = 0;
m_CurrentMsgType = -1;
clearEvents(); clearEvents();
} }
EventsMngr::~EventsMngr() EventsMngr::~EventsMngr()
{ {
clearEvents(); clearEvents();
// delete parsevault
if (m_ParseVault)
{
delete [] m_ParseVault;
m_ParseVault = NULL;
}
} }
@ -169,7 +172,7 @@ void EventsMngr::ClEvent::registerFilter(char *filter)
tmpCond->paramId = atoi(filter); tmpCond->paramId = atoi(filter);
// rest of line // rest of line
tmpCond->sValue.assign(value); tmpCond->sValue.set(value);
tmpCond->fValue = atof(value); tmpCond->fValue = atof(value);
tmpCond->iValue = atoi(value); tmpCond->iValue = atoi(value);
@ -207,8 +210,6 @@ void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int in
if (msg_type < 0 || msg_type > MAX_AMX_REG_MSG) if (msg_type < 0 || msg_type > MAX_AMX_REG_MSG)
return; return;
m_CurrentMsgType = msg_type;
m_ParseNotDone = false; m_ParseNotDone = false;
m_Timer = timer; m_Timer = timer;
@ -254,8 +255,8 @@ void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int in
{ {
m_ParsePos = 0; m_ParsePos = 0;
NextParam(); NextParam();
m_ParseVault[0].type = MSG_INTEGER; m_ParseVault[m_ParsePos].type = MSG_INTEGER;
m_ParseVault[0].iValue = index; m_ParseVault[m_ParsePos].iValue = index;
} }
m_ParseFun = &m_Events[msg_type]; m_ParseFun = &m_Events[msg_type];
} }
@ -282,13 +283,12 @@ void EventsMngr::parseValue(int iValue)
continue; // already skipped; don't bother with parsing continue; // already skipped; don't bother with parsing
// loop through conditions // loop through conditions
bool execute = false; bool execute;
bool anyConditions = false;
for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next) for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
{ {
if (condIter->paramId == m_ParsePos) if (condIter->paramId == m_ParsePos)
{ {
anyConditions = true; execute = false;
switch(condIter->type) switch(condIter->type)
{ {
case '=': if (condIter->iValue == iValue) execute=true; break; case '=': if (condIter->iValue == iValue) execute=true; break;
@ -298,11 +298,11 @@ void EventsMngr::parseValue(int iValue)
case '>': if (iValue > condIter->iValue) execute=true; break; case '>': if (iValue > condIter->iValue) execute=true; break;
} }
if (execute) if (execute)
break; continue;
(*iter).m_Done = true; // don't execute
break;
} }
} }
if (anyConditions && !execute)
(*iter).m_Done = true; // don't execute
} }
} }
@ -328,13 +328,11 @@ void EventsMngr::parseValue(float fValue)
continue; // already skipped; don't bother with parsing continue; // already skipped; don't bother with parsing
// loop through conditions // loop through conditions
bool execute = false;
bool anyConditions = false;
for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next) for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
{ {
if (condIter->paramId == m_ParsePos) if (condIter->paramId == m_ParsePos)
{ {
anyConditions = true; bool execute = false;
switch(condIter->type) switch(condIter->type)
{ {
case '=': if (condIter->fValue == fValue) execute=true; break; case '=': if (condIter->fValue == fValue) execute=true; break;
@ -343,11 +341,11 @@ void EventsMngr::parseValue(float fValue)
case '>': if (fValue > condIter->fValue) execute=true; break; case '>': if (fValue > condIter->fValue) execute=true; break;
} }
if (execute) if (execute)
break; continue;
(*iter).m_Done = true; // don't execute
break;
} }
} }
if (anyConditions && !execute)
(*iter).m_Done = true; // don't execute
} }
} }
@ -372,25 +370,23 @@ void EventsMngr::parseValue(const char *sz)
continue; // already skipped; don't bother with parsing continue; // already skipped; don't bother with parsing
// loop through conditions // loop through conditions
bool execute = false;
bool anyConditions = false;
for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next) for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
{ {
if (condIter->paramId == m_ParsePos) if (condIter->paramId == m_ParsePos)
{ {
anyConditions = true; bool execute = false;
switch(condIter->type) switch(condIter->type)
{ {
case '=': if (!strcmp(sz, condIter->sValue.c_str())) execute=true; break; case '=': if (!strcmp(sz, condIter->sValue.str())) execute=true; break;
case '!': if (strcmp(sz, condIter->sValue.c_str())) execute=true; break; case '!': if (strcmp(sz, condIter->sValue.str())) execute=true; break;
case '&': if (strstr(sz, condIter->sValue.c_str())) execute=true; break; case '&': if (strstr(sz, condIter->sValue.str())) execute=true; break;
} }
if (execute) if (execute)
break; continue;
(*iter).m_Done = true; // don't execute
break;
} }
} }
if (anyConditions && !execute)
(*iter).m_Done = true; // don't execute
} }
} }
@ -417,9 +413,10 @@ void EventsMngr::executeEvents()
(*iter).m_Stamp = (float)*m_Timer; (*iter).m_Stamp = (float)*m_Timer;
if ((err = amx_Exec((*iter).m_Plugin->getAMX(), NULL, (*iter).m_Func, 1, m_ParseVault ? m_ParseVault[0].iValue : 0)) != AMX_ERR_NONE) if ((err = amx_Exec((*iter).m_Plugin->getAMX(), NULL, (*iter).m_Func, 1, m_ParseVaultSize ? m_ParseVault[0].iValue : 0)) != AMX_ERR_NONE)
{ {
LogError((*iter).m_Plugin->getAMX(), err, ""); UTIL_Log("[AMXX] Run time error %d on line %ld (plugin \"%s\")", err,
(*iter).m_Plugin->getAMX()->curline, (*iter).m_Plugin->getName());
} }
} }
@ -427,20 +424,19 @@ void EventsMngr::executeEvents()
} }
catch( ... ) catch( ... )
{ {
AMXXLOG_Log( "[AMXX] fatal error at event execution"); UTIL_Log( "[AMXX] fatal error at event execution");
} }
#endif // #ifdef ENABLEEXEPTIONS #endif // #ifdef ENABLEEXEPTIONS
m_CurrentMsgType = -1;
m_ParseFun = NULL; m_ParseFun = NULL;
} }
int EventsMngr::getArgNum() const int EventsMngr::getArgNum()
{ {
return m_ParsePos + 1; return m_ParsePos + 1;
} }
const char* EventsMngr::getArgString(int a) const const char* EventsMngr::getArgString(int a)
{ {
if ( a < 0 || a > m_ParsePos ) if ( a < 0 || a > m_ParsePos )
return ""; return "";
@ -460,7 +456,7 @@ const char* EventsMngr::getArgString(int a) const
} }
} }
int EventsMngr::getArgInteger(int a) const int EventsMngr::getArgInteger(int a)
{ {
if ( a < 0 || a > m_ParsePos ) if ( a < 0 || a > m_ParsePos )
return 0; return 0;
@ -476,7 +472,7 @@ int EventsMngr::getArgInteger(int a) const
} }
} }
float EventsMngr::getArgFloat(int a) const float EventsMngr::getArgFloat(int a)
{ {
if ( a < 0 || a > m_ParsePos ) if ( a < 0 || a > m_ParsePos )
return 0.0f; return 0.0f;
@ -498,13 +494,6 @@ void EventsMngr::clearEvents(void)
{ {
m_Events[i].clear(); m_Events[i].clear();
} }
// delete parsevault
if (m_ParseVault)
{
delete [] m_ParseVault;
m_ParseVault = NULL;
m_ParseVaultSize = 0;
}
} }
int EventsMngr::getEventId(const char* msg) int EventsMngr::getEventId(const char* msg)
@ -536,8 +525,3 @@ int EventsMngr::getEventId(const char* msg)
// find the id of the message // find the id of the message
return pos = GET_USER_MSG_ID(PLID, msg , 0 ); return pos = GET_USER_MSG_ID(PLID, msg , 0 );
} }
int EventsMngr::getCurrentMsgType()
{
return m_CurrentMsgType;
}

View File

@ -132,7 +132,6 @@ private:
ClEvent* getValidEvent(ClEvent* a ); ClEvent* getValidEvent(ClEvent* a );
int m_CurrentMsgType;
public: public:
EventsMngr(); EventsMngr();
~EventsMngr(); ~EventsMngr();
@ -145,15 +144,12 @@ public:
void parseValue(float fValue); void parseValue(float fValue);
void parseValue(const char *sz); void parseValue(const char *sz);
void executeEvents(); void executeEvents();
int getArgNum() const; //{ return (parsePos+1); } int getArgNum(); //{ return (parsePos+1); }
const char* getArgString(int a) const; const char* getArgString(int a);
int getArgInteger(int a) const; int getArgInteger(int a);
float getArgFloat(int a) const; float getArgFloat(int a);
void clearEvents(void); void clearEvents(void);
static int getEventId( const char* msg ); static int getEventId( const char* msg );
int getCurrentMsgType();
}; };
#endif // #ifdef __CEVENTS_H__ #endif // #ifdef __CEVENTS_H__

View File

@ -29,9 +29,8 @@
* version. * version.
*/ */
#include <ctype.h>
#include "amxmodx.h"
#include "CFile.h" #include "CFile.h"
#include <ctype.h>
// ***************************************************** // *****************************************************
// class File // class File
@ -54,7 +53,7 @@ File::operator bool ( ) const
File& operator<<( File& f, const String& n ) File& operator<<( File& f, const String& n )
{ {
if ( f ) fputs( n.c_str() , f.fp ) ; if ( f ) fputs( n.str() , f.fp ) ;
return f; return f;
} }
@ -82,7 +81,7 @@ File& operator>>( File& f, String& n )
if ( !f ) return f; if ( !f ) return f;
char temp[1024]; char temp[1024];
fscanf( f.fp , "%s", temp ); fscanf( f.fp , "%s", temp );
n.assign(temp); n.set(temp);
return f; return f;
} }
@ -95,7 +94,6 @@ File& operator>>( File& f, char* n )
int File::getline( char* buf, int sz ) int File::getline( char* buf, int sz )
{ {
int a = sz; int a = sz;
char *origBuf = buf;
if ( *this ) if ( *this )
{ {
int c; int c;
@ -103,15 +101,6 @@ int File::getline( char* buf, int sz )
*buf++ = c; *buf++ = c;
*buf = 0; *buf = 0;
} }
// trim 0x0a and 0x0d characters at the end
while (buf != origBuf)
{
if (*buf == 0x0a || *buf == 0x0d)
*buf = 0;
--buf;
}
return a - sz; return a - sz;
} }

View File

@ -29,508 +29,52 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CForward.h"
CForward::CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam *paramTypes) void CForwardMngr::registerForward( CPluginMngr::CPlugin* p, int func , int type ){
{
m_FuncName = name;
m_ExecType = et;
m_NumParams = numParams;
memcpy((void *)m_ParamTypes, paramTypes, numParams * sizeof(ForwardParam));
// find funcs
int func;
AMXForward *tmp = NULL;
m_Funcs.clear();
for (CPluginMngr::iterator iter = g_plugins.begin(); iter; ++iter)
{
if ((*iter).isValid() && amx_FindPublic((*iter).getAMX(), name, &func) == AMX_ERR_NONE)
{
AMXForward tmp;
tmp.pPlugin = &(*iter);
tmp.func = func;
m_Funcs.push_back(tmp);
}
}
}
cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
{
cell realParams[FORWARD_MAX_PARAMS];
cell *physAddrs[FORWARD_MAX_PARAMS];
const int STRINGEX_MAXLENGTH = 128;
cell globRetVal = 0;
unsigned int id = 0;
AMXForwardList::iterator iter;
for (iter = m_Funcs.begin(); iter != m_Funcs.end(); iter++)
{
if (iter->pPlugin->isExecutable(iter->func))
{
// 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(iter->pPlugin->getAMX(),
(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(iter->pPlugin->getAMX(), 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;
int err = amx_Execv(iter->pPlugin->getAMX(), &retVal, iter->func, m_NumParams, realParams);
// log runtime error, if any
if (err != AMX_ERR_NONE)
LogError(iter->pPlugin->getAMX(), err, "");
// cleanup strings & arrays
for (i = 0; i < m_NumParams; ++i)
{
if (m_ParamTypes[i] == FP_STRING)
{
amx_Release(iter->pPlugin->getAMX(), realParams[i]);
}
else if (m_ParamTypes[i] == FP_STRINGEX)
{
// copy back
amx_GetString(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
amx_Release(iter->pPlugin->getAMX(), realParams[i]);
}
else if (m_ParamTypes[i] == FP_ARRAY)
{
// copy back
if (preparedArrays[params[i]].copyBack)
{
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(iter->pPlugin->getAMX(), realParams[i]);
}
}
// decide what to do (based on exectype and retval)
switch (m_ExecType)
{
case ET_IGNORE:
break;
case ET_STOP:
if (retVal > 0)
return retVal;
case ET_STOP2:
if (retVal == 1)
return 1;
else if (retVal > globRetVal)
globRetVal = retVal;
break;
case ET_CONTINUE:
if (retVal > globRetVal)
globRetVal = retVal;
break;
}
}
}
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;
isFree = false;
}
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);
isFree = false;
}
cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
{
if (isFree)
return 0;
const int STRINGEX_MAXLENGTH = 128; CForward** a = &head[ type ];
while(*a) a = &(*a)->next;
cell realParams[FORWARD_MAX_PARAMS]; *a = new CForward( p , func );
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 void CForwardMngr::clearForwards( CForward** a ){
int i; while( *a ) {
for (i = 0; i < m_NumParams; ++i) CForward* b = (*a)->next;
{ delete *a;
if (m_ParamTypes[i] == FP_STRING || m_ParamTypes[i] == FP_STRINGEX) *a = b;
{
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
if (preparedArrays[params[i]].copyBack)
{
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() << 1;
CForward *tmp = new CForward(funcName, et, numParams, paramTypes);
if (!tmp)
return -1; // should be invalid
m_Forwards.push_back(tmp);
return retVal;
}
int CForwardMngr::registerSPForward(int func, AMX *amx, int numParams, const ForwardParam *paramTypes)
{
int retVal = -1;
CSPForward *pForward;
if (!m_FreeSPForwards.empty())
{
retVal = m_FreeSPForwards.front();
pForward = m_SPForwards[retVal >> 1];
pForward->Set(func, amx, numParams, paramTypes);
if (pForward->getFuncsNum() == 0)
return -1;
m_FreeSPForwards.pop();
}
else
{
retVal = (m_SPForwards.size() << 1) | 1;
pForward = new CSPForward();
if (!pForward)
return -1;
pForward->Set(func, amx, numParams, paramTypes);
if (pForward->getFuncsNum() == 0)
{
return -1;
delete pForward;
}
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.empty())
{
retVal = m_FreeSPForwards.front();
pForward = m_SPForwards[retVal>>1]; // >>1 because unregisterSPForward pushes the id which contains the sp flag
pForward->Set(funcName, amx, numParams, paramTypes);
if (pForward->getFuncsNum() == 0)
return -1;
m_FreeSPForwards.pop();
}
else
{
pForward = new CSPForward();
if (!pForward)
return -1;
pForward->Set(funcName, amx, numParams, paramTypes);
if (pForward->getFuncsNum() == 0)
{
delete pForward;
return -1;
}
m_SPForwards.push_back(pForward);
}
return retVal;
}
bool CForwardMngr::isIdValid(int id) const
{
return (id >= 0) && ((id & 1) ?
(static_cast<size_t>(id >> 1) < m_SPForwards.size()) :
(static_cast<size_t>(id >> 1) < m_Forwards.size()));
}
cell CForwardMngr::executeForwards(int id, cell *params)
{
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 (id & 1) ? m_SPForwards[id >> 1]->getParamsNum() :
m_Forwards[id >> 1]->getParamsNum();
}
ForwardParam CForwardMngr::getParamType(int id, int paramNum) const
{
return (id & 1) ? m_SPForwards[id >> 1]->getParamType(paramNum) :
m_Forwards[id >> 1]->getParamType(paramNum);
} }
void CForwardMngr::clear() void CForwardMngr::clear()
{ {
for (ForwardVec::iterator iter = m_Forwards.begin(); iter != m_Forwards.end(); ++iter) for ( int a = 0; a < FORWARD_NUM; ++a )
{ clearForwards( &head[ a ] );
delete *iter;
}
SPForwardVec::iterator spIter;
for (spIter = m_SPForwards.begin(); spIter != m_SPForwards.end(); ++spIter)
{
delete (*spIter);
}
m_Forwards.clear();
m_SPForwards.clear();
while (!m_FreeSPForwards.empty())
m_FreeSPForwards.pop();
m_TmpArraysNum = 0;
} }
bool CForwardMngr::isSPForward(int id) const void CForwardMngr::executeForwards( int type , int num , int player ) {
{
return ((id & 1) == 0) ? false : true; cell ret = 0;
} int err;
CForward* a = head[ type ];
void CForwardMngr::unregisterSPForward(int id)
{ while ( a )
//make sure the id is valid
if ( !isIdValid(id) || m_SPForwards.at(id >> 1)->isFree )
return;
m_SPForwards.at(id >> 1)->isFree = true;
m_FreeSPForwards.push(id);
}
int registerForward(const char *funcName, ForwardExecType et, ...)
{
int curParam = 0;
va_list argptr;
va_start(argptr, et);
ForwardParam params[FORWARD_MAX_PARAMS];
ForwardParam tmp;
while (true)
{ {
if (curParam == FORWARD_MAX_PARAMS) if ( a->getPlugin()->isExecutable( a->getFunction() ) )
break;
tmp = (ForwardParam)va_arg(argptr, int);
if (tmp == FP_DONE)
break;
params[curParam] = tmp;
++curParam;
}
va_end(argptr);
return g_forwards.registerForward(funcName, et, curParam, params);
}
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;
cell params[FORWARD_MAX_PARAMS];
int paramsNum = g_forwards.getParamsNum(id);
va_list argptr;
va_start(argptr, id);
for (int i = 0; i < paramsNum && i < FORWARD_MAX_PARAMS; ++i)
{
if (g_forwards.getParamType(id, i) == FP_FLOAT)
{ {
REAL tmp = (REAL)va_arg(argptr, double); // floats get converted to doubles
params[i] = *(cell*)&tmp; if ((err = amx_Exec(a->getPlugin()->getAMX(), &ret, a->getFunction() , num, player)) != AMX_ERR_NONE)
UTIL_Log("[AMXX] Run time error %d on line %ld (plugin \"%s\")", err,a->getPlugin()->getAMX()->curline,a->getPlugin()->getName());
if ( ret )
break;
} }
else
params[i] = (cell)va_arg(argptr, cell); a = a->next;
} }
va_end(argptr); }
return g_forwards.executeForwards(id, params);
}
cell CForwardMngr::prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type, bool copyBack)
{
if (m_TmpArraysNum >= FORWARD_MAX_PARAMS)
{
#ifdef MEMORY_TEST
m_validateAllAllocUnits();
#endif // MEMORY_TEST
AMXXLOG_Log("[AMXX] Forwards with more than 32 parameters are not supported (tried to prepare array # %d).", m_TmpArraysNum + 1);
m_TmpArraysNum = 0;
return -1;
}
m_TmpArrays[m_TmpArraysNum].ptr = ptr;
m_TmpArrays[m_TmpArraysNum].size = size;
m_TmpArrays[m_TmpArraysNum].type = type;
m_TmpArrays[m_TmpArraysNum].copyBack = copyBack;
return m_TmpArraysNum++;
}
cell prepareCellArray(cell *ptr, unsigned int size, bool copyBack)
{
return g_forwards.prepareArray((void*)ptr, size, Type_Cell, copyBack);
}
cell prepareCharArray(char *ptr, unsigned int size, bool copyBack)
{
return g_forwards.prepareArray((void*)ptr, size, Type_Char, copyBack);
}
void unregisterSPForward(int id)
{
g_forwards.unregisterSPForward(id);
}

View File

@ -29,178 +29,87 @@
* version. * 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 #ifndef FORWARD_H
#define FORWARD_H #define FORWARD_H
const int FORWARD_MAX_PARAMS = 32; // *****************************************************
// class CmdMngr
// *****************************************************
enum ForwardExecType #define FORWARD_NUM 12
{
ET_IGNORE = 0, // Ignore return vaue enum {
ET_STOP, // Stop on PLUGIN_HANDLED FF_ClientCommand,
ET_STOP2, // Stop on PLUGIN_HANDLED, continue on other values, return biggest return value FF_ClientConnect,
ET_CONTINUE, // Continue; return biggest return value FF_ClientDisconnect,
FF_ClientInfoChanged,
FF_ClientPutInServer,
FF_PluginInit,
FF_PluginCfg,
FF_PluginPrecache,
FF_PluginLog,
FF_PluginEnd,
FF_InconsistentFile,
FF_ClientAuthorized,
}; };
enum ForwardParam class CForwardMngr
{ {
FP_DONE = -1, // specify this as the last argument public:
// only tells the function that there are no more arguments
FP_CELL, // normal cell class iterator;
FP_FLOAT, // float; used as normal cell though
FP_STRING, // string
FP_STRINGEX, // string; will be updated to the last function's value
FP_ARRAY, // array; use the return value of prepareArray.
};
// for prepareArray class CForward
enum ForwardArrayElemType
{
Type_Cell = 0,
Type_Char
};
struct ForwardPreparedArray
{
void *ptr;
ForwardArrayElemType type;
unsigned int size;
bool copyBack;
};
// Normal forward
class CForward
{
const char *m_FuncName;
ForwardExecType m_ExecType;
int m_NumParams;
struct AMXForward
{ {
CPluginMngr::CPlugin *pPlugin;
int func; friend class iterator;
friend class CForwardMngr;
CPluginMngr::CPlugin* plugin;
int function;
CForward* next;
CForward( CPluginMngr::CPlugin* p, int func ) : plugin(p) , function(func) {next=0;}
public:
inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
inline int getFunction() { return function; }
}; };
typedef CVector<AMXForward> AMXForwardList;
AMXForwardList m_Funcs;
ForwardParam m_ParamTypes[FORWARD_MAX_PARAMS];
private:
CForward *head[ FORWARD_NUM ];
void clearForwards( CForward** a );
public: public:
CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam * paramTypes); CForwardMngr() {memset( head, 0, sizeof(head));}
CForward() ~CForwardMngr() { clear(); }
{ } // leaves everything unitialized'
cell execute(cell *params, ForwardPreparedArray *preparedArrays);
int getParamsNum() const
{
return m_NumParams;
}
int getFuncsNum() const
{
return m_Funcs.size();
}
ForwardParam getParamType(int paramId) const
{
if (paramId < 0 || paramId >= m_NumParams)
return FP_DONE;
return m_ParamTypes[paramId];
}
};
// 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:
bool isFree;
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;
}
ForwardParam getParamType(int paramId) const
{
if (paramId < 0 || paramId >= m_NumParams)
return FP_DONE;
return m_ParamTypes[paramId];
}
};
class CForwardMngr
{
typedef CVector<CForward*> ForwardVec;
typedef CVector<CSPForward*> SPForwardVec;
typedef CQueue<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:
CForwardMngr()
{ m_TmpArraysNum = 0; }
~CForwardMngr()
{ }
// Interface // Interface
// Register normal forward
int registerForward(const char *funcName, ForwardExecType et, int numParams, const ForwardParam *paramTypes); void registerForward( CPluginMngr::CPlugin* p, int func , int type );
// Register single plugin forward void executeForwards( int type , int num = 0, int player = 0 );
int registerSPForward(const char *funcName, AMX *amx, int numParams, const ForwardParam * paramTypes); void clear();
int registerSPForward(int func, AMX *amx, int numParams, const ForwardParam * paramTypes);
// Unregister single plugin forward
void unregisterSPForward(int id); class iterator {
// execute forward CForward *a;
cell executeForwards(int id, cell *params); public:
void clear(); // delete all forwards iterator(CForward*aa) : a(aa) {}
bool isIdValid(int id) const; // check whether forward id is valid iterator& operator++() { a = a->next; return *this; }
bool isSPForward(int id) const; // check whether forward is single plugin bool operator==(const iterator& b) const { return a == b.a; }
int getParamsNum(int id) const; // get num of params of a forward bool operator!=(const iterator& b) const { return !operator==(b); }
int getFuncsNum(int id) const; // get num of found functions of a forward operator bool () const { return a ? true : false; }
ForwardParam getParamType(int id, int paramId) const; CForward& operator*() { return *a; }
cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type, };
bool copyBack); // prepare array inline iterator begin( int type ) const { return iterator(head[(int)type]); }
inline iterator end() const { return iterator(0); }
inline bool forwardsExist( int type ) {return head[(int)type]?true:false;}
}; };
// (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
cell executeForwards(int id, ...);
// prepare array
cell prepareCellArray(cell *ptr, unsigned int size, bool copyBack = false);
cell prepareCharArray(char *ptr, unsigned int size, bool copyBack = false);
#endif #endif

File diff suppressed because it is too large Load Diff

View File

@ -1,210 +0,0 @@
/* AMX Mod X
*
* by the AMX Mod X Development Team
* originally developed by OLO
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*/
#ifndef _INCLUDE_CLANG_H
#define _INCLUDE_CLANG_H
#define LANG_SERVER 0
#define LANG_PLAYER -1
struct md5Pair
{
String file;
String val;
};
struct keyEntry
{
String key;
uint32_t hash;
};
struct sKeyDef
{
sKeyDef() { key = -1; def = 0; }
~sKeyDef() { if (def) delete def; }
int key;
String *def;
};
class CLangMngr
{
class CLang
{
public:
// Construct an empty CLang object
CLang();
// Construct a CLang object initialized with a language name
CLang(const char *lang);
// Destructor
~CLang();
// Get the definition
const char *GetDef(const char *key);
// Add definitions to this language
void MergeDefinitions(CQueue <sKeyDef*> & vec);
// Reset this language
void Clear();
// compare this language to a language name
friend bool operator == (const CLang &left, const char *right)
{
return strcmp(left.m_LanguageName, right)==0 ? true : false;
}
// Get language name
const char *GetName() { return m_LanguageName; }
// Save to file
bool Save(FILE *fp, int &defOffset, uint32_t &curOffset);
bool SaveDefinitions(FILE *fp, uint32_t &curOffset);
// Load
bool Load(FILE *fp);
void SetMngr(CLangMngr *l) { m_LMan = l; }
// Get number of entries
int Entries() { return m_LookUpTable.size(); }
// Make a hash from a string; convert to lowercase first if needed
static uint32_t MakeHash(const char *src, bool makeLower = false);
protected:
// An entry in the language
class LangEntry
{
// the definition hash
uint32_t m_DefHash;
// index into the lookup table?
int key;
// the definition
String m_pDef;
// is this from the cache or not?
bool m_isCache;
public:
// Set
void SetKey(int key);
void SetDef(const char *pDef);
void SetCache(bool c);
// Get
uint32_t GetDefHash();
int GetKey();
const char *GetDef();
int GetDefLength();
bool GetCache();
// Constructors / destructors
LangEntry();
LangEntry(int key);
LangEntry(int key, const char *pDef);
LangEntry(const LangEntry &other);
LangEntry(int pKey, uint32_t defHash, const char *pDef);
// Reset
void Clear();
};
// Get (construct if needed) an entry
LangEntry * GetEntry(int key);
typedef CVector<LangEntry*> LookUpVec;
typedef LookUpVec::iterator LookUpVecIter;
char m_LanguageName[3];
// our lookup table
LookUpVec m_LookUpTable;
CLangMngr *m_LMan;
public:
LangEntry *AddEntry(int pKey, uint32_t defHash, const char *def, bool cache);
};
// Merge definitions into a language
void MergeDefinitions(const char *lang, CQueue <sKeyDef*> &tmpVec);
// strip lowercase; make lower if needed
static size_t strip(char *str, char *newstr, bool makelower=false);
typedef CVector<CLang*> LangVec;
typedef CVector<CLang*>::iterator LangVecIter;
LangVec m_Languages;
CVector<md5Pair *> FileList;
CVector<keyEntry*> KeyList;
// Get a lang object (construct if needed)
CLang * GetLang(const char *name);
CLang * GetLangR(const char *name);
// Current global client-id for functions like client_print with first parameter 0
int m_CurGlobId;
public:
// Merge a definitions file
int MergeDefinitionFile(const char *file);
// Get a definition from a lang name and a kyer
const char *GetDef(const char *langName, const char *key);
// Format a string
const char *Format(const char *src, ...);
// Format a string for an AMX plugin
char *FormatAmxString(AMX *amx, cell *params, int parm, int &len);
char *FormatString(const char *fmt, va_list &ap);
// Save
bool Save(const char *filename);
// Load
bool Load(const char *filename);
// Cache
bool LoadCache(const char *filename);
bool SaveCache(const char *filename);
// Get index
int GetKeyEntry(String &key);
int GetKeyEntry(const char *key);
int GetKeyHash(int key);
// Get key from index
const char *GetKey(int key);
// Add key
int AddKeyEntry(String &key);
// Make a hash from a string; convert to lowercase first if needed
uint32_t MakeHash(const char *src, bool makeLower);
// Get the number of languages
int GetLangsNum();
// Get the name of a language
const char *GetLangName(int langId);
// Check if a language exists
bool LangExists(const char *langName);
// When a language id in a format string in FormatAmxString is LANG_PLAYER, the glob id decides which language to take.
void SetDefLang(int id);
// Reset
void Clear();
CLangMngr();
~CLangMngr();
};
#endif //_INCLUDE_CLANG_H

View File

@ -35,279 +35,76 @@
// ***************************************************** // *****************************************************
// class CList // class CList
// ***************************************************** // *****************************************************
// Linked list
template <typename T, typename F = char* > template <typename T, typename F = char* >
class CList class CList {
{
private:
// One list element
class CElement
{
T *m_pObject; // pointer to the object
CElement *m_pNext; // pointer to the next element
CElement *m_pPrev; // pointer to the previous element
public:
// dereference operator
T& operator* ()
{
return *m_pObject;
}
// constructor
CElement(T *pObj)
{
m_pObject = pObj;
m_pNext = NULL;
m_pPrev = NULL;
}
// destructor
~CElement()
{
delete m_pObject;
if (m_pNext)
m_pNext->m_pPrev = m_pPrev;
if (m_pPrev)
m_pPrev->m_pNext = m_pNext;
}
// returns object pointer
T *GetObj()
{
return m_pObject;
}
// returns next element pointer
CElement *GetNext()
{
return m_pNext;
}
// sets next element
void SetNext(CElement *newNext)
{
m_pNext = newNext;
}
// returns previous element pointer
CElement *GetPrev()
{
return m_pPrev;
}
// sets previous element
void SetPrev(CElement *newPrev)
{
m_pPrev = newPrev;
}
};
// CList<T,F> class
CElement *m_pHead; // head of the linked list
CElement *m_pTail; // tail of the linked list
public: public:
// iterator class class iterator;
class iterator class CListEle {
{
friend class CList<T,F>; friend class CList<T,F>;
CList<T,F> *m_pList; // The list that created this iterator friend class iterator;
CElement *m_CurPos; // Current position in the list T* obj;
CListEle* next;
CListEle( T* a , CListEle* nn ) : obj(a) , next(nn) {}
public: public:
iterator() T& operator* () { return *obj; }
{ };
m_pList = NULL; private:
m_CurPos = NULL; CListEle *head;
} int cur_size;
public:
// constructor based on list, element CList<T,F>() { head = 0; cur_size = 0; }
iterator(CList<T,F> *pList, CElement *startPos) ~CList<T,F>() { clear(); }
{ void clear() {
m_pList = pList; iterator a = begin();
m_CurPos = startPos; while( a ) a.remove();
} cur_size = 0;
}
// constructor based on other iterator void put( T* a ) {
iterator(const iterator &other) head = new CListEle( a , head );
{ ++cur_size;
m_pList = other.m_pList; }
m_CurPos = other.m_CurPos; int size() {
} return cur_size;
}
// dereference operator class iterator {
T & operator* () const CListEle** a;
{ public:
return *m_CurPos->GetObj(); iterator(CListEle** i=0) : a(i){}
} T& operator*() const { return *(*a)->obj;}
inline operator bool () const { return (a && *a); }
T * operator-> () const inline iterator& operator++() {
{ a = &(*a)->next;
return m_CurPos->GetObj();
}
// validity check operator
inline operator bool () const
{
return m_pList!=NULL && m_CurPos!=NULL && m_CurPos->GetObj()!=NULL;
}
// pre increment operator
inline iterator& operator ++ ()
{
m_CurPos = m_CurPos->GetNext();
return *this; return *this;
} }
inline iterator operator++(int) {
// post increment operator iterator tmp(a);
inline iterator operator++(int) a = &(*a)->next;
{
iterator tmp(*this);
m_CurPos = m_CurPos->next;
return tmp; return tmp;
} }
iterator& remove(){
// returns iterator that points to next element CListEle* aa = (*a)->next;
iterator GetNext() delete (*a)->obj;
{ delete *a;
iterator tmp(*this); *a = aa;
return ++tmp; return *this;
} }
iterator& put( T* aa ){
iterator remove() *a = new CListEle( aa , *a );
{ return *this;
return m_pList->remove(*this);
}
iterator put(T *obj)
{
return m_pList->put(obj, *this);
} }
}; };
inline iterator begin() { return iterator(&head); }
CList<T,F>() iterator find( F a ){
{ iterator cc = begin();
m_pHead = NULL; while(cc){
m_pTail = NULL; if ( *cc == a )
}
~CList<T,F>()
{
clear();
}
// removes the object referenced by where
// sets where to the next object
// returns an iterator pointing to the next object
iterator remove(iterator &where)
{
iterator tmp(where.GetNext());
if (where.m_CurPos == m_pHead)
m_pHead = where.m_CurPos->GetNext();
if (where.m_CurPos == m_pTail)
m_pTail = where.m_CurPos->GetPrev();
delete where.m_CurPos;
where = tmp;
return tmp;
}
// puts an element to the end of the list
// returns an iterator pointing to it
iterator put_back(T *pObj)
{
CElement *pTmp = new CElement(pObj);
if (!m_pHead)
{
m_pHead = pTmp;
m_pTail = pTmp;
}
else
{
pTmp->SetNext(NULL);
pTmp->SetPrev(m_pTail);
m_pTail->SetNext(pTmp);
m_pTail = pTmp;
}
return iterator(this, pTmp);
}
iterator put_front(T *pObj)
{
CElement *pTmp = new CElement(pObj);
if (!m_pHead)
{
m_pHead = pTmp;
m_pTail = pTmp;
}
else
{
pTmp->SetNext(m_pHead);
pTmp->SetPrev(NULL);
m_pHead->SetPrev(pTmp);
m_pHead = pTmp;
}
return iterator(this, pTmp);
}
// alias for put_back
iterator put(T *pObj)
{
return put_back(pObj);
}
// puts an element after where
// alters where to point to the new element
// returns an iterator pointing to the new element
iterator put(T *pObj, iterator &where)
{
CElement *pTmp = new CElement(pObj);
if (where.m_CurPos->GetNext())
where.m_CurPos->GetNext()->SetPrev(pTmp);
else // where = tail
m_pTail = pTmp;
pTmp->SetPrev(where.m_CurPos);
pTmp->SetNext(where.m_CurPos->GetNext());
where.m_CurPos->SetNext(pTmp);
return ++where;
}
iterator begin()
{
return iterator(this, m_pHead);
}
void clear()
{
iterator iter = begin();
while (iter) iter.remove();
}
iterator find(iterator startOn, const F &desc)
{
iterator iter = startOn;
while(iter)
{
if (*iter == desc)
break; break;
++iter; ++cc;
} }
return iter; return cc;
}
iterator find(const F &desc)
{
return find(begin(), desc);
}
int size()
{
iterator iter = begin();
int i=0;
while (iter)
{
++i;
++iter;
}
return i;
} }
}; };
#endif #endif

View File

@ -29,7 +29,9 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CLogEvent.h" #include "CLogEvent.h"
// ***************************************************** // *****************************************************
@ -50,8 +52,8 @@ int LogEventsMngr::CLogCmp::compareCondition(const char* string){
if ( logid == parent->logCounter ) if ( logid == parent->logCounter )
return result; return result;
logid = parent->logCounter; logid = parent->logCounter;
if ( in ) return result = strstr( string , text.c_str() ) ? 0 : 1; if ( in ) return result = strstr( string , text.str() ) ? 0 : 1;
return result = strcmp(string,text.c_str()); return result = strcmp(string,text.str());
} }
LogEventsMngr::CLogCmp* LogEventsMngr::registerCondition(char* filter){ LogEventsMngr::CLogCmp* LogEventsMngr::registerCondition(char* filter){
@ -65,7 +67,7 @@ LogEventsMngr::CLogCmp* LogEventsMngr::registerCondition(char* filter){
if ( pos < 0 || pos >= MAX_LOGARGS) pos = 0; if ( pos < 0 || pos >= MAX_LOGARGS) pos = 0;
CLogCmp* c = logcmplist; CLogCmp* c = logcmplist;
while( c ) { while( c ) {
if ( (c->pos==pos) && (c->in==in) && !strcmp(c->text.c_str(), filter)) if ( (c->pos==pos) && (c->in==in) && !strcmp(c->text.str(), filter))
return c; return c;
c = c->next; c = c->next;
} }
@ -153,11 +155,9 @@ void LogEventsMngr::executeLogEvents()
{ {
int err; int err;
bool valid; bool valid;
for(CLogEvent* a = logevents[ logArgc ]; a ; a = a->next) for(CLogEvent* a = logevents[ logArgc ]; a ; a = a->next){
{
valid = true; valid = true;
for( CLogEvent::LogCond* b = a->filters; b ; b = b->next) for( CLogEvent::LogCond* b = a->filters; b ; b = b->next){
{
valid = false; valid = false;
for( CLogEvent::LogCondEle* c = b->list; c ; c = c->next) { for( CLogEvent::LogCondEle* c = b->list; c ; c = c->next) {
if ( c->cmp->compareCondition( logArgs[b->argnum] ) == 0 ){ if ( c->cmp->compareCondition( logArgs[b->argnum] ) == 0 ){
@ -165,15 +165,28 @@ void LogEventsMngr::executeLogEvents()
break; break;
} }
} }
if (!valid) if (!valid) break;
break;
} }
if (valid) #ifdef ENABLEEXEPTIONS
try
{ {
if ((err = amx_Exec(a->plugin->getAMX(), NULL , a->func , 0)) != AMX_ERR_NONE) #endif
LogError(a->plugin->getAMX(), err, "");
if (valid){
if ((err = amx_Exec(a->plugin->getAMX(), NULL , a->func , 0)) != AMX_ERR_NONE)
UTIL_Log("[AMXX] Run time error %d on line %ld (plugin \"%s\")",
err,a->plugin->getAMX()->curline,a->plugin->getName());
}
#ifdef ENABLEEXEPTIONS
} }
catch( ... )
{
UTIL_Log( "[AMXX] fatal error at log forward function execution");
}
#endif
} }
} }
@ -237,4 +250,4 @@ LogEventsMngr::CLogEvent *LogEventsMngr::getValidLogEvent( CLogEvent * a )
return a; return a;
} }
return 0; return 0;
} }

View File

@ -96,22 +96,23 @@ public:
LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c) , next(n) { } LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c) , next(n) { }
}; };
struct LogCond { struct LogCond {
int argnum;
LogCondEle *list; LogCondEle *list;
int argnum;
LogCond *next; LogCond *next;
LogCond( int a , LogCondEle* ee , LogCond* n ) : argnum(a) , list(ee), next(n) {} LogCond( int a , LogCondEle* ee , LogCond* n ) : argnum(a) , list(ee), next(n) {}
~LogCond(); ~LogCond();
}; };
CPluginMngr::CPlugin *plugin; CPluginMngr::CPlugin *plugin;
int func; int func;
LogEventsMngr* parent;
LogCond *filters; LogCond *filters;
LogEventsMngr* parent;
CLogEvent *next; CLogEvent *next;
CLogEvent(CPluginMngr::CPlugin *p,int f, LogEventsMngr* ppp) : plugin(p),func(f), filters(0),parent(ppp) ,next(0) { } CLogEvent(CPluginMngr::CPlugin *p,int f, LogEventsMngr* ppp) : plugin(p),func(f), filters(0),parent(ppp) ,next(0) { }
~CLogEvent(); ~CLogEvent();
public: public:
inline CPluginMngr::CPlugin *getPlugin() { return plugin; }
void registerFilter( char* filter ); void registerFilter( char* filter );
inline CPluginMngr::CPlugin *getPlugin() { return plugin; }
inline int getFunction() { return func; } inline int getFunction() { return func; }
}; };
@ -143,8 +144,8 @@ public:
class iterator { class iterator {
CLogEvent* a;
LogEventsMngr* b; LogEventsMngr* b;
CLogEvent* a;
public: public:
inline iterator(CLogEvent*aa,LogEventsMngr* bb) : a(aa), b(bb) {} inline iterator(CLogEvent*aa,LogEventsMngr* bb) : a(aa), b(bb) {}
inline iterator& operator++() { inline iterator& operator++() {

View File

@ -29,7 +29,9 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CMenu.h" #include "CMenu.h"
// ***************************************************** // *****************************************************
@ -51,7 +53,7 @@ MenuMngr::~MenuMngr()
int MenuMngr::findMenuId(const char* name, AMX* amx) int MenuMngr::findMenuId(const char* name, AMX* amx)
{ {
for( MenuIdEle* b = headid; b ; b = b->next) { for( MenuIdEle* b = headid; b ; b = b->next) {
if ( (!b->amx || amx == b->amx) && strstr(name,b->name.c_str()) ) if ( (!b->amx || amx == b->amx) && strstr(name,b->name.str()) )
return b->id; return b->id;
} }
return 0; return 0;
@ -62,8 +64,6 @@ int MenuMngr::registerMenuId(const char* n, AMX* a )
int id = findMenuId( n, a ); int id = findMenuId( n, a );
if (id) return id; if (id) return id;
headid = new MenuIdEle( n, a , headid ); headid = new MenuIdEle( n, a , headid );
if (!headid)
return 0; // :TODO: Better error report
return headid->id; return headid->id;
} }

View File

@ -28,11 +28,14 @@
* you do not wish to do so, delete this exception statement from your * you do not wish to do so, delete this exception statement from your
* version. * version.
*/ */
#include "amxmodx.h"
#include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
// ***************************************************** // *****************************************************
// class CPlayer // class CPlayer
// ***************************************************** // *****************************************************
void CPlayer::Init( edict_t* e , int i ) void CPlayer::Init( edict_t* e , int i )
{ {
index = i; index = i;
@ -59,16 +62,14 @@ void CPlayer::Disconnect() {
ingame = false; ingame = false;
initialized = false; initialized = false;
authorized = false; authorized = false;
bot = 0;
} }
void CPlayer::PutInServer() { void CPlayer::PutInServer() {
playtime = gpGlobals->time; playtime = gpGlobals->time;
ingame = true; ingame = true;
} }
bool CPlayer::Connect(const char* connectname,const char* ipaddress) { bool CPlayer::Connect(const char* connectname,const char* ipaddress) {
name.assign(connectname); name.set(connectname);
ip.assign(ipaddress); ip.set(ipaddress);
time = gpGlobals->time; time = gpGlobals->time;
bot = IsBot(); bot = IsBot();
death_killer = 0; death_killer = 0;
@ -119,8 +120,7 @@ bool Grenades::find( edict_t* enemy, CPlayer** p, int& type )
Obj* b = (*a)->next; Obj* b = (*a)->next;
delete *a; delete *a;
*a = b; *a = b;
continue;
continue;
} }
a = &(*a)->next; a = &(*a)->next;
@ -192,7 +192,7 @@ void TeamIds::registerTeam( const char* n ,int s )
{ {
TeamEle** a = &head; TeamEle** a = &head;
while( *a ){ while( *a ){
if ( strcmp((*a)->name.c_str(),n) == 0 ){ if ( strcmp((*a)->name.str(),n) == 0 ){
if (s != -1){ if (s != -1){
(*a)->id = s; (*a)->id = s;
newTeam &= ~(1<<(*a)->tid); newTeam &= ~(1<<(*a)->tid);
@ -210,7 +210,7 @@ int TeamIds::findTeamId( const char* n )
{ {
TeamEle* a = head; TeamEle* a = head;
while( a ){ while( a ){
if ( !strcmpi(a->name.c_str(),n) ) if ( !strcmpi(a->name.str(),n) )
return a->id; return a->id;
a = a->next; a = a->next;
} }
@ -221,7 +221,7 @@ int TeamIds::findTeamIdCase( const char* n)
{ {
TeamEle* a = head; TeamEle* a = head;
while( a ){ while( a ){
if ( !strcmp(a->name.c_str(), n) ) if ( !strcmp(a->name.str(), n) )
return a->id; return a->id;
a = a->next; a = a->next;
} }

View File

@ -33,6 +33,7 @@
#define CMISC_H #define CMISC_H
#include "CList.h" #include "CList.h"
#include "string.h"
// ***************************************************** // *****************************************************
// class CCVar // class CCVar
@ -45,15 +46,15 @@ class CCVar
public: public:
CCVar( const char* pname, const char* pplugin, CCVar( const char* pname, const char* pplugin,
int pflags, float pvalue ) : name(pname) , plugin(pplugin ) { int pflags, float pvalue ) : name(pname) , plugin(pplugin ) {
cvar.name = (char*)name.c_str(); cvar.name = (char*)name.str();
cvar.flags = pflags; cvar.flags = pflags;
cvar.string = ""; cvar.string = "";
cvar.value = pvalue; cvar.value = pvalue;
} }
inline cvar_t* getCvar() { return &cvar; } inline cvar_t* getCvar() { return &cvar; }
inline const char* getPluginName() { return plugin.c_str(); } inline const char* getPluginName() { return plugin.str(); }
inline const char* getName() { return name.c_str(); } inline const char* getName() { return name.str(); }
inline bool operator == ( const char* string ) { return (strcmp(name.c_str(),string)==0); } inline bool operator == ( const char* string ) const { return (strcmp(name.str(),string)==0); }
}; };
@ -110,7 +111,8 @@ public:
bool Connect(const char* connectname,const char* ipaddress); bool Connect(const char* connectname,const char* ipaddress);
inline bool IsBot(){ inline bool IsBot(){
return ((pEdict->v.flags & FL_FAKECLIENT)?true:false); const char* auth= (*g_engfuncs.pfnGetPlayerAuthId)(pEdict);
return ( auth && !strcmp( auth , "BOT" ) );
} }
inline bool IsAlive(){ inline bool IsAlive(){
@ -149,15 +151,15 @@ public:
// class ForceObject // class ForceObject
// ***************************************************** // *****************************************************
class ForceObject { class ForceObject {
AMX* amx;
String filename; String filename;
FORCE_TYPE type; FORCE_TYPE type;
Vector mins; Vector mins;
Vector maxs; Vector maxs;
AMX* amx;
public: public:
ForceObject(const char* n, FORCE_TYPE c,Vector& mi, Vector& ma, AMX* a) : ForceObject(const char* n, FORCE_TYPE c,Vector& mi, Vector& ma, AMX* a) :
filename(n) , type(c), mins(mi), maxs(ma), amx(a) {} filename(n) , type(c), mins(mi), maxs(ma), amx(a) {}
inline const char* getFilename() { return filename.c_str(); } inline const char* getFilename() { return filename.str(); }
inline AMX* getAMX() { return amx; } inline AMX* getAMX() { return amx; }
Vector& getMin() { return mins; } Vector& getMin() { return mins; }
Vector& getMax() { return maxs; } Vector& getMax() { return maxs; }
@ -209,7 +211,7 @@ class CScript
public: public:
CScript(AMX* aa, void* cc,const char* ff):filename(ff),amx(aa),code(cc){} CScript(AMX* aa, void* cc,const char* ff):filename(ff),amx(aa),code(cc){}
inline AMX* getAMX() { return amx; } inline AMX* getAMX() { return amx; }
inline const char* getName() { return filename.c_str(); } inline const char* getName() { return filename.str(); }
inline bool operator==( void* a ) { return (amx == (AMX*)a); } inline bool operator==( void* a ) { return (amx == (AMX*)a); }
inline void* getCode() { return code; } inline void* getCode() { return code; }
}; };

View File

@ -29,40 +29,23 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#ifndef FAR #ifndef FAR // PM: Test: FAR
#define FAR #define FAR
#endif #endif
// Old
typedef int (FAR *QUERYMOD)(module_info_s**); typedef int (FAR *QUERYMOD)(module_info_s**);
typedef int (FAR *ATTACHMOD)(pfnamx_engine_g*,pfnmodule_engine_g*); typedef int (FAR *ATTACHMOD)(pfnamx_engine_g*,pfnmodule_engine_g*);
typedef int (FAR *DETACHMOD)(void); typedef int (FAR *DETACHMOD)(void);
// New QUERYMOD QueryModule;
typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/); ATTACHMOD AttachModule;
typedef int (FAR *QUERYMOD_NEW)(int * /*ifvers*/, amxx_module_info_s * /*modInfo*/); DETACHMOD DetachModule;
typedef int (FAR *ATTACHMOD_NEW)(PFN_REQ_FNPTR /*reqFnptrFunc*/);
typedef int (FAR *DETACHMOD_NEW)(void);
typedef void (FAR *PLUGINSLOADED_NEW)(void);
// Old
// These functions are needed since Small Abstract Machine 2.5.0
int wamx_FindPublic(AMX *amx, char *name, int *index)
{ return amx_FindPublic(amx, name, index); }
int wamx_FindPubVar(AMX *amx, char *varname, cell *amx_addr)
{ return amx_FindPubVar(amx, varname, amx_addr); }
int wamx_GetString(char *dest, cell *source)
{ return amx_GetString(dest, source, 0); }
AMX_NATIVE_INFO *wamx_NativeInfo(char *name, AMX_NATIVE func)
{ return amx_NativeInfo(name, func); }
int wamx_SetString(cell *dest, char *source, int pack)
{ return amx_SetString(dest, source, pack, 0); }
pfnamx_engine_g engAmxFunc = { pfnamx_engine_g engAmxFunc = {
amx_Align16, amx_Align16,
@ -73,21 +56,21 @@ pfnamx_engine_g engAmxFunc = {
amx_Debug, amx_Debug,
amx_Exec, amx_Exec,
amx_Execv, amx_Execv,
wamx_FindPublic, amx_FindPublic,
wamx_FindPubVar, amx_FindPubVar,
amx_FindTagId, amx_FindTagId,
amx_Flags, amx_Flags,
amx_GetAddr, amx_GetAddr,
amx_GetPublic, amx_GetPublic,
amx_GetPubVar, amx_GetPubVar,
wamx_GetString, amx_GetString,
amx_GetTag, amx_GetTag,
amx_GetUserData, amx_GetUserData,
amx_Init, amx_Init,
amx_InitJIT, amx_InitJIT,
amx_MemInfo, amx_MemInfo,
amx_NameLength, amx_NameLength,
wamx_NativeInfo, amx_NativeInfo,
amx_NumPublics, amx_NumPublics,
amx_NumPubVars, amx_NumPubVars,
amx_NumTags, amx_NumTags,
@ -96,7 +79,7 @@ pfnamx_engine_g engAmxFunc = {
amx_Release, amx_Release,
amx_SetCallback, amx_SetCallback,
amx_SetDebugHook, amx_SetDebugHook,
wamx_SetString, amx_SetString,
amx_SetUserData, amx_SetUserData,
amx_StrLen, amx_StrLen,
}; };
@ -126,252 +109,84 @@ pfnmodule_engine_g engModuleFunc = {
// class CModule // class CModule
// ***************************************************** // *****************************************************
CModule::CModule(const char* fname) CModule::CModule(const char* fname) : filename(fname)
{ {
m_Filename.assign(fname); metamod = false;
clear(false); info = 0;
module = 0;
status = MODULE_NONE;
} }
CModule::~CModule() CModule::~CModule()
{ {
// old & new if ( module ) DLFREE(module);
if ( m_Handle ) natives.clear();
DLFREE(m_Handle);
clear();
} }
void CModule::clear(bool clearFilename)
{
// old & new
m_Metamod = false;
m_Handle = NULL;
m_Status = MODULE_NONE;
if (clearFilename)
m_Filename.assign("unknown");
// old
m_InfoOld = NULL;
// new
m_Amxx = false;
m_InfoNew.author = "unknown";
m_InfoNew.name = "unknown";
m_InfoNew.version = "unknown";
m_InfoNew.reload = 0;
m_MissingFunc = NULL;
m_Natives.clear();
}
bool CModule::attachModule() bool CModule::attachModule()
{ {
// old & new if ( status != MODULE_QUERY )
if (m_Status != MODULE_QUERY || !m_Handle)
return false; return false;
AttachModule = (ATTACHMOD)DLPROC(module,"AMX_Attach");
if (m_Amxx) if ( AttachModule ) (*AttachModule)(&engAmxFunc,&engModuleFunc);
{ status = MODULE_LOADED;
// new
ATTACHMOD_NEW AttachFunc_New = (ATTACHMOD_NEW)DLPROC(m_Handle, "AMXX_Attach");
if (!AttachFunc_New)
return false;
g_ModuleCallReason = ModuleCall_Attach;
g_CurrentlyCalledModule = this;
int retVal = (*AttachFunc_New)(Module_ReqFnptr);
g_CurrentlyCalledModule = NULL;
g_ModuleCallReason = ModuleCall_NotCalled;
switch (retVal)
{
case AMXX_OK:
m_Status = MODULE_LOADED;
return true;
case AMXX_PARAM:
AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") retured \"Invalid parameter\" from Attach func.", m_Filename.c_str(), getVersion());
m_Status = MODULE_INTERROR;
return false;
case AMXX_FUNC_NOT_PRESENT:
m_Status = MODULE_FUNCNOTPRESENT;
m_MissingFunc = g_LastRequestedFunc;
return false;
default:
AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.", m_Filename.c_str(), getVersion());
m_Status = MODULE_BADLOAD;
return false;
}
}
else
{
// old
ATTACHMOD AttachFunc = (ATTACHMOD)DLPROC(m_Handle, "AMX_Attach");
if (AttachFunc)
(*AttachFunc)(&engAmxFunc,&engModuleFunc);
m_Status = MODULE_LOADED;
return true;
}
}
bool CModule::queryModule()
{
if (m_Status != MODULE_NONE) // don't check if already queried
return false;
m_Handle = DLLOAD(m_Filename.c_str()); // load file
if (!m_Handle)
{
m_Status = MODULE_BADLOAD;
return false;
}
// Check whether the module uses metamod (for auto attach)
if (DLPROC(m_Handle, "Meta_Attach"))
m_Metamod = true;
// Try new interface first
QUERYMOD_NEW queryFunc_New = (QUERYMOD_NEW)DLPROC(m_Handle, "AMXX_Query");
if (queryFunc_New)
{
m_Amxx = true;
int ifVers = AMXX_INTERFACE_VERSION;
g_ModuleCallReason = ModuleCall_Query;
g_CurrentlyCalledModule = this;
int retVal = (*queryFunc_New)(&ifVers, &m_InfoNew);
g_CurrentlyCalledModule = NULL;
g_ModuleCallReason = ModuleCall_NotCalled;
switch (retVal)
{
case AMXX_PARAM:
AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") retured \"Invalid parameter\" from Attach func.", m_Filename.c_str(), getVersion());
m_Status = MODULE_INTERROR;
return false;
case AMXX_IFVERS:
if (ifVers < AMXX_INTERFACE_VERSION)
m_Status = MODULE_OLD;
else
m_Status = MODULE_NEWER;
return false;
case AMXX_OK:
break;
default:
AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.", m_Filename.c_str(), getVersion());
m_Status = MODULE_BADLOAD;
return false;
}
// Check for attach
if (!DLPROC(m_Handle, "AMXX_Attach"))
{
m_Status = MODULE_NOATTACH;
return false;
}
m_Status = MODULE_QUERY;
return true;
}
else
{
// old interface not 64 bit compatible
#if SMALL_CELL_SIZE == 64
m_Status = MODULE_NOT64BIT;
return false;
#else
// Try old interface
QUERYMOD queryFunc_Old = (QUERYMOD)DLPROC(m_Handle,"AMX_Query"); // check what version
if (!queryFunc_Old)
{
m_Status = MODULE_NOQUERY;
return false;
}
(*queryFunc_Old)(&m_InfoOld);
if (!m_InfoOld)
{
m_Status = MODULE_NOINFO;
return false;
}
if (m_InfoOld->ivers != AMX_INTERFACE_VERSION)
{
m_Status = MODULE_OLD;
return false;
}
// Check for attach
if (!DLPROC(m_Handle, "AMX_Attach"))
{
m_Status = MODULE_NOATTACH;
return false;
}
m_InfoOld->serial = (long int)this;
m_Status = MODULE_QUERY;
return true;
#endif
}
}
bool CModule::detachModule()
{
if (m_Status != MODULE_LOADED)
return false;
if (m_Amxx)
{
DETACHMOD_NEW detachFunc_New = (DETACHMOD_NEW)DLPROC(m_Handle, "AMXX_Detach");
if (detachFunc_New)
{
g_ModuleCallReason = ModuleCall_Detach;
g_CurrentlyCalledModule = this;
(*detachFunc_New)();
g_CurrentlyCalledModule = NULL;
g_ModuleCallReason = ModuleCall_NotCalled;
}
}
else
{
DETACHMOD detachFunc_Old = (DETACHMOD)DLPROC(m_Handle, "AMX_Detach");
if (detachFunc_Old)
(*detachFunc_Old)();
}
DLFREE(m_Handle);
clear();
return true; return true;
} }
bool CModule::queryModule()
void CModule::CallPluginsLoaded()
{ {
if (m_Status != MODULE_LOADED) if ( status != MODULE_NONE ) // don't check if already quried
return; return false;
module = DLLOAD( filename.str() ); // link dll
if ( !module ){
status = MODULE_BADLOAD;
return false;
}
int meta = (int)DLPROC(module,"Meta_Attach"); // check if also MM
if ( meta ) metamod = true;
if (!m_Handle) QueryModule = (QUERYMOD)DLPROC(module,"AMX_Query"); // check what version
return; if (QueryModule == 0) {
status = MODULE_NOQUERY;
PLUGINSLOADED_NEW func = (PLUGINSLOADED_NEW)DLPROC(m_Handle, "AMXX_PluginsLoaded"); return false;
if (!func) }
return; (*QueryModule)( &info );
func(); if ( info == 0 ){
status = MODULE_NOINFO;
return false;
}
if ( info->ivers != AMX_INTERFACE_VERSION ) {
status = MODULE_OLD;
return false;
}
AttachModule = (ATTACHMOD)DLPROC(module,"AMX_Attach"); // check for attach
if ( AttachModule == 0) {
status = MODULE_NOATTACH;
return false;
}
info->serial = (long int)this;
status = MODULE_QUERY;
return true;
} }
bool CModule::detachModule()
const char* CModule::getStatus() const
{ {
switch(m_Status) if ( status != MODULE_LOADED )
{ return false;
case MODULE_NONE: return "error"; DetachModule = (DETACHMOD)DLPROC(module,"AMX_Detach");
case MODULE_QUERY: return "pending"; if (DetachModule) (*DetachModule)();
case MODULE_BADLOAD: return "bad load"; DLFREE(module);
case MODULE_LOADED: return "running"; module = 0;
case MODULE_NOINFO: return "no info"; natives.clear();
case MODULE_NOQUERY: return "no query"; status = MODULE_NONE;
case MODULE_NOATTACH: return "no attach"; return true;
case MODULE_OLD: return "old"; }
case MODULE_FUNCNOTPRESENT: const char* CModule::getStatus() const {
case MODULE_NEWER: return "newer"; switch(status){
case MODULE_INTERROR: return "internal err"; case MODULE_NONE: return "error";
case MODULE_NOT64BIT: return "not 64bit"; case MODULE_QUERY: return "pending";
default: break; case MODULE_BADLOAD:return "bad load";
case MODULE_LOADED:return "running";
case MODULE_NOINFO:return "no info";
case MODULE_NOQUERY:return "no query";
case MODULE_NOATTACH:return "no attach";
case MODULE_OLD:return "old";
} }
return "unknown"; return "unknown";
} }

View File

@ -37,49 +37,26 @@
#define CMODULE_H #define CMODULE_H
enum MODULE_STATUS { enum MODULE_STATUS {
MODULE_NONE, // No module loaded MODULE_NONE,
MODULE_QUERY, // Query failed MODULE_QUERY,
MODULE_BADLOAD, // Bad file or the module writer messed something up ;] MODULE_BADLOAD,
MODULE_LOADED, // Loaded MODULE_LOADED,
MODULE_NOINFO, // No info MODULE_NOINFO,
MODULE_NOQUERY, // No query function present MODULE_NOQUERY,
MODULE_NOATTACH, // No attach function present MODULE_NOATTACH,
MODULE_OLD, // Old interface MODULE_OLD
MODULE_NEWER, // newer interface
MODULE_INTERROR, // Internal error
MODULE_FUNCNOTPRESENT, // Function not present
MODULE_NOT64BIT // Not 64 bit compatible
}; };
struct amxx_module_info_s
{
const char *name;
const char *author;
const char *version;
int reload; // reload on mapchange when nonzero
};
#define AMXX_OK 0 /* no error */
#define AMXX_IFVERS 1 /* interface version */
#define AMXX_PARAM 2 /* Invalid parameter */
#define AMXX_FUNC_NOT_PRESENT 3 /* Function not present */
#define AMXX_INTERFACE_VERSION 1
class CModule class CModule
{ {
String m_Filename; // Filename String filename;
bool m_Metamod; // Using metamod? bool metamod;
bool m_Amxx; // Using new module interface? module_info_s* info;
module_info_s* m_InfoOld; // module info (old module interface) DLHANDLE module;
amxx_module_info_s m_InfoNew; // module info (new module interface) MODULE_STATUS status;
DLHANDLE m_Handle; // handle
MODULE_STATUS m_Status; // status
const char *m_MissingFunc; // missing function; only set on MODULE_FUNCNOTPRESENT status
void clear(bool clearFilename = true);
public: public:
CModule(const char* fname); CModule(const char* fname);
~CModule(); ~CModule();
@ -88,21 +65,15 @@ public:
bool queryModule(); bool queryModule();
bool detachModule(); bool detachModule();
const char* getStatus() const; const char* getStatus() const;
inline const char* getType() const { return m_Amxx ? "amxx" : (m_Metamod ? "amx&mm" : "amx"); } inline const char* getType() const { return metamod ? "amx&mm" : "amx"; }
inline const char* getAuthor() const { return m_Amxx ? (m_InfoNew.author) : (m_InfoOld ? m_InfoOld->author : "unknown"); } inline const char* getAuthor() const { return info ? info->author : "unknown"; }
inline const char* getVersion() const { return m_Amxx ? (m_InfoNew.version) : (m_InfoOld ? m_InfoOld->version : "unknown"); } inline const char* getVersion() const { return info ? info->version : "unknown"; }
inline const char* getName() const { return m_Amxx ? (m_InfoNew.name) : (m_InfoOld ? m_InfoOld->name : "unknown"); } inline const char* getName() const { return info ? info->name : "unknown"; }
inline module_info_s* getInfo() const { return m_InfoOld; } // old inline module_info_s* getInfo() const { return info; }
inline const amxx_module_info_s* getInfoNew() const { return &m_InfoNew; } // new inline int getStatusValue() { return status; }
inline int getStatusValue() { return m_Status; } inline bool operator==( void* fname ) { return !strcmp( filename.str() , (char*)fname ); }
inline bool operator==( const char* fname ) { return !strcmp( m_Filename.c_str() , fname ); } inline bool isReloadable() { return ( (status==MODULE_LOADED) && (info->type==RELOAD_MODULE)); }
inline bool isReloadable() { return m_Amxx ? ((m_Status == MODULE_LOADED) && (m_InfoNew.reload != 0)) : ( (m_Status==MODULE_LOADED) && (m_InfoOld->type==RELOAD_MODULE)); } CList<AMX_NATIVE_INFO*> natives;
inline bool isAmxx() const { return m_Amxx; }
inline const char *getMissingFunc() const { return m_MissingFunc; }
inline const char *getFilename() { return m_Filename.c_str(); }
void CModule::CallPluginsLoaded();
CList<AMX_NATIVE_INFO*> m_Natives;
}; };

View File

@ -29,16 +29,18 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CPlugin.h" #include "CPlugin.h"
#include "CForward.h" #include "CForward.h"
#include "CFile.h" #include "CFile.h"
CPluginMngr::CPlugin* CPluginMngr::loadPlugin(const char* path, const char* name, char* error, int debug) { CPluginMngr::CPlugin* CPluginMngr::loadPlugin(const char* path, const char* name, char* error) {
CPlugin** a = &head; CPlugin** a = &head;
while( *a ) a = &(*a)->next; while( *a ) a = &(*a)->next;
*a = new CPlugin( pCounter++ ,path,name,error, debug); *a = new CPlugin( pCounter++ ,path,name,error);
return (*a); return *error ? 0 : *a;
} }
void CPluginMngr::unloadPlugin( CPlugin** a ) { void CPluginMngr::unloadPlugin( CPlugin** a ) {
@ -50,49 +52,63 @@ void CPluginMngr::unloadPlugin( CPlugin** a ) {
int CPluginMngr::loadPluginsFromFile( const char* filename ) int CPluginMngr::loadPluginsFromFile( const char* filename )
{ {
FILE *fp = fopen(build_pathname("%s",filename) , "rt"); File fp( build_pathname("%s",filename) , "r" );
if ( !fp ) if ( !fp )
{ {
AMXXLOG_Log( "[AMXX] Plugins list not found (file \"%s\")",filename); UTIL_Log( "[AMXX] Plugins list not found (file \"%s\")",filename);
return 1; return 1;
} }
// Find now folder // Find now folder
char pluginName[256], error[256], debug[256]; char pluginName[256], line[256], error[256];
int debugFlag = 0; const char pluginsDir[] = "addons/amxx/plugins"; // hardcoded; :TODO: make it localinfo
const char *pluginsDir = get_localinfo("amxx_pluginsdir", "addons/amxmodx/plugins");
String line;
while ( fp.getline(line , 255 ) )
while ( !feof(fp) )
{ {
*pluginName = 0; *pluginName = 0;
*debug = 0; sscanf(line,"%s",pluginName);
debugFlag = 0;
line.clear();
line._fread(fp);
sscanf(line.c_str(),"%s %s",pluginName, debug);
if (!isalnum(*pluginName)) continue; if (!isalnum(*pluginName)) continue;
if (isalnum(*debug) && strcmp(debug, "debug") == 0) CPlugin* plugin = loadPlugin( pluginsDir , pluginName , error );
{
debugFlag = 1;
}
CPlugin* plugin = loadPlugin( pluginsDir , pluginName , error, debugFlag);
if (plugin->getStatusCode() == ps_bad_load) if ( plugin != 0 ) // load_amxscript fills it with info in case of error
{ {
char errorMsg[255]; AMX* amx = plugin->getAMX();
sprintf(errorMsg, "%s (plugin \"%s\")", error, pluginName); int iFunc;
plugin->setError(errorMsg);
AMXXLOG_Log("[AMXX] %s", plugin->getError()); if(amx_FindPublic(amx, "client_command" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientCommand);
if(amx_FindPublic(amx, "client_connect" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientConnect);
if(amx_FindPublic(amx, "client_disconnect" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientDisconnect);
if(amx_FindPublic(amx, "client_infochanged" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientInfoChanged);
if(amx_FindPublic(amx, "client_putinserver" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientPutInServer);
if(amx_FindPublic(amx, "plugin_init" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginInit);
if(amx_FindPublic(amx, "plugin_cfg" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginCfg);
if(amx_FindPublic(amx, "plugin_precache" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginPrecache);
if(amx_FindPublic(amx, "plugin_log" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginLog);
if(amx_FindPublic(amx, "plugin_end" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_PluginEnd);
if(amx_FindPublic(amx, "inconsistent_file" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_InconsistentFile);
if(amx_FindPublic(amx, "client_authorized" , &iFunc) == AMX_ERR_NONE)
g_forwards.registerForward( plugin , iFunc , FF_ClientAuthorized);
}
else
{
UTIL_Log("[AMXX] %s (plugin \"%s\")", error, pluginName );
} }
} }
fclose(fp);
return pCounter; return pCounter;
} }
@ -105,6 +121,10 @@ void CPluginMngr::clear() {
CPluginMngr::CPlugin* CPluginMngr::findPluginFast(AMX *amx) CPluginMngr::CPlugin* CPluginMngr::findPluginFast(AMX *amx)
{ {
return (CPlugin*)(amx->userdata[3]); return (CPlugin*)(amx->userdata[3]);
/*CPlugin*a = head;
while ( a && &a->amx != amx )
a=a->next;
return a;*/
} }
CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx) { CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx) {
@ -126,23 +146,14 @@ CPluginMngr::CPlugin* CPluginMngr::findPlugin(const char* name) {
int len = strlen(name); int len = strlen(name);
if (!len) return 0; if (!len) return 0;
CPlugin*a = head; CPlugin*a = head;
while( a && strncmp(a->name.c_str(), name,len) ) while( a && strncmp(a->name.str(), name,len) )
a=a->next; a=a->next;
return a; return a;
} }
const char* CPluginMngr::CPlugin::getStatus() const { const char* CPluginMngr::CPlugin::getStatus() const {
switch(status){ switch(status){
case ps_running: case ps_running: return "running";
{
if (getAMX()->flags & AMX_FLAG_DEBUG)
{
return "debug";
} else {
return "running";
}
break;
}
case ps_paused: return "paused"; case ps_paused: return "paused";
case ps_bad_load: return "bad load"; case ps_bad_load: return "bad load";
case ps_stopped: return "stopped"; case ps_stopped: return "stopped";
@ -151,20 +162,16 @@ const char* CPluginMngr::CPlugin::getStatus() const {
return "error"; return "error";
} }
CPluginMngr::CPlugin::CPlugin(int i, const char* p,const char* n, char* e, int d) : name(n), title(n) { CPluginMngr::CPlugin::CPlugin(int i, const char* p,const char* n, char* e) : name(n), title(n) {
const char* unk = "unknown"; const char* unk = "unknown";
title.assign(unk); title.set(unk);
author.assign(unk); author.set(unk);
version.assign(unk); version.set(unk);
char* path = build_pathname("%s/%s",p,n); char* path = build_pathname("%s/%s",p,n);
code = 0; code = 0;
int err = load_amxscript(&amx,&code,path,e, d); int err = load_amxscript(&amx,&code,path,e );
if ( err == AMX_ERR_NONE ) if ( err == AMX_ERR_NONE ) status = ps_running;
{ else status = ps_bad_load;
status = ps_running;
} else {
status = ps_bad_load;
}
amx.userdata[3] = this; amx.userdata[3] = this;
paused_fun = 0; paused_fun = 0;
next = 0; next = 0;
@ -187,50 +194,9 @@ void CPluginMngr::CPlugin::unpauseFunction( int id ) {
g_commands.clearBufforedInfo(); g_commands.clearBufforedInfo();
} }
} }
void CPluginMngr::CPlugin::setStatus( int a ) { void CPluginMngr::CPlugin::setStatus( int a ) {
status = a; status = a;
g_commands.clearBufforedInfo(); // ugly way g_commands.clearBufforedInfo(); // ugly way
} }
// Pause a plugin
void CPluginMngr::CPlugin::pausePlugin()
{
if (isValid())
{
// call plugin_pause if provided
int func;
cell retval;
if (amx_FindPublic(&amx, "plugin_pause", &func) == AMX_ERR_NONE)
{
if (isExecutable(func))
{
amx_Exec(&amx, &retval, func, 0);
}
}
setStatus(ps_paused);
}
}
// Unpause a plugin
void CPluginMngr::CPlugin::unpausePlugin()
{
if (isValid())
{
// set status first so the function will be marked executable
setStatus(ps_running);
// call plugin_unpause if provided
int func;
cell retval;
if (amx_FindPublic(&amx, "plugin_unpause", &func) == AMX_ERR_NONE)
{
if (isExecutable(func))
{
amx_Exec(&amx, &retval, func, 0);
}
}
}
}

View File

@ -63,35 +63,30 @@ public:
String version; String version;
String title; String title;
String author; String author;
String errorMsg;
int paused_fun; int paused_fun;
int status; int status;
CPlugin* next; CPlugin* next;
int id; int id;
CPlugin(int i , const char* p,const char* n, char* e, int d); CPlugin(int i , const char* p,const char* n, char* e);
~CPlugin( ); ~CPlugin( );
public: public:
inline const char* getName() { return name.c_str();} inline const char* getName() const { return name.str();}
inline const char* getVersion() { return version.c_str();} inline const char* getVersion() const { return version.str();}
inline const char* getTitle() { return title.c_str();} inline const char* getTitle() const { return title.str();}
inline const char* getAuthor() { return author.c_str();} inline const char* getAuthor()const { return author.str();}
inline const char* getError() { return errorMsg.c_str();}
inline int getStatusCode() { return status; }
inline int getId() const { return id; } inline int getId() const { return id; }
inline AMX* getAMX() { return &amx; } inline AMX* getAMX() { return &amx; }
inline const AMX* getAMX() const { return &amx; } inline void setTitle( const char* n ) { title.set(n); }
inline void setTitle( const char* n ) { title.assign(n); } inline void setAuthor( const char* n ) { author.set(n); }
inline void setAuthor( const char* n ) { author.assign(n); } inline void setVersion( const char* n ) { version.set(n); }
inline void setVersion( const char* n ) { version.assign(n); }
inline void setError( const char* n ) { errorMsg.assign(n); }
inline bool isValid() const { return ((status != ps_bad_load) && (status != ps_locked)); } inline bool isValid() const { return ((status != ps_bad_load) && (status != ps_locked)); }
inline bool isPaused() const { return ( (status == ps_paused) || (status == ps_stopped)); } inline bool isPaused() const { return ( (status == ps_paused) || (status == ps_stopped)); }
inline bool isFunctionPaused( int id ) const { return (paused_fun & (1<<id)) ? true : false; } inline bool isFunctionPaused( int id ) const { return (paused_fun & (1<<id)) ? true : false; }
inline bool isExecutable(int id) const { return (isValid() && !isPaused() && !isFunctionPaused(id)); } inline bool isExecutable(int id) const { return (isValid() && !isPaused() && !isFunctionPaused(id)); }
void pausePlugin(); inline void pausePlugin( ) { if ( isValid() ) setStatus(ps_paused); }
void unpausePlugin(); inline void unpausePlugin( ) { if ( isValid() ) setStatus(ps_running); }
void pauseFunction( int id ); void pauseFunction( int id );
void unpauseFunction( int id ); void unpauseFunction( int id );
void setStatus( int a ); void setStatus( int a );
@ -109,7 +104,7 @@ public:
// Interface // Interface
CPlugin* loadPlugin(const char* path, const char* name, char* error, int debug); CPlugin* loadPlugin(const char* path, const char* name, char* error);
void unloadPlugin( CPlugin** a ); void unloadPlugin( CPlugin** a );
int loadPluginsFromFile( const char* filename ); int loadPluginsFromFile( const char* filename );
CPlugin* findPluginFast(AMX *amx); CPlugin* findPluginFast(AMX *amx);

View File

@ -1,126 +0,0 @@
/* AMX Mod X
*
* by the AMX Mod X Development Team
* originally developed by OLO
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*/
//by David "BAILOPAN" Anderson
#ifndef _INCLUDE_CQUEUE_H
#define _INCLUDE_CQUEUE_H
template <class T>
class CQueue
{
public:
class CQueueItem
{
public:
CQueueItem(const T &i, CQueueItem *n)
{
item = i;
next = n;
}
CQueueItem *GetNext()
{
return next;
}
T & GetItem()
{
return item;
}
void SetNext(CQueueItem *n)
{
next = n;
}
private:
T item;
CQueueItem *next;
};
public:
CQueue()
{
mSize = 0;
mFirst = NULL;
mLast = NULL;
}
bool empty()
{
return ((mSize==0)?true:false);
}
void push(const T &v)
{
CQueueItem *p = new CQueueItem(v, NULL);
if (empty())
{
mFirst = p;
} else {
mLast->SetNext(p);
}
mLast = p;
mSize++;
}
void pop()
{
if (mFirst == mLast)
{
delete mFirst;
mFirst = NULL;
mLast = NULL;
} else {
CQueueItem *p = mFirst->GetNext();
delete mFirst;
mFirst = p;
}
mSize--;
}
T & front()
{
return mFirst->GetItem();
}
T & back()
{
return mLast->GetItem();
}
unsigned int size()
{
return mSize;
}
private:
CQueueItem *mFirst;
CQueueItem *mLast;
unsigned int mSize;
};
#endif //_INCLUDE_CQUEUE_H

View File

@ -1,6 +1,7 @@
/* AMX Mod X /* AMX Mod X
* *
* by the AMX Mod X Development Team * by the AMX Mod X Development Team
* originally developed by OLO
* *
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
@ -28,25 +29,41 @@
* version. * version.
*/ */
#ifndef __AMXXLOG_H__ #include "CString.h"
#define __AMXXLOG_H__ #include "string.h"
#include "CFile.h"
class CLog String::String()
{ {
private: len = 0;
String m_LogFile; napis = 0;
int m_LogType; }
void GetLastFile(int &outMonth, int &outDay, String &outFilename); String::String( const char* n )
void UseFile(const String &fileName); {
public: napis = 0;
CLog(); set(n);
~CLog(); }
void CreateNewFile();
void CloseFile();
void MapChange();
void Log(const char *fmt, ...);
};
#endif // __AMXXLOG_H__ String::~String()
{
clear();
}
void String::set( const char* n )
{
clear();
if ( n != 0 ){
len = strlen( n );
napis = new char[ len + 1 ];
if ( napis ) strcpy( napis , n );
else len = 0;
}
}
void String::clear() {
delete[] napis;
napis = 0;
len = 0;
}

View File

@ -29,376 +29,30 @@
* version. * version.
*/ */
#ifndef _INCLUDE_CSTRING_H #ifndef STRING_CUSTOM_H
#define _INCLUDE_CSTRING_H #define STRING_CUSTOM_H
// *****************************************************
// class String
// *****************************************************
//by David "BAILOPAN" Anderson
class String class String
{ {
char* napis;
short int len;
public: public:
String() String();
{ String( const char* n );
v = NULL; ~String();
mSize = 0; void set( const char* n );
cSize = 0; inline bool empty() const { return (len == 0); }
Grow(2); inline const char* str() const { return napis ? napis : "(null)"; }
assign(""); inline short int size() const { return len; }
} void clear();
~String()
{
if (v)
delete [] v;
}
String(const char *src)
{
v = NULL;
mSize = 0;
cSize = 0; assign(src);
}
String(String &src)
{
v = NULL;
mSize = 0;
cSize = 0;
assign(src.c_str());
}
const char *c_str() { return v?v:""; }
const char *c_str() const { return v?v:""; }
void append(const char *t)
{
Grow(cSize + strlen(t) + 1);
strcat(v, t);
cSize = strlen(v);
}
void append(const char c)
{
Grow(cSize + 2);
v[cSize] = c;
v[++cSize] = 0;
}
void append(String &d)
{
const char *t = d.c_str();
Grow(cSize + strlen(t));
strcat(v, t);
cSize = strlen(v);
}
void assign(const String &src)
{
assign(src.c_str());
}
void assign(const char *d)
{
if (!d)
{
Grow(1);
cSize = 0;
strcpy(v, "");
return;
}
Grow(strlen(d));
if (v)
{
strcpy(v, d);
cSize = strlen(v);
} else {
cSize = 0;
}
}
void clear()
{
if (v)
{
v[0] = 0;
cSize = 0;
}
}
int compare (const char *d)
{
if (v) {
if (d) {
return strcmp(v, d);
} else {
return strlen(v);
}
} else {
if (d) {
return strlen(d);
} else {
return 0;
}
}
}
//Added this for amxx inclusion
bool empty()
{
if (!v || !cSize)
return true;
return false;
}
int size()
{
if (!v)
return 0;
return cSize;
}
const char * _fread(FILE *fp)
{
Grow(512);
char * ret = fgets(v, 511, fp);
cSize = strlen(v);
return ret;
}
int find(const char c, int index = 0)
{
if (!v)
return npos;
if (index >= (int)cSize || index < 0)
return npos;
unsigned int i = 0;
for (i=index; i<cSize; i++)
{
if (v[i] == c)
{
return i;
}
}
return npos;
}
bool is_space(int c)
{
if (c == '\f' || c == '\n' ||
c == '\t' || c == '\r' ||
c == '\v' || c == ' ')
{
return true;
}
return false;
}
void trim()
{
if (!v)
return;
unsigned int i = 0;
unsigned int j = 0;
if (cSize == 1)
{
if (is_space(v[i]))
{
clear();
return;
}
}
unsigned char c0 = v[0];
if (is_space(c0))
{
for (i=0; i<cSize; i++)
{
if (!is_space(v[i]) || (is_space(v[i]) && ((unsigned char)i==cSize-1)))
{
erase(0, i);
break;
}
}
}
cSize = strlen(v);
if (cSize < 1)
{
return;
}
if (is_space(v[cSize-1]))
{
for (i=cSize-1; i>=0; i--)
{
if (!is_space(v[i])
|| (is_space(v[i]) && i==0))
{
erase(i+1, j);
break;
}
j++;
}
}
if (cSize == 1)
{
if (is_space(v[0]))
{
clear();
return;
}
}
}
String & erase(unsigned int start, int num = npos)
{
if (!v)
return (*this);
unsigned int i = 0;
//check for bounds
if (num == npos || start+num > cSize-num+1)
num = cSize - start;
//do the erasing
bool copyflag = false;
for (i=0; i<cSize; i++)
{
if (i>=start && i<start+num)
{
if (i+num < cSize)
{
v[i] = v[i+num];
} else {
v[i] = 0;
}
copyflag = true;
} else if (copyflag) {
if (i+num < cSize)
{
v[i] = v[i+num];
} else {
v[i] = 0;
}
}
}
cSize -= num;
v[cSize] = 0;
return (*this);
}
String substr(unsigned int index, int num = npos)
{
String ns;
if (index >= cSize || !v)
return ns;
if (num == npos)
{
num = cSize - index;
} else if (index+num >= cSize) {
num = cSize - index;
}
unsigned int i = 0, j=0;
char *s = new char[cSize+1];
for (i=index; i<index+num; i++)
{
s[j++] = v[i];
}
s[j] = 0;
ns.assign(s);
delete [] s;
return ns;
}
void toLower()
{
if (!v)
return;
unsigned int i = 0;
for (i=0; i<cSize; i++)
{
if (v[i] >= 65 && v[i] <= 90)
v[i] |= 32;
}
}
String & operator = (const String &src)
{
assign(src);
return *this;
}
String & operator = (const char *src)
{
assign(src);
return *this;
}
char operator [] (unsigned int index)
{
if (index > cSize)
{
return -1;
} else {
return v[index];
}
}
int at(int a)
{
if (a < 0 || a >= (int)cSize)
return -1;
return v[a];
}
bool at(int at, char c)
{
if (at < 0 || at >= (int)cSize)
return false;
v[at] = c;
return true;
}
private:
void Grow(unsigned int d)
{
if (d<1)
return;
if (d > mSize)
{
mSize = d + 16; // allocate a buffer
char *t = new char[d+1];
if (v) {
strcpy(t, v);
t[cSize] = 0;
delete [] v;
}
v = t;
mSize = d;
}
}
char *v;
unsigned int mSize;
unsigned int cSize;
public:
static const int npos = -1;
}; };
#endif //_INCLUDE_CSTRING_H #endif

View File

@ -29,211 +29,164 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
#include "CTask.h" #include "CTask.h"
/*********************** CTask ***********************/
int CTaskMngr::CTask::getTaskId() const
{
return m_iId;
}
CPluginMngr::CPlugin *CTaskMngr::CTask::getPlugin() const CTaskMngr::CTask::CTask( CPluginMngr::CPlugin* p, int f, int flags,
{ int i, float base, float exec, int parlen ,
return m_pPlugin; const cell* par, int r){
} plugin = p;
func = f;
id = i;
next = 0;
prev = 0;
param_len = 0;
param = 0;
base_time = base;
exec_time = exec;
repeat = (flags & 1) ? r : 0;
loop = (flags & 2) ? true : false;
afterstart = (flags & 4) ? true : false;
beforeend = (flags & 8) ? true : false;
void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime) if ( parlen )
{
m_bFree = false;
m_pPlugin = pPlugin;
m_iFunc = iFunc;
m_iId = iId;
m_fBase = fBase;
m_iRepeat = (iFlags & 1) ? iRepeat : 0;
m_bLoop = (iFlags & 2) ? true : false;
m_bAfterStart = (iFlags & 4) ? true : false;
m_bBeforeEnd = (iFlags & 8) ? true : false;
m_fNextExecTime = fCurrentTime + m_fBase;
if (iParamsLen)
{ {
m_iParamLen = iParamsLen + 1; param = new cell[ parlen + 1 ];
m_pParams = new cell[m_iParamLen];
memcpy(m_pParams, pParams, sizeof(cell)*iParamsLen);
m_pParams[iParamsLen] = 0;
} else {
m_iParamLen = 0;
m_pParams = NULL;
}
}
void CTaskMngr::CTask::clear() if ( param ){
{ param_len = parlen + 1;
if (m_iFunc >= 0) memcpy( param , par , sizeof( cell ) * parlen );
{ param[ parlen ] = 0;
unregisterSPForward(m_iFunc);
m_iFunc = -1;
}
m_bFree = true;
if (m_pParams)
{
delete [] m_pParams;
m_pParams = NULL;
}
}
bool CTaskMngr::CTask::isFree() const
{
return m_bFree;
}
void CTaskMngr::CTask::changeBase(float fNewBase)
{
m_fBase = fNewBase;
}
void CTaskMngr::CTask::resetNextExecTime(float fCurrentTime)
{
m_fNextExecTime = fCurrentTime + m_fBase;
}
void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, float fTimeLeft)
{
bool execute=false;
if (m_bAfterStart)
{
if (fCurrentTime - fTimeLeft + 1.0f >= m_fBase)
execute = true;
}
else if (m_bBeforeEnd)
{
if (fTimeLimit != 0.0f && (fTimeLeft + fTimeLimit * 60.0f) - fCurrentTime - 1.0f <= m_fBase)
execute = true;
}
else if (m_fNextExecTime <= fCurrentTime)
execute = true;
if (execute)
{
if (m_iParamLen) // call with parameters
{
cell arr = prepareCellArray(m_pParams, m_iParamLen);
executeForwards(m_iFunc, arr, m_iId);
} else {
executeForwards(m_iFunc, m_iId);
}
if (isFree())
return;
// set new exec time OR remove the task if needed
if (m_bLoop || (--m_iRepeat > 0))
{
m_fNextExecTime += m_fBase;
}
else
{
unregisterSPForward(m_iFunc);
m_iFunc = -1;
m_bFree = true;
} }
} }
} }
CTaskMngr::CTask::CTask() CTaskMngr::CTask* CTaskMngr::getFirstValidTask(CTask* h){
{ CTask* a = h;
m_bFree = true; while( a ) {
if ( a->isRemoved() ) {
CTask* b = a->next;
unlink( a );
delete a;
a = b;
continue;
}
else if ( a->afterstart ){
if ( *m_timer - *m_timeleft + 1 < a->base_time ) {
a = a->next;
continue;
}
}
else if ( a->beforeend ){
if ( *m_timelimit == 0 ){
a = a->next;
continue;
}
if ( (*m_timeleft + *m_timelimit * 60.0) - *m_timer - 1 >
a->base_time ){
a = a->next;
continue;
}
}
else if ( a->exec_time > *m_timer ) {
a = a->next;
continue;
}
return a;
}
return 0;
} }
CTaskMngr::CTask::~CTask() CTaskMngr::CTask* CTaskMngr::getNextTask(CTask* a) {
{ if ( a->isRemoved() )
return a->next;
if ( a->loop || a->isToReply() ){
a->exec_time = *m_timer + a->base_time;
return a->next;
}
a->setToRemove();
return a->next;
}
CTaskMngr::CTaskMngr() {
head = 0;
tail = 0;
m_timer = 0;
m_timelimit = 0;
m_timeleft = 0;
}
CTaskMngr::~CTaskMngr() {
clear(); clear();
} }
/*********************** CTaskMngr ***********************/ void CTaskMngr::clear() {
CTaskMngr::CTaskMngr() while ( head ) {
{ tail = head->next;
m_pTmr_CurrentTime = NULL; delete head;
m_pTmr_TimeLimit = NULL; head = tail;
m_pTmr_TimeLeft = NULL;
}
void CTaskMngr::registerTimers(float *pCurrentTime, float *pTimeLimit, float *pTimeLeft)
{
m_pTmr_CurrentTime = pCurrentTime;
m_pTmr_TimeLimit = pTimeLimit;
m_pTmr_TimeLeft = pTimeLeft;
}
void CTaskMngr::registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat)
{
// first, search for free tasks
TaskListIter iter = m_Tasks.find(CTaskDescriptor(0, NULL, true));
if (iter)
{
// found: reuse it
iter->set(pPlugin, iFunc, iFlags, iId, fBase, iParamsLen, pParams, iRepeat, *m_pTmr_CurrentTime);
}
else
{
// not found: make a new one
CTask *pTmp = new CTask;
if (!pTmp)
return;
pTmp->set(pPlugin, iFunc, iFlags, iId, fBase, iParamsLen, pParams, iRepeat, *m_pTmr_CurrentTime);
m_Tasks.put(pTmp);
} }
} }
int CTaskMngr::removeTasks(int iId, AMX *pAmx) void CTaskMngr::registerTimers( float* timer , float* timelimit, float* timeleft ) {
{ m_timer = timer;
CTaskDescriptor descriptor(iId, pAmx); m_timelimit = timelimit;
TaskListIter iter = m_Tasks.find(descriptor); m_timeleft = timeleft;
int i=0; }
while (iter)
void CTaskMngr::registerTask( CPluginMngr::CPlugin* plugin, int func,
int flags, int i, float base, float exec,
int parlen , const cell* par, int repeat ){
CTask* a = new CTask(plugin,func,flags,i,base,exec,parlen,par,repeat );
if ( a == 0 ) return;
if ( tail )
{ {
iter->clear(); tail->next = a;
++i; a->prev = tail;
iter = m_Tasks.find(++iter, descriptor); tail = a;
} }
else {
head = a;
tail = a;
}
}
CTaskMngr::CTask* CTaskMngr::findTask( int id , AMX* amx )
{
for (CTask* a = head; a ; a = a->next)
{
if ( !a->isRemoved() && (a->getTaskId() == id) && (!amx ||
(a->getPlugin()->getAMX() == amx)) )
return a;
}
return 0;
}
void CTaskMngr::unlink(CTask* a){
if ( a->prev ) a->prev->next = a->next;
else head = a->next;
if ( a->next ) a->next->prev = a->prev;
else tail = a->prev;
}
int CTaskMngr::removeTasks( int id , AMX* amx )
{
CTask* a;
int i = 0;
while ( (a = findTask(id, amx )) != 0 ) {
a->setToRemove();
++i;
}
return i; return i;
} }
int CTaskMngr::changeTasks(int iId, AMX *pAmx, float fNewBase)
{
CTaskDescriptor descriptor(iId, pAmx);
TaskListIter iter = m_Tasks.find(descriptor);
int i=0;
while (iter)
{
iter->changeBase(fNewBase);
iter->resetNextExecTime(*m_pTmr_CurrentTime);
++i;
iter = m_Tasks.find(++iter, descriptor);
}
return i;
}
bool CTaskMngr::taskExists(int iId, AMX *pAmx)
{
return m_Tasks.find(CTaskDescriptor(iId, pAmx));
}
void CTaskMngr::startFrame()
{
for (TaskListIter iter = m_Tasks.begin(); iter; ++iter)
{
if (iter->isFree())
continue;
iter->executeIfRequired(*m_pTmr_CurrentTime, *m_pTmr_TimeLimit, *m_pTmr_TimeLeft);
}
}
void CTaskMngr::clear()
{
m_Tasks.clear();
}

View File

@ -32,88 +32,95 @@
#ifndef CTASK_H #ifndef CTASK_H
#define CTASK_H #define CTASK_H
// *****************************************************
// class CTaskMngr
// *****************************************************
class CTaskMngr class CTaskMngr
{ {
private: public:
/*** class CTask ***/
class iterator;
class CTask class CTask
{ {
// task settings
CPluginMngr::CPlugin *m_pPlugin;
int m_iId;
int m_iFunc;
int m_iRepeat;
bool m_bLoop;
bool m_bAfterStart;
bool m_bBeforeEnd;
float m_fBase; // for normal tasks, stores the interval, for the others, stores the amount of time before start / after end
int m_iParamLen;
cell *m_pParams;
bool m_bFree;
// execution friend class iterator;
float m_fNextExecTime; friend class CTaskMngr;
CPluginMngr::CPlugin* plugin;
int id;
int func;
int repeat;
bool loop;
bool afterstart;
bool beforeend;
float base_time;
float exec_time;
int param_len;
cell* param;
CTask* next;
CTask* prev;
inline void setToRemove() { exec_time = -1.0f; }
inline bool isToReply() { return (repeat-- > 0); }
inline bool isRemoved() { return (exec_time == -1.0f); }
CTask( CPluginMngr::CPlugin* p, int f, int flags, int i,
float base, float exec, int parlen , const cell* par, int r );
~CTask() { if ( param_len ) delete[] param; }
public: public:
void set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime);
void clear();
bool isFree() const;
CPluginMngr::CPlugin *getPlugin() const; inline int getParamLen() { return param_len; }
int getTaskId() const; inline int getTaskId() { return id; }
inline int getFunction() { return func; }
void executeIfRequired(float fCurrentTime, float fTimeLimit, float fTimeLeft); // also removes the task if needed cell* getParam() { return param; }
CPluginMngr::CPlugin* getPlugin() { return plugin; }
void changeBase(float fNewBase);
void resetNextExecTime(float fCurrentTime);
bool shouldRepeat();
CTask();
~CTask();
}; };
class CTaskDescriptor
{
public:
int m_iId;
AMX *m_pAmx;
bool m_bFree;
CTaskDescriptor(int iId, AMX *pAmx, bool bFree = false)
{
m_iId = iId;
m_pAmx = pAmx;
m_bFree = bFree;
}
friend bool operator == (const CTask &left, const CTaskDescriptor &right) private:
{
if (right.m_bFree) friend class iterator;
return left.isFree(); CTask *head;
CTask *tail;
return !left.isFree() && float* m_timer;
(right.m_pAmx ? left.getPlugin()->getAMX() == right.m_pAmx : true) && float* m_timelimit;
left.getTaskId() == right.m_iId; float* m_timeleft;
} CTask* getFirstValidTask(CTask* a);
}; CTask* getNextTask(CTask* a);
CTask* findTask( int id , AMX* amx );
void unlink(CTask* a);
/*** CTaskMngr priv members ***/
typedef CList<CTask, CTaskDescriptor> TaskList;
typedef TaskList::iterator TaskListIter;
TaskList m_Tasks;
float *m_pTmr_CurrentTime;
float *m_pTmr_TimeLimit;
float *m_pTmr_TimeLeft;
public: public:
CTaskMngr(); CTaskMngr();
~CTaskMngr();
void registerTimers(float *pCurrentTime, float *pTimeLimit, float *pTimeLeft); // The timers will always point to the right value // Interface
void registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat);
int removeTasks(int iId, AMX *pAmx); // remove all tasks that match the id and amx
int changeTasks(int iId, AMX *pAmx, float fNewBase); // change all tasks that match the id and amx void registerTimers( float* timer , float* timelimit, float* timeleft );
bool taskExists(int iId, AMX *pAmx); void registerTask( CPluginMngr::CPlugin* plugin, int func, int flags, int i, float base, float exec, int parlen , const cell* par, int repeat );
void startFrame(); inline int taskExists( int id ,AMX* amx) { return findTask(id,amx ) ? 1 : 0; }
int removeTasks( int id , AMX* amx );
void clear(); void clear();
class iterator {
CTaskMngr* b;
CTask* a;
public:
iterator(CTask*aa,CTaskMngr* bb) : a(aa), b(bb) {}
iterator& operator++() {
a = b->getNextTask( a );
a = b->getFirstValidTask( a );
return *this;
}
CTask& operator*() { return *a; }
operator bool ( ) const { return a ? true : false; }
};
inline iterator begin() { return iterator(getFirstValidTask(head),this); }
}; };
#endif #endif

View File

@ -29,12 +29,11 @@
* version. * version.
*/ */
#include "CVault.h"
#include "CFile.h"
#include <ctype.h> #include <ctype.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "amxmodx.h"
#include "CVault.h"
#include "CFile.h"
// ***************************************************** // *****************************************************
// class Vault // class Vault
@ -60,7 +59,7 @@ void Vault::put( const char* k, const char* v )
if ( *a ) if ( *a )
{ {
(*a)->value.assign(v); (*a)->value.set(v);
(*a)->number = atoi( v ); (*a)->number = atoi( v );
} }
else else
@ -78,7 +77,7 @@ Vault::Obj** Vault::find( const char* n )
while( *a ) while( *a )
{ {
if ( strcmp((*a)->key.c_str(), n) == 0 ) if ( strcmp((*a)->key.str(), n) == 0 )
return a; return a;
a = &(*a)->next; a = &(*a)->next;
@ -107,7 +106,7 @@ const char* Vault::get( const char* n )
if ( b == 0 ) return ""; if ( b == 0 ) return "";
return b->value.c_str(); return b->value.str();
} }
void Vault::clear() void Vault::clear()
@ -133,7 +132,7 @@ void Vault::remove( const char* n )
void Vault::setSource( const char* n ) void Vault::setSource( const char* n )
{ {
path.assign(n); path.set(n);
} }
@ -143,7 +142,7 @@ bool Vault::loadVault( )
clear(); clear();
File a( path.c_str() , "r" ); File a( path.str() , "r" );
if ( !a ) return false; if ( !a ) return false;
@ -165,7 +164,7 @@ bool Vault::saveVault( )
{ {
if ( path.empty() ) return false; if ( path.empty() ) return false;
File a( path.c_str() , "w" ); File a( path.str() , "w" );
if ( !a ) return false; if ( !a ) return false;

View File

@ -1,444 +0,0 @@
/* AMX Mod X
*
* by the AMX Mod X Development Team
* originally developed by OLO
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*/
#ifndef __CVECTOR_H__
#define __CVECTOR_H__
#include <assert.h>
// Vector
template <class T> class CVector
{
bool Grow()
{
// automatic grow
size_t newSize = m_Size * 2;
if (newSize == 0)
newSize = 8; // a good init value
T *newData = new T[newSize];
if (!newData)
return false;
if (m_Data)
{
memcpy(newData, m_Data, m_Size * sizeof(T));
delete [] m_Data;
}
m_Data = newData;
m_Size = newSize;
return true;
}
bool GrowIfNeeded()
{
if (m_CurrentUsedSize >= m_Size)
return Grow();
else
return true;
}
bool ChangeSize(size_t size)
{
// change size
if (size == m_Size)
return true;
T *newData = new T[size];
if (!newData)
return false;
if (m_Data)
{
memcpy(newData, m_Data, (m_Size < size) ? (m_Size * sizeof(T)) : (size * sizeof(T)));
delete [] m_Data;
}
if (m_Size < size)
m_CurrentSize = size;
m_Data = newData;
m_Size = size;
return true;
}
void FreeMemIfPossible()
{
}
protected:
T *m_Data;
size_t m_Size;
size_t m_CurrentUsedSize;
size_t m_CurrentSize;
public:
class iterator
{
protected:
T *m_Ptr;
public:
// constructors / destructors
iterator()
{
m_Ptr = NULL;
}
iterator(T * ptr)
{
m_Ptr = ptr;
}
// member functions
T * base()
{
return m_Ptr;
}
const T * base() const
{
return m_Ptr;
}
// operators
T & operator*()
{
return *m_Ptr;
}
T * operator->()
{
return m_Ptr;
}
iterator & operator++() // preincrement
{
++m_Ptr;
return (*this);
}
iterator operator++(int) // postincrement
{
iterator tmp = *this;
++m_Ptr;
return tmp;
}
iterator & operator--() // predecrement
{
--m_Ptr;
return (*this);
}
iterator operator--(int) // postdecrememnt
{
iterator tmp = *this;
--m_Ptr;
return tmp;
}
bool operator==(T * right) const
{
return (m_Ptr == right);
}
bool operator==(const iterator & right) const
{
return (m_Ptr == right.m_Ptr);
}
bool operator!=(T * right) const
{
return (m_Ptr != right);
}
bool operator!=(const iterator & right) const
{
return (m_Ptr != right.m_Ptr);
}
iterator & operator+=(size_t offset)
{
m_Ptr += offset;
return (*this);
}
iterator & operator-=(size_t offset)
{
m_Ptr += offset;
return (*this);
}
iterator operator+(size_t offset) const
{
iterator tmp(*this);
tmp.m_Ptr += offset;
return tmp;
}
iterator operator-(size_t offset) const
{
iterator tmp(*this);
tmp.m_Ptr += offset;
return tmp;
}
T & operator[](size_t offset)
{
return (*(*this + offset));
}
const T & operator[](size_t offset) const
{
return (*(*this + offset));
}
bool operator<(const iterator & right) const
{
return m_Ptr < right.m_Ptr;
}
bool operator>(const iterator & right) const
{
return m_Ptr > right.m_Ptr;
}
bool operator<=(const iterator & right) const
{
return m_Ptr <= right.m_Ptr;
}
bool operator>=(const iterator & right) const
{
return m_Ptr >= right.m_Ptr;
}
size_t operator-(const iterator & right) const
{
return m_Ptr - right.m_Ptr;
}
};
// constructors / destructors
CVector<T>()
{
m_Size = 0;
m_CurrentUsedSize = 0;
m_Data = NULL;
}
CVector<T>(const CVector<T> & other)
{
// copy data
m_Data = new T [other.m_Size];
m_Size = other.m_Size;
m_CurrentUsedSize = other.m_CurrentUsedSize;
memcpy(m_Data, other.m_Data, m_CurrentUsedSize * sizeof(T));
}
~CVector<T>()
{
clear();
}
// interface
size_t size() const
{
return m_CurrentUsedSize;
}
size_t capacity() const
{
return m_Size;
}
iterator begin()
{
return iterator(m_Data);
}
iterator end()
{
return iterator(m_Data + m_CurrentUsedSize);
}
iterator iterAt(size_t pos)
{
if (pos > m_CurrentUsedSize)
assert(0);
return iterator(m_Data + pos);
}
bool reserve(size_t newSize)
{
return ChangeSize(newSize);
}
bool push_back(const T & elem)
{
++m_CurrentUsedSize;
if (!GrowIfNeeded())
{
--m_CurrentUsedSize;
return false;
}
m_Data[m_CurrentUsedSize - 1] = elem;
return true;
}
void pop_back()
{
--m_CurrentUsedSize;
if (m_CurrentUsedSize < 0)
m_CurrentUsedSize = 0;
// :TODO: free memory sometimes
}
bool resize(size_t newSize)
{
if (!ChangeSize(newSize))
return false;
FreeMemIfPossible();
return true;
}
bool empty() const
{
return (m_CurrentUsedSize == 0);
}
T & at(size_t pos)
{
if (pos > m_CurrentUsedSize)
{
assert(0);
}
return m_Data[pos];
}
const T & at(size_t pos) const
{
if (pos > m_CurrentUsedSize)
{
assert(0);
}
return m_Data[pos];
}
T & operator[](size_t pos)
{
return at(pos);
}
const T & operator[](size_t pos) const
{
return at(pos);
}
T & front()
{
if (m_CurrentUsedSize < 1)
{
assert(0);
}
return m_Data[0];
}
const T & front() const
{
if (m_CurrentUsedSize < 1)
{
assert(0);
}
return m_Data[0];
}
T & back()
{
if (m_CurrentUsedSize < 1)
{
assert(0);
}
return m_Data[m_CurrentUsedSize - 1];
}
const T & back() const
{
if (m_CurrentUsedSize < 1)
{
assert(0);
}
return m_Data[m_CurrentUsedSize - 1];
}
bool insert(iterator where, const T & value)
{
// we have to insert before
// if it is begin, don't decrement
if (where != m_Data)
--where;
// validate iter
if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
return false;
++m_CurrentUsedSize;
if (!GrowIfNeeded())
{
--m_CurrentUsedSize;
return false;
}
memmove(where.base() + 1, where.base(), m_CurrentUsedSize - (where - m_Data));
memcpy(where.base(), &value, sizeof(T));
return true;
}
void erase(iterator where)
{
// validate iter
if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
return false;
if (m_CurrentUsedSize > 1)
{
// move
memmove(where.base(), where.base() + 1, m_CurrentUsedSize - 1);
}
--m_CurrentUsedSize;
// :TODO: free memory sometimes
}
void clear()
{
m_Size = 0;
m_CurrentUsedSize = 0;
delete [] m_Data;
m_Data = NULL;
}
};
#endif // __CVECTOR_H__

File diff suppressed because it is too large Load Diff

Binary file not shown.

Binary file not shown.

View File

@ -1,13 +1,9 @@
MODNAME = amxx_mm MODNAME = amx_mm
SRCFILES = meta_api.cpp CFile.cpp CString.cpp CVault.cpp vault.cpp\ SRCFILES = meta_api.cpp CFile.cpp CString.cpp CVault.cpp vault.cpp\
float.cpp file.cpp modules.cpp CMisc.cpp CTask.cpp string.cpp\ float.cpp file.cpp modules.cpp CMisc.cpp CTask.cpp string.cpp\
amxmodx.cpp CEvent.cpp CCmd.cpp CLogEvent.cpp srvcmd.cpp strptime.cpp\ amxmod.cpp CEvent.cpp CCmd.cpp CLogEvent.cpp srvcmd.cpp strptime.cpp\
CForward.cpp CPlugin.cpp CModule.cpp CMenu.cpp emsg.cpp util.cpp \ CForward.cpp CPlugin.cpp CModule.cpp CMenu.cpp emsg.cpp util.cpp
amxcore.cpp amxtime.cpp power.cpp amxxlog.cpp fakemeta.cpp mmgr/mmgr.cpp \ CSRCFILES = amx.c amxcore.c amxtime.c power.c
amxxfile.cpp CLang.cpp md5.cpp amx.cpp
#use this for amd64, remove the above amx.cpp, and rename amx.cpp to amx.c
#CSRCFILES = amx.c minilzo/minilzo.c
CSRCFILES = minilzo/minilzo.c
EXTRA_LIBS_LINUX = EXTRA_LIBS_LINUX =
EXTRA_LIBS_WIN32 = EXTRA_LIBS_WIN32 =
@ -19,7 +15,7 @@ EXTRA_INCLUDEDIRS = -Iextra/include
EXTRA_FLAGS = -Dstrcmpi=strcasecmp EXTRA_FLAGS = -Dstrcmpi=strcasecmp
SDKTOP=../hlsdk SDKTOP=../hlsdk
METADIR=../metamod/metamod METADIR=../metamodx
SDKSRC=$(SDKTOP)/SourceCode SDKSRC=$(SDKTOP)/SourceCode
@ -33,7 +29,7 @@ else
OS=LINUX OS=LINUX
endif endif
CC_LINUX=gcc CC_LINUX=gcc-2.95
ifeq "$(OS)" "WIN32" ifeq "$(OS)" "WIN32"
CC_WIN32=gcc CC_WIN32=gcc
LD_WINDLL=dllwrap LD_WINDLL=dllwrap
@ -47,8 +43,7 @@ else
endif endif
#use this for AMD64
#LIBFILE_LINUX = $(MODNAME)_amd64.so
LIBFILE_LINUX = $(MODNAME)_i386.so LIBFILE_LINUX = $(MODNAME)_i386.so
LIBFILE_WIN32 = $(MODNAME).dll LIBFILE_WIN32 = $(MODNAME).dll
TARGET_LINUX = $(OBJDIR_LINUX)/$(LIBFILE_LINUX) TARGET_LINUX = $(OBJDIR_LINUX)/$(LIBFILE_LINUX)
@ -65,9 +60,10 @@ OBJC_LINUX := $(CSRCFILES:%.c=$(OBJDIR_LINUX)/%.o)
OBJ_WIN32 := $(SRCFILES:%.cpp=$(OBJDIR_WIN32)/%.o) OBJ_WIN32 := $(SRCFILES:%.cpp=$(OBJDIR_WIN32)/%.o)
OBJC_WIN32 := $(CSRCFILES:%.c=$(OBJDIR_WIN32)/%.o) OBJC_WIN32 := $(CSRCFILES:%.c=$(OBJDIR_WIN32)/%.o)
#use this for amd64
#CCOPT = -m64 -g -ggdb3 -DHAVE_I64 -DSMALL_CELL_SIZE=64 CCOPT = -O2 -march=i686 -ffast-math -funroll-loops \
CCOPT = -march=i386 -s -DNDEBUG -O2 -fomit-frame-pointer -fno-exceptions -fno-rtti -ffast math -fomit-frame-pointer -fexpensive-optimizations -malign-loops=2 \
-malign-jumps=2 -malign-functions=2 -s -DNDEBUG
INCLUDEDIRS=-I../curl/include -I$(SRCDIR) -I$(METADIR) -I$(SDKSRC)/engine -I$(SDKSRC)/common -I$(SDKSRC)/pm_shared -I$(SDKSRC)/dlls -I$(SDKSRC) $(EXTRA_INCLUDEDIRS) INCLUDEDIRS=-I../curl/include -I$(SRCDIR) -I$(METADIR) -I$(SDKSRC)/engine -I$(SDKSRC)/common -I$(SDKSRC)/pm_shared -I$(SDKSRC)/dlls -I$(SDKSRC) $(EXTRA_INCLUDEDIRS)
CFLAGS=-Wall -Wno-unknown-pragmas CFLAGS=-Wall -Wno-unknown-pragmas
@ -101,11 +97,9 @@ $(TARGET_WIN32): $(OBJDIR_WIN32) $(OBJ_WIN32) $(OBJC_WIN32)
$(OBJDIR_LINUX): $(OBJDIR_LINUX):
mkdir $@ mkdir $@
mkdir $@/mmgr
$(OBJDIR_WIN32): $(OBJDIR_WIN32):
mkdir $@ mkdir $@
mkdir $@/mmgr
win32: $(TARGET_WIN32) win32: $(TARGET_WIN32)
@ -120,4 +114,3 @@ clean_both:
clean_win32: clean_win32:
del /q $(OBJDIR_WIN32) del /q $(OBJDIR_WIN32)

View File

@ -1,256 +0,0 @@
#!/usr/bin/perl
#(C)2004 AMX Mod X Development Team
# by David "BAILOPAN" Anderson
# output will occur in bin.x.proc
# where x is debug or opt and proc is ix86 or amd64
# You must use this script from the amxmodx src dir
#options =
# jit - use the JIT
# debug - enable gdb debugging
# amd64 - compile for AMD64 (impiles no jit)
# proc=ix86 - assumed not amd64
# clean - clean the specifications above
# asm - for ASM implementation
# !! TODO - add memory mananger support
# lineop - for JIT only, uses slow version
$PROJECT = "amxmodx_mm";
$sdk = "../hlsdk/SourceCode";
$mm = "../metamod/metamod";
$gccf = "gcc";
$ccf = "cc";
$amd64_lstdc = "-lstdc++";
@CPP_SOURCE_FILES = ("meta_api.cpp", "CFile.cpp", "CVault.cpp", "vault.cpp", "float.cpp", "file.cpp", "modules.cpp", "CMisc.cpp", "CTask.cpp", "string.cpp", "amxmodx.cpp", "CEvent.cpp", "CCmd.cpp", "CLogEvent.cpp", "srvcmd.cpp", "strptime.cpp", "amxcore.cpp", "amxtime.cpp", "power.cpp", "amxxlog.cpp", "fakemeta.cpp", "amxxfile.cpp", "CLang.cpp", "md5.cpp", "emsg.cpp", "CForward.cpp", "CPlugin.cpp", "CModule.cpp", "CMenu.cpp", "util.cpp");
@C_SOURCE_FILES = ();
my %OPTIONS, %OPT;
$OPT{"debug"} = "-g -ggdb";
$OPT{"opt"} = "-O2 -ffast-math -funroll-loops -fomit-frame-pointer -s -DNDEBUG -Wall -Wno-unknown-pragmas -DOPT_TYPE=\"optimized\" -fno-exceptions -fno-rtti";
$OPTIONS{"include"} = "-I$sdk -I. -I$mm -I$sdk/engine -I$sdk/common -I$sdk/pm_shared -I$sdk/dlls";
while ($cmd = shift)
{
if ($cmd =~ /asm/)
{
if ($OPTIONS{"amd64"})
{
die "You cannot compile the ASM core with AMD64 yet.\n";
} else {
$OPTIONS{"asm"} = 1;
}
}
if ($cmd =~ /jit/)
{
if ($OPTIONS{"amd64"})
{
die "You cannot compile the JIT and AMD64 yet.\n";
} else {
$OPTIONS{"jit"} = 1;
}
} elsif ($cmd =~ /amd64/) {
if ($OPTIONS{"jit"} || $OPTIONS{"asm"})
{
die "You cannot compile the JIT or ASM and AMD64 yet.\n";
} else {
$OPTIONS{"amd64"} = 1;
}
} elsif ($cmd =~ /debug/) {
$OPTIONS{"debug"} = 1;
} elsif ($cmd =~ /proc=i(\d)86/) {
$proc = $1;
if ($OPTIONS{"amd64"})
{
die "You cannot compile for i".$proc."86 and AMD64.\n";
} else {
$OPTIONS{"proc"} = "i".$proc."86";
}
} elsif ($cmd =~ /clean/) {
$OPTIONS{"clean"} = 1;
} elsif ($cmd =~ /lineop/) {
$OPTIONS{"lineop"} = 1;
}
}
$gcc = `$gccf --version`;
if ($gcc =~ /2\.9/)
{
#if ($OPTIONS{"jit"})
#{
# push(@CPP_SOURCE_FILES, "amx.cpp");
# $OPT{"opt"} .= " -malign-loops=2 -malign-jumps=2 -malign-functions=2";
# } else {
`ln -s amx.cpp amx.c`;
push(@C_SOURCE_FILES, "amx.c");
# }
} else {
if ($OPTIONS{"amd64"})
{
`ln -s amx.cpp amx.c`;
push(@C_SOURCE_FILES, "amx.c");
} else {
push(@CPP_SOURCE_FILES, "amx.cpp");
}
$OPT{"opt"} .= " -falign-loops=2 -falign-jumps=2 -falign-functions=2";
}
if ($OPTIONS{"debug"})
{
$cflags = $OPT{"debug"};
} else {
if (!$OPTIONS{"amd64"})
{
$proc = $OPTIONS{"proc"};
if (!$proc)
{
$proc = 3;
}
$cflags = "-march=i".$proc."86 ".$OPT{"opt"};
} else {
$cflags = $OPT{"opt"};
}
}
if ($OPTIONS{"amd64"})
{
$cflags = " -m64 -DSMALL_CELL_SIZE=64 -DHAVE_I64 $cflags";
}
if ($OPTIONS{"jit"})
{
$cflags .= " -DJIT";
}
if ($OPTIONS{"asm"})
{
$cflags .= " -DASM32";
}
if ($OPTIONS{"debug"})
{
$outdir = "bin.debug";
} else {
$outdir = "bin.opt";
}
if ($OPTIONS{"amd64"})
{
$outdir .= ".amd64";
$bin = $PROJECT."_amd64.so";
} else {
$proc = $OPTIONS{"proc"};
if ($proc)
{
$outdir .= ".i".$proc."86";
$bin = $PROJECT."_i".$proc."86.so";
} else {
$outdir .= ".i386";
$bin = $PROJECT."_i386.so";
}
}
if ($OPTIONS{"clean"})
{
`rm $outdir/*.o`;
`rm $outdir/$bin`;
die("Project cleaned.\n");
}
#create the dirs
#build link list
my @LINK;
for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
{
$file = $CPP_SOURCE_FILES[$i];
$file =~ s/\.cpp/\.o/;
push(@LINK, $outdir."/".$file);
}
for ($i=0; $i<=$#C_SOURCE_FILES; $i++)
{
$file = $C_SOURCE_FILES[$i];
$file =~ s/\.c/\.o/;
push(@LINK, $outdir."/".$file);
}
if ($OPTIONS{"jit"})
{
if ($OPTIONS{"lineop"}) {
push(@LINK, "JIT/jits-lineop.o");
} else {
push(@LINK, "JIT/jits.o");
}
}
if ($OPTIONS{"amd64"})
{
push(@LINK, "zlib/libz64.a");
push(@LINK, $amd64_lstdc);
} else {
push(@LINK, "zlib/libz.a");
}
if ($OPTIONS{"asm"})
{
push(@LINK, "amxexecn.o");
}
if (!(-d $outdir))
{
mkdir($outdir);
}
if (!(-d "$outdir/JIT"))
{
mkdir("$outdir/JIT");
}
$inc = $OPTIONS{"include"};
for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
{
$file = $CPP_SOURCE_FILES[$i];
$ofile = $file;
$ofile =~ s/\.cpp/\.o/;
$ofile = "$outdir/$ofile";
$gcc = "$gccf $cflags -Dstrcmpi=strcasecmp -fPIC $inc -c $file -o $ofile";
if (-e $ofile)
{
$file_time = (stat($file))[9];
$ofile_time = (stat($ofile))[9];
if ($file_time > $ofile_time)
{
`rm $ofile`;
print "$gcc\n";
`$gcc`;
}
} else {
print "$gcc\n";
`$gcc`;
}
}
for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
{
$file = $C_SOURCE_FILES[$i];
$ofile = $file;
$ofile =~ s/\.c/\.o/;
$ofile = "$outdir/$ofile";
$gcc = "$ccf $cflags -Dstrcmpi=strcasecmp -fPIC $inc -c $file -o $ofile";
if (-e $ofile)
{
$file_time = (stat($file))[9];
$ofile_time = (stat($ofile))[9];
if ($file_time > $ofile_time)
{
print "$gcc\n";
`$gcc`;
}
} else {
print "$gcc\n";
`$gcc`;
}
}
$gcc = "$gccf $cflags -shared -ldl -lm @LINK -o $outdir/$bin";
print "$gcc\n";
`$gcc`;

File diff suppressed because it is too large Load Diff

View File

@ -1,6 +1,6 @@
/* Abstract Machine for the Small compiler /* Abstract Machine for the Small compiler
* *
* Copyright (c) ITB CompuPhase, 1997-2004 * Copyright (c) ITB CompuPhase, 1997-2003
* *
* This software is provided "as-is", without any express or implied warranty. * This software is provided "as-is", without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from * In no event will the authors be held liable for any damages arising from
@ -10,32 +10,18 @@
* including commercial applications, and to alter it and redistribute it * including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions: * freely, subject to the following restrictions:
* *
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software in
* a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/ */
#if defined __linux__ #if defined __linux__
#include <sclinux.h> #include <sclinux.h>
#endif #endif
#ifndef __AMX_H
#ifndef AMX_H_INCLUDED #define __AMX_H
#define AMX_H_INCLUDED #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
#if defined __LCC__ || defined __DMC__ || defined __linux__
#include <stdint.h>
#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
/* The ISO C99 defines the int16_t and int_32t types. If the compiler got /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
* here, these types are probably undefined. * here, these types are probably undefined.
*/ */
#if defined __FreeBSD__ #if defined __LCC__ || defined __linux__
#include <inttypes.h> #include <stdint.h>
#else #else
typedef short int int16_t; typedef short int int16_t;
typedef unsigned short int uint16_t; typedef unsigned short int uint16_t;
@ -46,28 +32,16 @@
typedef long int int32_t; typedef long int int32_t;
typedef unsigned long int uint32_t; typedef unsigned long int uint32_t;
#endif #endif
#if defined __WIN32__ || defined _WIN32 || defined WIN32
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#define HAVE_I64
#elif defined __GNUC__
typedef long long int64_t;
typedef unsigned long long uint64_t;
#define HAVE_I64
#endif
#endif #endif
#endif #endif
#if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined __MSDOS__
#if defined __WIN32__ || defined _WIN32 || defined WIN32 /* || defined __MSDOS__ */
#if !defined alloca #if !defined alloca
#define alloca(n) _alloca(n) #define alloca(n) _alloca(n)
#endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* calling convention for native functions */ /* calling convention for native functions */
#if !defined AMX_NATIVE_CALL #if !defined AMX_NATIVE_CALL
#define AMX_NATIVE_CALL #define AMX_NATIVE_CALL
@ -85,7 +59,6 @@ extern "C" {
#if !defined AMXEXPORT #if !defined AMXEXPORT
#define AMXEXPORT #define AMXEXPORT
#endif #endif
/* File format version Required AMX version /* File format version Required AMX version
* 0 (original version) 0 * 0 (original version) 0
* 1 (opcodes JUMP.pri, SWITCH and CASETBL) 1 * 1 (opcodes JUMP.pri, SWITCH and CASETBL) 1
@ -99,65 +72,40 @@ extern "C" {
#define CUR_FILE_VERSION 7 /* current file version; also the current AMX version */ #define CUR_FILE_VERSION 7 /* current file version; also the current AMX version */
#define MIN_FILE_VERSION 6 /* lowest supported file format version for the current AMX version */ #define MIN_FILE_VERSION 6 /* lowest supported file format version for the current AMX version */
#define MIN_AMX_VERSION 7 /* minimum AMX version needed to support the current file format */ #define MIN_AMX_VERSION 7 /* minimum AMX version needed to support the current file format */
#if !defined CELL_TYPE
#if defined BIT16 #define CELL_TYPE
#define SMALL_CELL_SIZE 16 /* for backward compatibility */ #if defined(BIT16)
typedef uint16_t ucell; /* only for type casting */
typedef int16_t cell;
#else
typedef uint32_t ucell;
typedef int32_t cell;
#endif
#endif #endif
#if !defined SMALL_CELL_SIZE
#define SMALL_CELL_SIZE 32 /* by default, use 32-bit cells */
#endif
#if SMALL_CELL_SIZE==16
typedef uint16_t ucell;
typedef int16_t cell;
#elif SMALL_CELL_SIZE==32
typedef uint32_t ucell;
typedef int32_t cell;
#elif SMALL_CELL_SIZE==64
typedef uint64_t ucell;
typedef int64_t cell;
#else
#error Unsupported cell size (SMALL_CELL_SIZE)
#endif
#if SMALL_CELL_SIZE==32
#define REAL float
#elif SMALL_CELL_SIZE==64
#define REAL double
#else
#error Unsupported cell size
#endif
#define UNPACKEDMAX ((1 << (sizeof(cell)-1)*8) - 1)
struct tagAMX; struct tagAMX;
typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params); typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params);
typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index, typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index,
cell *result, cell *params); cell *result, cell *params);
typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx); typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
#if !defined _FAR #if !defined _FAR
#define _FAR #define _FAR
#endif #endif
#if defined _MSC_VER #if defined _MSC_VER
#pragma warning(disable:4103) /* disable warning message 4103 that complains #pragma warning(disable:4103) /* disable warning message 4103 that complains
* about pragma pack in a header file */ * about pragma pack in a header file */
#pragma warning(disable:4100) /* "'%$S' : unreferenced formal parameter" */ #pragma warning(disable:4100) /* "'%$S' : unreferenced formal parameter" */
#endif #endif
/* Some compilers do not support the #pragma align, which should be fine. Some /* Some compilers do not support the #pragma align, which should be fine. Some
* compilers give a warning on unknown #pragmas, which is not so fine... * compilers give a warning on unknown #pragmas, which is not so fine...
*/ */
#if defined SN_TARGET_PS2 || defined __GNUC__ #if defined SN_TARGET_PS2 || defined __GNUC__
#define AMX_NO_ALIGN #define AMX_NO_ALIGN
#endif #endif
#if defined __GNUC__ #if defined __GNUC__
#define PACKED __attribute__((packed)) #define PACKED __attribute__((packed))
#else #else
#define PACKED #define PACKED
#endif #endif
#if !defined AMX_NO_ALIGN #if !defined AMX_NO_ALIGN
#if defined __linux__ #if defined __linux__
#pragma pack(1) /* structures must be packed (byte-aligned) */ #pragma pack(1) /* structures must be packed (byte-aligned) */
@ -169,21 +117,17 @@ typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
#endif #endif
#endif #endif
#endif #endif
typedef struct { typedef struct {
const char _FAR *name PACKED; char _FAR *name PACKED;
AMX_NATIVE func PACKED; AMX_NATIVE func PACKED;
} AMX_NATIVE_INFO; } AMX_NATIVE_INFO PACKED;
#define AMX_USERNUM 4 #define AMX_USERNUM 4
#define sEXPMAX 19 /* maximum name length for file version <= 6 */ #define sEXPMAX 19 /* maximum name length for file version <= 6 */
#define sNAMEMAX 31 /* maximum name length of symbol name */ #define sNAMEMAX 31 /* maximum name length of symbol name */
typedef struct tagAMX_FUNCSTUB { typedef struct tagAMX_FUNCSTUB {
ucell address PACKED; uint32_t address PACKED;
const char name[sEXPMAX+1] PACKED; char name[sEXPMAX+1] PACKED;
} AMX_FUNCSTUB; } AMX_FUNCSTUB PACKED;
/* The AMX structure is the internal structure for many functions. Not all /* The AMX structure is the internal structure for many functions. Not all
* fields are valid at all times; many fields are cached in local variables. * fields are valid at all times; many fields are cached in local variables.
*/ */
@ -217,12 +161,13 @@ typedef struct tagAMX {
cell alt PACKED; cell alt PACKED;
cell reset_stk PACKED; cell reset_stk PACKED;
cell reset_hea PACKED; cell reset_hea PACKED;
cell sysreq_d PACKED; /* relocated address/value for the SYSREQ.D opcode */ cell _FAR *syscall_d PACKED; /* relocated value/address for the SYSCALL.D opcode */
#if defined JIT
/* support variables for the JIT */ /* support variables for the JIT */
int reloc_size PACKED; /* required temporary buffer for relocations */ int reloc_size PACKED; /* required temporary buffer for relocations */
long code_size PACKED; /* estimated memory footprint of the native code */ long code_size PACKED; /* estimated memory footprint of the native code */
} AMX; #endif
} AMX PACKED;
/* The AMX_HEADER structure is both the memory format as the file format. The /* The AMX_HEADER structure is both the memory format as the file format. The
* structure is used internaly. * structure is used internaly.
*/ */
@ -246,24 +191,6 @@ typedef struct tagAMX_HEADER {
int32_t nametable PACKED; /* name table, file version 7 only */ int32_t nametable PACKED; /* name table, file version 7 only */
} AMX_HEADER PACKED; } AMX_HEADER PACKED;
#define AMX_MAGIC 0xf1e0 #define AMX_MAGIC 0xf1e0
//double linked list for stack
typedef struct tagAMX_TRACE
{
cell line PACKED;
cell file PACKED;
struct tagAMX_TRACE *next PACKED;
struct tagAMX_TRACE *prev PACKED;
} AMX_TRACE PACKED;
typedef struct tagAMX_DBG
{
int32_t numFiles PACKED; /* number of chars in array */
char **files PACKED; /* array of files */
AMX_TRACE *head PACKED; /* begin of link list */
AMX_TRACE *tail PACKED; /* end of link list */
} AMX_DBG PACKED;
enum { enum {
AMX_ERR_NONE, AMX_ERR_NONE,
/* reserve the first 15 error codes for exit codes of the abstract machine */ /* reserve the first 15 error codes for exit codes of the abstract machine */
@ -279,7 +206,6 @@ enum {
AMX_ERR_NATIVE, /* native function failed */ AMX_ERR_NATIVE, /* native function failed */
AMX_ERR_DIVIDE, /* divide by zero */ AMX_ERR_DIVIDE, /* divide by zero */
AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */ AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */
AMX_ERR_MEMORY = 16, /* out of memory */ AMX_ERR_MEMORY = 16, /* out of memory */
AMX_ERR_FORMAT, /* invalid file format */ AMX_ERR_FORMAT, /* invalid file format */
AMX_ERR_VERSION, /* file is for a newer version of the AMX */ AMX_ERR_VERSION, /* file is for a newer version of the AMX */
@ -292,7 +218,6 @@ enum {
AMX_ERR_PARAMS, /* parameter error */ AMX_ERR_PARAMS, /* parameter error */
AMX_ERR_DOMAIN, /* domain error, expression result does not fit in range */ AMX_ERR_DOMAIN, /* domain error, expression result does not fit in range */
}; };
enum { enum {
DBG_INIT, /* query/initialize */ DBG_INIT, /* query/initialize */
DBG_FILE, /* file number in curfile, filename in name */ DBG_FILE, /* file number in curfile, filename in name */
@ -305,88 +230,58 @@ enum {
DBG_SRANGE, /* symbol size and dimensions (arrays); level in dbgaddr (!); length in dbgparam */ DBG_SRANGE, /* symbol size and dimensions (arrays); level in dbgaddr (!); length in dbgparam */
DBG_SYMTAG, /* tag of the most recent symbol (if non-zero), tag in dbgparam */ DBG_SYMTAG, /* tag of the most recent symbol (if non-zero), tag in dbgparam */
}; };
#define AMX_FLAG_CHAR16 0x01 /* characters are 16-bit */
/* AMX_FLAG_CHAR16 0x01 no longer used */
#define AMX_FLAG_DEBUG 0x02 /* symbolic info. available */ #define AMX_FLAG_DEBUG 0x02 /* symbolic info. available */
#define AMX_FLAG_COMPACT 0x04 /* compact encoding */ #define AMX_FLAG_COMPACT 0x04 /* compact encoding */
#define AMX_FLAG_BIGENDIAN 0x08 /* big endian encoding */ #define AMX_FLAG_BIGENDIAN 0x08 /* big endian encoding */
#define AMX_FLAG_NOCHECKS 0x10 /* no array bounds checking */ #define AMX_FLAG_NOCHECKS 0x10 /* no array bounds checking */
#define AMX_FLAG_LINEOPS 0x20 /* line ops are parsed by the JIT [loadtime only flag] */
#define AMX_FLAG_TRACED 0x40 /* the file has already been traced */
#define AMX_FLAG_BROWSE 0x4000 /* browsing/relocating or executing */ #define AMX_FLAG_BROWSE 0x4000 /* browsing/relocating or executing */
#define AMX_FLAG_RELOC 0x8000 /* jump/call addresses relocated */ #define AMX_FLAG_RELOC 0x8000 /* jump/call addresses relocated */
#define AMX_EXEC_MAIN -1 /* start at program entry point */ #define AMX_EXEC_MAIN -1 /* start at program entry point */
#define AMX_EXEC_CONT -2 /* continue from last address */ #define AMX_EXEC_CONT -2 /* continue from last address */
#define AMX_USERTAG(a,b,c,d) ((a) | ((b)<<8) | ((long)(c)<<16) | ((long)(d)<<24)) #define AMX_USERTAG(a,b,c,d) ((a) | ((b)<<8) | ((long)(c)<<16) | ((long)(d)<<24))
#define AMX_EXPANDMARGIN 64 #define AMX_EXPANDMARGIN 64
/* for native functions that use floating point parameters, the following /* for native functions that use floating point parameters, the following
* two macros are convenient for casting a "cell" into a "float" type _without_ * two macros are convenient for casting a "cell" into a "float" type _without_
* changing the bit pattern * changing the bit pattern
*/ */
#if SMALL_CELL_SIZE==32 #define amx_ftoc(f) ( * ((cell*)&f) ) /* float to cell */
#define amx_ftoc(f) ( * ((cell*)&f) ) /* float to cell */ #define amx_ctof(c) ( * ((float*)&c) ) /* cell to float */
#define amx_ctof(c) ( * ((float*)&c) ) /* cell to float */ #define amx_StrParam(amx,param,result) { \
#elif SMALL_CELL_SIZE==64 cell *amx_cstr_; int amx_length_; \
#define amx_ftoc(f) ( * ((cell*)&f) ) /* float to cell */ amx_GetAddr((amx), (param), &amx_cstr_); \
#define amx_ctof(c) ( * ((double*)&c) ) /* cell to float */ amx_StrLen(amx_cstr_, &amx_length_); \
#else if (amx_length_ > 0 && \
#error Unsupported cell size ((result) = (char*)alloca(amx_length_ + 1)) != NULL) \
#endif amx_GetString((result), amx_cstr_); \
else (result) = NULL; \
#define amx_StrParam(amx,param,result) \ }
do { \
cell *amx_cstr_; int amx_length_; \
amx_GetAddr((amx), (param), &amx_cstr_); \
amx_StrLen(amx_cstr_, &amx_length_); \
if (amx_length_ > 0 && \
((result) = (void*)alloca((amx_length_ + 1) * sizeof(*(result)))) != NULL) \
amx_GetString((char*)(result), amx_cstr_, sizeof(*(result))>1); \
else (result) = NULL; \
} while (0)
uint16_t * AMXAPI amx_Align16(uint16_t *v); uint16_t * AMXAPI amx_Align16(uint16_t *v);
uint32_t * AMXAPI amx_Align32(uint32_t *v); uint32_t * AMXAPI amx_Align32(uint32_t *v);
#if defined _I64_MAX || defined HAVE_I64
uint64_t * AMXAPI amx_Align64(uint64_t *v);
#endif
#if SMALL_CELL_SIZE==32
#define amx_AlignCell amx_Align32
#elif SMALL_CELL_SIZE==64
#define amx_AlignCell amx_Align64
#else
#error Unsupported cell size
#endif
int AMXAPI amx_Allot(AMX *amx, int cells, cell *amx_addr, cell **phys_addr); int AMXAPI amx_Allot(AMX *amx, int cells, cell *amx_addr, cell **phys_addr);
int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params); int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params);
int AMXAPI amx_Cleanup(AMX *amx); int AMXAPI amx_Cleanup(AMX *amx);
int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data); int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data);
int AMXAPI amx_Debug(AMX *amx); /* default debug procedure, does nothing */ int AMXAPI amx_Debug(AMX *amx); /* default debug procedure, does nothing */
int AMXAPI amx_DebugCall(AMX *amx, int mode);
int AMXAPI amx_Exec(AMX *amx, cell *retval, int index, int numparams, ...); int AMXAPI amx_Exec(AMX *amx, cell *retval, int index, int numparams, ...);
int AMXAPI amx_Execv(AMX *amx, cell *retval, int index, int numparams, cell params[]); int AMXAPI amx_Execv(AMX *amx, cell *retval, int index, int numparams, cell params[]);
int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index); int AMXAPI amx_FindNative(AMX *amx, char *name, int *index);
int AMXAPI amx_FindPublic(AMX *amx, const char *funcname, int *index); int AMXAPI amx_FindPublic(AMX *amx, char *funcname, int *index);
int AMXAPI amx_FindPubVar(AMX *amx, const char *varname, cell *amx_addr); int AMXAPI amx_FindPubVar(AMX *amx, char *varname, cell *amx_addr);
int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname); int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname);
int AMXAPI amx_Flags(AMX *amx,uint16_t *flags); int AMXAPI amx_Flags(AMX *amx,uint16_t *flags);
int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr); int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr);
int AMXAPI amx_GetNative(AMX *amx, int index, char *funcname); int AMXAPI amx_GetNative(AMX *amx, int index, char *funcname);
int AMXAPI amx_GetPublic(AMX *amx, int index, char *funcname); int AMXAPI amx_GetPublic(AMX *amx, int index, char *funcname);
int AMXAPI amx_GetPubVar(AMX *amx, int index, char *varname, cell *amx_addr); int AMXAPI amx_GetPubVar(AMX *amx, int index, char *varname, cell *amx_addr);
int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar); int AMXAPI amx_GetString(char *dest,cell *source);
int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id); int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id);
int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr); int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr);
int AMXAPI amx_Init(AMX *amx, void *program); int AMXAPI amx_Init(AMX *amx, void *program);
int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code); int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code);
int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap); int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap);
int AMXAPI amx_NameLength(AMX *amx, int *length); int AMXAPI amx_NameLength(AMX *amx, int *length);
AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name,AMX_NATIVE func); AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(char *name,AMX_NATIVE func);
int AMXAPI amx_NumNatives(AMX *amx, int *number); int AMXAPI amx_NumNatives(AMX *amx, int *number);
int AMXAPI amx_NumPublics(AMX *amx, int *number); int AMXAPI amx_NumPublics(AMX *amx, int *number);
int AMXAPI amx_NumPubVars(AMX *amx, int *number); int AMXAPI amx_NumPubVars(AMX *amx, int *number);
@ -396,14 +291,10 @@ int AMXAPI amx_Register(AMX *amx, AMX_NATIVE_INFO *nativelist, int number);
int AMXAPI amx_Release(AMX *amx, cell amx_addr); int AMXAPI amx_Release(AMX *amx, cell amx_addr);
int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback); int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback);
int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug); int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug);
int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar); int AMXAPI amx_SetString(cell *dest, char *source, int pack);
int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr); int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr);
char * AMXAPI amx_StrError(int errnum);
int AMXAPI amx_StrLen(cell *cstring, int *length); int AMXAPI amx_StrLen(cell *cstring, int *length);
int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value);
int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value);
int AMXAPI amx_UTF8Check(const char *string);
void amx_NullNativeTable(AMX *amx);
#if !defined AMX_NO_ALIGN #if !defined AMX_NO_ALIGN
#if defined __linux__ #if defined __linux__
#pragma pack() /* reset default packing */ #pragma pack() /* reset default packing */
@ -411,9 +302,7 @@ void amx_NullNativeTable(AMX *amx);
#pragma pack(pop) /* reset previous packing */ #pragma pack(pop) /* reset previous packing */
#endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* __AMX_H */
#endif /* AMX_H_INCLUDED */

View File

@ -1,69 +1,24 @@
/* Core module for the Small AMX /* Core module for the Small AMX
* *
* Copyright (c) ITB CompuPhase, 1997-2004 * Copyright (c) ITB CompuPhase, 1997-2002
* * This file may be freely used. No warranties of any kind.
* This software is provided "as-is", without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from
* the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software in
* a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
* *
* Version: $Id$ * Version: $Id$
*/ */
#if defined _UNICODE || defined __UNICODE__ || defined UNICODE
# if !defined UNICODE /* for Windows */
# define UNICODE
# endif
# if !defined _UNICODE /* for C library */
# define _UNICODE
# endif
#endif
#include <ctype.h> #include <ctype.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <limits.h> #include <limits.h>
#include <assert.h> #include <assert.h>
// this file does not include amxmodx.h, so we have to include the memory manager here
#ifdef MEMORY_TEST
#include "mmgr/mmgr.h"
#endif // MEMORY_TEST
#include "amx.h" #include "amx.h"
#if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined _Windows #define NOPROPLIST
#include <windows.h>
#endif
/* A few compilers do not provide the ANSI C standard "time" functions */ /* A few compilers do not provide the ANSI C standard "time" functions */
#if !defined SN_TARGET_PS2 && !defined _WIN32_WCE #if !defined SN_TARGET_PS2 && !defined _WIN32_WCE
#include <time.h> #include <time.h>
#endif #endif
#if defined _UNICODE
# include <tchar.h>
#elif !defined __T
typedef char TCHAR;
# define __T(string) string
# define _tcschr strchr
# define _tcscpy strcpy
# define _tcsdup strdup
# define _tcslen strlen
# define _stprintf sprintf
#endif
#define CHARBITS (8*sizeof(char)) #define CHARBITS (8*sizeof(char))
typedef unsigned char uchar; typedef unsigned char uchar;
@ -73,7 +28,6 @@ typedef struct _property_list {
cell id; cell id;
char *name; char *name;
cell value; cell value;
//??? safe AMX (owner of the property)
} proplist; } proplist;
static proplist proproot = { NULL }; static proplist proproot = { NULL };
@ -152,7 +106,7 @@ static cell AMX_NATIVE_CALL numargs(AMX *amx, cell *params)
cell bytes; cell bytes;
hdr=(AMX_HEADER *)amx->base; hdr=(AMX_HEADER *)amx->base;
data=amx->data ? amx->data : amx->base+(int)hdr->dat; data=amx->base+(int)hdr->dat;
/* the number of bytes is on the stack, at "frm + 2*cell" */ /* the number of bytes is on the stack, at "frm + 2*cell" */
bytes= * (cell *)(data+(int)amx->frm+2*sizeof(cell)); bytes= * (cell *)(data+(int)amx->frm+2*sizeof(cell));
/* the number of arguments is the number of bytes divided /* the number of arguments is the number of bytes divided
@ -167,7 +121,7 @@ static cell AMX_NATIVE_CALL getarg(AMX *amx, cell *params)
cell value; cell value;
hdr=(AMX_HEADER *)amx->base; hdr=(AMX_HEADER *)amx->base;
data=amx->data ? amx->data : amx->base+(int)hdr->dat; data=amx->base+(int)hdr->dat;
/* get the base value */ /* get the base value */
value= * (cell *)(data+(int)amx->frm+((int)params[1]+3)*sizeof(cell)); value= * (cell *)(data+(int)amx->frm+((int)params[1]+3)*sizeof(cell));
/* adjust the address in "value" in case of an array access */ /* adjust the address in "value" in case of an array access */
@ -184,13 +138,13 @@ static cell AMX_NATIVE_CALL setarg(AMX *amx, cell *params)
cell value; cell value;
hdr=(AMX_HEADER *)amx->base; hdr=(AMX_HEADER *)amx->base;
data=amx->data ? amx->data : amx->base+(int)hdr->dat; data=amx->base+(int)hdr->dat;
/* get the base value */ /* get the base value */
value= * (cell *)(data+(int)amx->frm+((int)params[1]+3)*sizeof(cell)); value= * (cell *)(data+(int)amx->frm+((int)params[1]+3)*sizeof(cell));
/* adjust the address in "value" in case of an array access */ /* adjust the address in "value" in case of an array access */
value+=params[2]*sizeof(cell); value+=params[2]*sizeof(cell);
/* verify the address */ /* verify the address */
if (value<0 || (value>=amx->hea && value<amx->stk)) if (value<0 || value>=amx->hea && value<amx->stk)
return 0; return 0;
/* set the value indirectly */ /* set the value indirectly */
* (cell *)(data+(int)value) = params[3]; * (cell *)(data+(int)value) = params[3];
@ -220,7 +174,7 @@ static cell AMX_NATIVE_CALL funcidx(AMX *amx,cell *params)
return 0; return 0;
} /* if */ } /* if */
amx_GetString(name,cstr,0); amx_GetString(name,cstr);
err=amx_FindPublic(amx,name,&index); err=amx_FindPublic(amx,name,&index);
if (err!=AMX_ERR_NONE) if (err!=AMX_ERR_NONE)
index=-1; /* this is not considered a fatal error */ index=-1; /* this is not considered a fatal error */
@ -232,7 +186,7 @@ int amx_StrPack(cell *dest,cell *source)
int len; int len;
amx_StrLen(source,&len); amx_StrLen(source,&len);
if ((ucell)*source>UNPACKEDMAX) { if ((ucell)*source>UCHAR_MAX) {
/* source string is already packed */ /* source string is already packed */
while (len >= 0) { while (len >= 0) {
*dest++ = *source++; *dest++ = *source++;
@ -260,7 +214,7 @@ int amx_StrPack(cell *dest,cell *source)
int amx_StrUnpack(cell *dest,cell *source) int amx_StrUnpack(cell *dest,cell *source)
{ {
if ((ucell)*source>UNPACKEDMAX) { if ((ucell)*source>UCHAR_MAX) {
/* unpack string, from top down (so string can be unpacked in place) */ /* unpack string, from top down (so string can be unpacked in place) */
cell c; cell c;
int i,len; int i,len;
@ -302,15 +256,14 @@ static cell AMX_NATIVE_CALL core_strlen(AMX *amx,cell *params)
static cell AMX_NATIVE_CALL strpack(AMX *amx,cell *params) static cell AMX_NATIVE_CALL strpack(AMX *amx,cell *params)
{ {
cell *cdest,*csrc; cell *cdest,*csrc;
int len,needed,err; int len,needed,lastaddr,err;
size_t lastaddr;
/* calculate number of cells needed for (packed) destination */ /* calculate number of cells needed for (packed) destination */
amx_GetAddr(amx,params[2],&csrc); amx_GetAddr(amx,params[2],&csrc);
amx_StrLen(csrc,&len); amx_StrLen(csrc,&len);
needed=(len+sizeof(cell))/sizeof(cell); /* # of cells needed */ needed=(len+sizeof(cell))/sizeof(cell); /* # of cells needed */
assert(needed>0); assert(needed>0);
lastaddr=(size_t)(params[1]+sizeof(cell)*needed-1); lastaddr=params[1]+sizeof(cell)*needed-1;
if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE) if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE)
return 0; return 0;
@ -325,14 +278,13 @@ static cell AMX_NATIVE_CALL strpack(AMX *amx,cell *params)
static cell AMX_NATIVE_CALL strunpack(AMX *amx,cell *params) static cell AMX_NATIVE_CALL strunpack(AMX *amx,cell *params)
{ {
cell *cdest,*csrc; cell *cdest,*csrc;
int len,err; int len,err,lastaddr;
size_t lastaddr;
/* calculate number of cells needed for (packed) destination */ /* calculate number of cells needed for (packed) destination */
amx_GetAddr(amx,params[2],&csrc); amx_GetAddr(amx,params[2],&csrc);
amx_StrLen(csrc,&len); amx_StrLen(csrc,&len);
assert(len>=0); assert(len>=0);
lastaddr=(size_t)(params[1]+sizeof(cell)*(len+1)-1); lastaddr=params[1]+sizeof(cell)*(len+1)-1;
if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE) if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE)
return 0; return 0;
@ -351,46 +303,27 @@ static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
{ {
union { union {
cell c; cell c;
#if SMALL_CELL_SIZE==16 #if defined BIT16
uchar b[2]; uchar b[2];
#elif SMALL_CELL_SIZE==32 #else
uchar b[4]; uchar b[4];
#elif SMALL_CELL_SIZE==64
uchar b[8];
#else
#error Unsupported cell size
#endif #endif
} value; } value;
uchar t; uchar t;
assert((size_t)params[0]==sizeof(cell)); assert((size_t)params[0]==sizeof(cell));
value.c = params[1]; value.c = params[1];
#if SMALL_CELL_SIZE==16 #if defined BIT16
t = value.b[0]; t = value.b[0];
value.b[0] = value.b[1]; value.b[0] = value.b[1];
value.b[1] = t; value.b[1] = t;
#elif SMALL_CELL_SIZE==32 #else
t = value.b[0]; t = value.b[0];
value.b[0] = value.b[3]; value.b[0] = value.b[3];
value.b[3] = t; value.b[3] = t;
t = value.b[1]; t = value.b[1];
value.b[1] = value.b[2]; value.b[1] = value.b[2];
value.b[2] = t; value.b[2] = t;
#elif SMALL_CELL_SIZE==64
t = value.b[0];
value.b[0] = value.b[7];
value.b[7] = t;
t = value.b[1];
value.b[1] = value.b[6];
value.b[6] = t;
t = value.b[2];
value.b[2] = value.b[5];
value.b[5] = t;
t = value.b[3];
value.b[3] = value.b[4];
value.b[4] = t;
#else
#error Unsupported cell size
#endif #endif
return value.c; return value.c;
} }
@ -400,13 +333,8 @@ static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
#endif #endif
static cell AMX_NATIVE_CALL core_tolower(AMX *amx,cell *params) static cell AMX_NATIVE_CALL core_tolower(AMX *amx,cell *params)
{ {
#if defined __WIN32__ || defined _WIN32 || defined WIN32 assert((size_t)params[0]==sizeof(cell));
return (cell)CharLower((LPTSTR)params[1]); return tolower((int)params[1]);
#elif defined _Windows
return (cell)AnsiLower((LPSTR)params[1]);
#else
return tolower((int)params[1]);
#endif
} }
#if defined __BORLANDC__ || defined __WATCOMC__ #if defined __BORLANDC__ || defined __WATCOMC__
@ -414,13 +342,8 @@ static cell AMX_NATIVE_CALL core_tolower(AMX *amx,cell *params)
#endif #endif
static cell AMX_NATIVE_CALL core_toupper(AMX *amx,cell *params) static cell AMX_NATIVE_CALL core_toupper(AMX *amx,cell *params)
{ {
#if defined __WIN32__ || defined _WIN32 || defined WIN32 assert((size_t)params[0]==sizeof(cell));
return (cell)CharUpper((LPTSTR)params[1]); return toupper((int)params[1]);
#elif defined _Windows
return (cell)AnsiUpper((LPSTR)params[1]);
#else
return toupper((int)params[1]);
#endif
} }
#if defined __BORLANDC__ || defined __WATCOMC__ #if defined __BORLANDC__ || defined __WATCOMC__
@ -459,7 +382,7 @@ static char *MakePackedString(cell *cptr)
amx_StrLen(cptr,&len); amx_StrLen(cptr,&len);
dest=(char *)malloc(len+sizeof(cell)); dest=(char *)malloc(len+sizeof(cell));
amx_GetString(dest,cptr,0); amx_GetString(dest,cptr);
return dest; return dest;
} }
@ -480,7 +403,7 @@ static cell AMX_NATIVE_CALL getproperty(AMX *amx,cell *params)
return 0; return 0;
} /* if */ } /* if */
amx_GetAddr(amx,params[4],&cstr); amx_GetAddr(amx,params[4],&cstr);
amx_SetString(cstr,item->name,1,0); amx_SetString(cstr,item->name,1);
} /* if */ } /* if */
free(name); free(name);
return (item!=NULL) ? item->value : 0; return (item!=NULL) ? item->value : 0;
@ -565,7 +488,7 @@ static cell AMX_NATIVE_CALL core_random(AMX *amx,cell *params)
if (IL_StandardRandom_seed == 0L) if (IL_StandardRandom_seed == 0L)
IL_StandardRandom_seed=(unsigned long)time(NULL); IL_StandardRandom_seed=(unsigned long)time(NULL);
#endif #endif
lo = IL_StandardRandom_seed & 0xffff; lo = IL_StandardRandom_seed & 0xffff;
hi = IL_StandardRandom_seed >> 16; hi = IL_StandardRandom_seed >> 16;
IL_StandardRandom_seed = IL_StandardRandom_seed * IL_RMULT + 12345; IL_StandardRandom_seed = IL_StandardRandom_seed * IL_RMULT + 12345;
@ -580,6 +503,22 @@ static cell AMX_NATIVE_CALL core_random(AMX *amx,cell *params)
return (cell)result; return (cell)result;
} }
#if 0
void core_Init(void)
{
/* reduced to a do-nothing routine */
}
void core_Exit(void)
{
#if !defined NOPROPLIST
while (proproot.next!=NULL)
list_delete(&proproot,proproot.next);
#endif
}
#endif
AMX_NATIVE_INFO core_Natives[] = { AMX_NATIVE_INFO core_Natives[] = {
{ "numargs", numargs }, { "numargs", numargs },
@ -606,20 +545,4 @@ AMX_NATIVE_INFO core_Natives[] = {
{ NULL, NULL } /* terminator */ { NULL, NULL } /* terminator */
}; };
int AMXEXPORT amx_CoreInit(AMX *amx)
{
return amx_Register(amx, core_Natives, -1);
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
int AMXEXPORT amx_CoreCleanup(AMX *amx)
{
#if !defined NOPROPLIST
//??? delete only the properties owned by the AMX
while (proproot.next!=NULL)
list_delete(&proproot,proproot.next);
#endif
return AMX_ERR_NONE;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -29,24 +29,12 @@
* version. * version.
*/ */
#ifndef AMXMODX_H #ifndef AMXMOD_H
#define AMXMODX_H #define AMXMOD_H
#include "string.h"
#include <extdll.h>
#include <meta_api.h>
#ifdef MEMORY_TEST
#include "mmgr/mmgr.h"
#endif
#include "md5.h"
#include "CVector.h"
#include "CList.h"
#include "CQueue.h"
#include "modules.h" #include "modules.h"
#include "CString.h" #include "CString.h"
#include "CList.h"
#include "CPlugin.h" #include "CPlugin.h"
#include "CMisc.h" #include "CMisc.h"
#include "CVault.h" #include "CVault.h"
@ -57,16 +45,18 @@
#include "CCmd.h" #include "CCmd.h"
#include "CMenu.h" #include "CMenu.h"
#include "CEvent.h" #include "CEvent.h"
#include "CLang.h"
#include "fakemeta.h"
#include "amxxlog.h"
#define AMXXLOG_Log g_log.Log #define AMX_VERSION "0.15"
#define AMX_VERSION "0.2"
extern AMX_NATIVE_INFO core_Natives[]; #ifdef __cplusplus
extern AMX_NATIVE_INFO time_Natives[]; extern "C" {
extern AMX_NATIVE_INFO power_Natives[]; #endif
extern AMX_NATIVE_INFO core_Natives[];
extern AMX_NATIVE_INFO time_Natives[];
extern AMX_NATIVE_INFO power_Natives[];
#ifdef __cplusplus
}
#endif
extern AMX_NATIVE_INFO amxmod_Natives[]; extern AMX_NATIVE_INFO amxmod_Natives[];
extern AMX_NATIVE_INFO file_Natives[]; extern AMX_NATIVE_INFO file_Natives[];
extern AMX_NATIVE_INFO float_Natives[]; extern AMX_NATIVE_INFO float_Natives[];
@ -75,13 +65,13 @@ extern AMX_NATIVE_INFO vault_Natives[];
#ifndef __linux__ #ifndef __linux__
#define DLLOAD(path) (DLHANDLE)LoadLibrary(path) #define DLLOAD(path) (DLHANDLE)LoadLibrary(path);
#define DLPROC(m,func) GetProcAddress(m,func) #define DLPROC(m,func) GetProcAddress(m,func);
#define DLFREE(m) FreeLibrary(m) #define DLFREE(m) FreeLibrary(m);
#else #else
#define DLLOAD(path) (DLHANDLE)dlopen(path, RTLD_NOW) #define DLLOAD(path) (DLHANDLE)dlopen(path, RTLD_NOW);
#define DLPROC(m,func) dlsym(m,func) #define DLPROC(m,func) dlsym(m,func);
#define DLFREE(m) dlclose(m) #define DLFREE(m) dlclose(m);
#endif #endif
#ifndef __linux__ #ifndef __linux__
@ -110,7 +100,8 @@ void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pM
void UTIL_IntToString(int value, char *output); void UTIL_IntToString(int value, char *output);
void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name); void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name);
void UTIL_ShowMenu( edict_t* pEntity, int slots, int time, char *menu, int mlen ); void UTIL_ShowMenu( edict_t* pEntity, int slots, int time, char *menu, int mlen );
void UTIL_MakeNewLogFile();
void UTIL_Log(const char *fmt, ...);
#define GET_PLAYER_POINTER(e) (&g_players[ENTINDEX(e)]) #define GET_PLAYER_POINTER(e) (&g_players[ENTINDEX(e)])
//#define GET_PLAYER_POINTER(e) (&g_players[(((int)e-g_edict_point)/sizeof(edict_t ))]) //#define GET_PLAYER_POINTER(e) (&g_players[(((int)e-g_edict_point)/sizeof(edict_t ))])
@ -130,7 +121,7 @@ struct fakecmd_t {
bool fake; bool fake;
}; };
extern CLog g_log;
extern CPluginMngr g_plugins; extern CPluginMngr g_plugins;
extern CTaskMngr g_tasksMngr; extern CTaskMngr g_tasksMngr;
extern CPlayer g_players[33]; extern CPlayer g_players[33];
@ -140,13 +131,12 @@ extern CList<CCVar> g_cvars;
extern CList<ForceObject> g_forcemodels; extern CList<ForceObject> g_forcemodels;
extern CList<ForceObject> g_forcesounds; extern CList<ForceObject> g_forcesounds;
extern CList<ForceObject> g_forcegeneric; extern CList<ForceObject> g_forcegeneric;
extern CList<CModule,const char *> g_modules; extern CList<CModule> g_modules;
extern CList<CPlayer*> g_auth; extern CList<CPlayer*> g_auth;
extern EventsMngr g_events; extern EventsMngr g_events;
extern Grenades g_grenades; extern Grenades g_grenades;
extern LogEventsMngr g_logevents; extern LogEventsMngr g_logevents;
extern MenuMngr g_menucmds; extern MenuMngr g_menucmds;
extern CLangMngr g_langMngr;
extern String g_log_dir; extern String g_log_dir;
extern String g_mod_name; extern String g_mod_name;
extern TeamIds g_teamsIds; extern TeamIds g_teamsIds;
@ -157,7 +147,9 @@ extern XVars g_xvars;
extern bool g_bmod_cstrike; extern bool g_bmod_cstrike;
extern bool g_bmod_dod; extern bool g_bmod_dod;
extern bool g_dontprecache; extern bool g_dontprecache;
extern bool g_initialized;
extern int g_srvindex; extern int g_srvindex;
extern cvar_t* amx_version;
extern cvar_t* amxmodx_version; extern cvar_t* amxmodx_version;
extern cvar_t* hostname; extern cvar_t* hostname;
extern cvar_t* mp_timelimit; extern cvar_t* mp_timelimit;
@ -218,21 +210,11 @@ const char* stristr(const char* a,const char* b);
char *strptime(const char *buf, const char *fmt, struct tm *tm, short addthem); char *strptime(const char *buf, const char *fmt, struct tm *tm, short addthem);
int loadModules(const char* filename); int loadModules(const char* filename);
void detachModules(); void dettachModules();
void detachReloadModules(); void dettachReloadModules();
void attachModules(); void attachModules();
void attachMetaModModules(PLUG_LOADTIME now, const char* filename); void attachMetaModModules( const char* filename );
void dettachMetaModModules( const char* filename );
// Count modules
enum CountModulesMode
{
CountModules_Running = 0,
CountModules_All,
CountModules_Stopped
};
int countModules(CountModulesMode mode);
void modules_callPluginsLoaded();
int add_amxnatives(module_info_s* info,AMX_NATIVE_INFO*natives); int add_amxnatives(module_info_s* info,AMX_NATIVE_INFO*natives);
cell* get_amxaddr(AMX *amx,cell amx_addr); cell* get_amxaddr(AMX *amx,cell amx_addr);
@ -242,7 +224,7 @@ AMX* get_amxscript(int, void**,const char**);
const char* get_amxscriptname(AMX* amx); const char* get_amxscriptname(AMX* amx);
char* get_amxstring(AMX *amx,cell amx_addr,int id,int& len); char* get_amxstring(AMX *amx,cell amx_addr,int id,int& len);
int amxstring_len(cell* cstr); int amxstring_len(cell* cstr);
int load_amxscript(AMX* amx, void** program, const char* path, char error[64], int debug); int load_amxscript(AMX* amx, void** program, const char* path, char error[64]);
int set_amxnatives(AMX* amx,char error[64]); int set_amxnatives(AMX* amx,char error[64]);
int set_amxstring(AMX *amx,cell amx_addr,const char *source,int max); int set_amxstring(AMX *amx,cell amx_addr,const char *source,int max);
int unload_amxscript(AMX* amx,void** program); int unload_amxscript(AMX* amx,void** program);
@ -252,41 +234,7 @@ void print_srvconsole( char *fmt, ... );
void report_error( int code, char* fmt, ... ); void report_error( int code, char* fmt, ... );
void* alloc_amxmemory(void**, int size); void* alloc_amxmemory(void**, int size);
void free_amxmemory(void **ptr); void free_amxmemory(void **ptr);
// get_localinfo
const char* get_localinfo( const char* name , const char* def );
cell AMX_NATIVE_CALL require_module(AMX *amx, cell *params);
void LogError(AMX *amx, int err, const char *fmt, ...);
enum ModuleCallReason
{
ModuleCall_NotCalled = 0, // nothing
ModuleCall_Query, // in Query func
ModuleCall_Attach, // in Attach func
ModuleCall_Detach, // in Detach func
};
extern ModuleCallReason g_ModuleCallReason; // modules.cpp #endif // AMXMOD_H
extern CModule *g_CurrentlyCalledModule; // modules.cpp
extern const char *g_LastRequestedFunc; // modules.cpp
extern CQueue<String> CurModuleList;
void *Module_ReqFnptr(const char *funcName); // modules.cpp
// standard forwards
// defined in meta_api.cpp
extern int FF_ClientCommand;
extern int FF_ClientConnect;
extern int FF_ClientDisconnect;
extern int FF_ClientInfoChanged;
extern int FF_ClientPutInServer;
extern int FF_PluginInit;
extern int FF_PluginCfg;
extern int FF_PluginPrecache;
extern int FF_PluginLog;
extern int FF_PluginEnd;
extern int FF_InconsistentFile;
extern int FF_ClientAuthorized;
extern CFakeMeta g_FakeMeta;
#endif // AMXMODX_H

View File

@ -11,18 +11,6 @@
#include <windows.h> #include <windows.h>
#include <mmsystem.h> #include <mmsystem.h>
#endif #endif
#ifdef __GNUC__
# ifndef CLK_TCK
# define CLK_TCK CLOCKS_PER_SEC
# endif
#endif
// this file does not include amxmodx.h, so we have to include the memory manager here
#ifdef MEMORY_TEST
#include "mmgr/mmgr.h"
#endif // MEMORY_TEST
#include "amx.h" #include "amx.h"
#if defined __BORLANDC__ || defined __WATCOMC__ #if defined __BORLANDC__ || defined __WATCOMC__

View File

@ -1,11 +0,0 @@
; /usr/local/cross-tools/bin/i386-mingw32msvc-dlltool --base-file /tmp/cc4kB6s0.base --output-exp amx_mm.exp --dllname amx_mm.dll --output-def amx_mm.def --add-stdcall-alias --exclude-symbol=DllMainCRTStartup@12 --def /tmp/ccyI7I7K.def
EXPORTS
GetEngineFunctions @ 1 ;
GetEngineFunctions_Post @ 2 ;
GetEntityAPI2 @ 3 ;
GetEntityAPI2_Post @ 4 ;
GiveFnptrsToDll = GiveFnptrsToDll@8 @ 5 ;
GiveFnptrsToDll@8 @ 6 ;
Meta_Attach @ 7 ;
Meta_Detach @ 8 ;
Meta_Query @ 9 ;

View File

@ -1,281 +0,0 @@
/* AMX Mod X
*
* by the AMX Mod X Development Team
* originally developed by OLO
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*/
#include "amxmodx.h"
#include "amxxfile.h"
#include "zlib/zlib.h"
/**********************
****** AMXXFILE ******
**********************/
#if defined __GNUC__
#define PACKED __attribute__((packed))
#else
#define PACKED
#endif
#if defined __linux__
#pragma pack(1) /* structures must be packed (byte-aligned) */
#else
#pragma pack(1) /* structures must be packed (byte-aligned) */
#if defined __TURBOC__
#pragma option -a- /* "pack" pragma for older Borland compilers */
#endif
#endif
typedef char mint8_t;
typedef int16_t mint16_t;
typedef int32_t mint32_t;
struct TableEntry
{
mint8_t cellSize PACKED;
mint32_t origSize PACKED; // contains AMX_HEADER->stp
mint32_t offset PACKED;
};
#define DATAREAD(addr, itemsize, itemcount) \
if (fread((addr), (itemsize), (itemcount), (m_pFile)) != (itemcount)) \
{ \
if (feof(m_pFile)) \
m_Status = Err_FileInvalid; \
else \
m_Status = Err_FileRead; \
fclose(m_pFile); \
m_pFile = NULL; \
return; \
}
CAmxxReader::CAmxxReader(const char *filename, int cellsize)
{
if (!filename)
{
m_Status = Err_InvalidParam;
return;
}
m_Status = Err_None;
m_CellSize = cellsize;
m_pFile = fopen(filename, "rb");
if (!m_pFile)
{
m_Status = Err_FileOpen;
return;
}
mint32_t magic;
DATAREAD(&magic, sizeof(magic), 1);
m_OldFile = false;
if (magic != 0x414D5842)
{
// check for old file
AMX_HEADER hdr;
rewind(m_pFile);
fread(&hdr, sizeof(hdr), 1, m_pFile);
amx_Align16(&hdr.magic);
if (hdr.magic == AMX_MAGIC)
{
if (cellsize != 4)
{
m_Status = Err_SectionNotFound;
fclose(m_pFile);
m_pFile = NULL;
return;
}
m_OldFile = true;
return;
}
else
{
// no known file format
m_Status = Err_FileInvalid;
fclose(m_pFile);
m_pFile = NULL;
return;
}
} else if ( magic == 0x524C4542 ) {
//we have an invalid, old, RLEB file
m_Status = Err_OldFile;
fclose(m_pFile);
m_pFile = NULL;
return;
} else {
// try to find the section
mint8_t numOfPlugins;
DATAREAD(&numOfPlugins, sizeof(numOfPlugins), 1);
TableEntry entry;
m_SectionHdrOffset = 0;
int i = 0;
for (i = 0; i < static_cast<int>(numOfPlugins); ++i)
{
DATAREAD(&entry, sizeof(entry), 1);
if (entry.cellSize == m_CellSize)
{
m_SectionHdrOffset = ftell(m_pFile) - sizeof(entry);
break;
}
}
if (!m_SectionHdrOffset)
{
m_Status = Err_SectionNotFound;
fclose(m_pFile);
m_pFile = NULL;
return;
}
// compute section length
if ((i+1) < static_cast<int>(numOfPlugins))
{
// there is a next section
TableEntry nextEntry;
DATAREAD(&nextEntry, sizeof(nextEntry), 1);
m_SectionLength = nextEntry.offset - entry.offset;
}
else
{
fseek(m_pFile, 0, SEEK_END);
m_SectionLength = ftell(m_pFile) - (long)entry.offset;
}
}
}
CAmxxReader::~CAmxxReader()
{
if (m_pFile)
{
fclose(m_pFile);
m_pFile = NULL;
}
}
CAmxxReader::Error CAmxxReader::GetStatus()
{
return m_Status;
}
#undef DATAREAD
#define DATAREAD(addr, itemsize, itemcount) \
if (fread(addr, itemsize, itemcount, m_pFile) != itemcount) \
{ \
if (feof(m_pFile)) \
m_Status = Err_FileInvalid; \
else \
m_Status = Err_FileRead; \
fclose(m_pFile); \
m_pFile = NULL; \
return 0; \
}
size_t CAmxxReader::GetBufferSize()
{
if (!m_pFile)
return 0;
long save = ftell(m_pFile);
if (m_OldFile)
{
rewind(m_pFile);
AMX_HEADER hdr;
DATAREAD(&hdr, sizeof(hdr), 1);
fseek(m_pFile, save, SEEK_SET);
return hdr.stp;
}
fseek(m_pFile, m_SectionHdrOffset, SEEK_SET);
TableEntry entry;
DATAREAD(&entry, sizeof(entry), 1);
fseek(m_pFile, save, SEEK_SET);
return entry.origSize + 1; // +1 : safe
}
#undef DATAREAD
#define DATAREAD(addr, itemsize, itemcount) \
if (fread(addr, itemsize, itemcount, m_pFile) != itemcount) \
{ \
if (feof(m_pFile)) \
m_Status = Err_FileInvalid; \
else \
m_Status = Err_FileRead; \
fclose(m_pFile); \
m_pFile = NULL; \
return m_Status; \
}
CAmxxReader::Error CAmxxReader::GetSection(void *buffer)
{
if (!m_pFile)
return m_Status;
if (m_OldFile)
{
// get file size
fseek(m_pFile, 0, SEEK_END);
long filesize = ftell(m_pFile);
rewind(m_pFile);
DATAREAD(buffer, 1, filesize);
m_Status = Err_None;
return m_Status;
}
// new file type: go to the section table entry
fseek(m_pFile, m_SectionHdrOffset, SEEK_SET);
// go to the offset
TableEntry entry;
DATAREAD(&entry, sizeof(entry), 1);
fseek(m_pFile, entry.offset, SEEK_SET);
// AMXXLOG_Log("|||| Offset needed: %d At: %d", entry.offset, ftell(m_pFile));
uLongf destLen = GetBufferSize();
// read the data to a temporary buffer
char *tempBuffer = new char[m_SectionLength + 1];
//fread(tempBuffer, sizeof(char), m_SectionLength, m_pFile);
DATAREAD((void*)tempBuffer, 1, m_SectionLength);
// decompress
// AMXXLOG_Log("|||| First Bytes: %d %d %d %d", tempBuffer[0], tempBuffer[1], tempBuffer[2], tempBuffer[3]);
int result = uncompress((Bytef *)buffer, &destLen,
(Bytef *)tempBuffer, m_SectionLength);
delete [] tempBuffer;
// AMXXLOG_Log("|||| Result: %d, m_SectionLength=%d, destLen=%d", result, m_SectionLength, destLen);
if (result != Z_OK)
{
m_Status = Err_Decompress;
return Err_Decompress;
}
return Err_None;
}

View File

@ -1,71 +0,0 @@
/* AMX Mod X
*
* by the AMX Mod X Development Team
* originally developed by OLO
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*/
#ifndef __AMXXFILE_H__
#define __AMXXFILE_H__
class CAmxxReader
{
public:
enum Error
{
Err_None=0,
Err_InvalidParam,
Err_FileOpen,
Err_FileRead,
Err_FileInvalid,
Err_SectionNotFound,
Err_DecompressorInit,
Err_Decompress,
Err_OldFile,
};
private:
Error m_Status;
FILE *m_pFile;
bool m_OldFile; // old .amx file
int m_CellSize;
int m_SectionHdrOffset; // offset to the table in the header that describes the required section
int m_SectionLength;
public:
CAmxxReader(const char *filename, int cellsize);
~CAmxxReader();
Error GetStatus(); // Get the current status
size_t GetBufferSize(); // Get the size for the buffer
Error GetSection(void *buffer); // Copy the currently selected section to the buffer
};
#endif // __AMXXFILE_H__

View File

@ -1,217 +0,0 @@
/* AMX Mod X
*
* by the AMX Mod X Development Team
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*/
// amxx_logging localinfo:
// 0 = no logging
// 1 = one logfile / day
// 2 = one logfile / map
// 3 = HL Logs
#include <time.h>
#ifndef __linux__
#include <io.h>
#endif
#include "amxmodx.h"
#ifndef __linux__
#define vsnprintf _vsnprintf
#endif
CLog::CLog()
{
m_LogType = 0;
m_LogFile.clear();
}
CLog::~CLog()
{
CloseFile();
}
void CLog::CloseFile()
{
// log "log file closed" to old file, if any
if (!m_LogFile.empty())
{
FILE *fp = fopen(m_LogFile.c_str(), "r");
if (fp)
{
fclose(fp);
fp = fopen(m_LogFile.c_str(), "a+");
// get time
time_t td;
time(&td);
tm *curTime = localtime(&td);
char date[32];
strftime(date, 31, "%m/%d/%Y - %H:%M:%S", curTime);
fprintf(fp, "L %s: %s\n", date, "Log file closed.");
fclose(fp);
}
m_LogFile.clear();
}
}
void CLog::CreateNewFile()
{
CloseFile();
// build filename
time_t td;
time(&td);
tm *curTime = localtime(&td);
int i = 0;
while (true)
{
m_LogFile.assign(build_pathname("%s/L%02d%02d%03d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday, i));
FILE *pTmpFile = fopen(m_LogFile.c_str(), "r"); // open for reading to check whether the file exists
if (!pTmpFile)
break;
fclose(pTmpFile);
++i;
}
// Log logfile start
FILE *fp = fopen(m_LogFile.c_str(), "w");
if (!fp)
{
ALERT(at_logged, "[AMXX] Unexpected fatal logging error. AMXX Logging disabled.\n");
SET_LOCALINFO("amxx_logging", "0");
}
else
{
fprintf(fp, "AMX Mod X log file started (file \"%s/L%02d%02d%03d.log\") (version \"%s\")\n", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday, i, AMX_VERSION);
fclose(fp);
}
}
void CLog::UseFile(const String &fileName)
{
m_LogFile.assign(build_pathname("%s/%s", g_log_dir.c_str(), fileName.c_str()));
}
void CLog::MapChange()
{
// create dir if not existing
#ifdef __linux
mkdir(build_pathname("%s", g_log_dir.c_str()), 0700);
#else
mkdir(build_pathname("%s", g_log_dir.c_str()));
#endif
m_LogType = atoi(get_localinfo("amxx_logging", "1"));
if (m_LogType < 0 || m_LogType > 3)
{
SET_LOCALINFO("amxx_logging", "1");
m_LogType = 1;
print_srvconsole("[AMXX] Invalid amxx_logging value; setting back to 1...");
}
if (m_LogType == 2)
{
// create new logfile
CreateNewFile();
}
else if (m_LogType == 1)
{
Log("-------- Mapchange --------");
}
else
return;
}
void CLog::Log(const char *fmt, ...)
{
if (m_LogType == 1 || m_LogType == 2)
{
// get time
time_t td;
time(&td);
tm *curTime = localtime(&td);
char date[32];
strftime(date, 31, "%m/%d/%Y - %H:%M:%S", curTime);
// msg
char msg[3072];
va_list arglst;
va_start(arglst, fmt);
vsnprintf(msg, 3071, fmt, arglst);
va_end(arglst);
FILE *pF;
if (m_LogType == 2)
{
pF = fopen(m_LogFile.c_str(), "a+");
if (!pF)
{
CreateNewFile();
pF = fopen(m_LogFile.c_str(), "a+");
if (!pF)
{
ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Logging disabled for this map.\n", m_LogFile.c_str());
m_LogType = 0;
return;
}
}
}
else
{
pF = fopen(build_pathname("%s/L%02d%02d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday), "a+");
}
if (pF)
{
fprintf(pF, "L %s: %s\n", date, msg);
fclose(pF);
}
else
{
ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Logging disabled for this map.\n", m_LogFile.c_str());
m_LogType = 0;
return;
}
// print on server console
print_srvconsole("L %s: %s\n", date, msg);
}
else if (m_LogType == 3)
{
// build message
// :TODO: Overflow possible here
char msg[3072];
va_list arglst;
va_start(arglst, fmt);
vsnprintf(msg, 3071, fmt, arglst);
va_end(arglst);
ALERT(at_logged, "%s\n", msg);
}
}

View File

@ -29,7 +29,9 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
int gmsgAmmoPickup; int gmsgAmmoPickup;
int gmsgAmmoX; int gmsgAmmoX;
@ -90,7 +92,7 @@ void Client_TeamInfo(void* mValue)
case 1: case 1:
if ( index < 1 || index > gpGlobals->maxClients ) break; if ( index < 1 || index > gpGlobals->maxClients ) break;
char* msg = (char*)mValue; char* msg = (char*)mValue;
g_players[ index ].team.assign( msg ); g_players[ index ].team.set( msg );
g_teamsIds.registerTeam( msg , -1 ); g_teamsIds.registerTeam( msg , -1 );
} }
} }
@ -169,7 +171,7 @@ void Client_WeaponList(void* mValue)
wpnList |= (1<<iId); wpnList |= (1<<iId);
g_weaponsData[iId].iId = iId; g_weaponsData[iId].iId = iId;
g_weaponsData[iId].ammoSlot = iSlot; g_weaponsData[iId].ammoSlot = iSlot;
g_weaponsData[iId].fullName.assign(wpnName); g_weaponsData[iId].fullName.set(wpnName);
} }
} }
@ -243,7 +245,7 @@ void Client_ScoreInfo(void* mValue)
pPlayer->deaths = deaths; pPlayer->deaths = deaths;
pPlayer->teamId = *(int*)mValue; pPlayer->teamId = *(int*)mValue;
if ( g_teamsIds.isNewTeam() ) if ( g_teamsIds.isNewTeam() )
g_teamsIds.registerTeam( pPlayer->team.c_str() , pPlayer->teamId ); g_teamsIds.registerTeam( pPlayer->team.str() , pPlayer->teamId );
} }
} }
@ -257,7 +259,7 @@ void Client_DamageEnd(void* mValue)
g_events.parseValue( dead->death_killer ); g_events.parseValue( dead->death_killer );
g_events.parseValue( dead->index ); g_events.parseValue( dead->index );
g_events.parseValue( dead->death_headshot ); g_events.parseValue( dead->death_headshot );
g_events.parseValue( dead->death_weapon.c_str() ); g_events.parseValue( dead->death_weapon.str() );
g_events.parseValue( dead->death_tk ? 1 : 0 ); g_events.parseValue( dead->death_tk ? 1 : 0 );
g_events.executeEvents(); g_events.executeEvents();
dead->death_killer = 0; dead->death_killer = 0;
@ -291,7 +293,7 @@ void Client_DeathMsg(void* mValue)
if ( !killer || !victim ) break; if ( !killer || !victim ) break;
victim->death_killer = killer_id; victim->death_killer = killer_id;
victim->death_weapon.assign((char*)mValue); victim->death_weapon.set((char*)mValue);
victim->death_headshot = hs; victim->death_headshot = hs;
victim->death_tk = (killer->teamId == victim->teamId); victim->death_tk = (killer->teamId == victim->teamId);
} }

File diff suppressed because it is too large Load Diff

View File

@ -1,229 +0,0 @@
/* AMX Mod X
*
* by the AMX Mod X Development Team
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*/
#ifndef __FAKEMETA_H__
#define __FAKEMETA_H__
// Fake metamod api for modules
#include "CList.h"
// from mplugin.h (metamod)
// Flags to indicate current "load" state of plugin.
// NOTE: order is important, as greater/less comparisons are made.
typedef enum {
PL_EMPTY = 0, // empty slot
PL_VALID, // has valid info in it
PL_BADFILE, // nonexistent file (open failed),
// or not a valid plugin file (query failed)
PL_OPENED, // dlopened and queried
PL_FAILED, // opened, but failed to attach or unattach
PL_RUNNING, // attached and running
PL_PAUSED, // attached but paused
} PLUG_STATUS;
// from h_export.h (metamod)
// Our GiveFnptrsToDll, called by engine.
typedef void (WINAPI *GIVE_ENGINE_FUNCTIONS_FN) (enginefuncs_t
*pengfuncsFromEngine, globalvars_t *pGlobals);
// *** CFakeMeta
class CFakeMeta
{
private:
// Core tables
/* DLL_FUNCTIONS m_CoreDllFuncTable;
enginefuncs_t m_CoreEngineFuncTable;
NEW_DLL_FUNCTIONS m_CoreNewDllFuncTable;
DLL_FUNCTIONS m_CoreDllFuncTable_Post;
enginefuncs_t m_CoreEngineFuncTable_Post;
NEW_DLL_FUNCTIONS m_CoreNewDllFuncTable_Post; */
bool AddCorePlugin(); // Adds the core plugin if needed
public:
class CFakeMetaPlugin
{
private:
// plugin info
String m_Path;
PLUG_STATUS m_Status;
plugin_info_t *m_Info;
// Function tables
META_FUNCTIONS m_MetaFuncTable;
DLL_FUNCTIONS m_DllFuncTable;
enginefuncs_t m_EngineFuncTable;
NEW_DLL_FUNCTIONS m_NewDllFuncTable;
DLL_FUNCTIONS m_DllFuncTable_Post;
enginefuncs_t m_EngineFuncTable_Post;
NEW_DLL_FUNCTIONS m_NewDllFuncTable_Post;
// OS dep handle
DLHANDLE m_Handle;
public:
inline PLUG_STATUS GetStatus() const
{ return m_Status; }
inline void SetStatus(PLUG_STATUS newStatus)
{ m_Status = newStatus; }
inline plugin_info_t * GetInfo()
{ return m_Info; }
inline const plugin_info_t * GetInfo() const
{ return m_Info; }
inline void SetInfo(plugin_info_t *newInfo)
{ m_Info = newInfo; }
inline const char * GetPath()
{ return m_Path.c_str(); }
inline const META_FUNCTIONS &GetMetaFunctions() const
{ return m_MetaFuncTable; }
// Get
inline DLL_FUNCTIONS &GetDllFuncTable()
{ return m_DllFuncTable; }
inline enginefuncs_t &GetEngineFuncTable()
{ return m_EngineFuncTable; }
inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable()
{ return m_NewDllFuncTable; }
// Get const
inline const DLL_FUNCTIONS &GetDllFuncTable() const
{ return m_DllFuncTable; }
inline const enginefuncs_t &GetEngineFuncTable() const
{ return m_EngineFuncTable; }
inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable() const
{ return m_NewDllFuncTable; }
// Get post
inline DLL_FUNCTIONS &GetDllFuncTable_Post()
{ return m_DllFuncTable_Post; }
inline enginefuncs_t &GetEngineFuncTable_Post()
{ return m_EngineFuncTable_Post; }
inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post()
{ return m_NewDllFuncTable_Post; }
// Get post const
inline const DLL_FUNCTIONS &GetDllFuncTable_Post() const
{ return m_DllFuncTable_Post; }
inline const enginefuncs_t &GetEngineFuncTable_Post() const
{ return m_EngineFuncTable_Post; }
inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post() const
{ return m_NewDllFuncTable_Post; }
int Query(mutil_funcs_t *pMetaUtilFuncs); // Also calls GiveFnPtrsToDll
int Attach(PLUG_LOADTIME now, meta_globals_t *pMGlobals, gamedll_funcs_t *pGameDllFuncs);
int Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
int GetEntityAPI2(int interfaceVersion);
int GetEntityAPI2_Post(int interfaceVersion);
int GetEngineFunctions(int interfaceVersion);
int GetEngineFunctions_Post(int interfaceVersion);
int GetNewDLLFunctions(int interfaceVersion);
int GetNewDLLFunctions_Post(int interfaceVersion);
CFakeMetaPlugin(const char *path);
~CFakeMetaPlugin();
}; // CFakeMetaPlugin
CFakeMeta();
~CFakeMeta();
bool AddPlugin(const char *path /*path relative to moddir*/);
void ReleasePlugins();
// This is public because i don't want to declare all the functions as friends :)
// :NOTE: The core is now a special, first plugin!
CList<CFakeMetaPlugin> m_Plugins;
// ****** Meta functions ******
// Query all added plugins
void Meta_Query(mutil_funcs_t *pMetaUtilFuncs);
// Attach all added plugins
void Meta_Attach(PLUG_LOADTIME now, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs);
// Detach all added plugins
void Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
// :NOTE: Meta_Init currently not supported
int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable /*from metamod*/, int *interfaceVersion /*from metamod*/,
DLL_FUNCTIONS *pAMXXFunctionTable /*Functions amxx needs*/);
int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable /*from metamod*/, int *interfaceVersion /*from metamod*/,
DLL_FUNCTIONS *pAMXXFunctionTable /*Functions amxx needs*/);
int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion,
enginefuncs_t *pAMXXFunctionTable /*Fucntions amxx needs*/);
int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion,
enginefuncs_t *pAMXXFunctionTable /*Fucntions amxx needs*/);
int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion,
NEW_DLL_FUNCTIONS *pAMXXFunctionTable);
int GetNewDLLFunctions_Post(NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion,
NEW_DLL_FUNCTIONS *pAMXXFunctionTable);
// Get
/*inline DLL_FUNCTIONS &GetDllFuncTable()
{ return m_CoreDllFuncTable; }
inline enginefuncs_t &GetEngineFuncTable()
{ return m_CoreEngineFuncTable; }
inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable()
{ return m_CoreNewDllFuncTable; }
// Get const
inline const DLL_FUNCTIONS &GetDllFuncTable() const
{ return m_CoreDllFuncTable; }
inline const enginefuncs_t &GetEngineFuncTable() const
{ return m_CoreEngineFuncTable; }
inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable() const
{ return m_CoreNewDllFuncTable; }
// Get post
inline DLL_FUNCTIONS &GetDllFuncTable_Post()
{ return m_CoreDllFuncTable_Post; }
inline enginefuncs_t &GetEngineFuncTable_Post()
{ return m_CoreEngineFuncTable_Post; }
inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post()
{ return m_CoreNewDllFuncTable_Post; }
// Get post const
inline const DLL_FUNCTIONS &GetDllFuncTable_Post() const
{ return m_CoreDllFuncTable_Post; }
inline const enginefuncs_t &GetEngineFuncTable_Post() const
{ return m_CoreEngineFuncTable_Post; }
inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post() const
{ return m_CoreNewDllFuncTable_Post; } */
}; // CFakeMeta
// Fake Metamod
// defined in meta_api.cpp
extern CFakeMeta g_FakeMeta;
#endif // #ifndef __FAKEMETA_H__

View File

@ -35,14 +35,9 @@
#define _INTPTR_T_DEFINED #define _INTPTR_T_DEFINED
#endif #endif
#ifdef __GNUC__ #include <extdll.h>
#include <meta_api.h>
//#include <stddef.h> #include "amxmod.h"
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#endif
// header file for unlink() // header file for unlink()
#ifdef __linux__ #ifdef __linux__
@ -51,28 +46,14 @@
#include <io.h> #include <io.h>
#endif #endif
#include <extdll.h> #ifdef __GNUC__
#include <meta_api.h>
#include "amxmodx.h"
CVector<FILE *> FileList; //#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
class AutoFilePtr #endif
{
FILE *m_FP;
public:
AutoFilePtr(FILE *fp) : m_FP(fp)
{ }
~AutoFilePtr()
{
if (m_FP)
fclose(m_FP);
}
operator FILE* ()
{
return m_FP;
}
};
static cell AMX_NATIVE_CALL read_dir(AMX *amx, cell *params) static cell AMX_NATIVE_CALL read_dir(AMX *amx, cell *params)
{ {
@ -245,365 +226,41 @@ static cell AMX_NATIVE_CALL file_exists(AMX *amx, cell *params) /* 1 param */
static cell AMX_NATIVE_CALL file_size(AMX *amx, cell *params) /* 1 param */ static cell AMX_NATIVE_CALL file_size(AMX *amx, cell *params) /* 1 param */
{ {
int iLen; int iLen;
char* sFile = get_amxstring(amx,params[1],0,iLen); char* sFile = get_amxstring(amx,params[1],0,iLen);
AutoFilePtr fp(fopen(build_pathname("%s",sFile),"r")); FILE* fp = fopen(build_pathname("%s",sFile),"r");
if ( fp != NULL) if ( fp != NULL) {
{ if ( params[0] < 2 || params[2] == 0 ){
if ( params[0] < 2 || params[2] == 0 ) fseek(fp,0,SEEK_END);
{ int size = ftell(fp);
fseek(fp,0,SEEK_END); fclose(fp);
int size = ftell(fp); return size;
return size; }
} else if ( params[2] == 1 ){
else if ( params[2] == 1 ) int a = 0,lines = 0;
{ while( a != EOF ){
int a = 0,lines = 0; ++lines;
while( a != EOF ) while ( (a = fgetc(fp)) != '\n' && a != EOF )
{ ;
++lines; }
while ( (a = fgetc(fp)) != '\n' && a != EOF ) //int a, b = '\n';
; //while( (a = fgetc(fp)) != EOF ){
} // if ( a == '\n')
//int a, b = '\n'; // ++lines;
//while( (a = fgetc(fp)) != EOF ){ // b = a;
// if ( a == '\n') //}
// ++lines; //if ( b != '\n' )
// b = a; // ++lines;
//} return lines;
//if ( b != '\n' ) }
// ++lines; else if ( params[2] == 2 ){
return lines; fseek(fp,-1,SEEK_END);
} if ( fgetc(fp) == '\n' )
else if ( params[2] == 2 ){ return 1;
fseek(fp,-1,SEEK_END); return 0;
if ( fgetc(fp) == '\n' ) }
return 1; }
return 0; return -1;
}
}
return -1;
}
//ported from Sanji's file access module by BAILOPAN
// Important update - now uses new handles
static cell AMX_NATIVE_CALL amx_fopen(AMX *amx, cell *params)
{
unsigned int i;
int len, j=-1;
char *file = build_pathname("%s", get_amxstring(amx, params[1], 1, len));
char *flags = get_amxstring(amx, params[2], 0, len);
FILE *fp = fopen(file, flags);
for (i=0; i<FileList.size(); i++)
{
if (FileList.at(i) == NULL)
{
j = i;
break;
}
}
if (j==-1)
{
FileList.push_back(fp);
j = FileList.size() - 1;
} else {
FileList.at(j) = fp;
}
return j+1;
}
static cell AMX_NATIVE_CALL amx_fclose(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
if (fp) {
return fclose(fp);
} else {
return -1;
}
}
static cell AMX_NATIVE_CALL amx_fgetc(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
if (fp) {
return fgetc(fp);
} else {
return -1;
}
}
static cell AMX_NATIVE_CALL amx_fread(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
char *buffer;
if (fp) {
buffer = new char[params[3]]; // SLOW!!! :TODO: Find a better way (auto pointers?)
fread(buffer, sizeof(char), params[3], fp);
set_amxstring(amx, params[2], buffer, params[3]);
delete [] buffer;
return 1;
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fwrite(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
char *buf;
int len;
if (fp) {
buf = format_amxstring(amx, params, 2, len);
return fwrite(buf, sizeof(char), strlen(buf), fp);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_feof(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
if (fp) {
if (feof(fp)) {
return 1;
}
return 0;
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fseek(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
if (fp) {
return fseek(fp, (long)params[2], params[3]);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fputc(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
if (fp) {
return fputc(params[2], fp);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_rewind(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
if (fp) {
rewind(fp);
return 1;
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fflush(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
if (fp) {
return fflush(fp);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fscanf(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
char *buf;
int len;
buf = format_amxstring(amx, params, 2, len);
if (fp) {
return fscanf(fp, "%s", buf);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_ftell(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
if (fp) {
return ftell(fp);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_filesize(AMX *amx, cell *params)
{
int len;
char *file = build_pathname("%s", format_amxstring(amx, params, 1, len));
long size;
AutoFilePtr fp(fopen(file, "rb"));
if (fp) {
fseek(fp, 0, SEEK_END);
size = ftell(fp);
return size;
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fgetl(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
long t;
if (fp) {
fread(&t, sizeof(long), 1, fp);
return t;
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fgeti(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
int t;
if (fp) {
fread(&t, sizeof(int), 1, fp);
return t;
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fgets(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
short t;
if (fp) {
fread(&t, sizeof(short), 1, fp);
return t;
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fputs(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
short size = params[2];
if (fp) {
return fwrite(&size, sizeof(short), 1, fp);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fputl(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
long size = params[2];
if (fp) {
return fwrite(&size, sizeof(long), 1, fp);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fputi(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
int size = params[2];
if (fp) {
return fwrite(&size, sizeof(int), 1, fp);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fgetf(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
float t;
if (fp) {
fread(&t, sizeof(float), 1, fp);
return *(cell*)&t;
}
return -1;
}
static cell AMX_NATIVE_CALL amx_fputf(AMX *amx, cell *params)
{
unsigned int id = params[1] - 1;
if (id >= FileList.size() || FileList.at(id) == NULL)
return 0;
FILE *fp = FileList.at(id);
float size = *(float *)((void *)&params[2]);
if (fp) {
return fwrite(&size, sizeof(float), 1, fp);
}
return -1;
}
static cell AMX_NATIVE_CALL amx_build_pathname(AMX *amx, cell *params)
{
int len;
char *szPath = get_amxstring(amx, params[1], 0, len);
return set_amxstring(amx, params[2], build_pathname("%s", szPath), params[3]);
} }
AMX_NATIVE_INFO file_Natives[] = { AMX_NATIVE_INFO file_Natives[] = {
@ -613,32 +270,6 @@ AMX_NATIVE_INFO file_Natives[] = {
{ "read_dir", read_dir }, { "read_dir", read_dir },
{ "read_file", read_file }, { "read_file", read_file },
{ "write_file", write_file }, { "write_file", write_file },
//Sanji's File Natives
{ "fopen", amx_fopen },
{ "fclose", amx_fclose },
{ "fgetc", amx_fgetc },
{ "fread", amx_fread },
{ "fwrite", amx_fwrite },
{ "feof", amx_feof },
{ "fseek", amx_fseek },
{ "fputc", amx_fputc },
{ "rewind", amx_rewind },
{ "fflush", amx_fflush },
{ "fscanf", amx_fscanf },
{ "ftell", amx_ftell },
{ "filesize", amx_filesize },
{ "fgetl", amx_fgetl },
{ "fgeti", amx_fgeti },
{ "fgets", amx_fgets },
{ "fputs", amx_fputs },
{ "fputl", amx_fputl },
{ "fputi", amx_fputi },
{ "unlink", delete_file },
{ "fgetf", amx_fgetf },
{ "fputf", amx_fputf },
{ "build_pathname", amx_build_pathname},
{ NULL, NULL } { NULL, NULL }
}; };

View File

@ -14,19 +14,11 @@
* 2003-11-24: A few more native functions (geometry), plus minor modifications, * 2003-11-24: A few more native functions (geometry), plus minor modifications,
* mostly to be compatible with dynamically loadable extension * mostly to be compatible with dynamically loadable extension
* modules, by Thiadmer Riemersma * modules, by Thiadmer Riemersma
* 2004-01-09: Adaptions for 64-bit cells (using "double precision"), by
* Thiadmer Riemersma
*/ */
#include <stdlib.h> /* for atof() */ #include <stdlib.h> /* for atof() */
#include <stdio.h> /* for NULL */ #include <stdio.h> /* for NULL */
#include <assert.h> #include <assert.h>
#include <math.h> #include <math.h>
// this file does not include amxmodx.h, so we have to include the memory manager here
#ifdef MEMORY_TEST
#include "mmgr/mmgr.h"
#endif // MEMORY_TEST
#include "amx.h" #include "amx.h"
/* /*
@ -37,19 +29,6 @@
#define PI 3.1415926535897932384626433832795 #define PI 3.1415926535897932384626433832795
static REAL FromRadians(REAL angle, int radix)
{
switch (radix)
{
case 1: /* degrees, sexagesimal system (technically: degrees/minutes/seconds) */
return (REAL)(angle / PI * 180.0);
case 2: /* grades, centesimal system */
return (REAL)(angle / PI * 200.0);
default: /* assume already radian */
return angle;
} /* switch */
}
#if defined __BORLANDC__ || defined __WATCOMC__ #if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused #pragma argsused
#endif #endif
@ -60,10 +39,10 @@ static cell AMX_NATIVE_CALL n_float(AMX *amx,cell *params)
* params[0] = number of bytes * params[0] = number of bytes
* params[1] = long value to convert to a float * params[1] = long value to convert to a float
*/ */
REAL fValue; float fValue;
/* Convert to a float. Calls the compilers long to float conversion. */ /* Convert to a float. Calls the compilers long to float conversion. */
fValue = (REAL) params[1]; fValue = (float) params[1];
/* Return the cell. */ /* Return the cell. */
return amx_ftoc(fValue); return amx_ftoc(fValue);
@ -81,7 +60,7 @@ static cell AMX_NATIVE_CALL n_floatstr(AMX *amx,cell *params)
*/ */
char szSource[60]; char szSource[60];
cell *pString; cell *pString;
REAL fNum; float fNum;
int nLen; int nLen;
/* They should have sent us 1 cell. */ /* They should have sent us 1 cell. */
@ -92,14 +71,14 @@ static cell AMX_NATIVE_CALL n_floatstr(AMX *amx,cell *params)
/* Find out how long the string is in characters. */ /* Find out how long the string is in characters. */
amx_StrLen(pString, &nLen); amx_StrLen(pString, &nLen);
if (nLen == 0 || (unsigned int)nLen >= sizeof szSource) if (nLen == 0 || nLen >= sizeof szSource)
return 0; return 0;
/* Now convert the Small String into a C type null terminated string */ /* Now convert the Small String into a C type null terminated string */
amx_GetString(szSource, pString, 0); amx_GetString(szSource, pString);
/* Now convert this to a float. */ /* Now convert this to a float. */
fNum = (REAL)atof(szSource); fNum = (float)atof(szSource);
return amx_ftoc(fNum); return amx_ftoc(fNum);
} }
@ -115,7 +94,7 @@ static cell AMX_NATIVE_CALL n_floatmul(AMX *amx,cell *params)
* params[1] = float operand 1 * params[1] = float operand 1
* params[2] = float operand 2 * params[2] = float operand 2
*/ */
REAL fRes = amx_ctof(params[1]) * amx_ctof(params[2]); float fRes = amx_ctof(params[1]) * amx_ctof(params[2]);
return amx_ftoc(fRes); return amx_ftoc(fRes);
} }
@ -130,7 +109,7 @@ static cell AMX_NATIVE_CALL n_floatdiv(AMX *amx,cell *params)
* params[1] = float dividend (top) * params[1] = float dividend (top)
* params[2] = float divisor (bottom) * params[2] = float divisor (bottom)
*/ */
REAL fRes = amx_ctof(params[1]) / amx_ctof(params[2]); float fRes = amx_ctof(params[1]) / amx_ctof(params[2]);
return amx_ftoc(fRes); return amx_ftoc(fRes);
} }
@ -145,7 +124,7 @@ static cell AMX_NATIVE_CALL n_floatadd(AMX *amx,cell *params)
* params[1] = float operand 1 * params[1] = float operand 1
* params[2] = float operand 2 * params[2] = float operand 2
*/ */
REAL fRes = amx_ctof(params[1]) + amx_ctof(params[2]); float fRes = amx_ctof(params[1]) + amx_ctof(params[2]);
return amx_ftoc(fRes); return amx_ftoc(fRes);
} }
@ -160,7 +139,7 @@ static cell AMX_NATIVE_CALL n_floatsub(AMX *amx,cell *params)
* params[1] = float operand 1 * params[1] = float operand 1
* params[2] = float operand 2 * params[2] = float operand 2
*/ */
REAL fRes = amx_ctof(params[1]) - amx_ctof(params[2]); float fRes = amx_ctof(params[1]) - amx_ctof(params[2]);
return amx_ftoc(fRes); return amx_ftoc(fRes);
} }
@ -175,8 +154,8 @@ static cell AMX_NATIVE_CALL n_floatfract(AMX *amx,cell *params)
* params[0] = number of bytes * params[0] = number of bytes
* params[1] = float operand * params[1] = float operand
*/ */
REAL fA = amx_ctof(params[1]); float fA = amx_ctof(params[1]);
fA = fA - (REAL)(floor((double)fA)); fA = fA - (float)(floor((double)fA));
return amx_ftoc(fA); return amx_ftoc(fA);
} }
@ -192,24 +171,24 @@ static cell AMX_NATIVE_CALL n_floatround(AMX *amx,cell *params)
* params[1] = float operand * params[1] = float operand
* params[2] = Type of rounding (long) * params[2] = Type of rounding (long)
*/ */
REAL fA = amx_ctof(params[1]); float fA = amx_ctof(params[1]);
switch (params[2]) switch (params[2])
{ {
case 1: /* round downwards (truncate) */ case 1: /* round downwards (truncate) */
fA = (REAL)(floor((double)fA)); fA = (float)(floor((double)fA));
break; break;
case 2: /* round upwards */ case 2: /* round upwards */
fA = (REAL)(ceil((double)fA)); fA = (float)(ceil((double)fA));
break; break;
case 3: /* round towards zero */ case 3: /* round towards zero */
if ( fA>=0.0 ) if ( fA>=0.0 )
fA = (REAL)(floor((double)fA)); fA = (float)(floor((double)fA));
else else
fA = (REAL)(ceil((double)fA)); fA = (float)(ceil((double)fA));
break; break;
default: /* standard, round to nearest */ default: /* standard, round to nearest */
fA = (REAL)(floor((double)fA+.5)); fA = (float)(floor((double)fA+.5));
break; break;
} }
@ -227,7 +206,7 @@ static cell AMX_NATIVE_CALL n_floatcmp(AMX *amx,cell *params)
* params[1] = float operand 1 * params[1] = float operand 1
* params[2] = float operand 2 * params[2] = float operand 2
*/ */
REAL fA, fB; float fA, fB;
fA = amx_ctof(params[1]); fA = amx_ctof(params[1]);
fB = amx_ctof(params[2]); fB = amx_ctof(params[2]);
@ -247,8 +226,8 @@ static cell AMX_NATIVE_CALL n_floatsqroot(AMX *amx,cell *params)
* params[0] = number of bytes * params[0] = number of bytes
* params[1] = float operand * params[1] = float operand
*/ */
REAL fA = amx_ctof(params[1]); float fA = amx_ctof(params[1]);
fA = (REAL)sqrt(fA); fA = (float)sqrt(fA);
if (fA < 0) if (fA < 0)
return amx_RaiseError(amx, AMX_ERR_DOMAIN); return amx_RaiseError(amx, AMX_ERR_DOMAIN);
return amx_ftoc(fA); return amx_ftoc(fA);
@ -265,9 +244,9 @@ static cell AMX_NATIVE_CALL n_floatpower(AMX *amx,cell *params)
* params[1] = float operand 1 (base) * params[1] = float operand 1 (base)
* params[2] = float operand 2 (exponent) * params[2] = float operand 2 (exponent)
*/ */
REAL fA = amx_ctof(params[1]); float fA = amx_ctof(params[1]);
REAL fB = amx_ctof(params[2]); float fB = amx_ctof(params[2]);
fA = (REAL)pow(fA, fB); fA = (float)pow(fA, fB);
return amx_ftoc(fA); return amx_ftoc(fA);
} }
@ -282,25 +261,25 @@ static cell AMX_NATIVE_CALL n_floatlog(AMX *amx,cell *params)
* params[1] = float operand 1 (value) * params[1] = float operand 1 (value)
* params[2] = float operand 2 (base) * params[2] = float operand 2 (base)
*/ */
REAL fValue = amx_ctof(params[1]); float fValue = amx_ctof(params[1]);
REAL fBase = amx_ctof(params[2]); float fBase = amx_ctof(params[2]);
if (fValue <= 0.0 || fBase <= 0) if (fValue <= 0.0 || fBase <= 0)
return amx_RaiseError(amx, AMX_ERR_DOMAIN); return amx_RaiseError(amx, AMX_ERR_DOMAIN);
if (fBase == 10.0) // ??? epsilon if (fBase == 10.0) // ??? epsilon
fValue = (REAL)log10(fValue); fValue = (float)log10(fValue);
else else
fValue = (REAL)(log(fValue) / log(fBase)); fValue = (float)(log(fValue) / log(fBase));
return amx_ftoc(fValue); return amx_ftoc(fValue);
} }
static REAL ToRadians(REAL angle, int radix) static float ToRadians(float angle, int radix)
{ {
switch (radix) switch (radix)
{ {
case 1: /* degrees, sexagesimal system (technically: degrees/minutes/seconds) */ case 1: /* degrees, sexagesimal system (technically: degrees/minutes/seconds) */
return (REAL)(angle * PI / 180.0); return (float)(angle * PI / 180.0);
case 2: /* grades, centesimal system */ case 2: /* grades, centesimal system */
return (REAL)(angle * PI / 200.0); return (float)(angle * PI / 200.0);
default: /* assume already radian */ default: /* assume already radian */
return angle; return angle;
} /* switch */ } /* switch */
@ -317,9 +296,9 @@ static cell AMX_NATIVE_CALL n_floatsin(AMX *amx,cell *params)
* params[1] = float operand 1 (angle) * params[1] = float operand 1 (angle)
* params[2] = float operand 2 (radix) * params[2] = float operand 2 (radix)
*/ */
REAL fA = amx_ctof(params[1]); float fA = amx_ctof(params[1]);
fA = ToRadians(fA, params[2]); fA = ToRadians(fA, params[2]);
fA = sin(fA); fA = sinf(fA); // PM: using the float version of sin
return amx_ftoc(fA); return amx_ftoc(fA);
} }
@ -334,9 +313,9 @@ static cell AMX_NATIVE_CALL n_floatcos(AMX *amx,cell *params)
* params[1] = float operand 1 (angle) * params[1] = float operand 1 (angle)
* params[2] = float operand 2 (radix) * params[2] = float operand 2 (radix)
*/ */
REAL fA = amx_ctof(params[1]); float fA = amx_ctof(params[1]);
fA = ToRadians(fA, params[2]); fA = ToRadians(fA, params[2]);
fA = cos(fA); fA = cosf(fA); // PM: using the float version of cos
return amx_ftoc(fA); return amx_ftoc(fA);
} }
@ -351,87 +330,19 @@ static cell AMX_NATIVE_CALL n_floattan(AMX *amx,cell *params)
* params[1] = float operand 1 (angle) * params[1] = float operand 1 (angle)
* params[2] = float operand 2 (radix) * params[2] = float operand 2 (radix)
*/ */
REAL fA = amx_ctof(params[1]); float fA = amx_ctof(params[1]);
fA = ToRadians(fA, params[2]); fA = ToRadians(fA, params[2]);
fA = tan(fA); fA = tanf(fA); // PM: using the float version of tan
return amx_ftoc(fA); return amx_ftoc(fA);
} }
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
/* Added by BAILOPAN */
static cell AMX_NATIVE_CALL n_floatatan(AMX *amx, cell *params)
{
/*
* params[1] = angle
* params[2] = radix
*/
REAL fA = amx_ctof(params[1]);
fA = ToRadians(fA, params[2]);
fA = atan(fA);
fA = FromRadians(fA, params[2]);
return amx_ftoc(fA);
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
/* Added by BAILOPAN */
static cell AMX_NATIVE_CALL n_floatacos(AMX *amx, cell *params)
{
/*
* params[1] = angle
* params[2] = radix
*/
REAL fA = amx_ctof(params[1]);
fA = acos(fA);
fA = FromRadians(fA, params[2]);
return amx_ftoc(fA);
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
/* Added by BAILOPAN */
static cell AMX_NATIVE_CALL n_floatasin(AMX *amx, cell *params)
{
/*
* params[1] = angle
* params[2] = radix
*/
REAL fA = amx_ctof(params[1]);
fA = asin(fA);
fA = FromRadians(fA, params[2]);
return amx_ftoc(fA);
}
#if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused
#endif
/* Added by BAILOPAN */
static cell AMX_NATIVE_CALL n_floatatan2(AMX *amx, cell *params)
{
/*
* params[1] = x
* params[2] = y
* params[3] = radix
*/
REAL fA = amx_ctof(params[1]);
REAL fB = amx_ctof(params[2]);
REAL fC;
fC = atan2(fA, fB);
fC = FromRadians(fC, params[3]);
return amx_ftoc(fC);
}
#if defined __BORLANDC__ || defined __WATCOMC__ #if defined __BORLANDC__ || defined __WATCOMC__
#pragma argsused #pragma argsused
#endif #endif
/******************************************************************/ /******************************************************************/
static cell AMX_NATIVE_CALL n_floatabs(AMX *amx,cell *params) static cell AMX_NATIVE_CALL n_floatabs(AMX *amx,cell *params)
{ {
REAL fA = amx_ctof(params[1]); float fA = amx_ctof(params[1]);
fA = (fA >= 0) ? fA : -fA; fA = (fA >= 0) ? fA : -fA;
return amx_ftoc(fA); return amx_ftoc(fA);
} }
@ -453,10 +364,6 @@ AMX_NATIVE_INFO float_Natives[] = {
{ "floatcos", n_floatcos }, { "floatcos", n_floatcos },
{ "floattan", n_floattan }, { "floattan", n_floattan },
{ "floatabs", n_floatabs }, { "floatabs", n_floatabs },
{ "floatasin", n_floatasin },
{ "floatacos", n_floatacos },
{ "floatatan", n_floatatan },
{ "floatatan2", n_floatatan2 },
{ NULL, NULL } /* terminator */ { NULL, NULL } /* terminator */
}; };

View File

@ -1,474 +0,0 @@
// MD5.CC - source code for the C++/object oriented translation and
// modification of MD5.
// Translation and modification (c) 1995 by Mordechai T. Abzug
// This translation/ modification is provided "as is," without express or
// implied warranty of any kind.
// The translator/ modifier does not claim (1) that MD5 will do what you think
// it does; (2) that this translation/ modification is accurate; or (3) that
// this software is "merchantible." (Language for this disclaimer partially
// copied from the disclaimer below).
/* based on:
MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
MDDRIVER.C - test driver for MD2, MD4 and MD5
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
#include "md5.h"
#include <assert.h>
#include <string.h>
// MD5 simple initialization method
MD5::MD5(){
init();
}
// MD5 block update operation. Continues an MD5 message-digest
// operation, processing another message block, and updating the
// context.
void MD5::update (uint1 *input, uint4 input_length) {
uint4 input_index, buffer_index;
uint4 buffer_space; // how much space is left in buffer
if (finalized){ // so we can't update!
/*cerr << "MD5::update: Can't update a finalized digest!" << endl;*/
return;
}
// Compute number of bytes mod 64
buffer_index = (unsigned int)((count[0] >> 3) & 0x3F);
// Update number of bits
if ( (count[0] += ((uint4) input_length << 3))<((uint4) input_length << 3) )
count[1]++;
count[1] += ((uint4)input_length >> 29);
buffer_space = 64 - buffer_index; // how much space is left in buffer
// Transform as many times as possible.
if (input_length >= buffer_space) { // ie. we have enough to fill the buffer
// fill the rest of the buffer and transform
memcpy (buffer + buffer_index, input, buffer_space);
transform (buffer);
// now, transform each 64-byte piece of the input, bypassing the buffer
for (input_index = buffer_space; input_index + 63 < input_length;
input_index += 64)
transform (input+input_index);
buffer_index = 0; // so we can buffer remaining
}
else
input_index=0; // so we can buffer the whole input
// and here we do the buffering:
memcpy(buffer+buffer_index, input+input_index, input_length-input_index);
}
// MD5 update for files.
// Like above, except that it works on files (and uses above as a primitive.)
void MD5::update(FILE *file){
unsigned char buffer[1024];
int len;
while (len=fread(buffer, 1, 1024, file))
update(buffer, len);
fclose (file);
}
// MD5 finalization. Ends an MD5 message-digest operation, writing the
// the message digest and zeroizing the context.
void MD5::finalize (){
unsigned char bits[8];
unsigned int index, padLen;
static uint1 PADDING[64]={
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
if (finalized){
/* cerr << "MD5::finalize: Already finalized this digest!" << endl;*/
return;
}
// Save number of bits
encode (bits, count, 8);
// Pad out to 56 mod 64.
index = (uint4) ((count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
update (PADDING, padLen);
// Append length (before padding)
update (bits, 8);
// Store state in digest
encode (digest, state, 16);
// Zeroize sensitive information
memset (buffer, 0, sizeof(*buffer));
finalized=1;
}
MD5::MD5(FILE *file){
init(); // must be called be all constructors
update(file);
finalize ();
}
unsigned char *MD5::raw_digest(){
uint1 *s = new uint1[16];
if (!finalized){
/* cerr << "MD5::raw_digest: Can't get digest if you haven't "<<
"finalized the digest!" <<endl;*/
return ( (unsigned char*) "");
}
memcpy(s, digest, 16);
return s;
}
char *MD5::hex_digest(){
int i;
char *s= new char[33];
if (!finalized){
/* cerr << "MD5::hex_digest: Can't get digest if you haven't "<<
"finalized the digest!" <<endl;*/
return "";
}
for (i=0; i<16; i++)
sprintf(s+i*2, "%02x", digest[i]);
s[32]='\0';
return s;
}
char *MD5::hex_digest(char buffer[33]){
int i;
if (!finalized)
{
/* cerr << "MD5::hex_digest: Can't get digest if you haven't "<<
"finalized the digest!" <<endl;*/
return "";
}
for (i=0; i<16; i++)
sprintf(buffer+i*2, "%02x", digest[i]);
buffer[32]='\0';
return buffer;
}
// PRIVATE METHODS:
void MD5::init(){
finalized=0; // we just started!
// Nothing counted, so count=0
count[0] = 0;
count[1] = 0;
// Load magic initialization constants.
state[0] = 0x67452301;
state[1] = 0xefcdab89;
state[2] = 0x98badcfe;
state[3] = 0x10325476;
}
// Constants for MD5Transform routine.
// Although we could use C++ style constants, defines are actually better,
// since they let us easily evade scope clashes.
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
// MD5 basic transformation. Transforms state based on block.
void MD5::transform (uint1 block[64]){
uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
decode (x, block, 64);
assert(!finalized); // not just a user error, since the method is private
/* Round 1 */
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
// Zeroize sensitive information.
memset ( (uint1 *) x, 0, sizeof(x));
}
// Encodes input (UINT4) into output (unsigned char). Assumes len is
// a multiple of 4.
void MD5::encode (uint1 *output, uint4 *input, uint4 len) {
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4) {
output[j] = (uint1) (input[i] & 0xff);
output[j+1] = (uint1) ((input[i] >> 8) & 0xff);
output[j+2] = (uint1) ((input[i] >> 16) & 0xff);
output[j+3] = (uint1) ((input[i] >> 24) & 0xff);
}
}
// Decodes input (unsigned char) into output (UINT4). Assumes len is
// a multiple of 4.
void MD5::decode (uint4 *output, uint1 *input, uint4 len){
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
(((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
}
// Note: Replace "for loop" with standard memcpy if possible.
void MD5::memcpy (uint1 *output, uint1 *input, uint4 len){
unsigned int i;
for (i = 0; i < len; i++)
output[i] = input[i];
}
// Note: Replace "for loop" with standard memset if possible.
void MD5::memset (uint1 *output, uint1 value, uint4 len){
unsigned int i;
for (i = 0; i < len; i++)
output[i] = value;
}
// ROTATE_LEFT rotates x left n bits.
inline unsigned int MD5::rotate_left (uint4 x, uint4 n){
return (x << n) | (x >> (32-n)) ;
}
// F, G, H and I are basic MD5 functions.
inline unsigned int MD5::F (uint4 x, uint4 y, uint4 z){
return (x & y) | (~x & z);
}
inline unsigned int MD5::G (uint4 x, uint4 y, uint4 z){
return (x & z) | (y & ~z);
}
inline unsigned int MD5::H (uint4 x, uint4 y, uint4 z){
return x ^ y ^ z;
}
inline unsigned int MD5::I (uint4 x, uint4 y, uint4 z){
return y ^ (x | ~z);
}
// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
// Rotation is separate from addition to prevent recomputation.
inline void MD5::FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac){
a += F(b, c, d) + x + ac;
a = rotate_left (a, s) +b;
}
inline void MD5::GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac){
a += G(b, c, d) + x + ac;
a = rotate_left (a, s) +b;
}
inline void MD5::HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac){
a += H(b, c, d) + x + ac;
a = rotate_left (a, s) +b;
}
inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac){
a += I(b, c, d) + x + ac;
a = rotate_left (a, s) +b;
}

View File

@ -1,105 +0,0 @@
// MD5.CC - source code for the C++/object oriented translation and
// modification of MD5.
// Translation and modification (c) 1995 by Mordechai T. Abzug
// This translation/ modification is provided "as is," without express or
// implied warranty of any kind.
// The translator/ modifier does not claim (1) that MD5 will do what you think
// it does; (2) that this translation/ modification is accurate; or (3) that
// this software is "merchantible." (Language for this disclaimer partially
// copied from the disclaimer below).
/* based on:
MD5.H - header file for MD5C.C
MDDRIVER.C - test driver for MD2, MD4 and MD5
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
#include <stdio.h>
//#include <fstream.h>
//#include <iostream.h>
class MD5 {
public:
// methods for controlled operation:
MD5 (); // simple initializer
void update (unsigned char *input, unsigned int input_length);
void update (FILE *file);
void finalize ();
// constructors for special circumstances. All these constructors finalize
// the MD5 context.
MD5 (unsigned char *string); // digest string, finalize
MD5 (FILE *file); // digest file, close, finalize
// methods to acquire finalized result
unsigned char *raw_digest (); // digest as a 16-byte binary array
char * hex_digest (); // digest as a 33-byte ascii-hex string
char * hex_digest (char buffer[33]); //same as above, passing buffer
private:
// first, some types:
typedef unsigned int uint4; // assumes integer is 4 words long
typedef unsigned short int uint2; // assumes short integer is 2 words long
typedef unsigned char uint1; // assumes char is 1 word long
// next, the private data:
uint4 state[4];
uint4 count[2]; // number of *bits*, mod 2^64
uint1 buffer[64]; // input buffer
uint1 digest[16];
uint1 finalized;
// last, the private methods, mostly static:
void init (); // called by all constructors
void transform (uint1 *buffer); // does the real update work. Note
// that length is implied to be 64.
static void encode (uint1 *dest, uint4 *src, uint4 length);
static void decode (uint4 *dest, uint1 *src, uint4 length);
static void memcpy (uint1 *dest, uint1 *src, uint4 length);
static void memset (uint1 *start, uint1 val, uint4 length);
static inline uint4 rotate_left (uint4 x, uint4 n);
static inline uint4 F (uint4 x, uint4 y, uint4 z);
static inline uint4 G (uint4 x, uint4 y, uint4 z);
static inline uint4 H (uint4 x, uint4 y, uint4 z);
static inline uint4 I (uint4 x, uint4 y, uint4 z);
static inline void FF (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac);
static inline void GG (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac);
static inline void HH (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac);
static inline void II (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac);
};

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,146 +0,0 @@
// ---------------------------------------------------------------------------------------------------------------------------------
// Copyright 2000, Paul Nettle. All rights reserved.
//
// You are free to use this source code in any commercial or non-commercial product.
//
// mmgr.h - Memory manager & tracking software
//
// The most recent version of this software can be found at: ftp://ftp.GraphicsPapers.com/pub/ProgrammingTools/MemoryManagers/
//
// [NOTE: Best when viewed with 8-character tabs]
// ---------------------------------------------------------------------------------------------------------------------------------
#ifndef _H_MMGR
#define _H_MMGR
// ---------------------------------------------------------------------------------------------------------------------------------
// For systems that don't have the __FUNCTION__ variable, we can just define it here
// ---------------------------------------------------------------------------------------------------------------------------------
#ifndef __FUNCTION__
#define __FUNCTION__ "??"
#endif // #ifndef __FUNCTION__
// ---------------------------------------------------------------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------------------------------------------------------------
typedef struct tag_au
{
size_t actualSize;
size_t reportedSize;
void *actualAddress;
void *reportedAddress;
char sourceFile[40];
char sourceFunc[40];
unsigned int sourceLine;
unsigned int allocationType;
bool breakOnDealloc;
bool breakOnRealloc;
unsigned int allocationNumber;
struct tag_au *next;
struct tag_au *prev;
} sAllocUnit;
typedef struct
{
unsigned int totalReportedMemory;
unsigned int totalActualMemory;
unsigned int peakReportedMemory;
unsigned int peakActualMemory;
unsigned int accumulatedReportedMemory;
unsigned int accumulatedActualMemory;
unsigned int accumulatedAllocUnitCount;
unsigned int totalAllocUnitCount;
unsigned int peakAllocUnitCount;
} sMStats;
// ---------------------------------------------------------------------------------------------------------------------------------
// External constants
// ---------------------------------------------------------------------------------------------------------------------------------
extern const unsigned int m_alloc_unknown;
extern const unsigned int m_alloc_new;
extern const unsigned int m_alloc_new_array;
extern const unsigned int m_alloc_malloc;
extern const unsigned int m_alloc_calloc;
extern const unsigned int m_alloc_realloc;
extern const unsigned int m_alloc_delete;
extern const unsigned int m_alloc_delete_array;
extern const unsigned int m_alloc_free;
// ---------------------------------------------------------------------------------------------------------------------------------
// Used by the macros
// ---------------------------------------------------------------------------------------------------------------------------------
void m_setOwner(const char *file, const unsigned int line, const char *func);
// ---------------------------------------------------------------------------------------------------------------------------------
// Allocation breakpoints
// ---------------------------------------------------------------------------------------------------------------------------------
bool &m_breakOnRealloc(void *reportedAddress);
bool &m_breakOnDealloc(void *reportedAddress);
// ---------------------------------------------------------------------------------------------------------------------------------
// The meat of the memory tracking software
// ---------------------------------------------------------------------------------------------------------------------------------
void *m_allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
const unsigned int allocationType, const size_t reportedSize);
void *m_reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress);
void m_deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
const unsigned int deallocationType, const void *reportedAddress);
// ---------------------------------------------------------------------------------------------------------------------------------
// Utilitarian functions
// ---------------------------------------------------------------------------------------------------------------------------------
bool m_validateAddress(const void *reportedAddress);
bool m_validateAllocUnit(const sAllocUnit *allocUnit);
bool m_validateAllAllocUnits();
// ---------------------------------------------------------------------------------------------------------------------------------
// Unused RAM calculations
// ---------------------------------------------------------------------------------------------------------------------------------
unsigned int m_calcUnused(const sAllocUnit *allocUnit);
unsigned int m_calcAllUnused();
// ---------------------------------------------------------------------------------------------------------------------------------
// Logging and reporting
// ---------------------------------------------------------------------------------------------------------------------------------
void m_dumpAllocUnit(const sAllocUnit *allocUnit, const char *prefix = "");
void m_dumpMemoryReport(const char *filename = "memreport.log", const bool overwrite = true);
sMStats m_getMemoryStatistics();
// ---------------------------------------------------------------------------------------------------------------------------------
// Variations of global operators new & delete
// ---------------------------------------------------------------------------------------------------------------------------------
void *operator new(size_t reportedSize);
void *operator new[](size_t reportedSize);
void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine);
void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine);
void operator delete(void *reportedAddress);
void operator delete[](void *reportedAddress);
#endif // _H_MMGR
// ---------------------------------------------------------------------------------------------------------------------------------
// Macros -- "Kids, please don't try this at home. We're trained professionals here." :)
// ---------------------------------------------------------------------------------------------------------------------------------
#include "nommgr.h"
#define new (m_setOwner (__FILE__,__LINE__,__FUNCTION__),false) ? NULL : new
#define delete (m_setOwner (__FILE__,__LINE__,__FUNCTION__),false) ? m_setOwner("",0,"") : delete
#define malloc(sz) m_allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_malloc,sz)
#define calloc(sz) m_allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_calloc,sz)
#define realloc(ptr,sz) m_reallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_realloc,sz,ptr)
#define free(ptr) m_deallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_free,ptr)
// ---------------------------------------------------------------------------------------------------------------------------------
// mmgr.h - End of file
// ---------------------------------------------------------------------------------------------------------------------------------

View File

@ -1,39 +0,0 @@
// ---------------------------------------------------------------------------------------------------------------------------------
// Copyright 2000, Paul Nettle. All rights reserved.
//
// You are free to use this source code in any commercial or non-commercial product.
//
// nommgr.h - Memory manager & tracking software
//
// The most recent version of this software can be found at: ftp://ftp.GraphicsPapers.com/pub/ProgrammingTools/MemoryManagers/
//
// [NOTE: Best when viewed with 8-character tabs]
// ---------------------------------------------------------------------------------------------------------------------------------
#ifdef new
#undef new
#endif
#ifdef delete
#undef delete
#endif
#ifdef malloc
#undef malloc
#endif
#ifdef calloc
#undef calloc
#endif
#ifdef realloc
#undef realloc
#endif
#ifdef free
#undef free
#endif
// ---------------------------------------------------------------------------------------------------------------------------------
// nommgr.h - End of file
// ---------------------------------------------------------------------------------------------------------------------------------

File diff suppressed because it is too large Load Diff

View File

@ -144,7 +144,7 @@ struct pfnmodule_engine_g {
const char* (*pfnget_amxscriptname)(AMX* amx); // amx const char* (*pfnget_amxscriptname)(AMX* amx); // amx
char* (*pfnget_amxstring)(AMX*,cell,int, int&); // amx, src, buffer (0-3), len char* (*pfnget_amxstring)(AMX*,cell,int, int&); // amx, src, buffer (0-3), len
void (*pfnget_modname)(char*); // modname void (*pfnget_modname)(char*); // modname
int (*pfnload_amxscript)(AMX*, void**, const char*, char[64], int); // amx, code, path, error info int (*pfnload_amxscript)(AMX*, void**, const char*, char[64]); // amx, code, path, error info
void (*pfnprint_console)(char*, ...); // format, .... void (*pfnprint_console)(char*, ...); // format, ....
void (*pfnreport_error)(int code, char*, ... ); void (*pfnreport_error)(int code, char*, ... );
int (*pfnset_amxnatives)(AMX*,char[64]); // amx, error info int (*pfnset_amxnatives)(AMX*,char[64]); // amx, error info

View File

@ -1,12 +0,0 @@
amxmodx.sln
amxmodx.suo
amxmodx.aps
amxmodx.ncb
Debug
JITDebug
JITMemtestRelease
JITRelease
MaximalSpeed
MemtestDebug
MemtestRelease
Release

View File

@ -1,4 +1,4 @@
LIBRARY amxx_mm LIBRARY amx_mm
EXPORTS EXPORTS
GiveFnptrsToDll @1 GiveFnptrsToDll @1

View File

@ -1,24 +1,24 @@
# Microsoft Developer Studio Project File - Name="amxmodx_mm" - Package Owner=<4> # Microsoft Developer Studio Project File - Name="amxmod_mm" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00 # Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT ** # ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=amxmodx_mm - Win32 Debug CFG=amxmod_mm - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run !MESSAGE use the Export Makefile command and run
!MESSAGE !MESSAGE
!MESSAGE NMAKE /f "amxmodx_mm.mak". !MESSAGE NMAKE /f "amxmod_mm.mak".
!MESSAGE !MESSAGE
!MESSAGE You can specify a configuration when running NMAKE !MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE !MESSAGE
!MESSAGE NMAKE /f "amxmodx_mm.mak" CFG="amxmodx_mm - Win32 Debug" !MESSAGE NMAKE /f "amxmod_mm.mak" CFG="amxmod_mm - Win32 Debug"
!MESSAGE !MESSAGE
!MESSAGE Possible choices for configuration are: !MESSAGE Possible choices for configuration are:
!MESSAGE !MESSAGE
!MESSAGE "amxmodx_mm - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library") !MESSAGE "amxmod_mm - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "amxmodx_mm - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library") !MESSAGE "amxmod_mm - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE !MESSAGE
# Begin Project # Begin Project
@ -29,7 +29,7 @@ CPP=cl.exe
MTL=midl.exe MTL=midl.exe
RSC=rc.exe RSC=rc.exe
!IF "$(CFG)" == "amxmodx_mm - Win32 Release" !IF "$(CFG)" == "amxmod_mm - Win32 Release"
# PROP BASE Use_MFC 0 # PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0 # PROP BASE Use_Debug_Libraries 0
@ -42,8 +42,8 @@ RSC=rc.exe
# PROP Intermediate_Dir "release" # PROP Intermediate_Dir "release"
# PROP Ignore_Export_Lib 0 # PROP Ignore_Export_Lib 0
# PROP Target_Dir "" # PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmodx_mm_EXPORTS" /YX /FD /c # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmod_mm_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "..\..\metamod\metamod" /I "..\..\hlsdk\sourcecode\common" /I "..\..\hlsdk\sourcecode\engine" /I "..\..\hlsdk\sourcecode\dlls" /I "..\..\hlsdk\sourcecode\pm_shared" /I "..\extra\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmodx_mm_EXPORTS" /YX /FD /c # ADD CPP /nologo /MT /W3 /GX /O2 /I "..\..\metamod\metamod" /I "..\..\hlsdk\sourcecode\common" /I "..\..\hlsdk\sourcecode\engine" /I "..\..\hlsdk\sourcecode\dlls" /I "..\..\hlsdk\sourcecode\pm_shared" /I "..\extra\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmod_mm_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD BASE RSC /l 0x409 /d "NDEBUG"
@ -53,11 +53,11 @@ BSC32=bscmake.exe
# ADD BSC32 /nologo # ADD BSC32 /nologo
LINK32=link.exe LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /def:".\amxmodx_mm.def" /out:"release/amxx_mm.dll" /libpath:"..\extra\lib_win32" # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /def:".\amxmod_mm.def" /out:"release/amx_mm.dll" /libpath:"..\extra\lib_win32"
# Begin Custom Build # Begin Custom Build
TargetPath=.\release\amxx_mm.dll TargetPath=.\release\amx_mm.dll
TargetName=amxx_mm TargetName=amx_mm
InputPath=.\release\amxx_mm.dll InputPath=.\release\amx_mm.dll
SOURCE="$(InputPath)" SOURCE="$(InputPath)"
"$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" "$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
@ -65,7 +65,7 @@ SOURCE="$(InputPath)"
# End Custom Build # End Custom Build
!ELSEIF "$(CFG)" == "amxmodx_mm - Win32 Debug" !ELSEIF "$(CFG)" == "amxmod_mm - Win32 Debug"
# PROP BASE Use_MFC 0 # PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1 # PROP BASE Use_Debug_Libraries 1
@ -78,8 +78,8 @@ SOURCE="$(InputPath)"
# PROP Intermediate_Dir "debug" # PROP Intermediate_Dir "debug"
# PROP Ignore_Export_Lib 0 # PROP Ignore_Export_Lib 0
# PROP Target_Dir "" # PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmodx_mm_EXPORTS" /YX /FD /GZ /c # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmod_mm_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /Zp4 /MTd /W3 /Gm /GX /ZI /Od /I "..\..\metamod\metamod" /I "..\...\hlsdk\sourcecode\common" /I "..\...\hlsdk\sourcecode\engine" /I "..\...\hlsdk\sourcecode\dlls" /I "..\...\hlsdk\sourcecode\pm_shared" /I "..\extra\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmodx_mm_EXPORTS" /YX /FD /GZ /c # ADD CPP /nologo /Zp4 /MTd /W3 /Gm /GX /ZI /Od /I "..\..\metamod\metamod" /I "..\...\hlsdk\sourcecode\common" /I "..\...\hlsdk\sourcecode\engine" /I "..\...\hlsdk\sourcecode\dlls" /I "..\...\hlsdk\sourcecode\pm_shared" /I "..\extra\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "amxmod_mm_EXPORTS" /YX /FD /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD BASE RSC /l 0x409 /d "_DEBUG"
@ -89,12 +89,12 @@ BSC32=bscmake.exe
# ADD BSC32 /nologo # ADD BSC32 /nologo
LINK32=link.exe LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /def:".\amxmodx_mm.def" /out:"debug/amxx_mm.dll" /pdbtype:sept /libpath:"..\extra\lib_win32" # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /def:".\amxmod_mm.def" /out:"debug/amx_mm.dll" /pdbtype:sept /libpath:"..\extra\lib_win32"
# SUBTRACT LINK32 /incremental:no /nodefaultlib # SUBTRACT LINK32 /incremental:no /nodefaultlib
# Begin Custom Build # Begin Custom Build
TargetPath=.\debug\amxx_mm.dll TargetPath=.\debug\amx_mm.dll
TargetName=amxx_mm TargetName=amx_mm
InputPath=.\debug\amxx_mm.dll InputPath=.\debug\amx_mm.dll
SOURCE="$(InputPath)" SOURCE="$(InputPath)"
"$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" "$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
@ -106,8 +106,8 @@ SOURCE="$(InputPath)"
# Begin Target # Begin Target
# Name "amxmodx_mm - Win32 Release" # Name "amxmod_mm - Win32 Release"
# Name "amxmodx_mm - Win32 Debug" # Name "amxmod_mm - Win32 Debug"
# Begin Group "Source Files" # Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
@ -121,7 +121,7 @@ SOURCE=..\amxcore.c
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=..\amxmodx.cpp SOURCE=..\amxmod.cpp
# End Source File # End Source File
# Begin Source File # Begin Source File
@ -129,10 +129,6 @@ SOURCE=..\amxtime.c
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=..\amxxlog.cpp
# End Source File
# Begin Source File
SOURCE=..\CCmd.cpp SOURCE=..\CCmd.cpp
# End Source File # End Source File
# Begin Source File # Begin Source File
@ -229,7 +225,7 @@ SOURCE=..\vault.cpp
# PROP Default_Filter "h;hpp;hxx;hm;inl" # PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File # Begin Source File
SOURCE=..\amxmodx.h SOURCE=..\amxmod.h
# End Source File # End Source File
# Begin Source File # Begin Source File

View File

@ -3,7 +3,7 @@ Microsoft Developer Studio Workspace File, Format Version 6.00
############################################################################### ###############################################################################
Project: "tfcx"=.\tfcx.dsp - Package Owner=<4> Project: "amxmod_mm"=.\amxmod_mm.dsp - Package Owner=<4>
Package=<5> Package=<5>
{{{ {{{
@ -27,4 +27,3 @@ Package=<3>
############################################################################### ###############################################################################

752
amxmodx/msvc/amxmod_mm.vcproj Executable file
View File

@ -0,0 +1,752 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="amxmod_mm"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Release|Win32"
OutputDirectory=".\release"
IntermediateDirectory=".\release"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmod_mm_EXPORTS"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\release/amxmod_mm.pch"
AssemblerListingLocation=".\release/"
ObjectFile=".\release/"
ProgramDataBaseFileName=".\release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"
CommandLine="copy &quot;$(TargetPath)&quot; D:\SIERRA\Half-Life\cstrike\addons\amx\dlls
"
Outputs="$(TargetName)"/>
<Tool
Name="VCLinkerTool"
OutputFile="release/amx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=".\amxmod_mm.def"
ProgramDatabaseFile=".\release/amx_mm.pdb"
ImportLibrary=".\release/amx_mm.lib"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmod_mm.tlb"
HeaderFileName=""/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\debug"
IntermediateDirectory=".\debug"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\...\hlsdk\sourcecode\common,..\...\hlsdk\sourcecode\engine,..\...\hlsdk\sourcecode\dlls,..\...\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmod_mm_EXPORTS"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
StructMemberAlignment="3"
UsePrecompiledHeader="2"
PrecompiledHeaderFile=".\debug/amxmod_mm.pch"
AssemblerListingLocation=".\debug/"
ObjectFile=".\debug/"
ProgramDataBaseFileName=".\debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"
CommandLine="copy &quot;$(TargetPath)&quot; D:\SIERRA\Half-Life\cstrike\addons\amx\dlls
"
Outputs="$(TargetName)"/>
<Tool
Name="VCLinkerTool"
OutputFile="debug/amx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=".\amxmod_mm.def"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\debug/amx_mm.pdb"
ImportLibrary=".\debug/amx_mm.lib"
TargetMachine="1"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\debug/amxmod_mm.tlb"
HeaderFileName=""/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\amx.c">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\amxcore.c">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\amxmod.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\amxtime.c">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CCmd.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CEvent.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CFile.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CForward.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CLogEvent.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CMenu.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CMisc.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CModule.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CPlugin.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CString.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CTask.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\CVault.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\emsg.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\file.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\float.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\meta_api.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\modules.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\power.c">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\srvcmd.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\string.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\strptime.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\util.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
<File
RelativePath="..\vault.cpp">
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;amxmod_mm_EXPORTS;$(NoInherit)"
BasicRuntimeChecks="3"/>
</FileConfiguration>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
<File
RelativePath="..\amxmod.h">
</File>
<File
RelativePath="..\CCmd.h">
</File>
<File
RelativePath="..\CEvent.h">
</File>
<File
RelativePath="..\CFile.h">
</File>
<File
RelativePath="..\CForward.h">
</File>
<File
RelativePath="..\CList.h">
</File>
<File
RelativePath="..\CLogEvent.h">
</File>
<File
RelativePath="..\CMenu.h">
</File>
<File
RelativePath="..\CMisc.h">
</File>
<File
RelativePath="..\CModule.h">
</File>
<File
RelativePath="..\CPlugin.h">
</File>
<File
RelativePath="..\CString.h">
</File>
<File
RelativePath="..\CTask.h">
</File>
<File
RelativePath="..\CVault.h">
</File>
<File
RelativePath="..\modules.h">
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

View File

@ -1,804 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="amxmodx"
ProjectGUID="{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\pm_shared&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\dlls&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\engine&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\common&quot;;C:\Files\Programming\metamod\metamod"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
StructMemberAlignment="3"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\debug/amxmodx.pch"
AssemblerListingLocation=".\debug/"
ObjectFile=".\debug/"
ProgramDataBaseFileName=".\debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
OutputFile="debug/amxmodx_mm.dll"
Version="0.1"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\debug/amxx_mm.pdb"
ImportLibrary=".\debug/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\debug/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\release/amxmodx.pch"
AssemblerListingLocation=".\release/"
ObjectFile=".\release/"
ProgramDataBaseFileName=".\release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
OutputFile="release/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\release/amxx_mm.pdb"
ImportLibrary=".\release/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="MemtestDebug|Win32"
OutputDirectory="MemtestDebug"
IntermediateDirectory="MemtestDebug"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\pm_shared&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\dlls&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\engine&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\common&quot;;C:\Files\Programming\metamod\metamod"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;MEMORY_TEST"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
StructMemberAlignment="3"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\memtestdebug/amxmodx.pch"
AssemblerListingLocation=".\memtestdebug/"
ObjectFile=".\memtestdebug/"
ProgramDataBaseFileName=".\memtestdebug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
OutputFile="memtestdebug/amxmodx_mm.dll"
Version="0.1"
LinkIncremental="2"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\memtestdebug/amxx_mm.pdb"
ImportLibrary=".\memtestdebug/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\debug/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="MemtestRelease|Win32"
OutputDirectory="MemtestRelease"
IntermediateDirectory="MemtestRelease"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;MEMORY_TEST"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\memtestrelease/amxmodx.pch"
AssemblerListingLocation=".\memtestrelease/"
ObjectFile=".\memtestrelease/"
ProgramDataBaseFileName=".\memtestrelease/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
OutputFile="memtestrelease/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\memtestrelease/amxx_mm.pdb"
ImportLibrary=".\memtestrelease/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="JITDebug|Win32"
OutputDirectory="JITDebug"
IntermediateDirectory="JITDebug"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\pm_shared&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\dlls&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\engine&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\common&quot;;C:\Files\Programming\metamod\metamod"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
StructMemberAlignment="3"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\jitdebug/amxmodx.pch"
AssemblerListingLocation=".\jitdebug/"
ObjectFile=".\jitdebug/"
ProgramDataBaseFileName=".\jitdebug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\jit\jits.lib ..\zlib\zlib.lib"
OutputFile="jitdebug/amxmodx_mm.dll"
Version="0.1"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\jitdebug/amxx_mm.pdb"
ImportLibrary=".\jitdebug/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\debug/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="JITRelease|Win32"
OutputDirectory="JITRelease"
IntermediateDirectory="JITRelease"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\jitrelease/amxmodx.pch"
AssemblerListingLocation=".\jitrelease/"
ObjectFile=".\jitrelease/"
ProgramDataBaseFileName=".\jitrelease/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="..\jit\jits.obj ..\zlib\zlib.lib"
OutputFile="jitrelease/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\jitrelease/amxx_mm.pdb"
ImportLibrary=".\jitrelease/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="JITMemtestRelease|Win32"
OutputDirectory="JITMemtestRelease"
IntermediateDirectory="JITMemtestRelease"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;MEMORY_TEST;JIT"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\jitmemtestrelease/amxmodx.pch"
AssemblerListingLocation=".\jitmemtestrelease/"
ObjectFile=".\jitmemtestrelease/"
ProgramDataBaseFileName=".\jitmemtestrelease/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\jit\jits.lib ..\zlib\zlib.lib"
OutputFile="jitmemtestrelease/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\jitmemtestrelease/amxx_mm.pdb"
ImportLibrary=".\jitmemtestrelease/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="MaximalSpeed|Win32"
OutputDirectory="MaximalSpeed"
IntermediateDirectory="MaximalSpeed"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
EnableIntrinsicFunctions="TRUE"
FavorSizeOrSpeed="1"
OptimizeForProcessor="2"
OptimizeForWindowsApplication="TRUE"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\MaximalSpeed/amxmodx.pch"
AssemblerListingLocation=".\MaximalSpeed/"
ObjectFile=".\MaximalSpeed/"
ProgramDataBaseFileName=".\MaximalSpeed/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\jit\jits.lib ..\zlib\zlib.lib"
OutputFile="MaximalSpeed/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\MaximalSpeede/amxx_mm.pdb"
ImportLibrary=".\jitrelease/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\amx.cpp">
</File>
<File
RelativePath="..\amxcore.cpp">
</File>
<File
RelativePath="..\amxmodx.cpp">
</File>
<File
RelativePath="..\amxtime.cpp">
</File>
<File
RelativePath="..\amxxfile.cpp">
</File>
<File
RelativePath="..\amxxlog.cpp">
</File>
<File
RelativePath="..\CCmd.cpp">
</File>
<File
RelativePath="..\CEvent.cpp">
</File>
<File
RelativePath="..\CFile.cpp">
</File>
<File
RelativePath="..\CForward.cpp">
</File>
<File
RelativePath="..\CLang.cpp">
</File>
<File
RelativePath="..\CLogEvent.cpp">
</File>
<File
RelativePath="..\CMenu.cpp">
</File>
<File
RelativePath="..\CMisc.cpp">
</File>
<File
RelativePath="..\CModule.cpp">
</File>
<File
RelativePath="..\CPlugin.cpp">
</File>
<File
RelativePath="..\CTask.cpp">
</File>
<File
RelativePath="..\CVault.cpp">
</File>
<File
RelativePath="..\emsg.cpp">
</File>
<File
RelativePath="..\fakemeta.cpp">
<FileConfiguration
Name="MemtestDebug|Win32">
<Tool
Name="VCCLCompilerTool"
GeneratePreprocessedFile="0"/>
</FileConfiguration>
</File>
<File
RelativePath="..\file.cpp">
</File>
<File
RelativePath="..\float.cpp">
</File>
<File
RelativePath="..\md5.cpp">
</File>
<File
RelativePath="..\meta_api.cpp">
</File>
<File
RelativePath="..\modules.cpp">
</File>
<File
RelativePath="..\power.cpp">
</File>
<File
RelativePath="..\srvcmd.cpp">
</File>
<File
RelativePath="..\string.cpp">
</File>
<File
RelativePath="..\strptime.cpp">
</File>
<File
RelativePath="..\util.cpp">
</File>
<File
RelativePath="..\vault.cpp">
</File>
<Filter
Name="mmgr"
Filter="">
<File
RelativePath="..\mmgr\mmgr.cpp">
<FileConfiguration
Name="Debug|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
<FileConfiguration
Name="JITDebug|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
<FileConfiguration
Name="JITRelease|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
<FileConfiguration
Name="MaximalSpeed|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
</File>
</Filter>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
<File
RelativePath="..\amx.h">
</File>
<File
RelativePath="..\amxmodx.h">
</File>
<File
RelativePath="..\amxxfile.h">
</File>
<File
RelativePath="..\amxxlog.h">
</File>
<File
RelativePath="..\CCmd.h">
</File>
<File
RelativePath="..\CEvent.h">
</File>
<File
RelativePath="..\CFile.h">
</File>
<File
RelativePath="..\CForward.h">
</File>
<File
RelativePath="..\CLang.h">
</File>
<File
RelativePath="..\CList.h">
</File>
<File
RelativePath="..\CLogEvent.h">
</File>
<File
RelativePath="..\CMenu.h">
</File>
<File
RelativePath="..\CMisc.h">
</File>
<File
RelativePath="..\CModule.h">
</File>
<File
RelativePath="..\CPlugin.h">
</File>
<File
RelativePath="..\CQueue.h">
</File>
<File
RelativePath="..\CRList.h">
</File>
<File
RelativePath="..\CString.h">
</File>
<File
RelativePath="..\CTask.h">
</File>
<File
RelativePath="..\CVault.h">
</File>
<File
RelativePath="..\CVector.h">
</File>
<File
RelativePath="..\fakemeta.h">
</File>
<File
RelativePath="..\md5.h">
</File>
<File
RelativePath="..\modules.h">
</File>
<Filter
Name="mmgr"
Filter="">
<File
RelativePath="..\mmgr\mmgr.h">
</File>
<File
RelativePath="..\mmgr\nommgr.h">
</File>
</Filter>
</Filter>
<Filter
Name="Resource Files"
Filter="rc">
<File
RelativePath="..\version.rc">
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

View File

@ -1,29 +0,0 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "amxmodx_mm"=.\amxmodx_mm.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

View File

@ -1,804 +0,0 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.10"
Name="amxmodx"
ProjectGUID="{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\pm_shared&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\dlls&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\engine&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\common&quot;;C:\Files\Programming\metamod\metamod"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
StructMemberAlignment="3"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\debug/amxmodx.pch"
AssemblerListingLocation=".\debug/"
ObjectFile=".\debug/"
ProgramDataBaseFileName=".\debug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
OutputFile="debug/amxmodx_mm.dll"
Version="0.1"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\debug/amxx_mm.pdb"
ImportLibrary=".\debug/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\debug/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\release/amxmodx.pch"
AssemblerListingLocation=".\release/"
ObjectFile=".\release/"
ProgramDataBaseFileName=".\release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
OutputFile="release/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\release/amxx_mm.pdb"
ImportLibrary=".\release/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="MemtestDebug|Win32"
OutputDirectory="MemtestDebug"
IntermediateDirectory="MemtestDebug"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\pm_shared&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\dlls&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\engine&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\common&quot;;C:\Files\Programming\metamod\metamod"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;MEMORY_TEST"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
StructMemberAlignment="3"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\memtestdebug/amxmodx.pch"
AssemblerListingLocation=".\memtestdebug/"
ObjectFile=".\memtestdebug/"
ProgramDataBaseFileName=".\memtestdebug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
OutputFile="memtestdebug/amxmodx_mm.dll"
Version="0.1"
LinkIncremental="2"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\memtestdebug/amxx_mm.pdb"
ImportLibrary=".\memtestdebug/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\debug/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="MemtestRelease|Win32"
OutputDirectory="MemtestRelease"
IntermediateDirectory="MemtestRelease"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;MEMORY_TEST"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\memtestrelease/amxmodx.pch"
AssemblerListingLocation=".\memtestrelease/"
ObjectFile=".\memtestrelease/"
ProgramDataBaseFileName=".\memtestrelease/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
OutputFile="memtestrelease/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\memtestrelease/amxx_mm.pdb"
ImportLibrary=".\memtestrelease/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="JITDebug|Win32"
OutputDirectory="JITDebug"
IntermediateDirectory="JITDebug"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\pm_shared&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\dlls&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\engine&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\common&quot;;C:\Files\Programming\metamod\metamod"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT"
BasicRuntimeChecks="3"
RuntimeLibrary="5"
StructMemberAlignment="3"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\jitdebug/amxmodx.pch"
AssemblerListingLocation=".\jitdebug/"
ObjectFile=".\jitdebug/"
ProgramDataBaseFileName=".\jitdebug/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="..\jit\jits.obj ..\zlib\zlib.lib"
OutputFile="jitdebug/amxmodx_mm.dll"
Version="0.1"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\jitdebug/amxx_mm.pdb"
ImportLibrary=".\jitdebug/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="_DEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\debug/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="JITRelease|Win32"
OutputDirectory="JITRelease"
IntermediateDirectory="JITRelease"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\jitrelease/amxmodx.pch"
AssemblerListingLocation=".\jitrelease/"
ObjectFile=".\jitrelease/"
ProgramDataBaseFileName=".\jitrelease/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="..\jit\jits.obj ..\zlib\zlib.lib"
OutputFile="jitrelease/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\jitrelease/amxx_mm.pdb"
ImportLibrary=".\jitrelease/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="JITMemtestRelease|Win32"
OutputDirectory="JITMemtestRelease"
IntermediateDirectory="JITMemtestRelease"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;MEMORY_TEST;JIT"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\jitmemtestrelease/amxmodx.pch"
AssemblerListingLocation=".\jitmemtestrelease/"
ObjectFile=".\jitmemtestrelease/"
ProgramDataBaseFileName=".\jitmemtestrelease/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\jit\jits.lib ..\zlib\zlib.lib"
OutputFile="jitmemtestrelease/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\jitmemtestrelease/amxx_mm.pdb"
ImportLibrary=".\jitmemtestrelease/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
<Configuration
Name="MaximalSpeed|Win32"
OutputDirectory="MaximalSpeed"
IntermediateDirectory="MaximalSpeed"
ConfigurationType="2"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
GlobalOptimizations="TRUE"
InlineFunctionExpansion="1"
EnableIntrinsicFunctions="TRUE"
FavorSizeOrSpeed="1"
OptimizeForProcessor="2"
OptimizeForWindowsApplication="TRUE"
AdditionalIncludeDirectories="..\..\metamod\metamod,..\..\hlsdk\sourcecode\common,..\..\hlsdk\sourcecode\engine,..\..\hlsdk\sourcecode\dlls,..\..\hlsdk\sourcecode\pm_shared,..\extra\include"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT"
StringPooling="TRUE"
RuntimeLibrary="4"
EnableFunctionLevelLinking="TRUE"
UsePrecompiledHeader="2"
PrecompiledHeaderThrough="amxmodx.h"
PrecompiledHeaderFile=".\MaximalSpeed/amxmodx.pch"
AssemblerListingLocation=".\MaximalSpeed/"
ObjectFile=".\MaximalSpeed/"
ProgramDataBaseFileName=".\MaximalSpeed/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="odbc32.lib odbccp32.lib ..\jit\jits.lib ..\zlib\zlib.lib"
OutputFile="MaximalSpeed/amxmodx_mm.dll"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\extra\lib_win32"
ModuleDefinitionFile=""
ProgramDatabaseFile=".\MaximalSpeede/amxx_mm.pdb"
ImportLibrary=".\jitrelease/amxx_mm.lib"/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="NDEBUG"
MkTypLibCompatible="TRUE"
SuppressStartupBanner="TRUE"
TargetEnvironment="1"
TypeLibraryName=".\release/amxmodx.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCXMLDataGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
<Tool
Name="VCManagedWrapperGeneratorTool"/>
<Tool
Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
<File
RelativePath="..\amx.cpp">
</File>
<File
RelativePath="..\amxcore.cpp">
</File>
<File
RelativePath="..\amxmodx.cpp">
</File>
<File
RelativePath="..\amxtime.cpp">
</File>
<File
RelativePath="..\amxxfile.cpp">
</File>
<File
RelativePath="..\amxxlog.cpp">
</File>
<File
RelativePath="..\CCmd.cpp">
</File>
<File
RelativePath="..\CEvent.cpp">
</File>
<File
RelativePath="..\CFile.cpp">
</File>
<File
RelativePath="..\CForward.cpp">
</File>
<File
RelativePath="..\CLang.cpp">
</File>
<File
RelativePath="..\CLogEvent.cpp">
</File>
<File
RelativePath="..\CMenu.cpp">
</File>
<File
RelativePath="..\CMisc.cpp">
</File>
<File
RelativePath="..\CModule.cpp">
</File>
<File
RelativePath="..\CPlugin.cpp">
</File>
<File
RelativePath="..\CTask.cpp">
</File>
<File
RelativePath="..\CVault.cpp">
</File>
<File
RelativePath="..\emsg.cpp">
</File>
<File
RelativePath="..\fakemeta.cpp">
<FileConfiguration
Name="MemtestDebug|Win32">
<Tool
Name="VCCLCompilerTool"
GeneratePreprocessedFile="0"/>
</FileConfiguration>
</File>
<File
RelativePath="..\file.cpp">
</File>
<File
RelativePath="..\float.cpp">
</File>
<File
RelativePath="..\md5.cpp">
</File>
<File
RelativePath="..\meta_api.cpp">
</File>
<File
RelativePath="..\modules.cpp">
</File>
<File
RelativePath="..\power.cpp">
</File>
<File
RelativePath="..\srvcmd.cpp">
</File>
<File
RelativePath="..\string.cpp">
</File>
<File
RelativePath="..\strptime.cpp">
</File>
<File
RelativePath="..\util.cpp">
</File>
<File
RelativePath="..\vault.cpp">
</File>
<Filter
Name="mmgr"
Filter="">
<File
RelativePath="..\mmgr\mmgr.cpp">
<FileConfiguration
Name="Debug|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
<FileConfiguration
Name="JITDebug|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
<FileConfiguration
Name="JITRelease|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
<FileConfiguration
Name="MaximalSpeed|Win32"
ExcludedFromBuild="TRUE">
<Tool
Name="VCCLCompilerTool"/>
</FileConfiguration>
</File>
</Filter>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl">
<File
RelativePath="..\amx.h">
</File>
<File
RelativePath="..\amxmodx.h">
</File>
<File
RelativePath="..\amxxfile.h">
</File>
<File
RelativePath="..\amxxlog.h">
</File>
<File
RelativePath="..\CCmd.h">
</File>
<File
RelativePath="..\CEvent.h">
</File>
<File
RelativePath="..\CFile.h">
</File>
<File
RelativePath="..\CForward.h">
</File>
<File
RelativePath="..\CLang.h">
</File>
<File
RelativePath="..\CList.h">
</File>
<File
RelativePath="..\CLogEvent.h">
</File>
<File
RelativePath="..\CMenu.h">
</File>
<File
RelativePath="..\CMisc.h">
</File>
<File
RelativePath="..\CModule.h">
</File>
<File
RelativePath="..\CPlugin.h">
</File>
<File
RelativePath="..\CQueue.h">
</File>
<File
RelativePath="..\CRList.h">
</File>
<File
RelativePath="..\CString.h">
</File>
<File
RelativePath="..\CTask.h">
</File>
<File
RelativePath="..\CVault.h">
</File>
<File
RelativePath="..\CVector.h">
</File>
<File
RelativePath="..\fakemeta.h">
</File>
<File
RelativePath="..\md5.h">
</File>
<File
RelativePath="..\modules.h">
</File>
<Filter
Name="mmgr"
Filter="">
<File
RelativePath="..\mmgr\mmgr.h">
</File>
<File
RelativePath="..\mmgr\nommgr.h">
</File>
</Filter>
</Filter>
<Filter
Name="Resource Files"
Filter="rc">
<File
RelativePath="..\version.rc">
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

View File

@ -5,12 +5,6 @@
* Copyright (c) ITB CompuPhase, 1998, 1999 * Copyright (c) ITB CompuPhase, 1998, 1999
* This file may be freely used. No warranties of any kind. * This file may be freely used. No warranties of any kind.
*/ */
// this file does not include amxmodx.h, so we have to include the memory manager here
#ifdef MEMORY_TEST
#include "mmgr/mmgr.h"
#endif // MEMORY_TEST
#include "amx.h" #include "amx.h"
static cell power(AMX *amx, cell *params) static cell power(AMX *amx, cell *params)

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,34 +0,0 @@
**** HOWTO MAKE A MODULE ****
* STEP 1
Download the AMXX Sdk, and place all files into your module source dir.
Don't edit amxxmodule.h or amxxmodule.cpp
Go through the moduleconfig.h file and do what it says
If you want to have natives in your module, uncomment line 30
( // #define FN_AMXX_ATTACH OnAmxxAttach )
If you want to have forwards in your module, uncomment line 35
( // #define FN_AMXX_PLUGINSLOADED OnPluginsLoaded )
If you want your module to use metamod, uncomment line 22
( // #define USE_METAMOD ) and set up metamod hooks (starting an line 54)
You only have to uncomment the line (you may change the function name if you want to).
* STEP 2
Add an another source file.
At the beginning, add the short GPL and
#include "amxxmodule.h"
If you have uncommented any hooks in moduleconfig.h (metamod hooks or Metamod init functions or amxx init functions),
define the functions here (or you will get unresolved externals).
If you want native functions, add a call to MF_AddNatives into the OnAmxxAttach function.
If you want forward functions add (a) call(s) to MF_RegisterForward into the OnPluginsLoaded function.
* NOTES
Include files order in your cpp file(s):
standard files
amxxmodule.h
your files
Example:
#include <stdlib.h>
#include <string>
#include <stdio.h>
#include "amxxmodule.h"
#include "mymoduleutils.h"

View File

@ -1,462 +0,0 @@
// Configuration
#ifndef __MODULECONFIG_H__
#define __MODULECONFIG_H__
// Module info
#define MODULE_NAME "--ENTER NAME HERE--"
#define MODULE_VERSION "--ENTER VERSION HERE--"
#define MODULE_AUTHOR "--ENTER AUTHOR HERE--"
#define MODULE_URL "--ENTER URL HERE--"
#define MODULE_LOGTAG "--ENTER LOGTAG HERE--"
// If you want the module not to be reloaded on mapchange, remove / comment out the next line
#define MODULE_RELOAD_ON_MAPCHANGE
#ifdef __DATE__
#define MODULE_DATE __DATE__
#else // __DATE__
#define MODULE_DATE "Unknown"
#endif // __DATE__
// metamod plugin?
// #define USE_METAMOD
// - AMXX Init functions
// Also consider using FN_META_*
// AMXX query
//#define FN_AMXX_QUERY OnAmxxQuery
// AMXX attach
// Do native functions init here (MF_AddNatives)
// #define FN_AMXX_ATTACH OnAmxxAttach
// AMXX detach
//#define FN_AMXX_DETACH OnAmxxDetach
// All plugins loaded
// Do forward functions init here (MF_RegisterForward)
// #define FN_AMXX_PLUGINSLOADED OnPluginsLoaded
/**** METAMOD ****/
// If your module doesn't use metamod, you may close the file now :)
#ifdef USE_METAMOD
// ----
// Hook Functions
// Uncomment these to be called
// You can also change the function name
// - Metamod init functions
// Also consider using FN_AMXX_*
// Meta query
//#define FN_META_QUERY OnMetaQuery
// Meta attach
//#define FN_META_ATTACH OnMetaAttach
// Meta detach
//#define FN_META_DETACH OnMetaDetach
// (wd) are Will Day's notes
// - GetEntityAPI2 functions
// #define FN_GameDLLInit GameDLLInit /* pfnGameInit() */
// #define FN_DispatchSpawn DispatchSpawn /* pfnSpawn() */
// #define FN_DispatchThink DispatchThink /* pfnThink() */
// #define FN_DispatchUse DispatchUse /* pfnUse() */
// #define FN_DispatchTouch DispatchTouch /* pfnTouch() */
// #define FN_DispatchBlocked DispatchBlocked /* pfnBlocked() */
// #define FN_DispatchKeyValue DispatchKeyValue /* pfnKeyValue() */
// #define FN_DispatchSave DispatchSave /* pfnSave() */
// #define FN_DispatchRestore DispatchRestore /* pfnRestore() */
// #define FN_DispatchObjectCollsionBox DispatchObjectCollsionBox /* pfnSetAbsBox() */
// #define FN_SaveWriteFields SaveWriteFields /* pfnSaveWriteFields() */
// #define FN_SaveReadFields SaveReadFields /* pfnSaveReadFields() */
// #define FN_SaveGlobalState SaveGlobalState /* pfnSaveGlobalState() */
// #define FN_RestoreGlobalState RestoreGlobalState /* pfnRestoreGlobalState() */
// #define FN_ResetGlobalState ResetGlobalState /* pfnResetGlobalState() */
// #define FN_ClientConnect ClientConnect /* pfnClientConnect() (wd) Client has connected */
// #define FN_ClientDisconnect ClientDisconnect /* pfnClientDisconnect() (wd) Player has left the game */
// #define FN_ClientKill ClientKill /* pfnClientKill() (wd) Player has typed "kill" */
// #define FN_ClientPutInServer ClientPutInServer /* pfnClientPutInServer() (wd) Client is entering the game */
// #define FN_ClientCommand ClientCommand /* pfnClientCommand() (wd) Player has sent a command (typed or from a bind) */
// #define FN_ClientUserInfoChanged ClientUserInfoChanged /* pfnClientUserInfoChanged() (wd) Client has updated their setinfo structure */
// #define FN_ServerActivate ServerActivate /* pfnServerActivate() (wd) Server is starting a new map */
// #define FN_ServerDeactivate ServerDeactivate /* pfnServerDeactivate() (wd) Server is leaving the map (shutdown or changelevel); SDK2 */
// #define FN_PlayerPreThink PlayerPreThink /* pfnPlayerPreThink() */
// #define FN_PlayerPostThink PlayerPostThink /* pfnPlayerPostThink() */
// #define FN_StartFrame StartFrame /* pfnStartFrame() */
// #define FN_ParmsNewLevel ParmsNewLevel /* pfnParmsNewLevel() */
// #define FN_ParmsChangeLevel ParmsChangeLevel /* pfnParmsChangeLevel() */
// #define FN_GetGameDescription GetGameDescription /* pfnGetGameDescription() Returns string describing current .dll. E.g. "TeamFotrress 2" "Half-Life" */
// #define FN_PlayerCustomization PlayerCustomization /* pfnPlayerCustomization() Notifies .dll of new customization for player. */
// #define FN_SpectatorConnect SpectatorConnect /* pfnSpectatorConnect() Called when spectator joins server */
// #define FN_SpectatorDisconnect SpectatorDisconnect /* pfnSpectatorDisconnect() Called when spectator leaves the server */
// #define FN_SpectatorThink SpectatorThink /* pfnSpectatorThink() Called when spectator sends a command packet (usercmd_t) */
// #define FN_Sys_Error Sys_Error /* pfnSys_Error() Notify game .dll that engine is going to shut down. Allows mod authors to set a breakpoint. SDK2 */
// #define FN_PM_Move PM_Move /* pfnPM_Move() (wd) SDK2 */
// #define FN_PM_Init PM_Init /* pfnPM_Init() Server version of player movement initialization; (wd) SDK2 */
// #define FN_PM_FindTextureType PM_FindTextureType /* pfnPM_FindTextureType() (wd) SDK2 */
// #define FN_SetupVisibility SetupVisibility /* pfnSetupVisibility() Set up PVS and PAS for networking for this client; (wd) SDK2 */
// #define FN_UpdateClientData UpdateClientData /* pfnUpdateClientData() Set up data sent only to specific client; (wd) SDK2 */
// #define FN_AddToFullPack AddToFullPack /* pfnAddToFullPack() (wd) SDK2 */
// #define FN_CreateBaseline CreateBaseline /* pfnCreateBaseline() Tweak entity baseline for network encoding allows setup of player baselines too.; (wd) SDK2 */
// #define FN_RegisterEncoders RegisterEncoders /* pfnRegisterEncoders() Callbacks for network encoding; (wd) SDK2 */
// #define FN_GetWeaponData GetWeaponData /* pfnGetWeaponData() (wd) SDK2 */
// #define FN_CmdStart CmdStart /* pfnCmdStart() (wd) SDK2 */
// #define FN_CmdEnd CmdEnd /* pfnCmdEnd() (wd) SDK2 */
// #define FN_ConnectionlessPacket ConnectionlessPacket /* pfnConnectionlessPacket() (wd) SDK2 */
// #define FN_GetHullBounds GetHullBounds /* pfnGetHullBounds() (wd) SDK2 */
// #define FN_CreateInstancedBaselines CreateInstancedBaselines /* pfnCreateInstancedBaselines() (wd) SDK2 */
// #define FN_InconsistentFile InconsistentFile /* pfnInconsistentFile() (wd) SDK2 */
// #define FN_AllowLagCompensation AllowLagCompensation /* pfnAllowLagCompensation() (wd) SDK2 */
// - GetEntityAPI2_Post functions
// #define FN_GameDLLInit_Post GameDLLInit_Post
// #define FN_DispatchSpawn_Post DispatchSpawn_Post
// #define FN_DispatchThink_Post DispatchThink_Post
// #define FN_DispatchUse_Post DispatchUse_Post
// #define FN_DispatchTouch_Post DispatchTouch_Post
// #define FN_DispatchBlocked_Post DispatchBlocked_Post
// #define FN_DispatchKeyValue_Post DispatchKeyValue_Post
// #define FN_DispatchSave_Post DispatchSave_Post
// #define FN_DispatchRestore_Post DispatchRestore_Post
// #define FN_DispatchObjectCollsionBox_Post DispatchObjectCollsionBox_Post
// #define FN_SaveWriteFields_Post SaveWriteFields_Post
// #define FN_SaveReadFields_Post SaveReadFields_Post
// #define FN_SaveGlobalState_Post SaveGlobalState_Post
// #define FN_RestoreGlobalState_Post RestoreGlobalState_Post
// #define FN_ResetGlobalState_Post ResetGlobalState_Post
// #define FN_ClientConnect_Post ClientConnect_Post
// #define FN_ClientDisconnect_Post ClientDisconnect_Post
// #define FN_ClientKill_Post ClientKill_Post
// #define FN_ClientPutInServer_Post ClientPutInServer_Post
// #define FN_ClientCommand_Post ClientCommand_Post
// #define FN_ClientUserInfoChanged_Post ClientUserInfoChanged_Post
// #define FN_ServerActivate_Post ServerActivate_Post
// #define FN_ServerDeactivate_Post ServerDeactivate_Post
// #define FN_PlayerPreThink_Post PlayerPreThink_Post
// #define FN_PlayerPostThink_Post PlayerPostThink_Post
// #define FN_StartFrame_Post StartFrame_Post
// #define FN_ParmsNewLevel_Post ParmsNewLevel_Post
// #define FN_ParmsChangeLevel_Post ParmsChangeLevel_Post
// #define FN_GetGameDescription_Post GetGameDescription_Post
// #define FN_PlayerCustomization_Post PlayerCustomization_Post
// #define FN_SpectatorConnect_Post SpectatorConnect_Post
// #define FN_SpectatorDisconnect_Post SpectatorDisconnect_Post
// #define FN_SpectatorThink_Post SpectatorThink_Post
// #define FN_Sys_Error_Post Sys_Error_Post
// #define FN_PM_Move_Post PM_Move_Post
// #define FN_PM_Init_Post PM_Init_Post
// #define FN_PM_FindTextureType_Post PM_FindTextureType_Post
// #define FN_SetupVisibility_Post SetupVisibility_Post
// #define FN_UpdateClientData_Post UpdateClientData_Post
// #define FN_AddToFullPack_Post AddToFullPack_Post
// #define FN_CreateBaseline_Post CreateBaseline_Post
// #define FN_RegisterEncoders_Post RegisterEncoders_Post
// #define FN_GetWeaponData_Post GetWeaponData_Post
// #define FN_CmdStart_Post CmdStart_Post
// #define FN_CmdEnd_Post CmdEnd_Post
// #define FN_ConnectionlessPacket_Post ConnectionlessPacket_Post
// #define FN_GetHullBounds_Post GetHullBounds_Post
// #define FN_CreateInstancedBaselines_Post CreateInstancedBaselines_Post
// #define FN_InconsistentFile_Post InconsistentFile_Post
// #define FN_AllowLagCompensation_Post AllowLagCompensation_Post
// - GetEngineAPI functions
// #define FN_PrecacheModel PrecacheModel
// #define FN_PrecacheSound PrecacheSound
// #define FN_SetModel SetModel
// #define FN_ModelIndex ModelIndex
// #define FN_ModelFrames ModelFrames
// #define FN_SetSize SetSize
// #define FN_ChangeLevel ChangeLevel
// #define FN_GetSpawnParms GetSpawnParms
// #define FN_SaveSpawnParms SaveSpawnParms
// #define FN_VecToYaw VecToYaw
// #define FN_VecToAngles VecToAngles
// #define FN_MoveToOrigin MoveToOrigin
// #define FN_ChangeYaw ChangeYaw
// #define FN_ChangePitch ChangePitch
// #define FN_FindEntityByString FindEntityByString
// #define FN_GetEntityIllum GetEntityIllum
// #define FN_FindEntityInSphere FindEntityInSphere
// #define FN_FindClientInPVS FindClientInPVS
// #define FN_EntitiesInPVS EntitiesInPVS
// #define FN_MakeVectors MakeVectors
// #define FN_AngleVectors AngleVectors
// #define FN_CreateEntity CreateEntity
// #define FN_RemoveEntity RemoveEntity
// #define FN_CreateNamedEntity CreateNamedEntity
// #define FN_MakeStatic MakeStatic
// #define FN_EntIsOnFloor EntIsOnFloor
// #define FN_DropToFloor DropToFloor
// #define FN_WalkMove WalkMove
// #define FN_SetOrigin SetOrigin
// #define FN_EmitSound EmitSound
// #define FN_EmitAmbientSound EmitAmbientSound
// #define FN_TraceLine TraceLine
// #define FN_TraceToss TraceToss
// #define FN_TraceMonsterHull TraceMonsterHull
// #define FN_TraceHull TraceHull
// #define FN_TraceModel TraceModel
// #define FN_TraceTexture TraceTexture
// #define FN_TraceSphere TraceSphere
// #define FN_GetAimVector GetAimVector
// #define FN_ServerCommand ServerCommand
// #define FN_ServerExecute ServerExecute
// #define FN_engClientCommand engClientCommand
// #define FN_ParticleEffect ParticleEffect
// #define FN_LightStyle LightStyle
// #define FN_DecalIndex DecalIndex
// #define FN_PointContents PointContents
// #define FN_MessageBegin MessageBegin
// #define FN_MessageEnd MessageEnd
// #define FN_WriteByte WriteByte
// #define FN_WriteChar WriteChar
// #define FN_WriteShort WriteShort
// #define FN_WriteLong WriteLong
// #define FN_WriteAngle WriteAngle
// #define FN_WriteCoord WriteCoord
// #define FN_WriteString WriteString
// #define FN_WriteEntity WriteEntity
// #define FN_CVarRegister CVarRegister
// #define FN_CVarGetFloat CVarGetFloat
// #define FN_CVarGetString CVarGetString
// #define FN_CVarSetFloat CVarSetFloat
// #define FN_CVarSetString CVarSetString
// #define FN_AlertMessage AlertMessage
// #define FN_EngineFprintf EngineFprintf
// #define FN_PvAllocEntPrivateData PvAllocEntPrivateData
// #define FN_PvEntPrivateData PvEntPrivateData
// #define FN_FreeEntPrivateData FreeEntPrivateData
// #define FN_SzFromIndex SzFromIndex
// #define FN_AllocString AllocString
// #define FN_GetVarsOfEnt GetVarsOfEnt
// #define FN_PEntityOfEntOffset PEntityOfEntOffset
// #define FN_EntOffsetOfPEntity EntOffsetOfPEntity
// #define FN_IndexOfEdict IndexOfEdict
// #define FN_PEntityOfEntIndex PEntityOfEntIndex
// #define FN_FindEntityByVars FindEntityByVars
// #define FN_GetModelPtr GetModelPtr
// #define FN_RegUserMsg RegUserMsg
// #define FN_AnimationAutomove AnimationAutomove
// #define FN_GetBonePosition GetBonePosition
// #define FN_FunctionFromName FunctionFromName
// #define FN_NameForFunction NameForFunction
// #define FN_ClientPrintf ClientPrintf
// #define FN_ServerPrint ServerPrint
// #define FN_Cmd_Args Cmd_Args
// #define FN_Cmd_Argv Cmd_Argv
// #define FN_Cmd_Argc Cmd_Argc
// #define FN_GetAttachment GetAttachment
// #define FN_CRC32_Init CRC32_Init
// #define FN_CRC32_ProcessBuffer CRC32_ProcessBuffer
// #define FN_CRC32_ProcessByte CRC32_ProcessByte
// #define FN_CRC32_Final CRC32_Final
// #define FN_RandomLong RandomLong
// #define FN_RandomFloat RandomFloat
// #define FN_SetView SetView
// #define FN_Time Time
// #define FN_CrosshairAngle CrosshairAngle
// #define FN_LoadFileForMe LoadFileForMe
// #define FN_FreeFile FreeFile
// #define FN_EndSection EndSection
// #define FN_CompareFileTime CompareFileTime
// #define FN_GetGameDir GetGameDir
// #define FN_Cvar_RegisterVariable Cvar_RegisterVariable
// #define FN_FadeClientVolume FadeClientVolume
// #define FN_SetClientMaxspeed SetClientMaxspeed
// #define FN_CreateFakeClient CreateFakeClient
// #define FN_RunPlayerMove RunPlayerMove
// #define FN_NumberOfEntities NumberOfEntities
// #define FN_GetInfoKeyBuffer GetInfoKeyBuffer
// #define FN_InfoKeyValue InfoKeyValue
// #define FN_SetKeyValue SetKeyValue
// #define FN_SetClientKeyValue SetClientKeyValue
// #define FN_IsMapValid IsMapValid
// #define FN_StaticDecal StaticDecal
// #define FN_PrecacheGeneric PrecacheGeneric
// #define FN_GetPlayerUserId GetPlayerUserId
// #define FN_BuildSoundMsg BuildSoundMsg
// #define FN_IsDedicatedServer IsDedicatedServer
// #define FN_CVarGetPointer CVarGetPointer
// #define FN_GetPlayerWONId GetPlayerWONId
// #define FN_Info_RemoveKey Info_RemoveKey
// #define FN_GetPhysicsKeyValue GetPhysicsKeyValue
// #define FN_SetPhysicsKeyValue SetPhysicsKeyValue
// #define FN_GetPhysicsInfoString GetPhysicsInfoString
// #define FN_PrecacheEvent PrecacheEvent
// #define FN_PlaybackEvent PlaybackEvent
// #define FN_SetFatPVS SetFatPVS
// #define FN_SetFatPAS SetFatPAS
// #define FN_CheckVisibility CheckVisibility
// #define FN_DeltaSetField DeltaSetField
// #define FN_DeltaUnsetField DeltaUnsetField
// #define FN_DeltaAddEncoder DeltaAddEncoder
// #define FN_GetCurrentPlayer GetCurrentPlayer
// #define FN_CanSkipPlayer CanSkipPlayer
// #define FN_DeltaFindField DeltaFindField
// #define FN_DeltaSetFieldByIndex DeltaSetFieldByIndex
// #define FN_DeltaUnsetFieldByIndex DeltaUnsetFieldByIndex
// #define FN_SetGroupMask SetGroupMask
// #define FN_engCreateInstancedBaseline engCreateInstancedBaseline
// #define FN_Cvar_DirectSet Cvar_DirectSet
// #define FN_ForceUnmodified ForceUnmodified
// #define FN_GetPlayerStats GetPlayerStats
// #define FN_AddServerCommand AddServerCommand
// #define FN_Voice_GetClientListening Voice_GetClientListening
// #define FN_Voice_SetClientListening Voice_SetClientListening
// #define FN_GetPlayerAuthId GetPlayerAuthId
// - GetEngineAPI_Post functions
// #define FN_PrecacheModel_Post PrecacheModel_Post
// #define FN_PrecacheSound_Post PrecacheSound_Post
// #define FN_SetModel_Post SetModel_Post
// #define FN_ModelIndex_Post ModelIndex_Post
// #define FN_ModelFrames_Post ModelFrames_Post
// #define FN_SetSize_Post SetSize_Post
// #define FN_ChangeLevel_Post ChangeLevel_Post
// #define FN_GetSpawnParms_Post GetSpawnParms_Post
// #define FN_SaveSpawnParms_Post SaveSpawnParms_Post
// #define FN_VecToYaw_Post VecToYaw_Post
// #define FN_VecToAngles_Post VecToAngles_Post
// #define FN_MoveToOrigin_Post MoveToOrigin_Post
// #define FN_ChangeYaw_Post ChangeYaw_Post
// #define FN_ChangePitch_Post ChangePitch_Post
// #define FN_FindEntityByString_Post FindEntityByString_Post
// #define FN_GetEntityIllum_Post GetEntityIllum_Post
// #define FN_FindEntityInSphere_Post FindEntityInSphere_Post
// #define FN_FindClientInPVS_Post FindClientInPVS_Post
// #define FN_EntitiesInPVS_Post EntitiesInPVS_Post
// #define FN_MakeVectors_Post MakeVectors_Post
// #define FN_AngleVectors_Post AngleVectors_Post
// #define FN_CreateEntity_Post CreateEntity_Post
// #define FN_RemoveEntity_Post RemoveEntity_Post
// #define FN_CreateNamedEntity_Post CreateNamedEntity_Post
// #define FN_MakeStatic_Post MakeStatic_Post
// #define FN_EntIsOnFloor_Post EntIsOnFloor_Post
// #define FN_DropToFloor_Post DropToFloor_Post
// #define FN_WalkMove_Post WalkMove_Post
// #define FN_SetOrigin_Post SetOrigin_Post
// #define FN_EmitSound_Post EmitSound_Post
// #define FN_EmitAmbientSound_Post EmitAmbientSound_Post
// #define FN_TraceLine_Post TraceLine_Post
// #define FN_TraceToss_Post TraceToss_Post
// #define FN_TraceMonsterHull_Post TraceMonsterHull_Post
// #define FN_TraceHull_Post TraceHull_Post
// #define FN_TraceModel_Post TraceModel_Post
// #define FN_TraceTexture_Post TraceTexture_Post
// #define FN_TraceSphere_Post TraceSphere_Post
// #define FN_GetAimVector_Post GetAimVector_Post
// #define FN_ServerCommand_Post ServerCommand_Post
// #define FN_ServerExecute_Post ServerExecute_Post
// #define FN_engClientCommand_Post engClientCommand_Post
// #define FN_ParticleEffect_Post ParticleEffect_Post
// #define FN_LightStyle_Post LightStyle_Post
// #define FN_DecalIndex_Post DecalIndex_Post
// #define FN_PointContents_Post PointContents_Post
// #define FN_MessageBegin_Post MessageBegin_Post
// #define FN_MessageEnd_Post MessageEnd_Post
// #define FN_WriteByte_Post WriteByte_Post
// #define FN_WriteChar_Post WriteChar_Post
// #define FN_WriteShort_Post WriteShort_Post
// #define FN_WriteLong_Post WriteLong_Post
// #define FN_WriteAngle_Post WriteAngle_Post
// #define FN_WriteCoord_Post WriteCoord_Post
// #define FN_WriteString_Post WriteString_Post
// #define FN_WriteEntity_Post WriteEntity_Post
// #define FN_CVarRegister_Post CVarRegister_Post
// #define FN_CVarGetFloat_Post CVarGetFloat_Post
// #define FN_CVarGetString_Post CVarGetString_Post
// #define FN_CVarSetFloat_Post CVarSetFloat_Post
// #define FN_CVarSetString_Post CVarSetString_Post
// #define FN_AlertMessage_Post AlertMessage_Post
// #define FN_EngineFprintf_Post EngineFprintf_Post
// #define FN_PvAllocEntPrivateData_Post PvAllocEntPrivateData_Post
// #define FN_PvEntPrivateData_Post PvEntPrivateData_Post
// #define FN_FreeEntPrivateData_Post FreeEntPrivateData_Post
// #define FN_SzFromIndex_Post SzFromIndex_Post
// #define FN_AllocString_Post AllocString_Post
// #define FN_GetVarsOfEnt_Post GetVarsOfEnt_Post
// #define FN_PEntityOfEntOffset_Post PEntityOfEntOffset_Post
// #define FN_EntOffsetOfPEntity_Post EntOffsetOfPEntity_Post
// #define FN_IndexOfEdict_Post IndexOfEdict_Post
// #define FN_PEntityOfEntIndex_Post PEntityOfEntIndex_Post
// #define FN_FindEntityByVars_Post FindEntityByVars_Post
// #define FN_GetModelPtr_Post GetModelPtr_Post
// #define FN_RegUserMsg_Post RegUserMsg_Post
// #define FN_AnimationAutomove_Post AnimationAutomove_Post
// #define FN_GetBonePosition_Post GetBonePosition_Post
// #define FN_FunctionFromName_Post FunctionFromName_Post
// #define FN_NameForFunction_Post NameForFunction_Post
// #define FN_ClientPrintf_Post ClientPrintf_Post
// #define FN_ServerPrint_Post ServerPrint_Post
// #define FN_Cmd_Args_Post Cmd_Args_Post
// #define FN_Cmd_Argv_Post Cmd_Argv_Post
// #define FN_Cmd_Argc_Post Cmd_Argc_Post
// #define FN_GetAttachment_Post GetAttachment_Post
// #define FN_CRC32_Init_Post CRC32_Init_Post
// #define FN_CRC32_ProcessBuffer_Post CRC32_ProcessBuffer_Post
// #define FN_CRC32_ProcessByte_Post CRC32_ProcessByte_Post
// #define FN_CRC32_Final_Post CRC32_Final_Post
// #define FN_RandomLong_Post RandomLong_Post
// #define FN_RandomFloat_Post RandomFloat_Post
// #define FN_SetView_Post SetView_Post
// #define FN_Time_Post Time_Post
// #define FN_CrosshairAngle_Post CrosshairAngle_Post
// #define FN_LoadFileForMe_Post LoadFileForMe_Post
// #define FN_FreeFile_Post FreeFile_Post
// #define FN_EndSection_Post EndSection_Post
// #define FN_CompareFileTime_Post CompareFileTime_Post
// #define FN_GetGameDir_Post GetGameDir_Post
// #define FN_Cvar_RegisterVariable_Post Cvar_RegisterVariable_Post
// #define FN_FadeClientVolume_Post FadeClientVolume_Post
// #define FN_SetClientMaxspeed_Post SetClientMaxspeed_Post
// #define FN_CreateFakeClient_Post CreateFakeClient_Post
// #define FN_RunPlayerMove_Post RunPlayerMove_Post
// #define FN_NumberOfEntities_Post NumberOfEntities_Post
// #define FN_GetInfoKeyBuffer_Post GetInfoKeyBuffer_Post
// #define FN_InfoKeyValue_Post InfoKeyValue_Post
// #define FN_SetKeyValue_Post SetKeyValue_Post
// #define FN_SetClientKeyValue_Post SetClientKeyValue_Post
// #define FN_IsMapValid_Post IsMapValid_Post
// #define FN_StaticDecal_Post StaticDecal_Post
// #define FN_PrecacheGeneric_Post PrecacheGeneric_Post
// #define FN_GetPlayerUserId_Post GetPlayerUserId_Post
// #define FN_BuildSoundMsg_Post BuildSoundMsg_Post
// #define FN_IsDedicatedServer_Post IsDedicatedServer_Post
// #define FN_CVarGetPointer_Post CVarGetPointer_Post
// #define FN_GetPlayerWONId_Post GetPlayerWONId_Post
// #define FN_Info_RemoveKey_Post Info_RemoveKey_Post
// #define FN_GetPhysicsKeyValue_Post GetPhysicsKeyValue_Post
// #define FN_SetPhysicsKeyValue_Post SetPhysicsKeyValue_Post
// #define FN_GetPhysicsInfoString_Post GetPhysicsInfoString_Post
// #define FN_PrecacheEvent_Post PrecacheEvent_Post
// #define FN_PlaybackEvent_Post PlaybackEvent_Post
// #define FN_SetFatPVS_Post SetFatPVS_Post
// #define FN_SetFatPAS_Post SetFatPAS_Post
// #define FN_CheckVisibility_Post CheckVisibility_Post
// #define FN_DeltaSetField_Post DeltaSetField_Post
// #define FN_DeltaUnsetField_Post DeltaUnsetField_Post
// #define FN_DeltaAddEncoder_Post DeltaAddEncoder_Post
// #define FN_GetCurrentPlayer_Post GetCurrentPlayer_Post
// #define FN_CanSkipPlayer_Post CanSkipPlayer_Post
// #define FN_DeltaFindField_Post DeltaFindField_Post
// #define FN_DeltaSetFieldByIndex_Post DeltaSetFieldByIndex_Post
// #define FN_DeltaUnsetFieldByIndex_Post DeltaUnsetFieldByIndex_Post
// #define FN_SetGroupMask_Post SetGroupMask_Post
// #define FN_engCreateInstancedBaseline_Post engCreateInstancedBaseline_Post
// #define FN_Cvar_DirectSet_Post Cvar_DirectSet_Post
// #define FN_ForceUnmodified_Post ForceUnmodified_Post
// #define FN_GetPlayerStats_Post GetPlayerStats_Post
// #define FN_AddServerCommand_Post AddServerCommand_Post
// #define FN_Voice_GetClientListening_Post Voice_GetClientListening_Post
// #define FN_Voice_SetClientListening_Post Voice_SetClientListening_Post
// #define FN_GetPlayerAuthId_Post GetPlayerAuthId_Post
// #define FN_OnFreeEntPrivateData OnFreeEntPrivateData
// #define FN_GameShutdown GameShutdown
// #define FN_ShouldCollide ShouldCollide
// #define FN_OnFreeEntPrivateData_Post OnFreeEntPrivateData_Post
// #define FN_GameShutdown_Post GameShutdown_Post
// #define FN_ShouldCollide_Post ShouldCollide_Post
#endif // USE_METAMOD
#endif // __MODULECONFIG_H__

View File

@ -29,274 +29,200 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "amxmod.h"
void amx_command(){ void amx_command(){
const char* cmd = CMD_ARGV(1);
if (!strcmp(cmd,"plugins") || !strcmp(cmd,"list"))
{
print_srvconsole( "Currently loaded plugins:\n");
print_srvconsole( " %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n",
"name","version","author","file","status");
int plugins = 0;
int running = 0;
CPluginMngr::iterator a = g_plugins.begin();
const char* cmd = CMD_ARGV(1); while (a)
{
++plugins;
if ( (*a).isValid() && !(*a).isPaused() )
++running;
print_srvconsole( " [%3d] %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n",
plugins,(*a).getTitle(),(*a).getVersion(),
(*a).getAuthor(), (*a).getName(), (*a).getStatus() );
++a;
}
print_srvconsole( "%d plugins, %d running\n",plugins,running );
}
else if (!strcmp(cmd,"pause") && CMD_ARGC() > 2)
{
const char* sPlugin = CMD_ARGV(2);
CPluginMngr::CPlugin *plugin = g_plugins.findPlugin(sPlugin);
if ( plugin && plugin->isValid() )
{
plugin->pausePlugin();
print_srvconsole("Paused plugin \"%s\"\n",plugin->getName() );
}
else print_srvconsole("Couldn't find plugin matching \"%s\"\n",sPlugin);
}
else if (!strcmp(cmd,"unpause") && CMD_ARGC() > 2)
{
const char* sPlugin = CMD_ARGV(2);
CPluginMngr::CPlugin *plugin = g_plugins.findPlugin(sPlugin);
if ( plugin && plugin->isValid() )
{
plugin->unpausePlugin();
print_srvconsole("Unpaused plugin \"%s\"\n",plugin->getName() );
}
else print_srvconsole("Couldn't find plugin matching \"%s\"\n",sPlugin);
}
else if (!strcmp(cmd,"cvars"))
{
print_srvconsole( "Registered cvars:\n");
print_srvconsole( " %-24.23s %-24.23s %-16.15s\n",
"name","value","plugin");
int ammount = 0;
for( CList<CCVar>::iterator a = g_cvars.begin(); a ; ++a )
{
print_srvconsole( " [%3d] %-24.23s %-24.23s %-16.15s\n",++ammount,
(*a).getName() ,CVAR_GET_STRING( (*a).getName() ),(*a).getPluginName() );
}
print_srvconsole( "%d cvars\n",ammount);
}
else if ( !strcmp(cmd,"cmds") )
{
if (!strcmp(cmd,"plugins") || !strcmp(cmd,"list")) print_srvconsole( "Registered commands:\n");
{ print_srvconsole( " %-24.23s %-16.15s %-8.7s %-16.15s\n",
"name","access" ,"type" ,"plugin");
print_srvconsole( "Currently loaded plugins:\n");
print_srvconsole( " %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n",
"name","version","author","file","status");
int plugins = 0;
int running = 0;
CPluginMngr::iterator a = g_plugins.begin();
while (a)
{
++plugins;
if ( (*a).isValid() && !(*a).isPaused() )
++running;
print_srvconsole( " [%3d] %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n",
plugins,(*a).getTitle(),(*a).getVersion(),
(*a).getAuthor(), (*a).getName(), (*a).getStatus() );
++a;
}
a = g_plugins.begin();
while (a)
{
if ( (*a).getStatusCode() == ps_bad_load )
{
//error
print_srvconsole("Load fails: %s\n", (*a).getError());
}
++a;
}
print_srvconsole( "%d plugins, %d running\n",plugins,running );
}
else if (!strcmp(cmd,"pause") && CMD_ARGC() > 2)
{
const char* sPlugin = CMD_ARGV(2);
CPluginMngr::CPlugin *plugin = g_plugins.findPlugin(sPlugin);
if ( plugin && plugin->isValid() )
{
plugin->pausePlugin();
print_srvconsole("Paused plugin \"%s\"\n",plugin->getName() );
}
else print_srvconsole("Couldn't find plugin matching \"%s\"\n",sPlugin);
}
else if (!strcmp(cmd,"unpause") && CMD_ARGC() > 2)
{
const char* sPlugin = CMD_ARGV(2);
CPluginMngr::CPlugin *plugin = g_plugins.findPlugin(sPlugin);
if ( plugin && plugin->isValid() )
{
plugin->unpausePlugin();
print_srvconsole("Unpaused plugin \"%s\"\n",plugin->getName() );
}
else print_srvconsole("Couldn't find plugin matching \"%s\"\n",sPlugin);
}
else if (!strcmp(cmd,"cvars"))
{
print_srvconsole( "Registered cvars:\n");
print_srvconsole( " %-24.23s %-24.23s %-16.15s\n",
"name","value","plugin");
int ammount = 0;
for( CList<CCVar>::iterator a = g_cvars.begin(); a ; ++a )
{
print_srvconsole( " [%3d] %-24.23s %-24.23s %-16.15s\n",++ammount,
(*a).getName() ,CVAR_GET_STRING( (*a).getName() ),(*a).getPluginName() );
}
print_srvconsole( "%d cvars\n",ammount);
}
else if ( !strcmp(cmd,"cmds") )
{
print_srvconsole( "Registered commands:\n");
print_srvconsole( " %-24.23s %-16.15s %-8.7s %-16.15s\n",
"name","access" ,"type" ,"plugin");
int ammount = 0;
char access[32];
CmdMngr::iterator a = g_commands.begin( CMD_ConsoleCommand );
while( a )
{
UTIL_GetFlags( access , (*a).getFlags() );
print_srvconsole( " [%3d] %-24.23s %-16.15s %-8.7s %-16.15s\n",
++ammount,(*a).getCmdLine() , access , (*a).getCmdType() , (*a).getPlugin()->getName());
++a;
}
print_srvconsole( "%d commands\n",ammount);
}
else if (!strcmp(cmd,"version"))
{
print_srvconsole( "%s %s\n", Plugin_info.name, Plugin_info.version);
print_srvconsole( "author: %s (%s)\n", Plugin_info.author, Plugin_info.url);
print_srvconsole( "compiled: %s\n", __DATE__ ", " __TIME__);
#ifdef JIT
print_srvconsole( "Core mode: JIT\n");
#else
#ifdef ASM32
print_srvconsole( "Core mode: ASM\n");
#else
print_srvconsole( "Core mode: Normal\n");
#endif
#endif
}
else if (!strcmp(cmd,"modules"))
{
print_srvconsole( "Currently loaded modules:\n");
print_srvconsole( " %-23.22s %-8.7s %-20.19s %-11.10s\n",
"name", "version", "author", "status");
int running = 0;
int modules = 0;
CList<CModule,const char *>::iterator a = g_modules.begin();
while ( a )
{
if ( (*a).getStatusValue() == MODULE_LOADED )
++running;
++modules;
print_srvconsole( " [%2d] %-23.22s %-8.7s %-20.19s %-11.10s\n", modules,
(*a).getName(), (*a).getVersion(), (*a).getAuthor() , (*a).getStatus() );
++a;
}
print_srvconsole( "%d modules, %d correct\n",modules,running);
} else if (!strcmp(cmd, "gpl"))
{
print_srvconsole("AMX Mod X\n");
print_srvconsole("\n");
print_srvconsole(" by the AMX Mod X Development Team\n");
print_srvconsole(" originally developed by OLO\n");
print_srvconsole("\n");
print_srvconsole("\n");
print_srvconsole(" This program is free software; you can redistribute it and/or modify it\n");
print_srvconsole(" under the terms of the GNU General Public License as published by the\n");
print_srvconsole(" Free Software Foundation; either version 2 of the License, or (at\n");
print_srvconsole(" your option) any later version.\n");
print_srvconsole("\n");
print_srvconsole(" This program is distributed in the hope that it will be useful, but\n");
print_srvconsole(" WITHOUT ANY WARRANTY; without even the implied warranty of\n");
print_srvconsole(" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n");
print_srvconsole(" General Public License for more details.\n");
print_srvconsole("\n");
print_srvconsole(" You should have received a copy of the GNU General Public License\n");
print_srvconsole(" along with this program; if not, write to the Free Software Foundation,\n");
print_srvconsole(" Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n");
print_srvconsole("\n");
print_srvconsole(" In addition, as a special exception, the author gives permission to\n");
print_srvconsole(" link the code of this program with the Half-Life Game Engine (\"HL\n");
print_srvconsole(" Engine\") and Modified Game Libraries (\"MODs\") developed by Valve,\n");
print_srvconsole(" L.L.C (\"Valve\"). You must obey the GNU General Public License in all\n");
print_srvconsole(" respects for all of the code used other than the HL Engine and MODs\n");
print_srvconsole(" from Valve. If you modify this file, you may extend this exception\n");
print_srvconsole(" to your version of the file, but you are not obligated to do so. If\n");
print_srvconsole(" you do not wish to do so, delete this exception statement from your\n");
print_srvconsole(" version.\n");
print_srvconsole("\n");
}
else if (!strcmp(cmd, "\x74\x75\x72\x74\x6C\x65")) // !! Hidden Command :D !!
{
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2E\x2E\x3A\x3A\x3E\x3E\x3A\x3A\x3B\x3E\x5E\x27\x2E\x27\x27\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x27\x3A\x3A\x3F\x3D\x3E\x3E\x3E\x3E\x3E\x3D\x3F\x3E\x78\x2B\x3F\x3E\x3E\x3E\x3D\x3E\x3F\x2B\x3F\x3E\x3B\x2E\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x2E\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x27\x2C\x3A\x3E\x3B\x3F\x3D\x3E\x3B\x2E\x27\x5E\x5E\x3B\x3B\x2C\x3A\x3F\x3F\x3D\x78\x3F\x3B\x3E\x3A\x3B\x3A\x5E\x3B\x3D\x3E\x2B\x2B\x2B\x2B\x3D\x2C\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x2C\x3E\x37\x24\x24\x78\x3D\x3D\x3D\x3F\x3A\x27\x20\x20\x20\x20\x20\x20\x20\x2E\x3A\x3B\x3D\x3E\x3A\x3A\x3A\x3A\x3F\x3F\x3F\x3E\x5E\x2C\x2E\x2E\x2C\x2C\x2C\x2C\x3A\x3B\x3D\x3D\x3B\x5E\x2C\x2C\x2C\x3A\x5E\x3A\x3F\x3F\x3E\x3D\x3D\x3E\x3E\x2B\x3B\x27\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x2C\x3D\x2B\x3E\x2C\x5E\x3D\x79\x24\x33\x78\x33\x24\x5A\x24\x3B\x20\x20\x3A\x3E\x2B\x3E\x3D\x3F\x5E\x2C\x2C\x2C\x5E\x5E\x3E\x3D\x3E\x3B\x3B\x3A\x5E\x5E\x3E\x3F\x3D\x2B\x37\x3D\x3F\x3E\x3E\x3E\x3F\x3D\x3F\x3F\x3D\x3D\x3D\x3D\x3E\x3F\x3D\x3E\x3E\x3E\x3D\x5A\x78\x3E\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x3D\x5A\x24\x37\x78\x66\x68\x78\x5A\x5A\x24\x79\x79\x71\x23\x23\x4D\x71\x3B\x3A\x3B\x3A\x3E\x3B\x3B\x2C\x5E\x3E\x3F\x3D\x3F\x3A\x2C\x2C\x3A\x3B\x3B\x3E\x3E\x3D\x2B\x3D\x3E\x3D\x3B\x3A\x3E\x3D\x2B\x3D\x2B\x37\x2B\x3D\x2B\x37\x37\x2B\x2B\x33\x33\x33\x37\x37\x24\x5A\x79\x3A\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x5E\x2B\x5A\x2B\x3E\x3D\x37\x5A\x66\x40\x40\x23\x40\x48\x23\x23\x23\x38\x5E\x3B\x3D\x3F\x2B\x3E\x3B\x3E\x5E\x5E\x2C\x27\x2E\x27\x2E\x2E\x5E\x3F\x3D\x3D\x3F\x3A\x3B\x3A\x3A\x3A\x5E\x5E\x3E\x3E\x3F\x3D\x37\x37\x3D\x3D\x37\x2B\x3D\x37\x2B\x37\x78\x24\x79\x38\x68\x45\x48\x79\x3E\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x2C\x3E\x3E\x78\x33\x68\x48\x23\x23\x40\x40\x48\x45\x66\x33\x20\x2C\x3A\x3E\x3E\x3E\x3B\x3B\x3A\x3A\x2C\x2E\x2C\x5E\x3A\x2C\x5E\x3B\x3E\x37\x37\x3F\x3B\x3A\x2E\x3A\x3A\x3B\x3D\x3B\x3B\x3D\x2B\x3D\x78\x33\x37\x3E\x3D\x3D\x2B\x37\x2B\x78\x78\x78\x78\x5A\x66\x71\x68\x38\x45\x27\x20\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x3A\x37\x37\x24\x66\x71\x45\x45\x71\x45\x3A\x3A\x2C\x5E\x3A\x3E\x3A\x3A\x3B\x3B\x5E\x3A\x2C\x5E\x5E\x2C\x2C\x5E\x3A\x3E\x2B\x33\x3D\x3E\x3A\x3A\x3A\x3D\x2B\x2B\x3D\x3F\x3F\x37\x37\x2B\x37\x3D\x3D\x5A\x33\x78\x33\x37\x78\x24\x5A\x33\x37\x38\x40\x71\x38\x66\x40\x2C\x20\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x5E\x2B\x5A\x45\x40\x5E\x5E\x5E\x3A\x2C\x3A\x3B\x3E\x3A\x5E\x5E\x2C\x2E\x2E\x2C\x5E\x3B\x3B\x3A\x2B\x3E\x3F\x3B\x3F\x3F\x3F\x3F\x3E\x3F\x3D\x37\x3B\x3B\x3D\x33\x2B\x3D\x3D\x78\x78\x5A\x78\x33\x78\x5A\x5A\x5A\x24\x71\x48\x79\x5A\x24\x79\x45\x3E\x20\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x27\x3B\x2C\x2C\x27\x5E\x5E\x2C\x3A\x5E\x3A\x3A\x5E\x3A\x3B\x3F\x3E\x3F\x3E\x3B\x3E\x3E\x3F\x3D\x2B\x37\x37\x2B\x2B\x3D\x2B\x37\x2B\x37\x37\x2B\x3B\x3D\x33\x2B\x2B\x37\x37\x2B\x3D\x78\x78\x66\x78\x78\x37\x33\x66\x78\x38\x23\x23\x27\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x3A\x3F\x3B\x5E\x2C\x3B\x3F\x3D\x3F\x3F\x3B\x3A\x3A\x3A\x3E\x3F\x3E\x3E\x3F\x3A\x3F\x33\x78\x78\x33\x24\x24\x33\x2B\x37\x78\x24\x78\x33\x3D\x2B\x2B\x5A\x24\x78\x24\x78\x33\x33\x24\x5A\x79\x24\x24\x24\x68\x45\x48\x38\x68\x45\x40\x3E\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2C\x3A\x3E\x3F\x37\x3D\x3E\x3F\x2B\x3F\x3F\x3E\x3F\x3F\x3F\x3D\x3F\x3E\x3F\x3D\x37\x2B\x3E\x3E\x2B\x37\x37\x33\x37\x33\x78\x33\x33\x33\x78\x37\x37\x37\x78\x5A\x78\x5A\x79\x79\x5A\x24\x79\x79\x79\x79\x79\x68\x71\x38\x38\x71\x23\x23\x45\x37\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x5E\x2B\x2B\x3F\x2B\x78\x40\x38\x3F\x3B\x3E\x3B\x3B\x3E\x3F\x37\x2B\x3F\x3F\x3D\x3D\x3E\x3F\x2B\x37\x37\x37\x37\x33\x33\x78\x78\x33\x37\x24\x5A\x78\x5A\x5A\x78\x24\x33\x3D\x37\x37\x37\x78\x24\x5A\x78\x37\x37\x78\x66\x79\x66\x71\x66\x40\x45\x40\x3A\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2B\x3A\x3F\x2B\x3D\x2B\x79\x23\x79\x3B\x2C\x3A\x3A\x3A\x37\x78\x3F\x3E\x3B\x3E\x3B\x3E\x3D\x37\x24\x33\x37\x33\x37\x78\x78\x33\x24\x68\x79\x33\x24\x78\x2B\x33\x33\x5A\x79\x24\x5A\x79\x24\x5A\x37\x24\x5A\x5A\x66\x38\x66\x79\x66\x40\x71\x45\x48\x5A\x3A\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x5E\x37\x3D\x37\x37\x33\x37\x37\x66\x45\x5A\x3F\x5E\x5E\x78\x37\x3D\x3F\x3E\x3B\x3B\x3E\x2B\x2B\x24\x78\x37\x2B\x37\x2B\x37\x78\x78\x71\x79\x33\x33\x24\x24\x78\x24\x5A\x3F\x37\x78\x24\x78\x79\x66\x5A\x78\x79\x66\x79\x68\x79\x66\x5A\x33\x3F\x3D\x3D\x20\x20\x20\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x5E\x2B\x3D\x3F\x37\x37\x78\x33\x5A\x4E\x4D\x23\x38\x33\x3F\x3E\x3B\x3E\x3B\x3D\x3D\x33\x66\x24\x78\x33\x2B\x78\x24\x5A\x24\x5A\x71\x79\x78\x33\x33\x78\x79\x5A\x5A\x33\x66\x24\x78\x78\x24\x79\x5A\x24\x79\x5A\x37\x66\x24\x3D\x3B\x66\x23\x4D\x4D\x4D\x79\x3B\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x3A\x33\x37\x37\x24\x78\x66\x79\x48\x4D\x4D\x4D\x4D\x23\x71\x68\x5A\x24\x5A\x79\x68\x68\x5A\x5A\x24\x79\x66\x68\x78\x5A\x4E\x45\x66\x66\x45\x45\x45\x24\x5A\x40\x71\x68\x5A\x68\x5A\x37\x66\x79\x78\x37\x78\x37\x68\x38\x38\x71\x48\x40\x23\x45\x3A\x3D\x37\x45\x27\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x37\x37\x78\x37\x33\x38\x45\x45\x71\x20\x5E\x3D\x2B\x3F\x2B\x2B\x79\x71\x45\x48\x40\x45\x45\x45\x45\x45\x71\x40\x40\x71\x38\x38\x79\x66\x38\x68\x48\x48\x45\x66\x37\x2B\x3A\x37\x3F\x3B\x3A\x2C\x27\x2C\x27\x78\x4D\x23\x48\x48\x48\x79\x2B\x3A\x3F\x79\x27\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x3A\x78\x78\x24\x40\x4E\x4E\x4D\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x5E\x3E\x3E\x3F\x3E\x3E\x3E\x3E\x3B\x3B\x3B\x3A\x3A\x3F\x3E\x3A\x2E\x2E\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2E\x45\x4D\x40\x45\x78\x5E\x33\x68\x33\x2B\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x24\x48\x45\x48\x78\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2B\x4E\x40\x2B\x66\x33\x78\x20\x20\n");
print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2B\x2C\x20\x3A\x20\x20\n");
}
else
{
print_srvconsole("Usage: amxx < command > [ argument ]\n");
print_srvconsole("Commands:\n");
print_srvconsole(" version - display amxx version info\n");
print_srvconsole(" gpl - print the license\n");
print_srvconsole(" plugins - list plugins currently loaded\n");
print_srvconsole(" modules - list modules currently loaded\n");
print_srvconsole(" cvars - list cvars registered by plugins\n");
print_srvconsole(" cmds - list commands registered by plugins\n");
print_srvconsole(" pause < plugin > - pause a running plugin\n");
print_srvconsole(" unpause < plugin > - unpause a previously paused plugin\n");
int ammount = 0;
char access[32];
CmdMngr::iterator a = g_commands.begin( CMD_ConsoleCommand );
while( a )
{
UTIL_GetFlags( access , (*a).getFlags() );
print_srvconsole( " [%3d] %-24.23s %-16.15s %-8.7s %-16.15s\n",
++ammount,(*a).getCmdLine() , access , (*a).getCmdType() , (*a).getPlugin()->getName());
++a;
} }
print_srvconsole( "%d commands\n",ammount);
}
else if (!strcmp(cmd,"version"))
{
print_srvconsole( "%s %s\n", Plugin_info.name, Plugin_info.version);
print_srvconsole( "author: %s (%s)\n", Plugin_info.author, Plugin_info.url);
print_srvconsole( "compiled: %s\n", __DATE__ ", " __TIME__);
}
else if (!strcmp(cmd,"modules"))
{
print_srvconsole( "Currently loaded modules:\n");
print_srvconsole( " %-23.22s %-7.8s %-8.7s %-20.19s %-11.10s\n",
"name","type","version", "author", "status");
int running = 0;
int modules = 0;
CList<CModule>::iterator a = g_modules.begin();
while ( a )
{
if ( (*a).getStatusValue() == MODULE_LOADED )
++running;
++modules;
print_srvconsole( " [%2d] %-23.22s %-7.6s %-8.7s %-20.19s %-11.10s\n",modules,
(*a).getName(), (*a).getType(), (*a).getVersion(), (*a).getAuthor() , (*a).getStatus() );
++a;
}
print_srvconsole( "%d modules, %d correct\n",modules,running);
}
else
{
print_srvconsole("Usage: amxx < command > [ argument ]\n");
print_srvconsole("Commands:\n");
print_srvconsole(" version - display amxx version info\n");
print_srvconsole(" plugins - list plugins currently loaded\n");
print_srvconsole(" modules - list modules currently loaded\n");
print_srvconsole(" cvars - list cvars registered by plugins\n");
print_srvconsole(" cmds - list commands registered by plugins\n");
print_srvconsole(" pause < plugin > - pause a running plugin\n");
print_srvconsole(" unpause < plugin > - unpause a previously paused plugin\n");
}
} }
void plugin_srvcmd() void plugin_srvcmd()
{ {
cell ret = 0; cell ret = 0;
int err; int err;
const char* cmd = CMD_ARGV(0); const char* cmd = CMD_ARGV(0);
#ifdef ENABLEEXEPTIONS #ifdef ENABLEEXEPTIONS
try{ try{
#endif #endif
CmdMngr::iterator a = g_commands.srvcmdbegin(); CmdMngr::iterator a = g_commands.srvcmdbegin();
while ( a ) while ( a )
{
if ( (*a).matchCommand( cmd ) &&
(*a).getPlugin()->isExecutable( (*a).getFunction() ) )
{
if ((err = amx_Exec( (*a).getPlugin()->getAMX(), &ret , (*a).getFunction()
, 3 , g_srvindex , (*a).getFlags() , (*a).getId() )) != AMX_ERR_NONE)
{
LogError((*a).getPlugin()->getAMX(), err, "");
}
if ( ret ) break;
}
++a;
}
#ifdef ENABLEEXEPTIONS
}catch( ... )
{ {
AMXXLOG_Log( "[AMXX] fatal error at forward function execution"); if ( (*a).matchCommand( cmd ) &&
(*a).getPlugin()->isExecutable( (*a).getFunction() ) )
{
if ((err = amx_Exec( (*a).getPlugin()->getAMX(), &ret , (*a).getFunction()
, 3 , g_srvindex , (*a).getFlags() , (*a).getId() )) != AMX_ERR_NONE)
UTIL_Log("[AMXX] Run time error %d on line %ld (plugin \"%s\")",
err,(*a).getPlugin()->getAMX()->curline,(*a).getPlugin()->getName());
if ( ret ) break;
}
++a;
} }
#endif
#ifdef ENABLEEXEPTIONS
}catch( ... )
{
UTIL_Log( "[AMXX] fatal error at forward function execution");
}
#endif
} }

View File

@ -29,8 +29,10 @@
* version. * version.
*/ */
#include <extdll.h>
#include <meta_api.h>
#include <ctype.h> #include <ctype.h>
#include "amxmodx.h" #include "amxmod.h"
const char* stristr(const char* str,const char* substr) const char* stristr(const char* str,const char* substr)
{ {
@ -55,7 +57,39 @@ const char* stristr(const char* str,const char* substr)
char* format_amxstring(AMX *amx, cell *params, int parm,int& len) char* format_amxstring(AMX *amx, cell *params, int parm,int& len)
{ {
return g_langMngr.FormatAmxString(amx, params, parm, len); static char buffer[2][3072];
static char format[16];
char *ptr,*arg;
char *dest = *buffer;
cell *src = get_amxaddr(amx, params[parm++]);
int numparam = *params/sizeof(cell);
while(*src) {
if (*src=='%'&&*(src+1)) {
ptr = format;
*ptr++ = *src++;
if (*src=='%'){
*dest++=*src++;
continue;
}
while (!isalpha(*ptr++=*src++))
;
*ptr=0;
if (numparam < parm) continue;
arg = buffer[1];
switch(*(ptr-1)){
case 's': sprintf(arg,format,get_amxstring(amx, params[parm++],2,len)); break;
case 'f': case 'g': sprintf(arg,format,*(float*)get_amxaddr(amx, params[parm++])); break;
default: sprintf(arg,format,(int)*get_amxaddr(amx, params[parm++]));
}
while(*arg) *dest++=*arg++;
continue;
}
*dest++=*src++;
}
*dest=0;
len = dest - *buffer;
return *buffer;
} }
int amxstring_len(cell* a) int amxstring_len(cell* a)
@ -89,7 +123,7 @@ char* get_amxstring(AMX *amx,cell amx_addr,int id, int& len)
register cell* source = (cell *)(amx->base + (int)(((AMX_HEADER *)amx->base)->dat + amx_addr)); register cell* source = (cell *)(amx->base + (int)(((AMX_HEADER *)amx->base)->dat + amx_addr));
register char* dest = buffor[id]; register char* dest = buffor[id];
char* start = dest; char* start = dest;
while ((*dest++=(char)(*source++))) while (*dest++=(char)*source++)
; ;
len = --dest - start; len = --dest - start;
return start; return start;
@ -393,7 +427,7 @@ float fo_getargfloat(AMX *amx, int pos)
unsigned char *data =amx->base+(int)((AMX_HEADER *)amx->base)->dat; unsigned char *data =amx->base+(int)((AMX_HEADER *)amx->base)->dat;
cell value = * (cell *)(data+(int)amx->frm+(pos+3)*sizeof(cell)); cell value = * (cell *)(data+(int)amx->frm+(pos+3)*sizeof(cell));
cell number = *(cell *)(data+(int)value); cell number = *(cell *)(data+(int)value);
return *(REAL *)((void *)&number); return *(float *)((void *)&number);
} }
char* fo_getargstr(AMX *amx, int swap, int pos) char* fo_getargstr(AMX *amx, int swap, int pos)
@ -448,119 +482,6 @@ char* format_arguments(AMX *amx, int parm,int& len)
return *buffer; return *buffer;
} }
//added by BAILOPAN for jtp10181
//takes a string and breaks it into a 1st param and rest params
//different from strbreak because it's more crafted for control
static cell AMX_NATIVE_CALL amx_strtok(AMX *amx, cell *params)
{
int left_pos = 0;
int right_pos = 0;
unsigned int i = 0;
bool done_flag = false;
int len = 0;
//string[]
char *string = get_amxstring(amx, params[1], 0, len);
//left[]
char *left = new char[len+1];
//right[]
char *right = new char[len+1];
int leftMax = params[3];
int rightMax = params[5];
//token
char token = params[6];
//trim
int trim = params[7];
for (i=0; i<len; i++)
{
if (trim && !done_flag)
{
if (isspace(string[i]))
{
while (isspace(string[++i]));
done_flag = true;
}
}
if (!done_flag && string[i] == token)
{
done_flag = true;
i++;
}
if (done_flag)
{
right[right_pos++] = string[i];
} else {
left[left_pos++] = string[i];
}
}
right[right_pos] = 0;
left[left_pos] = 0;
set_amxstring(amx, params[2], left, leftMax);
set_amxstring(amx, params[4], right, rightMax);
delete [] left;
delete [] right;
return 1;
}
//added by BAILOPAN
//Takes a string and breaks it into a 1st param and rest params
//strbreak(String[], First[], FirstLen, Rest[], RestLen)
static cell AMX_NATIVE_CALL strbreak(AMX *amx, cell *params) /* 5 param */
{
bool quote_flag = false;
bool done_flag = false;
int left_pos = 0;
int right_pos = 0;
int l=0;
unsigned int i=0;
char hold = '"';
char *string = get_amxstring(amx, params[1], 0, l);
char *left = new char[strlen(string)+1];
char *right = new char[strlen(string)+1];
int LeftMax = params[3];
int RightMax = params[5];
for (i=0; i<l; i++) {
if (string[i] == '"' && !quote_flag) {
quote_flag = true;
} else if (string[i] == '"' && quote_flag) {
quote_flag = false;
}
if ((string[i] == ' ') && !quote_flag && !done_flag) {
done_flag = true;
i++;
}
if (!done_flag && string[i]!='"') {
if (left_pos < LeftMax) {
left[left_pos] = string[i];
if (left[left_pos] == '\'') {
left[left_pos] = hold;
}
left_pos++;
} else {
done_flag = true;
}
} else {
if (right_pos < RightMax && string[i]!='"') {
right[right_pos] = string[i];
if (right[right_pos] == '\'') {
right[right_pos] = hold;
}
right_pos++;
}
}
}
left[left_pos] = '\0';
right[right_pos] = '\0';
set_amxstring(amx, params[2], left, params[3]);
set_amxstring(amx, params[4], right, params[5]);
delete [] left;
delete [] right;
return 1;
}
static cell AMX_NATIVE_CALL format_args(AMX *amx, cell *params) static cell AMX_NATIVE_CALL format_args(AMX *amx, cell *params)
{ {
int len; int len;
@ -593,54 +514,6 @@ static cell AMX_NATIVE_CALL is_alpha(AMX *amx, cell *params)
return isalpha( params[1] ); return isalpha( params[1] );
} }
static cell AMX_NATIVE_CALL amx_ucfirst(AMX *amx, cell *params)
{
int len = 0;
cell *str = get_amxaddr(amx, params[1]);
if (!isalpha((char)str[0]) || !(str[0]&(1<<5)))
return 0;
str[0] &= ~(1<<5);
return 1;
}
static cell AMX_NATIVE_CALL amx_trim(AMX *amx, cell *params)
{
cell *asdf = get_amxaddr(amx, params[1]);
cell *cptr = asdf;
int len = 0;
while (*cptr++) len++;
int flag = 0, incr = 0;
register int i = 0;
for (i=len-1; i>=0; i--)
{
if (!isspace(asdf[i]))
{
break;
} else {
asdf[i] = 0;
len--;
}
}
for (i=0; i<len; i++)
{
if (isspace(asdf[i]) && !flag)
{
incr++;
if (incr+i<len)
asdf[i] = asdf[incr+i];
} else {
if (!flag)
flag = 1;
if (incr)
asdf[i] = asdf[incr+i];
}
}
asdf[len] = 0;
return incr;
}
AMX_NATIVE_INFO string_Natives[] = { AMX_NATIVE_INFO string_Natives[] = {
{ "add", add }, { "add", add },
{ "contain", contain }, { "contain", contain },
@ -659,12 +532,8 @@ AMX_NATIVE_INFO string_Natives[] = {
{ "parse", parse }, { "parse", parse },
{ "replace", replace }, { "replace", replace },
{ "setc", setc }, { "setc", setc },
{ "strbreak", strbreak},
{ "strtolower", strtolower }, { "strtolower", strtolower },
{ "strtoupper", strtoupper }, { "strtoupper", strtoupper },
{ "str_to_num", strtonum }, { "str_to_num", strtonum },
{ "trim", amx_trim },
{ "ucfirst", amx_ucfirst },
{ "strtok", amx_strtok },
{ NULL, NULL } { NULL, NULL }
}; };

View File

@ -14,11 +14,6 @@
#define strnicmp strncasecmp #define strnicmp strncasecmp
#endif #endif
// this file does not include amxmodx.h, so we have to include the memory manager here
#ifdef MEMORY_TEST
#include "mmgr/mmgr.h"
#endif // MEMORY_TEST
const char *_lc_Wday_ [2][ 7], const char *_lc_Wday_ [2][ 7],
*_lc_Month_[2][12], *_lc_Month_[2][12],
*_lc_AmPm_ [2][ 2]; *_lc_AmPm_ [2][ 2];

View File

@ -29,287 +29,304 @@
* version. * version.
*/ */
#include <extdll.h>
#include <meta_api.h>
#include <time.h> #include <time.h>
#include "amxmodx.h" #include "amxmod.h"
int UTIL_ReadFlags(const char* c) int UTIL_ReadFlags(const char* c)
{ {
int flags = 0; int flags = 0;
while (*c) flags |= ( 1 << ( *c++ - 'a' ) ); while (*c) flags |= ( 1 << ( *c++ - 'a' ) );
return flags; return flags;
} }
void UTIL_GetFlags(char* f,int a) void UTIL_GetFlags(char* f,int a)
{ {
for(int i='a';i<='z';++i){ for(int i='a';i<='z';++i){
if ( a & 1 ) *f++ = i; if ( a & 1 ) *f++ = i;
a >>= 1; a >>= 1;
} }
*f = 0; *f = 0;
} }
/* warning - don't pass here const string */ /* warning - don't pass here const string */
void UTIL_ShowMenu( edict_t* pEdict, int slots, int time, char *menu, int mlen ) void UTIL_ShowMenu( edict_t* pEdict, int slots, int time, char *menu, int mlen )
{ {
char *n = menu; char *n = menu;
char c = 0; char c = 0;
int a; int a;
if (!gmsgShowMenu) while ( *n ) {
return; // some games don't support ShowMenu (Firearms) a = mlen;
if ( a > 175 ) a = 175;
while ( *n ) { mlen -= a;
a = mlen; c = *(n+=a);
if ( a > 175 ) a = 175; *n = 0;
mlen -= a; MESSAGE_BEGIN( MSG_ONE , gmsgShowMenu, NULL, pEdict );
c = *(n+=a); WRITE_SHORT( slots );
*n = 0; WRITE_CHAR( time );
MESSAGE_BEGIN( MSG_ONE , gmsgShowMenu, NULL, pEdict ); WRITE_BYTE( c ? TRUE : FALSE);
WRITE_SHORT( slots ); WRITE_STRING( menu );
WRITE_CHAR( time ); MESSAGE_END();
WRITE_BYTE( c ? TRUE : FALSE); *n = c;
WRITE_STRING( menu ); menu = n;
MESSAGE_END(); }
*n = c;
menu = n;
}
} }
/* warning - don't pass here const string */ /* warning - don't pass here const string */
void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name) void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name)
{ {
if (!gmsgMOTD) MESSAGE_BEGIN( MSG_ONE , gmsgServerName, NULL, client );
return; // :TODO: Maybe output a warning log? WRITE_STRING(name);
MESSAGE_END();
if (gmsgServerName) char *n = motd;
{ char c = 0;
MESSAGE_BEGIN( MSG_ONE , gmsgServerName, NULL, client ); int a;
WRITE_STRING(name);
MESSAGE_END();
}
char *n = motd; while ( *n ) {
char c = 0; a = mlen;
int a; if ( a > 175 ) a = 175;
mlen -= a;
c = *(n+=a);
*n = 0;
MESSAGE_BEGIN( MSG_ONE , gmsgMOTD, NULL, client );
WRITE_BYTE( c ? FALSE : TRUE );
WRITE_STRING( motd );
MESSAGE_END();
*n = c;
motd = n;
}
while ( *n ) { MESSAGE_BEGIN( MSG_ONE , gmsgServerName, NULL, client );
a = mlen; WRITE_STRING( hostname->string );
if ( a > 175 ) a = 175; MESSAGE_END();
mlen -= a;
c = *(n+=a);
*n = 0;
MESSAGE_BEGIN( MSG_ONE , gmsgMOTD, NULL, client );
WRITE_BYTE( c ? FALSE : TRUE );
WRITE_STRING( motd );
MESSAGE_END();
*n = c;
motd = n;
}
if (gmsgServerName)
{
MESSAGE_BEGIN( MSG_ONE , gmsgServerName, NULL, client );
WRITE_STRING( hostname->string );
MESSAGE_END();
}
} }
void UTIL_IntToString(int value, char *output) void UTIL_IntToString(int value, char *output)
{ {
static const char *words[] = {"zero ","one ","two ","three ","four ", static const char *words[] = {"zero ","one ","two ","three ","four ",
"five ", "six ","seven ","eight ","nine ","ten ", "five ", "six ","seven ","eight ","nine ","ten ",
"eleven ","twelve ","thirteen ","fourteen ","fifteen ", "eleven ","twelve ","thirteen ","fourteen ","fifteen ",
"sixteen ","seventeen ","eighteen ","nineteen ", "sixteen ","seventeen ","eighteen ","nineteen ",
"twenty ","thirty ","fourty ", "fifty ","sixty ", "twenty ","thirty ","fourty ", "fifty ","sixty ",
"seventy ","eighty ","ninety ", "seventy ","eighty ","ninety ",
"hundred ","thousand "}; "hundred ","thousand "};
*output = 0; *output = 0;
if (value < 0) value = -value; if (value < 0) value = -value;
int tho = value / 1000; int tho = value / 1000;
int aaa = 0; int aaa = 0;
if (tho){ if (tho){
aaa += sprintf(&output[aaa], words[ tho ] ); aaa += sprintf(&output[aaa], words[ tho ] );
aaa += sprintf(&output[aaa], words[29] ); aaa += sprintf(&output[aaa], words[29] );
value = value % 1000; value = value % 1000;
} }
int hun = value / 100; int hun = value / 100;
if (hun) { if (hun) {
aaa += sprintf(&output[aaa], words[ hun ] ); aaa += sprintf(&output[aaa], words[ hun ] );
aaa += sprintf(&output[aaa], words[28] ); aaa += sprintf(&output[aaa], words[28] );
value = value % 100; value = value % 100;
} }
int ten = value / 10; int ten = value / 10;
int unit = value % 10; int unit = value % 10;
if ( ten ) if ( ten )
aaa += sprintf(&output[aaa], words[ ( ten > 1 ) ? ( ten + 18 ) : ( unit + 10 ) ] ); aaa += sprintf(&output[aaa], words[ ( ten > 1 ) ? ( ten + 18 ) : ( unit + 10 ) ] );
if ( ten != 1 && ( unit || (!value && !hun && !tho) ) ) if ( ten != 1 && ( unit || (!value && !hun && !tho) ) )
sprintf(&output[aaa], words[ unit ] ); sprintf(&output[aaa], words[ unit ] );
} }
char* UTIL_SplitHudMessage(const char *src) char* UTIL_SplitHudMessage(const char *src)
{ {
static char message[512]; static char message[512];
short b = 0, d = 0, e = 0, c = -1; short b = 0, d = 0, e = 0, c = -1;
while ( src[ d ] && e < 480 ) { while ( src[ d ] && e < 480 ) {
if ( src[ d ] == ' ' ) { if ( src[ d ] == ' ' ) {
c = e; c = e;
} }
else if ( src[ d ] == '\n' ) { else if ( src[ d ] == '\n' ) {
c = -1; c = -1;
b = 0; b = 0;
} }
message[ e++ ] = src[ d++ ]; message[ e++ ] = src[ d++ ];
if ( ++b == 69 ) { if ( ++b == 69 ) {
if ( c == -1 ) { if ( c == -1 ) {
message[ e++ ] = '\n'; message[ e++ ] = '\n';
b = 0; b = 0;
} }
else { else {
message[ c ] = '\n'; message[ c ] = '\n';
b = e - c - 1; b = e - c - 1;
c = -1; c = -1;
} }
} }
} }
message[ e ] = 0; message[ e ] = 0;
return message; return message;
} }
unsigned short FixedUnsigned16( float value, float scale ) unsigned short FixedUnsigned16( float value, float scale )
{ {
int output = (int)(value * scale); int output = value * scale;
if ( output < 0 ) if ( output < 0 )
output = 0; output = 0;
else if ( output > 0xFFFF ) else if ( output > 0xFFFF )
output = 0xFFFF; output = 0xFFFF;
return (unsigned short)output; return (unsigned short)output;
} }
short FixedSigned16( float value, float scale ) short FixedSigned16( float value, float scale )
{ {
int output = (int)(value * scale); int output = value * scale;
if ( output > 32767 ) if ( output > 32767 )
output = 32767; output = 32767;
else if ( output < -32768 ) else if ( output < -32768 )
output = -32768; output = -32768;
return (short)output; return (short)output;
} }
void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pMessage) void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pMessage)
{ {
if ( pEntity ) if ( pEntity )
MESSAGE_BEGIN( MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, NULL, pEntity ); MESSAGE_BEGIN( MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, NULL, pEntity );
else else
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY ); MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE(29); WRITE_BYTE(29);
WRITE_BYTE(textparms.channel & 0xFF); WRITE_BYTE(textparms.channel & 0xFF);
WRITE_SHORT(FixedSigned16(textparms.x, (1<<13) )); WRITE_SHORT(FixedSigned16(textparms.x, (1<<13) ));
WRITE_SHORT(FixedSigned16(textparms.y, (1<<13) )); WRITE_SHORT(FixedSigned16(textparms.y, (1<<13) ));
WRITE_BYTE(textparms.effect); WRITE_BYTE(textparms.effect);
WRITE_BYTE(textparms.r1); WRITE_BYTE(textparms.r1);
WRITE_BYTE(textparms.g1); WRITE_BYTE(textparms.g1);
WRITE_BYTE(textparms.b1); WRITE_BYTE(textparms.b1);
WRITE_BYTE(0); WRITE_BYTE(0);
WRITE_BYTE(255); WRITE_BYTE(255);
WRITE_BYTE(255); WRITE_BYTE(255);
WRITE_BYTE(250); WRITE_BYTE(250);
WRITE_BYTE(0); WRITE_BYTE(0);
WRITE_SHORT(FixedUnsigned16(textparms.fadeinTime, (1<<8) )); WRITE_SHORT(FixedUnsigned16(textparms.fadeinTime, (1<<8) ));
WRITE_SHORT(FixedUnsigned16(textparms.fadeoutTime, (1<<8) )); WRITE_SHORT(FixedUnsigned16(textparms.fadeoutTime, (1<<8) ));
WRITE_SHORT(FixedUnsigned16(textparms.holdTime, (1<<8) )); WRITE_SHORT(FixedUnsigned16(textparms.holdTime, (1<<8) ));
if (textparms.effect==2) if (textparms.effect==2)
WRITE_SHORT(FixedUnsigned16(textparms.fxTime, (1<<8) ) ); WRITE_SHORT(FixedUnsigned16(textparms.fxTime, (1<<8) ) );
WRITE_STRING(pMessage); WRITE_STRING(pMessage);
MESSAGE_END(); MESSAGE_END();
} }
/* warning - buffer of msg must be longer than 190 chars! /* warning - buffer of msg must be longer than 190 chars!
(here in AMX it is always longer) */ (here in AMX it is always longer) */
void UTIL_ClientPrint( edict_t *pEntity, int msg_dest, char *msg ) void UTIL_ClientPrint( edict_t *pEntity, int msg_dest, char *msg )
{ {
if (!gmsgTextMsg) char c = msg[190];
return; // :TODO: Maybe output a warning log? msg[190] = 0; // truncate without checking with strlen()
if ( pEntity )
char c = msg[190]; MESSAGE_BEGIN( MSG_ONE, gmsgTextMsg, NULL, pEntity );
msg[190] = 0; // truncate without checking with strlen() else
if ( pEntity ) MESSAGE_BEGIN( MSG_BROADCAST , gmsgTextMsg);
MESSAGE_BEGIN( MSG_ONE, gmsgTextMsg, NULL, pEntity ); WRITE_BYTE( msg_dest );
else WRITE_STRING( msg );
MESSAGE_BEGIN( MSG_BROADCAST , gmsgTextMsg); MESSAGE_END();
WRITE_BYTE( msg_dest ); msg[190] = c;
WRITE_STRING( msg );
MESSAGE_END();
msg[190] = c;
} }
// UTIL_FakeClientCommand void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1, const char *arg2) {
// PURPOSE: Sends a fake client command to GameDLL if (!cmd) return;
// HOW DOES IT WORK: //strncpy(g_fakecmd.argv[0], cmd, 127 );
// 1) Stores command and arguments into a global and sets the global "fake" flag to true //g_fakecmd.argv[0][ 127 ] = 0;
// 2) Invokes ClientCommand in GameDLL
// 3) meta_api.cpp overrides Cmd_Args, Cmd_Argv, Cmd_Argc and gives them fake values if the "fake" flag is set
// 4) unsets the global "fake" flag
void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1, const char *arg2)
{
if (!cmd)
return; // no command
/*
char clCmd[256];
snprintf(g_fakecmd.args, 255, "%s%s%s%s%s", cmd,
arg1 ? " " : "", arg1 ? arg1 : "",
arg2 ? " " : "", arg2 ? arg2 : "");
clCmd[255] = 0;
CLIENT_COMMAND(pEdict, clCmd);
return;
*/
if (!cmd)
return; // no command
// store command
g_fakecmd.argv[0] = cmd; g_fakecmd.argv[0] = cmd;
// if only arg2 is passed, swap the arguments if (arg2){
if (!arg1 && arg2) g_fakecmd.argc = 3;
{
arg1 = arg2;
arg2 = NULL;
}
// store arguments
if (arg2)
{ // both arguments passed
g_fakecmd.argc = 3; // 2 arguments + 1 command
// store arguments
g_fakecmd.argv[1] = arg1; g_fakecmd.argv[1] = arg1;
g_fakecmd.argv[2] = arg2; g_fakecmd.argv[2] = arg2;
// build argument line snprintf( g_fakecmd.args ,255 , "%s %s",arg1,arg2 );
snprintf(g_fakecmd.args, 255, "%s %s", arg1, arg2);
// if snprintf reached 255 chars limit, this will make sure there will be no access violation
g_fakecmd.args[255] = 0; g_fakecmd.args[255] = 0;
//strncpy(g_fakecmd.argv[1], arg1 , 127 );
//g_fakecmd.argv[1][ 127 ] = 0;
//strncpy(g_fakecmd.argv[2], arg2 , 127 );
//g_fakecmd.argv[2][ 127 ] = 0;
//snprintf(g_fakecmd.args, 255 , "%s %s",arg1,arg2);
//g_fakecmd.args[255] = 0;
} }
else if (arg1) else if (arg1){
{ // only one argument passed g_fakecmd.argc = 2;
g_fakecmd.argc = 2; // 1 argument + 1 command
// store argument
g_fakecmd.argv[1] = arg1; g_fakecmd.argv[1] = arg1;
// build argument line snprintf( g_fakecmd.args ,255 , "%s" , arg1 );
snprintf( g_fakecmd.args, 255, "%s", arg1);
// if snprintf reached 255 chars limit, this will make sure there will be no access violation
g_fakecmd.args[255] = 0; g_fakecmd.args[255] = 0;
//strncpy(g_fakecmd.argv[1], arg1, 127 );
//g_fakecmd.argv[1][ 127 ] = 0;
//*g_fakecmd.argv[2] = 0;
//snprintf(g_fakecmd.args, 255 ,"%s",arg1);
//g_fakecmd.args[255] = 0;
} }
else else
g_fakecmd.argc = 1; // no argmuents -> only one command g_fakecmd.argc = 1;
// set the global "fake" flag so the Cmd_Arg* functions will be superceded
g_fakecmd.fake = true; g_fakecmd.fake = true;
// tell the GameDLL that the client sent a command
MDLL_ClientCommand(pEdict); MDLL_ClientCommand(pEdict);
// unset the global "fake" flag
g_fakecmd.fake = false; g_fakecmd.fake = false;
} }
String g_UTIL_LogFile;
void UTIL_MakeNewLogFile()
{
// build filename
time_t td;
time(&td);
tm *curTime = localtime(&td);
// create dir if not existing
#ifdef __linux
mkdir(build_pathname("%s", g_log_dir.str()), 0700);
#else
mkdir(build_pathname("%s", g_log_dir.str()));
#endif
int i = 0;
while (true)
{
g_UTIL_LogFile.set(build_pathname("%s/L%02d%02d%03d.log", g_log_dir.str(), curTime->tm_mon + 1, curTime->tm_mday, i));
FILE *pTmpFile = fopen(g_UTIL_LogFile.str(), "r"); // open for reading to check whether the file exists
if (!pTmpFile)
break;
fclose(pTmpFile);
++i;
}
// Log logfile start
UTIL_Log("AMX Mod X log file started (file \"%s/L%02d%02d%03d.log\") (version \"%s\")", g_log_dir.str(), curTime->tm_mon + 1, curTime->tm_mday, i, AMX_VERSION);
}
void UTIL_Log(const char *fmt, ...)
{
// build message
// :TODO: Overflow possible here
char msg[3072];
va_list arglst;
va_start(arglst, fmt);
vsprintf(msg, fmt, arglst);
va_end(arglst);
// get time
time_t td;
time(&td);
tm *curTime = localtime(&td);
char date[32];
strftime(date, 31, "%m/%d/%Y - %H:%M:%S", curTime);
// log msg now
FILE *pF = fopen(g_UTIL_LogFile.str(), "a+");
if (!pF)
return; // don't try to create a new logfile to prevent recursion crashes if there is an unforseen error
fprintf(pF, "L %s: %s\n", date, msg);
fclose(pF);
print_srvconsole("L %s: %s\n", date, msg);
}

View File

@ -29,8 +29,10 @@
* version. * version.
*/ */
#include "amxmodx.h" #include <extdll.h>
#include <meta_api.h>
#include "CVault.h" #include "CVault.h"
#include "amxmod.h"
Vault g_vault; Vault g_vault;
@ -80,6 +82,4 @@ AMX_NATIVE_INFO vault_Natives[] = {
{ "delete_vaultdata", remove_vaultdata }, { "delete_vaultdata", remove_vaultdata },
{ "vaultdata_exists", vaultdata_exists }, { "vaultdata_exists", vaultdata_exists },
{ 0, 0 } { 0, 0 }
}; };

View File

@ -1,34 +0,0 @@
#include "winres.h"
VS_VERSION_INFO VERSIONINFO
FILEVERSION 0,2,0,0
PRODUCTVERSION 0,2,0,0
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x4L
FILETYPE 0x2L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "000004b0"
BEGIN
VALUE "Comments", "AMX Mod X\0"
VALUE "FileDescription", "AMX Mod X\0"
VALUE "FileVersion", "0.20\0"
VALUE "InternalName", "amxmodx\0"
VALUE "LegalCopyright", "Copyright (c) 2004, AMX Mod X Dev Team\0"
VALUE "OriginalFilename", "amxx_mm.dll\0"
VALUE "ProductName", "AMX Mod X\0"
VALUE "ProductVersion", "0.20\0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x0, 1200
END
END

Binary file not shown.

Binary file not shown.

View File

@ -1,323 +0,0 @@
/* zconf.h -- configuration of the zlib compression library
* Copyright (C) 1995-2003 Jean-loup Gailly.
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#ifndef ZCONF_H
#define ZCONF_H
/*
* If you *really* need a unique prefix for all types and library functions,
* compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
*/
#ifdef Z_PREFIX
# define deflateInit_ z_deflateInit_
# define deflate z_deflate
# define deflateEnd z_deflateEnd
# define inflateInit_ z_inflateInit_
# define inflate z_inflate
# define inflateEnd z_inflateEnd
# define deflateInit2_ z_deflateInit2_
# define deflateSetDictionary z_deflateSetDictionary
# define deflateCopy z_deflateCopy
# define deflateReset z_deflateReset
# define deflatePrime z_deflatePrime
# define deflateParams z_deflateParams
# define deflateBound z_deflateBound
# define inflateInit2_ z_inflateInit2_
# define inflateSetDictionary z_inflateSetDictionary
# define inflateSync z_inflateSync
# define inflateSyncPoint z_inflateSyncPoint
# define inflateCopy z_inflateCopy
# define inflateReset z_inflateReset
# define compress z_compress
# define compress2 z_compress2
# define compressBound z_compressBound
# define uncompress z_uncompress
# define adler32 z_adler32
# define crc32 z_crc32
# define get_crc_table z_get_crc_table
# define Byte z_Byte
# define uInt z_uInt
# define uLong z_uLong
# define Bytef z_Bytef
# define charf z_charf
# define intf z_intf
# define uIntf z_uIntf
# define uLongf z_uLongf
# define voidpf z_voidpf
# define voidp z_voidp
#endif
#if defined(__MSDOS__) && !defined(MSDOS)
# define MSDOS
#endif
#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
# define OS2
#endif
#if defined(_WINDOWS) && !defined(WINDOWS)
# define WINDOWS
#endif
#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
# define WIN32
#endif
#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
# ifndef SYS16BIT
# define SYS16BIT
# endif
# endif
#endif
/*
* Compile with -DMAXSEG_64K if the alloc function cannot allocate more
* than 64k bytes at a time (needed on systems with 16-bit int).
*/
#ifdef SYS16BIT
# define MAXSEG_64K
#endif
#ifdef MSDOS
# define UNALIGNED_OK
#endif
#ifdef __STDC_VERSION__
# ifndef STDC
# define STDC
# endif
# if __STDC_VERSION__ >= 199901L
# ifndef STDC99
# define STDC99
# endif
# endif
#endif
#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
# define STDC
#endif
#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
# define STDC
#endif
#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
# define STDC
#endif
#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
# define STDC
#endif
#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */
# define STDC
#endif
#ifndef STDC
# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
# define const /* note: need a more gentle solution here */
# endif
#endif
/* Some Mac compilers merge all .h files incorrectly: */
#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
# define NO_DUMMY_DECL
#endif
/* Maximum value for memLevel in deflateInit2 */
#ifndef MAX_MEM_LEVEL
# ifdef MAXSEG_64K
# define MAX_MEM_LEVEL 8
# else
# define MAX_MEM_LEVEL 9
# endif
#endif
/* Maximum value for windowBits in deflateInit2 and inflateInit2.
* WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
* created by gzip. (Files created by minigzip can still be extracted by
* gzip.)
*/
#ifndef MAX_WBITS
# define MAX_WBITS 15 /* 32K LZ77 window */
#endif
/* The memory requirements for deflate are (in bytes):
(1 << (windowBits+2)) + (1 << (memLevel+9))
that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
plus a few kilobytes for small objects. For example, if you want to reduce
the default memory requirements from 256K to 128K, compile with
make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
Of course this will generally degrade compression (there's no free lunch).
The memory requirements for inflate are (in bytes) 1 << windowBits
that is, 32K for windowBits=15 (default value) plus a few kilobytes
for small objects.
*/
/* Type declarations */
#ifndef OF /* function prototypes */
# ifdef STDC
# define OF(args) args
# else
# define OF(args) ()
# endif
#endif
/* The following definitions for FAR are needed only for MSDOS mixed
* model programming (small or medium model with some far allocations).
* This was tested only with MSC; for other MSDOS compilers you may have
* to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
* just define FAR to be empty.
*/
#ifdef SYS16BIT
# if defined(M_I86SM) || defined(M_I86MM)
/* MSC small or medium model */
# define SMALL_MEDIUM
# ifdef _MSC_VER
# define FAR _far
# else
# define FAR far
# endif
# endif
# if (defined(__SMALL__) || defined(__MEDIUM__))
/* Turbo C small or medium model */
# define SMALL_MEDIUM
# ifdef __BORLANDC__
# define FAR _far
# else
# define FAR far
# endif
# endif
#endif
#if defined(WINDOWS) || defined(WIN32)
/* If building or using zlib as a DLL, define ZLIB_DLL.
* This is not mandatory, but it offers a little performance increase.
*/
# ifdef ZLIB_DLL
# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
# ifdef ZLIB_INTERNAL
# define ZEXTERN extern __declspec(dllexport)
# else
# define ZEXTERN extern __declspec(dllimport)
# endif
# endif
# endif /* ZLIB_DLL */
/* If building or using zlib with the WINAPI/WINAPIV calling convention,
* define ZLIB_WINAPI.
* Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
*/
# ifdef ZLIB_WINAPI
# ifdef FAR
# undef FAR
# endif
# include <windows.h>
/* No need for _export, use ZLIB.DEF instead. */
/* For complete Windows compatibility, use WINAPI, not __stdcall. */
# define ZEXPORT WINAPI
# ifdef WIN32
# define ZEXPORTVA WINAPIV
# else
# define ZEXPORTVA FAR CDECL
# endif
# endif
#endif
#if defined (__BEOS__)
# ifdef ZLIB_DLL
# ifdef ZLIB_INTERNAL
# define ZEXPORT __declspec(dllexport)
# define ZEXPORTVA __declspec(dllexport)
# else
# define ZEXPORT __declspec(dllimport)
# define ZEXPORTVA __declspec(dllimport)
# endif
# endif
#endif
#ifndef ZEXTERN
# define ZEXTERN extern
#endif
#ifndef ZEXPORT
# define ZEXPORT
#endif
#ifndef ZEXPORTVA
# define ZEXPORTVA
#endif
#ifndef FAR
# define FAR
#endif
#if !defined(__MACTYPES__)
typedef unsigned char Byte; /* 8 bits */
#endif
typedef unsigned int uInt; /* 16 bits or more */
typedef unsigned long uLong; /* 32 bits or more */
#ifdef SMALL_MEDIUM
/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
# define Bytef Byte FAR
#else
typedef Byte FAR Bytef;
#endif
typedef char FAR charf;
typedef int FAR intf;
typedef uInt FAR uIntf;
typedef uLong FAR uLongf;
#ifdef STDC
typedef void const *voidpc;
typedef void FAR *voidpf;
typedef void *voidp;
#else
typedef Byte const *voidpc;
typedef Byte FAR *voidpf;
typedef Byte *voidp;
#endif
#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */
# include <sys/types.h> /* for off_t */
# include <unistd.h> /* for SEEK_* and off_t */
# ifdef VMS
# include <unixio.h> /* for off_t */
# endif
# define z_off_t off_t
#endif
#ifndef SEEK_SET
# define SEEK_SET 0 /* Seek from beginning of file. */
# define SEEK_CUR 1 /* Seek from current position. */
# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
#endif
#ifndef z_off_t
# define z_off_t long
#endif
#if defined(__OS400__)
#define NO_vsnprintf
#endif
#if defined(__MVS__)
# define NO_vsnprintf
# ifdef FAR
# undef FAR
# endif
#endif
/* MVS linker does not support external names larger than 8 bytes */
#if defined(__MVS__)
# pragma map(deflateInit_,"DEIN")
# pragma map(deflateInit2_,"DEIN2")
# pragma map(deflateEnd,"DEEND")
# pragma map(deflateBound,"DEBND")
# pragma map(inflateInit_,"ININ")
# pragma map(inflateInit2_,"ININ2")
# pragma map(inflateEnd,"INEND")
# pragma map(inflateSync,"INSY")
# pragma map(inflateSetDictionary,"INSEDI")
# pragma map(compressBound,"CMBND")
# pragma map(inflate_table,"INTABL")
# pragma map(inflate_fast,"INFA")
# pragma map(inflate_copyright,"INCOPY")
#endif
#endif /* ZCONF_H */

File diff suppressed because it is too large Load Diff

Binary file not shown.

View File

@ -1,38 +0,0 @@
-$A8
-$B-
-$C+
-$D+
-$E-
-$F-
-$G+
-$H+
-$I+
-$J-
-$K-
-$L+
-$M-
-$N+
-$O+
-$P+
-$Q-
-$R-
-$S-
-$T-
-$U-
-$V+
-$W-
-$X+
-$YD
-$Z1
-cg
-AWinTypes=Windows;WinProcs=Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE;
-H+
-W+
-M
-$M16384,1048576
-K$00400000
-LE"..\Bpl"
-LN"..\Bpl"
-w-UNSAFE_TYPE
-w-UNSAFE_CODE
-w-UNSAFE_CAST

View File

@ -1,132 +0,0 @@
[FileVersion]
Version=7.0
[Compiler]
A=8
B=0
C=1
D=1
E=0
F=0
G=1
H=1
I=1
J=0
K=0
L=1
M=0
N=1
O=1
P=1
Q=0
R=0
S=0
T=0
U=0
V=1
W=0
X=1
Y=1
Z=1
ShowHints=1
ShowWarnings=1
UnitAliases=WinTypes=Windows;WinProcs=Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE;
NamespacePrefix=
SymbolDeprecated=1
SymbolLibrary=1
SymbolPlatform=1
UnitLibrary=1
UnitPlatform=1
UnitDeprecated=1
HResultCompat=1
HidingMember=1
HiddenVirtual=1
Garbage=1
BoundsError=1
ZeroNilCompat=1
StringConstTruncated=1
ForLoopVarVarPar=1
TypedConstVarPar=1
AsgToTypedConst=1
CaseLabelRange=1
ForVariable=1
ConstructingAbstract=1
ComparisonFalse=1
ComparisonTrue=1
ComparingSignedUnsigned=1
CombiningSignedUnsigned=1
UnsupportedConstruct=1
FileOpen=1
FileOpenUnitSrc=1
BadGlobalSymbol=1
DuplicateConstructorDestructor=1
InvalidDirective=1
PackageNoLink=1
PackageThreadVar=1
ImplicitImport=1
HPPEMITIgnored=1
NoRetVal=1
UseBeforeDef=1
ForLoopVarUndef=1
UnitNameMismatch=1
NoCFGFileFound=1
MessageDirective=1
ImplicitVariants=1
UnicodeToLocale=1
LocaleToUnicode=1
ImagebaseMultiple=1
SuspiciousTypecast=1
PrivatePropAccessor=1
UnsafeType=0
UnsafeCode=0
UnsafeCast=0
[Linker]
MapFile=0
OutputObjs=0
ConsoleApp=1
DebugInfo=0
RemoteSymbols=0
MinStackSize=16384
MaxStackSize=1048576
ImageBase=4194304
ExeDescription=
[Directories]
OutputDir=
UnitOutputDir=
PackageDLLOutputDir=
PackageDCPOutputDir=
SearchPath=
Packages=
Conditionals=
DebugSourceDirs=
UsePackages=0
[Parameters]
RunParams=
HostApplication=
Launcher=
UseLauncher=0
DebugCWD=
[Version Info]
IncludeVerInfo=0
AutoIncBuild=0
MajorVer=1
MinorVer=0
Release=0
Build=0
Debug=0
PreRelease=0
Special=0
Private=0
DLL=0
Locale=1031
CodePage=1252
[Version Info Keys]
CompanyName=
FileDescription=
FileVersion=1.0.0.0
InternalName=
LegalCopyright=
LegalTrademarks=
OriginalFilename=
ProductName=
ProductVersion=1.0.0.0
Comments=

View File

@ -1,88 +0,0 @@
(* AMX Mod X
* compile.exe
*
* by the AMX Mod X Development Team
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*)
program compile;
{$APPTYPE CONSOLE}
{$R version.res}
{$R icon.res}
uses
SysUtils, Classes,
uFunc in 'uFunc.pas';
var
sr: TSearchRec;
i: Word;
begin
WriteLn('//AMXXSC compile.exe');
WriteLn('// by the AMX Mod X Dev Team');
WriteLn;
if not FileExists(ExtractFilePath(ParamStr(0))+'amxxsc.exe') then
begin
WriteLn('// Could not find amxxsc.exe');
AppExit;
end;
if not DirectoryExists(ExtractFilePath(ParamStr(0))+'compiled') then
CreateDir(ExtractFilePath(ParamStr(0))+'compiled');
if ( ParamCount > 0 ) then
begin
for i := 1 to ParamCount do
begin
if FileExists(ParamStr(i)) then
CompilePlugin(ParamStr(i))
else
begin
WriteLn;
WriteLn('// File not found.');
end;
end;
end
else
begin
if ( FindFirst('*.sma',faAnyFile,sr) = 0 ) then
begin
repeat
CompilePlugin(sr.Name);
until ( FindNext(sr) <> 0 );
end
else
begin
WriteLn('// No file found.');
end;
FindClose(sr);
end;
AppExit;
end.

Binary file not shown.

Before

Width:  |  Height:  |  Size: 766 B

View File

@ -1 +0,0 @@
AMXX ICON "favicon.ico"

View File

@ -1,201 +0,0 @@
(* AMX Mod X
* compile.exe
*
* by the AMX Mod X Development Team
*
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* 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, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* In addition, as a special exception, the author gives permission to
* link the code of this program with the Half-Life Game Engine ("HL
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
* L.L.C ("Valve"). You must obey the GNU General Public License in all
* respects for all of the code used other than the HL Engine and MODs
* from Valve. If you modify this file, you may extend this exception
* to your version of the file, but you are not obligated to do so. If
* you do not wish to do so, delete this exception statement from your
* version.
*)
unit uFunc;
interface
uses
Windows, SysUtils, Classes, Math, IniFiles;
procedure AppExit;
procedure CompilePlugin(const Name: String);
function GetAgeFromDat(const FileName: String): Integer;
procedure SetAgeToDat(const FileName: String; const Age: Integer);
function GetConsoleOutput(const Command: String; var Output: TStringList): Boolean;
implementation
procedure AppExit;
begin
WriteLn;
Write('Press enter to exit ...');
ReadLn;
Halt;
end;
procedure CompilePlugin(const Name: String);
var
Output: TStringList;
i: Word;
cStart,cEnd: Longword;
FileName, FilePath, Compiled: String;
begin
FileName := ExtractFileName(Name);
FilePath := ExtractFilePath(Name);
Compiled := FilePath+'compiled\'+ChangeFileExt(Filename,'.amxx');
if (FilePath='') then
FilePath := ExtractFilePath(ParamStr(0));
WriteLn;
WriteLn('//// '+ExtractFileName(FileName));
if FileExists(Compiled) and ( GetAgeFromDat(FileName)=FileAge(Name) ) then
begin
WriteLn('// Already compiled.');
WriteLn('// ----------------------------------------');
Exit;
end;
Output := TStringList.Create;
try
cStart := GetTickCount;
if not GetConsoleOutput(ExtractFilePath(ParamStr(0))+'amxxsc.exe "'+FilePath+FileName+'" "-o'+Compiled+'"',Output) then
begin
WriteLn('// Internal error.');
AppExit;
end;
cEnd := GetTickCount;
for i := 3 to (Output.Count-1) do
begin
WriteLn('// '+Output.Strings[i]);
end;
WriteLn('//');
WriteLn('// Compilation Time: '+FloatToStr(SimpleRoundTo((cEnd-cStart) / 1000,-2))+' sec');
WriteLn('// ----------------------------------------');
Output.Free;
except
WriteLn('// Internal error.');
AppExit;
end;
SetAgeToDat(FileName,FileAge(Name));
end;
function GetAgeFromDat(const FileName: String): Integer;
var
Ini: TIniFile;
begin
Ini := TIniFile.Create(ExtractFilePath(ParamStr(0))+'compile.dat');
Result := Ini.ReadInteger(FileName,'Age',-1);
Ini.Free;
end;
procedure SetAgeToDat(const FileName: String; const Age: Integer);
var
Ini: TIniFile;
begin
Ini := TIniFile.Create(ExtractFilePath(ParamStr(0))+'compile.dat');
Ini.WriteInteger(FileName,'Age',Age);
Ini.UpdateFile;
Ini.Free;
end;
function GetConsoleOutput(const Command: String; var Output: TStringList): Boolean;
var
StartupInfo: TStartupInfo;
ProcessInfo: TProcessInformation;
SecurityAttr: TSecurityAttributes;
PipeOutputRead: THandle;
PipeOutputWrite: THandle;
PipeErrorsRead: THandle;
PipeErrorsWrite: THandle;
Succeed: Boolean;
Buffer: array [0..255] of Char;
NumberOfBytesRead: DWORD;
Stream: TMemoryStream;
begin
FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);
FillChar(SecurityAttr, SizeOf(TSecurityAttributes), 0);
SecurityAttr.nLength := SizeOf(SecurityAttr);
SecurityAttr.bInheritHandle := True;
SecurityAttr.lpSecurityDescriptor := nil;
CreatePipe(PipeOutputRead, PipeOutputWrite, @SecurityAttr, 0);
CreatePipe(PipeErrorsRead, PipeErrorsWrite, @SecurityAttr, 0);
FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
StartupInfo.cb:=SizeOf(StartupInfo);
StartupInfo.hStdInput := 0;
StartupInfo.hStdOutput := PipeOutputWrite;
StartupInfo.hStdError := PipeErrorsWrite;
StartupInfo.wShowWindow := SW_HIDE;
StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;
if CreateProcess(nil, PChar(command), nil, nil, true,
CREATE_DEFAULT_ERROR_MODE or CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, nil,
StartupInfo, ProcessInfo) then begin
Result := True;
CloseHandle(PipeOutputWrite);
CloseHandle(PipeErrorsWrite);
Stream := TMemoryStream.Create;
try
while True do begin
Succeed := ReadFile(PipeOutputRead, Buffer, 255, NumberOfBytesRead, nil);
if not Succeed then Break;
Stream.Write(Buffer, NumberOfBytesRead);
end;
Stream.Position := 0;
Output.LoadFromStream(Stream);
finally
Stream.Free;
end;
CloseHandle(PipeOutputRead);
try
while True do
begin
Succeed := ReadFile(PipeErrorsRead, Buffer, 255, NumberOfBytesRead, nil);
if not Succeed then Break;
end;
finally
end;
CloseHandle(PipeErrorsRead);
WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
CloseHandle(ProcessInfo.hProcess);
end
else
begin
Result := False;
CloseHandle(PipeOutputRead);
CloseHandle(PipeOutputWrite);
CloseHandle(PipeErrorsRead);
CloseHandle(PipeErrorsWrite);
end;
end;
end.

View File

@ -1,33 +0,0 @@
VS_VERSION_INFO VERSIONINFO
FILEVERSION 0,2,0,0
PRODUCTVERSION 0,2,0,0
FILEOS VOS__WINDOWS32
FILETYPE VFT_APP // VFT_APP VFT_DLL
//FILEFLGAGS:
// VS_FF_DEBUG VS_FF_PRERELEASE VS_FF_PATCHED VS_FF_PRIVATEBUILD VS_FF_INFOINFERRED VS_FF_SPECIALBUILD
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904b0"
BEGIN
VALUE "Comments", "AMXXSC compile.exe\0"
//VALUE "CompanyName", "AMXX Development Team\0"
VALUE "FileDescription", "AMXXSC compile.exe\0"
VALUE "FileVersion", "0.20\0"
VALUE "InternalName", "AMXXSC compile.exe\0"
VALUE "LegalCopyright", "(c) 2004, AMXX Development Team\0"
//VALUE "LegalTrademarks", "\0"
VALUE "OriginalFilename", "compile.exe\0"
//VALUE "PrivateBuild", "\0"
VALUE "ProductName", "AMXXSC compile.exe\0"
VALUE "ProductVersion", "0.20\0"
//VALUE "SpecialBuild", "\0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", LANG_ENGLISH SUBLANG_ENGLISH_US
END
END

View File

@ -1,14 +0,0 @@
CPPFILES = amxasm.cpp cexpr.cpp amx_symbol.cpp amx_proc.cpp \
amx_parser.cpp amx_natives.cpp amx_macro.cpp amx_label.cpp \
amx_error.cpp amx_define.cpp amx_data.cpp amx_compiler.cpp
FLAGS = -march=i386
all: sasm
sasm:
g++ $(FLAGS) -Wall $(CPPFILES) -o sasm -s
clean:
-rm *.o
-rm sasm

View File

@ -1,176 +0,0 @@
#!/usr/bin/perl
#(C)2004 AMX Mod X Development Team
# by David "BAILOPAN" Anderson
# output will occur in bin.x.proc
# where x is debug or opt and proc is ix86 or amd64
# You must use this script from the project src dir
#options =
# debug - enable gdb debugging
# amd64 - compile for AMD64
# proc=ix86 - assumed not amd64
# clean - clean the specifications above
$PROJECT = "sasm";
$gccf = "gcc";
@CPP_SOURCE_FILES = ("amx_compiler.cpp", "amx_data.cpp", "amx_define.cpp", "amx_error.cpp", "amx_label.cpp", "amx_macro.cpp", "amx_natives.cpp", "amx_proc.cpp", "amx_parser.cpp", "amx_symbol.cpp", "amxasm.cpp", "cexpr.cpp");
@C_SOURCE_FILES = ();
my %OPTIONS, %OPT;
$OPT{"debug"} = "-g -ggdb";
$OPT{"opt"} = "-O2 -ffast-math -funroll-loops -fomit-frame-pointer -s -DNDEBUG -Wall -Wno-unknown-pragmas -DOPT_TYPE=\"optimized\"";
$OPTIONS{"include"} = "";
while ($cmd = shift)
{
if ($cmd =~ /amd64/) {
$OPTIONS{"amd64"} = 1;
} elsif ($cmd =~ /debug/) {
$OPTIONS{"debug"} = 1;
} elsif ($cmd =~ /proc=i(\d)86/) {
$proc = $1;
if ($OPTIONS{"amd64"})
{
die "You cannot compile for i".$proc."86 and AMD64.\n";
} else {
$OPTIONS{"proc"} = "i".$proc."86";
}
} elsif ($cmd =~ /clean/) {
$OPTIONS{"clean"} = 1;
}
}
$gcc = `$gccf --version`;
if ($gcc =~ /2\.9/)
{
$OPT{"opt"} .= " -malign-loops=2 -malign-jumps=2 -malign-functions=2";
} else {
$OPT{"opt"} .= " -falign-loops=2 -falign-jumps=2 -falign-functions=2";
}
if ($OPTIONS{"debug"})
{
$cflags = $OPT{"debug"};
} else {
if (!$OPTIONS{"amd64"})
{
$proc = $OPTIONS{"proc"};
if (!$proc)
{
$proc = 3;
}
$cflags = "-march=i".$proc."86 ".$OPT{"opt"};
} else {
$cflags = $OPT{"opt"};
}
}
if ($OPTIONS{"amd64"})
{
$cflags .= " -m64 -DHAVE_I64 -DSMALL_CELL_SIZE=64 $cflags";
}
if ($OPTIONS{"debug"})
{
$outdir = "bin.debug";
} else {
$outdir = "bin.opt";
}
if ($OPTIONS{"amd64"})
{
$outdir .= ".amd64";
$bin = $PROJECT."_amd64.so";
} else {
$proc = $OPTIONS{"proc"};
if ($proc)
{
$outdir .= ".i".$proc."86";
$bin = $PROJECT."_i".$proc."86.so";
} else {
$outdir .= ".i386";
$bin = $PROJECT."_i386.so";
}
}
unlink("$outdir/$bin");
if ($OPTIONS{"clean"})
{
`rm $outdir/*.o`;
die("Project cleaned.\n");
}
#create the dirs
#build link list
my @LINK;
for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
{
$file = $CPP_SOURCE_FILES[$i];
$file =~ s/\.cpp/\.o/;
push(@LINK, $outdir."/".$file);
}
for ($i=0; $i<=$#C_SOURCE_FILES; $i++)
{
$file = $C_SOURCE_FILES[$i];
$file =~ s/\.c/\.o/;
push(@LINK, $outdir."/".$file);
}
if (!(-d $outdir))
{
mkdir($outdir);
}
$inc = $OPTIONS{"include"};
for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
{
$file = $CPP_SOURCE_FILES[$i];
$ofile = $file;
$ofile =~ s/\.cpp/\.o/;
$ofile = "$outdir/$ofile";
$gcc = "$gccf $cflags -Dstrcmpi=strcasecmp -fPIC $inc -c $file -o $ofile";
if (-e $ofile)
{
$file_time = (stat($file))[9];
$ofile_time = (stat($ofile))[9];
if ($file_time > $ofile_time)
{
print "$gcc\n";
`$gcc`;
}
} else {
print "$gcc\n";
`$gcc`;
}
}
for ($i=0; $i<=$#CPP_SOURCE_FILES; $i++)
{
$file = $C_SOURCE_FILES[$i];
$ofile = $file;
$ofile =~ s/\.c/\.o/;
$ofile = "$outdir/$ofile";
$gcc = "cc $cflags -Dstrcmpi=strcasecmp -fPIC $inc -c $file -o $ofile";
if (-e $ofile)
{
$file_time = (stat($file))[9];
$ofile_time = (stat($file))[9];
if ($file_time > $ofile_time)
{
print "$gcc\n";
`$gcc`;
}
} else {
print "$gcc\n";
`$gcc`;
}
}
$gcc = "$gccf $cflags -shared -lstdc++ -ldl -lm @LINK -o $outdir/$bin";
print "$gcc\n";
`$gcc`;

View File

@ -1,240 +0,0 @@
;(C)2004 David "BAILOPAN" Anderson
; Assembler version of Anti-Flood
#define VERSION "0.20-A"
#define PLUGIN_HANDLED
#macro ARGN(argc) (12+(argc*CELL))
.CODE
halt 0 ;Return point for end
.NATIVE
register_plugin
register_cvar
random_num
register_clcmd
server_cmd
get_maxplayers
get_playersnum
get_cvar_num
set_cvar_num
get_user_flags
client_cmd
get_user_userid
.DATA
Plugin db "Slots Reservation"
Version db VERSION
Author db "AMXX Dev Team"
Cvar db "amx_reservation"
CvarVal db "1"
Callback db "ackSignal"
loopBack db "amxres0000"
.CODE
PROC plugin_init
push.c Author ;push author
push.c Version ;push version
push.c Plugin ;push name
push.c CELL*3 ;push 3 args
sysreq.c register_plugin ;call register_plugin
stack CELL*4 ;clean-up
push.c CvarVal ;push Cvar initial value
push.c Cvar ;push Cvar
push.c CELL*2 ;push 2 args
sysreq.c register_cvar ;call register_cvar
stack CELL*3 ;clean-up
push.c 90 ;push max range
push.c 65 ;push min range
push.c CELL*2 ;push 2 args
sysreq.c random_num ;call random_num
stack CELL*3 ;clean-up
stor.pri loopBack+CELL*6 ;store pri in loopBack[6]
push.c 90 ;push max range
push.c 65 ;push min range
push.c CELL*2 ;push 2 args
sysreq.c random_num ;call random_num
stack CELL*3 ;clean-up
stor.pri loopBack+CELL*7 ;store pri in loopBack[7]
push.c 90 ;push max range
push.c 65 ;push min range
push.c CELL*2 ;push 2 args
sysreq.c random_num ;call random_num
stack CELL*3 ;clean-up
stor.pri loopBack+CELL*8 ;store pri in loopBack[8]
push.c 90 ;push max range
push.c 65 ;push min range
push.c CELL*2 ;push 2 args
sysreq.c random_num ;call random_num
stack CELL*3 ;clean-up
stor.pri loopBack+CELL*9 ;store pri in loopBack[9]
push.c Callback ;push callback
push.c loopBack ;push loopback
push.c CELL*2
sysreq.c register_clcmd ;call register_clcmd
stack CELL*3 ;clean-up
zero.pri ;return 0
retn ;final cleanup
ENDP
.DATA
KickMsg db "kick #%d \"Dropped due to slot reservation\""
.CODE
PROC ackSignal
push.s ARGN(0) ;push the first argument
push.c CELL*1 ;push one argument
sysreq.c get_user_userid ;call get_user_userid
stack CELL*2 ;clean-up
push.pri ;push the result of the last call
push.c KickMsg ;push the kick message
push.c CELL*2 ;push 2 args
sysreq.c server_cmd ;call server_cmd
stack CELL*3 ;clean-up
zero.pri ;return 0
retn ;final cleanup
ENDP
.DATA
VisCvar db "sv_visiblemaxplayers"
.CODE
;players, maxplayrs, limit
PROC setVisibleSlots
stack -CELL ;new variable
load.s.pri ARGN(0) ;get first parameter into [PRI]
add.c 1 ;[PRI] += 1
stor.s.pri -CELL ;[var] = [PRI]
load.s.pri ARGN(0) ;Reset [PRI] to first param
load.s.alt ARGN(1) ;get second parameter into [ALT]
jeq setMax ;does players == maxplayers?
jump setLimitCheck ; -- no, jump to next check
setMax: ; -- yes
stor.s.alt -CELL ; store the maxplayers into [var]
jump endSetIf ; we're done, jump to the end
setLimitCheck:
load.s.alt ARGN(2) ;load the third param into [ALT]
jless setLimit ;is playres < limit?
jump endSetIf ; -- no, jump to end
setLimit: ; -- yes
stor.s.alt -CELL ;store limit into [var]
endSetIf:
push.s -CELL ;push [var] onto stack
push.c VisCvar ;push cvar onto stack
push.c CELL*2 ;push 2 args
sysreq.c set_cvar_num ;call set_cvar_num
stack CELL*3 ;clean-up
stack CELL ;restore stack
zero.pri ;return 0
retn ;final cleanup
ENDP
PROC client_authorized
push.c 0 ;push 0 args
sysreq.c get_maxplayers ;call get_maxplayers
stack CELL ;clean-up
push.pri ;store the result - maxplayers
push.c 1 ;push 1
push.c CELL ;push 1 args
sysreq.c get_playersnum ;call get_playersnum
stack CELL*2 ;clean-up
push.pri ;store the result - players
push.c Cvar ;push cvar
push.c CELL ;push 1 arg
sysreq.c get_cvar_num ;call get_cvar_num
stack CELL*2 ;clean-up
xchg ;last result is now in alt
load.s.pri -CELL ;load the first result into pri
sub ;pri = maxplayers - cvar
push.pri ;store the result - limit
push.s ARGN(0) ;push the id
push.c CELL ;push 1 arg
sysreq.c get_user_flags ;call get_user_flags
stack CELL*2 ;clean-up
const.alt 2 ;2 = ADMIN_RESERVATION
and ;flags & 2
jeq setVis ;if (flags & 2) == 2, short circuit
;otherwise check this condition
load.s.pri -CELL*2 ;load players into pri
load.s.alt -CELL*3 ;load limit into alt
jleq setVis ;if players <= limit, jump
jump setVisSkip ;otherwise skip
setVis:
push.s -CELL*3 ;push limit
push.s -CELL ;push maxplayers
push.s -CELL*2 ;push players
push.c CELL*3 ;push 3 args
call setVisibleSlots ;call setVisibleSlots
stack CELL*3 ;restore stack
zero.pri ;return 0
retn ;finalize
setVisSkip:
push.c loopBack ;push loopback cmd
push.s ARGN(0) ;push the id passed
push.c CELL*2 ;push 2 args
sysreq.c client_cmd ;call client_cmd
stack CELL*3 ;clean-up
stack CELL*3 ;restore stack
const.pri PLUGIN_HANDLED ;return
retn ;finalize
ENDP
PROC client_disconnect
push.c 0 ;push 0 args
sysreq.c get_maxplayers ;call get_maxplayers
stack CELL ;clean-up
push.pri ;store the result - maxplayers
push.c 1 ;push 1
push.c CELL ;push 1 args
sysreq.c get_playersnum ;call get_playersnum
stack CELL*2 ;clean-up
push.pri ;store the result - players
dec.s -CELL*2 ;players--
push.c Cvar ;push cvar
push.c CELL ;push 1 arg
sysreq.c get_cvar_num ;call get_cvar_num
stack CELL*2 ;clean-up
xchg ;last result is now in alt
load.s.pri -CELL ;[pri] = maxplayers
sub ;[pri] = maxplayers - cvar
push.pri ;store the result - limit
push.s -CELL*3 ;push limit
push.s -CELL ;push maxplayers
push.s -CELL*2 ;push playersnum-1
push.c CELL*3 ;push 3 args
call setVisibleSlots ;call
stack 3*CELL ;clean up 3 vars
zero.pri ;return 0
retn ;finalize
ENDP
.PUBLIC
ackSignal
plugin_init
client_authorized
client_disconnect

View File

@ -1,383 +0,0 @@
/* Abstract Machine for the Small compiler
*
* Copyright (c) ITB CompuPhase, 1997-2004
*
* This software is provided "as-is", without any express or implied warranty.
* In no event will the authors be held liable for any damages arising from
* the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software in
* a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#if defined LINUX
#include <sclinux.h>
#endif
#ifndef AMX_H_INCLUDED
#define AMX_H_INCLUDED
#if defined __LCC__ || defined __DMC__ || defined LINUX
#include <stdint.h>
#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
/* The ISO C99 defines the int16_t and int_32t types. If the compiler got
* here, these types are probably undefined.
*/
#if defined __FreeBSD__
#include <inttypes.h>
#else
typedef short int int16_t;
typedef unsigned short int uint16_t;
#if defined SN_TARGET_PS2
typedef int int32_t;
typedef unsigned int uint32_t;
#else
typedef long int int32_t;
typedef unsigned long int uint32_t;
#endif
#if defined __WIN32__ || defined _WIN32 || defined WIN32
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#define HAVE_I64
#elif defined __GNUC__
typedef long long int64_t;
typedef unsigned long long uint64_t;
#define HAVE_I64
#endif
#endif
#endif
#if defined __WIN32__ || defined _WIN32 || defined WIN32 /* || defined __MSDOS__ */
#if !defined alloca
#define alloca(n) _alloca(n)
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* calling convention for native functions */
#if !defined AMX_NATIVE_CALL
#define AMX_NATIVE_CALL
#endif
/* calling convention for all interface functions and callback functions */
#if !defined AMXAPI
#if defined STDECL
#define AMXAPI __stdcall
#elif defined CDECL
#define AMXAPI __cdecl
#else
#define AMXAPI
#endif
#endif
#if !defined AMXEXPORT
#define AMXEXPORT
#endif
/* File format version Required AMX version
* 0 (original version) 0
* 1 (opcodes JUMP.pri, SWITCH and CASETBL) 1
* 2 (compressed files) 2
* 3 (public variables) 2
* 4 (opcodes SWAP.pri/alt and PUSHADDR) 4
* 5 (tagnames table) 4
* 6 (reformatted header) 6
* 7 (name table, opcodes SYMTAG & SYSREQ.D) 7
*/
#define CUR_FILE_VERSION 7 /* current file version; also the current AMX version */
#define MIN_FILE_VERSION 6 /* lowest supported file format version for the current AMX version */
#define MIN_AMX_VERSION 7 /* minimum AMX version needed to support the current file format */
#if defined BIT16
#define SMALL_CELL_SIZE 16 /* for backward compatibility */
#endif
#if !defined SMALL_CELL_SIZE
#define SMALL_CELL_SIZE 32 /* by default, use 32-bit cells */
#endif
#if SMALL_CELL_SIZE==16
typedef uint16_t ucell;
typedef int16_t cell;
#elif SMALL_CELL_SIZE==32
typedef uint32_t ucell;
typedef int32_t cell;
#elif SMALL_CELL_SIZE==64
typedef uint64_t ucell;
typedef int64_t cell;
#else
#error Unsupported cell size (SMALL_CELL_SIZE)
#endif
#define UNPACKEDMAX ((1 << (sizeof(cell)-1)*8) - 1)
struct tagAMX;
typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params);
typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index,
cell *result, cell *params);
typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
#if !defined _FAR
#define _FAR
#endif
#if defined _MSC_VER
#pragma warning(disable:4103) /* disable warning message 4103 that complains
* about pragma pack in a header file */
#pragma warning(disable:4100) /* "'%$S' : unreferenced formal parameter" */
#endif
/* Some compilers do not support the #pragma align, which should be fine. Some
* compilers give a warning on unknown #pragmas, which is not so fine...
*/
#if defined SN_TARGET_PS2 || defined __GNUC__
#define AMX_NO_ALIGN
#endif
#if defined __GNUC__
#define PACKED __attribute__((packed))
#else
#define PACKED
#endif
#if !defined AMX_NO_ALIGN
#if defined LINUX
#pragma pack(1) /* structures must be packed (byte-aligned) */
#else
#pragma pack(push)
#pragma pack(1) /* structures must be packed (byte-aligned) */
#if defined __TURBOC__
#pragma option -a- /* "pack" pragma for older Borland compilers */
#endif
#endif
#endif
typedef struct {
const char _FAR *name PACKED;
AMX_NATIVE func PACKED;
} AMX_NATIVE_INFO PACKED;
#define AMX_USERNUM 4
#define sEXPMAX 19 /* maximum name length for file version <= 6 */
#define sNAMEMAX 31 /* maximum name length of symbol name */
typedef struct tagAMX_FUNCSTUB {
uint32_t address PACKED;
char name[sEXPMAX+1] PACKED;
} AMX_FUNCSTUB PACKED;
/* The AMX structure is the internal structure for many functions. Not all
* fields are valid at all times; many fields are cached in local variables.
*/
typedef struct tagAMX {
unsigned char _FAR *base PACKED; /* points to the AMX header ("amxhdr") plus the code, optionally also the data */
unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */
AMX_CALLBACK callback PACKED;
AMX_DEBUG debug PACKED; /* debug callback */
/* for external functions a few registers must be accessible from the outside */
cell cip PACKED; /* instruction pointer: relative to base + amxhdr->cod */
cell frm PACKED; /* stack frame base: relative to base + amxhdr->dat */
cell hea PACKED; /* top of the heap: relative to base + amxhdr->dat */
cell hlw PACKED; /* bottom of the heap: relative to base + amxhdr->dat */
cell stk PACKED; /* stack pointer: relative to base + amxhdr->dat */
cell stp PACKED; /* top of the stack: relative to base + amxhdr->dat */
int flags PACKED; /* current status, see amx_Flags() */
/* for assertions and debug hook */
cell curline PACKED;
cell curfile PACKED;
int dbgcode PACKED;
cell dbgaddr PACKED;
cell dbgparam PACKED;
char _FAR *dbgname PACKED;
/* user data */
long usertags[AMX_USERNUM] PACKED;
void _FAR *userdata[AMX_USERNUM] PACKED;
/* native functions can raise an error */
int error PACKED;
/* the sleep opcode needs to store the full AMX status */
cell pri PACKED;
cell alt PACKED;
cell reset_stk PACKED;
cell reset_hea PACKED;
cell sysreq_d PACKED; /* relocated address/value for the SYSREQ.D opcode */
#if defined JIT
/* support variables for the JIT */
int reloc_size PACKED; /* required temporary buffer for relocations */
long code_size PACKED; /* estimated memory footprint of the native code */
#endif
} AMX PACKED;
/* The AMX_HEADER structure is both the memory format as the file format. The
* structure is used internaly.
*/
typedef struct tagAMX_HEADER {
int32_t size PACKED; /* size of the "file" */
uint16_t magic PACKED; /* signature */
char file_version PACKED; /* file format version */
char amx_version PACKED; /* required version of the AMX */
int16_t flags PACKED;
int16_t defsize PACKED; /* size of a definition record */
int32_t cod PACKED; /* initial value of COD - code block */
int32_t dat PACKED; /* initial value of DAT - data block */
int32_t hea PACKED; /* initial value of HEA - start of the heap */
int32_t stp PACKED; /* initial value of STP - stack top */
int32_t cip PACKED; /* initial value of CIP - the instruction pointer */
int32_t publics PACKED; /* offset to the "public functions" table */
int32_t natives PACKED; /* offset to the "native functions" table */
int32_t libraries PACKED; /* offset to the table of libraries */
int32_t pubvars PACKED; /* the "public variables" table */
int32_t tags PACKED; /* the "public tagnames" table */
int32_t nametable PACKED; /* name table, file version 7 only */
} AMX_HEADER PACKED;
#define AMX_MAGIC 0xf1e0
enum {
AMX_ERR_NONE,
/* reserve the first 15 error codes for exit codes of the abstract machine */
AMX_ERR_EXIT, /* forced exit */
AMX_ERR_ASSERT, /* assertion failed */
AMX_ERR_STACKERR, /* stack/heap collision */
AMX_ERR_BOUNDS, /* index out of bounds */
AMX_ERR_MEMACCESS, /* invalid memory access */
AMX_ERR_INVINSTR, /* invalid instruction */
AMX_ERR_STACKLOW, /* stack underflow */
AMX_ERR_HEAPLOW, /* heap underflow */
AMX_ERR_CALLBACK, /* no callback, or invalid callback */
AMX_ERR_NATIVE, /* native function failed */
AMX_ERR_DIVIDE, /* divide by zero */
AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */
AMX_ERR_MEMORY = 16, /* out of memory */
AMX_ERR_FORMAT, /* invalid file format */
AMX_ERR_VERSION, /* file is for a newer version of the AMX */
AMX_ERR_NOTFOUND, /* function not found */
AMX_ERR_INDEX, /* invalid index parameter (bad entry point) */
AMX_ERR_DEBUG, /* debugger cannot run */
AMX_ERR_INIT, /* AMX not initialized (or doubly initialized) */
AMX_ERR_USERDATA, /* unable to set user data field (table full) */
AMX_ERR_INIT_JIT, /* cannot initialize the JIT */
AMX_ERR_PARAMS, /* parameter error */
AMX_ERR_DOMAIN, /* domain error, expression result does not fit in range */
};
enum {
DBG_INIT, /* query/initialize */
DBG_FILE, /* file number in curfile, filename in name */
DBG_LINE, /* line number in curline, file number in curfile */
DBG_SYMBOL, /* address in dbgaddr, class/type in dbgparam */
DBG_CLRSYM, /* stack address below which locals should be removed. stack address in stk */
DBG_CALL, /* function call, address jumped to in dbgaddr */
DBG_RETURN, /* function returns */
DBG_TERMINATE, /* program ends, code address in dbgaddr, reason in dbgparam */
DBG_SRANGE, /* symbol size and dimensions (arrays); level in dbgaddr (!); length in dbgparam */
DBG_SYMTAG, /* tag of the most recent symbol (if non-zero), tag in dbgparam */
};
/* AMX_FLAG_CHAR16 0x01 no longer used */
#define AMX_FLAG_DEBUG 0x02 /* symbolic info. available */
#define AMX_FLAG_COMPACT 0x04 /* compact encoding */
#define AMX_FLAG_BIGENDIAN 0x08 /* big endian encoding */
#define AMX_FLAG_NOCHECKS 0x10 /* no array bounds checking */
#define AMX_FLAG_BROWSE 0x4000 /* browsing/relocating or executing */
#define AMX_FLAG_RELOC 0x8000 /* jump/call addresses relocated */
#define AMX_EXEC_MAIN -1 /* start at program entry point */
#define AMX_EXEC_CONT -2 /* continue from last address */
#define AMX_USERTAG(a,b,c,d) ((a) | ((b)<<8) | ((long)(c)<<16) | ((long)(d)<<24))
#define AMX_EXPANDMARGIN 64
/* for native functions that use floating point parameters, the following
* two macros are convenient for casting a "cell" into a "float" type _without_
* changing the bit pattern
*/
#if SMALL_CELL_SIZE==32
#define amx_ftoc(f) ( * ((cell*)&f) ) /* float to cell */
#define amx_ctof(c) ( * ((float*)&c) ) /* cell to float */
#elif SMALL_CELL_SIZE==64
#define amx_ftoc(f) ( * ((cell*)&f) ) /* float to cell */
#define amx_ctof(c) ( * ((double*)&c) ) /* cell to float */
#else
#error Unsupported cell size
#endif
#define amx_StrParam(amx,param,result) \
do { \
cell *amx_cstr_; int amx_length_; \
amx_GetAddr((amx), (param), &amx_cstr_); \
amx_StrLen(amx_cstr_, &amx_length_); \
if (amx_length_ > 0 && \
((result) = (void*)alloca((amx_length_ + 1) * sizeof(*(result)))) != NULL) \
amx_GetString((char*)(result), amx_cstr_, sizeof(*(result))>1); \
else (result) = NULL; \
} while (0)
uint16_t * AMXAPI amx_Align16(uint16_t *v);
uint32_t * AMXAPI amx_Align32(uint32_t *v);
#if defined _I64_MAX || defined HAVE_I64
uint64_t * AMXAPI amx_Align64(uint64_t *v);
#endif
int AMXAPI amx_Allot(AMX *amx, int cells, cell *amx_addr, cell **phys_addr);
int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params);
int AMXAPI amx_Cleanup(AMX *amx);
int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data);
int AMXAPI amx_Debug(AMX *amx); /* default debug procedure, does nothing */
int AMXAPI amx_Exec(AMX *amx, cell *retval, int index, int numparams, ...);
int AMXAPI amx_Execv(AMX *amx, cell *retval, int index, int numparams, cell params[]);
int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index);
int AMXAPI amx_FindPublic(AMX *amx, const char *funcname, int *index);
int AMXAPI amx_FindPubVar(AMX *amx, const char *varname, cell *amx_addr);
int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname);
int AMXAPI amx_Flags(AMX *amx,uint16_t *flags);
int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr);
int AMXAPI amx_GetNative(AMX *amx, int index, char *funcname);
int AMXAPI amx_GetPublic(AMX *amx, int index, char *funcname);
int AMXAPI amx_GetPubVar(AMX *amx, int index, char *varname, cell *amx_addr);
int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar);
int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id);
int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr);
int AMXAPI amx_Init(AMX *amx, void *program);
int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code);
int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap);
int AMXAPI amx_NameLength(AMX *amx, int *length);
AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name,AMX_NATIVE func);
int AMXAPI amx_NumNatives(AMX *amx, int *number);
int AMXAPI amx_NumPublics(AMX *amx, int *number);
int AMXAPI amx_NumPubVars(AMX *amx, int *number);
int AMXAPI amx_NumTags(AMX *amx, int *number);
int AMXAPI amx_RaiseError(AMX *amx, int error);
int AMXAPI amx_Register(AMX *amx, AMX_NATIVE_INFO *nativelist, int number);
int AMXAPI amx_Release(AMX *amx, cell amx_addr);
int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback);
int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug);
int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar);
int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr);
int AMXAPI amx_StrLen(cell *cstring, int *length);
int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value);
int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value);
int AMXAPI amx_UTF8Check(const char *string);
#if !defined AMX_NO_ALIGN
#if defined LINUX
#pragma pack() /* reset default packing */
#else
#pragma pack(pop) /* reset previous packing */
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif /* AMX_H_INCLUDED */

File diff suppressed because it is too large Load Diff

View File

@ -1,110 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#ifndef _INCLUDE_AMXCOMPILER_H
#define _INCLUDE_AMXCOMPILER_H
#define CHK_PARAMS(d) \
if (paramList.size() > d) \
{ \
CError->ErrorMsg(Warning_Param_Count, paramList.size(), d); \
} else if (paramList.size() < d) { \
CError->ErrorMsg(Err_Param_Count, paramList.size(), d); \
delete ASM; \
ASM = 0; \
}
#define PUSH_PARAM(n,sym) \
if (paramList.size() >= n) \
{ \
ASM->params.push_back(Eval(*(paramList[n-1]), sym)); \
lastCip+=cellsize; \
}
class rpn
{
public:
~rpn();
//TODO: use linked lists, but not std::list
std::vector<char> ops;
std::vector<CExpr> vals;
};
class Compiler
{
public:
Compiler();
~Compiler();
Compiler(std::string &f);
void Load(std::string &f);
bool Parse();
bool Compile(std::string &out);
int CurLine() { return curLine; }
ErrorMngr *ErrorHandler() { return CError; }
void PrintCodeList();
public:
int FindArguments(std::string &text, std::vector<std::string*> &List, int &end, bool simple = false);
void Clear();
int CipCount();
int CurCip() { return lastCip; }
Asm *CurAsm() { return curAsm; }
bool SetDebug();
bool SetPack();
bool SetDOpt();
int DerefSymbol(std::string &str, SymbolType sym = Sym_None);
bool IsSymbol(std::string &str);
private:
void ProcessDirective(std::string &text);
void Init();
void InitOpcodes();
int Eval(std::string &str, SymbolType sym = Sym_None);
CExpr EvalE(std::string &str, SymbolType sym = Sym_None);
CExpr EvalRpn(rpn *r, SymbolType sym);
OpToken OperToken(char c);
char OperChar(OpToken c);
void WriteCell(FILE *fp, ucell *c, int repeat);
private:
std::vector<Asm *> CodeList;
std::map<std::string,int> OpCodes;
std::stack<std::string> LabelStack;
char *Output;
ErrorMngr *CError;
SymbolList *CSymbols;
DefineMngr *CDefines;
MacroList *CMacros;
DataMngr *DAT;
ProcMngr *PROC;
LabelMngr *CLabels;
NativeMngr *CNatives;
std::string filename;
int curLine;
int lastCip;
int cellsize;
int stacksize;
bool debug;
bool pack;
bool dopt;
int bitsOut;
Asm *curAsm;
};
#endif //_INCLUDE_AMXCOMPILER_H

View File

@ -1,196 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#include "amxasm.h"
DataMngr::~DataMngr()
{
Clear();
}
void DataMngr::Clear()
{
std::vector<DataMngr::Datum *>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
if ( (*i) )
delete (*i);
}
List.clear();
}
DataMngr::Datum::Datum()
{
db = false;
offset = -1;
fill = 0;
zeroed = false;
}
void DataMngr::Add(std::string &s, CExpr &expr, bool db, int fill)
{
DataMngr::Datum *D = new DataMngr::Datum();
D->symbol.assign(s);
D->e = expr;
D->fill = fill;
D->db = db;
int size = 0;
if (db)
{
size = ((D->e.GetType() == Val_Number) ?
cellsize : D->e.Size() * cellsize);
} else {
size = (D->e.GetNumber() * cellsize);
}
if (List.size() == 0)
{
D->offset = 0;
} else {
DataMngr::Datum *p = List[List.size()-1];
if (p->db)
{
D->offset = p->offset +
((p->e.GetType() == Val_Number) ?
cellsize : p->e.Size() * cellsize);
} else {
D->offset = p->offset + (p->e.GetNumber() * cellsize);
}
}
cursize += size;
List.push_back(D);
}
DataMngr::Datum *DataMngr::FindData(std::string &sym)
{
std::vector<DataMngr::Datum *>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
if ((*i)->symbol.compare(sym) == 0)
{
return (*i);
}
}
return NULL;
}
int DataMngr::GetOffset(std::string &sym)
{
DataMngr::Datum *D = NULL;
D = FindData(sym);
if (D == NULL)
return DataMngr::nof;
return D->offset;
}
int DataMngr::GetSize()
{
return cursize;
}
void DataMngr::GetData(std::vector<DataMngr::Datum *> &dList)
{
std::vector<DataMngr::Datum *>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
dList.push_back( (*i) );
}
}
void DataMngr::PrintTable()
{
std::vector<DataMngr::Datum *>::iterator i;
DataMngr::Datum *p = 0;
printf("Symbol\tSize\n");
for (i=List.begin(); i!=List.end(); i++)
{
p = (*i);
printf("%s\t%d\n", p->symbol.c_str(), p->offset);
}
}
//Rewrite the DAT section so empties are at the end
void DataMngr::Optimize()
{
std::vector<DataMngr::Datum *> DbList;
std::vector<DataMngr::Datum *> MtList;
std::vector<DataMngr::Datum *>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
if ( (*i)->db )
{
DbList.push_back( (*i) );
} else if ( (*i)->fill == 0 ) {
MtList.push_back( (*i) );
} else {
DbList.push_back( (*i) );
}
}
List.clear();
lastOffset = 0;
cursize = 0;
int size = 0;
for (i=DbList.begin(); i!=DbList.end(); i++)
{
size = (( (*i)->e.GetType() == Val_Number
|| (*i)->e.GetType() == Val_Float ) ?
cellsize : (*i)->e.Size() * cellsize);
(*i)->offset = lastOffset;
lastOffset += size;
(*i)->zeroed = false;
List.push_back( (*i) );
}
cursize = lastOffset;
DbList.clear();
for (i=MtList.begin(); i!=MtList.end(); i++)
{
size = ( (*i)->e.GetNumber() * cellsize );
(*i)->offset = lastOffset;
lastOffset += size;
(*i)->zeroed = true;
List.push_back( (*i) );
}
MtList.clear();
optimized = true;
}

View File

@ -1,63 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#ifndef _INCLUDE_AMXDATA_H
#define _INCLUDE_AMXDATA_H
class DataMngr
{
public:
class Datum
{
public:
Datum();
std::string symbol;
CExpr e;
bool db;
int offset;
int fill;
bool zeroed;
};
public:
~DataMngr();
DataMngr() { cellsize = 4; lastOffset = 0; cursize = 0; optimized = false; }
DataMngr(int cell) { lastOffset = 0; cellsize = cell; cursize = 0; optimized = false; }
void Add(std::string &s, CExpr &expr, bool db = false, int fill = 0);
DataMngr::Datum *FindData(std::string &sym);
void GetData(std::vector<DataMngr::Datum *> &dList);
int GetOffset(std::string &sym);
int GetSize();
void Clear();
void PrintTable();
void Optimize();
bool IsOptimized() { return optimized; }
private:
std::vector<DataMngr::Datum *> List;
int lastOffset;
int cellsize;
int cursize;
bool optimized;
public:
static const int nof = -1;
};
#endif //_INCLUDE_AMXDATA_H

View File

@ -1,90 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#include "amxasm.h"
DefineMngr::~DefineMngr()
{
Clear();
}
void DefineMngr::Clear()
{
std::vector<DefineMngr::Define *>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
if ( (*i) )
delete (*i);
}
List.clear();
}
void DefineMngr::Define::Set(std::string &s, std::string &d)
{
sym.assign(s);
def.assign(d);
}
DefineMngr::Define *DefineMngr::AddDefine(std::string &sym, std::string &def)
{
DefineMngr::Define *D = new DefineMngr::Define;
D->Set(sym, def);
List.push_back(D);
return D;
}
DefineMngr::Define *DefineMngr::FindDefine(std::string &sym)
{
std::vector<DefineMngr::Define*>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
if ((*i)->GetSymbol()->compare(sym)==0)
{
return (*i);
}
}
return NULL;
}
void DefineMngr::SearchAndReplace(std::string &text)
{
std::vector<DefineMngr::Define*>::iterator i;
DefineMngr::Define *D = NULL;
int pos;
for (i=List.begin(); i!=List.end(); i++)
{
D = (*i);
pos = FindSymbol(text, *(D->GetSymbol()), 0);
if (pos != -1)
{
text.replace(pos, D->GetSymbol()->size(), *(D->GetDefine()));
i = List.begin();
}
}
}

View File

@ -1,49 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#ifndef _INCLUDE_DEFINE_H
#define _INCLUDE_DEFINE_H
class DefineMngr
{
public:
class Define
{
public:
void Set(std::string &s, std::string &d);
const std::string *GetSymbol() { return &sym; }
const std::string *GetDefine() { return &def; }
private:
std::string sym;
std::string def;
};
private:
std::vector<Define *> List;
public:
~DefineMngr();
void Clear();
DefineMngr::Define *AddDefine(std::string &sym, std::string &def);
DefineMngr::Define *FindDefine(std::string &sym);
void SearchAndReplace(std::string &text);
};
#endif //_INCLUDE_DEFINE_H

View File

@ -1,198 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#include "amxasm.h"
ErrorMngr::ErrorMngr()
{
printf("Not instantiated with a compiler.");
Cmp = NULL;
line = -1;
assert(Cmp);
}
void ErrorMngr::Clear()
{
Totals[0] = 0;
Totals[1] = 0;
Totals[2] = 0;
Totals[3] = 0;
HighestError = Err_None;
}
int ErrorMngr::CurLine()
{
return ((Compiler *)Cmp)->CurLine();
}
int ErrorMngr::CurCip()
{
return ((Compiler *)Cmp)->CurCip();
}
ErrorMngr::ErrorMngr(void *c)
{
Cmp = c;
DefineErrors();
Totals[0] = 0;
Totals[1] = 0;
Totals[2] = 0;
Totals[3] = 0;
line = -1;
HighestError = Err_None;
}
ErrorType ErrorMngr::GetErrorType(ErrorCode id)
{
if (id > fatals_start && id < fatals_end)
return Err_Fatal;
if (id > warnings_start && id < warnings_end)
return Err_Warning;
if (id > notices_start && id < notices_end)
return Err_Notice;
if (id > errors_start && id < errors_end)
return Err_Error;
return Err_None;
}
void ErrorMngr::DefineErrors()
{
List.resize(fatals_end+1);
List.at(Warning_Hex_Start) = "Hexadecimal notation is 0xN, 0 missing";
List.at(Warning_Null_Expression) = "Bad expression will evaluate to 0";
List.at(Warning_Param_Count) = "Expected %d parameters, found %d";
List.at(Err_String_Terminate) = "String not terminated properly";
List.at(Err_String_Extra) = "Unexpected characters after string end (character '%c')";
List.at(Err_Unexpected_Char) = "Unexpected character found (character '%c')";
List.at(Err_Wandering_Stuff) = "Unknown directive placed outside of a section";
List.at(Err_Symbol_Reuse) = "Symbol \"%s\" already defined on line %d";
List.at(Err_Invalid_Stor) = "Invalid DAT storage identifier \"%s\"";
List.at(Err_Unknown_Symbol) = "Unknown symbol \"%s\"";
List.at(Err_Symbol_Type) = "Expected symbol type %d, got %d (bad symbol)";
List.at(Err_Invalid_Symbol) = "Invalid symbol";
List.at(Err_Opcode) = "Invalid or unrecognized opcode";
List.at(Err_Unmatched_Token) = "Unmatched token '%c'";
List.at(Err_Param_Count) = "Expected %d parameters, found %d";
List.at(Err_Unknown_Define) = "Unknown define referenced";
List.at(Err_Misplaced_Directive) = "Misplaced preprocessor directive";
List.at(Err_Bad_Label) = "Label referenced without being created";
List.at(Err_Bad_Not) = "Wrong type argument to bit-complement";
List.at(Err_Invalid_Operator) = "Operator used on bad type";
List.at(Err_Invalid_Pragma) = "Invalid pragma";
List.at(Err_Invalid_Proc) = "Procedure referenced that does not exist";
List.at(Err_FileNone) = "No file specified";
List.at(Err_FileOpen) = "Could not open file \"%s\"";
List.at(Err_NoMemory) = "Ran out of memory";
List.at(Err_PragmaStacksize) = "Invalid stacksize on #pragma stacksize";
List.at(Err_InvalidMacro) = "Invalid or empty macro definition";
List.at(Err_SymbolRedef) = "Symbol \"%s\" already defined on line %d";
List.at(Err_Reserved) = "Symbol assigned to a reserved token";
List.at(Err_MacroParamCount) = "Parameter count for macro \"%s\" incorrect";
List.at(Err_FatalTokenError) = "Fatal token error encountered";
List.at(Err_Invalid_Section) = "Section identifier \"%s\" is not valid, ignoring section.";
}
void ErrorMngr::PrintReport()
{
static char *ErrorSwi[4] = {"Notice", "Warning", "Error", "Fatal Error"};
int i = 0;
printf("+---------------------------+\n");
for (i=0; i<4; i++)
{
printf("| %ss: %s%d |\n", ErrorSwi[i], (i!=3)?"\t\t":"\t", Totals[i]);
}
printf("+---------------------------+\n");
}
void ErrorMngr::ErrorMsg(ErrorCode error, ...)
{
static char *ErrorSwi[4] = {"Notice", "Warning", "Error", "Fatal Error"};
static char errbuf[1024];
ErrorType type = GetErrorType(error);
if (type == -1)
return;
int curLine = 0;
if (line == -1)
{
curLine = ((Compiler *)Cmp)->CurLine();
} else {
curLine = line;
line = -1;
}
va_list argptr;
va_start(argptr, error);
if (((Compiler *)Cmp)->CurLine() == -1)
sprintf(errbuf, "%s(%d): %s\n", ErrorSwi[type], error, GetError(error));
else
sprintf(errbuf, "%s(%d) on line %d: %s\n", ErrorSwi[type], error, curLine, GetError(error));
vprintf(errbuf, argptr);
va_end(argptr);
Totals[type]++;
if (type == Err_Fatal)
exit(0);
if (type > HighestError)
HighestError = type;
}
const char *ErrorMngr::GetError(ErrorCode id)
{
if (id == fatals_start || id == fatals_end)
return NULL;
if (id == warnings_start || id == warnings_end)
return NULL;
if (id == notices_start || id == notices_end)
return NULL;
if (id == errors_start || id == errors_end)
return NULL;
if (id < notices_start || id > fatals_end)
return NULL;
return List.at(id);
}
int ErrorMngr::DerefSymbol(std::string &str, int sym)
{
return ((Compiler *)Cmp)->DerefSymbol(str, (SymbolType)sym);
}
bool ErrorMngr::IsSymbol(std::string &str)
{
return ((Compiler *)Cmp)->IsSymbol(str);
}
void ErrorMngr::SetLine(int ln)
{
line = ln;
}

View File

@ -1,109 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#ifndef _INCLUDE_AMX_ERROR
#define _INCLUDE_AMX_ERROR
typedef enum
{
Err_None=-1,
Err_Notice,
Err_Warning,
Err_Error,
Err_Fatal,
} ErrorType;
typedef enum
{
notices_start,
notices_end,
warnings_start,
Warning_Hex_Start,
Warning_Null_Expression,
Warning_Param_Count,
warnings_end,
errors_start,
Err_String_Terminate,
Err_String_Extra,
Err_Unexpected_Char,
Err_Invalid_Section,
Err_Wandering_Stuff,
Err_Symbol_Reuse, /* Non-fatal version of Redef */
Err_Invalid_Stor,
Err_Unknown_Symbol,
Err_Symbol_Type,
Err_Invalid_Symbol,
Err_Opcode,
Err_Unmatched_Token,
Err_Param_Count,
Err_Unknown_Define,
Err_Misplaced_Directive,
Err_Bad_Label,
Err_Bad_Not,
Err_Invalid_Operator,
Err_Invalid_Pragma,
Err_Invalid_Proc,
errors_end,
fatals_start,
Err_FileNone,
Err_FileOpen,
Err_NoMemory,
Err_PragmaStacksize,
Err_InvalidMacro,
Err_SymbolRedef,
Err_Reserved,
Err_MacroParamCount,
Err_FatalTokenError,
fatals_end,
} ErrorCode;
class ErrorMngr
{
private:
void DefineErrors();
const char *GetError(ErrorCode id);
ErrorType GetErrorType(ErrorCode id);
private:
std::vector<const char *> List;
ErrorType HighestError;
void *Cmp;
int Totals[4];
int line;
public:
ErrorMngr();
ErrorMngr(void *c);
void Clear();
void ErrorMsg(ErrorCode error, ...);
ErrorType GetStatus() { return HighestError; }
void PrintReport();
int CurLine();
int CurCip();
void SetLine(int ln);
int DerefSymbol(std::string &str, int sym = 0);
bool IsSymbol(std::string &str);
};
#endif //_INCLUDE_AMX_ERROR

View File

@ -1,182 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#include "amxasm.h"
LabelMngr::~LabelMngr()
{
Clear();
}
LabelMngr::Label::Label()
{
cip = -1;
sym = 0;
}
void LabelMngr::Clear()
{
std::list<LabelMngr::Label *>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
if ( (*i) )
delete (*i);
}
List.clear();
}
LabelMngr::Label *LabelMngr::AddLabel(SymbolList::Symbol *sym, int cip)
{
LabelMngr::Label *p = new LabelMngr::Label;
p->sym = sym;
p->cip = cip;
List.push_back(p);
return p;
}
LabelMngr::Label *LabelMngr::FindLabel(std::string &sym)
{
std::list<LabelMngr::Label *>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
if ( (*i)->sym->IsEqual(sym) )
{
return (*i);
}
}
return NULL;
}
bool LabelMngr::SetCip(std::string &sym, int cip)
{
LabelMngr::Label *p = NULL;
p = FindLabel(sym);
if (p == NULL)
return false;
p->cip = cip;
return true;
}
void LabelMngr::QueueLabel(std::string &sym, Asm *ASM)
{
std::string d(sym);
LQ[d].push(ASM);
}
void LabelMngr::CompleteQueue(bool isLocal)
{
std::map<std::string,std::stack<Asm *> >::iterator i;
std::stack<Asm *> *stk = 0;
std::stack<std::map<std::string,std::stack<Asm *> >::iterator> DeleteStack;
std::string search;
Asm *ASM = 0;
LabelMngr::Label *p = 0;
for (i=LQ.begin(); i!=LQ.end(); i++)
{
search.assign( (*i).first );
p = FindLabel(search);
stk = &((*i).second);
if (p == NULL || p->cip == LabelMngr::ncip)
{
if ((!isLocal || (isLocal && search[0]=='_')) && CError)
{
while (!stk->empty())
{
CError->SetLine(stk->top()->line);
CError->ErrorMsg(Err_Bad_Label);
stk->pop();
}
DeleteStack.push( i );
}
} else {
while (!stk->empty())
{
ASM = stk->top();
ASM->params[0] = p->cip;
stk->pop();
}
DeleteStack.push( i );
}
}
while (!DeleteStack.empty())
{
LQ.erase(DeleteStack.top());
DeleteStack.pop();
}
}
int LabelMngr::GetCip(std::string &sym)
{
LabelMngr::Label *p = NULL;
p = FindLabel(sym);
if (p == NULL)
return ncip;
return p->cip;
}
bool LabelMngr::EraseLabel(std::string &sym)
{
std::list<LabelMngr::Label *>::iterator i;
LabelMngr::Label *L = 0;
for (i=List.begin(); i!=List.end(); i++)
{
L = (*i);
if ( L->sym->IsEqual(sym) )
{
i = List.erase(i);
L->sym = 0;
delete L;
L = 0;
return true;
}
}
return false;
}
void LabelMngr::PrintList()
{
std::list<LabelMngr::Label *>::iterator i;
for (i=List.begin(); i!=List.end(); i++)
{
printf("Label:\t%s\t%d\t%d\n", (*i)->sym->sym.c_str(), (*i)->cip, (*i)->sym->line);
}
}

View File

@ -1,57 +0,0 @@
/* AMX Assembler
* Copyright (C)2004 David "BAILOPAN" Anderson
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* Version: $Id$
*/
#ifndef _INCLUDE_AMXLABEL_H
#define _INCLUDE_AMXLABEL_H
class LabelMngr
{
public:
class Label
{
public:
Label();
SymbolList::Symbol *sym;
int cip;
};
public:
~LabelMngr();
LabelMngr() { CError = NULL; assert(CError!=NULL); }
LabelMngr(ErrorMngr *e) { CError = e; }
LabelMngr::Label *AddLabel(SymbolList::Symbol *sym, int cip);
LabelMngr::Label *FindLabel(std::string &sym);
int GetCip(std::string &sym);
void Clear();
bool SetCip(std::string &sym, int cip);
void QueueLabel(std::string &sym, Asm *ASM);
void CompleteQueue(bool isLocal = false);
bool EraseLabel(std::string &sym);
void PrintList();
private:
std::list<LabelMngr::Label *> List;
std::map<std::string, std::stack<Asm *> > LQ;
ErrorMngr *CError;
public:
static const int ncip = -1;
};
#endif //_INCLUDE_AMXLABEL_H

Some files were not shown because too many files have changed in this diff Show More