Bump version for release.

Former-commit-id: 4e0f69d8421b4d0a421f5960ce8ff77497acfa63

.hgignore

@@ -0,0 +1,24 @@
+# Binaries
+\.dll$
+\.exe$
+\.so$
+
+# Files generated by Visual Studio
+\.aps$
+\.ncb$
+\.sdf$
+\.suo$
+\.user$
+
+# Build directories
+/Debug.*
+/Release.*
+/JITDebug.*
+/JITRelease.*
+
+# Files generated by Mac OS X Finder
+(^|/)\.DS_Store$
+
+# Files generated by Windows Explorer
+(^|/)Desktop\.ini$
+(^|/)Thumbs\.db$

amxmodx/CCmd.cpp

@@ -35,8 +35,10 @@
 // *****************************************************
 // class CmdMngr
 // *****************************************************
-CmdMngr::CmdMngr() { 
+
-	memset(sortedlists,0,sizeof(sortedlists));
+CmdMngr::CmdMngr()
+{ 
+	memset(sortedlists, 0, sizeof(sortedlists));
 	srvcmdlist = 0;
 	clcmdlist = 0;
 	prefixHead = 0;
@@ -49,13 +51,12 @@ CmdMngr::CmdMngr() {
 
 }
 
-CmdMngr::Command::Command( CPluginMngr::CPlugin* pplugin,const char* pcmd, 
+CmdMngr::Command::Command(CPluginMngr::CPlugin* pplugin, const char* pcmd, const char* pinfo, int pflags, 
-			const char* pinfo , int pflags , int pfunc, 
+							int pfunc, bool pviewable, CmdMngr* pparent) : commandline(pcmd), info(pinfo)
-			bool pviewable, CmdMngr* pparent ) : commandline(pcmd) , info(pinfo) {
+{
-
 	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);
 	argument.assign(szArg);
 	plugin = pplugin;
@@ -73,95 +74,86 @@ CmdMngr::Command::~Command()
 	++uniqueid;
 }
 
-CmdMngr::Command* CmdMngr::registerCommand( CPluginMngr::CPlugin* plugin ,   int func , char* cmd ,  char* info , int level , bool listable )
+CmdMngr::Command* CmdMngr::registerCommand(CPluginMngr::CPlugin* plugin, int func, char* cmd, char* info, int level, bool listable)
 {
-  Command* b = new Command( plugin ,  cmd , info ,  level , func , listable,  this );
+	Command* b = new Command(plugin, cmd, info, level, func, listable, this);
-  if ( b == 0 ) return 0;
+	if (b == 0) return 0;
-  setCmdLink( &sortedlists[0] , b );
+	setCmdLink(&sortedlists[0], b);
-  return b;
+	
+	return b;
 }
 
-CmdMngr::Command* CmdMngr::getCmd( long int id ,int type,  int access )
+CmdMngr::Command* CmdMngr::getCmd(long int id, int type, int access)
 {
-	//if ( id >= 1024 || id < 0 ) return (Command*)id;
+	//if (id >= 1024 || id < 0) return (Command*)id;
-	if ( id < 0 ){
+	if (id < 0)
-		for (CmdMngr::iterator a = begin( type ); a ; ++a){
+	{
-			if ( (*a).id == id )
+		for (CmdMngr::iterator a = begin(type); a ; ++a)
+		{
+			if ((*a).id == id)
 				return &(*a);
 		}
+		
 		return 0;
 	}
 
-	if ( (id < buf_cmdid) || (access != buf_cmdaccess) || (type != buf_cmdtype) )
+	if ((id < buf_cmdid) || (access != buf_cmdaccess) || (type != buf_cmdtype))
 	{
-		buf_cmdptr = begin( type );
+		buf_cmdptr = begin(type);
 		buf_cmdaccess = access;
 		buf_cmdtype = type;
 		buf_cmdid = id;
-	}
+	} else {
-	else
-	{
 		int a = id;
 		id -= buf_cmdid;
 		buf_cmdid = a;
 	}
 
-	while ( buf_cmdptr )
+	while (buf_cmdptr)
 	{
-		
+		if ((*buf_cmdptr).gotAccess(access) && (*buf_cmdptr).getPlugin()->isExecutable((*buf_cmdptr).getFunction()) && (*buf_cmdptr).isViewable())
-		if ( (*buf_cmdptr).gotAccess(  access ) && 
-			(*buf_cmdptr).getPlugin()->isExecutable( (*buf_cmdptr).getFunction()  )
-			&& (*buf_cmdptr).isViewable() )
 		{
-			
+			if (id-- == 0) 
-			if ( id-- == 0 ) 
 				return &(*buf_cmdptr);
-			
 		}
-		
 		++buf_cmdptr;
 	}
 
 	return 0;		
 }
 
-int CmdMngr::getCmdNum( int type, int access )
+int CmdMngr::getCmdNum(int type, int access)
 {
-	if ( (access == buf_access) && (type == buf_type) )
-		return buf_num; // once calculated don't have to be done again
 
 	buf_access = access;
 	buf_type = type;
 	buf_num = 0;
 
-	CmdMngr::iterator a = begin( type );
+	CmdMngr::iterator a = begin(type);
 
-	while ( a )
+	while (a)
 	{
-			
+		if ((*a).gotAccess(access) && (*a).getPlugin()->isExecutable((*a).getFunction()) && (*a).isViewable())
-		if ( (*a).gotAccess(  access ) && 
+			++buf_num;
-			(*a).getPlugin()->isExecutable( (*a).getFunction()  ) 
-			&& (*a).isViewable() )
-				++buf_num;
 		++a;
 	}
 
 	return buf_num;
 }
 
-void CmdMngr::setCmdLink( CmdLink** a , Command* c, bool sorted  )
+void CmdMngr::setCmdLink(CmdLink** a, Command* c, bool sorted)
 {
-	CmdLink* np = new CmdLink( c );
+	CmdLink* np = new CmdLink(c);
 
-	if ( np == 0 ) return;
+	if (np == 0) return;
 
-	if ( sorted )
+	if (sorted)
 	{
-		while( *a ) 
+		while (*a)
 		{
-			int i = strcmp(c->getCommand(),(*a)->cmd->getCommand() );
+			int i = strcmp(c->getCommand(), (*a)->cmd->getCommand());
 
-			if ( (i<0) || (i==0) && ( strcmp( c->getArgument() , (*a)->cmd->getArgument() ) < 0 ) )
+			if ((i < 0) || ((i == 0) && (strcmp(c->getArgument(), (*a)->cmd->getArgument()) < 0)))
 				break;
 			
 			a = &(*a)->next;
@@ -169,84 +161,101 @@ void CmdMngr::setCmdLink( CmdLink** a , Command* c, bool sorted  )
 
 		np->next = *a;
 		*a = np;
-	}
+	} else {
-	else 
+		while (*a) a = &(*a)->next;
-	{
-		while ( *a ) a = &(*a)->next;
 		*a = np;
 	}
-
-	
 }
 
-void CmdMngr::clearCmdLink( CmdLink** phead, bool pclear )
+void CmdMngr::clearCmdLink(CmdLink** phead, bool pclear)
 {
-	while( *phead ){
+	while (*phead)
+	{
 		CmdLink* pp = (*phead)->next;
-		if ( pclear ) delete (*phead)->cmd;
+		
+		if (pclear) delete (*phead)->cmd;
 		delete *phead;
 		*phead = pp;
 	}
 }
 
-void CmdMngr::Command::setCmdType( int a ) 
+void CmdMngr::Command::setCmdType(int a)
 {
-	switch(a){
+	switch (a)
-	case CMD_ConsoleCommand: cmdtype |= 3; break;
+	{
-	case CMD_ClientCommand: cmdtype |= 1; break;
+		case CMD_ConsoleCommand: cmdtype |= 3; break;
-	case CMD_ServerCommand: cmdtype |= 2; break;
+		case CMD_ClientCommand: cmdtype |= 1; break;
+		case CMD_ServerCommand: cmdtype |= 2; break;
 	}
-	if ( cmdtype & 1 ) { // ClientCommand
+
-		parent->setCmdLink( &parent->sortedlists[1] , this );
+	if (cmdtype & 1)	// ClientCommand
-		if ( !parent->registerCmdPrefix(  this ) )
+	{
-			parent->setCmdLink( &parent->clcmdlist , this , false );
+		parent->setCmdLink(&parent->sortedlists[1], this);
+		
+		if (!parent->registerCmdPrefix(this))
+			parent->setCmdLink(&parent->clcmdlist, this, false);
 	}
-	if ( cmdtype & 2 ) { // ServerCommand
+	
-		parent->setCmdLink( &parent->sortedlists[2] , this );
+	if (cmdtype & 2)	// ServerCommand
-		parent->setCmdLink( &parent->srvcmdlist , this , false );
+	{
+		parent->setCmdLink(&parent->sortedlists[2], this);
+		parent->setCmdLink(&parent->srvcmdlist, this, false);
 	}
 }
 
-const char* CmdMngr::Command::getCmdType() const {
+const char* CmdMngr::Command::getCmdType() const
-	switch( cmdtype ){
+{
-	case 1:	return"client";
+	switch (cmdtype)
-	case 2:	return "server";
+	{
-	case 3:	return "console";
+		case 1:	return "client";
+		case 2:	return "server";
+		case 3:	return "console";
 	}
+	
 	return "unknown";
 }
 
-bool CmdMngr::registerCmdPrefix( Command* cc )
+bool CmdMngr::registerCmdPrefix(Command* cc)
 {
-	CmdPrefix** b = findPrefix( cc->getCommand() );
+	CmdPrefix** b = findPrefix(cc->getCommand());
-	if (*b){
+
-		setCmdLink( &(*b)->list , cc , false );
+	if (*b)
+	{
+		setCmdLink(&(*b)->list, cc, false);
 		cc->prefix = (*b)->name.size();
 		return true;
 	}
+	
 	return false;
 }
 
-void CmdMngr::registerPrefix( const char* nn )
+void CmdMngr::registerPrefix(const char* nn)
 {
-	if ( *nn == 0 ) return;
+	if (*nn == 0) return;
-	CmdPrefix** b = findPrefix( nn );
+	CmdPrefix** b = findPrefix(nn);
+	
 	if (*b) return;
-	*b = new CmdPrefix( nn , this );
+	*b = new CmdPrefix(nn, this);
 }
 
-CmdMngr::CmdPrefix** CmdMngr::findPrefix(  const char* nn ){
+CmdMngr::CmdPrefix** CmdMngr::findPrefix(const char* nn)
+{
 	CmdPrefix** aa = &prefixHead;
-	while(*aa){
+	
-		if ( !strncmp( (*aa)->name.c_str(), nn, (*aa)->name.size() ) ) 
+	while (*aa)
+	{
+		if (!strncmp((*aa)->name.c_str(), nn, (*aa)->name.size()))
 			break;
-		aa=&(*aa)->next;
+		aa = &(*aa)->next;
 	}
+	
 	return aa;
 }
 
-void CmdMngr::clearPrefix(){
+void CmdMngr::clearPrefix()
-	while(prefixHead){
+{
+	while (prefixHead)
+	{
 		CmdPrefix* a = prefixHead->next;
 		delete prefixHead;
 		prefixHead = a;
@@ -264,7 +273,8 @@ void CmdMngr::clear()
 	clearBufforedInfo();
 }
 
-void CmdMngr::clearBufforedInfo() { 
+void CmdMngr::clearBufforedInfo()
+{
 	buf_type = -1; 
 	buf_access = 0; 
 	buf_id = -1; 
@@ -274,4 +284,3 @@ void CmdMngr::clearBufforedInfo() {
 }
 
 int CmdMngr::Command::uniqueid = 0;
-

amxmodx/CCmd.h

@@ -36,7 +36,8 @@
 // class CmdMngr
 // *****************************************************
 
-enum {
+enum
+{
 	CMD_ConsoleCommand,
 	CMD_ClientCommand,
 	CMD_ServerCommand
@@ -48,14 +49,17 @@ public:
 	class Command;
 	friend class Command;
 	
-	class Command {
+	class Command
+	{
 		friend class CmdMngr;
+		
 		CPluginMngr::CPlugin* plugin;
 		CmdMngr* parent;
 		String command;
 		String argument;
 		String commandline;
 		String info;
+		
 		bool listable;
 		int function;
 		int flags;
@@ -63,33 +67,33 @@ public:
 		int cmdtype;
 		int prefix;
 		static int uniqueid;
-		Command( CPluginMngr::CPlugin* pplugin,const char* pcmd, const char* pinfo , int pflags , int pfunc, bool pviewable, CmdMngr* pparent );
+		
+		Command(CPluginMngr::CPlugin* pplugin, const char* pcmd, const char* pinfo, int pflags, int pfunc, bool pviewable, CmdMngr* pparent);
 		~Command();
 	public:
-
 		inline const char* getCommand() { return command.c_str(); }
 		inline const char* getArgument() { return argument.c_str(); }
 		inline const char* getCmdInfo() { return info.c_str(); }
 		inline const char* getCmdLine() { return commandline.c_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.c_str() + prefix, cmd + prefix) && (argument.empty() || !stricmp(argument.c_str(), arg))); }
-		inline bool matchCommand(const char* cmd) {	return (!strcmp(command.c_str(), cmd ));	}
+		inline bool matchCommand(const char* cmd) {	return (!strcmp(command.c_str(), cmd)); }
 		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) != 0)); }
 		inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
 		inline bool isViewable() const { return listable; }
 		inline int getFlags() const { return flags; }
 		inline long int getId() const { return (long int)id; }
-		const char* getCmdType() const;		
-		void setCmdType( int a );
 		
+		const char* getCmdType() const;		
+		void setCmdType(int a);
 	};
 
 private:
-
 	struct CmdPrefix;
 	friend struct CmdPrefix;
 
-	struct CmdLink {
+	struct CmdLink
+	{
 		Command* cmd;
 		CmdLink* next;
 		CmdLink(Command* c): cmd(c), next(0) {}
@@ -99,36 +103,40 @@ private:
 	CmdLink* srvcmdlist;
 	CmdLink* clcmdlist;
 
-	struct CmdPrefix {
+	struct CmdPrefix
+	{
 		String name;
 		CmdMngr* parent;
 		CmdLink* list;
 		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) {}
-		~CmdPrefix(){  parent->clearCmdLink(&list);  }
+		~CmdPrefix() { parent->clearCmdLink(&list); }
 	} *prefixHead;
 
-	bool registerCmdPrefix( Command* cc );
+	bool registerCmdPrefix(Command* cc);
-	CmdPrefix** findPrefix(  const char* nn );
+	CmdPrefix** findPrefix(const char* nn);
 	void clearPrefix();
 
-	void setCmdLink( CmdLink** a , Command* c, bool sorted = true );
+	void setCmdLink(CmdLink** a, Command* c, bool sorted = true);
-	void clearCmdLink( CmdLink** phead, bool pclear = false  );
+	void clearCmdLink(CmdLink** phead, bool pclear = false);
 
 public:
 	CmdMngr();
-	~CmdMngr() {clear();}
+	~CmdMngr() { clear(); }
 
 	// Interface
 
-	void registerPrefix( const char* nn );
+	void registerPrefix(const char* nn);
-	Command* registerCommand( CPluginMngr::CPlugin* plugin , int func , char* cmd ,  char* info , int level , bool listable );
+	
-	Command* getCmd( long int id ,int type,  int access);
+	Command* registerCommand(CPluginMngr::CPlugin* plugin, int func, char* cmd, char* info, int level, bool listable);
-	int getCmdNum( int type, int access );
+	Command* getCmd(long int id, int type, int access);
+	int getCmdNum(int type, int access);
+	
 	void clearBufforedInfo();
 	void clear();
 
-	class iterator {
+	class iterator
+	{
 		CmdLink *a;
 	public:
 		iterator(CmdLink*aa = 0) : a(aa) {}
@@ -138,28 +146,30 @@ public:
 		operator bool () const { return a ? true : false; }
 		Command& operator*() { return *a->cmd; }
 	};
-	inline iterator clcmdprefixbegin(const char* nn){
+
+	inline iterator clcmdprefixbegin(const char* nn)
+	{
 		CmdPrefix* a = *findPrefix(nn);
-		return iterator( a ? a->list : 0 );
+		return iterator(a ? a->list : 0);
 	}
-	inline iterator clcmdbegin() const {return iterator(clcmdlist);}
+
-	inline iterator srvcmdbegin() const {return iterator(srvcmdlist);}
+	inline iterator clcmdbegin() const { return iterator(clcmdlist); }
-	inline iterator begin( int type ) const { return iterator(sortedlists[type]); }
+	inline iterator srvcmdbegin() const { return iterator(srvcmdlist); }
+	inline iterator begin(int type) const { return iterator(sortedlists[type]); }
 	inline iterator end() const { return iterator(0); }
 
 private:
-
 	int buf_cmdid;
 	int buf_cmdtype;
 	int buf_cmdaccess;
+	
 	iterator buf_cmdptr;
 
 	int buf_id;
 	int buf_type;
 	int buf_access;
 	int buf_num;
-
 };
 
-#endif
+#endif //COMMANDS_H
 

amxmodx/CEvent.cpp

@@ -36,7 +36,7 @@
 // class ClEvent
 // *****************************************************
 
-EventsMngr::ClEvent::ClEvent(CPluginMngr::CPlugin* plugin,  int func, int flags)
+EventsMngr::ClEvent::ClEvent(CPluginMngr::CPlugin* plugin, int func, int flags)
 {
 	m_Plugin = plugin;
 	m_Func = func;
@@ -45,13 +45,14 @@ EventsMngr::ClEvent::ClEvent(CPluginMngr::CPlugin* plugin,  int func, int flags)
 	m_FlagAlive = true;
 	m_FlagDead = true;
 
-	m_FlagWorld = (flags & 1) ? true : false;						// flag a
+	m_FlagWorld = (flags & 1) ? true : false;			// flag a
-	m_FlagPlayer = (flags & 2) ? true : false;						// flag b
+	m_FlagPlayer = (flags & 2) ? true : false;			// flag b
-	m_FlagOnce = (flags & 4) ? true : false;						// flag c
+	m_FlagOnce = (flags & 4) ? true : false;			// flag c
+	
 	if (flags & 24)
 	{
-		m_FlagAlive = (flags & 16) ? true : false;				// flag e
+		m_FlagAlive = (flags & 16) ? true : false;		// flag e
-		m_FlagDead = (flags & 8) ? true : false;				// flag d
+		m_FlagDead = (flags & 8) ? true : false;		// flag d
 	}
 
 	m_Stamp = 0.0f;
@@ -64,12 +65,14 @@ EventsMngr::ClEvent::~ClEvent()
 {
 	cond_t *tmp1 = m_Conditions;
 	cond_t *tmp2 = NULL;
+	
 	while (tmp1)
 	{
 		tmp2 = tmp1->next;
 		delete tmp1;
 		tmp1 = tmp2;
 	}
+	
 	m_Conditions = NULL;
 }
 
@@ -82,14 +85,17 @@ void EventsMngr::NextParam()
 
 	MsgDataEntry *tmp = NULL;
 	int tmpSize = 0;
+	
 	if (m_ParseVault)
 	{
 		// copy to tmp
 		tmp = new MsgDataEntry[m_ParseVaultSize];
+		
 		if (!tmp)
 		{
 			return;		// :TODO: Error report !!
 		}
+		
 		memcpy(tmp, m_ParseVault, m_ParseVaultSize * sizeof(MsgDataEntry));
 		tmpSize = m_ParseVaultSize;
 		delete [] m_ParseVault;
@@ -102,6 +108,7 @@ void EventsMngr::NextParam()
 		m_ParseVaultSize = INITIAL_PARSEVAULT_SIZE;
 
 	m_ParseVault = new MsgDataEntry[m_ParseVaultSize];
+	
 	if (tmp)
 	{
 		memcpy(m_ParseVault, tmp, tmpSize * sizeof(MsgDataEntry));
@@ -128,7 +135,6 @@ EventsMngr::~EventsMngr()
 	clearEvents();
 }
 
-
 CPluginMngr::CPlugin * EventsMngr::ClEvent::getPlugin()
 {
 	return m_Plugin;
@@ -170,7 +176,7 @@ void EventsMngr::ClEvent::registerFilter(char *filter)
 
 	// rest of line
 	tmpCond->sValue.assign(value);
-	tmpCond->fValue = atof(value);
+	tmpCond->fValue = static_cast<float>(atof(value));
 	tmpCond->iValue = atoi(value);
 	
 	tmpCond->next = NULL;
@@ -178,10 +184,11 @@ void EventsMngr::ClEvent::registerFilter(char *filter)
 	if (m_Conditions)
 	{
 		cond_t *tmp = m_Conditions;
+		
 		while (tmp->next)
 			tmp = tmp->next;
-		tmp->next = tmpCond;
 		
+		tmp->next = tmpCond;
 	}
 	else
 		m_Conditions = tmpCond;
@@ -194,6 +201,7 @@ EventsMngr::ClEvent* EventsMngr::registerEvent(CPluginMngr::CPlugin* plugin, int
 		return NULL;
 
 	ClEvent *event = new ClEvent(plugin, func, flags);
+	
 	if (!event)
 		return NULL;
 
@@ -216,12 +224,11 @@ void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int in
 	if (!m_Events[msg_type].size())
 		return;
 
-	for(ClEventVecIter iter = m_Events[msg_type].begin(); iter; ++iter)
+	for (ClEventVecIter iter = m_Events[msg_type].begin(); iter; ++iter)
 	{
 		if ((*iter).m_Done)
 			continue;
 
-
 		if (!(*iter).m_Plugin->isExecutable((*iter).m_Func))
 		{
 			(*iter).m_Done = true;
@@ -230,7 +237,7 @@ void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int in
 
 		if (pPlayer)
 		{
-			if (!(*iter).m_FlagPlayer || (pPlayer->IsAlive() ? !(*iter).m_FlagAlive : !(*iter).m_FlagDead ) )
+			if (!(*iter).m_FlagPlayer || (pPlayer->IsAlive() ? !(*iter).m_FlagAlive : !(*iter).m_FlagDead))
 			{
 				(*iter).m_Done = true;
 				continue;
@@ -247,6 +254,7 @@ void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int in
 			(*iter).m_Done = true;
 			continue;
 		}
+		
 		m_ParseNotDone = true;
 	}
 
@@ -257,6 +265,7 @@ void EventsMngr::parserInit(int msg_type, float* timer, CPlayer* pPlayer, int in
 		m_ParseVault[0].type = MSG_INTEGER;
 		m_ParseVault[0].iValue = index;
 	}
+	
 	m_ParseFun = &m_Events[msg_type];
 }
 
@@ -266,7 +275,6 @@ void EventsMngr::parseValue(int iValue)
 	if (!m_ParseNotDone || !m_ParseFun)
 		return;
 
-
 	// grow if needed
 	++m_ParsePos;
 	NextParam();
@@ -284,23 +292,25 @@ void EventsMngr::parseValue(int iValue)
 		// loop through conditions
 		bool execute = false;
 		bool anyConditions = false;
+		
 		for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
 		{
 			if (condIter->paramId == m_ParsePos)
 			{
 				anyConditions = true;
-				switch(condIter->type)
+				switch (condIter->type)
 				{
-				case '=': if (condIter->iValue == iValue) execute=true; break;
+					case '=': if (condIter->iValue == iValue) execute = true; break;
-				case '!': if (condIter->iValue != iValue) execute=true; break;
+					case '!': if (condIter->iValue != iValue) execute = true; break;
-				case '&': if (iValue & condIter->iValue) execute=true; break;
+					case '&': if (iValue & condIter->iValue) execute = true; break;
-				case '<': if (iValue < condIter->iValue) execute=true; break;
+					case '<': if (iValue < condIter->iValue) execute = true; break;
-				case '>': if (iValue > condIter->iValue) execute=true; break;
+					case '>': if (iValue > condIter->iValue) execute = true; break;
 				}
 				if (execute)
 					break;
 			}
 		}
+		
 		if (anyConditions && !execute)
 			(*iter).m_Done = true;		// don't execute
 	}
@@ -312,7 +322,6 @@ void EventsMngr::parseValue(float fValue)
 	if (!m_ParseNotDone || !m_ParseFun)
 		return;
 
-
 	// grow if needed
 	++m_ParsePos;
 	NextParam();
@@ -330,22 +339,25 @@ void EventsMngr::parseValue(float fValue)
 		// loop through conditions
 		bool execute = false;
 		bool anyConditions = false;
+		
 		for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
 		{
 			if (condIter->paramId == m_ParsePos)
 			{
 				anyConditions = true;
-				switch(condIter->type)
+				switch (condIter->type)
 				{
-				case '=': if (condIter->fValue == fValue) execute=true; break;
+					case '=': if (condIter->fValue == fValue) execute = true; break;
-				case '!': if (condIter->fValue != fValue) execute=true; break;
+					case '!': if (condIter->fValue != fValue) execute = true; break;
-				case '<': if (fValue < condIter->fValue) execute=true; break;
+					case '<': if (fValue < condIter->fValue) execute = true; break;
-				case '>': if (fValue > condIter->fValue) execute=true; break;
+					case '>': if (fValue > condIter->fValue) execute = true; break;
 				}
+				
 				if (execute)
 					break;
 			}
 		}
+		
 		if (anyConditions && !execute)
 			(*iter).m_Done = true;		// don't execute
 	}
@@ -374,21 +386,24 @@ void EventsMngr::parseValue(const char *sz)
 		// loop through conditions
 		bool execute = false;
 		bool anyConditions = false;
+		
 		for (ClEvent::cond_t *condIter = (*iter).m_Conditions; condIter; condIter = condIter->next)
 		{
 			if (condIter->paramId == m_ParsePos)
 			{
 				anyConditions = true;
-				switch(condIter->type)
+				switch (condIter->type)
 				{
-				case '=': if (!strcmp(sz, condIter->sValue.c_str())) execute=true; break;
+					case '=': if (!strcmp(sz, condIter->sValue.c_str())) execute = true; break;
-				case '!': if (strcmp(sz, condIter->sValue.c_str())) execute=true; break;
+					case '!': if (strcmp(sz, condIter->sValue.c_str())) execute = true; break;
-				case '&': if (strstr(sz, condIter->sValue.c_str())) execute=true; break;
+					case '&': if (strstr(sz, condIter->sValue.c_str())) execute = true; break;
 				}
+				
 				if (execute)
 					break;
 			}
 		}
+		
 		if (anyConditions && !execute)
 			(*iter).m_Done = true;		// don't execute
 	}
@@ -403,13 +418,14 @@ void EventsMngr::executeEvents()
 
 	for (ClEventVecIter iter = m_ParseFun->begin(); iter; ++iter)
 	{
-		if ( (*iter).m_Done ) 
+		if ((*iter).m_Done) 
 		{
 			(*iter).m_Done = false;
 			continue;
 		}
+		
 		(*iter).m_Stamp = (float)*m_Timer;
-		executeForwards((*iter).m_Func, m_ParseVault ? m_ParseVault[0].iValue : 0);
+		executeForwards((*iter).m_Func, static_cast<cell>(m_ParseVault ? m_ParseVault[0].iValue : 0));
 	}
 
 	m_CurrentMsgType = -1;
@@ -423,53 +439,53 @@ int EventsMngr::getArgNum() const
 
 const char* EventsMngr::getArgString(int a) const
 {
-	if ( a < 0 || a > m_ParsePos )
+	if (a < 0 || a > m_ParsePos)
 		return "";
 
 	static char var[32];
 
-	switch(m_ParseVault[a].type)
+	switch (m_ParseVault[a].type)
 	{
-	case MSG_INTEGER: 
+		case MSG_INTEGER: 
-		sprintf( var, "%d", m_ParseVault[a].iValue );
+			sprintf(var, "%d", m_ParseVault[a].iValue);
-		return var;
+			return var;
-	case MSG_STRING: 
+		case MSG_STRING: 
-		return m_ParseVault[a].sValue;
+			return m_ParseVault[a].sValue;
-	default:
+		default:
-		sprintf( var, "%g", m_ParseVault[a].fValue );
+			sprintf(var, "%g", m_ParseVault[a].fValue);
-		return var;
+			return var;
 	}
 }
 
 int EventsMngr::getArgInteger(int a) const
 {
-	if ( a < 0 || a > m_ParsePos )
+	if (a < 0 || a > m_ParsePos)
 		return 0;
 
-	switch(m_ParseVault[a].type)
+	switch (m_ParseVault[a].type)
 	{
-	case MSG_INTEGER:
+		case MSG_INTEGER:
-		return m_ParseVault[a].iValue;
+			return m_ParseVault[a].iValue;
-	case MSG_STRING:
+		case MSG_STRING:
-		return atoi(m_ParseVault[a].sValue);
+			return atoi(m_ParseVault[a].sValue);
-	default:
+		default:
-		return (int)m_ParseVault[a].fValue; 
+			return (int)m_ParseVault[a].fValue; 
 	}
 }
 
 float EventsMngr::getArgFloat(int a) const
 {
-	if ( a < 0 || a > m_ParsePos )
+	if (a < 0 || a > m_ParsePos)
 		return 0.0f;
 
-	switch(m_ParseVault[a].type)
+	switch (m_ParseVault[a].type)
 	{
-	case MSG_INTEGER:
+		case MSG_INTEGER:
-		return m_ParseVault[a].iValue;
+			return static_cast<float>(m_ParseVault[a].iValue);
-	case MSG_STRING:
+		case MSG_STRING:
-		return atof(m_ParseVault[a].sValue);
+			return static_cast<float>(atof(m_ParseVault[a].sValue));
-	default:
+		default:
-		return m_ParseVault[a].fValue; 
+			return m_ParseVault[a].fValue; 
 	}
 }
 
@@ -479,6 +495,7 @@ void EventsMngr::clearEvents(void)
 	{
 		m_Events[i].clear();
 	}
+	
 	// delete parsevault
 	if (m_ParseVault)
 	{
@@ -497,25 +514,26 @@ int EventsMngr::getEventId(const char* msg)
 		CS_EventsIds id;
 	} table[] =
 	{
-		{ "CS_DeathMsg" ,	CS_DeathMsg  },
+		{"CS_DeathMsg",		CS_DeathMsg},
-			//		{ "CS_RoundEnd" ,	CS_RoundEnd  },
+//		{"CS_RoundEnd",		CS_RoundEnd},
-			//		{ "CS_RoundStart" , CS_RoundStart  },
+//		{"CS_RoundStart",	CS_RoundStart},
-			//		{ "CS_Restart" ,	CS_Restart  },
+//		{"CS_Restart",		CS_Restart},
-		{ "" ,				CS_Null  }
+		{"",				CS_Null}
 	};
 
 	// if msg is a number, return it
 	int pos = atoi(msg);
+	
 	if (pos != 0)
 		return pos;
 
 	// try to find in table first
-	for (pos = 0; table[ pos ].id != CS_Null; ++pos )
+	for (pos = 0; table[pos].id != CS_Null; ++pos)
-		if ( !strcmp( table[ pos ].name , msg ) )
+		if (!strcmp(table[pos].name, msg))
-			return table[ pos ].id;
+			return table[pos].id;
 
 	// 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()

amxmodx/CEvent.h

@@ -32,9 +32,10 @@
 #ifndef __CEVENTS_H__
 #define __CEVENTS_H__
 
-#define MAX_AMX_REG_MSG MAX_REG_MSGS+16
+#define MAX_AMX_REG_MSG MAX_REG_MSGS + 16
  
-enum {
+enum
+{
 	CS_DEATHMSG = MAX_REG_MSGS,
 //	CS_ROUNDEND,
 //	CS_ROUNDSTART,
@@ -67,7 +68,7 @@ public:
 
 	class ClEvent
 	{
-		friend class EventsMngr;		// events manager may access our private members
+		friend class EventsMngr;				// events manager may access our private members
 
 		int m_Func;								// function to be executed
 		CPluginMngr::CPlugin *m_Plugin;			// the plugin this ClEvent class is assigned to
@@ -100,7 +101,7 @@ public:
 
 	public:
 		// constructors & destructors
-		ClEvent(CPluginMngr::CPlugin* plugin,  int func, int flags);
+		ClEvent(CPluginMngr::CPlugin* plugin, int func, int flags);
 		~ClEvent();
 
 		inline CPluginMngr::CPlugin* getPlugin();
@@ -116,21 +117,22 @@ private:
 		const char* sValue;
 		MsgParamType type;
 	};
+
 	MsgDataEntry *m_ParseVault;
 	int m_ParseVaultSize;
-	void NextParam();				// make sure a new parameter can be added
+	void NextParam();			// make sure a new parameter can be added
 
 	typedef CList<ClEvent> ClEventVec;
 	typedef ClEventVec::iterator ClEventVecIter;
 
 	ClEventVec m_Events[MAX_AMX_REG_MSG];
-	ClEventVec *m_ParseFun;	// current Event vector
+	ClEventVec *m_ParseFun;		// current Event vector
 
 	bool m_ParseNotDone;
 	int m_ParsePos;				// is args. num. - 1
 	float* m_Timer;
 	
-	ClEvent* getValidEvent(ClEvent* a );
+	ClEvent* getValidEvent(ClEvent* a);
 
 	int m_CurrentMsgType;
 public:
@@ -140,20 +142,20 @@ public:
 	// Interface
 
 	ClEvent* registerEvent(CPluginMngr::CPlugin* plugin, int func, int flags, int msgid);
+	
 	void parserInit(int msg_type, float* timer, CPlayer* pPlayer, int index);
 	void parseValue(int iValue);
 	void parseValue(float fValue);
 	void parseValue(const char *sz);
 	void executeEvents();
-	int getArgNum() const; //{ return (parsePos+1); }
+	
+	int getArgNum() const;		//{ return (parsePos + 1); }
 	const char* getArgString(int a) const;
 	int getArgInteger(int a) const;
 	float getArgFloat(int a) const;
 	void clearEvents(void);
-	static int getEventId( const char* msg );
+	static int getEventId(const char* msg);
 	int getCurrentMsgType();
 };
 
-#endif // #ifdef __CEVENTS_H__
+#endif //__CEVENTS_H__
-
-

amxmodx/CFile.cpp

@@ -36,91 +36,91 @@
 // *****************************************************
 // class File
 // *****************************************************
-File::File( const char* n, const char* m )
+
+File::File(const char* n, const char* m)
 {
-  fp = fopen( n , m );
+	fp = fopen(n, m);
 }
 
-File::~File( )
+File::~File()
 {
-  if ( fp )
+	if (fp)
-    fclose( fp );
+		fclose(fp);
 }
 
-File::operator bool ( ) const
+File::operator bool () const
 {
-  return fp && !feof(fp);
+	return fp && !feof(fp);
 }
 
-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.c_str(), f.fp);
-  return f;
+	return f;
 }
 
-File& operator<<( File& f, const char* n )
+File& operator<<(File& f, const char* n)
 {
-  if ( f ) fputs( n , f.fp ) ;
+	if (f) fputs(n, f.fp);
-  return f;
+	return f;
 }
 
-File& operator<<( File& f, int n )
+File& operator<<(File& f, int n)
 {
-  if ( f ) fprintf( f.fp , "%d" , n ) ;
+	if (f) fprintf(f.fp, "%d", n);
-  return f;
+	return f;
 }
 
-
+File& operator<<(File& f, const char& c)
-File& operator<<( File& f, const char& c )
 {
-  if ( f ) fputc( c , f.fp ) ;
+	if (f) fputc(c, f.fp);
-  return f;
+	return f;
 }
 
-File& operator>>( File& f, String& n )
+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.assign(temp);
-  return f;
+	return f;
 }
 
-File& operator>>( File& f, char* n )
+File& operator>>(File& f, char* n)
 {
-  if ( f ) fscanf( f.fp , "%s", n );
+	if (f) fscanf(f.fp, "%s", n);
-  return f;
+	return f;
 }
 
-int File::getline( char* buf, int sz )
+int File::getline(char* buf, int sz)
 {
-  int a = sz;
+	int a = sz;
-  char *origBuf = buf;
+	char *origBuf = buf;
-  if ( *this )
-  {
-    int c;
-    while ( sz-- && (c = getc( (*this).fp)) && c != EOF && c != '\n'  )
-      *buf++ = c;
-    *buf = 0;
-  }
 	
-  // trim 0x0a and 0x0d characters at the end
+	if (*this)
-  while (buf != origBuf)
+	{
-  {
+		int c;
-    if (*buf == 0x0a || *buf == 0x0d)
+		while (sz-- && (c = getc((*this).fp)) && c != EOF && c != '\n')
+		*buf++ = c;
 		*buf = 0;
-	--buf;
+	}
-  }
 
-  return a - sz;
+	// trim 0x0a and 0x0d characters at the end
+	while (buf != origBuf)
+	{
+		if (*buf == 0x0a || *buf == 0x0d)
+			*buf = 0;
+		--buf;
+	}
+
+	return a - sz;
 }
 
-File& File::skipWs( )
+File& File::skipWs()
 {
-  if ( !*this ) return *this;
+	if (!*this) return *this;
-  int c;
+	int c;
-  while( isspace( c = getc( fp ) ) ){};
+	while (isspace(c = getc(fp))) {};
-  ungetc( c , fp );
+	ungetc(c, fp);
-  return *this;
+	return *this;
 }
-

amxmodx/CFile.h

@@ -41,18 +41,19 @@ class File
 	FILE* fp;
 
 public:
-	File( const char* n, const char* m );
+	File(const char* n, const char* m);
-	~File( );
+	~File();
-	operator bool ( ) const;
+	
-	friend File& operator<<( File& f, const String& n );
+	operator bool () const;
-	friend File& operator<<( File& f, const char* n );
+	
-	friend File& operator<<( File& f, const char& c );
+	friend File& operator<<(File& f, const String& n);
-	friend File& operator<<( File& f, int n );
+	friend File& operator<<(File& f, const char* n);
-	friend File& operator>>( File& f, String& n );
+	friend File& operator<<(File& f, const char& c);
-	friend File& operator>>( File& f, char* n );
+	friend File& operator<<(File& f, int n);
-	int getline( char* buf, int sz );
+	friend File& operator>>(File& f, String& n);
-	File& skipWs( );
+	friend File& operator>>(File& f, char* n);
+	
+	int getline(char* buf, int sz);
+	
+	File& skipWs();
 };
-
-
-

amxmodx/CFlagManager.cpp

@@ -0,0 +1,418 @@
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "sh_list.h"
+#include "CString.h"
+
+#include "amxmodx.h"
+
+#include "CFlagManager.h"
+
+void CFlagManager::SetFile(const char *Filename)
+{
+
+	m_strConfigFile.assign(g_mod_name.c_str());
+	m_strConfigFile.append("/");
+	m_strConfigFile.append(get_localinfo("amxx_configsdir","addons/amxmodx/configs"));
+	m_strConfigFile.append("/");
+	m_strConfigFile.append(Filename);
+
+
+	CreateIfNotExist();
+}
+
+const int CFlagManager::LoadFile(const int force)
+{
+	CheckIfDisabled();
+	// If we're disabled get the hell out.  now.
+	if (m_iDisabled)
+	{
+		return 0;
+	}
+	// if we're not forcing this, and NeedToLoad says we dont have to
+	// then just stop
+	if (!force && !NeedToLoad())
+	{
+		return 0;
+	};
+
+	this->Clear();
+
+
+	// We need to load the file
+
+	FILE *File;
+
+	File=fopen(m_strConfigFile.c_str(),"r");
+
+	if (!File)
+	{
+		AMXXLOG_Log("[AMXX] FlagManager: Cannot open file \"%s\" (FILE pointer null!)",m_strConfigFile.c_str());
+		return -1;
+	};
+
+	// Trying to copy this almost exactly as other configs are read...
+	String Line;
+
+	char Command[256];
+	char Flags[256];
+
+	String TempLine;
+	while (!feof(File))
+	{
+
+		Line._fread(File);
+
+		char *nonconst=const_cast<char *>(Line.c_str());
+
+
+		// Strip out comments
+		while (*nonconst)
+		{
+			if (*nonconst==';') // End the line at comments
+			{
+				*nonconst='\0';
+			}
+			else
+			{
+				nonconst++;
+			}
+		};
+
+		Command[0]='\0';
+		Flags[0]='\0';
+
+		// Extract the command
+		TempLine.assign(Line.c_str());
+
+		nonconst=const_cast<char *>(TempLine.c_str());
+
+		char *start=NULL;
+		char *end=NULL;
+
+		// move up line until the first ", mark this down as the start
+		// then find the second " and mark it down as the end
+		while (*nonconst!='\0')
+		{
+			if (*nonconst=='"')
+			{
+				if (start==NULL)
+				{
+					start=nonconst+1;
+				}
+				else
+				{
+					end=nonconst;
+					goto done_with_command;
+				}
+			}
+			nonconst++;
+		}
+done_with_command:
+
+		// invalid line?
+		if (start==NULL || end==NULL)
+		{
+			// TODO: maybe warn for an invalid non-commented line?
+			continue;
+		}
+
+		*end='\0';
+
+		strncpy(Command,start,sizeof(Command)-1);
+
+
+		// Now do the same thing for the flags
+		nonconst=++end;
+
+		start=NULL;
+		end=NULL;
+
+		// move up line until the first ", mark this down as the start
+		// then find the second " and mark it down as the end
+		while (*nonconst!='\0')
+		{
+			if (*nonconst=='"')
+			{
+				if (start==NULL)
+				{
+					start=nonconst+1;
+				}
+				else
+				{
+					end=nonconst;
+					goto done_with_flags;
+				}
+			}
+			nonconst++;
+		}
+done_with_flags:
+		// invalid line?
+		if (start==NULL || end==NULL)
+		{
+			// TODO: maybe warn for an invalid non-commented line?
+			continue;
+		}
+
+		*end='\0';
+
+		strncpy(Flags,start,sizeof(Flags)-1);
+
+
+
+		//if (!isalnum(*Command))
+		if (*Command == '"' || 
+			*Command == '\0')
+		{
+			continue;
+		};
+
+		// Done sucking the command and flags out of the line
+		// now insert this command into the linked list
+
+		AddFromFile(const_cast<const char*>(&Command[0]),&Flags[0]);
+
+		nonconst=const_cast<char *>(Line.c_str());
+		*nonconst='\0';
+	};
+
+
+	fclose(File);
+
+
+	return 1;
+}
+
+/**
+ * This gets called from LoadFile
+ * Do NOT flag the entries as NeedToWrite
+ * No comment is passed from the file because
+ * this should never get written
+ */
+void CFlagManager::AddFromFile(const char *Command, const char *Flags)
+{
+
+	CFlagEntry *Entry=new CFlagEntry;
+
+	Entry->SetName(Command);
+	Entry->SetFlags(Flags);
+
+	// Link it
+	m_FlagList.push_back(Entry);
+
+};
+
+
+void CFlagManager::LookupOrAdd(const char *Command, int &Flags, AMX *Plugin)
+{
+	if (m_iDisabled) // if disabled in core.ini stop
+	{
+		return;
+	}
+	
+
+	int TempFlags=Flags;
+	if (TempFlags==-1)
+	{
+		TempFlags=0;
+	}
+
+	List<CFlagEntry *>::iterator	 iter;
+	List<CFlagEntry *>::iterator	 end;
+
+	iter=m_FlagList.begin();
+	end=m_FlagList.end();
+
+	while (iter!=end)
+	{
+		if (strcmp((*iter)->GetName()->c_str(),Command)==0)
+		{
+			CFlagEntry *Entry=(*iter);
+
+			if (Entry->IsHidden()) // "!" flag, exclude this function
+			{
+				return;
+			}
+			// Found, byref the new flags
+			Flags=Entry->Flags();
+
+			// Move it to the back of the list for faster lookup for the rest
+			m_FlagList.erase(iter);
+
+			m_FlagList.push_back(Entry);
+			return;
+		}
+		iter++;
+	}
+
+	// was not found, add it
+
+	CFlagEntry *Entry=new CFlagEntry;
+
+	Entry->SetName(Command);
+	Entry->SetFlags(TempFlags);
+
+	if (Plugin)
+	{
+		CPluginMngr::CPlugin* a = g_plugins.findPluginFast(Plugin);
+
+		if (a)
+		{
+			Entry->SetComment(a->getName());
+		}
+	}
+
+	// This entry was added from a register_* native
+	// it needs to be written during map change
+	Entry->SetNeedWritten(1);
+
+	// Link it
+	m_FlagList.push_back(Entry);
+
+}
+void CFlagManager::WriteCommands(void)
+{
+	List<CFlagEntry *>::iterator	 iter;
+	List<CFlagEntry *>::iterator	 end;
+	FILE							*File;
+	int								 NeedToRead=0;
+
+	// First off check the modified time of this file
+	// if it matches the stored modified time, then update
+	// after we write so we do not re-read next map
+	struct stat TempStat;
+
+	stat(m_strConfigFile.c_str(),&TempStat);
+
+
+
+	if (TempStat.st_mtime != m_Stat.st_mtime)
+	{
+		NeedToRead=1;
+	};
+
+
+	File=fopen(m_strConfigFile.c_str(),"a");
+	
+	if (!File)
+	{
+		return;
+	}
+
+	iter=m_FlagList.begin();
+	end=m_FlagList.end();
+
+
+
+	while (iter!=end)
+	{
+		if ((*iter)->NeedWritten())
+		{
+			if ((*iter)->GetComment()->size())
+			{
+				fprintf(File,"\"%s\" \t\"%s\" ; %s\n",(*iter)->GetName()->c_str(),(*iter)->GetFlags()->c_str(),(*iter)->GetComment()->c_str());
+			}
+			else
+			{
+				fprintf(File,"\"%s\" \t\"%s\"\n",(*iter)->GetName()->c_str(),(*iter)->GetFlags()->c_str());
+			}
+			(*iter)->SetNeedWritten(0);
+		}
+		++iter;
+	};
+
+	fclose(File);
+
+
+	// If NeedToRead was 0, then update the timestamp
+	// that was saved so we do not re-read this file
+	// next map
+	if (!NeedToRead)
+	{
+		stat(m_strConfigFile.c_str(),&TempStat);
+
+		m_Stat.st_mtime=TempStat.st_mtime;
+
+	}
+
+}
+
+int CFlagManager::ShouldIAddThisCommand(const AMX *amx, const cell *params, const char *cmdname) const
+{
+
+	// If flagmanager is disabled then ignore this
+	if (m_iDisabled)
+	{
+		return 0;
+	}
+	
+	
+	// If 5th param exists it was compiled after this change was made
+	// if it does not exist, try our logic at the end of this function
+	// 5th param being > 0 means explicit yes
+	// < 0 means auto detect (default is -1), treat it like there was no 5th param
+	// 0 means explicit no
+
+	if ((params[0] / sizeof(cell)) >= 5)
+	{
+		if (params[5]>0) // This command was explicitly told to be included
+		{
+			return 1;
+		}
+		else if (params[5]==0) // this command was explicitly told to NOT be used
+		{
+			return 0;
+		}
+	}
+
+	// auto detect if we should use this command
+
+	// if command access is -1 (default, not set to ADMIN_ALL or any other access), then no
+	if (params[3]==-1)
+	{
+		return 0;
+	}
+
+
+	// if command is (or starts with) "say", then no
+	if (strncmp(cmdname,"say",3)==0)
+	{
+		return 0;
+	}
+
+
+	// else use it
+	return 1;
+};
+
+
+void CFlagManager::Clear(void)
+{
+	List<CFlagEntry *>::iterator	 iter;
+	List<CFlagEntry *>::iterator	 end;
+
+	iter=m_FlagList.begin();
+	end=m_FlagList.end();
+
+	while (iter!=end)
+	{
+		delete (*iter);
+
+		++iter;
+	}
+
+	m_FlagList.clear();
+};
+
+void CFlagManager::CheckIfDisabled(void)
+{
+	if (atoi(get_localinfo("disableflagman","0"))==0)
+	{
+		m_iDisabled=0;
+	}
+	else
+	{
+		m_iDisabled=1;
+	}
+};

amxmodx/CFlagManager.h

@@ -0,0 +1,218 @@
+#ifndef CFLAGMANAGER_H
+#define CFLAGMANAGER_H
+
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "sh_list.h"
+#include "CString.h"
+
+#include "amxmodx.h"
+
+class CFlagEntry
+{
+private:
+	String			m_strName;			// command name ("amx_slap")
+	String			m_strFlags;			// string flags ("a","b")
+	String          m_strComment;		// comment to write ("; admincmd.amxx")
+	int				m_iFlags;			// bitmask flags
+	int				m_iNeedWritten;		// write this command on map change?
+	int				m_iHidden;			// set to 1 when the command is set to "!" access in
+										// the .ini file: this means do not process this command
+
+public:
+
+	CFlagEntry()
+	{
+		m_iNeedWritten=0;
+		m_iFlags=0;
+		m_iHidden=0;
+	};
+	const int NeedWritten(void) const
+	{
+		return m_iNeedWritten;
+	};
+
+	void SetNeedWritten(const int i=1)
+	{
+		m_iNeedWritten=i;
+	};
+
+	const String *GetName(void) const
+	{
+		return &m_strName;
+	};
+
+	const String *GetFlags(void) const
+	{
+		return &m_strFlags;
+	};
+	const String *GetComment(void) const
+	{
+		return &m_strComment;
+	};
+
+	const int Flags(void) const
+	{
+		return m_iFlags;
+	};
+
+	void SetName(const char *data)
+	{
+		m_strName.assign(data);
+	};
+	void SetFlags(const char *flags)
+	{
+		// If this is a "!" entry then stop
+		if (flags && flags[0]=='!')
+		{
+			SetHidden(1);
+			return;
+		}
+
+		m_strFlags.assign(flags);
+		m_iFlags=UTIL_ReadFlags(flags);
+	};
+	void SetFlags(const int flags)
+	{
+		m_iFlags=flags;
+
+		char FlagsString[32];
+		UTIL_GetFlags(FlagsString, flags);
+
+		m_strFlags.assign(FlagsString);
+	};
+	void SetComment(const char *comment)
+	{
+		m_strComment.assign(comment);
+	};
+	void SetHidden(int i=1)
+	{
+		m_iHidden=i;
+	};
+	int IsHidden(void) const
+	{
+		return m_iHidden;
+	};
+};
+class CFlagManager
+{
+private:
+	List<CFlagEntry *>		 m_FlagList;
+	String					 m_strConfigFile;
+	struct stat				 m_Stat;
+	int						 m_iForceRead;
+	int						 m_iDisabled;
+	
+
+	void CreateIfNotExist(void) const
+	{
+		FILE *fp;
+		
+		fp=fopen(m_strConfigFile.c_str(),"r");
+
+		if (!fp)
+		{
+			// File does not exist, create the header
+			fp=fopen(m_strConfigFile.c_str(),"a");
+
+			if (fp)
+			{
+				fprintf(fp,"; This file will store the commands used by plugins, and their access level\n");
+				fprintf(fp,"; To change the access of a command, edit the flags beside it and then\n");
+				fprintf(fp,";   change the server's map.\n;\n");
+				fprintf(fp,"; Example: If I wanted to change the amx_slap access to require\n");
+				fprintf(fp,";          RCON access (flag \"l\") I would change this:\n");
+				fprintf(fp,";          \"amx_slap\"  \"e\" ; admincmd.amxx\n");
+				fprintf(fp,";          To this:\n");
+				fprintf(fp,";          \"amx_slap\"  \"l\" ; admincmd.amxx\n;\n");
+				fprintf(fp,"; To disable a specific command from being used with the command manager\n");
+				fprintf(fp,";   and to only use the plugin-specified access set the flag to \"!\"\n;\n");
+				fprintf(fp,"; NOTE: The plugin name at the end is just for reference to what plugin\n");
+				fprintf(fp,";       uses what commands.  It is ignored.\n\n");
+				fclose(fp);
+			};
+		}
+	};
+	/**
+	 * Returns 1 if the timestamp for the file is different than the one we have loaded
+	 * 0 otherwise
+	 */
+	inline int NeedToLoad(void)
+	{
+		struct stat TempStat;
+
+		stat(m_strConfigFile.c_str(),&TempStat);
+
+		// If the modified timestamp does not match the stored
+		// timestamp than we need to re-read this file.
+		// Otherwise, ignore the file.
+		if (TempStat.st_mtime != m_Stat.st_mtime)
+		{
+			// Save down the modified timestamp
+			m_Stat.st_mtime=TempStat.st_mtime;
+			return 1;
+		};
+
+		return 0;
+
+	};
+public:
+
+	CFlagManager()
+	{
+		memset(&m_Stat,0x0,sizeof(struct stat));
+		m_iDisabled=0;
+		m_iForceRead=0;
+	};
+	~CFlagManager()
+	{
+	};
+
+	/**
+	 * Sets the filename in relation to amxmodx/configs
+	 */
+	void SetFile(const char *Filename="cmdaccess.ini");
+
+	const char *GetFile(void) const	{ return m_strConfigFile.c_str(); };
+	
+	/**
+	 * Parse the file, and load all entries
+	 * Returns 1 on success, 0 on refusal (no need to), and -1 on error
+	 */
+	const int LoadFile(const int force=0);
+
+	/**
+	 * Checks if the command exists in the list
+	 * If it does, it byrefs the flags for it
+	 * If it does not, it adds it to the list
+	 * These are added from register_*cmd calls
+	 */
+	void LookupOrAdd(const char *Command, int &Flags, AMX *Plugin);
+
+
+	/**
+	 * Write the commands back to the file
+	 */
+	void WriteCommands(void);
+
+	/**
+	 * Add this straight from the cmdaccess.ini file
+	 */
+	void AddFromFile(const char *Command, const char *Flags);
+
+	/**
+	 * Checks if this command should be added to flagman or not
+	 * This is only checked when adding commands from the register_* natives
+	 * If an admin manually adds a command to cmdaccess.ini it will be used
+	 *   regardless of whatever this function would say should be done with it
+	 */
+	int ShouldIAddThisCommand(const AMX *amx, const cell *params, const char *cmdname) const;
+
+	void Clear(void);
+
+	void CheckIfDisabled(void);
+};
+
+#endif // CFLAGMANAGER_H

amxmodx/CForward.cpp

@@ -30,21 +30,30 @@
 */
 
 #include "amxmodx.h"
+#include "debugger.h"
+#include "binlog.h"
 
-void AMXAPI amxx_InvalidateTrace(AMX *amx);
+CForward::CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam *paramTypes, int fwd_type)
-
-CForward::CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam *paramTypes)
 {
 	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 ((fwd_type != FORWARD_ALL) &&
+			((fwd_type == FORWARD_ONLY_NEW && ((*iter).getAMX()->flags & AMX_FLAG_OLDFILE))
+			|| (fwd_type == FORWARD_ONLY_OLD && !((*iter).getAMX()->flags & AMX_FLAG_OLDFILE))
+			))
+		{
+			continue;
+		}
 		if ((*iter).isValid() && amx_FindPublic((*iter).getAMX(), name, &func) == AMX_ERR_NONE)
 		{
 			AMXForward tmp;
@@ -53,6 +62,8 @@ CForward::CForward(const char *name, ForwardExecType et, int numParams, const Fo
 			m_Funcs.push_back(tmp);
 		}
 	}
+
+	m_Name.assign(name);
 }
 
 cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
@@ -64,8 +75,6 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 
 	cell globRetVal = 0;
 
-	unsigned int id = 0;
-
 	AMXForwardList::iterator iter;
 
 	for (iter = m_Funcs.begin(); iter != m_Funcs.end(); iter++)
@@ -74,67 +83,79 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 		{
 			// Get debug info
 			AMX *amx = (*iter).pPlugin->getAMX();
-			AMX_DBGINFO *pInfo = (AMX_DBGINFO *)(amx->userdata[2]);
+			Debugger *pDebugger = (Debugger *)amx->userdata[UD_DEBUGGER];
-			if (pInfo)
+			
-				pInfo->error = AMX_ERR_NONE;
+			if (pDebugger)
+				pDebugger->BeginExec();
+			
 			// handle strings & arrays
-			int i, ax=0;
+			int i;
+			
 			for (i = 0; i < m_NumParams; ++i)
 			{
 				if (m_ParamTypes[i] == FP_STRING || m_ParamTypes[i] == FP_STRINGEX)
 				{
+					const char *str = reinterpret_cast<const char*>(params[i]);
 					cell *tmp;
-					amx_Allot(iter->pPlugin->getAMX(),
+					if (!str)
-						(m_ParamTypes[i] == FP_STRING) ? strlen(reinterpret_cast<const char*>(params[i]))+1 : STRINGEX_MAXLENGTH,
+						str = "";
-						&realParams[i], &tmp);
+					amx_Allot(iter->pPlugin->getAMX(), (m_ParamTypes[i] == FP_STRING) ? strlen(str) + 1 : STRINGEX_MAXLENGTH, &realParams[i], &tmp);
-					amx_SetStringOld(tmp, (const char *)(params[i]), 0, 0);
+					amx_SetStringOld(tmp, str, 0, 0);
 					physAddrs[i] = tmp;
 				}
 				else if (m_ParamTypes[i] == FP_ARRAY)
 				{
 					cell *tmp;
-					amx_Allot(amx, preparedArrays[params[i]].size,
+					amx_Allot(amx, preparedArrays[params[i]].size, &realParams[i], &tmp);
-						&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 {
-					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 {
-				else
-				{
 					realParams[i] = params[i];
 				}
 			}
-			//Push the parameters in reverse order.  Weird, unfriendly part of Small 3.0!
+			
-			for (i=m_NumParams-1; i>=0; i--)
+			//Push the parameters in reverse order. Weird, unfriendly part of Small 3.0!
+			for (i = m_NumParams-1; i >= 0; i--)
 			{
 				amx_Push(amx, realParams[i]);
 			}
+			
 			// exec
-			cell retVal;
+			cell retVal = 0;
+#if defined BINLOG_ENABLED
+			g_BinLog.WriteOp(BinLog_CallPubFunc, (*iter).pPlugin->getId(), iter->func);
+#endif
 			int err = amx_Exec(amx, &retVal, iter->func);
+			
 			// log runtime error, if any
 			if (err != AMX_ERR_NONE)
 			{
 				//Did something else set an error?
-				if (pInfo && pInfo->error != AMX_ERR_NONE)
+				if (pDebugger && pDebugger->ErrorExists())
 				{
 					//we don't care, something else logged the error.
-				} else {
+				}
+				else if (err != -1)
+				{
 					//nothing logged the error so spit it out anyway
-					LogError(amx, err, "");
+					LogError(amx, err, NULL);
 				}
 			}
-			amxx_InvalidateTrace(amx);
+			
 			amx->error = AMX_ERR_NONE;
 			
+			if (pDebugger)
+				pDebugger->EndExec();
+
 			// cleanup strings & arrays
 			for (i = 0; i < m_NumParams; ++i)
 			{
@@ -157,10 +178,9 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 						if (preparedArrays[params[i]].type == Type_Cell)
 						{
 							memcpy(preparedArrays[params[i]].ptr, tmp, preparedArrays[params[i]].size * sizeof(cell));
-						}
+						} else {
-						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);
 						}
@@ -172,35 +192,42 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 			// decide what to do (based on exectype and retval)
 			switch (m_ExecType)
 			{
-			case ET_IGNORE:
+				case ET_IGNORE:
-				break;
+					break;
-			case ET_STOP:
+				case ET_STOP:
-				if (retVal > 0)
+					if (retVal > 0)
-					return retVal;
+						return retVal;
-			case ET_STOP2:
+				case ET_STOP2:
-				if (retVal == 1)
+					if (retVal == 1)
-					return 1;
+						return 1;
-				else if (retVal > globRetVal)
+					else if (retVal > globRetVal)
-					globRetVal = retVal;
+						globRetVal = retVal;
-				break;
+					break;
-			case ET_CONTINUE:
+				case ET_CONTINUE:
-				if (retVal > globRetVal)
+					if (retVal > globRetVal)
-					globRetVal = retVal;
+						globRetVal = retVal;
-				break;
+					break;
 			}
 		}
 	}
+	
 	return globRetVal;
 }
 
 void CSPForward::Set(int func, AMX *amx, int numParams, const ForwardParam *paramTypes)
 {
+	char name[sNAMEMAX];
 	m_Func = func;
 	m_Amx = amx;
 	m_NumParams = numParams;
 	memcpy((void *)m_ParamTypes, paramTypes, numParams * sizeof(ForwardParam));
 	m_HasFunc = true;
 	isFree = false;
+	name[0] = '\0';
+	amx_GetPublic(amx, func, name);
+	m_Name.assign(name);
+	m_ToDelete = false;
+	m_InExec = false;
 }
 
 void CSPForward::Set(const char *funcName, AMX *amx, int numParams, const ForwardParam *paramTypes)
@@ -210,6 +237,9 @@ void CSPForward::Set(const char *funcName, AMX *amx, int numParams, const Forwar
 	memcpy((void *)m_ParamTypes, paramTypes, numParams * sizeof(ForwardParam));
 	m_HasFunc = (amx_FindPublic(amx, funcName, &m_Func) == AMX_ERR_NONE);
 	isFree = false;
+	m_Name.assign(funcName);
+	m_ToDelete = false;
+	m_InExec = false;
 }
 
 cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
@@ -222,69 +252,81 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 	cell realParams[FORWARD_MAX_PARAMS];
 	cell *physAddrs[FORWARD_MAX_PARAMS];
 
-	if (!m_HasFunc)
+	if (!m_HasFunc || m_ToDelete)
 		return 0;
 
 	CPluginMngr::CPlugin *pPlugin = g_plugins.findPluginFast(m_Amx);
 	if (!pPlugin->isExecutable(m_Func))
 		return 0;
 
-	AMX_DBGINFO *pInfo = (AMX_DBGINFO *)(m_Amx->userdata[2]);
+	m_InExec = true;
-	if (pInfo)
+
-		pInfo->error = AMX_ERR_NONE;
+	Debugger *pDebugger = (Debugger *)m_Amx->userdata[UD_DEBUGGER];
+	if (pDebugger)
+		pDebugger->BeginExec();
 
 	// handle strings & arrays
 	int i;
+	
 	for (i = 0; i < m_NumParams; ++i)
 	{
 		if (m_ParamTypes[i] == FP_STRING || m_ParamTypes[i] == FP_STRINGEX)
 		{
+			const char *str = reinterpret_cast<const char*>(params[i]);
+			if (!str)
+				str = "";
 			cell *tmp;
-			amx_Allot(m_Amx,
+			amx_Allot(m_Amx, (m_ParamTypes[i] == FP_STRING) ? strlen(str) + 1 : STRINGEX_MAXLENGTH, &realParams[i], &tmp);
-				(m_ParamTypes[i] == FP_STRING) ? strlen(reinterpret_cast<const char*>(params[i]))+1 : STRINGEX_MAXLENGTH,
+			amx_SetStringOld(tmp, str, 0, 0);
-				&realParams[i], &tmp);
-			amx_SetStringOld(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,
+			amx_Allot(m_Amx, preparedArrays[params[i]].size, &realParams[i], &tmp);
-				&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 {
-			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 {
-		else
-		{
 			realParams[i] = params[i];
 		}
 	}
-	for (i=m_NumParams-1; i>=0; i--)
+	
+	for (i = m_NumParams - 1; i >= 0; i--)
 		amx_Push(m_Amx, realParams[i]);
+	
 	// exec
 	cell retVal;
+#if defined BINLOG_ENABLED
+	g_BinLog.WriteOp(BinLog_CallPubFunc, pPlugin->getId(), m_Func);
+#endif
 	int err = amx_Exec(m_Amx, &retVal, m_Func);
+	
 	if (err != AMX_ERR_NONE)
 	{
 		//Did something else set an error?
-		if (pInfo && pInfo->error != AMX_ERR_NONE)
+		if (pDebugger && pDebugger->ErrorExists())
 		{
 			//we don't care, something else logged the error.
-		} else {
+		}
+		else if (err != -1)
+		{
 			//nothing logged the error so spit it out anyway
-			LogError(m_Amx, err, "");
+			LogError(m_Amx, err, NULL);
 		}
 	}
-	amxx_InvalidateTrace(m_Amx);
+	
+	if (pDebugger)
+		pDebugger->EndExec();
+	
 	m_Amx->error = AMX_ERR_NONE;
 
 	// cleanup strings & arrays
@@ -309,10 +351,9 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 				if (preparedArrays[params[i]].type == Type_Cell)
 				{
 					memcpy(preparedArrays[params[i]].ptr, tmp, preparedArrays[params[i]].size * sizeof(cell));
-				}
+				} else {
-				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);
 				}
@@ -321,16 +362,23 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 		}
 	}
 
+	m_InExec = false;
+
 	return retVal;
 }
 
-int CForwardMngr::registerForward(const char *funcName, ForwardExecType et, int numParams, const ForwardParam * paramTypes)
+int CForwardMngr::registerForward(const char *funcName, ForwardExecType et, int numParams, const ForwardParam * paramTypes, int fwd_type)
 {
 	int retVal = m_Forwards.size() << 1;
-	CForward *tmp = new CForward(funcName, et, numParams, paramTypes);
+	CForward *tmp = new CForward(funcName, et, numParams, paramTypes, fwd_type);
+	
 	if (!tmp)
+	{
 		return -1;				// should be invalid
+	}
+	
 	m_Forwards.push_back(tmp);
+	
 	return retVal;
 }
 
@@ -338,22 +386,26 @@ int CForwardMngr::registerSPForward(int func, AMX *amx, int numParams, const For
 {
 	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 {
-	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;
@@ -362,6 +414,7 @@ int CForwardMngr::registerSPForward(int func, AMX *amx, int numParams, const For
 					 
 		m_SPForwards.push_back(pForward);
 	}
+	
 	return retVal;
 }
 
@@ -369,56 +422,93 @@ int CForwardMngr::registerSPForward(const char *funcName, AMX *amx, int numParam
 {
 	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 = 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 {
-	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) ?
+	return (id >= 0) && ((id & 1) ? (static_cast<size_t>(id >> 1) < m_SPForwards.size()) : (static_cast<size_t>(id >> 1) < m_Forwards.size()));
-		(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) : 
+	int retVal;
-		m_Forwards[id >> 1]->execute(params, m_TmpArrays);
+	if (id & 1)
+	{
+		CSPForward *fwd = m_SPForwards[id >> 1];
+		retVal = fwd->execute(params, m_TmpArrays);
+		if (fwd->m_ToDelete)
+		{
+			fwd->m_ToDelete = false;
+			unregisterSPForward(id);
+		}
+	} else {
+		retVal = m_Forwards[id >> 1]->execute(params, m_TmpArrays);
+	}
+
 	m_TmpArraysNum = 0;
+	
 	return retVal;
 }
 
+const char *CForwardMngr::getFuncName(int id) const
+{
+	if (!isIdValid(id))
+	{
+		return "";
+	}
+	return (id & 1) ? m_SPForwards[id >> 1]->getFuncName() : m_Forwards[id >> 1]->getFuncName();
+}
+
+int CForwardMngr::getFuncsNum(int id) const
+{
+	if (!isIdValid(id))
+	{
+		return 0;
+	}
+	return (id & 1) ? m_SPForwards[id >> 1]->getFuncsNum() : m_Forwards[id >> 1]->getFuncsNum();
+}
+
 int CForwardMngr::getParamsNum(int id) const
 {
-	return (id & 1) ? m_SPForwards[id >> 1]->getParamsNum() :
+	return (id & 1) ? m_SPForwards[id >> 1]->getParamsNum() : m_Forwards[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) :
+	if (!isIdValid(id))
-		m_Forwards[id >> 1]->getParamType(paramNum);
+	{
+		return FP_DONE;
+	}
+	return (id & 1) ? m_SPForwards[id >> 1]->getParamType(paramNum) : m_Forwards[id >> 1]->getParamType(paramNum);
 }
 
 void CForwardMngr::clear()
@@ -427,7 +517,9 @@ void CForwardMngr::clear()
 	{
 		delete *iter;
 	}
+	
 	SPForwardVec::iterator spIter;
+	
 	for (spIter = m_SPForwards.begin(); spIter != m_SPForwards.end(); ++spIter)
 	{
 		delete (*spIter);
@@ -435,8 +527,10 @@ void CForwardMngr::clear()
 
 	m_Forwards.clear();
 	m_SPForwards.clear();
+	
 	while (!m_FreeSPForwards.empty())
 		m_FreeSPForwards.pop();
+	
 	m_TmpArraysNum = 0;
 }
 
@@ -448,74 +542,160 @@ bool CForwardMngr::isSPForward(int id) const
 void CForwardMngr::unregisterSPForward(int id)
 {
 	//make sure the id is valid
-	if ( !isIdValid(id) || m_SPForwards.at(id >> 1)->isFree )
+	if (!isIdValid(id) || m_SPForwards.at(id >> 1)->isFree)
+	{
 		return;
+	}
 
-	m_SPForwards.at(id >> 1)->isFree = true;
+	CSPForward *fwd = m_SPForwards.at(id >> 1);
 
-	m_FreeSPForwards.push(id);
+	if (fwd->m_InExec)
+	{
+		fwd->m_ToDelete = true;
+	} else {
+		fwd->isFree = true;
+		m_FreeSPForwards.push(id);
+	}
+}
+
+int CForwardMngr::duplicateSPForward(int id)
+{
+	if (!isIdValid(id) || m_SPForwards.at(id >> 1)->isFree)
+	{
+		return -1;
+	}
+
+	CSPForward *fwd = m_SPForwards.at(id >> 1);
+	
+	return registerSPForward(fwd->m_Func, fwd->m_Amx, fwd->m_NumParams, fwd->m_ParamTypes);
+}
+
+int CForwardMngr::isSameSPForward(int id1, int id2)
+{
+	if (!isIdValid(id1) || !isIdValid(id2))
+	{
+		return false;
+	}
+
+	CSPForward *fwd1 = m_SPForwards.at(id1 >> 1);
+	CSPForward *fwd2 = m_SPForwards.at(id2 >> 1);
+
+	if (fwd1->isFree || fwd2->isFree)
+	{
+		return false;
+	}
+
+	return ((fwd1->m_Amx == fwd2->m_Amx)
+			&& (fwd1->m_Func == fwd2->m_Func)
+			&& (fwd1->m_NumParams == fwd2->m_NumParams));
+}
+
+int registerForwardC(const char *funcName, ForwardExecType et, cell *list, size_t num, int fwd_type)
+{
+	ForwardParam params[FORWARD_MAX_PARAMS];
+	
+	for (size_t i=0; i<num; i++)
+	{
+		params[i] = static_cast<ForwardParam>(list[i]);
+	}
+	
+	return g_forwards.registerForward(funcName, et, num, params, fwd_type);
 }
 
 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)
 			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 registerSPForwardByNameC(AMX *amx, const char *funcName, cell *list, size_t num)
+{
+	ForwardParam params[FORWARD_MAX_PARAMS];
+	
+	for (size_t i=0; i<num; i++)
+		params[i] = static_cast<ForwardParam>(list[i]);
+
+	return g_forwards.registerSPForward(funcName, amx, num, 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);
 }
 
@@ -525,9 +705,12 @@ cell executeForwards(int 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)
@@ -538,7 +721,9 @@ cell executeForwards(int id, ...)
 		else
 			params[i] = (cell)va_arg(argptr, cell);
 	}
+	
 	va_end(argptr);
+	
 	return g_forwards.executeForwards(id, params);
 }
 
@@ -546,13 +731,16 @@ cell CForwardMngr::prepareArray(void *ptr, unsigned int size, ForwardArrayElemTy
 {
 	if (m_TmpArraysNum >= FORWARD_MAX_PARAMS)
 	{
-		#ifdef MEMORY_TEST
+#ifdef MEMORY_TEST
 		m_validateAllAllocUnits();
-		#endif // MEMORY_TEST
+#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;

amxmodx/CForward.h

@@ -46,8 +46,15 @@
 #ifndef FORWARD_H
 #define FORWARD_H
 
+#include <stdarg.h>
+#include "sh_stack.h"
+
 const int FORWARD_MAX_PARAMS = 32;
 
+#define FORWARD_ONLY_OLD	1
+#define FORWARD_ONLY_NEW	2
+#define FORWARD_ALL			3
+
 enum ForwardExecType
 {
 	ET_IGNORE = 0,					// Ignore return vaue
@@ -77,7 +84,9 @@ enum ForwardArrayElemType
 struct ForwardPreparedArray
 {
 	void *ptr;
+	
 	ForwardArrayElemType type;
+	
 	unsigned int size;
 	bool copyBack;
 };
@@ -88,31 +97,45 @@ class CForward
 	const char *m_FuncName;
 	ForwardExecType m_ExecType;
 	int m_NumParams;
+	String m_Name;
+	
 	struct AMXForward
 	{
 		CPluginMngr::CPlugin *pPlugin;
 		int func;
 	};
+	
 	typedef CVector<AMXForward> AMXForwardList;
+	
 	AMXForwardList m_Funcs;
 	ForwardParam m_ParamTypes[FORWARD_MAX_PARAMS];
+
 public:
-	CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam * paramTypes);
+	CForward(const char *name, ForwardExecType et, int numParams, const ForwardParam * paramTypes, int fwd_type=FORWARD_ALL);
-	CForward()
+	CForward() {}		// leaves everything unitialized'
-	{ }			// leaves everything unitialized'
+	
 	cell execute(cell *params, ForwardPreparedArray *preparedArrays);
+	
 	int getParamsNum() const
 	{
 		return m_NumParams;
 	}
+	
 	int getFuncsNum() const
 	{
 		return m_Funcs.size();
 	}
+
+	const char *getFuncName() const
+	{
+		return m_Name.c_str();
+	}
+	
 	ForwardParam getParamType(int paramId) const
 	{
 		if (paramId < 0 || paramId >= m_NumParams)
 			return FP_DONE;
+		
 		return m_ParamTypes[paramId];
 	}
 };
@@ -120,12 +143,18 @@ public:
 // Single plugin forward
 class CSPForward
 {
-	const char *m_FuncName;
+	friend class CForwardMngr;
 	int m_NumParams;
+	
 	ForwardParam m_ParamTypes[FORWARD_MAX_PARAMS];
 	AMX *m_Amx;
+	
 	int m_Func;
 	bool m_HasFunc;
+	String m_Name;
+	bool m_InExec;
+	bool m_ToDelete;
+
 public:
 	bool isFree;
 public:
@@ -134,18 +163,27 @@ public:
 	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;
 	}
+
+	const char *getFuncName() const
+	{
+		return m_Name.c_str();
+	}
+	
 	ForwardParam getParamType(int paramId) const
 	{
 		if (paramId < 0 || paramId >= m_NumParams)
 			return FP_DONE;
+		
 		return m_ParamTypes[paramId];
 	}
 };
@@ -154,45 +192,52 @@ class CForwardMngr
 {
 	typedef CVector<CForward*> ForwardVec;
 	typedef CVector<CSPForward*> SPForwardVec;
-	typedef CQueue<int> FreeSPVec;					// Free SP Forwards
+	typedef CStack<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
+	ForwardPreparedArray m_TmpArrays[FORWARD_MAX_PARAMS];	// used by prepareArray
 	int m_TmpArraysNum;
 public:
 
 	CForwardMngr()
 	{ m_TmpArraysNum = 0; }
-	~CForwardMngr()
+	~CForwardMngr() {}
-	{ }
 
 	// Interface
 	// Register normal forward
-	int registerForward(const char *funcName, ForwardExecType et, int numParams, const ForwardParam *paramTypes);
+	int registerForward(const char *funcName, ForwardExecType et, int numParams, const ForwardParam *paramTypes, int fwd_type=FORWARD_ALL);
 	// Register single plugin forward
 	int registerSPForward(const char *funcName, AMX *amx, int numParams, const ForwardParam * paramTypes);
 	int registerSPForward(int func, AMX *amx, int numParams, const ForwardParam * paramTypes);
+	
 	// Unregister single plugin forward
 	void unregisterSPForward(int id);
+	int duplicateSPForward(int id);
+	int isSameSPForward(int id1, int id2);
+	
 	// execute forward
 	cell executeForwards(int id, cell *params);
-	void clear();		// delete all forwards
+	void clear();							// delete all forwards
+	
 	bool isIdValid(int id) const;			// check whether forward id is valid
 	bool isSPForward(int id) const;			// check whether forward is single plugin
 	int getParamsNum(int id) const;			// get num of params of a forward
 	int getFuncsNum(int id) const;			// get num of found functions of a forward
+	const char *getFuncName(int id) const;	// get the function name
+	
 	ForwardParam getParamType(int id, int paramId) const;
-	cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type,
+	cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type, bool copyBack);		// prepare array
-		bool copyBack);		// prepare array
 };
 
 // (un)register forward
 int registerForward(const char *funcName, ForwardExecType et, ...);
+int registerForwardC(const char *funcName, ForwardExecType et, cell *list, size_t num, int fwd_type=FORWARD_ALL);
 int registerSPForwardByName(AMX *amx, const char *funcName, ...);
+int registerSPForwardByNameC(AMX *amx, const char *funcName, cell *list, size_t num);
 int registerSPForward(AMX *amx, int func, ...);
 void unregisterSPForward(int id);
 
@@ -202,5 +247,4 @@ cell executeForwards(int id, ...);
 cell prepareCellArray(cell *ptr, unsigned int size, bool copyBack = false);
 cell prepareCharArray(char *ptr, unsigned int size, bool copyBack = false);
 
-#endif
+#endif //FORWARD_H
-

amxmodx/CLang.h

@@ -32,27 +32,56 @@
 #ifndef _INCLUDE_CLANG_H
 #define _INCLUDE_CLANG_H
 
+#include "sh_tinyhash.h"
+
 #define LANG_SERVER 0
 #define LANG_PLAYER -1
 
+#define ERR_BADKEY	1	// Lang key not found
+#define ERR_BADLANG 2	// Invalid lang
+
 struct md5Pair
 {
 	String file;
 	String val;
 };
 
-struct keyEntry
-{
-	String key;
-	uint32_t hash;
-};
-
 struct sKeyDef
 {
-	sKeyDef() { key = -1; def = 0; }
+	String *definition;
-	~sKeyDef() { if (def) delete def; }
 	int key;
-	String *def;
+};
+
+struct lang_err
+{
+	lang_err() : last(0.0f)
+	{
+	};
+	float last;
+};
+
+class defentry
+{
+public:
+	defentry() : definition(NULL)
+	{
+	};
+	defentry(const defentry &src)
+	{
+		definition = src.definition;
+	}
+	~defentry()
+	{
+	}
+	String *definition;
+};
+
+struct keytbl_val
+{
+	keytbl_val() : index(-1)
+	{
+	};
+	int index;
 };
 
 class CLangMngr
@@ -68,84 +97,43 @@ class CLangMngr
 		~CLang();
 
 		// Get the definition
-		const char *GetDef(const char *key);
+		const char *GetDef(int key, int &status);
 		// Add definitions to this language
-		void MergeDefinitions(CQueue <sKeyDef*> & vec);
+		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;
+			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(); }
+		int Entries();
-		// Make a hash from a string; convert to lowercase first if needed
-		static uint32_t MakeHash(const char *src, bool makeLower = false);
 	protected:
-
+		typedef THash<int, defentry> LookUpVec;
-		// An entry in the language
+		typedef LookUpVec::iterator	 LookUpVecIter;
-		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;
+		int m_entries;
 		CLangMngr *m_LMan;
 	public:
-		LangEntry *AddEntry(int pKey, uint32_t defHash, const char *def, bool cache);
+		void AddEntry(int key, const char *definition);
 	};
-
+public:
 	// Merge definitions into a language
-	void MergeDefinitions(const char *lang, CQueue <sKeyDef*> &tmpVec);
+	void MergeDefinitions(const char *lang, CQueue <sKeyDef> &tmpVec);
+
+private:
 	// strip lowercase; make lower if needed
-	static size_t strip(char *str, char *newstr, bool makelower=false);
+	static size_t strip(char *str, char *newstr, bool makelower = false);
 
 	typedef CVector<CLang*> LangVec;
 	typedef CVector<CLang*>::iterator LangVecIter;
@@ -153,7 +141,8 @@ class CLangMngr
 	LangVec m_Languages;
 
 	CVector<md5Pair *> FileList;
-	CVector<keyEntry*> KeyList;
+	CVector<String *> KeyList;
+	THash<String, keytbl_val> KeyTable;
 
 	// Get a lang object (construct if needed)
 	CLang * GetLang(const char *name);
@@ -165,30 +154,19 @@ class CLangMngr
 public:
 	// Merge a definitions file
 	int MergeDefinitionFile(const char *file);
-	// Get a definition from a lang name and a kyer
+	// Get a definition from a lang name and a key
-	const char *GetDef(const char *langName, const char *key);
+	const char *GetDef(const char *langName, const char *key, int &status);
-	// 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);
+	void InvalidateCache();
-	// 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
+	int AddKeyEntry(const char *key);
-	uint32_t MakeHash(const char *src, bool makeLower);
 
 	// Get the number of languages
 	int GetLangsNum();
@@ -200,6 +178,8 @@ public:
 	// 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);
 
+	inline int GetDefLang() const { return m_CurGlobId; }
+
 	// Reset
 	void Clear();
 

amxmodx/CList.h

@@ -35,6 +35,7 @@
 // *****************************************************
 // class CList
 // *****************************************************
+
 // Linked list
 template <typename T, typename F = char* >
 class CList
@@ -65,8 +66,10 @@ private:
 		~CElement()
 		{
 			delete m_pObject;
+			
 			if (m_pNext)
 				m_pNext->m_pPrev = m_pPrev;
+			
 			if (m_pPrev)
 				m_pPrev->m_pNext = m_pNext;
 		}
@@ -102,15 +105,16 @@ private:
 		}
 	};
 
-	// CList<T,F> class
+	// CList<T, F> class
 	CElement *m_pHead;					// head of the linked list
 	CElement *m_pTail;					// tail of the linked list
 public:
 	// iterator class
 	class iterator
 	{
-		friend class CList<T,F>;
+		friend class CList<T, F>;
-		CList<T,F> *m_pList;			// The list that created this iterator
+		
+		CList<T, F> *m_pList;			// The list that created this iterator
 		CElement *m_CurPos;				// Current position in the list
 	public:
 		iterator()
@@ -120,7 +124,7 @@ public:
 		}
 
 		// constructor based on list, element
-		iterator(CList<T,F> *pList, CElement *startPos)
+		iterator(CList<T, F> *pList, CElement *startPos)
 		{
 			m_pList = pList;
 			m_CurPos = startPos;
@@ -147,7 +151,7 @@ public:
 		// validity check operator
 		inline operator bool () const
 		{
-			return m_pList!=NULL && m_CurPos!=NULL && m_CurPos->GetObj()!=NULL;
+			return m_pList != NULL && m_CurPos != NULL && m_CurPos->GetObj() != NULL;
 		}
 
 		// pre increment operator
@@ -162,6 +166,7 @@ public:
 		{
 			iterator tmp(*this);
 			m_CurPos = m_CurPos->next;
+			
 			return tmp;
 		}
 
@@ -176,18 +181,20 @@ public:
 		{
 			return m_pList->remove(*this);
 		}
+		
 		iterator put(T *obj)
 		{
 			return m_pList->put(obj, *this);
 		}
 	};
 
-	CList<T,F>()
+	CList<T, F>()
 	{
 		m_pHead = NULL;
 		m_pTail = NULL;
 	}
-	~CList<T,F>()
+	
+	~CList<T, F>()
 	{
 		clear();
 	}
@@ -198,12 +205,16 @@ public:
 	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;
 	}
 
@@ -212,36 +223,36 @@ public:
 	iterator put_back(T *pObj)
 	{
 		CElement *pTmp = new CElement(pObj);
+		
 		if (!m_pHead)
 		{
 			m_pHead = pTmp;
 			m_pTail = pTmp;
-		}
+		} else {
-		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 {
-		else
-		{
 			pTmp->SetNext(m_pHead);
 			pTmp->SetPrev(NULL);
 			m_pHead->SetPrev(pTmp);
 			m_pHead = pTmp;
 		}
+		
 		return iterator(this, pTmp);
 	}
 
@@ -257,6 +268,7 @@ public:
 	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
@@ -266,6 +278,7 @@ public:
 		pTmp->SetNext(where.m_CurPos->GetNext());
 
 		where.m_CurPos->SetNext(pTmp);
+		
 		return ++where;
 	}
 
@@ -283,12 +296,13 @@ public:
 	iterator find(iterator startOn, const F &desc)
 	{
 		iterator iter = startOn;
-		while(iter)
+		while (iter)
 		{
 			if (*iter == desc)
 				break;
 			++iter;
 		}
+		
 		return iter;
 	}
 
@@ -300,14 +314,16 @@ public:
 	int size()
 	{
 		iterator iter = begin();
-		int i=0;
+		int i = 0;
+		
 		while (iter)
 		{
 			++i;
 			++iter;
 		}
+		
 		return i;
 	}
 };
-#endif
 
+#endif //CLIST_H

amxmodx/CLogEvent.cpp

@@ -35,135 +35,192 @@
 // *****************************************************
 // class LogEventsMngr
 // *****************************************************
-LogEventsMngr::LogEventsMngr() {
+
-  logCurrent = logCounter = 0;
+LogEventsMngr::LogEventsMngr()
-  logcmplist = 0;
+{
-  arelogevents = false;
+	logCurrent = logCounter = 0;
-  memset( logevents, 0, sizeof(logevents) );
+	logcmplist = 0;
+	arelogevents = false;
+	memset(logevents, 0, sizeof(logevents));
 }
 
-LogEventsMngr::~LogEventsMngr() {
+LogEventsMngr::~LogEventsMngr()
-  clearLogEvents();
+{
+	clearLogEvents();
 }
 
-int LogEventsMngr::CLogCmp::compareCondition(const char* string){
+int LogEventsMngr::CLogCmp::compareCondition(const char* string)
-  if ( logid == parent->logCounter )
+{
-    return result;
+	if (logid == parent->logCounter)
-  logid = parent->logCounter;
+		return result;
-  if ( in ) return result = strstr( string , text.c_str() ) ? 0 : 1;
+	
-  return result = strcmp(string,text.c_str());
+	logid = parent->logCounter;
+	
+	if (in)
+		return result = strstr(string, text.c_str()) ? 0 : 1;
+	
+	return result = strcmp(string,text.c_str());
 }
 
-LogEventsMngr::CLogCmp* LogEventsMngr::registerCondition(char* filter){
+LogEventsMngr::CLogCmp* LogEventsMngr::registerCondition(char* filter)
+{
 	char* temp = filter;
 	// expand "1=message"
-    while ( isdigit(*filter) )
+
+	while (isdigit(*filter))
 		++filter;
-    bool in = (*filter=='&');
+
-    *filter++ = 0;
+	bool in = (*filter=='&');
-    int pos = atoi(temp);
+	*filter++ = 0;
-	if ( pos < 0 || pos >= MAX_LOGARGS) pos = 0;
+	int pos = atoi(temp);
+	
+	if (pos < 0 || pos >= MAX_LOGARGS)
+		pos = 0;
+	
 	CLogCmp* c = logcmplist;
-	while( c ) {
+	
-		if ( (c->pos==pos) && (c->in==in) && !strcmp(c->text.c_str(), filter))
+	while (c)
+	{
+		if ((c->pos == pos) && (c->in == in) && !strcmp(c->text.c_str(), filter))
 			return c;
 		c = c->next;
 	}
-	return logcmplist = new CLogCmp( filter , in , pos , logcmplist,this );
+	
+	return logcmplist = new CLogCmp(filter, in, pos, logcmplist, this);
 }
 
-void LogEventsMngr::CLogEvent::registerFilter( char* filter ){
+void LogEventsMngr::CLogEvent::registerFilter(char* filter)
-	CLogCmp *cmp = parent->registerCondition( filter );
+{
-	if ( cmp == 0 ) return;
+	CLogCmp *cmp = parent->registerCondition(filter);
-	for(LogCond* c = filters; c ; c = c->next){
+	if (cmp == 0) return;
-		if ( c->argnum == cmp->pos ){
+	
-			c->list = new LogCondEle( cmp , c->list );
+	for (LogCond* c = filters; c; c = c->next)
+	{
+		if (c->argnum == cmp->pos)
+		{
+			c->list = new LogCondEle(cmp, c->list);
 			return;
 		}
 	}
-	LogCondEle* aa = new LogCondEle( cmp , 0 );
+	
-	if ( aa == 0 ) return;
+	LogCondEle* aa = new LogCondEle(cmp, 0);
-	filters = new LogCond( cmp->pos , aa  , filters );
+	
+	if (aa == 0)
+		return;
+
+	filters = new LogCond(cmp->pos, aa, filters);
 }
 
-void LogEventsMngr::setLogString( char* frmt, va_list& vaptr ) {
+void LogEventsMngr::setLogString(const char* frmt, va_list& vaptr)
+{
 	++logCounter;
-	int len = vsnprintf (logString, 255 , frmt, vaptr );
+	int len = vsnprintf(logString, 255, frmt, vaptr);
-	if ( len == - 1) {
+	
+	if (len == - 1)
+	{
 		len = 255;
 		logString[len] = 0;
 	}
-	if ( len ) logString[--len] = 0;
+	
+	if (len)
+		logString[--len] = 0;
+	
 	logArgc = 0;
 }
 
-void LogEventsMngr::setLogString( char* frmt, ...  ) {
+void LogEventsMngr::setLogString(const char* frmt, ...)
+{
 	++logCounter;
 	va_list logArgPtr;
-	va_start ( logArgPtr , frmt );
+	va_start(logArgPtr, frmt);
-	int len = vsnprintf(logString, 255 , frmt, logArgPtr );
+	int len = vsnprintf(logString, 255, frmt, logArgPtr);
-	if ( len == - 1) {
+	
+	if (len == - 1)
+	{
 		len = 255;
 		logString[len] = 0;
 	}
-	va_end ( logArgPtr );
+	
-	if ( len ) logString[--len] = 0;
+	va_end(logArgPtr);
+	
+	if (len)
+		logString[--len] = 0;
+	
 	logArgc = 0;
 }
 
-void LogEventsMngr::parseLogString(   ) {
+void LogEventsMngr::parseLogString()
-  register const char* b = logString;
+{
-  register int a;
+	register const char* b = logString;
-  while( *b && logArgc < MAX_LOGARGS ){
+	register int a;
-    a = 0;
+	
-    if ( *b == '"' ) {
+	while (*b && logArgc < MAX_LOGARGS)
-      ++b;
+	{
-      while ( *b && *b != '"' && a < 127 ) 
+		a = 0;
-		  logArgs[logArgc][a++] = *b++;
+		
-      logArgs[logArgc++][a] = 0;
+		if (*b == '"')
-      if ( *b) b+=2; // thanks to double terminator
+		{
-    }
+			++b;
-    else if ( *b == '('  ) {
+			
-      ++b;
+			while (*b && *b != '"' && a < 127) 
-      while ( *b && *b != ')' && a < 127 ) 
+				logArgs[logArgc][a++] = *b++;
-		  logArgs[logArgc][a++] = *b++;
+			
-      logArgs[logArgc++][a] = 0;
+			logArgs[logArgc++][a] = 0;
-      if ( *b) b+=2;
+			if (*b) b+=2; // thanks to double terminator
-    }
+		}
-    else {
+		else if (*b == '(')
-      while ( *b && *b != '(' && *b != '"' && a < 127 ) 
+		{
-		  logArgs[logArgc][a++] = *b++;
+			++b;
-      if ( *b ) --a;
+			
-      logArgs[logArgc++][a] = 0;
+			while (*b && *b != ')' && a < 127) 
-    }
+				logArgs[logArgc][a++] = *b++;
-  }
+			
+			logArgs[logArgc++][a] = 0;
+			if (*b) b+=2;
+		} else {
+			while (*b && *b != '(' && *b != '"' && a < 127) 
+			logArgs[logArgc][a++] = *b++;
+			if (*b) --a;
+			logArgs[logArgc++][a] = 0;
+		}
+	}
 }
 
-LogEventsMngr::CLogEvent* LogEventsMngr::registerLogEvent( CPluginMngr::CPlugin* plugin,  int func, int pos )
+LogEventsMngr::CLogEvent* LogEventsMngr::registerLogEvent(CPluginMngr::CPlugin* plugin, int func, int pos)
 {
-  if ( pos < 1 || pos > MAX_LOGARGS)
+	if (pos < 1 || pos > MAX_LOGARGS)
-    return 0;
+		return 0;
-  arelogevents = true;
+
-  CLogEvent** d = &logevents[pos];
+	arelogevents = true;
-  while(*d) d = &(*d)->next;
+	CLogEvent** d = &logevents[pos];
-  return *d = new CLogEvent( plugin , func, this );
+	
+	while (*d)
+		d = &(*d)->next;
+	
+	return *d = new CLogEvent(plugin, func, this);
 }
 
 void LogEventsMngr::executeLogEvents()
 {
-    bool valid;
+	bool valid;
-    for(CLogEvent* a = logevents[ logArgc ]; a ; a = a->next)
+
+	for (CLogEvent* a = logevents[logArgc]; a; a = a->next)
 	{
 		valid = true;
-		for( CLogEvent::LogCond* b = a->filters; b ; b = b->next)
+		
+		for (CLogEvent::LogCond* b = a->filters; b; b = b->next)
 		{
 			valid = false;
-			for( CLogEvent::LogCondEle* c = b->list; c ; c = c->next) {
+
-				if ( c->cmp->compareCondition( logArgs[b->argnum] ) == 0 ){
+			for (CLogEvent::LogCondEle* c = b->list; c; c = c->next)
+			{
+				if (c->cmp->compareCondition(logArgs[b->argnum]) == 0)
+				{
 					valid = true;
 					break;
 				}
 			}
+			
 			if (!valid) 
 				break;
 		}
@@ -172,67 +229,90 @@ void LogEventsMngr::executeLogEvents()
 		{
 			executeForwards(a->func);
 		}
-    }
+	}
 }
 
-void LogEventsMngr::clearLogEvents(){
+void LogEventsMngr::clearLogEvents()
-  logCurrent = logCounter = 0;
+{
-  arelogevents = false;
+	logCurrent = logCounter = 0;
-  for(int i = 0; i < MAX_LOGARGS + 1; ++i){
+	arelogevents = false;
-    CLogEvent **a = &logevents[i];
+	
-    while(*a){
+	for (int i = 0; i < MAX_LOGARGS + 1; ++i)
-      CLogEvent* bb = (*a)->next;
+	{
-      delete *a;
+		CLogEvent **a = &logevents[i];
-      *a = bb;
+		while (*a)
-    }
+		{
-  }
+			CLogEvent* bb = (*a)->next;
-  clearConditions();
+			delete *a;
+			*a = bb;
+		}
+	}
+	
+	clearConditions();
 }
 
-void LogEventsMngr::clearConditions() {
+void LogEventsMngr::clearConditions()
-  while (logcmplist){
+{
-    CLogCmp* a = logcmplist->next;
+	while (logcmplist)
-    delete logcmplist;
+	{
-    logcmplist = a;
+		CLogCmp* a = logcmplist->next;
-  }
+		delete logcmplist;
+		logcmplist = a;
+	}
 }
 
-LogEventsMngr::CLogEvent::LogCond::~LogCond() {  
+LogEventsMngr::CLogEvent::LogCond::~LogCond()
-	while( list ) {
+{
+	while (list)
+	{
 		LogCondEle* cc = list->next;
 		delete list;
 		list = cc;
 	}
 }
 
-LogEventsMngr::CLogEvent::~CLogEvent() {
+LogEventsMngr::CLogEvent::~CLogEvent()
-	while( filters ) {
+{
+	while (filters)
+	{
 		LogCond* cc = filters->next;
 		delete filters;
 		filters = cc;
 	}
 }
 
-LogEventsMngr::CLogEvent *LogEventsMngr::getValidLogEvent( CLogEvent * a )
+LogEventsMngr::CLogEvent *LogEventsMngr::getValidLogEvent(CLogEvent * a)
 {
 	bool valid;
-	while(a){
+	
+	while (a)
+	{
 		valid = true;
-		for( CLogEvent::LogCond* b = a->filters; b ; b = b->next){
+		
+		for (CLogEvent::LogCond* b = a->filters; b; b = b->next)
+		{
 			valid = false;
-			for( CLogEvent::LogCondEle* c = b->list; c ; c = c->next) {
+
-				if ( c->cmp->compareCondition( logArgs[b->argnum] ) == 0 ){
+			for (CLogEvent::LogCondEle* c = b->list; c; c = c->next)
+			{
+				if (c->cmp->compareCondition(logArgs[b->argnum]) == 0)
+				{
 					valid = true;
 					break;
 				}
 			}
+			
 			if (!valid) break;
 		}
-		if (!valid){
+		
+		if (!valid)
+		{
 			a = a->next;
 			continue;
 		}
+		
 		return a;
 	}
+	
 	return 0;
 }

amxmodx/CLogEvent.h

@@ -40,126 +40,139 @@
 // class LogEventsMngr
 // *****************************************************
 
-class LogEventsMngr {
+class LogEventsMngr
-
+{
-  char logString[256];
+	char logString[256];
-  char logArgs[MAX_LOGARGS][128];
+	char logArgs[MAX_LOGARGS][128];
-  int logArgc;
+	int logArgc;
-  int logCounter;
+	int logCounter;
-  int logCurrent;
+	int logCurrent;
-  bool arelogevents;
+	bool arelogevents;
 
 public:
-  class CLogCmp;
+	class CLogCmp;
-  class iterator;
+	class iterator;
-  class CLogEvent;
+	class CLogEvent;
-
-  friend class CLogEvent;
-  friend class CLogCmp;
-  friend class iterator;
-
-  class CLogCmp 
-  {
-	friend class LogEventsMngr;
 	friend class CLogEvent;
-	LogEventsMngr* parent;
+	friend class CLogCmp;
-    String text;
-    int logid;
-    int pos;
-    int result;
-    bool in;
-    CLogCmp *next;
-    CLogCmp( const char* s, bool r, int p, CLogCmp *n, LogEventsMngr* mg ) : text(s) {
-      logid = result = 0;
-      pos = p;
-	  parent = mg;
-      in = r;
-      next = n;
-    }
-  public:
-
-	int compareCondition(const char* string);
-  };
-
-private:
-
-  CLogCmp *logcmplist;
-
-public:
-
-  class CLogEvent {
-	friend class LogEventsMngr;
 	friend class iterator;
-	struct LogCondEle {
+
-		CLogCmp *cmp;
+	class CLogCmp 
-		LogCondEle *next;
+	{
-		LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c) , next(n) { }
+		friend class LogEventsMngr;
+		friend class CLogEvent;
+		
+		LogEventsMngr* parent;
+		String text;
+		
+		int logid;
+		int pos;
+		int result;
+		bool in;
+		
+		CLogCmp *next;
+		
+		CLogCmp(const char* s, bool r, int p, CLogCmp *n, LogEventsMngr* mg) : text(s)
+		{
+			logid = result = 0;
+			pos = p;
+			parent = mg;
+			in = r;
+			next = n;
+		}
+	
+	public:
+		int compareCondition(const char* string);
 	};
-	struct LogCond {
-		int argnum;
-		LogCondEle *list;
-		LogCond *next;
-		LogCond( int a , LogCondEle* ee , LogCond* n ) : argnum(a) , list(ee), next(n)  {}
-		~LogCond();
-	};
-    CPluginMngr::CPlugin *plugin;
-    int func;
-    LogCond *filters;
-    LogEventsMngr* parent;
-    CLogEvent *next;
-    CLogEvent(CPluginMngr::CPlugin *p,int f, LogEventsMngr* ppp) : plugin(p),func(f), filters(0),parent(ppp) ,next(0) { }
-    ~CLogEvent();
-  public:
-	inline CPluginMngr::CPlugin *getPlugin() { return plugin; }
-	void registerFilter( char* filter );
-	inline int getFunction() { return func; }
-  };
 
 private:
-
+	CLogCmp *logcmplist;
-  CLogEvent *logevents[MAX_LOGARGS+1];
-  CLogEvent *getValidLogEvent( CLogEvent * a );
-  CLogCmp* registerCondition(char* filter);
-  void clearConditions();
-
 public:
 
-  LogEventsMngr();
+	class CLogEvent
-  ~LogEventsMngr();
+	{
+		friend class LogEventsMngr;
+		friend class iterator;
+		
+		struct LogCondEle
+		{
+			CLogCmp *cmp;
+			LogCondEle *next;
+			LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c), next(n) {}
+		};
+	
+		struct LogCond
+		{
+			int argnum;
+			
+			LogCondEle *list;
+			LogCond *next;
+			LogCond(int a, LogCondEle* ee, LogCond* n) : argnum(a), list(ee), next(n) {}
+			~LogCond();
+		};
+		
+		CPluginMngr::CPlugin *plugin;
+		
+		int func;
+		
+		LogCond *filters;
+		LogEventsMngr* parent;
+		
+		CLogEvent *next;
+		CLogEvent(CPluginMngr::CPlugin *p, int f, LogEventsMngr* ppp) : plugin(p), func(f), filters(0), parent(ppp), next(0) {}
+		~CLogEvent();
+	public:
+		inline CPluginMngr::CPlugin *getPlugin() { return plugin; }
+		void registerFilter(char* filter);
+		inline int getFunction() { return func; }
+	};
+
+private:
+	CLogEvent *logevents[MAX_LOGARGS + 1];
+	CLogEvent *getValidLogEvent(CLogEvent * a);
+	CLogCmp* registerCondition(char* filter);
+	
+	void clearConditions();
+public:
+	LogEventsMngr();
+	~LogEventsMngr();
 
 	// Interface
+	CLogEvent* registerLogEvent(CPluginMngr::CPlugin* plugin, int func, int pos);
+	inline bool logEventsExist() { return arelogevents; } 
 	
+	void setLogString(const char* frmt, va_list& vaptr);
+	void setLogString(const char* frmt, ...);
+	void parseLogString();
+	void executeLogEvents();
 	
-  CLogEvent* registerLogEvent( CPluginMngr::CPlugin* plugin,  int func, int pos );
+	inline const char* getLogString() { return logString; }
-  inline bool logEventsExist() { return arelogevents; } 
+	inline int getLogArgNum() { return logArgc; }
-  void setLogString( char* frmt, va_list& vaptr );
+	inline const char* getLogArg(int i) { return (i < 0 || i >= logArgc) ? "" : logArgs[i]; }
-  void setLogString( char* frmt , ... );
+	void clearLogEvents();
-  void parseLogString(  );
-  void executeLogEvents();
-  inline const char* getLogString() { return logString; }
-  inline int getLogArgNum() { return logArgc; }
-  inline const char* getLogArg( int i ) { return ( i < 0 || i >=  logArgc ) ? "" : logArgs[ i ]; }
-  void clearLogEvents();
 
+	class iterator
+	{
+		CLogEvent* a;
+		LogEventsMngr* b;
 	
-  class iterator {
+	public:
-	  CLogEvent* a;
+		inline iterator(CLogEvent*aa, LogEventsMngr* bb) : a(aa), b(bb) {}
-	  LogEventsMngr* b;
+			
-  public:
+		inline iterator& operator++()
-	  inline iterator(CLogEvent*aa,LogEventsMngr* bb) : a(aa), b(bb) {}
+		{
-	  inline iterator& operator++() {
+			a = b->getValidLogEvent(a->next);
-		  a = b->getValidLogEvent( a->next );
+			return *this;
-		  return *this;
+		}
-	  }
+
-	  inline bool operator==(const iterator& c) const { return a == c.a; }
+		inline bool operator==(const iterator& c) const { return a == c.a; }
-	  inline bool operator!=(const iterator& c) const  { return !operator==(c); }
+		inline bool operator!=(const iterator& c) const { return !operator == (c); }
-	  CLogEvent& operator*() { return *a; }
+		CLogEvent& operator*() { return *a; }
-	  operator bool ( ) const { return a ? true : false; }
+		operator bool () const { return a ? true : false; }
-  };
+	};
-  inline iterator begin() { return iterator(getValidLogEvent(logevents[ logArgc ]),this); }
+	
-  inline iterator end() { return iterator(0,this); }
+	inline iterator begin() { return iterator(getValidLogEvent(logevents[logArgc]), this); }
+	inline iterator end() { return iterator(0, this); }
 };
 
-#endif
+#endif //LOGEVENTS_H
-
-

amxmodx/CMenu.cpp

@@ -35,60 +35,101 @@
 // *****************************************************
 // class MenuMngr
 // *****************************************************
-MenuMngr::MenuCommand::MenuCommand( CPluginMngr::CPlugin *a, int mi, int k, int f ) {
+MenuMngr::MenuCommand::MenuCommand(CPluginMngr::CPlugin *a, int mi, int k, int f, bool new_menu)
+{
 	plugin = a;
 	keys = k;
 	menuid = mi;
-	function = f;
 	next = 0;
+	is_new_menu = new_menu;
+
+	function = f;
 }
 
 MenuMngr::~MenuMngr() 
 {
 	clear();
+	MenuMngr::MenuIdEle::uniqueid = 0;
 }
 
 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 ( (!amx || !b->amx || amx == b->amx) && strstr(name,b->name.c_str()) )
+	{
-      return b->id;
+		if ((!amx || !b->amx || amx == b->amx) && strstr(name,b->name.c_str()))
-  }
+			return b->id;
-  return 0;
+	}
+	
+	return 0;
 }
 
-int MenuMngr::registerMenuId(const char* n, AMX* a )
+int MenuMngr::registerMenuId(const char* n, AMX* a)
 {
-  int id = findMenuId( n, a );
+	int id = findMenuId(n, a);
-  if (id) return id;
+	
-  headid = new MenuIdEle( n, a , headid  );
+	if (id)
-  if (!headid)
+	{
-	  return 0;			// :TODO: Better error report
+		return id;
-  return headid->id;
+	}
+	
+	headid = new MenuIdEle(n, a, headid);
+	
+	return headid->id;
 }
 
-void MenuMngr::registerMenuCmd( CPluginMngr::CPlugin *a,int mi, int k , int f  ) 
+void MenuMngr::registerMenuCmd(CPluginMngr::CPlugin *a, int mi, int k, int f, bool from_new_menu) 
 {
-	MenuCommand** temp = &headcmd;
+	MenuCommand **temp = &headcmd;
-	while(*temp) temp = &(*temp)->next;
+	if (from_new_menu)
-	*temp = new MenuCommand(a,mi, k,f);
+	{
+		MenuCommand *ptr;
+		while (*temp)
+		{
+			ptr = *temp;
+			if (ptr->is_new_menu
+				&& ptr->plugin == a
+				&& ptr->menuid == mi)
+			{
+				if (g_forwards.isSameSPForward(ptr->function, f))
+				{
+					return;
+				}
+			}
+			temp = &(*temp)->next;
+		}
+	} else {
+		while (*temp)
+		{
+			temp = &(*temp)->next;
+		}
+	}
+	*temp = new MenuCommand(a, mi, k, f, from_new_menu);
 }
 
 void MenuMngr::clear()
 {
-  while (headid)
+	while (headid)
-  {
+	{
-    MenuIdEle* a = headid->next;
+		MenuIdEle* a = headid->next;
-    delete headid;
+		delete headid;
-    headid = a;
+		headid = a;
-  }
+	}
 
-  while (headcmd)
+	while (headcmd)
-  {
+	{
-    MenuCommand* a = headcmd->next;
+		MenuCommand* a = headcmd->next;
-    delete headcmd;
+		delete headcmd;
-    headcmd = a;
+		headcmd = a;
-  }
+	}
+}
+
+MenuMngr::iterator MenuMngr::SetWatchIter(MenuMngr::iterator iter)
+{
+	MenuMngr::iterator old = m_watch_iter;
+
+	m_watch_iter = iter;
+
+	return old;
 }
 
 int MenuMngr::MenuIdEle::uniqueid = 0;

amxmodx/CMenu.h

@@ -38,55 +38,62 @@
 
 class MenuMngr
 {
-  struct MenuIdEle
+	struct MenuIdEle
-  {
+	{
-    String name;
+		String name;
-    AMX* amx;
+		AMX* amx;
-    MenuIdEle* next;
+		MenuIdEle* next;
-	int id;
+		
-	static int uniqueid;
+		int id;
-    MenuIdEle( const char* n, AMX* a, MenuIdEle* m ) : name( n ) , amx(a) , next( m ) {
+		static int uniqueid;
-		id = ++uniqueid;
+		
-	}
+		MenuIdEle(const char* n, AMX* a, MenuIdEle* m) : name(n), amx(a), next(m)
-	~MenuIdEle() { --uniqueid; }
+		{
-  } *headid;
+			id = ++uniqueid;
+		}
+	} *headid;
 
 public:
-	class iterator;
+		class iterator;
-
 private:
 
-  class MenuCommand 
+	class MenuCommand 
-  {
+	{
-	  friend class iterator;
+		friend class iterator;
-	  friend class MenuMngr;
+		friend class MenuMngr;
 
-	  CPluginMngr::CPlugin *plugin;
+		CPluginMngr::CPlugin *plugin;
-	  int menuid;
+		int menuid;
-	  int keys;
+		int keys;
-	  int function;
+		int function;
-	  MenuCommand* next;
+		int is_new_menu;
-	  MenuCommand( CPluginMngr::CPlugin *a, int mi, int k, int f );
+		
-  public:
+		MenuCommand* next;
-	  inline int getFunction() { return function; }
+		MenuCommand(CPluginMngr::CPlugin *a, int mi, int k, int f, bool new_menu=false);
-	  inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
+	public:
-	  inline bool matchCommand( int m, int k  ) { return ((m == menuid) && (keys & k)); }
+		inline int getFunction() { return function; }
-  } *headcmd;
+		inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
+		inline bool matchCommand(int m, int k)
+		{
+			return ((m == menuid) && (keys & k));
+		}
+	} *headcmd;
 	
 public:
-	
+	MenuMngr() : m_watch_iter(end())
-	MenuMngr() { headid = 0;  headcmd = 0; }
+		{ headid = NULL; headcmd = NULL; }
 	~MenuMngr();
 
 	// Interface
 
-
 	int findMenuId(const char* name, AMX* a = 0);
-	int registerMenuId(const char* n, AMX* a );
+	int registerMenuId(const char* n, AMX* a);
-	void registerMenuCmd(CPluginMngr::CPlugin *a, int mi, int k, int f);
+	void registerMenuCmd(CPluginMngr::CPlugin *a, int mi, int k, int f, bool from_new_menu=false);
 	void clear();
 
-	class iterator {
+	class iterator
+	{
+		friend class MenuMngr;
 		MenuCommand* a;
 	public:
 		iterator(MenuCommand*aa) : a(aa) {}
@@ -96,8 +103,16 @@ public:
 		operator bool () const { return a ? true : false; }
 		MenuCommand& operator*() { return *a; }
 	};
+	
 	inline iterator begin() const { return iterator(headcmd); }
 	inline iterator end() const { return iterator(0); }
+
+	MenuMngr::iterator SetWatchIter(MenuMngr::iterator iter);
+	inline MenuMngr::iterator GetWatchIter() { return m_watch_iter; }
+private:
+	MenuMngr::iterator m_watch_iter;
 };
 
-#endif
+extern MenuMngr g_menucmds;
+
+#endif //MENUS_H

amxmodx/CMisc.cpp

@@ -29,17 +29,17 @@
 *  version.
 */
 #include "amxmodx.h"
+#include "newmenus.h"
 // *****************************************************
 // class CPlayer
 // *****************************************************
 
-void CPlayer::Init( edict_t* e , int i )
+void CPlayer::Init(edict_t* e, int i)
 {
 	index = i;
 	pEdict = e;
 	initialized = false;
 	ingame = false;
-	bot = false;
 	authorized = false;
 
 	current = 0;
@@ -48,6 +48,8 @@ void CPlayer::Init( edict_t* e , int i )
 	aiming = 0;
 	menu = 0;
 	keys = 0;
+	menuexpire = 0.0;
+	newmenu = -1;
 
 	death_weapon.clear();
 	name.clear();
@@ -55,178 +57,266 @@ void CPlayer::Init( edict_t* e , int i )
 	team.clear();
 }
 
-void CPlayer::Disconnect() {
+void CPlayer::Disconnect()
-  ingame = false;
+{
-  initialized = false;
+	ingame = false;
-  authorized = false;
+	initialized = false;
-  bot = 0;
+	authorized = false;
+
+	if (newmenu != -1)
+	{
+		Menu *pMenu = g_NewMenus[newmenu];
+		if (pMenu)
+		{
+			//prevent recursion
+			newmenu = -1;
+			menu = 0;
+			executeForwards(pMenu->func, 
+				static_cast<cell>(ENTINDEX(pEdict)),
+				static_cast<cell>(pMenu->thisId),
+				static_cast<cell>(MENU_EXIT));
+		}
+	}
+
+	List<ClientCvarQuery_Info *>::iterator iter, end=queries.end();
+	for (iter=queries.begin(); iter!=end; iter++)
+	{
+		unregisterSPForward((*iter)->resultFwd);
+		delete [] (*iter)->params;
+		delete (*iter);
+	}
+	queries.clear();
+
+	menu = 0;
+	newmenu = -1;
 }
 
-void CPlayer::PutInServer() {
+void CPlayer::PutInServer()
-  playtime = gpGlobals->time;
+{
-  ingame = true;
+	playtime = gpGlobals->time;
-}
+	ingame = true;
-bool CPlayer::Connect(const char* connectname,const char* ipaddress) {
-  name.assign(connectname);
-  ip.assign(ipaddress);
-  time = gpGlobals->time;
-  bot = IsBot();
-  death_killer = 0;
-  memset(flags,0,sizeof(flags));
-  memset(weapons,0,sizeof(weapons));
-  initialized = true;
-  authorized = false;
-
-  const char* authid = GETPLAYERAUTHID( pEdict );
-
-  if ( (authid == 0) || (*authid == 0) 
-	  || (strcmp( authid , "STEAM_ID_PENDING") == 0) )
-	return true;
-
-  return false;
 }
 
+int CPlayer::NextHUDChannel()
+{
+	int ilow = 1;
 
+	for (int i=ilow+1; i<=4; i++)
+	{
+		if (channels[i] < channels[ilow])
+			ilow = i;
+	}
+
+	return ilow;
+}
+
+bool CPlayer::Connect(const char* connectname, const char* ipaddress)
+{
+	name.assign(connectname);
+	ip.assign(ipaddress);
+	time = gpGlobals->time;
+	death_killer = 0;
+	menu = 0;
+	newmenu = -1;
+	
+	memset(flags, 0, sizeof(flags));
+	memset(weapons, 0, sizeof(weapons));
+	
+	initialized = true;
+	authorized = false;
+
+	for (int i=0; i<=4; i++)
+	{
+		channels[i] = 0.0f;
+		hudmap[i] = 0;
+	}
+
+	List<ClientCvarQuery_Info *>::iterator iter, end=queries.end();
+	for (iter=queries.begin(); iter!=end; iter++)
+	{
+		unregisterSPForward((*iter)->resultFwd);
+		delete [] (*iter)->params;
+		delete (*iter);
+	}
+	queries.clear();
+
+	const char* authid = GETPLAYERAUTHID(pEdict);
+
+	if ((authid == 0) || (*authid == 0) || (strcmp(authid, "STEAM_ID_PENDING") == 0))
+		return true;
+
+	return false;
+}
 
 // *****************************************************
 // class Grenades
 // *****************************************************
-void Grenades::put( edict_t* grenade, float time, int type, CPlayer* player  )
+
+void Grenades::put(edict_t* grenade, float time, int type, CPlayer* player)
 {
-  Obj* a = new Obj;
+	Obj* a = new Obj;
-  if ( a == 0 ) return;
+	if (a == 0) return;
-  a->player = player;
+	a->player = player;
-  a->grenade = grenade;
+	a->grenade = grenade;
-  a->time = gpGlobals->time + time;
+	a->time = gpGlobals->time + time;
-  a->type = type;
+	a->type = type;
-  a->next = head;
+	a->next = head;
-  head = a;
+	head = a;
 }
 
-bool Grenades::find( edict_t* enemy, CPlayer** p, int& type )
+bool Grenades::find(edict_t* enemy, CPlayer** p, int& type)
 {
-  bool found = false;
+	bool found = false;
-  Obj** a = &head;
+	Obj** a = &head;
-  while ( *a ){
-    if ( (*a)->time > gpGlobals->time ) {
-      if ( (*a)->grenade == enemy ) {
-        found = true;
-        (*p) = (*a)->player;
-        type = (*a)->type;
-      }
-    }
-    else {
-      Obj* b = (*a)->next;
-      delete *a;
-      *a = b;
 	
-     continue;
+	while (*a)
+	{
+		if ((*a)->time > gpGlobals->time)
+		{
+			if ((*a)->grenade == enemy)
+			{
+				found = true;
+				(*p) = (*a)->player;
+				type = (*a)->type;
+			}
+		} else {
+			Obj* b = (*a)->next;
+			delete *a;
+			*a = b;
+			continue;
+		}
+		a = &(*a)->next;
+	}
 	
-    }
+	return found;
-    a = &(*a)->next;
-  }
-  return found;
 }
 
 void Grenades::clear()
 {
-  while(head){
+	while (head)
-    Obj* a = head->next;
+	{
-    delete head;
+		Obj* a = head->next;
-    head = a;
+		delete head;
-  }
+		head = a;
+	}
 }
 
 // *****************************************************
 // class XVars
 // *****************************************************
-void XVars::clear()  {
+
+void XVars::clear()
+{
 	delete[] head;
 	head = 0;
 	num = 0;
 	size = 0;
 }
 
-int XVars::put( AMX* p, cell* v )
+int XVars::put(AMX* p, cell* v)
 {
-  for(int a = 0; a < num; ++a) {
+	for (int a = 0; a < num; ++a)
-	if ( (head[a].amx == p) && (head[a].value == v) )
+	{
-		return a;
+		if ((head[a].amx == p) && (head[a].value == v))
-  }
+			return a;
+	}
 
-  if ( (num >= size) && realloc_array( size ? (size * 2) : 8 ) )
+	if ((num >= size) && realloc_array(size ? (size * 2) : 8))
-	return -1;
+		return -1;
 
-  head[num].value = v;
+	head[num].value = v;
-  head[num].amx = p;
+	head[num].amx = p;
-  return num++;
+	
+	return num++;
 }
 
-int XVars::realloc_array( int nsize )
+int XVars::realloc_array(int nsize)
 {
 	XVarEle* me = new XVarEle[nsize];
-	if ( me ){
+	
-		for(int a = 0 ; a < num; ++a)
+	if (me)
+	{
+		for (int a = 0 ; a < num; ++a)
 			me[a] = head[a];
+		
 		delete[] head;
 		head = me;
 		size = nsize;
 		return 0;
 	}
+	
 	return 1;
 }
 
 // *****************************************************
 // class TeamIds
 // *****************************************************
+
 TeamIds::TeamIds() { head = 0; newTeam = 0; }
-TeamIds::~TeamIds() {
+
-    while( head ) {
+TeamIds::~TeamIds()
+{
+	while (head)
+	{
 		TeamEle* a = head->next;
 		delete head;
 		head = a;
-    }
+	}
 }
 
-void TeamIds::registerTeam( const char* n ,int s )
+void TeamIds::registerTeam(const char* n, int s)
 {
-    TeamEle** a = &head;
+	TeamEle** a = &head;
-    while( *a ){
+	
-		if ( strcmp((*a)->name.c_str(),n) == 0 ){
+	while (*a)
-			if (s != -1){
+	{
+		if (strcmp((*a)->name.c_str(),n) == 0)
+		{
+			if (s != -1)
+			{
 				(*a)->id = s;
 				newTeam &= ~(1<<(*a)->tid);				
 			}
+			
 			return;
 		}
 		a = &(*a)->next;
-    }
+	}
-    *a = new TeamEle( n , s );
+
-	if ( *a == 0 ) return;
+	*a = new TeamEle(n, s);
-    newTeam |= (1<<(*a)->tid);
+	
+	if (*a == 0)
+		return;
+	
+	newTeam |= (1<<(*a)->tid);
 }
 
-int TeamIds::findTeamId( const char* n )
+int TeamIds::findTeamId(const char* n)
 {
 	TeamEle* a = head;
-    while( a ){
+	
-		if ( !stricmp(a->name.c_str(),n) )
+	while (a)
+	{
+		if (!stricmp(a->name.c_str(), n))
 			return a->id;
 		a = a->next;
-    }
+	}
+	
 	return -1;
 }
 
-int TeamIds::findTeamIdCase( const char* n)
+int TeamIds::findTeamIdCase(const char* n)
 {
 	TeamEle* a = head;
-    while( a ){
+	
-		if ( !strcmp(a->name.c_str(), n) )
+	while (a)
+	{
+		if (!strcmp(a->name.c_str(), n))
 			return a->id;
 		a = a->next;
-    }
+	}
+	
 	return -1;
 }
 
 char TeamIds::TeamEle::uid = 0;
-

amxmodx/CMisc.h

@@ -33,38 +33,48 @@
 #define CMISC_H
 
 #include "CList.h"
+#include "sh_list.h"
 
 // *****************************************************
 // class CCVar
 // *****************************************************
+
 class CCVar
 {
-    cvar_t cvar;
+	cvar_t cvar;
-    String name;
+	String name;
-    String plugin;
+	String plugin;
+
 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.flags = pflags;
 		cvar.string = "";
 		cvar.value = pvalue;
-    }
+	}
+	
 	inline cvar_t* getCvar() { return &cvar; }
 	inline const char* getPluginName() { return plugin.c_str(); }
 	inline const char* getName() { return name.c_str(); }
-	inline bool operator == ( const char* string ) { return (strcmp(name.c_str(),string)==0); }
+	inline bool operator == (const char* string) { return (strcmp(name.c_str(), string) == 0); }
+	int plugin_id;
 };
 
-
-
 // *****************************************************
 // class CPlayer
 // *****************************************************
 
+struct ClientCvarQuery_Info
+{
+	int resultFwd;
+	int requestId;
+	int paramLen;
+	cell *params;
+};
+
 class CPlayer 
 {
-	
 public:
 	edict_t* pEdict;
 	
@@ -74,13 +84,15 @@ public:
 
 	bool initialized;
 	bool ingame;
-	bool bot;
 	bool authorized;
+	bool vgui;	
 
 	float time;
 	float playtime;
+	float menuexpire;
 	
-	struct {
+	struct
+	{
 		int ammo;
 		int clip;
 	} weapons[MAX_WEAPONS];
@@ -102,25 +114,45 @@ public:
 	int newmenu;
 	int page;
 
+	float channels[5];
+	cell hudmap[5];
+	
 	Vector lastTrace;
-	Vector thisTrace;
 	Vector lastHit;
 	
-	void Init( edict_t* e , int i );
+	List<ClientCvarQuery_Info *> queries;
+
+	void Init(edict_t* e, int i);
 	void Disconnect();
 	void PutInServer();
-	bool Connect(const char* connectname,const char* ipaddress);
 	
-	inline bool IsBot(){
+	bool Connect(const char* connectname, const char* ipaddress);
-		return ((pEdict->v.flags & FL_FAKECLIENT)?true:false);
+
+	inline bool IsBot()
+	{
+		if ((pEdict->v.flags & FL_FAKECLIENT) == FL_FAKECLIENT)
+		{
+			return true;
+		}
+		
+		const char *auth = GETPLAYERAUTHID(pEdict); 	 
+		if (auth && (strcmp(auth, "BOT") == 0)) 	 
+		{
+			return true;
+		}
+		
+		return false;
 	}
 
-	inline bool IsAlive(){
+	inline bool IsAlive()
-		return ((pEdict->v.deadflag==DEAD_NO)&&(pEdict->v.health>0));
+	{
+		return ((pEdict->v.deadflag == DEAD_NO) && (pEdict->v.health > 0));
 	}
 
 	inline void Authorize() { authorized = true; }
 
+	int NextHUDChannel();
+
 };
 
 // *****************************************************
@@ -129,40 +161,44 @@ public:
 
 class Grenades
 {
-  struct Obj 
+	struct Obj 
-  {
+	{
-    CPlayer* player;
+		CPlayer* player;
-    edict_t* grenade;
+		edict_t* grenade;
-    float time;
+		float time;
-    int type;
+		int type;
-    Obj* next;
+		Obj* next;
-  } *head;
+	} *head;
-
 
 public:
-  Grenades() { head = 0; }
+	Grenades() { head = 0; }
-  ~Grenades() { clear(); }
+	~Grenades() { clear(); }
-  void put( edict_t* grenade, float time, int type, CPlayer* player  );
+	
-  bool find( edict_t* enemy, CPlayer** p, int& type );
+	void put(edict_t* grenade, float time, int type, CPlayer* player);
-  void clear();
+	bool find(edict_t* enemy, CPlayer** p, int& type);
+	void clear();
 };
 
 // *****************************************************
 // class ForceObject
 // *****************************************************
-class ForceObject {
+
-    String filename;
+class ForceObject
-    FORCE_TYPE type;
+{
-    Vector mins;
+	String filename;
-    Vector maxs;
+	FORCE_TYPE type;
-    AMX* amx;
+	Vector mins;
+	Vector maxs;
+	AMX* amx;
 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 AMX* getAMX() { return amx; }
+	
 	Vector& getMin() { return mins; }
 	Vector& getMax() { return maxs; }
+	
 	inline FORCE_TYPE getForceType() { return type; }
 };
 
@@ -172,81 +208,175 @@ public:
 
 class XVars
 {
-  struct XVarEle  {
+	struct XVarEle
-    AMX* amx;
+	{
-    cell* value;
+		AMX* amx;
-  };
+		cell* value;
+	};
 
-  XVarEle* head;
+	XVarEle* head;
-  int size;
-  int num;
 	
-  int realloc_array( int nsize );
+	int size;
+	int num;
+	int realloc_array(int nsize);
 
 public:
-  XVars() {  num = 0;  size = 0;  head = 0; }
+	XVars() { num = 0; size = 0; head = 0; }
-  ~XVars() { clear(); }
+	~XVars() { clear(); }
-  void clear();
+	
-  int put( AMX* a, cell* v );
+	void clear();
-  inline cell getValue( int a ) {
+	int put(AMX* a, cell* v);
-	  return ( a >= 0 && a < num ) ? *(head[a].value) : 0;
+	
-  }
+	inline cell getValue(int a)
-  inline int setValue( int a, cell v ) { 
+	{
-	  if ( a >= 0 && a < num ){
+		return (a >= 0 && a < num) ? *(head[a].value) : 0;
-		*(head[a].value) = v;
+	}
-		return 0;
+
-	  }
+	inline int setValue(int a, cell v)
-	  return 1;
+	{ 
-  }
+		if (a >= 0 && a < num)
+		{
+			*(head[a].value) = v;
+			return 0;
+		}
+
+		return 1;
+	}
 };
 
 // *****************************************************
 // class CScript
 // *****************************************************
+
 class CScript
 {
 	String filename;
 	AMX* amx;
 	void* code;
 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 const char* getName() { return filename.c_str(); }
-	inline bool operator==( void* a ) { return (amx == (AMX*)a); }
+	inline bool operator==(void* a) { return (amx == (AMX*)a); }
 	inline void* getCode() { return code; }
 };
 
 // *****************************************************
 // class TeamIds
 // *****************************************************
+
 class TeamIds
 {
-  struct TeamEle {
+	struct TeamEle
-    String name;
+	{
-    int id;
+		String name;
-	char tid;
+		int id;
-	static char uid;
+		char tid;
-    TeamEle* next;
+		static char uid;
-    TeamEle(const char* n, int& i) : name(n) , id(i) , next(0) {
+		TeamEle* next;
-		tid = uid++;
-	};
-	~TeamEle(){ --uid; }
-  } *head;
 		
-  int newTeam;
+		TeamEle(const char* n, int& i) : name(n), id(i), next(0)
+		{
+			tid = uid++;
+		}
+		
+		~TeamEle() { --uid; }
+	} *head;
+
+	int newTeam;
 
 public:
-  TeamIds();
+	TeamIds();
-  ~TeamIds();
+	~TeamIds();
-  void registerTeam( const char* n ,int s );
+	
-  int findTeamId( const char* n);
+	void registerTeam(const char* n, int s);
-  int findTeamIdCase( const char* n);
+	int findTeamId(const char* n);
-  inline bool isNewTeam() { return newTeam ? true : false; }
+	int findTeamIdCase(const char* n);
+	inline bool isNewTeam() { return newTeam ? true : false; }
 };
 
+class CAdminData
+{
+private:
+	cell		m_AuthData[44];
+	cell		m_Password[32];
+	cell		m_Flags;
+	cell		m_Access;
+public:
 
+	CAdminData()
+	{
+		m_AuthData[0]=0;
+		m_Password[0]=0;
+		m_Flags=0;
+		m_Access=0;
+	};
 
-#endif
+	void SetAccess(cell Access)
+	{
+		m_Access=Access;
+	};
+	cell GetAccess(void) const
+	{
+		return m_Access;
+	};
 
+	void SetFlags(cell Flags)
+	{
+		m_Flags=Flags;
+	};
+	cell GetFlags(void) const
+	{
+		return m_Flags;
+	};
 
+	void SetAuthID(const cell *Input)
+	{
+		unsigned int i=0;
+		while (i<sizeof(m_AuthData)-1)
+		{
+			if ((m_AuthData[i++]=*Input++)==0)
+			{
+				return;
+			}
+		}
 
+		m_AuthData[arraysize(m_AuthData)-1]=0;
+
+	};
+	const cell *GetAuthID(void) const
+	{
+		return &m_AuthData[0];
+	};
+
+	void SetPass(const cell *Input)
+	{
+		unsigned int i=0;
+		while (i<sizeof(m_Password)-1)
+		{
+			if ((m_Password[i++]=*Input++)==0)
+			{
+				return;
+			}
+		}
+
+		m_Password[arraysize(m_Password)-1]=0;
+
+	};
+	const cell *GetPass(void) const
+	{
+		return &m_Password[0];
+	};
+
+	CAdminData & operator = (const CAdminData &src)
+	{
+		this->SetAccess(src.GetAccess());
+		this->SetFlags(src.GetFlags());
+		this->SetAuthID(src.GetAuthID());
+		this->SetPass(src.GetPass());
+
+		return *this;
+	}
+};
+#endif //CMISC_H

amxmodx/CModule.cpp

@@ -30,17 +30,21 @@
 */
 
 #include "amxmodx.h"
+#include "libraries.h"
 
 #ifndef FAR
-#define FAR
+	#define FAR
 #endif
 
 // New
 typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
 typedef int (FAR *QUERYMOD_NEW)(int * /*ifvers*/, amxx_module_info_s * /*modInfo*/);
+typedef int (FAR *CHECKGAME_NEW)(const char *);
 typedef int (FAR *ATTACHMOD_NEW)(PFN_REQ_FNPTR /*reqFnptrFunc*/);
 typedef int (FAR *DETACHMOD_NEW)(void);
 typedef void (FAR *PLUGINSLOADED_NEW)(void);
+typedef void (*PLUGINSUNLOADED_NEW)(void);
+typedef void (*PLUGINSUNLOADING_NEW)(void);
 
 // *****************************************************
 // class CModule
@@ -55,7 +59,7 @@ CModule::CModule(const char* fname)
 CModule::~CModule()
 {
 	// old & new
-	if ( m_Handle )
+	if (m_Handle)
 		DLFREE(m_Handle);
 
 	clear();
@@ -67,6 +71,7 @@ void CModule::clear(bool clearFilename)
 	m_Metamod = false;
 	m_Handle = NULL;
 	m_Status = MODULE_NONE;
+	
 	if (clearFilename)
 		m_Filename.assign("unknown");
 
@@ -78,7 +83,14 @@ void CModule::clear(bool clearFilename)
 	m_InfoNew.reload = 0;
 	m_MissingFunc = NULL;
 
+	for (size_t i=0; i<m_DestroyableIndexes.size(); i++)
+	{
+		delete [] m_Natives[m_DestroyableIndexes[i]];
+	}
+
+	m_DestroyableIndexes.clear();
 	m_Natives.clear();
+	m_NewNatives.clear();
 }
 
 bool CModule::attachMetamod(const char *mmfile, PLUG_LOADTIME now)
@@ -101,6 +113,53 @@ bool CModule::attachMetamod(const char *mmfile, PLUG_LOADTIME now)
 	return true;
 }
 
+//this ugly function is ultimately something like O(n^4).
+//sigh.  it shouldn't be needed.
+void CModule::rewriteNativeLists(AMX_NATIVE_INFO *list)
+{
+	AMX_NATIVE_INFO *curlist;
+	for (size_t i=0; i<m_Natives.size(); i++)
+	{
+		curlist = m_Natives[i];
+		bool changed = false;
+		bool found = false;
+		CVector<size_t> newlist;
+		for (size_t j=0; curlist[j].func != NULL; j++)
+		{
+			found = false;
+			for (size_t k=0; list[k].func != NULL; k++)
+			{
+				if (strcmp(curlist[j].name, list[k].name) == 0)
+				{
+					found = true;
+					break;
+				}
+			}
+			if (found)
+			{
+				changed = true;
+				//don't break, we have to search it all
+			} else {
+				newlist.push_back(j);
+			}
+		}
+		if (changed)
+		{
+			//now build the new list
+			AMX_NATIVE_INFO *rlist = new AMX_NATIVE_INFO[newlist.size()+1];
+			for (size_t j=0; j<newlist.size(); j++)
+			{
+				rlist[j].func = curlist[newlist[j]].func;
+				rlist[j].name = curlist[newlist[j]].name;
+			}
+			rlist[newlist.size()].func = NULL;
+			rlist[newlist.size()].name = NULL;
+			m_Natives[i] = rlist;
+			m_DestroyableIndexes.push_back(i);
+		}
+	}
+}
+
 bool CModule::attachModule()
 {
 	// old & new
@@ -114,6 +173,7 @@ bool CModule::attachModule()
 
 		if (!AttachFunc_New)
 			return false;
+		
 		g_ModuleCallReason = ModuleCall_Attach;
 		g_CurrentlyCalledModule = this;
 		int retVal = (*AttachFunc_New)(Module_ReqFnptr);
@@ -122,37 +182,47 @@ bool CModule::attachModule()
 
 		switch (retVal)
 		{
-		case AMXX_OK:
+			case AMXX_OK:
-			m_Status = MODULE_LOADED;
+				m_Status = MODULE_LOADED;
-			return true;
+				break;
-		case AMXX_PARAM:
+			case AMXX_PARAM:
-			AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") retured \"Invalid parameter\" from Attach func.", m_Filename.c_str(), getVersion());
+				AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") retured \"Invalid parameter\" from Attach func.", m_Filename.c_str(), getVersion());
-			m_Status = MODULE_INTERROR;
+				m_Status = MODULE_INTERROR;
-			return false;
+				return false;
-		case AMXX_FUNC_NOT_PRESENT:
+			case AMXX_FUNC_NOT_PRESENT:
-			m_Status = MODULE_FUNCNOTPRESENT;
+				m_Status = MODULE_FUNCNOTPRESENT;
-			m_MissingFunc = g_LastRequestedFunc;
+				m_MissingFunc = g_LastRequestedFunc;
-			return false;
+				return false;
-		default:
+			default:
-			AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.",  m_Filename.c_str(), getVersion());
+				AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.", m_Filename.c_str(), getVersion());
-			m_Status = MODULE_BADLOAD;
+				m_Status = MODULE_BADLOAD;
-			return false;
+				return false;
 		}
 	} else {
 		m_Status = MODULE_BADLOAD;
 	}
 
+	if (m_Status == MODULE_LOADED)
+	{
+		AddLibrariesFromString(m_InfoNew.library, LibType_Library, LibSource_Module, this);
+		AddLibrariesFromString(m_InfoNew.libclass, LibType_Class, LibSource_Module, this);
+		return true;
+	}
+
 	return false;
 }
 
 bool CModule::queryModule()
 {
-	if (m_Status != MODULE_NONE)			// don't check if already queried
+	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)
 	{
+#if defined(__linux__) || defined(__APPLE__)
+		AMXXLOG_Log("[AMXX] Module \"%s\" failed to load (%s)", m_Filename.c_str(), dlerror());
+#endif
 		m_Status = MODULE_BADLOAD;
 		return false;
 	}
@@ -163,6 +233,7 @@ bool CModule::queryModule()
 
 	// Try new interface first
 	QUERYMOD_NEW queryFunc_New = (QUERYMOD_NEW)DLPROC(m_Handle, "AMXX_Query");
+	
 	if (queryFunc_New)
 	{
 		m_Amxx = true;
@@ -172,24 +243,51 @@ bool CModule::queryModule()
 		int retVal = (*queryFunc_New)(&ifVers, &m_InfoNew);
 		g_CurrentlyCalledModule = NULL;
 		g_ModuleCallReason = ModuleCall_NotCalled;
+		
 		switch (retVal)
 		{
-		case AMXX_PARAM:
+			case AMXX_PARAM:
-			AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") retured \"Invalid parameter\" from Attach func.", m_Filename.c_str(), getVersion());
+				AMXXLOG_Log("[AMXX] Internal Error: Module \"%s\" (version \"%s\") retured \"Invalid parameter\" from Attach func.", m_Filename.c_str(), getVersion());
-			m_Status = MODULE_INTERROR;
+				m_Status = MODULE_INTERROR;
-			return false;
+				return false;
-		case AMXX_IFVERS:
+			case AMXX_IFVERS:
-			if (ifVers < AMXX_INTERFACE_VERSION)
+				if (ifVers < AMXX_INTERFACE_VERSION)
-				m_Status = MODULE_OLD;
+				{
-			else
+					//backwards compat for new defs
-				m_Status = MODULE_NEWER;
+					if (ifVers == 3)
-			return false;
+					{
-		case AMXX_OK:
+						g_ModuleCallReason = ModuleCall_Query;
-			break;
+						g_CurrentlyCalledModule = this;
-		default:
+						retVal = (*queryFunc_New)(&ifVers, &m_InfoNew);
-			AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an invalid code.",  m_Filename.c_str(), getVersion());
+                        g_CurrentlyCalledModule = NULL;
-			m_Status = MODULE_BADLOAD;
+						g_ModuleCallReason = ModuleCall_NotCalled;
-			return false;
+						if (retVal == AMXX_OK)
+						{
+							m_InfoNew.library = m_InfoNew.logtag;
+							if (StrCaseStr(m_InfoNew.library, "sql") 
+								|| StrCaseStr(m_InfoNew.library, "dbi"))
+							{
+								m_InfoNew.libclass = "DBI";
+							} else {
+								m_InfoNew.libclass = "";
+							}
+							break;
+						}
+						return false;
+					} else {
+						m_Status = MODULE_OLD;
+						return false;
+					}
+				} 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
@@ -199,11 +297,36 @@ bool CModule::queryModule()
 			return false;
 		}
 
+
+		// Lastly, check to see if this module is able to load on this game mod
+		CHECKGAME_NEW checkGame_New = (CHECKGAME_NEW)DLPROC(m_Handle, "AMXX_CheckGame");
+
+		if (checkGame_New)
+		{
+			// This is an optional check; do not fail modules that do not have it
+			int ret = checkGame_New(g_mod_name.c_str());
+
+			if (ret != AMXX_GAME_OK)
+			{
+				switch (ret)
+				{
+				case AMXX_GAME_BAD:
+					AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") reported that it cannot load on game \"%s\"", m_Filename.c_str(), getVersion(), g_mod_name.c_str());
+					m_Status = MODULE_BADGAME;
+					break;
+				default:
+					AMXXLOG_Log("[AMXX] Module \"%s\" (version \"%s\") returned an unknown CheckGame code (value: %d)", m_Filename.c_str(), getVersion(), ret);
+					m_Status = MODULE_BADLOAD;
+					break;
+				}
+
+				return false;
+			}
+		}
+
 		m_Status = MODULE_QUERY;
 		return true;
-	}
+	} else {
-	else
-	{
 		m_Status = MODULE_NOQUERY;
 		m_Amxx = false;
 		return false;
@@ -215,9 +338,12 @@ bool CModule::detachModule()
 	if (m_Status != MODULE_LOADED)
 		return false;
 
+	RemoveLibraries(this);
+
 	if (m_Amxx)
 	{
 		DETACHMOD_NEW detachFunc_New = (DETACHMOD_NEW)DLPROC(m_Handle, "AMXX_Detach");
+		
 		if (detachFunc_New)
 		{
 			g_ModuleCallReason = ModuleCall_Detach;
@@ -227,17 +353,52 @@ bool CModule::detachModule()
 			g_ModuleCallReason = ModuleCall_NotCalled;
 		}
 	}
+
 #ifndef FAKEMETA
 	if (IsMetamod())
 	{
 		UnloadMetamodPlugin(m_Handle);
 	}
 #endif
+	
 	DLFREE(m_Handle);
 	clear();
+	
 	return true;
 }
 
+void CModule::CallPluginsUnloaded()
+{
+	if (m_Status != MODULE_LOADED)
+		return;
+
+	if (!m_Handle)
+		return;
+
+	PLUGINSUNLOADED_NEW func = (PLUGINSUNLOADED_NEW)DLPROC(m_Handle, "AMXX_PluginsUnloaded");
+
+	if (!func)
+		return;
+
+	func();
+}
+
+void CModule::CallPluginsUnloading()
+{
+	if (m_Status != MODULE_LOADED)
+		return;
+
+	if (!m_Handle)
+		return;
+
+	PLUGINSUNLOADING_NEW func = (PLUGINSUNLOADING_NEW)DLPROC(m_Handle, "AMXX_PluginsUnloading");
+
+	if (!func)
+		return;
+
+	func();
+}
+
 void CModule::CallPluginsLoaded()
 {
 	if (m_Status != MODULE_LOADED)
@@ -247,28 +408,32 @@ void CModule::CallPluginsLoaded()
 		return;
 
 	PLUGINSLOADED_NEW func = (PLUGINSLOADED_NEW)DLPROC(m_Handle, "AMXX_PluginsLoaded");
+	
 	if (!func)
 		return;
+	
 	func();
 }
 
 const char* CModule::getStatus() const
 {
-	switch(m_Status)
+	switch (m_Status)
 	{
-	case MODULE_NONE:		return "error";
+		case MODULE_NONE:		return "error";
-	case MODULE_QUERY:		return "pending";
+		case MODULE_QUERY:		return "pending";
-	case MODULE_BADLOAD:	return "bad load";
+		case MODULE_BADLOAD:	return "bad load";
-	case MODULE_LOADED:		return "running";
+		case MODULE_LOADED:		return "running";
-	case MODULE_NOINFO:		return "no info";
+		case MODULE_NOINFO:		return "no info";
-	case MODULE_NOQUERY:	return "no query";
+		case MODULE_NOQUERY:	return "no query";
-	case MODULE_NOATTACH:	return "no attach";
+		case MODULE_NOATTACH:	return "no attach";
-	case MODULE_OLD:		return "old";
+		case MODULE_OLD:		return "old";
-	case MODULE_FUNCNOTPRESENT:
+		case MODULE_FUNCNOTPRESENT:
-	case MODULE_NEWER:		return "newer";
+		case MODULE_NEWER:		return "newer";
-	case MODULE_INTERROR:	return "internal err";
+		case MODULE_INTERROR:	return "internal err";
-	case MODULE_NOT64BIT:	return "not 64bit";
+		case MODULE_NOT64BIT:	return "not 64bit";
-	default:		break;
+		case MODULE_BADGAME:	return "bad game";
+		default:				break;
 	}
+	
 	return "unknown";
 }

amxmodx/CModule.h

@@ -36,19 +36,21 @@
 #ifndef CMODULE_H
 #define CMODULE_H
 
-enum MODULE_STATUS {
+enum MODULE_STATUS
-  MODULE_NONE,				// No module loaded
+{
-  MODULE_QUERY,				// Query failed
+	MODULE_NONE,			// No module loaded
-  MODULE_BADLOAD,			// Bad file or the module writer messed something up ;]
+	MODULE_QUERY,			// Query failed
-  MODULE_LOADED,			// Loaded
+	MODULE_BADLOAD,			// Bad file or the module writer messed something up ;]
-  MODULE_NOINFO,			// No info
+	MODULE_LOADED,			// Loaded
-  MODULE_NOQUERY,			// No query function present
+	MODULE_NOINFO,			// No info
-  MODULE_NOATTACH,			// No attach function present
+	MODULE_NOQUERY,			// No query function present
-  MODULE_OLD,				// Old interface
+	MODULE_NOATTACH,		// No attach function present
-  MODULE_NEWER,				// newer interface
+	MODULE_OLD,				// Old interface
-  MODULE_INTERROR,			// Internal error
+	MODULE_NEWER,			// newer interface
-  MODULE_FUNCNOTPRESENT,	// Function not present
+	MODULE_INTERROR,		// Internal error
-  MODULE_NOT64BIT			// Not 64 bit compatible
+	MODULE_FUNCNOTPRESENT,	// Function not present
+	MODULE_NOT64BIT,		// Not 64 bit compatible
+	MODULE_BADGAME,			// Module cannot load on the current game mod
 };
 
 struct amxx_module_info_s
@@ -58,21 +60,27 @@ struct amxx_module_info_s
 	const char *version;
 	int reload;				// reload on mapchange when nonzero
 	const char *logtag;		//added in version 2
+	const char *library;	// added in version 4
+	const char *libclass;	// added in version 4
 };
 
-
 #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	3
+#define AMXX_GAME_OK			0			/* Module can load on this game. */
+#define AMXX_GAME_BAD			1			/* Module cannot load on this game. */
+
+#define AMXX_INTERFACE_VERSION	4
 
 class CModule 
 {
 	String m_Filename;				// Filename
+	
 	bool m_Metamod;					// Using metamod?
 	bool m_Amxx;					// Using new module interface?
+	
 	amxx_module_info_s m_InfoNew;	// module info (new module interface)
 	DLHANDLE m_Handle;				// handle
 	MODULE_STATUS m_Status;			// status
@@ -84,12 +92,16 @@ public:
 	~CModule();
 
 	// Interface
+	
 	bool attachModule();
 	bool queryModule();
 	bool detachModule();
+	void rewriteNativeLists(AMX_NATIVE_INFO *list);
+
 #ifndef FAKEMETA
 	bool attachMetamod(const char *mmfile, PLUG_LOADTIME now);
 #endif
+
 	const char* getStatus() const;
 	inline const char* getType() const { return m_Amxx ? "amxx" : (m_Metamod ? "amx&mm" : "amx"); }
 	inline const char* getAuthor() const { return m_InfoNew.author; }
@@ -97,18 +109,20 @@ public:
 	inline const char* getName() const { return m_InfoNew.name; }
 	inline const amxx_module_info_s* getInfoNew() const { return &m_InfoNew; }	// new
 	inline int getStatusValue() { return m_Status; }
-	inline bool operator==( const char* fname ) { return !strcmp( m_Filename.c_str() , fname );  }
+	inline bool operator==(const char* fname) { return !strcmp(m_Filename.c_str(), fname); }
 	inline bool isReloadable() { return ((m_Status == MODULE_LOADED) && (m_InfoNew.reload != 0)); }
 	inline bool isAmxx() const { return m_Amxx; }
 	inline const char *getMissingFunc() const { return m_MissingFunc; }
 	inline const char *getFilename() { return m_Filename.c_str(); }
 	inline bool IsMetamod() { return m_Metamod; }
-	void CModule::CallPluginsLoaded();
 	
-	CList<AMX_NATIVE_INFO*> m_Natives;
+	void CallPluginsLoaded();
+	void CallPluginsUnloaded();
+	void CallPluginsUnloading();
+
+	CVector<AMX_NATIVE_INFO*> m_Natives;
+	CVector<AMX_NATIVE_INFO*> m_NewNatives; // Natives for new (AMXX, not AMX) plugins only
+	CVector<size_t> m_DestroyableIndexes;
 };
 
-#endif
+#endif //CMODULE_H
-
-
-

amxmodx/CPlugin.cpp

@@ -35,17 +35,25 @@
 #include "CFile.h"
 #include "amx.h"
 #include "natives.h"
+#include "debugger.h"
+#include "libraries.h"
 
 extern const char *no_function;
 
-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, int debug)
+{	
 	CPlugin** a = &head;
-	while( *a ) a = &(*a)->next;
+	
-	*a = new CPlugin( pCounter++ ,path,name,error, debug);
+	while (*a)
+		a = &(*a)->next;
+	
+	*a = new CPlugin(pCounter++, path, name, error, debug);
+	
 	return (*a);
 }
 
-void CPluginMngr::unloadPlugin( CPlugin** a ) {
+void CPluginMngr::unloadPlugin(CPlugin** a)
+{
 	CPlugin* next = (*a)->next;
 	delete *a;
 	*a = next;
@@ -56,9 +64,10 @@ void CPluginMngr::Finalize()
 {
 	if (m_Finalized)
 		return;
-	pNatives = BuildNativeTable();
 	
+	pNatives = BuildNativeTable();
 	CPlugin *a = head;
+	
 	while (a)
 	{
 		if (a->getStatusCode() == ps_running)
@@ -66,19 +75,23 @@ void CPluginMngr::Finalize()
 			amx_Register(a->getAMX(), pNatives, -1);
 			a->Finalize();
 		}
-		a=a->next;
+		a = a->next;
 	}
+	
 	m_Finalized = true;
 }
 
-int  CPluginMngr::loadPluginsFromFile( const char* filename )
+int CPluginMngr::loadPluginsFromFile(const char* filename, bool warn)
 {
 	char file[256];
-	FILE *fp = fopen(build_pathname_r(file, sizeof(file)-1, "%s",filename) , "rt");
+	FILE *fp = fopen(build_pathname_r(file, sizeof(file) - 1, "%s", filename), "rt");
 
-	if ( !fp ) 
+	if (!fp) 
 	{
-		AMXXLOG_Log( "[AMXX] Plugins list not found (file \"%s\")",filename);
+		if (warn)
+		{
+			AMXXLOG_Error("[AMXX] Plugins list not found (file \"%s\")", filename);
+		}
 		return 1;
 	}
 	
@@ -89,29 +102,70 @@ int  CPluginMngr::loadPluginsFromFile( const char* filename )
 	
 	String line;
 
-	while ( !feof(fp) ) 
+	List<String *>::iterator block_iter;
+
+	while (!feof(fp)) 
 	{
 		pluginName[0] = '\0';
+		
 		debug[0] = '\0';
 		debugFlag = 0;
+		
 		line.clear();
 		line._fread(fp);
-		sscanf(line.c_str(),"%s %s",pluginName, debug);
+		/** quick hack */
-		if (!isalnum(*pluginName))  continue;
+		char *ptr = const_cast<char *>(line.c_str());
+		while (*ptr)
+		{
+			if (*ptr == ';')
+			{
+				*ptr = '\0';
+			} else {
+				ptr++;
+			}
+		}
+		sscanf(line.c_str(), "%s %s", pluginName, debug);
 		
-		if (isalnum(*debug) && strcmp(debug, "debug") == 0)
+		if (!isalnum(*pluginName))
+		{
+			continue;
+		}
+
+		if (isalnum(*debug) && !strcmp(debug, "debug"))
 		{
 			debugFlag = 1;
 		}
 
-		CPlugin* plugin = loadPlugin( pluginsDir , pluginName  , error,  debugFlag);
+		bool skip = false;
+		for (block_iter = m_BlockList.begin();
+			 block_iter != m_BlockList.end();
+			 block_iter++)
+		{
+			if ((*block_iter)->compare(pluginName) == 0)
+			{
+				skip = true;
+				break;
+			}
+		}
+
+		if (skip || !strcmp(debug, "disabled"))
+		{
+			continue;
+		}
+
+		if (findPlugin(pluginName) != NULL)
+		{
+			continue;
+		}
+
+		CPlugin* plugin = loadPlugin(pluginsDir, pluginName, error, debugFlag);
 		
 		if (plugin->getStatusCode() == ps_bad_load)
 		{
 			char errorMsg[255];
 			sprintf(errorMsg, "%s (plugin \"%s\")", error, pluginName);
 			plugin->setError(errorMsg);
-			AMXXLOG_Log("[AMXX] %s", plugin->getError());
+			AMXXLOG_Error("[AMXX] %s", plugin->getError());
 		}
 	}
 
@@ -120,91 +174,134 @@ int  CPluginMngr::loadPluginsFromFile( const char* filename )
 	return pCounter;
 }
 
-void CPluginMngr::clear() {
+void CPluginMngr::clear()
+{
 	CPlugin**a = &head;	
-	while ( *a )
+	
+	while (*a)
 		unloadPlugin(a);
+	
 	m_Finalized = false;
+	
 	if (pNatives)
 	{
 		delete [] pNatives;
 		pNatives = NULL;
 	}
-}
 
-CPluginMngr::CPlugin* CPluginMngr::findPluginFast(AMX *amx) 
+	List<String *>::iterator iter = m_BlockList.begin();
-{ 
+	while (iter != m_BlockList.end())
-	return (CPlugin*)(amx->userdata[3]); 
+	{
-}
+		delete (*iter);
-
+		iter = m_BlockList.erase(iter);
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx) {
-	CPlugin*a = head;
-	while ( a && &a->amx != amx )
-		a=a->next;
-	return a;
-}
-	
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(int index){
-	CPlugin*a = head;
-	while ( a && index--)
-		a=a->next;
-	return a;
-}
-	
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(const char* name) {
-	if (!name) return 0;
-	int len = strlen(name);
-	if (!len) return 0;
-	CPlugin*a = head;
-	while( a && strncmp(a->name.c_str(), name,len) )
-		a=a->next;
-	return a;
-}
-
-const char* CPluginMngr::CPlugin::getStatus() const {
-	switch(status){
-	case ps_running: 
-			{
-					if (m_Debug)
-					{
-						return "debug";
-					} else {
-						return "running";
-					}
-					break;
-			}
-	case ps_paused: return "paused";
-	case ps_bad_load: return "bad load";
-	case ps_stopped: return "stopped";
-	case ps_locked: return "locked";
 	}
+	m_BlockList.clear();
+}
+
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx)
+{
+	CPlugin*a = head;
+	
+	while (a && &a->amx != amx)
+		a = a->next;
+	
+	return a;
+}
+	
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(int index)
+{
+	CPlugin*a = head;
+	
+	while (a && index--)
+		a = a->next;
+	
+	return a;
+}
+
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(const char* name)
+{
+	if (!name)
+		return 0;
+	
+	int len = strlen(name);
+	
+	if (!len)
+		return 0;
+	
+	CPlugin*a = head;
+	
+	while (a && strncmp(a->name.c_str(), name, len))
+		a = a->next;
+	
+	return a;
+}
+
+void CPluginMngr::CPlugin::AddToFailCounter(unsigned int i)
+{
+	failcounter += i;
+	if ((failcounter >= 3)
+		&& (status ))
+	{
+		errorMsg.assign("This plugin is non-GPL which violates AMX Mod X's license.");
+		status = ps_bad_load;
+	}
+}
+
+const char* CPluginMngr::CPlugin::getStatus() const
+{
+	switch (status)
+	{
+		case ps_running: 
+		{
+			if (m_Debug)
+			{
+				return "debug";
+			} else {
+				return "running";
+			}
+			break;
+		}
+		case ps_paused: return "paused";
+		case ps_bad_load: return "bad load";
+		case ps_stopped: return "stopped";
+		case ps_locked: return "locked";
+	}
+	
 	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, int d) : name(n), title(n)
+{
 	const char* unk = "unknown";
+	
+	failcounter = 0;
 	title.assign(unk);
 	author.assign(unk);
 	version.assign(unk);
+	
 	char file[256];
-	char* path = build_pathname_r(file, sizeof(file)-1, "%s/%s",p,n);
+	char* path = build_pathname_r(file, sizeof(file) - 1, "%s/%s", p, n);
 	code = 0;
 	memset(&amx, 0, sizeof(AMX));
-	int err = load_amxscript(&amx,&code,path,e, d);
+	int err = load_amxscript(&amx, &code, path, e, d);
-	if ( err == AMX_ERR_NONE )
+	
+	if (err == AMX_ERR_NONE)
 	{
 		status = ps_running;
 	} else {
 		status = ps_bad_load;
 	}
-	amx.userdata[3] = this;
+	
+	amx.userdata[UD_FINDPLUGIN] = this;
 	paused_fun = 0;
 	next = 0;
 	id = i;
+	
 	if (status == ps_running)
 	{
-		m_PauseFwd = registerSPForwardByName(&amx, "plugin_pause");
+		m_PauseFwd = registerSPForwardByName(&amx, "plugin_pause", FP_DONE);
-		m_UnpauseFwd = registerSPForwardByName(&amx, "plugin_unpause");
+		m_UnpauseFwd = registerSPForwardByName(&amx, "plugin_unpause", FP_DONE);
+		
 		if (amx.flags & AMX_FLAG_DEBUG)
 		{
 			m_Debug = true;
@@ -214,45 +311,109 @@ CPluginMngr::CPlugin::CPlugin(int i, const char* p,const char* n, char* e, int d
 	}
 }
 
-CPluginMngr::CPlugin::~CPlugin( )
+CPluginMngr::CPlugin::~CPlugin()
 {
-	unload_amxscript( &amx, &code );
+	unload_amxscript(&amx, &code);
+}
+
+int AMXAPI native_handler(AMX *amx, int index)
+{
+	Handler *pHandler = (Handler *)amx->userdata[UD_HANDLER];
+
+	char name[sNAMEMAX + 1];
+	amx_GetNative(amx, index, name);
+
+	return pHandler->HandleNative(name, index, 0);
+}
+
+static cell AMX_NATIVE_CALL invalid_native(AMX *amx, cell *params)
+{
+	//A script has accidentally called an invalid native! give them a
+	// first chance to block the resulting error.
+
+	Handler *pHandler = (Handler *)amx->userdata[UD_HANDLER];
+
+	//this should never happen
+	if (!pHandler)
+	{
+		LogError(amx, AMX_ERR_INVNATIVE, "Invalid native attempt");
+		return 0;
+	}
+
+	//this should never happen because this native won't be called
+	// if the plugin isn't filtering.
+	if (!pHandler->IsNativeFiltering())
+	{
+		LogError(amx, AMX_ERR_INVNATIVE, "Invalid native attempt");
+		return 0;
+	}
+
+	char name[sNAMEMAX + 1];
+	int native = (int)(_INT_PTR)(amx->usertags[UT_NATIVE]);
+	int err = amx_GetNative(amx, native, name);
+
+	if (err != AMX_ERR_NONE)
+		name[0] = '\0';
+
+	//1 - because we're trapping usage
+	if (!pHandler->HandleNative(name, native, 1))
+	{
+		amx->usertags[UT_NATIVE] = (void *)native;
+		LogError(amx, AMX_ERR_INVNATIVE, NULL);
+		return 0;
+	}
+
+	//Someday maybe allow native filters to write their own return value?
+	return 0;
 }
 
 void CPluginMngr::CPlugin::Finalize()
 {
 	char buffer[128];
-
 	int old_status = status;
+	
 	if (CheckModules(&amx, buffer))
 	{
-		if ( amx_Register(&amx, core_Natives, -1) != AMX_ERR_NONE )
+		if (amx_Register(&amx, core_Natives, -1) != AMX_ERR_NONE)
 		{
-			status = ps_bad_load;
+			Handler *pHandler = (Handler *)amx.userdata[UD_HANDLER];
-			sprintf(buffer, "Plugin uses an unknown function (name \"%s\") - check your modules.ini.", no_function);
+			int res = 0;
-			errorMsg.assign(buffer);
+			
-			amx.error = AMX_ERR_NOTFOUND;
+			if (pHandler->IsNativeFiltering())
+				res = amx_CheckNatives(&amx, native_handler);
+			
+			if (!res)
+			{
+				status = ps_bad_load;
+				sprintf(buffer, "Plugin uses an unknown function (name \"%s\") - check your modules.ini.", no_function);
+				errorMsg.assign(buffer);
+				amx.error = AMX_ERR_NOTFOUND;
+			} else {
+				amx_RegisterToAny(&amx, invalid_native);
+			}
 		}
 	} else {
 		status = ps_bad_load;
 		errorMsg.assign(buffer);
 		amx.error = AMX_ERR_NOTFOUND;
 	}
+	
 	if (old_status != status)
 	{
 		AMXXLOG_Log("[AMXX] Plugin \"%s\" failed to load: %s", name.c_str(), errorMsg.c_str());
 	}
 }
 
-void CPluginMngr::CPlugin::pauseFunction( int id )
+void CPluginMngr::CPlugin::pauseFunction(int id)
 { 
 }
 
-void CPluginMngr::CPlugin::unpauseFunction( int id )
+void CPluginMngr::CPlugin::unpauseFunction(int id)
 {
 }
 
-void CPluginMngr::CPlugin::setStatus( int a   ) { 
+void CPluginMngr::CPlugin::setStatus(int a)
+{ 
 	status = a; 
 	g_commands.clearBufforedInfo(); // ugly way
 }
@@ -273,13 +434,286 @@ void CPluginMngr::CPlugin::pausePlugin()
 // Unpause a plugin
 void CPluginMngr::CPlugin::unpausePlugin()
 {
-	if (isValid())
+	if (isValid() && (getStatusCode() != ps_stopped))
 	{
 		// set status first so the function will be marked executable
-
 		setStatus(ps_running);
+		
 		// call plugin_unpause if provided
 		if (m_UnpauseFwd != -1)
+		{
 			executeForwards(m_UnpauseFwd);
+		}
 	}
 }
+
+char *CPluginMngr::ReadIntoOrFromCache(const char *file, size_t &bufsize)
+{
+	List<plcache_entry *>::iterator iter;
+	plcache_entry *pl;
+
+	for (iter=m_plcache.begin(); iter!=m_plcache.end(); iter++)
+	{
+		pl = (*iter);
+		if (pl->path.compare(file) == 0)
+		{
+			bufsize = pl->bufsize;
+			return pl->buffer;
+		}
+	}
+
+	pl = new plcache_entry;
+
+	pl->file = new CAmxxReader(file, sizeof(cell));
+	pl->buffer = NULL;
+	if (pl->file->GetStatus() != CAmxxReader::Err_None ||
+		pl->file->IsOldFile())
+	{
+		delete pl->file;
+		delete pl;
+		return NULL;
+	}
+
+	pl->bufsize = pl->file->GetBufferSize();
+	if (pl->bufsize)
+	{
+		pl->buffer = new char[pl->bufsize];
+		pl->file->GetSection(pl->buffer);
+	}
+
+	if (!pl->buffer || pl->file->GetStatus() != CAmxxReader::Err_None)
+	{
+		delete [] pl->buffer;
+		delete pl->file;
+		delete pl;
+		return NULL;
+	}
+
+	pl->path.assign(file);
+
+	bufsize = pl->bufsize;
+
+	m_plcache.push_back(pl);
+
+	return pl->buffer;
+}
+
+void CPluginMngr::InvalidateCache()
+{
+	List<plcache_entry *>::iterator iter;
+	plcache_entry *pl;
+
+	for (iter=m_plcache.begin(); iter!=m_plcache.end(); iter++)
+	{
+		pl = (*iter);
+		delete [] pl->buffer;
+		delete pl->file;
+		delete pl;
+	}
+
+	m_plcache.clear();
+}
+
+void CPluginMngr::InvalidateFileInCache(const char *file, bool freebuf)
+{
+	List<plcache_entry *>::iterator iter;
+	plcache_entry *pl;
+
+	for (iter=m_plcache.begin(); iter!=m_plcache.end(); iter++)
+	{
+		pl = (*iter);
+		if (pl->path.compare(file) == 0)
+		{
+			if (freebuf)
+				delete [] pl->buffer;
+			delete pl->file;
+			delete pl;
+			m_plcache.erase(iter);
+			return;
+		}
+	}
+}
+
+void CPluginMngr::CacheAndLoadModules(const char *plugin)
+{
+	size_t progsize;
+	char *prog = ReadIntoOrFromCache(plugin, progsize);
+
+	if (!prog)
+		return;
+
+	AMX_HEADER hdr;
+	memcpy(&hdr, prog, sizeof(AMX_HEADER));
+
+	uint16_t magic = hdr.magic;
+	amx_Align16(&magic);
+
+	if (magic != AMX_MAGIC)
+	{
+		return;
+	}
+
+	if (hdr.file_version < MIN_FILE_VERSION ||
+		hdr.file_version > CUR_FILE_VERSION)
+	{
+		return;
+	}
+	if ((hdr.defsize != sizeof(AMX_FUNCSTUB)) && 
+		(hdr.defsize != sizeof(AMX_FUNCSTUBNT)))
+	{
+		return;
+	}
+
+	amx_Align32((uint32_t*)&hdr.nametable);
+	uint16_t *namelength=(uint16_t*)((unsigned char*)prog + (unsigned)hdr.nametable);
+	amx_Align16(namelength);
+	if (*namelength>sNAMEMAX)
+	{
+		return;
+	}
+	
+	if (hdr.stp <= 0)
+	{
+		return;
+	}
+
+	AMX amx;
+	memset(&amx, 0, sizeof(AMX));
+	amx.base = (unsigned char *)prog;
+
+	int num;
+	char name[sNAMEMAX+1];
+
+	num = amx_GetLibraries(&amx);
+	for (int i=0; i<num; i++)
+	{
+		amx_GetLibrary(&amx, i, name, sNAMEMAX);
+		if (stricmp(name, "Float")==0)
+			continue;
+		//awful backwards compat hack
+		if (stricmp(name, "socket")==0)
+			strcpy(name, "sockets");
+		//we don't want to report failed modules here...
+		LoadModule(name, PT_ANYTIME, true, true);
+	}
+
+	cell tag_id;
+	amx_NumTags(&amx, &num);
+
+	CVector<LibDecoder *> expects;
+	CVector<LibDecoder *> defaults;
+	CStack<LibDecoder *> delstack;
+	for (int i=0; i<num; i++)
+	{
+		amx_GetTag(&amx, i, name, &tag_id);
+		if (name[0] == '?')
+		{
+			LibDecoder *dc = new LibDecoder;
+			delstack.push(dc);
+			if (DecodeLibCmdString(name, dc))
+			{
+				if (dc->cmd == LibCmd_ForceLib)
+				{
+					RunLibCommand(dc);
+				} else if ( (dc->cmd == LibCmd_ExpectClass) ||
+							(dc->cmd == LibCmd_ExpectLib) ) 
+				{
+					expects.push_back(dc);
+				} else if (dc->cmd == LibCmd_DefaultLib) {
+					defaults.push_back(dc);
+				}
+			}
+		}
+	}
+
+	for (size_t i=0; i<expects.size(); i++)
+	{
+		RunLibCommand(expects[i]);
+	}
+	for (size_t i=0; i<defaults.size(); i++)
+	{
+		RunLibCommand(defaults[i]);
+	}
+
+	expects.clear();
+	defaults.clear();
+
+	while (!delstack.empty())
+	{
+		delete delstack.front();
+		delstack.pop();
+	}
+
+	return;
+}
+
+void CPluginMngr::CALMFromFile(const char *file)
+{
+	char filename[256];
+	FILE *fp = fopen(build_pathname_r(filename, sizeof(filename) - 1, "%s", file), "rt");
+
+	if (!fp) 
+	{
+		return;
+	}
+
+	// Find now folder
+	char pluginName[256];
+	char line[256];
+	String rline;
+
+	while (!feof(fp)) 
+	{
+		fgets(line, sizeof(line)-1, fp);
+		if (line[0] == ';' || line[0] == '\n' || line[0] == '\0')
+		{
+			continue;
+		}
+
+		/** quick hack */
+		char *ptr = line;
+		while (*ptr)
+		{
+			if (*ptr == ';')
+			{
+				*ptr = '\0';
+			} else {
+				ptr++;
+			}
+		}
+
+		rline.assign(line);
+		rline.trim();
+		pluginName[0] = '\0';
+		sscanf(rline.c_str(), "%s", pluginName);
+
+		/* HACK: see if there's a 'disabled' coming up
+		 * new block for scopying flexibility
+		 */
+		if (1)
+		{
+			const char *_ptr = rline.c_str() + strlen(pluginName);
+			while (*_ptr != '\0'  && isspace(*_ptr))
+			{
+				_ptr++;
+			}
+			if ((*_ptr != '\0') && !strcmp(_ptr, "disabled"))
+			{
+				String *pString = new String(pluginName);
+				m_BlockList.push_back(pString);
+				continue;
+			}
+		}
+
+		if (!isalnum(*pluginName))
+		{
+			continue;
+		}
+
+		build_pathname_r(filename, sizeof(filename)-1, "%s/%s", get_localinfo("amxx_pluginsdir", "addons/amxmodx/plugins"), pluginName);
+
+		CacheAndLoadModules(filename);
+	}
+
+	fclose(fp);
+}

amxmodx/CPlugin.h

@@ -32,22 +32,27 @@
 #ifndef PLUGIN_H
 #define PLUGIN_H
 
+#include "CString.h"
+#include "sh_list.h"
+#include "amx.h"
+#include "amxxfile.h"
+
 // *****************************************************
 // class CPluginMngr
 // *****************************************************
 
-enum {
+enum
-	ps_bad_load,
+{
-	ps_error,
+	ps_bad_load,	//Load failed
-	ps_paused,
+	ps_error,	//Erroneous state
-	ps_running,
+	ps_locked,	//UNUSED
-	ps_stopped,
+	ps_paused,	//Plugin is temporarily paused
-	ps_locked,
+	ps_stopped,	//Plugin is ... more temporarily paused
+	ps_running,	//Plugin is running
 };
 
 class CPluginMngr
 {
-
 public:
 
 	class iterator;
@@ -59,23 +64,26 @@ public:
 	
 		AMX amx;
 		void* code;
+		
 		String name;
 		String version;
 		String title;
 		String author;
 		String errorMsg;
+		
+		unsigned int failcounter;
 		int m_PauseFwd;
 		int m_UnpauseFwd;
 		int paused_fun;
 		int status;
 		CPlugin* next;
 		int id;
-		CPlugin(int i , const char* p,const char* n, char* e, int d);
+		
-		~CPlugin( );
+		CPlugin(int i, const char* p, const char* n, char* e, int d);
+		~CPlugin();
+		
 		bool m_Debug;
-
 	public:
-
 		inline const char* getName() { return name.c_str();}
 		inline const char* getVersion() { return version.c_str();}
 		inline const char* getTitle() { return title.c_str();}
@@ -85,20 +93,23 @@ public:
 		inline int getId() const { return id; }
 		inline AMX* getAMX() { return &amx; }
 		inline const AMX* getAMX() const { return &amx; }
-		inline void setTitle( const char* n ) { title.assign(n); }
+		inline void setTitle(const char* n) { title.assign(n); }
-		inline void setAuthor( const char* n ) { author.assign(n); }
+		inline void setAuthor(const char* n) { author.assign(n); }
-		inline void setVersion( const char* n ) { version.assign(n); }
+		inline void setVersion(const char* n) { version.assign(n); }
-		inline void setError( const char* n ) { errorMsg.assign(n); }
+		inline void setError(const char* n) { errorMsg.assign(n); }
-		inline bool isValid() const { return ((status == ps_running || status == ps_paused)); }
+		inline bool isValid() const { return (status >= ps_paused); }
-		inline bool isPaused() const { return ( (status == ps_paused) ); }
+		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 isStopped() const { return (status == ps_stopped); }
 		inline bool isExecutable(int id) const { return (isValid() && !isPaused());	}
+		
 		void Finalize();
+		void AddToFailCounter(unsigned int i);
 		void pausePlugin();
 		void unpausePlugin();
-		void pauseFunction( int id );
+		void pauseFunction(int id);
-		void unpauseFunction( int id );
+		void unpauseFunction(int id);
-		void setStatus( int a   );
+		void setStatus(int a);
+		
 		const char* getStatus() const;
 		inline bool isDebug() const { return m_Debug; }
 	}; 
@@ -106,11 +117,9 @@ public:
 private:	
 	CPlugin *head;
 	int pCounter;
-
-
 public:
 	CPluginMngr() { head = 0; pCounter = 0; pNatives = NULL; m_Finalized=false;}
-	~CPluginMngr() { clear(); }
+	~CPluginMngr() { clear(); InvalidateCache(); }
 
 	bool m_Finalized;
 	AMX_NATIVE_INFO *pNatives;
@@ -118,17 +127,20 @@ public:
 	// Interface
 
 	CPlugin* loadPlugin(const char* path, const char* name, char* error, int debug);
-	void unloadPlugin( CPlugin** a );
+	void unloadPlugin(CPlugin** a);
-	int loadPluginsFromFile( const char* filename );
+	int loadPluginsFromFile(const char* filename, bool warn=true);
-	CPlugin* findPluginFast(AMX *amx);
+	
+	inline CPlugin* findPluginFast(AMX *amx) { return (CPlugin*)(amx->userdata[UD_FINDPLUGIN]); }
 	CPlugin* findPlugin(AMX *amx);
 	CPlugin* findPlugin(int index);
 	CPlugin* findPlugin(const char* name);
+	
 	inline int getPluginsNum() const { return pCounter; }
 	void Finalize();
 	void clear();
 
-	class iterator {
+	class iterator
+	{
 		CPlugin *a;
 	public:
 		iterator(CPlugin*aa) : a(aa) {}
@@ -138,10 +150,25 @@ public:
 		operator bool () const { return a ? true : false; }
 		CPlugin& operator*() { return *a; }
 	};
+	
 	inline iterator begin() const { return iterator(head); }
 	inline iterator end() const { return iterator(0); }
+public:
+	struct plcache_entry
+	{
+		CAmxxReader *file;
+		size_t bufsize;
+		char *buffer;
+		String path;
+	};
+	char *ReadIntoOrFromCache(const char *file, size_t &bufsize);
+	void InvalidateCache();
+	void InvalidateFileInCache(const char *file, bool freebuf);
+	void CacheAndLoadModules(const char *plugin);
+	void CALMFromFile(const char *file);
+private:
+	List<plcache_entry *> m_plcache;
+	List<String *> m_BlockList;
 };
 
-#endif
+#endif //PLUGIN_H
-
-

amxmodx/CQueue.h

@@ -45,14 +45,17 @@ public:
 			item = i;
 			next = n;
 		}
+		
 		CQueueItem *GetNext()
 		{
 			return next;
 		}
+		
 		T & GetItem()
 		{
 			return item;
 		}
+		
 		void SetNext(CQueueItem *n)
 		{
 			next = n;
@@ -71,7 +74,7 @@ public:
 
 	bool empty()
 	{
-		return ((mSize==0)?true:false);
+		return ((mSize == 0) ? true : false);
 	}
 
 	void push(const T &v)
@@ -119,8 +122,8 @@ public:
 private:
 	CQueueItem *mFirst;
 	CQueueItem *mLast;
+	
 	unsigned int mSize;
 };
 
 #endif //_INCLUDE_CQUEUE_H
-

amxmodx/CString.h

@@ -66,7 +66,7 @@ public:
 		return ret; 	 
 	}
 
-	String(String &src) 
+	String(const String &src) 
 	{
 		v = NULL;
 		a_size = 0;
@@ -107,8 +107,10 @@ public:
 		{
 			clear();
 		} else {
-			Grow(strlen(d) + 1, false);
+			size_t len = strlen(d);
-			strcpy(v, d);
+			Grow(len + 1, false);
+			memcpy(v, d, len);
+			v[len] = '\0';
 		}
 	}
 
@@ -118,7 +120,7 @@ public:
 			v[0] = '\0';
 	}
 
-	int compare (const char *d)
+	int compare (const char *d) const
 	{
 		if (!v)
 			return strcmp("", d);
@@ -127,7 +129,7 @@ public:
 	}
 
 	//Added this for amxx inclusion
-	bool empty()
+	bool empty() const
 	{
 		if (!v)
 			return true;
@@ -138,7 +140,7 @@ public:
 		return false;
 	}
 
-	size_t size()
+	size_t size() const
 	{
 		if (v)
 			return strlen(v);
@@ -148,13 +150,13 @@ public:
 
 	int find(const char c, int index = 0)
 	{
-		size_t len = size();
+		int len = static_cast<int>(size());
 		if (len < 1)
 			return npos;
-		if (index >= (int)len || index < 0)
+		if (index >= len || index < 0)
 			return npos;
-		unsigned int i = 0;
+		int i = 0;
-		for (i=index; i<(int)len; i++)
+		for (i=index; i<len; i++)
 		{
 			if (v[i] == c)
 			{
@@ -177,6 +179,30 @@ public:
 		return false;
 	}
 
+	void reparse_newlines()
+	{
+		size_t len = size();
+		int offs = 0;
+		char c;
+		if (!len)
+			return;
+		for (size_t i=0; i<len; i++)
+		{
+			c = v[i];
+			if (c == '^' && (i != len-1))
+			{
+				c = v[++i];
+				if (c == 'n')
+					c = '\n';
+				else if (c == 't')
+					c = '\t';
+				offs++;
+			}
+			v[i-offs] = c;
+		}
+		v[len-offs] = '\0';
+	}
+	
 	void trim()
 	{
 		if (!v)
@@ -218,7 +244,7 @@ public:
 
 		if (is_space(v[len-1]))
 		{
-			for (i=len-1; i>=0; i--)
+			for (i=len-1; i<len; i--)
 			{
 				if (!is_space(v[i])
 					|| (is_space(v[i]) && i==0))
@@ -247,7 +273,7 @@ public:
 		unsigned int i = 0;
 		size_t len = size();
 		//check for bounds
-		if (num == npos || start+num > len-num+1)
+		if (num == npos || start+num > len-start)
 			num = len - start;
 		//do the erasing
 		bool copyflag = false;
@@ -297,7 +323,7 @@ public:
 			num = len - index;
 		}
 
-		unsigned int i = 0, j=0;
+		unsigned int i = 0;
 		unsigned int nslen = num + 2;
 
 		ns.Grow(nslen);

amxmodx/CTask.cpp

@@ -33,17 +33,8 @@
 #include "CTask.h"
 
 /*********************** CTask ***********************/
-int CTaskMngr::CTask::getTaskId() const
-{
-	return m_iId;
-}
 
-CPluginMngr::CPlugin *CTaskMngr::CTask::getPlugin() const
+void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime)
-{
-	return m_pPlugin;
-}
-
-void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime)
 {
 	clear();
 	m_bFree = false;
@@ -52,17 +43,21 @@ void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags,
 	m_iFunc = iFunc;
 	m_iId = iId;
 	m_fBase = fBase;
+	m_bInExecute = false;
 
 	if (iFlags & 2)
 	{
 		m_bLoop = true;
 		m_iRepeat = -1;
-	} else if (iFlags & 1) {
+	}
+	else if (iFlags & 1)
+	{
 		m_bLoop = true;
 		m_iRepeat = iRepeat;
 	}
-	m_bAfterStart =	(iFlags & 4) ?  true : false;
+	
-	m_bBeforeEnd =	(iFlags & 8) ?  true : false;
+	m_bAfterStart =	(iFlags & 4) ? true : false;
+	m_bBeforeEnd = (iFlags & 8) ? true : false;
 
 	m_fNextExecTime = fCurrentTime + m_fBase;
 
@@ -98,10 +93,10 @@ void CTaskMngr::CTask::clear()
 	m_iId = 0;
 	m_fBase = 0.0f;
 
-	m_iRepeat =		0;
+	m_iRepeat =	0;
-	m_bLoop =		false;
+	m_bLoop = false;
 	m_bAfterStart =	false;
-	m_bBeforeEnd =	false;
+	m_bBeforeEnd = false;
 
 	m_fNextExecTime = 0.0f;
 }
@@ -123,8 +118,9 @@ void CTaskMngr::CTask::resetNextExecTime(float fCurrentTime)
 
 void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, float fTimeLeft)
 {
-	bool execute=false;
+	bool execute = false;
-	bool done=false;
+	bool done = false;
+	
 	if (m_bAfterStart)
 	{
 		if (fCurrentTime - fTimeLeft + 1.0f >= m_fBase)
@@ -134,15 +130,18 @@ void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, f
 	{
 		if (fTimeLimit != 0.0f && (fTimeLeft + fTimeLimit * 60.0f) - fCurrentTime - 1.0f <= m_fBase)
 			execute = true;
-	} else if (m_fNextExecTime <= fCurrentTime) {
+	}
+	else if (m_fNextExecTime <= fCurrentTime)
+	{
 		execute = true;
 	}
 
 	if (execute)
 	{
 		//only bother calling if we have something to call
-		if ( !(m_bLoop && !m_iRepeat) )
+		if (!(m_bLoop && !m_iRepeat))
 		{
+			m_bInExecute = true;
 			if (m_iParamLen)	// call with parameters
 			{
 				cell arr = prepareCellArray(m_pParams, m_iParamLen);
@@ -150,6 +149,7 @@ void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, f
 			} else {
 				executeForwards(m_iFunc, m_iId);
 			}
+			m_bInExecute = false;
 		}
 	
 		if (isFree())
@@ -182,10 +182,11 @@ CTaskMngr::CTask::CTask()
 	m_iId = 0;
 	m_fBase = 0.0f;
 
-	m_iRepeat =		0;
+	m_iRepeat =	0;
-	m_bLoop =		false;
+	m_bLoop = false;
 	m_bAfterStart =	false;
-	m_bBeforeEnd =	false;
+	m_bBeforeEnd = false;
+	m_bInExecute = false;
 
 	m_fNextExecTime = 0.0f;
 
@@ -199,6 +200,7 @@ CTaskMngr::CTask::~CTask()
 }
 
 /*********************** CTaskMngr ***********************/
+
 CTaskMngr::CTaskMngr()
 {
 	m_pTmr_CurrentTime = NULL;
@@ -218,21 +220,22 @@ void CTaskMngr::registerTimers(float *pCurrentTime, float *pTimeLimit, float *pT
 	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)
+void CTaskMngr::registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell 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 {
-	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);
 	}
@@ -242,13 +245,15 @@ int CTaskMngr::removeTasks(int iId, AMX *pAmx)
 {
 	CTaskDescriptor descriptor(iId, pAmx);
 	TaskListIter iter = m_Tasks.find(descriptor);
-	int i=0;
+	int i = 0;
+	
 	while (iter)
 	{
-			iter->clear();
+		iter->clear();
-			++i;
+		++i;
-			iter = m_Tasks.find(++iter, descriptor);
+		iter = m_Tasks.find(++iter, descriptor);
 	}
+	
 	return i;
 }
 
@@ -256,14 +261,16 @@ int CTaskMngr::changeTasks(int iId, AMX *pAmx, float fNewBase)
 {
 	CTaskDescriptor descriptor(iId, pAmx);
 	TaskListIter iter = m_Tasks.find(descriptor);
-	int i=0;
+	int i = 0;
+	
 	while (iter)
 	{
-			iter->changeBase(fNewBase);
+		iter->changeBase(fNewBase);
-			iter->resetNextExecTime(*m_pTmr_CurrentTime);
+		iter->resetNextExecTime(*m_pTmr_CurrentTime);
-			++i;
+		++i;
-			iter = m_Tasks.find(++iter, descriptor);
+		iter = m_Tasks.find(++iter, descriptor);
 	}
+	
 	return i;
 }
 

amxmodx/CTask.h

@@ -39,34 +39,40 @@ private:
 	class CTask
 	{
 		// task settings
+		
 		CPluginMngr::CPlugin *m_pPlugin;
-		int m_iId;
+		cell m_iId;
 		int m_iFunc;
 		int m_iRepeat;
+		
+		bool m_bInExecute;
 		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
 		float m_fNextExecTime;
 	public:
-		 void set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime);
+		void set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime);
-		 void clear();
+		void clear();
-		 bool isFree() const;
+		bool isFree() const;
 
-		 CPluginMngr::CPlugin *getPlugin() const;
+		inline CPluginMngr::CPlugin *getPlugin() const { return m_pPlugin; }
-		 int getTaskId() const;
+		inline AMX *getAMX() const { return m_pPlugin->getAMX(); }
+		inline int getTaskId() const { return m_iId; }
 
-		 void executeIfRequired(float fCurrentTime, float fTimeLimit, float fTimeLeft);	// also removes the task if needed
+		void executeIfRequired(float fCurrentTime, float fTimeLimit, float fTimeLeft);	// also removes the task if needed
 
-		 void changeBase(float fNewBase);
+		void changeBase(float fNewBase);
-		 void resetNextExecTime(float fCurrentTime);
+		void resetNextExecTime(float fCurrentTime);
+		inline bool inExecute() const { return m_bInExecute; }
 
-		 bool shouldRepeat();
+		bool shouldRepeat();
 
 		CTask();
 		~CTask();
@@ -75,7 +81,7 @@ private:
 	class CTaskDescriptor
 	{
 	public:
-		int m_iId;
+		cell m_iId;
 		AMX *m_pAmx;
 		bool m_bFree;
 
@@ -89,18 +95,20 @@ private:
 		friend bool operator == (const CTask &left, const CTaskDescriptor &right)
 		{
 			if (right.m_bFree)
-				return left.isFree();
+				return (left.isFree() && !left.inExecute());
 			
-			return !left.isFree() &&
+			return (!left.isFree()) && 
-				(right.m_pAmx ? left.getPlugin()->getAMX() == right.m_pAmx : true) &&
+					(right.m_pAmx ? left.getAMX() == right.m_pAmx : true) && 
-				left.getTaskId() == right.m_iId;
+					(left.getTaskId() == right.m_iId);
 		}
 	};
 
 	/*** 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;
@@ -109,14 +117,14 @@ public:
 	~CTaskMngr();
 
 	void registerTimers(float *pCurrentTime, float *pTimeLimit, float *pTimeLeft);	// The timers will always point to the right value
-	void registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, int iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat);
+	void registerTask(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell 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
+	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
 	bool taskExists(int iId, AMX *pAmx);
+	
 	void startFrame();
 	void clear();
 };
 
-#endif
+#endif //CTASK_H
-
-

amxmodx/CVault.cpp

@@ -39,46 +39,47 @@
 // *****************************************************
 // class Vault
 // *****************************************************
-bool Vault::exists( const char* k )
-{
-	if ( *k == 0 ) return false;
 
-	return *find( k ) != 0;
+bool Vault::exists(const char* k)
+{
+	if (*k == 0) return false;
+
+	return *find(k) != 0;
 }
 
-void Vault::put( const char* k, const char* v )
+void Vault::put(const char* k, const char* v)
 {
-	if ( *k == 0 ) return;
+	if (*k == 0) return;
 
-	if ( *v == 0 )
+	if (*v == 0)
 	{
-		remove( k );
+		remove(k);
 		return;
 	}
 
-	Obj** a = find( k );
+	Obj** a = find(k);
 
-	if ( *a )
+	if (*a)
 	{
 		(*a)->value.assign(v);
-		(*a)->number = atoi( v );
+		(*a)->number = atoi(v);
 	}
 	else
-		*a = new Obj( k , v );
+		*a = new Obj(k, v);
-
 }
 
-Vault::Obj::Obj( const char* k,  const char* v): key(k) , value(v) , next(0) {
+Vault::Obj::Obj(const char* k, const char* v): key(k), value(v), next(0)
+{
 	number = atoi(v);
 }
 
-Vault::Obj** Vault::find( const char* n )
+Vault::Obj** Vault::find(const char* n)
 {
 	Obj** a = &head;
 
-	while( *a )
+	while (*a)
 	{
-		if ( strcmp((*a)->key.c_str(), n) == 0 )
+		if (strcmp((*a)->key.c_str(), n) == 0)
 			return a;
 
 		a = &(*a)->next;
@@ -88,90 +89,89 @@ Vault::Obj** Vault::find( const char* n )
 }
 
 
-int Vault::get_number( const char* n )
+int Vault::get_number(const char* n)
 {
-	if ( *n == 0 ) return 0;
+	if (*n == 0) return 0;
 
-	Obj* b = *find( n );
+	Obj* b = *find(n);
 
-	if ( b == 0 ) return 0;
+	if (b == 0) return 0;
 
 	return b->number;
 }
 
-const char* Vault::get( const char* n )
+const char* Vault::get(const char* n)
 {
-	if ( *n == 0 ) return "";
+	if (*n == 0) return "";
 
-	Obj* b = *find( n );
+	Obj* b = *find(n);
 
-	if ( b == 0 ) return "";
+	if (b == 0) return "";
 
 	return b->value.c_str();
 }
 
 void Vault::clear()
 {
-	while ( head )
+	while (head)
 	{
 		Obj* a = head->next;
 		delete head;
-		head =  a;
+		head = a;
 	}
 }
 
-void Vault::remove( const char* n )
+void Vault::remove(const char* n)
 {
-	Obj** b = find( n );
+	Obj** b = find(n);
 
-	if ( *b == 0 ) return;
+	if (*b == 0) return;
 
 	Obj* a = (*b)->next;
 	delete *b;
 	*b = a;
 }
 
-void Vault::setSource( const char* n )
+void Vault::setSource(const char* n)
 {
 	path.assign(n);
 }
 
-
+bool Vault::loadVault()
-bool Vault::loadVault(  )
 {
-	if ( path.empty() ) return false;
+	if (path.empty()) return false;
 
 	clear();
 
-	File a( path.c_str() , "r" );
+	File a(path.c_str(), "r");
 
-	if ( !a ) return false;
+	if (!a) return false;
 
 	const int sz = 512;
-	char value[sz+1];
+	char value[sz + 1];
-	char key[sz+1];
+	char key[sz + 1];
 
-	while ( a >> key && a.skipWs() && a.getline( value , sz ) )
+	while (a >> key && a.skipWs() && a.getline(value, sz))
 	{
-		if ( isalpha ( *key ) )
+		if (isalpha(*key))
-			put( key, value );
+			put(key, value);
 	}
 
 	return true;
 
 }
 
-bool Vault::saveVault( )
+bool Vault::saveVault()
 {
-	if ( path.empty() ) return false;
+	if (path.empty()) return false;
 
-	File a( path.c_str() , "w" );
+	File a(path.c_str(), "w");
 
-	if ( !a ) return false;
+	if (!a) return false;
 
 	a << "; Don't modify!" << '\n';
 
-	for (Obj* b = head; b ;b = b->next)
+	for (Obj* b = head; b; b = b->next)
 		a << b->key << '\t' << b->value << '\n';
 
 	return true;

amxmodx/CVault.h

@@ -41,53 +41,55 @@
 
 class Vault
 {
-  struct Obj
+	struct Obj
-  {
+	{
-	String key;
+		String key;
-	String value;
+		String value;
-	int number;
-    Obj *next;
-	Obj( const char* k,  const char* v);
-  } *head;
 		
-  String path;
+		int number;
+		Obj *next;
+		Obj(const char* k, const char* v);
+	} *head;
 
-  Obj** find( const char* n );
+	String path;
+
+	Obj** find(const char* n);
 
 public:
 
-  Vault() {head=0;}
+	Vault() { head = 0; }
-  ~Vault() { clear();}
+	~Vault() { clear(); }
 
 	// Interface
 
-  bool exists( const char* k );
+	bool exists(const char* k);
-  void put(const char* k, const char* v);
-  void remove( const char* k );
-  const char* get( const char* n );
-  int get_number( const char* n );
-  void setSource( const char* n );
-  bool loadVault( );
-  bool saveVault( );
-  void clear();
 	
+	void put(const char* k, const char* v);
+	void remove(const char* k);
 	
-  class iterator {
+	const char* get(const char* n);
-	Obj * a;
+	int get_number(const char* n);
-  public:
+	void setSource(const char* n);
-	iterator(Obj*aa) : a(aa) {}
-	iterator& operator++() { if ( a ) a = a->next; return *this; }
-	bool operator==(const iterator& b) const { return a == b.a; }
-	bool operator!=(const iterator& b) const { return !operator==(b); }
-	String& key() const { return a->key; }
-	String& value() const { return a->value; }
-  };
 	
-  inline iterator begin() const { return iterator(head); }
+	bool loadVault();
-  inline iterator end() const { return iterator(0); }
+	bool saveVault();
+	
+	void clear();
+
+	class iterator
+	{
+		Obj * a;
+	public:
+		iterator(Obj* aa) : a(aa) {}
+		iterator& operator++() { if (a) a = a->next; return *this; }
+		bool operator==(const iterator& b) const { return a == b.a; }
+		bool operator!=(const iterator& b) const { return !operator==(b); }
+		String& key() const { return a->key; }
+		String& value() const { return a->value; }
+	};
+
+	inline iterator begin() const { return iterator(head); }
+	inline iterator end() const { return iterator(0); }
 };
 
-#endif
+#endif //VAULT_CUSTOM_H
-
-
-

amxmodx/CVector.h

@@ -37,12 +37,20 @@
 // Vector
 template <class T> class CVector
 {
-	bool Grow()
+	bool Grow(size_t amount)
 	{
 		// automatic grow
 		size_t newSize = m_Size * 2;
+
 		if (newSize == 0)
-			newSize = 8;					// a good init value
+		{
+			newSize = 8;
+		}
+
+		while (m_CurrentUsedSize + amount > newSize)
+		{
+			newSize *= 2;
+		}
 		T *newData = new T[newSize];
 		if (!newData)
 			return false;
@@ -57,12 +65,16 @@ template <class T> class CVector
 		return true;
 	}
 
-	bool GrowIfNeeded()
+	bool GrowIfNeeded(size_t amount)
 	{
-		if (m_CurrentUsedSize >= m_Size)
+		if (m_CurrentUsedSize + amount >= m_Size)
-			return Grow();
+		{
+			return Grow(amount);
+		}
 		else
+		{
 			return true;
+		}
 	}
 
 	bool ChangeSize(size_t size)
@@ -70,32 +82,58 @@ template <class T> class CVector
 		// change size
 		if (size == m_Size)
 			return true;
+
+		if (!size)
+		{
+			if (m_Data)
+			{
+				delete [] m_Data;
+				m_Data = NULL;
+				m_Size = 0;
+			}
+			return true;
+		}
+
 		T *newData = new T[size];
 		if (!newData)
 			return false;
 		if (m_Data)
 		{
-			size_t end = (m_Size < size) ? (m_Size) : size;
+			size_t end = (m_CurrentUsedSize < size) ? (m_CurrentUsedSize) : size;
 			for (size_t i=0; i<end; i++)
 				newData[i] = m_Data[i];
 			delete [] m_Data;
 		}
-		if (m_Size < size)
-			m_CurrentSize = size;
 		m_Data = newData;
 		m_Size = size;
+		if (m_CurrentUsedSize > m_Size)
+			m_CurrentUsedSize = m_Size;
+
 		return true;
 	}
 
 	void FreeMemIfPossible()
 	{
+		if (!m_Data)
+			return;
 
+		if (!m_CurrentUsedSize)
+		{
+			ChangeSize(0);
+			return;
+		}
+
+		size_t newSize = m_Size;
+		while (m_CurrentUsedSize <= newSize / 2)
+			newSize /= 2;
+
+		if (newSize != m_Size)
+			ChangeSize(newSize);
 	}
 protected:
 	T *m_Data;
 	size_t m_Size;
 	size_t m_CurrentUsedSize;
-	size_t m_CurrentSize;
 public:
 	class iterator
 	{
@@ -189,7 +227,7 @@ public:
 
 		iterator & operator-=(size_t offset)
 		{
-			m_Ptr += offset;
+			m_Ptr -= offset;
 			return (*this);
 		}
 
@@ -203,7 +241,7 @@ public:
 		iterator operator-(size_t offset) const
 		{
 			iterator tmp(*this);
-			tmp.m_Ptr += offset;
+			tmp.m_Ptr -= offset;
 			return tmp;
 		}
 
@@ -277,12 +315,12 @@ public:
 		return m_Size;
 	}
 
-	iterator begin()
+	iterator begin() const
 	{
 		return iterator(m_Data);
 	}
 
-	iterator end()
+	iterator end() const
 	{
 		return iterator(m_Data + m_CurrentUsedSize);
 	}
@@ -296,19 +334,20 @@ public:
 
 	bool reserve(size_t newSize)
 	{
-		return ChangeSize(newSize);
+		if (newSize > m_Size)
+			return ChangeSize(newSize);
+		return true;
 	}
 
 	bool push_back(const T & elem)
 	{
-		++m_CurrentUsedSize;
+		if (!GrowIfNeeded(1))
-		if (!GrowIfNeeded())
 		{
-			--m_CurrentUsedSize;
 			return false;
 		}
 
-		m_Data[m_CurrentUsedSize - 1] = elem;
+		m_Data[m_CurrentUsedSize++] = elem;
+
 		return true;
 	}
 
@@ -317,14 +356,15 @@ public:
 		--m_CurrentUsedSize;
 		if (m_CurrentUsedSize < 0)
 			m_CurrentUsedSize = 0;
-		// :TODO: free memory sometimes
+
+		FreeMemIfPossible();
 	}
 
 	bool resize(size_t newSize)
 	{
 		if (!ChangeSize(newSize))
 			return false;
-		FreeMemIfPossible();
+		m_CurrentUsedSize = newSize;
 		return true;
 	}
 
@@ -397,50 +437,64 @@ public:
 		return m_Data[m_CurrentUsedSize - 1];
 	}
 
-	bool insert(iterator where, const T & value)
+	iterator 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))
+		if (where < m_Data || where > (m_Data + m_CurrentUsedSize))
-			return false;
+			return iterator(0);
 
-		++m_CurrentUsedSize;
+		size_t ofs = where - begin();
-		if (!GrowIfNeeded())
+
+		if (!GrowIfNeeded(1))
 		{
-			--m_CurrentUsedSize;
 			return false;
 		}
 
-		memmove(where.base() + 1, where.base(), m_CurrentUsedSize - (where - m_Data));
+		++m_CurrentUsedSize;
-		memcpy(where.base(), &value, sizeof(T));
+
-		return true;
+		where = begin() + ofs;
+
+		// Move subsequent entries
+		for (T *ptr = m_Data + m_CurrentUsedSize - 2; ptr >= where.base(); --ptr)
+			*(ptr + 1) = *ptr;
+
+		*where.base() = value;
+
+		return where;
 	}
 
-	void erase(iterator where)
+	iterator erase(iterator where)
 	{
 		// validate iter
 		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
-			return false;
+			return iterator(0);
+
+		size_t ofs = where - begin();
 
 		if (m_CurrentUsedSize > 1)
 		{
 			// move
-			memmove(where.base(), where.base() + 1, m_CurrentUsedSize - 1);
+			T *theend = m_Data + m_CurrentUsedSize;
+			for (T *ptr = where.base() + 1; ptr < theend; ++ptr)
+				*(ptr - 1) = *ptr;
 		}
 
 		--m_CurrentUsedSize;
-		// :TODO: free memory sometimes
+
+		FreeMemIfPossible();
+
+		return begin() + ofs;
 	}
 
 	void clear()
 	{
 		m_Size = 0;
 		m_CurrentUsedSize = 0;
-		delete [] m_Data;
+		if (m_Data)
-		m_Data = NULL;
+		{
+			delete [] m_Data;
+			m_Data = NULL;
+		}
 	}
 };
 

amxmodx/Makefile

@@ -1,95 +1,147 @@
-#(C)2004-2005 AMX Mod X Development Team
+# (C)2004-2013 AMX Mod X Development Team
 # Makefile written by David "BAILOPAN" Anderson
 
-HLSDK = ../hlsdk/SourceCode
+###########################################
-MM_ROOT = ../metamod/metamod
+### EDIT THESE PATHS FOR YOUR OWN SETUP ###
+###########################################
 
+HLSDK = ../../hlsdk/multiplayer
+MM_ROOT = ../../metamod/metamod
+
+#####################################
 ### EDIT BELOW FOR OTHER PROJECTS ###
+#####################################
 
-OPT_FLAGS = -O3 -funroll-loops -s -pipe
+PROJECT = amxmodx
-DEBUG_FLAGS = -g -ggdb3
-CPP = gcc
-NAME = amxmodx_mm
 
 OBJECTS = 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 \
+	  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 \
+	  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 \
+	  amxxfile.cpp CLang.cpp md5.cpp emsg.cpp CForward.cpp CPlugin.cpp CModule.cpp \
-	CMenu.cpp util.cpp amx.cpp amxdbg.cpp natives.cpp newmenus.cpp 
+	  CMenu.cpp util.cpp amx.cpp amxdbg.cpp natives.cpp newmenus.cpp debugger.cpp \
+	  optimizer.cpp format.cpp messages.cpp libraries.cpp vector.cpp sorting.cpp \
+	  amxmod_compat.cpp nongpl_matches.cpp CFlagManager.cpp datastructs.cpp \
+	  trie_natives.cpp
 
-LINK = -lz 
+##############################################
+### CONFIGURE ANY OTHER FLAGS/OPTIONS HERE ###
+##############################################
 
-INCLUDE = -I. -I$(HLSDK) -I$(HLSDK)/dlls -I$(HLSDK)/engine -I$(HLSDK)/game_shared -I$(HLSDK)/game_shared \
+C_OPT_FLAGS = -DNDEBUG -O2 -funroll-loops -fomit-frame-pointer -pipe
-	-I$(MM_ROOT) -Lzlib -I$(HLSDK)/common
+C_DEBUG_FLAGS = -D_DEBUG -DDEBUG -g -ggdb3
+C_GCC4_FLAGS = -fvisibility=hidden
+CPP_GCC4_FLAGS = -fvisibility-inlines-hidden
+CPP = gcc
+CPP_OSX = clang
+
+LINK = -Lzlib
+
+INCLUDE = -I. -I$(HLSDK) -I$(HLSDK)/common -I$(HLSDK)/dlls -I$(HLSDK)/engine -I$(HLSDK)/game_shared \
+	  -I$(MM_ROOT)
+
+################################################
+### DO NOT EDIT BELOW HERE FOR MOST PROJECTS ###
+################################################
+
+OS := $(shell uname -s)
+
+ifeq "$(OS)" "Darwin"
+	OBJECTS += JIT/amxexecn-darwin.o JIT/amxjitsn-darwin.o JIT/natives-darwin-x86.o \
+		   JIT/helpers-darwin-x86.o
+
+	CPP = $(CPP_OSX)
+	LIB_EXT = dylib
+	LIB_SUFFIX = _mm
+	CFLAGS += -DOSX
+	LINK += -dynamiclib -lstdc++ -mmacosx-version-min=10.5 -Wl,-read_only_relocs,suppress -lz-darwin
+else
+	OBJECTS += JIT/amxexecn.o JIT/amxjitsn.o JIT/natives-x86.o JIT/helpers-x86.o
+
+	LIB_EXT = so
+	LIB_SUFFIX = _mm_i386
+	CFLAGS += -DLINUX
+	LINK += -shared -lz
+endif
+
+LINK += -m32 -lm -ldl
+
+CFLAGS += -DAMX_NOPROPLIST -DPAWN_CELL_SIZE=32 -DJIT -DASM32 -DHAVE_STDINT_H -fno-strict-aliasing \
+	  -m32 -Wall -Werror
+CPPFLAGS += -fno-exceptions -fno-rtti
+
+BINARY = $(PROJECT)$(LIB_SUFFIX).$(LIB_EXT)
 
 ifeq "$(DEBUG)" "true"
 	BIN_DIR = Debug
-	CFLAGS = $(DEBUG_FLAGS)
+	CFLAGS += $(C_DEBUG_FLAGS)
 else
 	BIN_DIR = Release
-	CFLAGS = $(OPT_FLAGS)
+	CFLAGS += $(C_OPT_FLAGS)
+	LINK += -s
 endif
 
-ifeq "$(MMGR)" "true"
+ifeq "$(BINLOG)" "true"
-	OBJECTS += mmgr/mmgr.cpp
+	LIB_SUFFIX := _bl$(LIB_SUFFIX)
-	CFLAGS += -DMEMORY_TEST
+	BIN_DIR := $(BIN_DIR)BinLog
+	OBJECTS += binlog.cpp
+	CFLAGS += -DBINLOG_ENABLED
 endif
 
-CFLAGS += -DLINUX -DNDEBUG -fPIC -Wno-deprecated -DHAVE_STDINT_H -static-libgcc -fno-rtti -fno-exceptions
+IS_CLANG := $(shell $(CPP) --version | head -1 | grep clang > /dev/null && echo "1" || echo "0")
 
-ifeq "$(AMD64)" "true"
+ifeq "$(IS_CLANG)" "1"
-	BINARY = $(NAME)_amd64.so
+	CPP_MAJOR := $(shell $(CPP) --version | grep clang | sed "s/.*version \([0-9]\)*\.[0-9]*.*/\1/")
-	CFLAGS += -DPAWN_CELL_SIZE=64 -DHAVE_I64 -m64 
+	CPP_MINOR := $(shell $(CPP) --version | grep clang | sed "s/.*version [0-9]*\.\([0-9]\)*.*/\1/")
-	OBJECTS += JIT/natives-amd64.o
 else
-	BINARY = $(NAME)_i386.so
+	CPP_MAJOR := $(shell $(CPP) -dumpversion >&1 | cut -b1)
-	OBJECTS += JIT/amxexecn.o JIT/amxjitsn.o JIT/natives-x86.o
+	CPP_MINOR := $(shell $(CPP) -dumpversion >&1 | cut -b3)
-	CFLAGS += -DPAWN_CELL_SIZE=32 -DJIT -DASM32
-	OPT_FLAGS += -march=i686
 endif
 
-OBJ_LINUX := $(OBJECTS:%.cpp=$(BIN_DIR)/%.o)
+# Clang || GCC >= 4
+ifeq "$(shell expr $(IS_CLANG) \| $(CPP_MAJOR) \>= 4)" "1"
+	CFLAGS += $(C_GCC4_FLAGS)
+	CPPFLAGS += $(CPP_GCC4_FLAGS)
+endif
+
+# Clang >= 3 || GCC >= 4.7
+ifeq "$(shell expr $(IS_CLANG) \& $(CPP_MAJOR) \>= 3 \| $(CPP_MAJOR) \>= 4 \& $(CPP_MINOR) \>= 7)" "1"
+	CFLAGS += -Wno-delete-non-virtual-dtor
+endif
+
+# OS is Linux and not using clang
+ifeq "$(shell expr $(OS) \= Linux \& $(IS_CLANG) \= 0)" "1"
+	LINK += -static-libgcc
+endif
+
+OBJ_BIN := $(OBJECTS:%.cpp=$(BIN_DIR)/%.o)
+
+# This will break if we include other Makefiles, but is fine for now. It allows
+#  us to make a copy of this file that uses altered paths (ie. Makefile.mine)
+#  or other changes without mucking up the original.
+MAKEFILE_NAME := $(CURDIR)/$(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST))
 
 $(BIN_DIR)/%.o: %.cpp
-	$(CPP) $(INCLUDE) $(CFLAGS) -o $@ -c $<
+	$(CPP) $(INCLUDE) $(CFLAGS) $(CPPFLAGS) -o $@ -c $<
 
 all:
 	mkdir -p $(BIN_DIR)
-	$(MAKE) amxmodx
+	$(MAKE) -f $(MAKEFILE_NAME) $(PROJECT)
 
-amd64:
+binlog:
-	rm -f zlib/libz.a
+	$(MAKE) -f $(MAKEFILE_NAME) all BINLOG=true
-	$(MAKE) all AMD64=true
 
-amd64_mmgr:
+binlog_debug:
-	rm -f zlib/libz.a
+	$(MAKE) -f $(MAKEFILE_NAME) all BINLOG=true DEBUG=true
-	$(MAKE) all AMD64=true MMGR=true
 
-amd64_debug_mmgr:
+$(PROJECT): $(OBJ_BIN)
-	rm -f zlib/libz.a
+	$(CPP) $(INCLUDE) $(OBJ_BIN) $(LINK) -o $(BIN_DIR)/$(BINARY)
-	$(MAKE) all AMD64=true DEBUG=true MMGR=true
-
-amd64_debug:
-	rm -f zlib/libz.a
-	$(MAKE) all AMD64=true DEBUG=true
-
-mmgr:
-	$(MAKE) all MMGR=true
-
-debug_mmgr:
-	$(MAKE) all MMGR=true DEBUG=true
-
-amxmodx: $(OBJ_LINUX)
-	$(CPP) $(INCLUDE) $(CFLAGS) $(OBJ_LINUX) $(LINK) -shared -ldl -lm -o$(BIN_DIR)/$(BINARY)
 
 debug:
-	$(MAKE) all DEBUG=true
+	$(MAKE) -f $(MAKEFILE_NAME) all DEBUG=true
 
 default: all
 
 clean:
-	rm -rf Release/*.o
+	rm -rf $(BIN_DIR)/*.o
-	rm -rf Release/$(BINARY)
+	rm -f $(BIN_DIR)/$(BINARY)
-	rm -rf Debug/*.o
-	rm -rf Debug/$(BINARY)
 

amxmodx/amx.cpp

@@ -18,13 +18,13 @@
  *      misrepresented as being the original software.
  *  3.  This notice may not be removed or altered from any source distribution.
  *
- *  Version: $Id$
+ *  Version: $Id: amx.cpp 3707 2008-04-14 19:56:31Z sawce $
  */
 
 #define AMX_NODYNALOAD
-#define	AMX_ANSIONLY
+#define AMX_ANSIONLY
 
-#if BUILD_PLATFORM == WINDOWS && BUILD_TYPE == RELEASE && BUILD_COMPILER == MSVC && PAWN_CELL_SIZE == 64
+#if !defined __linux__ && BUILD_PLATFORM == WINDOWS && BUILD_TYPE == RELEASE && BUILD_COMPILER == MSVC && PAWN_CELL_SIZE == 64
   /* bad bad workaround but we have to prevent a compiler crash :/ */
   #pragma optimize("g",off)
 #endif
@@ -46,8 +46,9 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <math.h>
 #include "osdefs.h"
-#if defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
+#if defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
   #include <sclinux.h>
   #include <unistd.h>
   #include <errno.h>
@@ -265,6 +266,13 @@ typedef enum {
   OP_SYSREQ_D,
   OP_SYMTAG,  /* obsolete */
   OP_BREAK,
+  OP_FLOAT_MUL,
+  OP_FLOAT_DIV,
+  OP_FLOAT_ADD,
+  OP_FLOAT_SUB,
+  OP_FLOAT_TO,
+  OP_FLOAT_ROUND,
+  OP_FLOAT_CMP,
   /* ----- */
   OP_NUM_OPCODES
 } OPCODE;
@@ -425,13 +433,10 @@ int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params)
   AMX_FUNCSTUB *func;
   AMX_NATIVE f;
 
-  assert(amx!=NULL);
   hdr=(AMX_HEADER *)amx->base;
-  assert(hdr!=NULL);
-  assert(hdr->magic==AMX_MAGIC);
   assert(hdr->natives<=hdr->libraries);
 #if defined AMX_NATIVETABLE
-  if (index<NULL) {
+  if (index<0) {
     assert(-(index+1)<(sizeof(AMX_NATIVETABLE)/sizeof(AMX_NATIVETABLE)[0]));
     f=(AMX_NATIVETABLE)[-(index+1)];
   } else {
@@ -444,34 +449,10 @@ int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params)
 #endif
   assert(f!=NULL);
 
-  /* Now that we have found the function, patch the program so that any
+  /* As of AMX Mod X 1.56, we don't patch sysreq.c to sysreq.d anymore.
-   * subsequent call will call the function directly (bypassing this
+   * Otherwise, we'd have no way of knowing the last native to be used.
-   * callback).
-   * This trick cannot work in the JIT, because the program would need to
-   * be re-JIT-compiled after patching a P-code instruction.
    */
-  #if defined JIT && !defined NDEBUG
+  amx->usertags[UT_NATIVE] = (void *)index;
-    if ((amx->flags & AMX_FLAG_JITC)!=0)
-      assert(amx->sysreq_d==0);
-  #endif
-  if (amx->sysreq_d!=0) {
-    /* at the point of the call, the CIP pseudo-register points directly
-     * behind the SYSREQ instruction and its parameter.
-     */
-    unsigned char *code=amx->base+(int)hdr->cod+(int)amx->cip-4;
-    assert(amx->cip >= 4 && amx->cip < (hdr->dat - hdr->cod));
-    assert(sizeof(f)<=sizeof(cell));    /* function pointer must fit in a cell */
-#if defined __GNUC__ || defined ASM32
-    if (*(cell*)code==index) {
-#else
-    if (*(cell*)code!=OP_SYSREQ_PRI) {
-      assert(*(cell*)(code-sizeof(cell))==OP_SYSREQ_C);
-      assert(*(cell*)code==index);
-#endif
-      *(cell*)(code-sizeof(cell))=amx->sysreq_d;
-      *(cell*)code=(cell)f;
-    } /* if */
-  } /* if */
 
   /* Note:
    *   params[0] == number of bytes for the additional parameters passed to the native function
@@ -480,7 +461,25 @@ int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params)
    */
 
   amx->error=AMX_ERR_NONE;
+
+#if defined BINLOG_ENABLED
+  binlogfuncs_t *logfuncs = (binlogfuncs_t *)amx->usertags[UT_BINLOGS];
+  if (logfuncs)
+  {
+	  logfuncs->pfnLogNative(amx, index, (int)(params[0] / sizeof(cell)));
+	  logfuncs->pfnLogParams(amx, params);
+  }
+#endif //BINLOG_ENABLED
+
   *result = f(amx,params);
+
+#if defined BINLOG_ENABLED
+  if (logfuncs)
+  {
+	  logfuncs->pfnLogReturn(amx, *result);
+  }
+#endif
+
   return amx->error;
 }
 #endif /* defined AMX_INIT */
@@ -512,6 +511,7 @@ static int amx_BrowseRelocate(AMX *amx)
   cell cip;
   long codesize;
   OPCODE op;
+  BROWSEHOOK hook = NULL;
   #if defined __GNUC__ || defined ASM32 || defined JIT
     cell *opcode_list;
   #endif
@@ -527,6 +527,7 @@ static int amx_BrowseRelocate(AMX *amx)
   code=amx->base+(int)hdr->cod;
   codesize=hdr->dat - hdr->cod;
   amx->flags|=AMX_FLAG_BROWSE;
+  hook = (BROWSEHOOK)amx->usertags[UT_BROWSEHOOK];
 
   /* sanity checks */
   assert(OP_PUSH_PRI==36);
@@ -547,6 +548,7 @@ static int amx_BrowseRelocate(AMX *amx)
      */
     if ((amx->flags & AMX_FLAG_JITC)==0 && sizeof(AMX_NATIVE)<=sizeof(cell))
       amx->sysreq_d=opcode_list[OP_SYSREQ_D];
+	amx->userdata[UD_OPCODELIST] = (void *)opcode_list;
   #else
     /* ANSI C
      * to use direct system requests, a function pointer must fit in a cell;
@@ -554,6 +556,7 @@ static int amx_BrowseRelocate(AMX *amx)
      */
     if (sizeof(AMX_NATIVE)<=sizeof(cell))
       amx->sysreq_d=OP_SYSREQ_D;
+	amx->userdata[UD_OPCODELIST] = (long)NULL;
   #endif
 
   /* start browsing code */
@@ -630,11 +633,22 @@ static int amx_BrowseRelocate(AMX *amx)
     case OP_FILL:
     case OP_HALT:
     case OP_BOUNDS:
-    case OP_SYSREQ_C:
     case OP_PUSHADDR:
     case OP_SYSREQ_D:
       cip+=sizeof(cell);
       break;
+    case OP_SYSREQ_C:
+		{
+			if (hook)
+#if defined __GNUC__ || defined ASM32 || defined JIT
+				hook(amx, opcode_list, &cip);
+#else
+				hook(amx, NULL, &cip);
+#endif
+			else
+				cip+=sizeof(cell);
+			break;
+		}
 
     case OP_LOAD_I:     /* instructions without parameters */
     case OP_STOR_I:
@@ -695,6 +709,13 @@ static int amx_BrowseRelocate(AMX *amx)
     case OP_SWAP_ALT:
     case OP_NOP:
     case OP_BREAK:
+    case OP_FLOAT_MUL:
+    case OP_FLOAT_DIV:
+    case OP_FLOAT_ADD:
+    case OP_FLOAT_SUB:
+    case OP_FLOAT_TO:
+    case OP_FLOAT_ROUND:
+	case OP_FLOAT_CMP:
       break;
 
     case OP_CALL:       /* opcodes that need relocation */
@@ -782,7 +803,7 @@ static void expand(unsigned char *code, long codesize, long memsize)
     do {
       codesize--;
       /* no input byte should be shifted out completely */
-      assert(shift<8*sizeof(cell));
+      assert(shift<static_cast<int>(8*sizeof(cell)));
       /* we work from the end of a sequence backwards; the final code in
        * a sequence may not have the continuation bit set */
       assert(shift>0 || (code[(size_t)codesize] & 0x80)==0);
@@ -819,22 +840,10 @@ static void expand(unsigned char *code, long codesize, long memsize)
 }
 #endif /* defined AMX_INIT */
 
-int AMXAPI amx_Init(AMX *amx,void *program)
+int AMXAPI amx_Init(AMX *amx, void *program)
 {
   AMX_HEADER *hdr;
-  #if (defined _Windows || defined LINUX || defined __FreeBSD__ || defined __OpenBSD__) && !defined AMX_NODYNALOAD
+  BROWSEHOOK hook = NULL;
-    char libname[sNAMEMAX+8];  /* +1 for '\0', +3 for 'amx' prefix, +4 for extension */
-    #if defined _Windows
-      typedef int (FAR WINAPI *AMX_ENTRY)(AMX _FAR *amx);
-      HINSTANCE hlib;
-    #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
-      typedef int (*AMX_ENTRY)(AMX *amx);
-      void *hlib;
-    #endif
-    int numlibraries,i;
-    AMX_FUNCSTUB *lib;
-    AMX_ENTRY libinit;
-  #endif
 
   if ((amx->flags & AMX_FLAG_RELOC)!=0)
     return AMX_ERR_INIT;  /* already initialized (may not do so twice) */
@@ -844,22 +853,6 @@ int AMXAPI amx_Init(AMX *amx,void *program)
    * multi-byte words
    */
   assert(check_endian());
-  #if BYTE_ORDER==BIG_ENDIAN
-    amx_Align32((uint32_t*)&hdr->size);
-    amx_Align16(&hdr->magic);
-    amx_Align16((uint16_t*)&hdr->flags);
-    amx_Align16((uint16_t*)&hdr->defsize);
-    amx_Align32((uint32_t*)&hdr->cod);
-    amx_Align32((uint32_t*)&hdr->dat);
-    amx_Align32((uint32_t*)&hdr->hea);
-    amx_Align32((uint32_t*)&hdr->stp);
-    amx_Align32((uint32_t*)&hdr->cip);
-    amx_Align32((uint32_t*)&hdr->publics);
-    amx_Align32((uint32_t*)&hdr->natives);
-    amx_Align32((uint32_t*)&hdr->libraries);
-    amx_Align32((uint32_t*)&hdr->pubvars);
-    amx_Align32((uint32_t*)&hdr->tags);
-  #endif
 
   if (hdr->magic!=AMX_MAGIC)
     return AMX_ERR_FORMAT;
@@ -880,13 +873,7 @@ int AMXAPI amx_Init(AMX *amx,void *program)
   } /* if */
   if (hdr->stp<=0)
     return AMX_ERR_FORMAT;
-  #if BYTE_ORDER==BIG_ENDIAN
+
-    if ((hdr->flags & AMX_FLAG_COMPACT)==0) {
-      ucell *code=(ucell *)((unsigned char *)program+(int)hdr->cod);
-      while (code<(ucell *)((unsigned char *)program+(int)hdr->hea))
-        swapcell(code++);
-    } /* if */
-  #endif
   assert((hdr->flags & AMX_FLAG_COMPACT)!=0 || hdr->hea == hdr->size);
   if ((hdr->flags & AMX_FLAG_COMPACT)!=0) {
     #if AMX_COMPACTMARGIN > 2
@@ -913,111 +900,18 @@ int AMXAPI amx_Init(AMX *amx,void *program)
     amx->callback=amx_Callback;
   amx->data=NULL;
 
-  /* also align all addresses in the public function, public variable,
-   * public tag and native function tables --offsets into the name table
-   * (if present) must also be swapped.
-   */
-  #if BYTE_ORDER==BIG_ENDIAN
-  { /* local */
-    AMX_FUNCSTUB *fs;
-    int i,num;
-
-    fs=GETENTRY(hdr,natives,0);
-    num=NUMENTRIES(hdr,natives,libraries);
-    for (i=0; i<num; i++) {
-      amx_AlignCell(&fs->address);      /* redundant, because it should be zero */
-      if (USENAMETABLE(hdr))
-        amx_AlignCell(&((AMX_FUNCSTUBNT*)fs)->nameofs);
-      fs=(AMX_FUNCSTUB*)((unsigned char *)fs+hdr->defsize);
-    } /* for */
-
-    fs=GETENTRY(hdr,publics,0);
-    assert(hdr->publics<=hdr->natives);
-    num=NUMENTRIES(hdr,publics,natives);
-    for (i=0; i<num; i++) {
-      amx_AlignCell(&fs->address);
-      if (USENAMETABLE(hdr))
-        amx_AlignCell(&((AMX_FUNCSTUBNT*)fs)->nameofs);
-      fs=(AMX_FUNCSTUB*)((unsigned char *)fs+hdr->defsize);
-    } /* for */
-
-    fs=GETENTRY(hdr,pubvars,0);
-    assert(hdr->pubvars<=hdr->tags);
-    num=NUMENTRIES(hdr,pubvars,tags);
-    for (i=0; i<num; i++) {
-      amx_AlignCell(&fs->address);
-      if (USENAMETABLE(hdr))
-        amx_AlignCell(&((AMX_FUNCSTUBNT*)fs)->nameofs);
-      fs=(AMX_FUNCSTUB*)((unsigned char *)fs+hdr->defsize);
-    } /* for */
-
-    fs=GETENTRY(hdr,tags,0);
-    if (hdr->file_version<7) {
-      assert(hdr->tags<=hdr->cod);
-      num=NUMENTRIES(hdr,tags,cod);
-    } else {
-      assert(hdr->tags<=hdr->nametable);
-      num=NUMENTRIES(hdr,tags,nametable);
-    } /* if */
-    for (i=0; i<num; i++) {
-      amx_AlignCell(&fs->address);
-      if (USENAMETABLE(hdr))
-        amx_AlignCell(&((AMX_FUNCSTUBNT*)fs)->nameofs);
-      fs=(AMX_FUNCSTUB*)((unsigned char *)fs+hdr->defsize);
-    } /* for */
-  } /* local */
-  #endif
-
   /* relocate call and jump instructions */
+  hook = (BROWSEHOOK)amx->usertags[UT_BROWSEHOOK];
+  if (hook)
+	  hook(amx, NULL, NULL);
   amx_BrowseRelocate(amx);
 
-  /* load any extension modules that the AMX refers to */
-  #if (defined _Windows || defined LINUX || defined __FreeBSD__ || defined __OpenBSD__) && !defined AMX_NODYNALOAD
-    hdr=(AMX_HEADER *)amx->base;
-    numlibraries=NUMENTRIES(hdr,libraries,pubvars);
-    for (i=0; i<numlibraries; i++) {
-      lib=GETENTRY(hdr,libraries,i);
-      strcpy(libname,"amx");
-      strcat(libname,GETENTRYNAME(hdr,lib));
-      #if defined _Windows
-        strcat(libname,".dll");
-        #if defined __WIN32__
-          hlib=LoadLibraryA(libname);
-        #else
-          hlib=LoadLibrary(libname);
-          if (hlib<=HINSTANCE_ERROR)
-            hlib=NULL;
-        #endif
-      #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
-        strcat(libname,".so");
-        hlib=dlopen(libname,RTLD_NOW);
-      #endif
-      if (hlib!=NULL) {
-        /* a library that cannot be loaded or that does not have the required
-         * initialization function is simply ignored
-         */
-        char funcname[sNAMEMAX+9]; /* +1 for '\0', +4 for 'amx_', +4 for 'Init' */
-        strcpy(funcname,"amx_");
-        strcat(funcname,GETENTRYNAME(hdr,lib));
-        strcat(funcname,"Init");
-        #if defined _Windows
-          libinit=(AMX_ENTRY)GetProcAddress(hlib,funcname);
-        #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
-          libinit=(AMX_ENTRY)dlsym(hlib,funcname);
-        #endif
-        if (libinit!=NULL)
-          libinit(amx);
-      } /* if */
-      lib->address=(ucell)hlib;
-    } /* for */
-  #endif
-
   return AMX_ERR_NONE;
 }
 
 #if defined JIT
 
-  #define CODESIZE_JIT    8192  /* approximate size of the code for the JIT */
+  #define CODESIZE_JIT    65536  /* approximate size of the code for the JIT */
 
   #if defined __WIN32__   /* this also applies to Win32 "console" applications */
 
@@ -1038,7 +932,7 @@ int AMXAPI amx_Init(AMX *amx,void *program)
 
     #define ALIGN(addr) (addr)
 
-  #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
+  #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
 
     /* Linux already has mprotect() */
     /* But wants the address aligned! */
@@ -1079,26 +973,25 @@ int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code)
   memcpy(native_code, amx->base, ((AMX_HEADER *)(amx->base))->cod);
   hdr = (AMX_HEADER *)native_code;
 
+  
+
   /* JIT rulz! (TM) */
   /* MP: added check for correct compilation */
   //Fixed bug (thanks T(+)rget)
   if ((res = asm_runJIT(amx->base, reloc_table, native_code)) == 0) 
   {
-    /* update the required memory size (the previous value was a
-     * conservative estimate, now we know the exact size)
-     */
-    amx->code_size = (hdr->dat + hdr->stp + 3) & ~3;
     /* The compiled code is relocatable, since only relative jumps are
      * used for destinations within the generated code and absoulute
      * addresses for jumps into the runtime, which is fixed in memory.
      */
     amx->base = (unsigned char*) native_code;
     amx->cip = hdr->cip;
-    amx->hea = hdr->hea;
+	/* also put a sentinel for strings at the top the stack */
-    amx->stp = hdr->stp - sizeof(cell);
+	*(cell *)((char*)native_code + hdr->dat + amx->stp - sizeof(cell)) = 0;
-    /* also put a sentinel for strings at the top the stack */
+	/* update the required memory size (the previous value was a
-    *(cell *)((char*)native_code + hdr->dat + hdr->stp - sizeof(cell)) = 0;
+	 * conservative estimate, now we know the exact size)
-    amx->stk = amx->stp;
+	 */
+	amx->code_size = (hdr->dat + amx->stp + sizeof(cell)) & ~3;
   } /* if */
 
   return (res == 0) ? AMX_ERR_NONE : AMX_ERR_INIT_JIT;
@@ -1121,10 +1014,10 @@ int AMXAPI amx_InitJIT(AMX *amx,void *compiled_program,void *reloc_table)
 #if defined AMX_CLEANUP
 int AMXAPI amx_Cleanup(AMX *amx)
 {
-  #if (defined _Windows || defined LINUX || defined __FreeBSD__ || defined __OpenBSD__) && !defined AMX_NODYNALOAD
+  #if (defined _Windows || defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__) && !defined AMX_NODYNALOAD
     #if defined _Windows
       typedef int (FAR WINAPI *AMX_ENTRY)(AMX FAR *amx);
-    #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
+    #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
       typedef int (*AMX_ENTRY)(AMX *amx);
     #endif
     AMX_HEADER *hdr;
@@ -1134,7 +1027,7 @@ int AMXAPI amx_Cleanup(AMX *amx)
   #endif
 
   /* unload all extension modules */
-  #if (defined _Windows || defined LINUX || defined __FreeBSD__ || defined __OpenBSD__) && !defined AMX_NODYNALOAD
+  #if (defined _Windows || defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__) && !defined AMX_NODYNALOAD
     hdr=(AMX_HEADER *)amx->base;
     assert(hdr->magic==AMX_MAGIC);
     numlibraries=NUMENTRIES(hdr,libraries,pubvars);
@@ -1147,14 +1040,14 @@ int AMXAPI amx_Cleanup(AMX *amx)
         strcat(funcname,"Cleanup");
         #if defined _Windows
           libcleanup=(AMX_ENTRY)GetProcAddress((HINSTANCE)lib->address,funcname);
-        #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
+        #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
           libcleanup=(AMX_ENTRY)dlsym((void*)lib->address,funcname);
         #endif
         if (libcleanup!=NULL)
           libcleanup(amx);
         #if defined _Windows
           FreeLibrary((HINSTANCE)lib->address);
-        #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
+        #elif defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
           dlclose((void*)lib->address);
         #endif
       } /* if */
@@ -1282,27 +1175,22 @@ int AMXAPI amx_GetNative(AMX *amx, int index, char *funcname)
 
 int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index)
 {
-  int first,last,mid,result;
+  int first,last,mid;
   char pname[sNAMEMAX+1];
 
   amx_NumNatives(amx, &last);
   last--;       /* last valid index is 1 less than the number of functions */
   first=0;
-  /* binary search */
+  /* normal search */
-  while (first<=last) {
+  for (mid=0; mid<=last; mid++)
-    mid=(first+last)/2;
+  {
     amx_GetNative(amx, mid, pname);
-    result=strcmp(pname,name);
+    if (strcmp(pname, name)==0)
-    if (result>0) {
+	{
-      last=mid-1;
+      *index = mid;
-    } else if (result<0) {
-      first=mid+1;
-    } else {
-      *index=mid;
       return AMX_ERR_NONE;
-    } /* if */
+	} /* if */
-  } /* while */
+  } /* for */
-  /* not found, set to an invalid index, so amx_Exec() will fail */
   *index=INT_MAX;
   return AMX_ERR_NOTFOUND;
 }
@@ -1515,37 +1403,11 @@ int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname)
 #if defined AMX_XXXUSERDATA
 int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr)
 {
-  int index;
-
-  assert(amx!=NULL);
-  assert(tag!=0);
-  for (index=0; index<AMX_USERNUM && amx->usertags[index]!=tag; index++)
-    /* nothing */;
-  if (index>=AMX_USERNUM)
-    return AMX_ERR_USERDATA;
-  *ptr=amx->userdata[index];
   return AMX_ERR_NONE;
 }
 
 int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr)
 {
-  int index;
-
-  assert(amx!=NULL);
-  assert(tag!=0);
-  /* try to find existing tag */
-  for (index=0; index<AMX_USERNUM && amx->usertags[index]!=tag; index++)
-    /* nothing */;
-  /* if not found, try to find empty tag */
-  if (index>=AMX_USERNUM)
-    for (index=0; index<AMX_USERNUM && amx->usertags[index]!=0; index++)
-      /* nothing */;
-  /* if still not found, quit with error */
-  if (index>=AMX_USERNUM)
-    return AMX_ERR_INDEX;
-  /* set the tag and the value */
-  amx->usertags[index]=tag;
-  amx->userdata[index]=ptr;
   return AMX_ERR_NONE;
 }
 #endif /* AMX_XXXUSERDATA */
@@ -1563,6 +1425,91 @@ static AMX_NATIVE findfunction(const char *name, const AMX_NATIVE_INFO *list, in
 }
 
 const char *no_function;
+
+int AMXAPI amx_CheckNatives(AMX *amx, AMX_NATIVE_FILTER nf)
+{
+  AMX_FUNCSTUB *func;
+  AMX_HEADER *hdr;
+  int i,numnatives,res=0;
+
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->natives<=hdr->libraries);
+  numnatives=NUMENTRIES(hdr,natives,libraries);
+
+  func=GETENTRY(hdr,natives,0);
+  for (i=0; i<numnatives; i++) {
+    if (func->address==0) {
+      /* this function is not yet located */
+      res=nf(amx,i);
+      if (!res)
+	  {
+        no_function = GETENTRYNAME(hdr,func);
+        return 0;
+	  }
+    } /* if */
+    func=(AMX_FUNCSTUB*)((unsigned char*)func+hdr->defsize);
+  } /* for */
+  return 1;
+}
+
+int AMXAPI amx_RegisterToAny(AMX *amx, AMX_NATIVE f)
+{
+  AMX_FUNCSTUB *func;
+  AMX_HEADER *hdr;
+  int i,numnatives,err;
+
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->natives<=hdr->libraries);
+  numnatives=NUMENTRIES(hdr,natives,libraries);
+
+  err=AMX_ERR_NONE;
+  func=GETENTRY(hdr,natives,0);
+  for (i=0; i<numnatives; i++) {
+    if (func->address==0) {
+      /* this function is not yet located */
+      func->address=(ucell)f;
+    } /* if */
+    func=(AMX_FUNCSTUB*)((unsigned char*)func+hdr->defsize);
+  } /* for */
+  if (err==AMX_ERR_NONE)
+    amx->flags|=AMX_FLAG_NTVREG;
+  return err;
+}
+
+int AMXAPI amx_Reregister(AMX *amx, const AMX_NATIVE_INFO *list, int number)
+{
+  AMX_FUNCSTUB *func;
+  AMX_HEADER *hdr;
+  int i,numnatives,count=0;
+  AMX_NATIVE funcptr;
+
+  hdr=(AMX_HEADER *)amx->base;
+  assert(hdr!=NULL);
+  assert(hdr->magic==AMX_MAGIC);
+  assert(hdr->natives<=hdr->libraries);
+  numnatives=NUMENTRIES(hdr,natives,libraries);
+
+  count=0;
+  func=GETENTRY(hdr,natives,0);
+  for (i=0; i<numnatives; i++) {
+    if (func->address!=0) {
+      /* this function is located */
+      funcptr=(list!=NULL) ? findfunction(GETENTRYNAME(hdr,func),list,number) : NULL;
+      if (funcptr!=NULL)
+      {
+        func->address=(ucell)funcptr;
+        count++;
+      }
+    } /* if */
+    func=(AMX_FUNCSTUB*)((unsigned char*)func+hdr->defsize);
+  } /* for */
+  return count;
+}
+
 int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *list, int number)
 {
   AMX_FUNCSTUB *func;
@@ -1583,12 +1530,12 @@ int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *list, int number)
       /* this function is not yet located */
       funcptr=(list!=NULL) ? findfunction(GETENTRYNAME(hdr,func),list,number) : NULL;
       if (funcptr!=NULL)
-	  {
+      {
         func->address=(ucell)funcptr;
       } else {
         no_function = GETENTRYNAME(hdr,func);
         err=AMX_ERR_NOTFOUND;
-	  }
+       }
     } /* if */
     func=(AMX_FUNCSTUB*)((unsigned char*)func+hdr->defsize);
   } /* for */
@@ -1676,7 +1623,13 @@ int AMXAPI amx_PushString(AMX *amx, cell *amx_addr, cell **phys_addr, const char
 #define SKIPPARAM(n)    ( cip=(cell *)cip+(n) )
 #define PUSH(v)         ( stk-=sizeof(cell), *(cell *)(data+(int)stk)=v )
 #define POP(v)          ( v=*(cell *)(data+(int)stk), stk+=sizeof(cell) )
-#define ABORT(amx,v)    { (amx)->stk=reset_stk; (amx)->hea=reset_hea; return v; }
+#define ABORT(amx,v)    { (amx)->stk=reset_stk; \
+						  (amx)->hea=reset_hea; \
+						  (amx)->cip=(cell)cip; \
+						  (amx)->pri=pri; \
+						  (amx)->alt=alt; \
+						  return v; \
+						}
 
 #define CHKMARGIN()     if (hea+STKMARGIN>stk) return AMX_ERR_STACKERR
 #define CHKSTACK()      if (stk>amx->stp) return AMX_ERR_STACKLOW
@@ -1726,13 +1679,16 @@ static const void * const amx_opcodelist[] = {
         &&op_file,      &&op_line,      &&op_symbol,    &&op_srange,
         &&op_jump_pri,  &&op_switch,    &&op_casetbl,   &&op_swap_pri,
         &&op_swap_alt,  &&op_pushaddr,  &&op_nop,       &&op_sysreq_d,
-        &&op_symtag,    &&op_break };
+        &&op_symtag,    &&op_break,     &&op_float_mul, &&op_float_div,
+        &&op_float_add, &&op_float_sub, &&op_float_to,  &&op_float_round,
+        &&op_float_cmp};
   AMX_HEADER *hdr;
   AMX_FUNCSTUB *func;
   unsigned char *code, *data;
   cell pri,alt,stk,frm,hea;
   cell reset_stk, reset_hea, *cip;
-  cell offs;
+  cell offs, offs2;
+  REAL fnum, fnum2;
   ucell codesize;
   int num,i;
 
@@ -2471,6 +2427,8 @@ static const void * const amx_opcodelist[] = {
     amx->hea=hea;
     amx->frm=frm;
     amx->stk=stk;
+    amx->pri=pri;
+    amx->alt=alt;
     num=amx->callback(amx,pri,&pri,(cell *)(data+(int)stk));
     if (num!=AMX_ERR_NONE) {
       if (num==AMX_ERR_SLEEP) {
@@ -2490,6 +2448,8 @@ static const void * const amx_opcodelist[] = {
     amx->hea=hea;
     amx->frm=frm;
     amx->stk=stk;
+    amx->pri=pri;
+    amx->alt=alt;
     num=amx->callback(amx,offs,&pri,(cell *)(data+(int)stk));
     if (num!=AMX_ERR_NONE) {
       if (num==AMX_ERR_SLEEP) {
@@ -2509,6 +2469,8 @@ static const void * const amx_opcodelist[] = {
     amx->hea=hea;
     amx->frm=frm;
     amx->stk=stk;
+    amx->pri=pri;
+    amx->alt=alt;
     pri=((AMX_NATIVE)offs)(amx,(cell *)(data+(int)stk));
     if (amx->error!=AMX_ERR_NONE) {
       if (amx->error==AMX_ERR_SLEEP) {
@@ -2572,12 +2534,67 @@ static const void * const amx_opcodelist[] = {
     NEXT(cip);
   op_nop:
     NEXT(cip);
-  op_break:
+  op_float_mul:
+    offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+    offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+    fnum = amx_ctof(offs) * amx_ctof(offs2);
+    pri = amx_ftoc(fnum);
+    NEXT(cip);
+  op_float_add:
+    offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+    offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+    fnum = amx_ctof(offs) + amx_ctof(offs2);
+    pri = amx_ftoc(fnum);
+    NEXT(cip);
+  op_float_sub:
+    offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+    offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+    fnum = amx_ctof(offs) - amx_ctof(offs2);
+    pri = amx_ftoc(fnum);
+    NEXT(cip);
+  op_float_div:
+    offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+    offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+    fnum = amx_ctof(offs) / amx_ctof(offs2);
+    pri = amx_ftoc(fnum);
+    NEXT(cip);
+  op_float_to:
+    offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+    fnum = (REAL)offs;
+    pri = amx_ftoc(fnum);
+    NEXT(cip);
+  op_float_round:
+    offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+    offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+    fnum = amx_ctof(offs);
+    if (!offs2)
+       fnum = floor(fnum + 0.5);
+	else  if (offs2 == 1)
+       fnum = floor(fnum);
+	else
+       fnum = ceil(fnum);
+    pri = (cell)fnum;
+    NEXT(cip);
+  op_float_cmp:
+    offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+    offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+    fnum = amx_ctof(offs);
+    fnum2 = amx_ctof(offs2);
+    if (fnum == fnum2)
+      pri = 0;
+	else if (fnum > fnum2)
+      pri = 1;
+	else
+      pri = -1;
+    NEXT(cip);
+op_break:
     if (amx->debug!=NULL) {
       /* store status */
       amx->frm=frm;
       amx->stk=stk;
       amx->hea=hea;
+      amx->pri=pri;
+      amx->alt=alt;
       amx->cip=(cell)((unsigned char*)cip-code);
       num=amx->debug(amx);
       if (num!=AMX_ERR_NONE) {
@@ -2654,7 +2671,8 @@ int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
     cell  parms[9];     /* registers and parameters for assembler AMX */
   #else
     OPCODE op;
-    cell offs;
+    cell offs, offs2;
+	REAL fnum, fnum2;
     int num;
   #endif
   assert(amx!=NULL);
@@ -3445,6 +3463,8 @@ int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
       amx->hea=hea;
       amx->frm=frm;
       amx->stk=stk;
+      amx->pri=pri;
+      amx->alt=alt;
       num=amx->callback(amx,pri,&pri,(cell *)(data+(int)stk));
       if (num!=AMX_ERR_NONE) {
         if (num==AMX_ERR_SLEEP) {
@@ -3464,6 +3484,8 @@ int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
       amx->hea=hea;
       amx->frm=frm;
       amx->stk=stk;
+      amx->pri=pri;
+      amx->alt=alt;
       num=amx->callback(amx,offs,&pri,(cell *)(data+(int)stk));
       if (num!=AMX_ERR_NONE) {
         if (num==AMX_ERR_SLEEP) {
@@ -3483,6 +3505,8 @@ int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
       amx->hea=hea;
       amx->frm=frm;
       amx->stk=stk;
+      amx->pri=pri;
+      amx->alt=alt;
       pri=((AMX_NATIVE)offs)(amx,(cell *)(data+(int)stk));
       if (amx->error!=AMX_ERR_NONE) {
         if (amx->error==AMX_ERR_SLEEP) {
@@ -3539,6 +3563,59 @@ int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
       break;
     case OP_NOP:
       break;
+    case OP_FLOAT_MUL:
+      offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+      offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+      fnum = amx_ctof(offs) * amx_ctof(offs2);
+      pri = amx_ftoc(fnum);
+      break;
+    case OP_FLOAT_ADD:
+      offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+      offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+      fnum = amx_ctof(offs) + amx_ctof(offs2);
+      pri = amx_ftoc(fnum);
+      break;
+    case OP_FLOAT_SUB:
+      offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+      offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+      fnum = amx_ctof(offs) - amx_ctof(offs2);
+      pri = amx_ftoc(fnum);
+      break;
+    case OP_FLOAT_DIV:
+      offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+      offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+      fnum = amx_ctof(offs) / amx_ctof(offs2);
+      pri = amx_ftoc(fnum);
+      break;
+    case OP_FLOAT_TO:
+      offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+      fnum = (float)offs;
+      pri = amx_ftoc(fnum);
+      break;
+    case OP_FLOAT_ROUND:
+      offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+      offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+      fnum = amx_ctof(offs);
+      if (!offs2)
+         fnum = (REAL)floor(fnum + 0.5);
+      else  if (offs2 == 1)
+         fnum = floor(fnum);
+	  else
+         fnum = ceil(fnum);
+      pri = (cell)fnum;
+      break;
+	case OP_FLOAT_CMP:
+      offs = *(cell *)(data + (int)stk + sizeof(cell)*1);
+      offs2 = *(cell *)(data + (int)stk + sizeof(cell)*2);
+      fnum = amx_ctof(offs);
+      fnum2 = amx_ctof(offs2);
+      if (fnum == fnum2)
+        pri = 0;
+	  else if (fnum > fnum2)
+        pri = 1;
+	  else
+        pri = -1;
+      break;
     case OP_BREAK:
       assert((amx->flags & AMX_FLAG_BROWSE)==0);
       if (amx->debug!=NULL) {
@@ -3546,6 +3623,8 @@ int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
         amx->frm=frm;
         amx->stk=stk;
         amx->hea=hea;
+        amx->pri=pri;
+        amx->alt=alt;
         amx->cip=(cell)((unsigned char*)cip-code);
         num=amx->debug(amx);
         if (num!=AMX_ERR_NONE) {
@@ -3616,7 +3695,7 @@ int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr)
   data=(amx->data!=NULL) ? amx->data : amx->base+(int)hdr->dat;
 
   assert(phys_addr!=NULL);
-  if (amx_addr>=amx->hea && amx_addr<amx->stk || amx_addr<0 || amx_addr>=amx->stp) {
+  if ((amx_addr>=amx->hea && amx_addr<amx->stk) || amx_addr<0 || amx_addr>=amx->stp) {
     *phys_addr=NULL;
     return AMX_ERR_MEMACCESS;
   } /* if */
@@ -4015,7 +4094,7 @@ int AMXAPI amx_GetLibraries(AMX *amx)
 	return numLibraries;
 }
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__)
 #define _snprintf snprintf
 #endif
 

amxmodx/amx.h

@@ -18,13 +18,13 @@
  *      misrepresented as being the original software.
  *  3.  This notice may not be removed or altered from any source distribution.
  *
- *  Version: $Id$
+ *  Version: $Id: amx.h 3006 2006-08-28 11:08:18Z dvander $
  */
 
 #if defined FREEBSD && !defined __FreeBSD__
   #define __FreeBSD__
 #endif
-#if defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
+#if defined LINUX || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__
   #include <sclinux.h>
 #endif
 
@@ -34,7 +34,7 @@
 #if defined HAVE_STDINT_H
   #include <stdint.h>
 #else
-  #if defined __LCC__ || defined __DMC__ || defined LINUX
+  #if defined __LCC__ || defined __DMC__ || defined LINUX || defined __APPLE__
     #if defined HAVE_INTTYPES_H
       #include <inttypes.h>
     #else
@@ -79,15 +79,6 @@
   #endif
 #endif
 
-#if HAVE_ALLOCA_H
-  #include <alloca.h>
-#endif
-#if defined __WIN32__ || defined _WIN32 || defined WIN32 /* || defined __MSDOS__ */
-  #if !defined alloca
-    #define alloca(n)   _alloca(n)
-  #endif
-#endif
-
 #if !defined arraysize
   #define arraysize(array)  (sizeof(array) / sizeof((array)[0]))
 #endif
@@ -166,6 +157,7 @@ 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);
+typedef int (AMXAPI *AMX_NATIVE_FILTER)(struct tagAMX *amx, int index);
 #if !defined _FAR
   #define _FAR
 #endif
@@ -174,6 +166,14 @@ typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
   #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" */
+
+	#if _MSC_VER >= 1400
+		// MSVC8 - Replace POSIX stricmp with ISO C++ conformant one as it is deprecated
+		#define stricmp _stricmp
+
+		// Need this because of some stupid bug
+		#pragma warning (disable : 4996)
+	#endif
 #endif
 
 /* Some compilers do not support the #pragma align, which should be fine. Some
@@ -190,7 +190,7 @@ typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
 #endif
 
 #if !defined AMX_NO_ALIGN
-  #if defined LINUX || defined __FreeBSD__
+  #if defined LINUX || defined __FreeBSD__ || defined __APPLE__
     #pragma pack(1)         /* structures must be packed (byte-aligned) */
   #elif defined MACOS && defined __MWERKS__
 	#pragma options align=mac68k
@@ -214,7 +214,7 @@ typedef struct tagAMX_NATIVE_INFO {
 
 typedef struct tagAMX_FUNCSTUB {
   ucell address         PACKED;
-  char name[sEXPMAX+1]  PACKED;
+  char name[sEXPMAX+1];
 } PACKED AMX_FUNCSTUB;
 
 typedef struct tagFUNCSTUBNT {
@@ -239,9 +239,10 @@ typedef struct tagAMX {
   cell stp              PACKED; /* top of the stack: relative to base + amxhdr->dat */
   int flags             PACKED; /* current status, see amx_Flags() */
   /* user data */
-  long usertags[AMX_USERNUM] PACKED;
+  void _FAR *usertags[AMX_USERNUM] PACKED;
   //okay userdata[3] in AMX Mod X is for the CPlugin * pointer
   //we're also gonna set userdata[2] to a special debug structure
+  //lastly, userdata[1] is for opcode_list from amx_BrowseRelocate
   void _FAR *userdata[AMX_USERNUM] PACKED;
   /* native functions can raise an error */
   int error             PACKED;
@@ -264,8 +265,8 @@ typedef struct tagAMX {
 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    file_version;         /* file format version */
-  char    amx_version   PACKED; /* required version of the AMX */
+  char    amx_version;          /* 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 */
@@ -300,6 +301,7 @@ enum {
   AMX_ERR_DIVIDE,       /* divide by zero */
   AMX_ERR_SLEEP,        /* go into sleepmode - code can be restarted */
   AMX_ERR_INVSTATE,     /* invalid state for this access */
+  AMX_ERR_INVNATIVE,	/* invalid native was used */
 
   AMX_ERR_MEMORY = 16,  /* out of memory */
   AMX_ERR_FORMAT,       /* invalid file format */
@@ -320,6 +322,7 @@ enum {
 #define AMX_FLAG_COMPACT  0x04  /* compact encoding */
 #define AMX_FLAG_BYTEOPC  0x08  /* opcode is a byte (not a cell) */
 #define AMX_FLAG_NOCHECKS 0x10  /* no array bounds checking; no STMT opcode */
+#define AMX_FLAG_OLDFILE  0x20	/* Old AMX Mod plugin */
 #define AMX_FLAG_PRENIT	 0x100	/* pre-initialized, do not check natives */
 #define AMX_FLAG_NTVREG 0x1000  /* all native functions are registered */
 #define AMX_FLAG_JITC   0x2000  /* abstract machine is JIT compiled */
@@ -335,23 +338,16 @@ enum {
   #define AMX_COMPACTMARGIN 64
 #endif
 
-struct amx_trace
+#define UD_FINDPLUGIN	3
-{
+#define UD_DEBUGGER		2
-	cell frm;
+#define UD_OPCODELIST	1
-	amx_trace *prev;
+#define	UD_HANDLER		0
-	amx_trace *next;
+#define	UT_NATIVE		3
-	bool used;
+#define UT_OPTIMIZER	2
-};
+#define UT_BROWSEHOOK	1
+#define UT_BINLOGS		0
 
-struct AMX_DBGINFO
+typedef void (*BROWSEHOOK)(AMX *amx, cell *oplist, cell *cip);
-{
-	void *pDebug;			//Pointer to debug data
-	int error;				//non-amx_Exec() error setting
-	amx_trace *pTrace;		//Pointer to stack trace 
-	amx_trace *pTraceFrm;
-	amx_trace *pTraceEnd;
-	cell frm;
-};
 
 /* for native functions that use floating point parameters, the following
  * two macros are convenient for casting a "cell" into a "float" type _without_
@@ -385,6 +381,7 @@ uint32_t * AMXAPI amx_Align32(uint32_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_CheckNatives(AMX *amx, AMX_NATIVE_FILTER nf);
 int AMXAPI amx_Cleanup(AMX *amx);
 int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data);
 int AMXAPI amx_Exec(AMX *amx, cell *retval, int index);
@@ -414,6 +411,8 @@ int AMXAPI amx_PushArray(AMX *amx, cell *amx_addr, cell **phys_addr, const cell
 int AMXAPI amx_PushString(AMX *amx, cell *amx_addr, cell **phys_addr, const char *string, int pack, int use_wchar);
 int AMXAPI amx_RaiseError(AMX *amx, int error);
 int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number);
+int AMXAPI amx_Reregister(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number);
+int AMXAPI amx_RegisterToAny(AMX *amx, AMX_NATIVE f);
 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);
@@ -443,7 +442,7 @@ int AMXAPI amx_GetStringOld(char *dest,const cell *source,int use_wchar);
   amx_Register((amx), amx_NativeInfo((name),(func)), 1);
 
 #if !defined AMX_NO_ALIGN
-  #if defined LINUX || defined __FreeBSD__
+  #if defined LINUX || defined __FreeBSD__ || defined __APPLE__
     #pragma pack()    /* reset default packing */
   #elif defined MACOS && defined __MWERKS__
     #pragma options align=reset
@@ -452,6 +451,15 @@ int AMXAPI amx_GetStringOld(char *dest,const cell *source,int use_wchar);
   #endif
 #endif
 
+#if defined BINLOG_ENABLED
+typedef struct tagBINLOG
+{
+	void	(*pfnLogNative)(AMX *amx, int native, int params);
+	void	(*pfnLogReturn)(AMX *amx, cell retval);
+	void	(*pfnLogParams)(AMX *amx, cell *params);
+} binlogfuncs_t;
+#endif
+
 #ifdef  __cplusplus
 }
 #endif

amxmodx/amxcore.cpp

@@ -18,7 +18,7 @@
  *      misrepresented as being the original software.
  *  3.  This notice may not be removed or altered from any source distribution.
  *
- *  Version: $Id$
+ *  Version: $Id: amxcore.cpp 1733 2005-07-25 06:03:43Z dvander $
  */
 #if defined _UNICODE || defined __UNICODE__ || defined UNICODE
 # if !defined UNICODE   /* for Windows */
@@ -180,7 +180,7 @@ static cell AMX_NATIVE_CALL setarg(AMX *amx, cell *params)
   /* adjust the address in "value" in case of an array access */
   value+=params[2]*sizeof(cell);
   /* verify the address */
-  if (value<0 || value>=amx->hea && value<amx->stk)
+  if (value<0 || (value>=amx->hea && value<amx->stk))
     return 0;
   /* set the value indirectly */
   * (cell *)(data+(int)value) = params[3];

amxmodx/amxdbg.cpp

@@ -20,7 +20,7 @@
  *      misrepresented as being the original software.
  *  3.  This notice may not be removed or altered from any source distribution.
  *
- *  Version: $Id$
+ *  Version: $Id: amxdbg.cpp 2345 2006-02-10 19:47:09Z faluco $
  */
 #include <assert.h>
 #include <stdio.h>
@@ -462,8 +462,8 @@ int AMXAPI dbg_GetVariable(AMX_DBG *amxdbg, const char *symname, ucell scopeaddr
       break;
     /* check the range, keep a pointer to the symbol with the smallest range */
     if (strcmp(amxdbg->symboltbl[index]->name, symname) == 0
-        && (codestart == 0 && codeend == 0
+        && ((codestart == 0 && codeend == 0)
-            || amxdbg->symboltbl[index]->codestart >= codestart && amxdbg->symboltbl[index]->codeend <= codeend))
+            || (amxdbg->symboltbl[index]->codestart >= codestart && amxdbg->symboltbl[index]->codeend <= codeend)))
     {
       *sym = amxdbg->symboltbl[index];
       codestart = amxdbg->symboltbl[index]->codestart;

amxmodx/amxdbg.h

@@ -21,7 +21,7 @@
  *      misrepresented as being the original software.
  *  3.  This notice may not be removed or altered from any source distribution.
  *
- *  Version: $Id$
+ *  Version: $Id: amxdbg.h 2977 2006-08-27 02:17:18Z damagedsoul $
  */
 
 #ifndef AMXDBG_H_INCLUDED
@@ -49,7 +49,7 @@ extern  "C" {
 #endif
 
 #if !defined AMX_NO_ALIGN
-  #if defined LINUX || defined __FreeBSD__
+  #if defined LINUX || defined __FreeBSD__ || defined __APPLE__
     #pragma pack(1)         /* structures must be packed (byte-aligned) */
   #elif defined MACOS && defined __MWERKS__
 	#pragma options align=mac68k
@@ -65,8 +65,8 @@ extern  "C" {
 typedef struct tagAMX_DBG_HDR {
   int32_t size          PACKED; /* size of the debug information chunk */
   uint16_t magic        PACKED; /* signature, must be 0xf1ef */
-  char    file_version  PACKED; /* file format version */
+  char    file_version;         /* file format version */
-  char    amx_version   PACKED; /* required version of the AMX */
+  char    amx_version;          /* required version of the AMX */
   int16_t flags         PACKED; /* currently unused */
   int16_t files         PACKED; /* number of entries in the "file" table */
   int16_t lines         PACKED; /* number of entries in the "line" table */
@@ -74,51 +74,51 @@ typedef struct tagAMX_DBG_HDR {
   int16_t tags          PACKED; /* number of entries in the "tag" table */
   int16_t automatons    PACKED; /* number of entries in the "automaton" table */
   int16_t states        PACKED; /* number of entries in the "state" table */
-} AMX_DBG_HDR           PACKED;
+} PACKED AMX_DBG_HDR;
 #define AMX_DBG_MAGIC   0xf1ef
 
 typedef struct tagAMX_DBG_FILE {
   ucell   address       PACKED; /* address in the code segment where generated code (for this file) starts */
-  const char name[1]    PACKED; /* ASCII string, zero-terminated */
+  const char name[1];           /* ASCII string, zero-terminated */
-} AMX_DBG_FILE          PACKED;
+} PACKED AMX_DBG_FILE;
 
 typedef struct tagAMX_DBG_LINE {
   ucell   address       PACKED; /* address in the code segment where generated code (for this line) starts */
   int32_t line          PACKED; /* line number */
-} AMX_DBG_LINE          PACKED;
+} PACKED AMX_DBG_LINE;
 
 typedef struct tagAMX_DBG_SYMBOL {
   ucell   address       PACKED; /* address in the data segment or relative to the frame */
   int16_t tag           PACKED; /* tag for the symbol */
   ucell   codestart     PACKED; /* address in the code segment from which this symbol is valid (in scope) */
   ucell   codeend       PACKED; /* address in the code segment until which this symbol is valid (in scope) */
-  char    ident         PACKED; /* kind of symbol (function/variable) */
+  char    ident;                /* kind of symbol (function/variable) */
-  char    vclass        PACKED; /* class of symbol (global/local) */
+  char    vclass;               /* class of symbol (global/local) */
   int16_t dim           PACKED; /* number of dimensions */
-  const char name[1]    PACKED; /* ASCII string, zero-terminated */
+  const char name[1];           /* ASCII string, zero-terminated */
-} AMX_DBG_SYMBOL        PACKED;
+} PACKED AMX_DBG_SYMBOL;
 
 typedef struct tagAMX_DBG_SYMDIM {
   int16_t tag           PACKED; /* tag for the array dimension */
   ucell   size          PACKED; /* size of the array dimension */
-} AMX_DBG_SYMDIM        PACKED;
+} PACKED AMX_DBG_SYMDIM;
 
 typedef struct tagAMX_DBG_TAG {
   int16_t tag           PACKED; /* tag id */
-  const char name[1]    PACKED; /* ASCII string, zero-terminated */
+  const char name[1];           /* ASCII string, zero-terminated */
-} AMX_DBG_TAG           PACKED;
+} PACKED AMX_DBG_TAG;
 
 typedef struct tagAMX_DBG_MACHINE {
   int16_t automaton     PACKED; /* automaton id */
   ucell address         PACKED; /* address of state variable */
-  const char name[1]    PACKED; /* ASCII string, zero-terminated */
+  const char name[1];           /* ASCII string, zero-terminated */
-} AMX_DBG_MACHINE       PACKED;
+} PACKED AMX_DBG_MACHINE;
 
 typedef struct tagAMX_DBG_STATE {
   int16_t state         PACKED; /* state id */
   int16_t automaton     PACKED; /* automaton id */
-  const char name[1]    PACKED; /* ASCII string, zero-terminated */
+  const char name[1];           /* ASCII string, zero-terminated */
-} AMX_DBG_STATE         PACKED;
+} PACKED AMX_DBG_STATE;
 
 typedef struct tagAMX_DBG {
   AMX_DBG_HDR     _FAR *hdr         PACKED; /* points to the AMX_DBG header */
@@ -128,7 +128,7 @@ typedef struct tagAMX_DBG {
   AMX_DBG_TAG     _FAR **tagtbl     PACKED;
   AMX_DBG_MACHINE _FAR **automatontbl PACKED;
   AMX_DBG_STATE   _FAR **statetbl   PACKED;
-} AMX_DBG                           PACKED;
+} PACKED AMX_DBG;
 
 #if !defined iVARIABLE
   #define iVARIABLE  1  /* cell that has an address and that can be fetched directly (lvalue) */
@@ -156,7 +156,7 @@ int AMXAPI dbg_GetArrayDim(AMX_DBG *amxdbg, const AMX_DBG_SYMBOL *sym, const AMX
 
 
 #if !defined AMX_NO_ALIGN
-  #if defined LINUX || defined __FreeBSD__
+  #if defined LINUX || defined __FreeBSD__ || defined __APPLE__
     #pragma pack()    /* reset default packing */
   #elif defined MACOS && defined __MWERKS__
     #pragma options align=reset

amxmodx/amxexecn.asm

@@ -56,6 +56,8 @@
 ;
 ;History (list of changes)
 ;-------------------------
+; 10 february 2006 by David Anderson
+;       Addition of float opcodes
 ; 17 february 2005  by Thiadmer Riemersms
 ;       Addition of the BREAK opcode, removal of the older debugging opcode table.
 ;  6 march 2004  by Thiadmer Riemersma
@@ -129,6 +131,28 @@
         jg      near err_stack
 %endmacro
 
+;Normal abort, saves pri/alt
+%macro	_ABORT 1
+		mov		ebp,amx
+        mov     [ebp+_pri], dword eax  ; store values in AMX structure (PRI, ALT)
+        mov     [ebp+_alt], dword edx  ; store values in AMX structure (PRI, ALT)
+		mov		[ebp+_error], dword %1
+		jmp		_return
+%endmacro
+
+;Checked abort, saves nothing and uses a conditional
+%macro	_CHKABORT 1
+		mov		ebp,amx
+		mov		[ebp+_error], %1
+		cmp		%1, AMX_ERR_NONE
+		jne		_return
+%endmacro
+
+;Fast abort, only aborts, nothing else
+%macro	_FASTABORT 0
+		jmp		_return
+%endmacro
+
 %macro  _CHKHEAP 0
         mov     ebp,amx
         mov     ebp,[ebp+_hlw]
@@ -1196,8 +1220,7 @@ OP_HALT:
         mov     eax,esi         ; EAX=CIP
         sub     eax,code
         mov     [ebp+_cip],eax
-        mov     eax,ebx         ; return the parameter of the HALT opcode
+        _ABORT	ebx
-        jmp     _return
 
 
 OP_BOUNDS:
@@ -1221,6 +1244,7 @@ OP_SYSREQ_PRI:
         mov     alt,edx         ; save ALT
 
         mov     [ebp+_stk],ecx  ; store values in AMX structure (STK, HEA, FRM)
+        ;we don't save regs since they're useless after this
         mov     ecx,hea
         mov     ebx,frm
         mov     [ebp+_hea],ecx
@@ -1251,8 +1275,7 @@ OP_SYSREQ_PRI:
         pop     edi             ; restore saved registers
         pop     esi
         pop     ebp
-        cmp     eax,AMX_ERR_NONE
+        _CHKABORT eax			; if result was invalid, leave
-        jne     near _return    ; return error code, if any
 
         mov     eax,pri         ; get retval into eax (PRI)
         mov     edx,alt         ; restore ALT
@@ -1293,8 +1316,8 @@ OP_SYSREQ_D:                    ; (TR)
         pop     edi             ; restore saved registers
         pop     esi
         pop     ebp
-        cmp     DWORD [ebp+_error],AMX_ERR_NONE
+        mov		eax,[ebp+_error]
-        jne     near _return    ; return error code, if any
+        _CHKABORT eax
 
         ; function result is in eax (PRI)
         mov     edx,alt         ; restore ALT
@@ -1385,6 +1408,108 @@ OP_NOP:
         add     esi,4
         GO_ON
         
+OP_FLOAT_MUL:
+		add   esi,4
+		fld   dword [edi+ecx+4]
+		fmul	dword [edi+ecx+8]
+		sub   esp,4
+		fstp	dword [esp]
+		pop   eax
+		GO_ON
+		
+OP_FLOAT_DIV:
+		add   esi,4
+		fld   dword [edi+ecx+4]
+		fdiv	dword [edi+ecx+8]
+		sub   esp,4
+		fstp	dword [esp]
+		pop   eax
+		GO_ON
+		
+OP_FLOAT_ADD:
+		add   esi,4
+		fld   dword [edi+ecx+4]
+		fadd	dword [edi+ecx+8]
+		sub   esp,4
+		fstp	dword [esp]
+		pop   eax
+		GO_ON
+		
+OP_FLOAT_SUB:
+		add   esi,4
+		fld   dword [edi+ecx+4]
+		fsub	dword [edi+ecx+8]
+		sub   esp, 4
+		fstp	dword [esp]
+		pop   eax
+		GO_ON
+		
+OP_FLOAT_TO:
+		add     esi,4
+		fild    dword [edi+ecx+4]
+		sub     esp,4
+		fstp    dword [esp]
+		pop     eax
+		GO_ON
+		
+OP_FLOAT_ROUND:
+		add	    esi,4
+		;get the float control word
+		push    0
+		mov     ebp,esp
+		fstcw   [ebp]
+		mov		eax,[ebp]
+		push    eax
+		;clear the top bits
+		xor     ah,ah
+		;get the control method
+		push    edx
+		mov     edx,[edi+ecx+8]
+		and     edx,3	;sanity check
+		shl     edx,2	;shift it to right position
+		;set the bits
+		or      ah,dl	;set bits 15,14 of FCW to rounding method
+		or      ah,3	;set precision to 64bit
+		mov     [ebp], eax
+		fldcw   [ebp]
+		;calculate
+		sub     esp,4
+		fld     dword [edi+ecx+4]
+		test    edx,edx
+		jz      .correct
+		jmp     .skip_correct
+	.correct:
+		fadd    st0
+		fadd    dword [g_round_nearest]
+		fistp   dword [esp]
+		pop     eax
+		sar     eax,1
+		jmp     .done
+	.skip_correct:
+		frndint
+		fistp   dword [esp]
+		pop     eax
+	.done:
+		pop     edx
+		;restore bits
+		pop     ebp
+		mov     [esp], ebp
+		fldcw   [esp]
+		pop      ebp
+		GO_ON
+		
+OP_FLOAT_CMP:
+		add     esi, 4
+		fld     dword [edi+ecx+8]
+		fld     dword [edi+ecx+4]
+		fucompp
+		fnstsw  ax
+		fwait
+		sahf
+		cmovz   eax, [g_flags+4]
+		cmova   eax, [g_flags+8]
+		cmovb   eax, [g_flags+0]
+		GO_ON
 		
 OP_BREAK:
         mov     ebp,amx         ; get amx into ebp
@@ -1416,7 +1541,7 @@ OP_BREAK:
         mov     [ebp+_error],eax   ; save EAX (error code) before restoring all regs
         _RESTOREREGS               ; abort run, but restore stack first
         mov     eax,[ebp+_error]   ; get error code in EAX back again
-        jmp     _return         ; return error code
+        _FASTABORT
     break_noabort:
         _RESTOREREGS
         mov     eax,[ebp+_pri]  ; restore PRI and ALT
@@ -1425,43 +1550,34 @@ OP_BREAK:
 
 
 OP_INVALID:
-        mov     eax,AMX_ERR_INVINSTR
+        _ABORT	AMX_ERR_INVINSTR
-        jmp     _return
 
 err_call:
-        mov     eax,AMX_ERR_CALLBACK
+        _ABORT	AMX_ERR_CALLBACK
-        jmp     _return
 
 err_stack:
-        mov     eax,AMX_ERR_STACKERR
+        _ABORT	AMX_ERR_STACKERR
-        jmp     _return
 
 err_stacklow:
-        mov     eax,AMX_ERR_STACKLOW
+        _ABORT	AMX_ERR_STACKLOW
-        jmp     _return
 
 err_memaccess:
-        mov     eax,AMX_ERR_MEMACCESS
+        _ABORT	AMX_ERR_MEMACCESS
-        jmp     _return
 
 err_bounds:
-        mov     eax,AMX_ERR_BOUNDS
+        _ABORT	AMX_ERR_BOUNDS
-        jmp     _return
 
 err_heaplow:
-        mov     eax,AMX_ERR_HEAPLOW
+        _ABORT	AMX_ERR_HEAPLOW
-        jmp     _return
 
 err_divide:
-        mov     eax,AMX_ERR_DIVIDE
+        _ABORT	AMX_ERR_DIVIDE
-        jmp     _return
-
 
 _return:
         ; save a few parameters, mostly for the "sleep"function
         mov     ebp,amx         ; get amx into ebp
-        mov     [ebp+_pri],eax  ; store values in AMX structure (PRI, ALT)
+        mov		[ebp+_cip],esi	; get corrected cip for amxmodx
-        mov     [ebp+_alt],edx  ; store values in AMX structure (PRI, ALT)
+        mov		eax,[ebp+_error]; get error code
 
         pop     esi             ; remove FRM from stack
 
@@ -1489,6 +1605,14 @@ Start_DATA
 
 lodb_and DD     0ffh, 0ffffh, 0, 0ffffffffh
 
+g_round_nearest	DD	0.5
+
+		GLOBAL g_flags
+g_flags:
+		DD		-1
+		DD		0
+		DD		1
+
         GLOBAL  amx_opcodelist
         GLOBAL  _amx_opcodelist
 amx_opcodelist:
@@ -1630,4 +1754,10 @@ _amx_opcodelist DD OP_INVALID
         DD      OP_SYSREQ_D
         DD      OP_SYMTAG
         DD      OP_BREAK
-
+        DD      OP_FLOAT_MUL
+        DD      OP_FLOAT_DIV
+        DD      OP_FLOAT_ADD
+        DD      OP_FLOAT_SUB
+        DD      OP_FLOAT_TO
+        DD      OP_FLOAT_ROUND
+        DD      OP_FLOAT_CMP

amxmodx/amxjitsn.asm

@@ -303,10 +303,6 @@
     %endif
 %endmacro
 
-
-section .text
-
-
 global  asm_runJIT, _asm_runJIT
 global  amx_exec_jit, _amx_exec_jit
 global  getMaxCodeSize, _getMaxCodeSize
@@ -432,13 +428,6 @@ reloc_done:
         pop     ebp
         ret
 
-; GWMV:
-; The code below modifies itself to store the arguments to the Pawn opcodes
-; in the compiled code. This is fine, but the .text section in an ELF executable
-; is usually marked read-only, that's why this code is in the .data section.
-
-section .data exec
-
 OP_LOAD_PRI:
 ;nop;
         putval  j_load_pri+2
@@ -1046,7 +1035,7 @@ OP_CALL:
         j_call:
         ;call   12345678h ; tasm chokes on this out of a sudden
         _PUSH	0
-        j_call_e8
+        j_call_e8:
         db      0e8h, 0, 0, 0, 0
 	CHECKCODESIZE j_call
 
@@ -1876,7 +1865,7 @@ OP_BREAK:
         jae     code_gen_done
         jmp     DWORD [ebx]             ; go on with the next opcode
 %else
-        GO_ON   j_break, OP_INVALID
+        GO_ON   j_break, OP_FLOAT_MUL
     j_break:
         mov     ebp,amx
         cmp     DWORD [ebp+_debug], 0
@@ -1885,6 +1874,116 @@ OP_BREAK:
     CHECKCODESIZE j_break
 %endif
 
+OP_FLOAT_MUL:
+		GO_ON	j_float_mul, OP_FLOAT_DIV
+	j_float_mul:
+		fld     dword [esi+4]
+		fmul    dword [esi+8]
+		sub     esp, 4
+		fstp    dword [esp]
+		pop     eax
+	CHECKCODESIZE j_float_mul
+	
+OP_FLOAT_DIV:
+		GO_ON	j_float_div, OP_FLOAT_ADD
+	j_float_div:
+		fld     dword [esi+4]
+		fdiv    dword [esi+8]
+		sub     esp, 4
+		fstp    dword [esp]
+		pop     eax
+	CHECKCODESIZE j_float_div
+	
+OP_FLOAT_ADD:
+		GO_ON	j_float_add, OP_FLOAT_SUB
+	j_float_add:
+		fld     dword [esi+4]
+		fadd    dword [esi+8]
+		sub     esp, 4
+		fstp    dword [esp]
+		pop     eax
+	CHECKCODESIZE j_float_add
+	
+OP_FLOAT_SUB:
+		GO_ON	j_float_sub, OP_FLOAT_TO
+	j_float_sub:
+		fld     dword [esi+4]
+		fsub    dword [esi+8]
+		sub     esp, 4
+		fstp	  dword [esp]
+		pop     eax
+	CHECKCODESIZE j_float_sub
+	
+OP_FLOAT_TO:
+		GO_ON   j_float_to, OP_FLOAT_ROUND
+	j_float_to:
+		fild    dword [esi+4]
+		sub     esp, 4
+		fstp    dword [esp]
+		pop     eax
+	CHECKCODESIZE j_float_to
+	
+OP_FLOAT_ROUND:
+		GO_ON   j_float_round, OP_FLOAT_CMP
+	j_float_round:
+		;get the float control word
+		push    0
+		mov     ebp,esp
+		fstcw   [ebp]
+		mov     eax,[ebp]
+		push    eax
+		;clear the top bits
+		xor     ah,ah
+		;get the control method
+		push    edx
+		mov     edx,[esi+8]
+		and     edx,3	;sanity check
+		shl     edx,2	;shift it to right position
+		;set the bits
+		or      ah,dl	;set bits 15,14 of FCW to rounding method
+		or      ah,3	;set precision to 64bit
+		mov     [ebp], eax
+		fldcw   [ebp]
+		;calculate
+		sub     esp,4
+		fld     dword [esi+4]
+		test    edx,edx
+		jz      .correct
+		jmp     .skip_correct
+	.correct:
+		fadd    st0
+		fadd    dword [g_round_nearest]
+		fistp   dword [esp]
+		pop     eax
+		sar     eax,1
+		jmp     .done
+	.skip_correct:
+		frndint
+		fistp   dword [esp]
+		pop     eax
+	.done:
+		pop     edx
+		;restore bits
+		pop     ebp
+		mov     [esp], ebp
+		fldcw   [esp]
+		pop      ebp
+	CHECKCODESIZE j_float_round
+	
+OP_FLOAT_CMP:
+		GO_ON	j_float_cmp, OP_INVALID
+	j_float_cmp:
+		fld     dword [esi+8]
+		fld     dword [esi+4]
+		fucompp
+		fnstsw  ax
+		fwait
+		sahf
+		cmovz   eax, [g_flagsjit+4]
+		cmova   eax, [g_flagsjit+8]
+		cmovb   eax, [g_flagsjit+0]
+	CHECKCODESIZE j_float_cmp
+
 OP_INVALID:                     ; break from the compiler with an error code
         mov     eax,AMX_ERR_INVINSTR
         pop     esi
@@ -2006,7 +2105,9 @@ err_heaplow:
 _CHKMARGIN_HEAP:
         cmp     esi,stp
         jg      err_stacklow
-        cmp     dword hea,0
+        mov     ebp,amx
+        mov     ebp,[ebp+_hlw]
+        cmp     dword hea,ebp
         jl      err_heaplow
         ret
 
@@ -2137,8 +2238,8 @@ err_divide:
         jmp     _return_popstack
 
 JIT_OP_SYSREQ:
-		push	ecx
+        push	ecx
-		push	esi
+        push	esi
         mov     ebp,amx         ; get amx into EBP
 
         sub     esi,edi         ; correct STK
@@ -2172,8 +2273,8 @@ JIT_OP_SYSREQ:
 
 
 JIT_OP_SYSREQ_D:                ; (TR)
-		push	ecx
+        push	ecx
-		push	esi
+        push	esi
         mov     ebp,amx         ; get amx into EBP
 
         sub     esi,edi         ; correct STK
@@ -2204,8 +2305,8 @@ JIT_OP_SYSREQ_D:                ; (TR)
 
 JIT_OP_BREAK:
 %ifdef DEBUGSUPPORT
-		push	ecx
+        push	ecx
-		push	esi
+        push	esi
         mov     ebp,amx         ; get amx into EBP
 
         sub     esi,edi         ; correct STK
@@ -2313,6 +2414,16 @@ jit_switch      DD      JIT_OP_SWITCH
 ; The table for the browser/relocator function.
 ;
 
+global g_flagsjit
+g_flagsjit:
+		DD		-1
+		DD		0
+		DD		1
+		
+global g_round_nearest
+g_round_nearest:
+		DD		0.5
+
 global amx_opcodelist_jit, _amx_opcodelist_jit
 
 amx_opcodelist_jit:
@@ -2455,5 +2566,12 @@ _amx_opcodelist_jit:
         DD      OP_SYSREQ_D     ; TR
         DD      OP_SYMTAG       ; TR
         DD      OP_BREAK        ; TR
+        DD      OP_FLOAT_MUL	; DA
+        DD      OP_FLOAT_DIV	; DA
+        DD      OP_FLOAT_ADD	; DA
+        DD      OP_FLOAT_SUB	; DA
+        DD      OP_FLOAT_TO		; DA
+        DD      OP_FLOAT_ROUND	; DA
+        DD      OP_FLOAT_CMP	; DA
 
-END
+END:

amxmodx/amxmod_compat.cpp

@@ -0,0 +1,117 @@
+#include "amxmodx.h"
+#include "amxmod_compat.h"
+#include "format.h"
+
+bool GetTranslation(amxtrans_t trans, int &key, int &dest, int &lang)
+{
+	key = (trans & BCOMPAT_TRANSLATE_KEYMASK);
+	dest = (trans >> BCOMPAT_TRANSLATE_DESTRSH) & BCOMPAT_TRANSLATE_DESTMASK;
+	lang = (trans >> BCOMPAT_TRANSLATE_LANGRSH) & BCOMPAT_TRANSLATE_LANGMASK;
+
+	if (dest == 0x3F)
+	{
+		dest = -1;
+	} 
+
+	if (lang == 0x1F)
+	{
+		lang = -1;
+	}
+
+	return true;
+}
+
+bool translate_bcompat(AMX *amx, cell *source, const char **_key, const char **_def)
+{
+	amxtrans_t trans = static_cast<amxtrans_t>(*source);
+	int key, _dest, lang;
+	if (!GetTranslation(trans, key, _dest, lang))
+	{
+		return false;
+	}
+
+	cell amx_addr, *phys_addr;
+	if (amx_Allot(amx, 3, &amx_addr, &phys_addr) != AMX_ERR_NONE)
+	{
+		return false;
+	}
+
+	if (_dest == -1)
+	{
+		*phys_addr = LANG_PLAYER;
+	} else if (_dest == 0) {
+		*phys_addr = LANG_SERVER;
+	} else if (lang >= 0 && lang < g_langMngr.GetLangsNum()) {
+		const char *name = g_langMngr.GetLangName(lang);
+		phys_addr[0] = static_cast<cell>(name[0]);
+		phys_addr[1] = static_cast<cell>(name[1]);
+		phys_addr[2] = static_cast<cell>('\0');
+	} else {
+		*phys_addr = LANG_SERVER;
+	}
+
+	//not optimized but it works, eh
+	//if someone cares they can make a translate() wrapper that takes the key # in directly
+	const char *r_key = g_langMngr.GetKey(key);
+	const char *def = translate(amx, amx_addr, r_key);
+	if (!def)
+	{
+		def = r_key;
+	}
+	amx_Release(amx, amx_addr);
+
+	*_key = g_langMngr.GetKey(key);
+	*_def = def;
+
+	return true;
+}
+
+static cell AMX_NATIVE_CALL amx_translate(AMX *amx, cell *params)
+{
+	int len;
+	char *key = get_amxstring(amx, params[1], 0, len);
+
+	amxtrans_t trans;
+
+	int suki = g_langMngr.GetKeyEntry(key);
+	//Some AMX Mod plugins do not register everything they need.  Prevent a crash.
+	if (suki == -1)
+	{
+		suki = g_langMngr.AddKeyEntry(key);
+	}
+
+	if (suki > BCOMPAT_TRANSLATE_KEYMASK)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not enough translation space, aborting!");
+		return 0;
+	}
+
+	trans = suki & BCOMPAT_TRANSLATE_KEYMASK;
+	int dest = static_cast<int>(params[2]);
+	int lang = static_cast<int>(params[3]);
+	if (dest == -1)
+	{
+		trans |= (0x3F << BCOMPAT_TRANSLATE_DESTRSH);
+	} else {
+		trans |= (dest & BCOMPAT_TRANSLATE_DESTMASK) << BCOMPAT_TRANSLATE_DESTRSH;
+	}
+
+	if (lang == -1)
+	{
+		trans |= (0x1F << BCOMPAT_TRANSLATE_LANGRSH);
+	} else {
+		trans |= (lang & BCOMPAT_TRANSLATE_LANGMASK) << BCOMPAT_TRANSLATE_LANGRSH;
+	}
+
+	trans |= BCOMPAT_TRANSLATE_BITS;
+
+	return static_cast<cell>(trans);
+}
+
+AMX_NATIVE_INFO g_BcompatNatives[] = 
+{
+	{"translate",				amx_translate},
+
+	{NULL,						NULL},
+};
+

amxmodx/amxmod_compat.h

@@ -0,0 +1,28 @@
+#ifndef _INCLUDE_AMXMOD_CORE_COMPAT_H
+#define _INCLUDE_AMXMOD_CORE_COMPAT_H
+
+/**
+ * New format for translation:
+ * Note that we only support:
+ *  4k keys
+ *  32 languages
+ * 0000 0000 0000 0000 0000 0000 0000 0000
+ *                          |  key id    |
+ *                  |     | <- dest id
+ *           |     | <- lang id
+ */
+
+#define BCOMPAT_TRANSLATE_BITS		0xFF000000
+#define BCOMPAT_TRANSLATE_KEYMASK	0xFFF
+#define BCOMPAT_TRANSLATE_DESTMASK	0x3F
+#define BCOMPAT_TRANSLATE_DESTRSH	12
+#define BCOMPAT_TRANSLATE_LANGMASK  0x1F
+#define BCOMPAT_TRANSLATE_LANGRSH	18
+
+typedef unsigned int amxtrans_t;
+
+bool GetTranslation(amxtrans_t trans, int &key, int &dest, int &lang);
+
+extern AMX_NATIVE_INFO g_BcompatNatives[];
+
+#endif //_INCLUDE_AMXMOD_CORE_COMPAT_H

amxmodx/amxmodx.h

@@ -32,20 +32,23 @@
 #ifndef AMXMODX_H
 #define AMXMODX_H
 
-
+#if defined(__linux__) || defined(__APPLE__)
-#ifdef __linux__
 #include <unistd.h>
 #include <stdlib.h>
 #include "sclinux.h"
 #endif
-#include <ctype.h> //tolower, etc
+#include <ctype.h>				//tolower, etc
 #include "string.h"
 #include <extdll.h>
 #include <meta_api.h>
-#include "mm_pextensions.h"			// metamod-p extensions
 
-#ifdef MEMORY_TEST
+#ifdef _MSC_VER
-#include "mmgr/mmgr.h"
+	// MSVC8 - replace POSIX functions with ISO C++ conformant ones as they are deprecated
+	#if _MSC_VER >= 1400
+		#define unlink _unlink	
+		#define mkdir _mkdir
+		#define strdup _strdup
+	#endif
 #endif
 
 #include "md5.h"
@@ -62,39 +65,61 @@
 #include "CLogEvent.h"
 #include "CForward.h"
 #include "CCmd.h"
-#include "CMenu.h"
 #include "CEvent.h"
 #include "CLang.h"
 #include "fakemeta.h"
 #include "amxxlog.h"
 
 #define AMXXLOG_Log g_log.Log
-#define AMX_VERSION     "1.55"
+#define AMXXLOG_Error g_log.LogError
 
-extern AMX_NATIVE_INFO  core_Natives[];
+extern AMX_NATIVE_INFO core_Natives[];
-extern AMX_NATIVE_INFO  time_Natives[];
+extern AMX_NATIVE_INFO time_Natives[];
-extern AMX_NATIVE_INFO  power_Natives[];
+extern AMX_NATIVE_INFO power_Natives[];
-extern  AMX_NATIVE_INFO amxmod_Natives[];
+extern AMX_NATIVE_INFO amxmodx_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[];
-extern  AMX_NATIVE_INFO string_Natives[];
+extern AMX_NATIVE_INFO string_Natives[];
-extern  AMX_NATIVE_INFO vault_Natives[];
+extern AMX_NATIVE_INFO vault_Natives[];
+extern AMX_NATIVE_INFO msg_Natives[];
+extern AMX_NATIVE_INFO vector_Natives[];
+extern AMX_NATIVE_INFO g_SortNatives[];
+extern AMX_NATIVE_INFO g_DataStructNatives[];
 
-
+#if defined(_WIN32)
-#ifndef __linux__
 #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)
 #else
 #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)
 #endif
 
-#ifndef __linux__
+#if defined __GNUC__
-typedef HINSTANCE DLHANDLE;
+	#include <stdint.h>
+	typedef intptr_t _INT_PTR;
 #else
-typedef void* DLHANDLE;
+	#if defined AMD64
+		typedef __int64 _INT_PTR;
+	#else
+		typedef __int32 _INT_PTR;
+	#endif
+#endif
+
+#if defined(_WIN32)
+	typedef HINSTANCE DLHANDLE;
+#else
+	typedef void* DLHANDLE;
+	#define INFINITE 0xFFFFFFFF
+#endif
+
+#if defined(_WIN32)
+	#define PATH_SEP_CHAR		'\\'
+	#define ALT_SEP_CHAR		'/'
+#else
+	#define PATH_SEP_CHAR		'/'
+	#define ALT_SEP_CHAR		'\\'
 #endif
 
 #ifndef GETPLAYERAUTHID
@@ -110,36 +135,37 @@ typedef void* DLHANDLE;
 
 char* UTIL_SplitHudMessage(register const char *src);
 int UTIL_ReadFlags(const char* c);
-void UTIL_ClientPrint( edict_t *pEntity, int msg_dest,  char *msg );
+
+void UTIL_ClientPrint(edict_t *pEntity, int msg_dest, char *msg);
 void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1 = NULL, const char *arg2 = NULL);
-void UTIL_GetFlags(char* flags,int flag);
+void UTIL_GetFlags(char* flags, int flag);
-void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pMessage);
+void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, const char *pMessage);
 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);
+
 char *UTIL_VarArgs(const char *fmt, ...);
 
 
 #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))])
 #define GET_PLAYER_POINTER_I(i) (&g_players[i])
 
-struct WeaponsVault {
+struct WeaponsVault
-  String fullName;
+{
-  short int iId;
+	String fullName;
-  short int ammoSlot;
+	short int iId;
+	short int ammoSlot;
 };
 
-struct fakecmd_t {
+struct fakecmd_t
-  char args[256];
+{
-  const char *argv[3];
+	char args[256];
-  //char argv[3][128];
+	const char *argv[3];
-  int argc;
+	int argc;
-  bool fake;
+	bool fake;
 };
 
-extern bool g_IsNewMM;
-extern pextension_funcs_t *gpMetaPExtFuncs;
 extern CLog g_log;
 extern CPluginMngr g_plugins;
 extern CTaskMngr g_tasksMngr;
@@ -150,18 +176,18 @@ extern CList<CCVar> g_cvars;
 extern CList<ForceObject> g_forcemodels;
 extern CList<ForceObject> g_forcesounds;
 extern CList<ForceObject> g_forcegeneric;
-extern CList<CModule,const char *> g_modules;
+extern CList<CModule, const char *> g_modules;
+extern CList<CScript, AMX*> g_loadedscripts;
 extern CList<CPlayer*> g_auth;
 extern EventsMngr g_events;
 extern Grenades g_grenades;
 extern LogEventsMngr g_logevents;
-extern MenuMngr g_menucmds;
 extern CLangMngr g_langMngr;
 extern String g_log_dir;
 extern String g_mod_name;
 extern TeamIds g_teamsIds;
 extern Vault g_vault;
-extern CForwardMngr  g_forwards;
+extern CForwardMngr g_forwards;
 extern WeaponsVault g_weaponsData[MAX_WEAPONS];
 extern XVars g_xvars;
 extern bool g_bmod_cstrike;
@@ -176,6 +202,7 @@ extern float g_game_restarting;
 extern float g_game_timeleft;
 extern float g_task_time;
 extern float g_auth_time;
+extern bool g_NewDLL_Available;
 extern hudtextparms_t g_hudset;
 //extern int g_edict_point;
 extern int g_players_num;
@@ -224,14 +251,15 @@ void Client_DeathMsg(void*);
 void amx_command();
 void plugin_srvcmd();
 
-const char* stristr(const char* a,const char* b);
+const char* stristr(const char* a, const char* b);
 char *strptime(const char *buf, const char *fmt, struct tm *tm, short addthem);
 
 int loadModules(const char* filename, PLUG_LOADTIME now);
 void detachModules();
 void detachReloadModules();
+
 #ifdef FAKEMETA
-void attachModules();
+	void attachModules();
 #endif
 
 // Count modules
@@ -244,41 +272,47 @@ enum CountModulesMode
 
 int countModules(CountModulesMode mode);
 void modules_callPluginsLoaded();
+void modules_callPluginsUnloaded();
+void modules_callPluginsUnloading();
 
-cell* get_amxaddr(AMX *amx,cell amx_addr);
+cell* get_amxaddr(AMX *amx, cell amx_addr);
-char* build_pathname(char *fmt, ... );
+char* build_pathname(const char *fmt, ...);
-char* build_pathname_r(char *buffer, size_t maxlen, char *fmt, ...);
+char* build_pathname_r(char *buffer, size_t maxlen, const char *fmt, ...);
-char* format_amxstring(AMX *amx, cell *params, int parm,int& len);
+char* format_amxstring(AMX *amx, cell *params, int parm, int& len);
-AMX* get_amxscript(int, void**,const char**);
+AMX* get_amxscript(int, void**, const char**);
 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);
+extern "C" size_t get_amxstring_r(AMX *amx, cell amx_addr, char *destination, int maxlen);
+
 int amxstring_len(cell* cstr);
 int load_amxscript(AMX* amx, void** program, const char* path, char error[64], int debug);
-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);
-void copy_amxmemory(cell* dest,cell* src,int len);
+
+void copy_amxmemory(cell* dest, cell* src, int len);
 void get_modname(char*);
-void print_srvconsole( char *fmt, ... );
+void print_srvconsole(const char *fmt, ...);
-void report_error( int code, char* fmt, ... );
+void report_error(int code, const char* fmt, ...);
 void* alloc_amxmemory(void**, int size);
 void free_amxmemory(void **ptr);
 // get_localinfo
-const char* get_localinfo( const char* name , const char* def );
+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, ...);
+extern "C" void LogError(AMX *amx, int err, const char *fmt, ...);
 
 enum ModuleCallReason
 {
-	ModuleCall_NotCalled = 0,			// nothing
+	ModuleCall_NotCalled = 0,					// nothing
-	ModuleCall_Query,					// in Query func
+	ModuleCall_Query,							// in Query func
-	ModuleCall_Attach,					// in Attach func
+	ModuleCall_Attach,							// in Attach func
-	ModuleCall_Detach,					// in Detach func
+	ModuleCall_Detach,							// in Detach func
 };
 
 extern ModuleCallReason g_ModuleCallReason;		// modules.cpp
 extern CModule *g_CurrentlyCalledModule;		// modules.cpp
 extern const char *g_LastRequestedFunc;			// modules.cpp
+
 void Module_CacheFunctions();
 void Module_UncacheFunctions();
 
@@ -298,11 +332,12 @@ extern int FF_PluginLog;
 extern int FF_PluginEnd;
 extern int FF_InconsistentFile;
 extern int FF_ClientAuthorized;
+extern int FF_ChangeLevel;
 extern bool g_coloredmenus;
 
-#ifdef FAKEMETA
+typedef void (*AUTHORIZEFUNC)(int player, const char *authstring);
-extern CFakeMeta g_FakeMeta;
+
-#endif
+#define MM_CVAR2_VERS	13
 
 struct func_s
 {
@@ -310,5 +345,14 @@ struct func_s
 	const char *desc;
 };
 
-#endif // AMXMODX_H
+enum AdminProperty
+{
+	Admin_Auth = 0,
+	Admin_Password,
+	Admin_Access,
+	Admin_Flags
+};
 
+extern enginefuncs_t *g_pEngTable;
+
+#endif // AMXMODX_H

amxmodx/amxtime.cpp

@@ -3,7 +3,7 @@
  *  Copyright (c) ITB CompuPhase, 2001-2002
  *  This file may be freely used. No warranties of any kind.
  *
- *  Version: $Id$
+ *  Version: $Id: amxtime.cpp 2511 2006-04-06 12:56:45Z damagedsoul $
  */
 #include <time.h>
 #include <assert.h>
@@ -54,7 +54,7 @@ static cell AMX_NATIVE_CALL _time(AMX *amx, cell *params)
   /* the time() function returns the number of seconds since January 1 1970
    * in Universal Coordinated Time (the successor to Greenwich Mean Time)
    */
-  return sec1970;
+  return (cell)sec1970;
 }
 
 #if defined __BORLANDC__ || defined __WATCOMC__

amxmodx/amxxfile.cpp

@@ -35,24 +35,25 @@
 /**********************
  ****** AMXXFILE ******
  **********************/
+
 #if defined __GNUC__
-  #define PACKED        __attribute__((packed))
+	#define PACKED		__attribute__((packed))
 #else
-  #define PACKED
+	#define PACKED
 #endif
 
-#if defined __linux__
+#if defined(__linux__) || defined(__APPLE__)
-  #pragma pack(1)         /* structures must be packed (byte-aligned) */
+	#pragma pack(1)				/* structures must be packed (byte-aligned) */
 #else
-  #pragma pack(1)         /* structures must be packed (byte-aligned) */
+	#pragma pack(1)				/* structures must be packed (byte-aligned) */
-  #if defined __TURBOC__
+	#if defined __TURBOC__
-    #pragma option -a-    /* "pack" pragma for older Borland compilers */
+		#pragma option -a-		/* "pack" pragma for older Borland compilers */
-  #endif
+	#endif
 #endif
 
 struct TableEntry
 {
-	mint8_t cellSize PACKED;
+	mint8_t cellSize;
 	mint32_t origSize PACKED;			// contains AMX_HEADER->stp
 	mint32_t offset PACKED;
 };
@@ -73,6 +74,7 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 {
 	m_Bh.plugins = NULL;
 	m_AmxxFile = false;
+	
 	if (!filename)
 	{
 		m_Status = Err_InvalidParam;
@@ -81,8 +83,8 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 
 	m_Status = Err_None;
 	m_CellSize = cellsize;
-
 	m_pFile = fopen(filename, "rb");
+	
 	if (!m_pFile)
 	{
 		m_Status = Err_FileOpen;
@@ -93,56 +95,71 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 	DATAREAD(&magic, sizeof(magic), 1);
 
 	m_OldFile = false;
-	if ( magic == 0x524C4542 ) {
+	
+	if (magic == 0x524C4542)
+	{
 		//we have an invalid, old, RLEB file
 		m_Status = Err_OldFile;
 		fclose(m_pFile);
 		m_pFile = NULL;
+		
 		return;
-	} else if ( magic == MAGIC_HEADER2 ) {
+	}
+	else if (magic == MAGIC_HEADER2)
+	{
 		DATAREAD(&m_Bh.version, sizeof(int16_t), 1);
-		if (m_Bh.version != MAGIC_VERSION)
+		
+		if (m_Bh.version > MAGIC_VERSION)
 		{
 			m_Status = Err_OldFile;
 			fclose(m_pFile);
 			m_pFile = NULL;
+			
 			return;
 		}
+		
 		m_AmxxFile = true;
 		DATAREAD(&m_Bh.numPlugins, sizeof(mint8_t), 1);
 		m_Bh.plugins = new PluginEntry[m_Bh.numPlugins];
 		PluginEntry *pe;
 		m_SectionHdrOffset = 0;
 		m_Entry = -1;
-		for (mint8_t i=0; i<m_Bh.numPlugins; i++)
+		
+		for (mint8_t i = 0; i < m_Bh.numPlugins; i++)
 		{
-			pe = &(m_Bh.plugins[i]);
+			pe = &(m_Bh.plugins[(unsigned)i]);
 			DATAREAD(&pe->cellsize, sizeof(mint8_t), 1);
 			DATAREAD(&pe->disksize, sizeof(int32_t), 1);
 			DATAREAD(&pe->imagesize, sizeof(int32_t), 1);
 			DATAREAD(&pe->memsize, sizeof(int32_t), 1);
 			DATAREAD(&pe->offs, sizeof(int32_t), 1);
 		}
-		for (mint8_t i=0; i<m_Bh.numPlugins; i++)
+		
+		for (mint8_t i = 0; i < m_Bh.numPlugins; i++)
 		{
-			pe = &(m_Bh.plugins[i]);
+			pe = &(m_Bh.plugins[(unsigned)i]);
+			
 			if (pe->cellsize == m_CellSize)
 			{
 				m_Entry = i;
 				break;
 			}
 		}
+		
 		if (m_Entry == -1)
 		{
 			m_Status = Err_SectionNotFound;
 			fclose(m_pFile);
 			m_pFile = NULL;
+			
 			return;
 		}
+		
 		pe = &(m_Bh.plugins[m_Entry]);
 		m_SectionLength = pe->disksize;
-	} else if (magic == MAGIC_HEADER) {
+	}
-
+	else if (magic == MAGIC_HEADER)
+	{
 		// try to find the section
 		mint8_t numOfPlugins;
 		DATAREAD(&numOfPlugins, sizeof(numOfPlugins), 1);
@@ -151,6 +168,7 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 	
 		m_SectionHdrOffset = 0;
 		int i = 0;
+		
 		for (i = 0; i < static_cast<int>(numOfPlugins); ++i)
 		{
 			DATAREAD(&entry, sizeof(entry), 1);
@@ -160,6 +178,7 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 				break;
 			}
 		}
+		
 		if (!m_SectionHdrOffset)
 		{
 			m_Status = Err_SectionNotFound;
@@ -169,15 +188,13 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 		}
 
 		// compute section length
-		if ((i+1) < static_cast<int>(numOfPlugins))
+		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 {
-		else
-		{
 			fseek(m_pFile, 0, SEEK_END);
 			m_SectionLength = ftell(m_pFile) - (long)entry.offset;
 		}
@@ -187,6 +204,7 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 		rewind(m_pFile);
 		fread(&hdr, sizeof(hdr), 1, m_pFile);
 		amx_Align16(&hdr.magic);
+		
 		if (hdr.magic == AMX_MAGIC)
 		{
 			if (cellsize != 4)
@@ -194,18 +212,19 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 				m_Status = Err_SectionNotFound;
 				fclose(m_pFile);
 				m_pFile = NULL;
+				
 				return;
 			}
 
 			m_OldFile = true;
+			
 			return;
-		}
+		} else {
-		else
-		{
 			// no known file format
 			m_Status = Err_FileInvalid;
 			fclose(m_pFile);
 			m_pFile = NULL;
+			
 			return;
 		}
 	} 
@@ -218,6 +237,7 @@ CAmxxReader::~CAmxxReader()
 		fclose(m_pFile);
 		m_pFile = NULL;
 	}
+	
 	if (m_Bh.plugins)
 	{
 		delete [] m_Bh.plugins;
@@ -256,11 +276,16 @@ size_t CAmxxReader::GetBufferSize()
 		AMX_HEADER hdr;
 		DATAREAD(&hdr, sizeof(hdr), 1);
 		fseek(m_pFile, save, SEEK_SET);
+		
 		return hdr.stp;
-	} else if (m_AmxxFile) {
+	}
+	else if (m_AmxxFile)
+	{
 		PluginEntry *pe = &(m_Bh.plugins[m_Entry]);
+		
 		if (pe->imagesize > pe->memsize)
 			return pe->imagesize + 1;
+		
 		return pe->memsize + 1;
 	}
 
@@ -269,12 +294,13 @@ size_t CAmxxReader::GetBufferSize()
 	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 (fread(addr, itemsize, itemcount, m_pFile) != static_cast<size_t>(itemcount)) \
 	{ \
 		if (feof(m_pFile)) \
 			m_Status = Err_FileInvalid; \
@@ -298,22 +324,26 @@ CAmxxReader::Error CAmxxReader::GetSection(void *buffer)
 		rewind(m_pFile);
 		DATAREAD(buffer, 1, filesize);
 		m_Status = Err_None;
+		
 		return m_Status;
-	} else if (m_AmxxFile) {
+	}
+	else if (m_AmxxFile)
+	{
 		PluginEntry *pe = &(m_Bh.plugins[m_Entry]);
 		char *tempBuffer = new char[m_SectionLength + 1];
 		fseek(m_pFile, pe->offs, SEEK_SET);
 		DATAREAD((void *)tempBuffer, 1, m_SectionLength);
 		uLongf destLen = GetBufferSize();
-		int result = uncompress((Bytef *)buffer, &destLen, 
+		int result = uncompress((Bytef *)buffer, &destLen, (Bytef *)tempBuffer, m_SectionLength);
-			(Bytef *)tempBuffer, m_SectionLength);
 		delete [] tempBuffer;
+		
 		if (result != Z_OK)
 		{
 			AMXXLOG_Log("[AMXX] Zlib error encountered: %d(%d)", result, m_SectionLength);
 			m_Status = Err_Decompress;
 			return Err_Decompress;
 		}
+		
 		return Err_None;
 	} else {
 		// new file type: go to the section table entry
@@ -328,15 +358,17 @@ CAmxxReader::Error CAmxxReader::GetSection(void *buffer)
 		//fread(tempBuffer, sizeof(char), m_SectionLength, m_pFile);
 		DATAREAD((void*)tempBuffer, 1, m_SectionLength);
 		// decompress
-		int result = uncompress((Bytef *)buffer, &destLen,
+		int result = uncompress((Bytef *)buffer, &destLen, (Bytef *)tempBuffer, m_SectionLength);
-				(Bytef *)tempBuffer, m_SectionLength);
 		delete [] tempBuffer;
+		
 		if (result != Z_OK)
 		{
 			AMXXLOG_Log("[AMXX] Zlib error encountered: %d(%d)", result, m_SectionLength);
 			m_Status = Err_Decompress;
+			
 			return Err_Decompress;
 		}
+		
 		return Err_None;
 	}
 }

amxmodx/amxxfile.h

@@ -92,7 +92,7 @@ public:
 	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
+	inline bool IsOldFile() const { return m_OldFile; }
 };
 
 #endif // __AMXXFILE_H__
-

amxmodx/amxxlog.cpp

@@ -35,19 +35,23 @@
 //  3 = HL Logs
 
 #include <time.h>
-#ifndef __linux__
+#if defined(_WIN32)
-#include <io.h>
+	#include <io.h>
 #endif
 #include "amxmodx.h"
 
-#ifndef __linux__
+#if defined(_WIN32WIN32)
-#define	vsnprintf	_vsnprintf
+	#define	vsnprintf	_vsnprintf
 #endif
 
+#include "svn_version.h"
+
 CLog::CLog()
 {
 	m_LogType = 0;
 	m_LogFile.clear();
+	m_FoundError = false;
+	m_LoggedErrMap = false;
 }
 
 CLog::~CLog()
@@ -61,6 +65,7 @@ void CLog::CloseFile()
 	if (!m_LogFile.empty())
 	{
 		FILE *fp = fopen(m_LogFile.c_str(), "r");
+		
 		if (fp)
 		{
 			fclose(fp);
@@ -77,6 +82,7 @@ void CLog::CloseFile()
 			fprintf(fp, "L %s: %s\n", date, "Log file closed.");
 			fclose(fp);
 		}
+		
 		m_LogFile.clear();
 	}
 }
@@ -84,30 +90,39 @@ void CLog::CloseFile()
 void CLog::CreateNewFile()
 {
 	CloseFile();
+	
 	// build filename
 	time_t td;
 	time(&td);
 	tm *curTime = localtime(&td);
 
+	char file[256];
+	char name[256];
 	int i = 0;
+	
 	while (true)
 	{
-		FILE *pTmpFile = fopen(m_LogFile.c_str(), "r");		// open for reading to check whether the file exists
+		snprintf(name, sizeof(name), "%s/L%02d%02d%03d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday, i);
+		build_pathname_r(file, sizeof(file)-1, "%s", name);
+		FILE *pTmpFile = fopen(file, "r");			// open for reading to check whether the file exists
+		
 		if (!pTmpFile)
 			break;
+		
 		fclose(pTmpFile);
 		++i;
 	}
+	m_LogFile.assign(file);
+	
 	// 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 {
-	else
+		fprintf(fp, "AMX Mod X log file started (file \"%s\") (version \"%s\")\n", name, SVN_VERSION_STRING);
-	{
-		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);
 	}
 }
@@ -122,13 +137,14 @@ void CLog::MapChange()
 {
 	// create dir if not existing
 	char file[256];
-#ifdef __linux
+#if defined(__linux__) || defined(__APPLE__)
-	mkdir(build_pathname_r(file, sizeof(file)-1,"%s", g_log_dir.c_str()), 0700);
+	mkdir(build_pathname_r(file, sizeof(file)-1, "%s", g_log_dir.c_str()), 0700);
 #else
-	mkdir(build_pathname_r(file, sizeof(file)-1,"%s", g_log_dir.c_str()));
+	mkdir(build_pathname_r(file, sizeof(file)-1, "%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");
@@ -136,22 +152,23 @@ void CLog::MapChange()
 		print_srvconsole("[AMXX] Invalid amxx_logging value; setting back to 1...");
 	}
 
+	m_LoggedErrMap = false;
+
 	if (m_LogType == 2)
 	{
 		// create new logfile
 		CreateNewFile();
-	}
+	} else if (m_LogType == 1) {
-	else if (m_LogType == 1)
+		Log("-------- Mapchange to %s --------", STRING(gpGlobals->mapname));
-	{
+	} else {
-		Log("-------- Mapchange --------");
-	}
-	else
 		return;
+	}
 }
 
 void CLog::Log(const char *fmt, ...)
 {
 	static char file[256];
+	
 	if (m_LogType == 1 || m_LogType == 2)
 	{
 		// get time
@@ -178,6 +195,7 @@ void CLog::Log(const char *fmt, ...)
 			{
 				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());
@@ -185,19 +203,16 @@ void CLog::Log(const char *fmt, ...)
 					return;
 				}
 			}
-		}
+		} else {
-		else
+			build_pathname_r(file, sizeof(file)-1, "%s/L%04d%02d%02d.log", g_log_dir.c_str(), (curTime->tm_year + 1900), curTime->tm_mon + 1, curTime->tm_mday);
-		{
-			build_pathname_r(file, sizeof(file)-1, "%s/L%02d%02d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday);
 			pF = fopen(file, "a+");
 		}
+		
 		if (pF)
 		{
 			fprintf(pF, "L %s: %s\n", date, msg);
 			fclose(pF);
-		}
+		} else {
-		else
-		{
 			ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Logging disabled for this map.\n", file);
 			m_LogType = 0;
 			return;
@@ -205,9 +220,7 @@ void CLog::Log(const char *fmt, ...)
 
 		// print on server console
 		print_srvconsole("L %s: %s\n", date, msg);
-	}
+	} else if (m_LogType == 3) {
-	else if (m_LogType == 3)
-	{
 		// build message
 		static char msg_[3072];
 		va_list arglst;
@@ -217,3 +230,55 @@ void CLog::Log(const char *fmt, ...)
 		ALERT(at_logged, "%s\n", msg_);
 	}
 }
+
+void CLog::LogError(const char *fmt, ...)
+{
+	static char file[256];
+	static char name[256];
+
+	if (m_FoundError)
+	{
+		return;
+	}
+
+	// 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
+	static char msg[3072];
+
+	va_list arglst;
+	va_start(arglst, fmt);
+	vsnprintf(msg, sizeof(msg)-1, fmt, arglst);
+	va_end(arglst);
+
+	FILE *pF = NULL;
+	snprintf(name, sizeof(name), "%s/error_%04d%02d%02d.log", g_log_dir.c_str(), curTime->tm_year + 1900, curTime->tm_mon + 1, curTime->tm_mday);
+	build_pathname_r(file, sizeof(file)-1, "%s", name);
+	pF = fopen(file, "a+");
+
+	if (pF)
+	{
+		if (!m_LoggedErrMap)
+		{
+			fprintf(pF, "L %s: Start of error session.\n", date);
+			fprintf(pF, "L %s: Info (map \"%s\") (file \"%s\")\n", date, STRING(gpGlobals->mapname), name);
+			m_LoggedErrMap = true;
+		}
+		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 Error Logging disabled for this map.\n", file);
+		m_FoundError = true;
+		return;
+	}
+
+	// print on server console
+	print_srvconsole("L %s: %s\n", date, msg);
+}
+

amxmodx/amxxlog.h

@@ -36,17 +36,20 @@ class CLog
 private:
 	String m_LogFile;
 	int m_LogType;
+	bool m_FoundError;
+	bool m_LoggedErrMap;
 
 	void GetLastFile(int &outMonth, int &outDay, String &outFilename);
 	void UseFile(const String &fileName);
 public:
 	CLog();
 	~CLog();
+	
 	void CreateNewFile();
 	void CloseFile();
 	void MapChange();
 	void Log(const char *fmt, ...);
+	void LogError(const char *fmt, ...);
 };
 
 #endif // __AMXXLOG_H__
-

amxmodx/binlog.cpp

@@ -0,0 +1,362 @@
+#if defined BINLOG_ENABLED
+
+#include <time.h>
+#include "amxmodx.h"
+#include "binlog.h"
+#include "debugger.h"
+
+BinLog g_BinLog;
+int g_binlog_level = 0;
+int g_binlog_maxsize = 0;
+
+// Helper function to get a filename index
+#define USHR(x) ((unsigned int)(x)>>1)
+int LookupFile(AMX_DBG *amxdbg, ucell address)
+{
+	int high, low, mid;
+
+	high = amxdbg->hdr->files;
+	low = -1;
+
+	while (high - low > 1)
+	{
+		mid = USHR(low + high);
+		if (amxdbg->filetbl[mid]->address <= address)
+		{
+			low = mid;
+		} else {
+			high = mid;
+		}
+	}
+
+	if (low == -1)
+	{
+		return -1;
+	}
+
+	return low;
+}
+
+bool BinLog::Open()
+{
+	const char *data = get_localinfo("amxmodx_datadir", "addons/amxmodx/data");
+	char path[255];
+	build_pathname_r(path, sizeof(path)-1, "%s/binlogs", data);
+	
+	if (!DirExists(path))
+	{
+		mkdir(path
+#if defined(__linux__) || defined(__APPLE__)
+			, 0755
+#endif
+			);
+		if (!DirExists(path))
+			return false;
+	}
+
+	char file[255];
+	build_pathname_r(file, sizeof(file)-1, "%s/binlogs/lastlog", data);
+
+	unsigned int lastcntr = 0;
+	FILE *lastlog = fopen(file, "rb");
+	if (lastlog)
+	{
+		if (fread(&lastcntr, sizeof(int), 1, lastlog) != 1)
+			lastcntr = 0;
+		fclose(lastlog);
+	}
+	lastlog = fopen(file, "wb");
+	if (lastlog)
+	{
+		lastcntr++;
+		fwrite(&lastcntr, sizeof(int), 1, lastlog);
+		fclose(lastlog);
+	}
+	build_pathname_r(file, sizeof(file)-1, "%s/binlogs/binlog%04d.blg", data, lastcntr);
+	m_logfile.assign(file);
+
+	/**
+	* it's now safe to create the binary log
+	*/
+	FILE *fp = fopen(m_logfile.c_str(), "wb");
+	if (!fp)
+		return false;
+
+	int magic = BINLOG_MAGIC;
+	short vers = BINLOG_VERSION;
+	char c = sizeof(time_t);
+	fwrite(&magic, sizeof(int), 1, fp);
+	fwrite(&vers, sizeof(short), 1, fp);
+	fwrite(&c, sizeof(char), 1, fp);
+
+	WritePluginDB(fp);
+	fclose(fp);
+
+	m_state = true;
+
+	WriteOp(BinLog_Start, -1);
+
+	return true;
+}
+
+void BinLog::Close()
+{
+	WriteOp(BinLog_End, -1);
+	m_state = false;
+}
+
+void BinLog::WriteOp(BinLogOp op, int plug, ...)
+{
+	if (!m_state)
+		return;
+
+	FILE *fp = fopen(m_logfile.c_str(), "ab");
+	if (!fp)
+		return;
+
+	if (g_binlog_maxsize && op != BinLog_End)
+	{
+		fseek(fp, 0, SEEK_END);
+		if (ftell(fp) > (g_binlog_maxsize * (1024 * 1024)))
+		{
+			fclose(fp);
+			Close();
+			Open();
+			fp = fopen(m_logfile.c_str(), "ab");
+			if (!fp)
+				return;
+		}
+	}
+
+	unsigned char c = static_cast<char>(op);
+	time_t t = time(NULL);
+	float gt = gpGlobals->time;
+	fwrite(&c, sizeof(char), 1, fp);
+	fwrite(&t, sizeof(time_t), 1, fp);
+	fwrite(&gt, sizeof(float), 1, fp);
+	fwrite(&plug, sizeof(int), 1, fp);
+
+	va_list ap;
+	va_start(ap, plug);
+
+	AMX *amx = NULL;
+	bool debug = false;
+	AMX_DBG *dbg = NULL;
+	CPluginMngr::CPlugin *pl = NULL;
+
+	if (plug != -1)
+	{
+		pl = g_plugins.findPlugin(plug);
+		if ((debug = pl->isDebug()))
+		{
+			amx = pl->getAMX();
+			dbg = static_cast<Debugger *>(amx->userdata[UD_DEBUGGER])->m_pAmxDbg;
+		}
+	}
+
+	switch (c)
+	{
+	case BinLog_Registered:
+		{
+			const char *title = va_arg(ap, const char *);
+			const char *vers = va_arg(ap, const char *);
+			c = (char)strlen(title);
+			fwrite(&c, sizeof(char), 1, fp);
+			fwrite(title, sizeof(char), c+1, fp);
+			c = (char)strlen(vers);
+			fwrite(&c, sizeof(char), 1 ,fp);
+			fwrite(vers, sizeof(char), c+1, fp);
+			break;
+		}
+	case BinLog_NativeCall:
+		{
+			int file;
+			int native = va_arg(ap, int);
+			int params = va_arg(ap, int);
+			fwrite(&native, sizeof(int), 1, fp);
+			fwrite(&params, sizeof(int), 1, fp);
+			if (debug)
+			{
+				file = LookupFile(dbg, amx->cip);
+				fwrite(&file, sizeof(int), 1, fp);
+			} else {
+				file = 0;
+				fwrite(&file, sizeof(int), 1, fp);
+			}
+			break;
+		}
+	case BinLog_NativeRet:
+		{
+			cell retval = va_arg(ap, cell);
+			fwrite(&retval, sizeof(cell), 1, fp);
+			break;
+		}
+	case BinLog_NativeError:
+		{
+			int err = va_arg(ap, int);
+			const char *msg = va_arg(ap, const char *);
+			short len = (short)strlen(msg);
+			fwrite(&err, sizeof(int), 1, fp);
+			fwrite(&len, sizeof(short), 1, fp);
+			fwrite(msg, sizeof(char), len+1, fp);
+			break;
+		}
+	case BinLog_CallPubFunc:
+		{
+			int file;
+			int num = va_arg(ap, int);
+			fwrite(&num, sizeof(int), 1, fp);
+			if (debug)
+			{
+				file = LookupFile(dbg, amx->cip);
+				fwrite(&file, sizeof(int), 1, fp);
+			} else {
+				file = 0;
+				fwrite(&file, sizeof(int), 1, fp);
+			}
+			break;
+		}
+	case BinLog_SetLine:
+		{
+			int file;
+			int line = va_arg(ap, int);
+			fwrite(&line, sizeof(int), 1, fp);
+			if (debug)
+			{
+				file = LookupFile(dbg, amx->cip);
+				fwrite(&file, sizeof(int), 1, fp);
+			} else {
+				file = 0;
+				fwrite(&file, sizeof(int), 1, fp);
+			}
+			break;
+		}
+	case BinLog_FormatString:
+		{
+			int param = va_arg(ap, int);
+			int maxlen = va_arg(ap, int);
+			const char *str = va_arg(ap, const char *);
+			short len = (short)strlen(str);
+			fwrite(&param, sizeof(int), 1, fp);
+			fwrite(&maxlen, sizeof(int), 1, fp);
+			fwrite(&len, sizeof(short), 1, fp);
+			fwrite(str, sizeof(char), len+1, fp);
+			break;
+		}
+	case BinLog_NativeParams:
+		{
+			cell *params = va_arg(ap, cell *);
+			cell num = params[0] / sizeof(cell);
+			fwrite(&num, sizeof(cell), 1, fp);
+			for (cell i=1; i<=num; i++)
+				fwrite(&(params[i]), sizeof(cell), 1, fp);
+			break;
+		}
+	case BinLog_GetString:
+		{
+			cell addr = va_arg(ap, cell);
+			const char *str = va_arg(ap, const char *);
+			short len = (short)strlen(str);
+			fwrite(&addr, sizeof(cell), 1, fp);
+			fwrite(&len, sizeof(short), 1, fp);
+			fwrite(str, sizeof(char), len+1, fp);
+			break;
+		}
+	case BinLog_SetString:
+		{
+			cell addr = va_arg(ap, cell);
+			int maxlen = va_arg(ap, int);
+			const char *str = va_arg(ap, const char *);
+			short len = (short)strlen(str);
+			fwrite(&addr, sizeof(cell), 1, fp);
+			fwrite(&maxlen, sizeof(int), 1, fp);
+			fwrite(&len, sizeof(short), 1, fp);
+			fwrite(str, sizeof(char), len+1, fp);
+			break;
+		}
+	};
+
+	va_end(ap);
+	fclose(fp);
+}
+
+void BinLog::WritePluginDB(FILE *fp)
+{
+	int num = g_plugins.getPluginsNum();
+	fwrite(&num, sizeof(int), 1, fp);
+
+	CPluginMngr::CPlugin *pl;
+	char c;
+	unsigned char len;
+	for (CPluginMngr::iterator iter = g_plugins.begin(); iter; ++iter)
+	{
+		pl = &(*iter);
+		if (pl->isValid())
+			c = 1;
+		else
+			c = 0;
+		if (c && pl->isDebug())
+			c = 2;
+		fwrite(&c, sizeof(char), 1, fp);
+		if (c)
+		{
+			Debugger *pd = NULL;
+			len = (char)strlen(pl->getName());
+			fwrite(&len, sizeof(char), 1, fp);
+			len++;
+			fwrite(pl->getName(), sizeof(char), len, fp);
+			int natives, publics, files;
+			AMX *amx = pl->getAMX();
+			// Write the number of Filenames
+			if (c == 2)
+			{
+				pd = static_cast<Debugger *>(amx->userdata[UD_DEBUGGER]);
+				files = pd->m_pAmxDbg->hdr->files;
+				fwrite(&files, sizeof(int), 1, fp);
+			}
+			amx_NumNatives(amx, &natives);
+			amx_NumPublics(amx, &publics);
+			fwrite(&natives, sizeof(int), 1, fp);
+			fwrite(&publics, sizeof(int), 1, fp);
+			char name[34];
+			// Write the Filenames to the binfile
+			if (c == 2)
+			{
+				AMX_DBG_FILE **ftable = pd->m_pAmxDbg->filetbl;
+				for (int i=0; i<files; i++)
+				{
+					len = (char)strlen(ftable[i]->name);
+					fwrite(&len, sizeof(char), 1, fp);
+					len++;
+					fwrite(ftable[i]->name, sizeof(char), len, fp);
+				}
+			}
+			for (int i=0; i<natives; i++)
+			{
+				amx_GetNative(amx, i, name);
+				len = (char)strlen(name);
+				fwrite(&len, sizeof(char), 1, fp);
+				len++;
+				fwrite(name, sizeof(char), len, fp);
+			}
+			for (int i=0; i<publics; i++)
+			{
+				amx_GetPublic(amx, i, name);
+				len = (char)strlen(name);
+				fwrite(&len, sizeof(char), 1, fp);
+				len++;
+				fwrite(name, sizeof(char), len, fp);
+			}
+		} else {
+			char empty[] = " ";
+			len = 1;
+			fwrite(&len, sizeof(char), 1, fp);
+			fwrite(empty, sizeof(char), len, fp);
+			int no = 0;
+			fwrite(&no, sizeof(int), 1, fp);
+			fwrite(&no, sizeof(int), 1, fp);
+		}
+	}
+}
+
+#endif //BINLOG_ENABLED

amxmodx/binlog.h

@@ -0,0 +1,84 @@
+#ifndef _INCLUDE_BINLOG_H
+#define _INCLUDE_BINLOG_H
+
+#if defined BINLOG_ENABLED
+
+#include "CString.h"
+
+#define BINLOG_MAGIC	0x414D424C
+#define BINLOG_VERSION	0x0300
+
+/**
+ * Format of binlog:
+ * uint32		magic
+ * uint16		version
+ * uint8		sizeof(time_t)
+ * uint32		num plugins
+ * [
+ *  uint8		status codes
+ *  str[int8]	filename
+ *  if(status==2)
+ *    uint32	num filenames
+ *  uint32		num natives
+ *  uint32		num publics
+ *  if (status==2)
+ *    [
+ *     str[uint8] file name
+ *    ]
+ *  [
+ *   str[uint8] native name
+ *  ]
+ *  [
+ *   str[uint8] public name
+ *  ]
+ * ]
+ * [
+ *  uint8		operation code
+ *  time_t		realtime
+ *  float		gametime
+ *  int32		plugin id
+ *  <extra info>
+ * ]
+ * If filename id is 0 skip as plugin was not in debug mode, if -1 there was an error.
+ */
+
+enum BinLogOp
+{
+	BinLog_Start=1,
+	BinLog_End,
+	BinLog_NativeCall,	//<int32 native id> <int32_t num_params> <int32_t filename id>
+	BinLog_NativeError, //<int32 errornum> <str[int16] string>
+	BinLog_NativeRet,	//<cell value>
+	BinLog_CallPubFunc,	//<int32 public id> <int32_t filename id>
+	BinLog_SetLine,		//<int32 line no#> <int32_t filename id>
+	BinLog_Registered,	//<string title> <string version>
+	BinLog_FormatString, //<int32 param#> <int32 maxlen> <str[int16] string>
+	BinLog_NativeParams, //<int32 num> <cell ...>
+	BinLog_GetString,	//<cell addr> <string[int16]>
+	BinLog_SetString,	//<cell addr> <int maxlen> <string[int16]>
+};
+
+class BinLog
+{
+public:
+	BinLog() : m_state(false)
+	{
+	};
+public:
+	bool Open();
+	void Close();
+	void WriteOp(BinLogOp op, int plug, ...);
+private:
+	void WritePluginDB(FILE *fp);
+private:
+	String m_logfile;
+	bool m_state;
+};
+
+extern BinLog g_BinLog;
+extern int g_binlog_level;
+extern int g_binlog_maxsize;
+
+#endif //BINLOG_ENABLED
+
+#endif //_INCLUDE_BINLOG_H

amxmodx/datastructs.cpp

@@ -0,0 +1,608 @@
+/* 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 "datastructs.h"
+
+
+// Note: All handles start at 1. 0 and below are invalid handles.
+//       This way, a plugin that doesn't initialize a vector or
+//       string will not be able to modify another plugin's data
+//       on accident.
+CVector<CellVector*> VectorHolder;
+
+
+// Array:ArrayCreate(cellsize=1, reserved=32);
+static cell AMX_NATIVE_CALL ArrayCreate(AMX* amx, cell* params)
+{
+	// params[1] (cellsize) is how big in cells each element is.
+	// this MUST be greater than 0!
+	int cellsize=params[1];
+
+	// params[2] (reserved) is how many elements to allocate
+	// immediately when the list is created.
+	// this MUST be greater than 0!
+	int reserved=params[2];
+
+	if (cellsize<=0)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array size (%d)", cellsize);
+		return -1;
+	}
+	if (reserved<=0)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid reserved size (%d)", reserved);
+		return -1;
+	}
+
+	// Scan through the vector list to see if any are NULL.
+	// NULL means the vector was previously destroyed.
+	for (unsigned int i=0; i < VectorHolder.size(); ++i)
+	{
+		if (VectorHolder[i]==NULL)
+		{
+			VectorHolder[i]=new CellVector(cellsize);
+			VectorHolder[i]->Grow(reserved);
+			return i + 1;
+		}
+	}
+
+	// None are NULL, create a new vector
+	CellVector* NewVector=new CellVector(cellsize);
+	NewVector->Grow(reserved);
+
+	VectorHolder.push_back(NewVector);
+
+	return VectorHolder.size();
+}
+// ArrayClear(Array:which)
+static cell AMX_NATIVE_CALL ArrayClear(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	vec->Clear();
+
+	return 1;
+}
+// ArraySize(Array:which)
+static cell AMX_NATIVE_CALL ArraySize(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	return vec->Size();
+}
+// ArrayGetArray(Array:which, item, any:output[]);
+static cell AMX_NATIVE_CALL ArrayGetArray(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	if (vec->GetArray(params[2],get_amxaddr(amx, params[3]))!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cellvector handle provided (%d:%d:%d)", params[1], params[2], vec->Size());
+		return 0;
+	}
+
+	return 1;
+}
+// ArrayGetCell(Array:which, item, any:&output);
+static cell AMX_NATIVE_CALL ArrayGetCell(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	cell ret;
+	if (vec->GetCell(params[2],&ret)!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cellvector handle provided (%d:%d:%d)", params[1], params[2], vec->Size());
+		return 0;
+	}
+
+	return ret;
+}
+// ArrayGetString(Array:which, item, any:output[], size);
+static cell AMX_NATIVE_CALL ArrayGetString(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	if (vec->GetString(params[2],get_amxaddr(amx, params[3]),params[4])!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cellvector handle provided (%d:%d:%d)", params[1], params[2], vec->Size());
+		return 0;
+	}
+
+	return 1;
+}
+// ArraySetArray(Array:which, item, any:output[]);
+static cell AMX_NATIVE_CALL ArraySetArray(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	if (vec->SetArray(params[2],get_amxaddr(amx, params[3]))!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cellvector handle provided (%d:%d:%d)", params[1], params[2], vec->Size());
+		return 0;
+	}
+
+	return 1;
+}
+// ArraySetCell(Array:which, item, any:&output);
+static cell AMX_NATIVE_CALL ArraySetCell(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	if (vec->SetCell(params[2], params[3])!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cellvector handle provided (%d:%d:%d)", params[1], params[2], vec->Size());
+		return 0;
+	}
+
+	return 1;
+}
+// ArraySetString(Array:which, item, any:output[]);
+static cell AMX_NATIVE_CALL ArraySetString(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	if (vec->SetString(params[2],get_amxaddr(amx, params[3]))!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid cellvector handle provided (%d:%d:%d)", params[1], params[2], vec->Size());
+		return 0;
+	}
+
+	return 1;
+}
+// ArrayPushArray(Array:which, any:output[]);
+static cell AMX_NATIVE_CALL ArrayPushArray(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	vec->SetArray(vec->Push(),get_amxaddr(amx, params[2]));
+
+	return 1;
+}
+// ArrayPushCell(Array:which, &any:output);
+static cell AMX_NATIVE_CALL ArrayPushCell(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	vec->SetCell(vec->Push(), params[2]);
+
+	return 1;
+}
+// ArrayPushString(Array:which, any:output[]);
+static cell AMX_NATIVE_CALL ArrayPushString(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec==NULL)
+	{
+		return 0;
+	}
+
+	vec->SetString(vec->Push(),get_amxaddr(amx, params[2]));
+
+	return 1;
+}
+static cell AMX_NATIVE_CALL ArrayGetStringHandle(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (vec == NULL)
+	{
+		return 0;
+	}
+
+	cell* ptr=vec->GetCellPointer(params[2]);
+
+	if (ptr == NULL)
+	{
+		return 0;
+	}
+
+	return reinterpret_cast<cell>(ptr);
+
+}
+// ArrayInsertArrayAfter(Array:which, item, const value[])
+static cell AMX_NATIVE_CALL ArrayInsertArrayAfter(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	int item=params[2]+1;
+
+	if (vec->ShiftUpFrom(item)!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertArrayAfter (%d:%d)", params[1], vec->Size());
+		return 0;
+	}
+
+	vec->SetArray(item, get_amxaddr(amx, params[3]));
+
+	return 1;
+}
+// ArrayInsertCellAfter(Array:which, item, value[])
+static cell AMX_NATIVE_CALL ArrayInsertCellAfter(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	int item=params[2]+1;
+
+	if (vec->ShiftUpFrom(item)!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertCellAfter (%d:%d)", params[1], vec->Size());
+		return 0;
+	}
+
+	vec->SetCell(item, params[3]);
+
+	return 1;
+}
+// ArrayInsertStringAfter(Array:which, item, const value[])
+static cell AMX_NATIVE_CALL ArrayInsertStringAfter(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	int item=params[2]+1;
+
+	if (vec->ShiftUpFrom(item)!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertStringAfter (%d:%d)", params[1], vec->Size());
+		return 0;
+	}
+
+	vec->SetString(item, get_amxaddr(amx, params[3]));
+
+	return 1;
+}
+// ArrayInsertArrayBefore(Array:which, item, const value[])
+static cell AMX_NATIVE_CALL ArrayInsertArrayBefore(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	int item=params[2];
+
+	if (item==vec->Size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertArrayBefore (%d:%d)", params[2], vec->Size());
+		return 0;
+	}
+	if (vec->ShiftUpFrom(item)!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertArrayBefore (%d:%d)", params[2], vec->Size());
+		return 0;
+	}
+
+	vec->SetArray(item, get_amxaddr(amx, params[3]));
+
+	return 1;
+}
+// ArrayInsertCellBefore(Array:which, item, const value)
+static cell AMX_NATIVE_CALL ArrayInsertCellBefore(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	int item=params[2];
+
+	if (item==vec->Size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertCellBefore (%d:%d)", params[2], vec->Size());
+		return 0;
+	}
+	if (vec->ShiftUpFrom(item)!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertCellBefore (%d:%d)", params[2], vec->Size());
+		return 0;
+	}
+
+	vec->SetCell(item, params[3]);
+
+	return 1;
+}
+// ArrayInsertStringBefore(Array:which, item, const value[])
+static cell AMX_NATIVE_CALL ArrayInsertStringBefore(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	int item=params[2];
+
+	if (item==vec->Size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertStringBefore (%d:%d)", params[2], vec->Size());
+		return 0;
+	}
+	if (vec->ShiftUpFrom(item)!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayInsertStringBefore (%d:%d)", params[2], vec->Size());
+		return 0;
+	}
+
+	vec->SetString(item, get_amxaddr(amx, params[3]));
+
+	return 1;
+}
+
+// ArraySwap(Array:which, item1, item2)
+static cell AMX_NATIVE_CALL ArraySwap(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (!vec)
+	{
+		return 0;
+	}
+	if (vec->Swap(params[2], params[3])!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArraySwap (%d , %d:%d)",params[2], params[3], vec->Size());
+		return 0;
+	}
+
+	return 1;
+}
+
+// ArrayDeleteItem(Array:which, item);
+static cell AMX_NATIVE_CALL ArrayDeleteItem(AMX* amx, cell* params)
+{
+	CellVector* vec=HandleToVector(amx, params[1]);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	if (vec->Delete(params[2])!=1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid item specified in ArrayDeleteItem (%d:%d)", params[2], vec->Size());
+		return 0;
+	}
+	return 1;
+}
+
+
+// ArrayDestroy(Array:&which)
+static cell AMX_NATIVE_CALL ArrayDestroy(AMX* amx, cell* params)
+{
+	// byref the handle here so we can zero it out after destroying
+	// this way they cannot accidentally reuse it
+	cell* handle=get_amxaddr(amx,params[1]);
+	CellVector* vec=HandleToVector(amx, *handle);
+
+	if (!vec)
+	{
+		return 0;
+	}
+
+	delete vec;
+
+	VectorHolder[*handle-1]=NULL;
+
+	*handle=0;
+
+	return 1;
+}
+
+typedef struct ArraySort_s
+{
+	int    handle;
+	int    forward;
+	cell   data;
+	cell   size;
+
+} ArraySort_t;
+
+static CStack<ArraySort_t *> ArraySortStack;
+
+int SortArrayList(const void *itema, const void *itemb)
+{
+	ArraySort_t *Info = ArraySortStack.front();
+
+	return executeForwards(Info->forward, Info->handle, *((int *)itema), *((int *)itemb), Info->data, Info->size);
+
+}
+// native ArraySort(Array:array, const comparefunc[], data[]="", data_size=0);
+static cell AMX_NATIVE_CALL ArraySort(AMX* amx, cell* params)
+{
+	int handle=params[1];
+	CellVector* vec=HandleToVector(amx, handle);
+
+	if (!vec)
+	{
+		return 0;
+	}
+	
+	// This is kind of a cheating way to go about this but...
+	// Create an array of integers as big as however many elements are in the vector.
+	// Pass that array to qsort
+	// After the array is sorted out, then create a NEW cellvector
+	// and copy in the old data in the order of what was sorted
+	int len;
+	char* FuncName=get_amxstring(amx, params[2], 0, len);
+	// MySortFunc(Array:array, item1, item2, const data[], data_size)
+	int Forward = registerSPForwardByName(amx, FuncName, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+	if (Forward < 0)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "The public function \"%s\" was not found.", FuncName);
+		return 0;
+	}
+
+	int *IntList=new int[vec->Size()];
+
+	for (int i=0; i< vec->Size(); i++)
+	{
+		IntList[i]=i;
+	}
+
+	ArraySort_t *Info=new ArraySort_t;
+
+	Info->handle=handle;
+	Info->forward=Forward;
+	Info->data=params[3];
+	Info->size=params[4];
+
+	ArraySortStack.push(Info);
+	qsort(IntList, vec->Size(), sizeof(int), SortArrayList);
+	ArraySortStack.pop();
+
+	CellVector* newvec=new CellVector(vec->GetCellCount());
+
+	// Set the new vector's values
+	for (int i=0; i< vec->Size(); i++)
+	{
+		if (newvec->SetArray(newvec->Push(), vec->GetCellPointer(IntList[i]))!=1)
+		{
+			// This should never happen..
+			LogError(amx, AMX_ERR_NATIVE, "Failed to SetArray in ArraySort (i=%d, IntList=%d)",i,IntList[i]);
+
+			return 0;
+		}
+	}
+
+	// Delete the old vector
+	delete vec;
+
+	// Now save the new vector in its handle location
+	VectorHolder[handle-1]=newvec;
+
+	// Cleanup
+	delete Info;
+	delete IntList;
+
+	unregisterSPForward(Forward);
+
+	return 1;
+}
+
+
+
+AMX_NATIVE_INFO g_DataStructNatives[] = 
+{
+	{ "ArrayCreate",				ArrayCreate },
+	{ "ArrayClear",					ArrayClear },
+	{ "ArraySize",					ArraySize },
+	{ "ArrayGetArray",				ArrayGetArray },
+	{ "ArrayGetCell",				ArrayGetCell },
+	{ "ArrayGetString",				ArrayGetString },
+	{ "ArraySetArray",				ArraySetArray },
+	{ "ArraySetCell",				ArraySetCell },
+	{ "ArraySetString",				ArraySetString },
+	{ "ArrayPushArray",				ArrayPushArray },
+	{ "ArrayPushCell",				ArrayPushCell },
+	{ "ArrayPushString",			ArrayPushString },
+	{ "ArrayInsertArrayAfter",		ArrayInsertArrayAfter },
+	{ "ArrayInsertCellAfter",		ArrayInsertCellAfter },
+	{ "ArrayInsertStringAfter",		ArrayInsertStringAfter },
+	{ "ArrayInsertArrayBefore",		ArrayInsertArrayBefore },
+	{ "ArrayInsertCellBefore",		ArrayInsertCellBefore },
+	{ "ArrayInsertStringBefore",	ArrayInsertStringBefore },
+	{ "ArraySwap",					ArraySwap },
+	{ "ArrayDeleteItem",			ArrayDeleteItem },
+	{ "ArrayGetStringHandle",		ArrayGetStringHandle },
+	{ "ArrayDestroy",				ArrayDestroy },
+	{ "ArraySort",					ArraySort },
+
+	{ NULL,							NULL }
+};

amxmodx/datastructs.h

@@ -0,0 +1,321 @@
+/* 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 DATASTRUCTS_H
+#define DATASTRUCTS_H
+
+class CellVector
+{
+private:
+	cell*  data;       // allocated with malloc
+	size_t cellcount;  // how many cells per element
+	size_t cursize;    // current size of the vector (maximum elements)
+	size_t count;      // how many units of the vector are in use
+	
+public:
+	CellVector(): data(NULL), cellcount(0), cursize(0), count(0)
+	{
+	};
+	CellVector(int cellsize): data(NULL), cellcount(cellsize), cursize(0), count(0)
+	{
+	};
+	~CellVector()
+	{
+		if (data)
+		{
+			free(data);
+		}
+	};
+	size_t GetCellCount()
+	{
+		return cellcount;
+	};
+	void Grow(size_t howmany)
+	{
+		cursize+=howmany;
+		if (data)
+		{
+			data=(cell*)realloc(data, (sizeof(cell) * cellcount) * cursize);
+		}
+		else
+		{
+			data=(cell*)malloc((sizeof(cell) * cellcount) * cursize);
+		}
+	};
+	void FreeUnused(void)
+	{
+		if (cursize != count &&
+			data != NULL)
+		{
+			cursize=count;
+			data=(cell*)realloc(data, cursize * (sizeof(cell) * cellcount));
+		}
+	};
+	// Returns 1 on success
+	// 0 on out of bounds.
+	int GetArray(size_t which, cell* output)
+	{
+		// make sure it is in bounds.
+		if (which >= count)
+		{
+			return 0;
+		}
+		// align output data
+		cell* out=data + (cellcount * which);
+		
+		memcpy(output, out, sizeof(cell) * cellcount);
+
+		return 1;
+	};
+	// Returns 1 on success
+	// 0 on out of bounds
+	int GetCell(size_t which, cell* output)
+	{
+		// check bounds
+		if (which >= count)
+		{
+			return 0;
+		}
+		*output=*(data + (cellcount * which));
+
+		return 1;
+	}
+	// Returns 1 on success
+	// 0 on out of bounds
+	int GetString(size_t which, cell* output, size_t size)
+	{
+		// check bounds
+		if (which >= count)
+		{
+			return 0;
+		}
+		cell* out=data + (cellcount * which);
+
+		size_t count=cellcount;
+
+		while (size-- && 
+			count-- &&
+			(*output++=*out++)!='\0')
+			/* do nothing */ ;
+
+		// If size is zero here, then the string was never null terminated.
+		if (size==0)
+		{
+			*out='\0';
+		}
+
+		return 1;
+	}
+	// Returns 1 on success
+	// 0 on out of bounds
+	int SetArray(size_t which, cell* output)
+	{
+		if (which >= count)
+		{
+			return 0;
+		}
+		// align output
+		cell* out=data + (cellcount * which);
+
+		memcpy(out, output, sizeof(cell) * cellcount);
+
+		return 1;
+	};
+	// Returns 1 on success
+	// 0 on out of bounds
+	int SetCell(size_t which, cell output)
+	{
+		if (which >= count)
+		{
+			return 0;
+		}
+		// align output
+		*(data + (cellcount * which))=output;
+
+		return 1;
+	};
+	// Returns 1 on success
+	// 0 on out of bounds
+	int SetString(size_t which, cell* output)
+	{
+		if (which >= count)
+		{
+			return 0;
+		}
+		// align output
+		cell* out=data + (cellcount * which);
+
+		memcpy(out, output, sizeof(cell) * cellcount);
+
+		// now force a null terminator on the last entry.
+		out+=(cellcount - 1);
+		*out='\0';
+
+		return 1;
+	};
+	int Push()
+	{
+		if (count >= cursize)
+		{
+			// Grow in 8s to cause less reallocation
+			this->Grow(8);
+		};
+		
+		this->count++;
+
+		return this->count-1;
+	};
+	int Size() 
+	{
+		return this->count;
+	};
+	void Clear()
+	{
+		free(data);
+		data=(cell*)malloc(sizeof(cell) * cellcount);
+		cursize=1;
+		count=0;
+	};
+	cell* GetCellPointer(size_t which)
+	{
+		if (which >= count)
+		{
+			return NULL;
+		}
+		return data + (which * cellcount);
+	};
+	// Shifts all items from this item, and including this item up 1.
+	int ShiftUpFrom(size_t which)
+	{
+		// No point shifting this.
+		if (which > this->count)
+		{
+
+			return 0;
+		}
+		// First make a new item.
+		this->Push();
+
+		// If we got an InsertAfter(lastitem), then which will equal this->count - 1
+		// all we needed to do was Push()
+		if (which == this->count || 
+			which == this->count - 1)
+		{
+			return 1;
+		}
+
+		// Allocate a temporary buffer to store data in
+		size_t tempbuffsize=(sizeof(cell) * cellcount) * (this->count - which);
+
+		cell* temp=(cell*)malloc(tempbuffsize); 
+
+		// Copy old data to temp buffer
+		memcpy(temp, GetCellPointer(which), tempbuffsize);
+
+		// Now copy temp buffer to adjusted location
+		memcpy(GetCellPointer(which+1), temp, tempbuffsize);
+
+		// cleanup
+		free(temp);
+
+		return 1;
+
+	};
+	// Shifts all items from this item, and including this item down 1.
+	// This deletes the item specified.
+	int Delete(size_t which)
+	{
+		// No point shifting this.
+		if (which >= this->count)
+		{
+			return 0;
+		}
+
+
+		for (size_t i=which; i<this->count - 1; i++)
+		{
+			memcpy(GetCellPointer(i), GetCellPointer(i + 1), sizeof(cell) * cellcount);
+		}
+		this->count--;
+		return 1;
+	};
+	int Swap(size_t item1, size_t item2)
+	{
+		if (item1 >= this->count ||
+			item2 >= this->count)
+		{
+			return 0;
+		}
+
+		// Make a temp buffer to store item2
+		cell* temp=(cell*)malloc(sizeof(cell) * cellcount);
+		memcpy(temp, GetCellPointer(item2), sizeof(cell) * cellcount);
+		
+		// copy item1 to item2
+		memcpy(GetCellPointer(item2), GetCellPointer(item1), sizeof(cell) * cellcount);
+
+		// copy item2 to item1
+		memcpy(GetCellPointer(item1), temp, sizeof(cell) * cellcount);
+
+		// Cleanup
+		free(temp);
+
+		return 1;
+	};
+
+};
+
+extern CVector<CellVector*> VectorHolder;
+
+
+inline CellVector* HandleToVector(AMX* amx, int handle)
+{
+	if (handle <= 0 ||
+		handle > (int)VectorHolder.size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", handle);
+
+		return NULL;
+	}
+
+	CellVector* ret=VectorHolder[handle-1];
+
+	if (ret == NULL)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid array handle provided (%d)", handle);
+
+		return NULL;
+	}
+
+	return ret;
+}
+
+
+#endif

amxmodx/debugger.h

@@ -0,0 +1,201 @@
+/* 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_DEBUGGER_H_
+#define _INCLUDE_DEBUGGER_H_
+
+#include "CVector.h"
+#include "amxdbg.h"
+
+/**
+ * Third revision of the AMX Mod X Plugin Debugger.
+ * This final, object oriented version is safe for multiple calls and lets you 
+ *  fine-tune error handling.
+ *  -BAILOPAN
+ */
+class Debugger
+{
+public:
+	class Tracer
+	{
+	public:
+		
+		struct trace_info
+		{
+			trace_info() : cip(0), frm(0), next(NULL), prev(NULL), used(false) {};
+			
+			cell cip;
+			cell frm;
+			
+			trace_info *next;
+			trace_info *prev;
+			
+			bool used;
+		};
+	
+	public:
+		Tracer() : m_Error(0), m_pStart(NULL), m_pEnd(NULL), m_Reset(true) {};
+		~Tracer();
+	public:
+		void StepI(cell frm, cell cip);
+		void Reset();
+		void Clear();
+		
+		Debugger::Tracer::trace_info *GetStart() const;
+		Debugger::Tracer::trace_info *GetEnd() const;
+	public:
+		int m_Error;
+	private:
+		trace_info *m_pStart;
+		trace_info *m_pEnd;
+		
+		bool m_Reset;
+	};
+
+public:
+	Debugger(AMX *pAmx, AMX_DBG *pAmxDbg) : m_pAmx(pAmx), m_pAmxDbg(pAmxDbg), m_Top(-1)
+	{
+		_CacheAmxOpcodeList();
+	};
+	~Debugger();
+public:
+	//Begin a trace for a function
+	void BeginExec();
+
+	//Step through one instruction
+	void StepI();
+
+	//Get/set the last traced error
+	int GetTracedError();
+	void SetTracedError(int error);
+
+	//Get the first trace info of the call stack
+	Debugger::Tracer::trace_info *GetTraceStart() const;
+
+	//Get extra info about the call stack
+	bool GetTraceInfo(Debugger::Tracer::trace_info *pTraceInfo, long &line, const char *&function, const char *&file);
+
+	//Get the next trace in the call stack, NULL if none
+	Debugger::Tracer::trace_info *GetNextTrace(Debugger::Tracer::trace_info *pTraceInfo);
+
+	//Returns true if an error exists
+	bool ErrorExists();
+
+	//Formats the error message into a buffer.
+	//returns length of data copied, or -1 if there is no error.
+	int FormatError(char *buffer, size_t maxLength);
+
+	//End a trace
+	void EndExec();
+
+	//Reset the internal states as if the debugger was inactive
+	void Reset();
+
+	//Destroy internal states for shutdown
+	void Clear();
+
+	void DisplayTrace(const char *message);
+
+	AMX *GetAMX() const { return m_pAmx; }
+public:
+	//generic static opcode breaker
+	static int AMXAPI DebugHook(AMX *amx);
+	
+	static void FmtGenericMsg(AMX *amx, int error, char buffer[], size_t maxLength);
+	static void GenericMessage(AMX *amx, int error);
+private:
+	void _CacheAmxOpcodeList();
+	
+	int _GetOpcodeFromCip(cell cip, cell *&addr);
+	cell _CipAsVa(cell cip);
+	
+	const char *_GetFilename();
+public:
+	AMX *m_pAmx;
+	AMX_DBG *m_pAmxDbg;
+	
+	int m_Top;
+	cell *m_pOpcodeList;
+	String m_FileName;
+	
+	CVector<Tracer *> m_pCalls;
+};
+
+typedef Debugger::Tracer::trace_info trace_info_t;
+
+/**
+ * Error handler for plugins
+ */
+
+class Handler
+{
+public:
+	Handler(AMX *pAmx) : m_pAmx(pAmx), m_iErrFunc(-1), m_iModFunc(-1), m_iNatFunc(-1), m_Handling(false), m_InNativeFilter(false) {};
+	~Handler() {};
+public:
+	int SetErrorHandler(const char *function);
+	int SetNativeFilter(const char *function);
+	int SetModuleFilter(const char *function);
+public:
+	int HandleError(const char *msg);
+	int HandleNative(const char *native, int index, int trap);
+	int HandleModule(const char *module, bool isClass=false);
+public:
+	bool IsHandling() const { return m_Handling; }
+	void SetErrorMsg(const char *msg);
+	
+	const char *GetLastMsg();
+	trace_info_t *GetTrace() const { return m_pTrace; }
+	const char *GetFmtCache() { return m_FmtCache.c_str(); }
+	
+	bool IsNativeFiltering() { return (m_iNatFunc > -1); }
+	bool InNativeFilter() { return m_InNativeFilter; }
+private:
+	AMX *m_pAmx;
+	
+	int m_iErrFunc;
+	int m_iModFunc;
+	int m_iNatFunc;
+	
+	bool m_Handling;
+	
+	//in the future, make this a stack!
+	bool m_InNativeFilter;
+	
+	String m_MsgCache;
+	String m_FmtCache;
+	
+	trace_info_t *m_pTrace;
+};
+
+extern AMX_NATIVE_INFO g_DebugNatives[];
+
+#endif //_INCLUDE_DEBUGGER_H_

amxmodx/emsg.cpp

@@ -30,6 +30,7 @@
 */
 
 #include "amxmodx.h"
+#include "CMenu.h"
 
 int gmsgAmmoPickup;
 int gmsgAmmoX;
@@ -57,197 +58,242 @@ WeaponsVault g_weaponsData[MAX_WEAPONS];
 
 void Client_VGUIMenu(void* mValue)
 {
-  if (!mPlayer) return;
+	if (!mPlayer) return;
-  switch (mState++){
+
-  case 0:
+	mPlayer->vgui = true;
-    mPlayer->menu = -(*(int*)mValue);
+
-    break;
+	switch (mState++)
-  case 1:
+	{
-    mPlayer->keys = *(int*)mValue;
+		case 0:
-  }
+			mPlayer->menu = -(*(int*)mValue);
+			mPlayer->newmenu = -1;
+			break;
+		case 1:
+			mPlayer->keys = *(int*)mValue;
+	}
 }
 
 void Client_ShowMenu(void* mValue)
 {
-  if (!mPlayer) return;
+	if (!mPlayer) return;
-  switch (mState++){
+
-  case 0:
+	mPlayer->vgui = true;
-    mPlayer->keys = *(int*)mValue;
+
-    break;
+	switch (mState++)
-  case 3:
+	{
-    mPlayer->menu = g_menucmds.findMenuId( (char*)mValue );
+		case 0:
-  }
+			mPlayer->keys = *(int*)mValue;
+			break;
+		case 3:
+			{
+			mPlayer->menu = g_menucmds.findMenuId((char*)mValue);
+			mPlayer->newmenu = -1;
+			break;
+			}
+	}
 }
 
+extern bool g_bmod_tfc;
 void Client_TeamInfo(void* mValue)
 {
-  if (mPlayer) return;
+	if (mPlayer && !g_bmod_tfc) return;
-  static int index;
+	static int index;
-  switch (mState++) {
+
-  case 0:
+	switch (mState++)
-    index = *(int*)mValue;
+	{
-    break;
+		case 0:
-  case 1:
+			index = *(int*)mValue;
-	if ( index < 1 || index > gpGlobals->maxClients ) break;
+			break;
-	char* msg = (char*)mValue;
+		case 1:
-    g_players[ index ].team.assign( msg );
+			if (index < 1 || index > gpGlobals->maxClients) break;
-	g_teamsIds.registerTeam( msg , -1 );
+			char* msg = (char*)mValue;
-  }
+			g_players[index].team.assign(msg);
+			g_teamsIds.registerTeam(msg, -1);
+			g_players[index].teamId = g_teamsIds.findTeamId(msg);
+			break;
+	}
 }
 
 void Client_TextMsg(void* mValue)
 {
-	if ( mPlayer ) return;
+	if (mPlayer) return;
-	switch (mState++) {
-	case 1:{
-		char * msg = (char*)mValue;
-		if (!msg) break;
-		if ( !strncmp("#Game_C", msg , 7) ) {
-			g_game_timeleft = g_game_restarting = gpGlobals->time + 3;
-			//      g_endround_time = gpGlobals->time;
-			//      g_newround_time = gpGlobals->time + CVAR_GET_FLOAT("mp_freezetime") + 3;
-		}
-		else if (!strncmp("#Game_w", msg , 7) ) {
-			g_game_timeleft = -2;
-		}
-		else if ( !strncmp("#game_clan_s", msg , 12)  ){
-			g_game_timeleft = -3;
-		}
-		break;
-		   }
-	case 2:{
-		char * msg = (char*)mValue;
-		if (!msg) break;
-		if (g_game_timeleft == -2 ){
-			g_game_timeleft = g_game_restarting = gpGlobals->time + atoi( msg );
-			//    g_newround_time = g_game_timeleft + CVAR_GET_FLOAT("mp_freezetime");
-		}
-		else if ( g_game_timeleft == -3 )
-			g_game_restarting = atoi( msg ) * 60;
-		break;
-		   }
-	case 3:{
-		char * msg = (char*)mValue;
-		if (!msg) break;
-		if ( g_game_timeleft != -3 ) break;
-		g_game_restarting += atoi( msg );
-		g_game_timeleft = g_game_restarting	= gpGlobals->time + g_game_restarting;
-		break;
-		   }
-	}
 	
+	switch (mState++)
+	{
+		case 1:
+		{
+			char * msg = (char*)mValue;
+			if (!msg) break;
+			
+			if (!strncmp("#Game_C", msg, 7))
+			{
+				g_game_timeleft = g_game_restarting = gpGlobals->time + 3;
+				//g_endround_time = gpGlobals->time;
+				//g_newround_time = gpGlobals->time + CVAR_GET_FLOAT("mp_freezetime") + 3;
+			}
+			else if (!strncmp("#Game_w", msg, 7))
+			{
+				g_game_timeleft = -2;
+			}
+			else if (!strncmp("#game_clan_s", msg, 12))
+			{
+				g_game_timeleft = -3;
+			}
+			
+			break;
+		}
+		case 2:
+		{
+			char * msg = (char*)mValue;
+			if (!msg) break;
+			
+			if (g_game_timeleft == -2)
+			{
+				g_game_timeleft = g_game_restarting = gpGlobals->time + atoi(msg);
+				//g_newround_time = g_game_timeleft + CVAR_GET_FLOAT("mp_freezetime");
+			}
+			else if (g_game_timeleft == -3)
+				g_game_restarting = atoi(msg) * 60.0f;
+			
+			break;
+		}
+		case 3:
+		{
+			char * msg = (char*)mValue;
+			if (!msg) break;
+			if (g_game_timeleft != -3) break;
+			g_game_restarting += atoi(msg);
+			g_game_timeleft = g_game_restarting	= gpGlobals->time + g_game_restarting;
+			
+			break;
+		}
+	}
 }
 
 void Client_WeaponList(void* mValue)
 {
-  static int wpnList = 0;
+	static int wpnList = 0;
-  //static int wpnList2;
+	//static int wpnList2;
-  static int iSlot;
+	static int iSlot;
-  static const char* wpnName;
+	static const char* wpnName;
-  switch (mState++) {
-  case 0:
-    wpnName = (char*)mValue;
-    break;
-  case 1:
-    iSlot = *(int*)mValue;
-    break;
-  case 7:
-    int iId = *(int*)mValue;
-    if ( (iId < 0 || iId >= MAX_WEAPONS ) || (wpnList & (1<<iId)) )
-      break;
-    wpnList |= (1<<iId);
-    g_weaponsData[iId].iId = iId;
-    g_weaponsData[iId].ammoSlot = iSlot;
-    g_weaponsData[iId].fullName.assign(wpnName);
 	
-  }
+	switch (mState++)
+	{
+		case 0:
+			wpnName = (char*)mValue;
+			break;
+		case 1:
+			iSlot = *(int*)mValue;
+			break;
+		case 7:
+			int iId = *(int*)mValue;
+			if ((iId < 0 || iId >= MAX_WEAPONS) || (wpnList & (1<<iId)))
+			break;
+			wpnList |= (1<<iId);
+			g_weaponsData[iId].iId = iId;
+			g_weaponsData[iId].ammoSlot = iSlot;
+			g_weaponsData[iId].fullName.assign(wpnName);
+	}
 }
 
 void Client_CurWeapon(void* mValue)
 {
-  static int iState;
+	static int iState;
-  static int iId;
+	static int iId;
-  switch (mState++){
+	
-  case 0:
+	switch (mState++)
-    iState = *(int*)mValue;
+	{
-    break;
+		case 0:
-  case 1:
+			iState = *(int*)mValue;
-    if (!iState) break;
+			break;
-    iId = *(int*)mValue;
+		case 1:
-    break;
+			if (!iState) break;
-  case 2:
+			iId = *(int*)mValue;
-  if (!mPlayer) return;
+			break;
-    if (!iState || (iId < 1 || iId >= MAX_WEAPONS ) ) break;
+		case 2:
-    mPlayer->weapons[iId].clip = *(int*)mValue;
+			if (!mPlayer) return;
-    mPlayer->current = iId;
+			if (!iState || (iId < 1 || iId >= MAX_WEAPONS)) break;
-    mPlayer->lastHit = mPlayer->lastTrace;
+			mPlayer->current = iId;
-  }
+
+			
+			if (*(int*)mValue < mPlayer->weapons[iId].clip && // Only update the lastHit vector if the clip size is decreasing
+				*(int*)mValue != -1) // But not if it's a melee weapon
+			{
+				mPlayer->lastHit = mPlayer->lastTrace;
+			}
+			mPlayer->weapons[iId].clip = *(int*)mValue;
+	}
 }
 
 void Client_AmmoX(void* mValue)
 {
+	static int iAmmo;
 	
-  static int iAmmo;
+	switch (mState++)
-  switch (mState++){
+	{
-  case 0:
+		case 0:
-    iAmmo = *(int*)mValue;
+			iAmmo = *(int*)mValue;
-    break;
+			break;
-  case 1:
+		case 1:
-  if (!mPlayer) return;
+			if (!mPlayer) return;
-    for(int i=1;i<MAX_WEAPONS;++i)
+			for (int i = 1; i < MAX_WEAPONS; ++i)
-    if (iAmmo == g_weaponsData[i].ammoSlot)
+				if (iAmmo == g_weaponsData[i].ammoSlot)
-        mPlayer->weapons[i].ammo = *(int*)mValue;
+					mPlayer->weapons[i].ammo = *(int*)mValue;
-  }
+	}
 }
 
 void Client_AmmoPickup(void* mValue)
 {
-  static int iSlot;
+	static int iSlot;
-  switch (mState++){
+	
-  case 0:
+	switch (mState++)
-    iSlot = *(int*)mValue;
+	{
-    break;
+		case 0:
-  case 1:
+			iSlot = *(int*)mValue;
-  if (!mPlayer) return;
+			break;
-    for(int i=1;i<MAX_WEAPONS;++i)
+		case 1:
-    if (g_weaponsData[i].ammoSlot==iSlot)
+			if (!mPlayer) return;
-        mPlayer->weapons[i].ammo += *(int*)mValue;
+			for (int i = 1; i < MAX_WEAPONS; ++i)
-  }
+				if (g_weaponsData[i].ammoSlot==iSlot)
+					mPlayer->weapons[i].ammo += *(int*)mValue;
+	}
 }
 
 void Client_ScoreInfo(void* mValue)
 {
-  static int index;
+	static int index;
-  static int deaths;
+	static int deaths;
-  switch (mState++){
+
-  case 0:
+	switch (mState++)
-    index = *(int*)mValue;
+	{
-    break;
+		case 0:
-  case 2:
+			index = *(int*)mValue;
-    deaths = *(int*)mValue;
+			break;
-    break;
+		case 2:
-  case 4:
+			deaths = *(int*)mValue;
-	if ( index < 1 || index > gpGlobals->maxClients ) break;
+			break;
-    CPlayer*pPlayer = GET_PLAYER_POINTER_I( index );
+		case 4:
-    pPlayer->deaths = deaths;
+			if (index < 1 || index > gpGlobals->maxClients) break;
-    pPlayer->teamId = *(int*)mValue;
+			CPlayer*pPlayer = GET_PLAYER_POINTER_I(index);
-    if ( g_teamsIds.isNewTeam() )
+			pPlayer->deaths = deaths;
-      g_teamsIds.registerTeam( pPlayer->team.c_str() , pPlayer->teamId );
+			pPlayer->teamId = *(int*)mValue;
-  }
+			if (g_teamsIds.isNewTeam())
+				g_teamsIds.registerTeam(pPlayer->team.c_str(), pPlayer->teamId);
+	}
 }
 
 void Client_DamageEnd(void* mValue)
 {
 	CPlayer* dead = mPlayer;
 
-	if ( dead && dead->death_killer )
+	if (dead && dead->death_killer)
 	{
-		g_events.parserInit( CS_DEATHMSG , &gpGlobals->time , mPlayer = 0, mPlayerIndex = 0 );
+		g_events.parserInit(CS_DEATHMSG, &gpGlobals->time, mPlayer = 0, mPlayerIndex = 0);
-		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.c_str());
-		g_events.parseValue( dead->death_tk ? 1 : 0  );
+		g_events.parseValue(dead->death_tk ? 1 : 0);
 		g_events.executeEvents();
 		dead->death_killer = 0;
 	}
@@ -261,28 +307,25 @@ void Client_DeathMsg(void* mValue)
 	static int victim_id;
 	static int hs;
 	
-	switch (mState++){
+	switch (mState++)
-	case 0:
+	{
-		killer_id = *(int*)mValue;
+		case 0:
-		killer = (killer_id > 0 && killer_id < 33) ? 
+			killer_id = *(int*)mValue;
-			GET_PLAYER_POINTER_I(killer_id) : 0;
+			killer = (killer_id > 0 && killer_id < 33) ? GET_PLAYER_POINTER_I(killer_id) : 0;
-		break;
+			break;
-	case 1:
+		case 1:
-		victim_id = *(int*)mValue;
+			victim_id = *(int*)mValue;
-		victim = (victim_id > 0 && victim_id < 33) ? 
+			victim = (victim_id > 0 && victim_id < 33) ? GET_PLAYER_POINTER_I(victim_id) : 0;
-			GET_PLAYER_POINTER_I(victim_id) : 0;
+			break;
-		break;
+		case 2:	
-	case 2:	
+			hs = *(int*)mValue;
-		hs = *(int*)mValue;
+			break;
-		break;
+		case 3:
-	case 3:
+			if (!killer || !victim) break;
-		
+			victim->death_killer = killer_id;
-		if (  !killer || !victim ) break;
+			victim->death_weapon.assign((char*)mValue);
-
+			victim->death_headshot = hs;
-		victim->death_killer = killer_id;
+			victim->death_tk = (killer->teamId == victim->teamId);
-		victim->death_weapon.assign((char*)mValue);
-		victim->death_headshot = hs;
-		victim->death_tk = (killer->teamId == victim->teamId);
 	}
 }
 /*
@@ -313,4 +356,3 @@ void Client_ResetHUD(void* mValue)
 
 }
 */
-

amxmodx/fakemeta.h

@@ -31,205 +31,7 @@
 #ifndef __FAKEMETA_H__
 #define __FAKEMETA_H__
 
-#ifndef FAKEMETA
 int UnloadMetamodPlugin(void *handle);
 int LoadMetamodPlugin(const char *path, void **handle, PLUG_LOADTIME now);
-#else
-// 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 //FAKEMETA
 
 #endif // #ifndef __FAKEMETA_H__
-

amxmodx/float.cpp

@@ -368,7 +368,6 @@ static cell AMX_NATIVE_CALL n_floatatan(AMX *amx, cell *params)
 	 * 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);
@@ -425,6 +424,54 @@ static cell AMX_NATIVE_CALL n_floatatan2(AMX *amx, cell *params)
 	return amx_ftoc(fC);
 }
 
+#if defined __BORLANDC__ || defined __WATCOMC__
+  #pragma argsused
+#endif
+/* Added by DS */
+static cell AMX_NATIVE_CALL n_floatsinh(AMX *amx, cell *params)
+{
+	/*
+	 * params[1] = angle
+	 * params[2] = radix
+	 */
+	REAL fA = amx_ctof(params[1]);
+	fA = ToRadians(fA, params[2]);
+	fA = sinh(fA);
+	return amx_ftoc(fA);
+}
+
+#if defined __BORLANDC__ || defined __WATCOMC__
+  #pragma argsused
+#endif
+/* Added by DS */
+static cell AMX_NATIVE_CALL n_floatcosh(AMX *amx, cell *params)
+{
+	/*
+	 * params[1] = angle
+	 * params[2] = radix
+	 */
+	REAL fA = amx_ctof(params[1]);
+	fA = ToRadians(fA, params[2]);
+	fA = cosh(fA);
+	return amx_ftoc(fA);
+}
+
+#if defined __BORLANDC__ || defined __WATCOMC__
+  #pragma argsused
+#endif
+/* Added by DS */
+static cell AMX_NATIVE_CALL n_floattanh(AMX *amx, cell *params)
+{
+	/*
+	 * params[1] = angle
+	 * params[2] = radix
+	 */
+	REAL fA = amx_ctof(params[1]);
+	fA = ToRadians(fA, params[2]);
+	fA = tanh(fA);
+	return amx_ftoc(fA);
+}
+
 #if defined __BORLANDC__ || defined __WATCOMC__
   #pragma argsused
 #endif
@@ -457,6 +504,9 @@ AMX_NATIVE_INFO float_Natives[] = {
   { "floatacos",   n_floatacos  },
   { "floatatan",   n_floatatan  },
   { "floatatan2",  n_floatatan2 },
+  { "floatsinh",   n_floatsinh  },
+  { "floatcosh",   n_floatcosh  },
+  { "floattanh",   n_floattanh  },
   { NULL, NULL }        /* terminator */
 };
 

amxmodx/format.cpp

@@ -0,0 +1,656 @@
+#include "amxmodx.h"
+#include "format.h"
+#include "datastructs.h"
+#include "amxmod_compat.h"
+
+//Adapted from Quake3's vsprintf
+// thanks to cybermind for linking me to this :)
+//I made the following changes:
+// - Fixed spacing to be AMX Mod X standard
+// - Added 'n' support, no buffer overflows
+// - Templatized input/output buffers
+
+#define ALT			0x00000001		/* alternate form */
+#define HEXPREFIX	0x00000002		/* add 0x or 0X prefix */
+#define LADJUST		0x00000004		/* left adjustment */
+#define LONGDBL		0x00000008		/* long double */
+#define LONGINT		0x00000010		/* long integer */
+#define QUADINT		0x00000020		/* quad integer */
+#define SHORTINT	0x00000040		/* short integer */
+#define ZEROPAD		0x00000080		/* zero (as opposed to blank) pad */
+#define FPT			0x00000100		/* floating point number */
+#define UPPERDIGITS	0x00000200		/* make alpha digits uppercase */
+#define to_digit(c)		((c) - '0')
+#define is_digit(c)		((unsigned)to_digit(c) <= 9)
+#define to_char(n)		((n) + '0')
+#define CHECK_ARGS(n) \
+	if ((arg+n) > args) { \
+		LogError(amx, AMX_ERR_PARAMS, "String formatted incorrectly - parameter %d (total %d)", arg, args); \
+		return 0; \
+	}
+
+template size_t atcprintf<cell, cell>(cell *, size_t, const cell *, AMX *, cell *, int *);
+template size_t atcprintf<char, cell>(char *, size_t, const cell *, AMX *, cell *, int *);
+template size_t atcprintf<cell, char>(cell *, size_t, const char *, AMX *, cell *, int *);
+template size_t atcprintf<char, char>(char *, size_t, const char *, AMX *, cell *, int *);
+
+THash<String, lang_err> BadLang_Table;
+
+static cvar_t *amx_mldebug = NULL;
+static cvar_t *amx_cl_langs = NULL;
+
+const char *translate(AMX *amx, cell amxaddr, const char *key)
+{
+	const char *pLangName = NULL;
+	const char *def = NULL;
+	int status;
+	cell *addr = get_amxaddr(amx, amxaddr);
+	char name[4];
+	if (addr[0] == LANG_PLAYER)
+	{
+		if (!amx_cl_langs)
+			amx_cl_langs = CVAR_GET_POINTER("amx_client_languages");
+		if ( (int)amx_cl_langs->value == 0 )
+		{
+			pLangName = g_vault.get("server_language");
+		} else {
+			pLangName = ENTITY_KEYVALUE(GET_PLAYER_POINTER_I(g_langMngr.GetDefLang())->pEdict, "lang");
+		}
+	} else if (addr[0] == LANG_SERVER) {
+		pLangName = g_vault.get("server_language");
+	} else if (addr[0] >= 1 && addr[0] <= gpGlobals->maxClients) {
+		if (!amx_cl_langs)
+			amx_cl_langs = CVAR_GET_POINTER("amx_client_languages");
+		if ( (int)amx_cl_langs->value == 0 )
+		{
+			pLangName = g_vault.get("server_language");
+		} else {
+			pLangName = ENTITY_KEYVALUE(GET_PLAYER_POINTER_I(addr[0])->pEdict, "lang");
+		}
+	} else {
+		get_amxstring_r(amx, amxaddr, name, 3);
+		pLangName = name;
+	}
+	if (!pLangName || !isalpha(pLangName[0]))
+		pLangName = "en";
+	//next parameter!
+	def = g_langMngr.GetDef(pLangName, key, status);
+			
+	if (!amx_mldebug)
+		amx_mldebug = CVAR_GET_POINTER("amx_mldebug");
+
+	bool debug = (amx_mldebug && amx_mldebug->string && (amx_mldebug->string[0] != '\0'));
+		
+	if (debug)
+	{
+		int debug_status;
+		bool validlang = true;
+		const char *testlang = amx_mldebug->string;
+		if (!g_langMngr.LangExists(testlang))
+		{
+			AMXXLOG_Error("[AMXX] \"%s\" is an invalid debug language", testlang);
+			validlang = false;
+		}
+				
+		g_langMngr.GetDef(testlang, key, debug_status);
+				
+		if (validlang && debug_status == ERR_BADKEY)
+			AMXXLOG_Error("[AMXX] Language key \"%s\" not found for language \"%s\", check \"%s\"", key, testlang, GetFileName(amx));
+	}
+				
+	if (def == NULL)
+	{
+		if (debug)
+		{
+			if (status == ERR_BADLANG && (BadLang_Table.AltFindOrInsert(pLangName).last + 120.0f < gpGlobals->time))
+			{
+				AMXXLOG_Error("[AMXX] Language \"%s\" not found", pLangName);
+				BadLang_Table.AltFindOrInsert(pLangName).last = gpGlobals->time;
+			}
+		}
+
+		if (addr[0] != LANG_SERVER)
+			def = g_langMngr.GetDef(g_vault.get("server_language"), key, status);
+		
+		if (!def && (strcmp(pLangName, "en") != 0 && strcmp(g_vault.get("server_language"), "en") != 0))
+			def = g_langMngr.GetDef("en", key, status);
+	}
+
+	return def;
+}
+
+template <typename U>
+void AddString(U **buf_p, size_t &maxlen, const cell *string, int width, int prec)
+{
+	int		size = 0;
+	U		*buf;
+	static cell nlstr[] = {'(','n','u','l','l',')','\0'};
+
+	buf = *buf_p;
+
+	if (string == NULL)
+	{
+		string = nlstr;
+		prec = -1;
+	}
+
+	if (prec >= 0)
+	{
+		for (size = 0; size < prec; size++) 
+		{
+			if (string[size] == '\0')
+				break;
+		}
+	} else {
+		while (string[size++]) ;
+		size--;
+	}
+
+	if (size > (int)maxlen)
+		size = maxlen;
+
+	maxlen -= size;
+	width -= size;
+
+	while (size--)
+		*buf++ = static_cast<U>(*string++);
+
+	while (width-- > 0 && maxlen)
+	{
+		*buf++ = ' ';
+		maxlen--;
+	}
+
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddFloat(U **buf_p, size_t &maxlen, double fval, int width, int prec, int flags)
+{
+	int digits;				// non-fraction part digits
+	double tmp;				// temporary
+	U *buf = *buf_p;			// output buffer pointer
+	int val;				// temporary
+	int sign = 0;				// 0: positive, 1: negative
+	int fieldlength;			// for padding
+	int significant_digits = 0;		// number of significant digits written
+	const int MAX_SIGNIFICANT_DIGITS = 16;
+
+	// default precision
+	if (prec < 0)
+	{
+		prec = 6;
+	}
+
+	// get the sign
+	if (fval < 0)
+	{
+		fval = -fval;
+		sign = 1;
+	}
+
+	// compute whole-part digits count
+	digits = (int)log10(fval) + 1;
+
+	// Only print 0.something if 0 < fval < 1
+	if (digits < 1)
+	{
+		digits = 1;
+	}
+
+	// compute the field length
+	fieldlength = digits + prec + ((prec > 0) ? 1 : 0) + sign;
+
+	// minus sign BEFORE left padding if padding with zeros
+	if (sign && maxlen && (flags & ZEROPAD))
+	{
+		*buf++ = '-';
+		maxlen--;
+	}
+
+	// right justify if required
+	if ((flags & LADJUST) == 0)
+	{
+		while ((fieldlength < width) && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	// minus sign AFTER left padding if padding with spaces
+	if (sign && maxlen && !(flags & ZEROPAD))
+	{
+		*buf++ = '-';
+		maxlen--;
+	}
+
+	// write the whole part
+	tmp = pow(10.0, digits-1);
+	while ((digits--) && maxlen)
+	{
+		if (++significant_digits > MAX_SIGNIFICANT_DIGITS)
+		{
+			*buf++ = '0';
+		}
+		else
+		{
+			val = (int)(fval / tmp);
+			*buf++ = '0' + val;
+			fval -= val * tmp;
+			tmp *= 0.1;
+		}
+		maxlen--;
+	}
+
+	// write the fraction part
+	if (maxlen && prec)
+	{
+		*buf++ = '.';
+		maxlen--;
+	}
+
+	tmp = pow(10.0, prec);
+
+	fval *= tmp;
+	while (prec-- && maxlen)
+	{
+		if (++significant_digits > MAX_SIGNIFICANT_DIGITS)
+		{
+			*buf++ = '0';
+		}
+		else
+		{
+			tmp *= 0.1;
+			val = (int)(fval / tmp);
+			*buf++ = '0' + val;
+			fval -= val * tmp;
+		}
+		maxlen--;
+	}
+
+	// left justify if required
+	if (flags & LADJUST)
+	{
+		while ((fieldlength < width) && maxlen)
+		{
+			// right-padding only with spaces, ZEROPAD is ignored
+			*buf++ = ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	// update parent's buffer pointer
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddUInt(U **buf_p, size_t &maxlen, unsigned int val, int width, int flags)
+{
+	U		text[32];
+	int		digits;
+	U		*buf;
+
+	digits = 0;
+	do {
+		text[digits++] = '0' + val % 10;
+		val /= 10;
+	} while (val);
+
+	buf = *buf_p;
+
+	if( !(flags & LADJUST) )
+	{
+		while (digits < width && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	while (digits-- && maxlen)
+	{
+		*buf++ = text[digits];
+		width--;
+		maxlen--;
+	}
+
+	if (flags & LADJUST)
+	{
+		while (width-- && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			maxlen--;
+		}
+	}
+
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddInt(U **buf_p, size_t &maxlen, int val, int width, int flags)
+{
+	U		text[32];
+	int		digits;
+	int		signedVal;
+	U		*buf;
+	unsigned int unsignedVal;
+
+	digits = 0;
+	signedVal = val;
+	if (val < 0)
+	{
+		/* we want the unsigned version */
+		unsignedVal = abs(val);
+	} else {
+		unsignedVal = val;
+	}
+	do {
+		text[digits++] = '0' + unsignedVal % 10;
+		unsignedVal /= 10;
+	} while (unsignedVal);
+
+	if (signedVal < 0)
+		text[digits++] = '-';
+
+	buf = *buf_p;
+
+	if( !(flags & LADJUST) )
+	{
+		while (digits < width && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	while (digits-- && maxlen)
+	{
+		*buf++ = text[digits];
+		width--;
+		maxlen--;
+	}
+
+	if (flags & LADJUST)
+	{
+		while (width-- && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			maxlen--;
+		}
+	}
+
+	*buf_p = buf;
+}
+
+template <typename U>
+void AddHex(U **buf_p, size_t &maxlen, unsigned int val, int width, int flags)
+{
+	U		text[32];
+	int		digits;
+	U		*buf;
+	U		digit;
+	int		hexadjust;
+
+	if (flags & UPPERDIGITS)
+	{
+		hexadjust = 'A' - '9' - 1;
+	} else {
+		hexadjust = 'a' - '9' - 1;
+	}
+
+	digits = 0;
+	do
+	{
+		digit = ('0' + val % 16);
+		if (digit > '9')
+		{
+			digit += hexadjust;
+		}
+
+		text[digits++] = digit;
+		val /= 16;
+	} while (val);
+
+	buf = *buf_p;
+
+	if( !(flags & LADJUST) )
+	{
+		while (digits < width && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			width--;
+			maxlen--;
+		}
+	}
+
+	while (digits-- && maxlen)
+	{
+		*buf++ = text[digits];
+		width--;
+		maxlen--;
+	}
+
+	if (flags & LADJUST)
+	{
+		while (width-- && maxlen)
+		{
+			*buf++ = (flags & ZEROPAD) ? '0' : ' ';
+			maxlen--;
+		}
+	}
+
+	*buf_p = buf;
+}
+
+template <typename D, typename S>
+size_t atcprintf(D *buffer, size_t maxlen, const S *format, AMX *amx, cell *params, int *param)
+{
+	int		arg;
+	int		args = params[0] / sizeof(cell);
+	D		*buf_p;
+	D		ch;
+	int		flags;
+	int		width;
+	int		prec;
+	int		n;
+	char	sign;
+	const S	*fmt;
+	size_t	llen = maxlen;
+
+	buf_p = buffer;
+	arg = *param;
+	fmt = format;
+
+	while (true)
+	{
+		// run through the format string until we hit a '%' or '\0'
+		for (ch = static_cast<D>(*fmt); 
+			llen && ((ch = static_cast<D>(*fmt)) != '\0' && ch != '%');
+			fmt++)
+		{
+			*buf_p++ = static_cast<D>(ch);
+			llen--;
+		}
+		if (ch == '\0' || llen <= 0)
+			goto done;
+
+		// skip over the '%'
+		fmt++;
+
+		// reset formatting state
+		flags = 0;
+		width = 0;
+		prec = -1;
+		sign = '\0';
+
+rflag:
+		ch = static_cast<D>(*fmt++);
+reswitch:
+		switch(ch)
+		{
+		case '-':
+			flags |= LADJUST;
+			goto rflag;
+		case '.':
+			n = 0;
+			while( is_digit( ( ch = static_cast<D>(*fmt++)) ) )
+				n = 10 * n + ( ch - '0' );
+			prec = n < 0 ? -1 : n;
+			goto reswitch;
+		case '0':
+			flags |= ZEROPAD;
+			goto rflag;
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			n = 0;
+			do {
+				n = 10 * n + ( ch - '0' );
+				ch = static_cast<D>(*fmt++);
+			} while( is_digit( ch ) );
+			width = n;
+			goto reswitch;
+		case 'c':
+			CHECK_ARGS(0);
+			*buf_p++ = static_cast<D>(*get_amxaddr(amx, params[arg]));
+			llen--;
+			arg++;
+			break;
+		case 'd':
+		case 'i':
+			CHECK_ARGS(0);
+			AddInt(&buf_p, llen, *get_amxaddr(amx, params[arg]), width, flags);
+			arg++;
+			break;
+		case 'u':
+			CHECK_ARGS(0);
+			AddUInt(&buf_p, llen, static_cast<unsigned int>(*get_amxaddr(amx, params[arg])), width, flags);
+			arg++;
+			break;
+		case 'f':
+			CHECK_ARGS(0);
+			AddFloat(&buf_p, llen, amx_ctof(*get_amxaddr(amx, params[arg])), width, prec, flags);
+			arg++;
+			break;
+		case 'X':
+			CHECK_ARGS(0);
+			flags |= UPPERDIGITS;
+			AddHex(&buf_p, llen, static_cast<unsigned int>(*get_amxaddr(amx, params[arg])), width, flags);
+			arg++;
+			break;
+		case 'x':
+			CHECK_ARGS(0);
+			AddHex(&buf_p, llen, static_cast<unsigned int>(*get_amxaddr(amx, params[arg])), width, flags);
+			arg++;
+			break;
+		case 'a':
+			{
+				CHECK_ARGS(0);
+				// %a is passed a pointer directly to a cell string.
+				cell* ptr=reinterpret_cast<cell*>(*get_amxaddr(amx, params[arg]));
+				if (!ptr)
+				{
+					LogError(amx, AMX_ERR_NATIVE, "Invalid vector string handle provided (%d)", *get_amxaddr(amx, params[arg]));
+					return 0;
+				}
+
+				AddString(&buf_p, llen, ptr, width, prec);
+				arg++;
+				break;
+			}
+		case 's':
+			CHECK_ARGS(0);
+			if (amx->flags & AMX_FLAG_OLDFILE)
+			{
+				cell *addr = get_amxaddr(amx, params[arg]);
+				if (*addr & BCOMPAT_TRANSLATE_BITS)
+				{
+					const char *key, *def;
+					if (!translate_bcompat(amx, addr, &key, &def))
+					{
+						goto break_to_normal_string;
+					}
+					arg++;
+					size_t written = atcprintf(buf_p, llen, def, amx, params, &arg);
+					buf_p += written;
+					llen -= written;
+					break;
+				}
+			}
+break_to_normal_string:
+			AddString(&buf_p, llen, get_amxaddr(amx, params[arg]), width, prec);
+			arg++;
+			break;
+		case 'L':
+			{
+				CHECK_ARGS(1);
+				cell addr = params[arg++];
+				int len;
+				const char *key = get_amxstring(amx, params[arg++], 3, len);
+				const char *def = translate(amx, addr, key);
+				if (!def)
+				{
+					static char buf[255];
+					snprintf(buf, sizeof(buf)-1, "ML_NOTFOUND: %s", key);
+					def = buf;
+				}
+				size_t written = atcprintf(buf_p, llen, def, amx, params, &arg);
+				buf_p += written;
+				llen -= written;
+				break;
+			}
+		case '%':
+			*buf_p++ = static_cast<D>(ch);
+			if (!llen)
+				goto done;
+			llen--;
+			break;
+		case '\0':
+			*buf_p++ = static_cast<D>('%');
+			if (!llen)
+				goto done;
+			llen--;
+			goto done;
+			break;
+		default:
+			*buf_p++ = static_cast<D>(ch);
+			if (!llen)
+				goto done;
+			llen--;
+			break;
+		}
+	}
+
+done:
+	*buf_p = static_cast<D>(0);
+	*param = arg;
+	return maxlen-llen;
+}
+
+/**
+ * HACKHACK: The compiler will generate code for each case we need.
+ * Don't remove this, otherwise files that use certain code generations
+ *  will have extern problems.  For each case you need, add dummy code
+ *  here.
+ */
+void __WHOA_DONT_CALL_ME_PLZ_K_lol_o_O()
+{
+	//acsprintf
+	atcprintf((cell *)NULL, 0, (const char *)NULL, NULL, NULL, NULL);
+	//accprintf
+	atcprintf((cell *)NULL, 0, (cell *)NULL, NULL, NULL, NULL);
+	//ascprintf
+	atcprintf((char *)NULL, 0, (cell *)NULL, NULL, NULL, NULL);
+}
+

amxmodx/format.h

@@ -0,0 +1,11 @@
+#ifndef _INCLUDE_FORMATTING_H
+#define _INCLUDE_FORMATTING_H
+
+//Amx Templatized Cell Printf
+template <typename D, typename S>
+size_t atcprintf(D *buffer, size_t maxlen, const S *format, AMX *amx, cell *params, int *param);
+
+const char *translate(AMX *amx, cell amxaddr, const char *key);
+bool translate_bcompat(AMX *amx, cell *source, const char **_key, const char **_def);
+
+#endif //_INCLUDE_FORMATTING_H

amxmodx/helpers-x86.asm

@@ -0,0 +1,51 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; (C)2006 by David "BAILOPAN" Anderson			 ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;Licensed under the GNU General Public License, version 2
+;;This is a portion of AMX Mod X 
+;; and is maintained by the AMX Mod X development team.
+
+section .text
+
+global amxx_CpuSupport, _amxx_CpuSupport
+
+amxx_CpuSupport:
+_amxx_CpuSupport:
+	push	ebp
+	mov		ebp, esp
+	
+	push	ebx
+	
+	mov		eax, 0
+	cpuid
+	cmp		eax, 1
+	jl		.fail
+	
+	mov		eax, 1
+	cpuid
+	;check if family == 5 or 4
+	and		eax, 0780h	;family mask
+	shr		eax, 7		;family shift
+	cmp		eax, 5
+	je		.fail
+	cmp		eax, 4
+	je		.fail
+	;check if CMOV exists
+	shr		edx, 15
+	and		edx, 1
+	cmp		edx, 0
+	je		.fail
+	
+	mov		eax, 1
+	jmp		.end
+
+.fail:
+	xor		eax, eax
+	
+.end:
+	
+	pop		ebx
+
+	pop		ebp
+	ret

amxmodx/libraries.cpp

@@ -0,0 +1,243 @@
+#include "libraries.h"
+#include "sh_list.h"
+
+List<Library *> g_libraries;
+
+bool AddLibrary(const char *name, LibType type, LibSource src, void *parent)
+{
+	if (FindLibrary(name, type))
+		return false;
+
+	Library *lib = new Library;
+
+	lib->name.assign(name);
+	lib->type = type;
+	lib->src = src;
+	lib->parent = parent;
+
+	g_libraries.push_back(lib);
+	
+	return true;
+}
+
+bool DecodeLibCmdString(const char *str, LibDecoder *dec)
+{
+	if (dec->buffer)
+	{
+		free(dec->buffer);
+		dec->buffer = NULL;
+	}
+	if (str[0] != '?')
+	{
+		return false;
+	} else {
+		str++;
+		if (*str == 'r')
+		{
+			str++;
+			if (*str == 'c')
+				dec->cmd = LibCmd_ReqClass;
+			else if (*str == 'l')
+				dec->cmd = LibCmd_ReqLib;
+			else
+				return false;
+			str++;
+		} else if (*str == 'f') {
+			str++;
+			dec->cmd = LibCmd_ForceLib;
+		} else if (*str == 'e') {
+			str++;
+			if (*str == 'c')
+				dec->cmd = LibCmd_ExpectClass;
+			else if (*str == 'l')
+				dec->cmd = LibCmd_ExpectLib;
+			else
+				return false;
+			str++;
+		} else if (*str == 'd') {
+			str++;
+			dec->cmd = LibCmd_DefaultLib;
+		}
+		if (*str != '_')
+			return false;
+		str++;
+		if (dec->cmd < LibCmd_ExpectLib)
+		{
+			dec->buffer = strdup(str);
+			dec->param1 = dec->buffer;
+			dec->param2 = NULL;
+		} else {
+			dec->buffer = strdup(str);
+			char *p = strchr(dec->buffer, '_');
+			while (p && (*(p+1) == '_'))
+				p = strchr(p+2, '_');
+			if (!p || !*(p+1))
+				return false;
+			*p = '\0';
+			dec->param1 = dec->buffer;
+			dec->param2 = p+1;
+		}
+	}
+
+	return true;
+}
+
+size_t AddLibrariesFromString(const char *name, LibType type, LibSource src, void *parent)
+{
+	char buffer[255];
+	char *ptr, *p, s;
+	size_t count = 0;
+
+	snprintf(buffer, sizeof(buffer)-1, "%s", name);
+
+	ptr = buffer;
+	p = buffer;
+	while (*p)
+	{
+		while (*p && (*p != ','))
+			p++;
+		s = *p;
+		*p = '\0';
+		if (AddLibrary(ptr, type, src, parent))
+			count++;
+		if (!s)
+			break;
+		p++;
+		while (*p && (*p == ','))
+			p++;
+		ptr = p;
+	}
+
+	return count;
+}
+
+size_t ClearLibraries(LibSource src)
+{
+	List<Library *>::iterator iter;
+	size_t count = 0;
+
+	iter = g_libraries.begin();
+	while (iter != g_libraries.end())
+	{
+		if ( (*iter)->src == src )
+		{
+			delete (*iter);
+			iter = g_libraries.erase(iter);
+			count++;
+		} else {
+			iter++;
+		}
+	}
+
+	return count;
+}
+
+size_t RemoveLibraries(void *parent)
+{
+	List<Library *>::iterator iter;
+	Library *lib;
+	size_t count = 0;
+
+	iter = g_libraries.begin();
+	while (iter != g_libraries.end())
+	{
+		lib = (*iter);
+		if (lib->parent == parent)
+		{
+			delete (*iter);
+			iter = g_libraries.erase(iter);
+			count++;
+		} else {
+			iter++;
+		}
+	}
+
+	return count;
+}
+
+bool FindLibrary(const char *name, LibType type)
+{
+	List<Library *>::iterator iter;
+	Library *lib;
+
+	for (iter = g_libraries.begin(); iter != g_libraries.end(); iter++)
+	{
+		lib = (*iter);
+		if (lib->type != type)
+			continue;
+		if (strcasecmp(lib->name.c_str(), name) == 0)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+LibError RunLibCommand(const LibDecoder *enc)
+{
+	List<Library *>::iterator iter,end;
+	Library *lib;
+	
+	iter = g_libraries.begin();
+	end = g_libraries.end();
+
+	if ( (enc->cmd == LibCmd_ReqLib) || (enc->cmd == LibCmd_ReqClass) )
+	{
+		LibType expect = LibType_Library;
+
+		if (enc->cmd == LibCmd_ReqLib)
+			expect = LibType_Library;
+		else if (enc->cmd == LibCmd_ReqClass)
+			expect = LibType_Class;
+
+		/** see if it exists */
+		for (; iter != end; iter++)
+		{
+			lib = (*iter);
+			if (lib->type != expect)
+				continue;
+			if (strcasecmp(lib->name.c_str(), enc->param1) == 0)
+				return LibErr_None;
+		}
+		if (expect == LibType_Library)
+			return LibErr_NoLibrary;
+		else if (expect == LibType_Class)
+			return LibErr_NoClass;
+
+		return LibErr_NoLibrary;
+	} else if (enc->cmd == LibCmd_ForceLib) {
+		if (!LoadModule(enc->param1, PT_ANYTIME, true, true))
+		{
+			return LibErr_NoLibrary;
+		}
+	} else if ( (enc->cmd == LibCmd_DefaultLib) || 
+				((enc->cmd == LibCmd_ExpectLib) || (enc->cmd == LibCmd_ExpectClass)) )
+	{
+		LibType expect;
+
+		if (enc->cmd == LibCmd_ExpectLib)
+			expect = LibType_Library;
+		else
+			expect = LibType_Class;
+
+		/** see if it exists */
+		for (; iter != end; iter++)
+		{
+			lib = (*iter);
+			if (lib->type != expect)
+				continue;
+			if (strcasecmp(lib->name.c_str(), enc->param1) == 0)
+				return LibErr_None;
+		}
+
+		if (!LoadModule(enc->param2, PT_ANYTIME, true, true))
+		{
+			return LibErr_NoLibrary;
+		}
+
+		return LibErr_None;
+	}
+
+	return LibErr_None;
+}

amxmodx/libraries.h

@@ -0,0 +1,73 @@
+#ifndef _INCLUDE_LIBRARIES_H
+#define _INCLUDE_LIBRARIES_H
+
+#include <string.h>
+#include "amxmodx.h"
+#include "CString.h"
+
+enum LibSource
+{
+	LibSource_Plugin,
+	LibSource_Module
+};
+
+enum LibType
+{
+	LibType_Library,
+	LibType_Class
+};
+
+struct Library
+{
+	String name;
+	LibSource src;
+	LibType type;
+	void *parent;
+};
+
+enum LibCmd
+{
+	LibCmd_ReqLib,
+	LibCmd_ReqClass,
+	LibCmd_ForceLib,
+	LibCmd_ExpectLib,
+	LibCmd_ExpectClass,
+	LibCmd_DefaultLib,
+};
+
+enum LibError
+{
+	LibErr_None = 0,
+	LibErr_NoLibrary,
+	LibErr_NoClass,
+};
+
+class LibDecoder
+{
+public:
+	LibDecoder() : buffer(NULL)
+	{
+	}
+	~LibDecoder()
+	{
+		free(buffer);
+		buffer = NULL;
+		param1 = NULL;
+		param2 = NULL;
+	}
+	char *buffer;
+	char *param1;
+	char *param2;
+	LibCmd cmd;
+};
+
+bool AddLibrary(const char *name, LibType type, LibSource src, void *parent=NULL);
+bool DecodeLibCmdString(const char *str, LibDecoder *cmd);
+size_t AddLibrariesFromString(const char *name, LibType type, LibSource src, void *parent=NULL);
+size_t ClearLibraries(LibSource src);
+LibError RunLibCommand(const LibDecoder *enc);
+size_t RemoveLibraries(void *parent);
+bool FindLibrary(const char *name, LibType type);
+
+
+#endif //_INCLUDE_LIBRARIES_H

amxmodx/md5.cpp

@@ -111,7 +111,7 @@ void MD5::update(FILE *file){
   unsigned char buffer[1024];
   int len;
 
-  while (len=fread(buffer, 1, 1024, file))
+  while ((len=fread(buffer, 1, 1024, file)))
     update(buffer, len);
 
   fclose (file);
@@ -185,7 +185,7 @@ unsigned char *MD5::raw_digest(){
 
 
 
-char *MD5::hex_digest(){
+const char *MD5::hex_digest(){
 
   int i;
   char *s= new char[33];
@@ -205,7 +205,7 @@ char *MD5::hex_digest(){
 }
 
 
-char *MD5::hex_digest(char buffer[33]){
+const char *MD5::hex_digest(char buffer[33]){
 
   int i;
 

amxmodx/md5.h

@@ -59,8 +59,8 @@ public:
 
 // 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
+  const char       *hex_digest ();  // digest as a 33-byte ascii-hex string
-  char *			hex_digest (char buffer[33]); //same as above, passing buffer
+  const char       *hex_digest (char buffer[33]); //same as above, passing buffer
 
 
 

amxmodx/messages.cpp

@@ -0,0 +1,835 @@
+#include "amxmodx.h"
+#include "messages.h"
+
+Message Msg;
+//CVector<int> msgHooks[256];
+RegisteredMessage msgHooks[256];
+int msgBlocks[256] = {BLOCK_NOT};
+int msgDest;
+int msgType;
+float *msgOrigin;
+edict_t *msgpEntity;
+bool inhook = false;
+bool inblock = false;
+enginefuncs_t *g_pEngTable = NULL;
+
+void ClearMessages()
+{
+	for (size_t i=0; i<MAX_MESSAGES; i++)
+	{
+		msgHooks[i].Clear();
+		msgBlocks[i] = BLOCK_NOT;
+	}
+}
+
+Message::Message()
+{
+	m_CurParam = 0;
+}
+
+bool Message::Ready()
+{
+	if (!m_Params.size())
+		return false;
+	return true;
+}
+
+void Message::Init()
+{
+	if (!Ready())
+	{
+		msgparam *p = new msgparam;
+		m_Params.push_back(p);
+	}
+	m_CurParam = 0;
+}
+
+Message::~Message()
+{
+	for (size_t i=0; i<m_Params.size(); i++)
+		delete m_Params[i];
+	
+	m_Params.clear();
+}
+
+msgparam *Message::AdvPtr()
+{
+	msgparam *pParam = NULL;
+
+	if (++m_CurParam >= m_Params.size())
+	{
+		pParam = new msgparam;
+		m_Params.push_back(pParam);
+	} else {
+		pParam = m_Params[m_CurParam];
+	}
+
+	return pParam;
+}
+
+void Message::AddParam(const char *data, msgtype type)
+{
+	msgparam *pParam = AdvPtr();
+
+	pParam->szData.assign(data);
+	pParam->type = type;
+}
+
+void Message::AddParam(int data, msgtype type)
+{
+	msgparam *pParam = AdvPtr();
+	
+	pParam->v.iData = data;
+	pParam->type = type;
+}
+
+void Message::AddParam(float data, msgtype type)
+{
+	msgparam *pParam = AdvPtr();
+
+	pParam->v.fData = data;
+	pParam->type = type;
+}
+
+msgtype Message::GetParamType(size_t index)
+{
+	if (index < 1 || index > m_CurParam)
+		return static_cast<msgtype>(0);
+
+	return m_Params[index]->type;
+}
+
+float Message::GetParamFloat(size_t index)
+{
+	if (index < 1 || index > m_CurParam)
+		return 0;
+
+	return m_Params[index]->v.fData;
+}
+
+const char *Message::GetParamString(size_t index)
+{
+	if (index < 1 || index > m_CurParam)
+		return 0;
+
+	return m_Params[index]->szData.c_str();
+}
+
+int Message::GetParamInt(size_t index)
+{
+	if (index < 1 || index > m_CurParam)
+		return 0;
+
+	return m_Params[index]->v.iData;
+}
+
+void Message::SetParam(size_t index, float data)
+{
+	if (index < 1 || index > m_CurParam)
+		return;
+
+	m_Params[index]->v.fData = data;
+}
+
+void Message::SetParam(size_t index, int data)
+{
+	if (index < 1 || index > m_CurParam)
+		return;
+
+	m_Params[index]->v.iData = data;
+}
+
+void Message::SetParam(size_t index, const char *data)
+{
+	if (index < 1 || index > m_CurParam)
+		return;
+
+	m_Params[index]->szData.assign(data);
+}
+
+void Message::Reset()
+{
+	m_CurParam = 0;
+}
+
+size_t Message::Params()
+{
+	return m_CurParam;
+}
+
+void Message::Send()
+{
+	msgparam *pParam = NULL;
+
+	for (size_t i=1; i<=m_CurParam; i++)
+	{
+		pParam = m_Params[i];
+		switch (pParam->type)
+		{
+		case arg_byte:
+			WRITE_BYTE(pParam->v.iData);
+			break;
+		case arg_char:
+			WRITE_CHAR(pParam->v.iData);
+			break;
+		case arg_short:
+			WRITE_SHORT(pParam->v.iData);
+			break;
+		case arg_long:
+			WRITE_LONG(pParam->v.iData);
+			break;
+		case arg_angle:
+			WRITE_ANGLE(pParam->v.fData);
+			break;
+		case arg_coord:
+			WRITE_COORD(pParam->v.fData);
+			break;
+		case arg_string:
+			WRITE_STRING(pParam->szData.c_str());
+			break;
+		case arg_entity:
+			WRITE_ENTITY(pParam->v.iData);
+			break;
+		}
+	}
+}
+
+void C_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed)
+{
+	if (msgBlocks[msg_type])
+	{
+		inblock = true;
+		msgType = msg_type;
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (msgHooks[msg_type].Hooked()) {
+		inhook = true;
+		msgDest = msg_dest;
+		msgType = msg_type;
+		msgOrigin = (float *)pOrigin;
+		msgpEntity = ed;
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteByte(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_byte);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteChar(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_char);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteShort(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_short);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteLong(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_long);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteAngle(float flValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(flValue, arg_angle);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteCoord(float flValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(flValue, arg_coord);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteString(const char *sz)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(sz, arg_string);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_WriteEntity(int iValue)
+{
+	if (inblock)
+	{
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+		Msg.AddParam(iValue, arg_entity);
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void C_MessageEnd(void)
+{
+	int mres = 0;
+	
+	if (inblock)
+	{
+		inblock = false;
+		if (msgBlocks[msgType] == BLOCK_ONCE)
+		{
+			msgBlocks[msgType] = BLOCK_NOT;
+		}
+		RETURN_META(MRES_SUPERCEDE);
+	} else if (inhook) {
+
+		mres = msgHooks[msgType].Execute((cell)msgType, (cell)msgDest, (cell)ENTINDEX(msgpEntity));
+
+		/*
+		for (i=0; i<msgHooks[msgType].size(); i++)
+		{
+				mresB = executeForwards(msgHooks[msgType].at(i), (cell)msgType, (cell)msgDest, (cell)ENTINDEX(msgpEntity));
+				if (mresB > mres)
+						mres = mresB;
+		}
+		*/
+		inhook = false;
+		if (mres & 1)
+		{
+			Msg.Reset();
+			RETURN_META(MRES_SUPERCEDE);
+		}
+
+		/* send the real message */
+		MESSAGE_BEGIN(msgDest, msgType, msgOrigin, msgpEntity);
+		Msg.Send();
+		MESSAGE_END();
+
+		/* reset */
+		Msg.Reset();
+
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+static cell AMX_NATIVE_CALL message_begin(AMX *amx, cell *params) /* 4 param */
+{
+	int numparam = *params / sizeof(cell);
+	float vecOrigin[3];
+	cell *cpOrigin;
+
+	if (params[2] < 1 || ((params[2] > 63)		// maximal number of engine messages
+		&& !GET_USER_MSG_NAME(PLID, params[2], NULL)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Plugin called message_begin with an invalid message id (%d).", params[2]);
+		return 0;
+	}
+
+	switch (params[1])
+	{
+	case MSG_BROADCAST:
+	case MSG_ALL:
+	case MSG_SPEC:
+		MESSAGE_BEGIN(params[1], params[2], NULL);
+		break;
+	case MSG_PVS: case MSG_PAS:
+	case MSG_PVS_R: case MSG_PAS_R:
+		if (numparam < 3)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed");
+			return 0;
+		}
+
+		cpOrigin = get_amxaddr(amx, params[3]);
+
+		vecOrigin[0] = static_cast<float>(*cpOrigin);
+		vecOrigin[1] = static_cast<float>(*(cpOrigin + 1));
+		vecOrigin[2] = static_cast<float>(*(cpOrigin + 2));
+
+		MESSAGE_BEGIN(params[1], params[2], vecOrigin);
+
+		break;
+	case MSG_ONE_UNRELIABLE:
+	case MSG_ONE:
+		if (numparam < 4)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed");
+			return 0;
+		}
+
+		MESSAGE_BEGIN(params[1], params[2], NULL, INDEXENT(params[4]));
+		break;
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL message_end(AMX *amx, cell *params)
+{
+	MESSAGE_END();
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_byte(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_BYTE(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_char(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_CHAR(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_short(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_SHORT(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_long(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_LONG(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_entity(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_ENTITY(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_angle(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_ANGLE(static_cast<float>(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_coord(AMX *amx, cell *params) /* 1 param */
+{
+	WRITE_COORD(static_cast<float>(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL write_string(AMX *amx, cell *params) /* 1 param */
+{
+	int a;
+	WRITE_STRING(get_amxstring(amx, params[1], 3, a));
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL register_message(AMX *amx, cell *params)
+{
+	int len;
+	char *name = get_amxstring(amx, params[2], 0, len);
+
+	if (!Msg.Ready())
+		Msg.Init();
+
+	if (params[1]>0 && params[1] < 256)
+	{
+		int id = registerSPForwardByName(amx, name, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+		if (id != -1)
+		{
+			msgHooks[params[1]].AddHook(id);
+			return id;
+		} else {
+			LogError(amx, AMX_ERR_NOTFOUND, "Could not find function \"%s\"", name);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+// unregister_message(msgid, msghandle)
+static cell AMX_NATIVE_CALL unregister_message(AMX *amx, cell *params)
+{
+	if (!Msg.Ready())
+		Msg.Init();
+
+	if (params[1]>0 && params[1] < 256)
+	{
+		int id = params[2];
+		if (id != -1)
+		{
+			msgHooks[params[1]].RemoveHook(id);
+			return id;
+		} else {
+			LogError(amx, AMX_ERR_NOTFOUND, "Invalid registered message handle");
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+
+static cell AMX_NATIVE_CALL set_msg_block(AMX *amx, cell *params)
+{
+	int msgid = params[1];
+	int block = params[2];
+
+	if (msgid < 1 || msgid > 255)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message id");
+		return 0;
+	}
+
+	msgBlocks[msgid] = block;
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_msg_block(AMX *amx, cell *params)
+{
+	int msgid = params[1];
+
+	if (msgid < 1 || msgid > 255)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message id");
+		return 0;
+	}
+
+	return msgBlocks[msgid];
+}
+
+static cell AMX_NATIVE_CALL get_msg_args(AMX *amx, cell *params)
+{
+	return Msg.Params();
+}
+
+static cell AMX_NATIVE_CALL get_msg_argtype(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	return Msg.GetParamType(argn);
+}
+
+static cell AMX_NATIVE_CALL get_msg_arg_int(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	return Msg.GetParamInt(argn);
+}
+
+static cell AMX_NATIVE_CALL set_msg_arg_int(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	Msg.SetParam(argn, (int)params[3]);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_msg_arg_float(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	REAL f = (REAL)Msg.GetParamFloat(argn);
+	return amx_ftoc(f);
+}
+
+static cell AMX_NATIVE_CALL set_msg_arg_float(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	REAL fVal = amx_ctof(params[3]);
+
+	Msg.SetParam(argn, (float)fVal);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_msg_arg_string(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	const char *szVal = Msg.GetParamString(argn);
+
+	return set_amxstring(amx, params[2], szVal, params[3]);
+}
+
+static cell AMX_NATIVE_CALL set_msg_arg_string(AMX *amx, cell *params)
+{
+	size_t argn = static_cast<size_t>(params[1]);
+	int iLen;
+
+	if (!inhook || argn > Msg.Params())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid message argument %d", argn);
+		return 0;
+	}
+
+	char *szVal = get_amxstring(amx, params[2], 0, iLen);
+
+	Msg.SetParam(argn, szVal);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_msg_origin(AMX *amx, cell *params)
+{
+	if (!inhook)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not in a message hook");
+		return 0;
+	}
+
+	cell *cAddr = get_amxaddr(amx, params[1]);
+
+	if (msgDest >= MSG_PVS && msgDest <= MSG_PAS_R)
+	{
+		vec3_t vRet = (Vector)msgOrigin;
+		cAddr[0] = FloatToCell(vRet.x);
+		cAddr[1] = FloatToCell(vRet.y);
+		cAddr[2] = FloatToCell(vRet.z);
+	} else {
+		cAddr[0] = 0;
+		cAddr[1] = 0;
+		cAddr[2] = 0;
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL emessage_begin(AMX *amx, cell *params) /* 4 param */
+{
+	int numparam = *params / sizeof(cell);
+	float vecOrigin[3];
+	cell *cpOrigin;
+
+	if (params[2] < 1 || ((params[2] > 63)		// maximal number of engine messages
+		&& !GET_USER_MSG_NAME(PLID, params[2], NULL)))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Plugin called message_begin with an invalid message id (%d).", params[2]);
+		return 0;
+	}
+
+	switch (params[1])
+	{
+	case MSG_BROADCAST:
+	case MSG_ALL:
+	case MSG_SPEC:
+		g_pEngTable->pfnMessageBegin(params[1], params[2], NULL, NULL);
+		break;
+	case MSG_PVS: case MSG_PAS:
+	case MSG_PVS_R: case MSG_PAS_R:
+		if (numparam < 3)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed");
+			return 0;
+		}
+
+		cpOrigin = get_amxaddr(amx, params[3]);
+
+		vecOrigin[0] = static_cast<float>(*cpOrigin);
+		vecOrigin[1] = static_cast<float>(*(cpOrigin + 1));
+		vecOrigin[2] = static_cast<float>(*(cpOrigin + 2));
+
+		g_pEngTable->pfnMessageBegin(params[1], params[2], vecOrigin, NULL);
+
+		break;
+	case MSG_ONE_UNRELIABLE:
+	case MSG_ONE:
+		if (numparam < 4)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid number of parameters passed");
+			return 0;
+		}
+
+		g_pEngTable->pfnMessageBegin(params[1], params[2], NULL, INDEXENT(params[4]));
+		break;
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL emessage_end(AMX *amx, cell *params)
+{
+	g_pEngTable->pfnMessageEnd();
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_byte(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteByte(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_char(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteChar(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_short(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteShort(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_long(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteLong(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_entity(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteEntity(params[1]);
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_angle(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteAngle(static_cast<float>(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_coord(AMX *amx, cell *params) /* 1 param */
+{
+	g_pEngTable->pfnWriteCoord(static_cast<float>(params[1]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL ewrite_string(AMX *amx, cell *params) /* 1 param */
+{
+	int a;
+	g_pEngTable->pfnWriteString(get_amxstring(amx, params[1], 3, a));
+
+	return 1;
+}
+
+AMX_NATIVE_INFO msg_Natives[] =
+{
+	{"message_begin",		message_begin},
+	{"message_end",			message_end},
+
+	{"write_angle",			write_angle},
+	{"write_byte",			write_byte},
+	{"write_char",			write_char},
+	{"write_coord",			write_coord},
+	{"write_entity",		write_entity},
+	{"write_long",			write_long},
+	{"write_short",			write_short},
+	{"write_string",		write_string},
+
+	{"register_message",	register_message},
+	{"unregister_message",	unregister_message},
+
+	{"set_msg_block",		set_msg_block},
+	{"get_msg_block",		get_msg_block},
+
+	{"get_msg_args",		get_msg_args},
+	{"get_msg_argtype",		get_msg_argtype},
+	{"get_msg_arg_int",		get_msg_arg_int},
+	{"set_msg_arg_int",		set_msg_arg_int},
+	{"get_msg_arg_float",	get_msg_arg_float},
+	{"set_msg_arg_float",	set_msg_arg_float},
+	{"get_msg_arg_string",	get_msg_arg_string},
+	{"set_msg_arg_string",	set_msg_arg_string},
+	{"get_msg_origin",		get_msg_origin},
+
+	{"emessage_begin",		emessage_begin},
+	{"emessage_end",		emessage_end},
+
+	{"ewrite_angle",		ewrite_angle},
+	{"ewrite_byte",			ewrite_byte},
+	{"ewrite_char",			ewrite_char},
+	{"ewrite_coord",		ewrite_coord},
+	{"ewrite_entity",		ewrite_entity},
+	{"ewrite_long",			ewrite_long},
+	{"ewrite_short",		ewrite_short},
+	{"ewrite_string",		ewrite_string},
+
+	{NULL,					NULL},
+};

amxmodx/messages.h

@@ -0,0 +1,216 @@
+#ifndef _MSGS_INCLUDE_H
+#define _MSGS_INCLUDE_H
+
+#include <extdll.h>
+#include <meta_api.h>
+#include "amx.h"
+#include "CVector.h"
+#include "CString.h"
+#include "sh_stack.h"
+
+#define MAX_MESSAGES 255
+
+#define MSGBLOCK_SET	0
+#define MSGBLOCK_GET	1
+#define BLOCK_NOT 0
+#define BLOCK_ONCE 1
+#define BLOCK_SET 2
+
+class RegisteredMessage
+{
+private:
+	CVector<int> m_Forwards;
+	CStack<int> m_InExecution;
+	bool m_Cleanup;
+
+public:
+	RegisteredMessage() : m_Cleanup(false) { } 
+	~RegisteredMessage() { this->Clear(); }
+
+	void AddHook(int fwd)
+	{
+		m_Forwards.push_back(fwd);
+	}
+	bool RemoveHook(int fwd)
+	{
+		// Don't erase a forward if we're in the middle of execution; this
+		// could throw off the iterator that is going through the forwards
+		// and executing them.  Instead, unregister the forward and set it
+		// to -1 from within the vector.
+		if (m_InExecution.size())
+		{
+			this->m_Cleanup = true;
+
+			CVector<int>::iterator iter = m_Forwards.begin();
+			CVector<int>::iterator end = m_Forwards.end();
+			while (iter != end)
+			{
+				if (*iter == fwd)
+				{
+					if (*iter != -1)
+					{
+						unregisterSPForward(*iter);
+					}
+					*iter = -1;
+					return true;
+				}
+				else
+				{
+					iter++;
+				}
+			}
+		
+		}
+		else
+		{
+			CVector<int>::iterator iter = m_Forwards.begin();
+			CVector<int>::iterator end = m_Forwards.end();
+			while (iter != end)
+			{
+				if (*iter == fwd)
+				{
+					if (fwd != -1)
+					{
+						unregisterSPForward(fwd);
+
+						m_Forwards.erase(iter);
+
+						return true;
+					}
+					else
+					{
+						// -1 could be in here more than once
+						m_Forwards.erase(iter);
+					}
+				}
+				else
+				{
+					iter++;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	void Clear()
+	{
+		while (m_InExecution.size())
+		{
+			m_InExecution.pop();
+		}
+		for (size_t i = 0; i < m_Forwards.size(); i++)
+		{
+			int fwd = m_Forwards[i];
+
+			if (fwd != -1)
+			{
+				unregisterSPForward(m_Forwards[i]);
+			}
+		}
+
+		m_Forwards.clear();
+	}
+
+	cell Execute(cell type, cell dest, cell entity)
+	{
+		m_InExecution.push(1);
+		cell res = 0;
+		cell thisres = 0;
+		for (size_t i = 0; i < m_Forwards.size(); i++)
+		{
+			int fwd = m_Forwards[i];
+
+			if (fwd != -1)
+			{
+				thisres = executeForwards(fwd, type, dest, entity);
+				if (thisres > res)
+				{
+					res = thisres;
+				}
+
+			}
+		}
+
+		m_InExecution.pop();
+
+		if (m_InExecution.size() == 0 && m_Cleanup)
+		{
+			this->RemoveHook(-1);
+		}
+
+		return res;
+	}
+	bool Hooked() const
+	{
+		return m_Forwards.size() != 0;
+	}
+};
+enum msgtype
+{
+	arg_byte = 1,
+	arg_char,
+	arg_short,
+	arg_long,
+	arg_angle,
+	arg_coord,
+	arg_string,
+	arg_entity,
+};
+
+struct msgparam
+{
+	msgtype type;
+	union
+	{
+		REAL fData;
+		int iData;
+	} v;
+	String szData;
+};
+
+class Message
+{
+public:
+	Message();
+	~Message();
+	void AddParam(float data, msgtype type);
+	void AddParam(int data, msgtype type);
+	void AddParam(const char *data, msgtype type);
+	void SetParam(size_t index, float data);
+	void SetParam(size_t index, int data);
+	void SetParam(size_t index, const char *data);
+	const char *GetParamString(size_t index);
+	float GetParamFloat(size_t index);
+	bool Ready();
+	void Init();
+	int GetParamInt(size_t index);
+	msgtype GetParamType(size_t index);
+	void Reset();
+	void Send();
+	size_t Params();
+private:
+	msgparam *AdvPtr();
+private:
+	CVector<msgparam *> m_Params;
+	size_t m_CurParam;
+};
+
+void C_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+void C_WriteByte(int iValue);
+void C_WriteChar(int iValue);
+void C_WriteShort(int iValue);
+void C_WriteLong(int iValue);
+void C_WriteAngle(float flValue);
+void C_WriteCoord(float flValue);
+void C_WriteString(const char *sz);
+void C_WriteEntity(int iValue);
+void C_MessageEnd(void);
+
+extern RegisteredMessage msgHooks[256];
+extern int msgBlocks[256];
+
+void ClearMessages();
+
+#endif //_MSGS_INCLUDE_H
+

amxmodx/mm_pextensions.h

@@ -1,116 +0,0 @@
-/*
- * Copyright (c) 2004 Jussi Kivilinna
- *
- *    This file is part of "Metamod All-Mod-Support"-patch for Metamod.
- *
- *    Metamod 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.
- *
- *    Metamod 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 Metamod; 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 MM_PEXTENSIONS_H
-#define MM_PEXTENSIONS_H
-
-#include "plinfo.h"		// plid_t
-#include "meta_api.h"		// PLUG_LOADTIME
-/*
-
-	How to use:
-		1. Add new export function 'Meta_PExtGiveFnptrs' to your plugin file.
-		   'Meta_PExtGiveFnptrs' will be called right after 'Meta_Query' call.
-		2. Meta_PExtGiveFnptrs is called with interface version 'META_PEXT_VERSION'
-		   and pointer to extension function table.
-		3. Meta_PExtGiveFnptrs should return plugin's interface version.
-		4. !NOTE! Metamod will not stop loading plugin even if plugin returns 
-		   interface version greater than current. Plugin should disable itself in
-		   this kind of situation.
-	
-	Example:
-		#include "mm_pextensions.h"
-		
-		pextension_funcs_t *gpMetaPExtFuncs;
-		
-		int Meta_PExtGiveFnptrs(int interfaceVersion, pextension_funcs_t *pMetaPExtFuncs) {
-			if(interfaceVersion < META_PEXT_VERSION) {
-				LOG_DEVELOPER(PLID, "Error! Metamod is too old, please update!");
-				gpMetaPExtFuncs = NULL;
-			
-				return(META_PEXT_VERSION);
-			}
-			
-			gpMetaPExtFuncs = pMetaPExtFuncs;
-			
-			return(META_PEXT_VERSION);
-		}
-	
-	Callback functions:
-		- int PEXT_LOAD_PLUGIN_BY_NAME(PLID, const char *cmdline, PLUG_LOADTIME now, void **plugin_handle);
-			Parses 'cmdline' as metamod would parse 'meta load <cmdline>' and loads found 
-			plugin. If 'plugin_handle' is set, metamod writes module handle of loaded 
-			plugin at it.
-			Returns zero on success.
-			For error codes see 'META_ERRNO' in 'types_meta.h'.
-		
-		- int PEXT_UNLOAD_PLUGIN_BY_NAME(PLID, const char *cmdline, PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
-			Parses 'cmdline' as metamod would parse 'meta unload <cmdline>' and 
-			unloads found plugin.
-			Returns zero on success.
-			For error codes see 'META_ERRNO' in 'types_meta.h'.
-		
-		- int PEXT_UNLOAD_PLUGIN_BY_HANDLE(PLID, void *plugin_handle, PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
-			Unloads plugin with 'plugin_handle'.
-			Returns zero on success.
-			For error codes see 'META_ERRNO' in 'types_meta.h'.
-		
-		!NOTE! Plugin cannot unload itself!
-*/
-
-// Interface version
-//  1: first version. Used in p13
-//  2: Complete remake (p14):
-//	pfnLoadMetaPluginByName
-//	pfnUnloadMetaPluginByName
-//	pfnUnloadMetaPluginByHandle
-//  v2 is locked now. Don't modify old functions. If you add new functions, increase META_PEXT_VERSION.
-#define META_PEXT_VERSION 2
-
-// Meta PExtension Function table type.
-typedef struct pextension_funcs_s {
-	int (*pfnLoadMetaPluginByName)(plid_t plid, const char *cmdline, PLUG_LOADTIME now, void **plugin_handle);
-	int (*pfnUnloadMetaPluginByName)(plid_t plid, const char *cmdline, PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
-	int (*pfnUnloadMetaPluginByHandle)(plid_t plid, void *plugin_handle, PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
-} pextension_funcs_t;
-
-// Convenience macros for MetaPExtension functions.
-#define PEXT_LOAD_PLUGIN_BY_NAME	(*gpMetaPExtFuncs->pfnLoadMetaPluginByName)
-#define PEXT_UNLOAD_PLUGIN_BY_NAME	(*gpMetaPExtFuncs->pfnUnloadMetaPluginByName)
-#define PEXT_UNLOAD_PLUGIN_BY_HANDLE	(*gpMetaPExtFuncs->pfnUnloadMetaPluginByHandle)
-
-// Give plugin extension function table.
-C_DLLEXPORT int Meta_PExtGiveFnptrs(int interfaceVersion, 
-		pextension_funcs_t *pMetaPExtFuncs);
-typedef int (*META_GIVE_PEXT_FUNCTIONS_FN) (int interfaceVersion, 
-		pextension_funcs_t *pMetaPExtFuncs);
-
-#endif /* MM_PEXTENSIONS_H */

amxmodx/modules.h

@@ -35,11 +35,11 @@
 #include "amx.h"
 
 #undef DLLEXPORT
-#ifndef __linux__
+#if defined(_WIN32)
-  #define DLLEXPORT   __declspec(dllexport)
+	#define DLLEXPORT __declspec(dllexport)
 #else
-  #define DLLEXPORT
+	#define DLLEXPORT __attribute__((visibility("default")))
-  #define WINAPI
+	#define WINAPI
 #endif
 
 #undef C_DLLEXPORT
@@ -48,6 +48,44 @@
 #define RELOAD_MODULE 0
 #define STATIC_MODULE 1
 
+typedef enum
+{
+	Player_Name,		//String
+	Player_Ip,			//String
+	Player_Team,		//String
+	Player_Ingame,		//bool
+	Player_Authorized,	//bool
+	Player_Vgui,		//bool
+	Player_Time,		//float
+	Player_Playtime,	//float
+	Player_MenuExpire,	//float
+	Player_Weapons,		//struct{int,int}[32]
+	Player_CurrentWeapon,	//int
+	Player_TeamID,			//int
+	Player_Deaths,			//int
+	Player_Aiming,			//int
+	Player_Menu,			//int
+	Player_Keys,			//int
+	Player_Flags,			//int[32]
+	Player_Newmenu,			//int
+	Player_NewmenuPage,		//int
+}  PlayerProp;
+
 int CheckModules(AMX *amx, char error[128]);
+bool LoadModule(const char *shortname, PLUG_LOADTIME now, bool simplify=true, bool noFileBail=false);
+const char *StrCaseStr(const char *as, const char *bs);
+
+class Debugger;
+Debugger *DisableDebugHandler(AMX *amx);
+void EnableDebugHandler(AMX *amx, Debugger *pd);
+
+bool DirExists(const char *dir);
+const char* GetFileName(AMX *amx);
+
+inline cell FloatToCell(float input)
+{
+	REAL output = input;
+	return *(cell *)&output;
+}
 
 #endif // __MODULES_H__

amxmodx/msvc/.cvsignore

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

amxmodx/msvc/amxmodx_mm.def

@@ -1,6 +0,0 @@
-LIBRARY amxx_mm
-EXPORTS
-	GiveFnptrsToDll			@1
-	
-SECTIONS
-	.data READ WRITE

amxmodx/msvc/amxmodx_mm.dsp

@@ -1,292 +0,0 @@
-# Microsoft Developer Studio Project File - Name="amxmodx_mm" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-CFG=amxmodx_mm - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "amxmodx_mm.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "amxmodx_mm.mak" CFG="amxmodx_mm - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "amxmodx_mm - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "amxmodx_mm - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "amxmodx_mm - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "release"
-# PROP Intermediate_Dir "release"
-# PROP Ignore_Export_Lib 0
-# 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 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 BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-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 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"
-# Begin Custom Build
-TargetPath=.\release\amxx_mm.dll
-TargetName=amxx_mm
-InputPath=.\release\amxx_mm.dll
-SOURCE="$(InputPath)"
-
-"$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	copy $(TargetPath) D:\SIERRA\Half-Life\cstrike\addons\amx\dlls
-
-# End Custom Build
-
-!ELSEIF  "$(CFG)" == "amxmodx_mm - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "debug"
-# PROP Intermediate_Dir "debug"
-# PROP Ignore_Export_Lib 0
-# 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 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 BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-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 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"
-# SUBTRACT LINK32 /incremental:no /nodefaultlib
-# Begin Custom Build
-TargetPath=.\debug\amxx_mm.dll
-TargetName=amxx_mm
-InputPath=.\debug\amxx_mm.dll
-SOURCE="$(InputPath)"
-
-"$(TargetName)" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
-	copy $(TargetPath) D:\SIERRA\Half-Life\cstrike\addons\amx\dlls
-
-# End Custom Build
-
-!ENDIF 
-
-# Begin Target
-
-# Name "amxmodx_mm - Win32 Release"
-# Name "amxmodx_mm - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\amx.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\amxcore.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\amxmodx.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\amxtime.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\amxxlog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CCmd.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CEvent.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CFile.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CForward.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CLogEvent.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CMenu.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CMisc.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CModule.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CPlugin.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CTask.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\CVault.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\emsg.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\file.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\float.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\meta_api.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\modules.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\power.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\srvcmd.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\string.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\strptime.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\util.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\vault.cpp
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Source File
-
-SOURCE=..\amxmodx.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CCmd.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CEvent.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CFile.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CForward.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CList.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CLogEvent.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CMenu.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CMisc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CModule.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CPlugin.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CTask.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\CVault.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\modules.h
-# End Source File
-# End Group
-# End Target
-# End Project

amxmodx/msvc/amxmodx_mm.sln

@@ -1,39 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 8.00
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "amxmodx", "amxmodx_mm.vcproj", "{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}"
-	ProjectSection(ProjectDependencies) = postProject
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfiguration) = preSolution
-		Debug = Debug
-		JITDebug = JITDebug
-		JITMemtestRelease = JITMemtestRelease
-		JITRelease = JITRelease
-		MaximalSpeed = MaximalSpeed
-		MemtestDebug = MemtestDebug
-		MemtestRelease = MemtestRelease
-		Release = Release
-	EndGlobalSection
-	GlobalSection(ProjectConfiguration) = postSolution
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.Debug.ActiveCfg = Debug|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.Debug.Build.0 = Debug|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITDebug.ActiveCfg = JITDebug|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITDebug.Build.0 = JITDebug|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITMemtestRelease.ActiveCfg = JITMemtestRelease|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITMemtestRelease.Build.0 = JITMemtestRelease|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITRelease.ActiveCfg = JITRelease|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITRelease.Build.0 = JITRelease|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MaximalSpeed.ActiveCfg = MaximalSpeed|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MaximalSpeed.Build.0 = MaximalSpeed|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MemtestDebug.ActiveCfg = MemtestDebug|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MemtestDebug.Build.0 = MemtestDebug|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MemtestRelease.ActiveCfg = MemtestRelease|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MemtestRelease.Build.0 = MemtestRelease|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.Release.ActiveCfg = Release|Win32
-		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.Release.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-	EndGlobalSection
-	GlobalSection(ExtensibilityAddIns) = postSolution
-	EndGlobalSection
-EndGlobal

amxmodx/msvc/amxmodx_mm.vcproj

@@ -1,867 +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 ..\JIT\natives-x86.obj"
-				OutputFile="release/amxmodx_mm.dll"
-				LinkIncremental="1"
-				SuppressStartupBanner="TRUE"
-				AdditionalLibraryDirectories="..\extra\lib_win32"
-				IgnoreDefaultLibraryNames="LIBC"
-				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 ..\JIT\natives-x86.obj"
-				OutputFile="memtestdebug/amxmodx_mm.dll"
-				Version="0.1"
-				LinkIncremental="2"
-				SuppressStartupBanner="TRUE"
-				AdditionalLibraryDirectories="..\extra\lib_win32"
-				IgnoreDefaultLibraryNames="MSVCRT"
-				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 ..\JIT\natives-x86.obj"
-				OutputFile="memtestrelease/amxmodx_mm.dll"
-				LinkIncremental="1"
-				SuppressStartupBanner="TRUE"
-				AdditionalLibraryDirectories="..\extra\lib_win32"
-				IgnoreDefaultLibraryNames="LIBC"
-				ModuleDefinitionFile=""
-				GenerateDebugInformation="TRUE"
-				ProgramDatabaseFile=".\memtestrelease/amxx_mm.pdb"
-				GenerateMapFile="TRUE"
-				MapExports="TRUE"
-				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;PAWN_CELL_SIZE=32;ASM32;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="..\zlib\zlib.lib ..\JIT\amxjitsn.obj ..\JIT\amxexecn.obj ..\JIT\natives-x86.obj"
-				OutputFile="jitdebug/amxmodx_mm.dll"
-				Version="0.1"
-				LinkIncremental="1"
-				SuppressStartupBanner="TRUE"
-				AdditionalLibraryDirectories="..\extra\lib_win32"
-				IgnoreDefaultLibraryNames="MSVCRT"
-				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"
-				OmitFramePointers="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;ASM32;PAWN_CELL_SIZE=32"
-				IgnoreStandardIncludePath="FALSE"
-				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="..\zlib\zlib.lib ..\JIT\amxjitsn.obj ..\JIT\amxexecn.obj ..\JIT\natives-x86.obj"
-				OutputFile="jitrelease/amxmodx_mm.dll"
-				LinkIncremental="1"
-				SuppressStartupBanner="TRUE"
-				AdditionalLibraryDirectories="..\extra\lib_win32"
-				IgnoreDefaultLibraryNames="MSVCRT"
-				ModuleDefinitionFile=""
-				GenerateDebugInformation="TRUE"
-				ProgramDatabaseFile=".\jitrelease/amxx_mm.pdb"
-				GenerateMapFile="FALSE"
-				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;ASM32;PAWN_CELL_SIZE=32"
-				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="..\zlib\zlib.lib ..\JIT\amxjitsn.obj ..\JIT\amxexecn.obj ..\JIT\natives-x86.obj"
-				OutputFile="jitmemtestrelease/amxmodx_mm.dll"
-				LinkIncremental="1"
-				SuppressStartupBanner="TRUE"
-				AdditionalLibraryDirectories="..\extra\lib_win32"
-				IgnoreDefaultLibraryNames="MSVCRT"
-				ModuleDefinitionFile=""
-				GenerateDebugInformation="TRUE"
-				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="..\amxdbg.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="..\natives.cpp">
-			</File>
-			<File
-				RelativePath="..\newmenus.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="..\amxdbg.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="..\CStack.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="..\menus.h">
-			</File>
-			<File
-				RelativePath="..\modules.h">
-			</File>
-			<File
-				RelativePath="..\natives.h">
-			</File>
-			<File
-				RelativePath="..\newmenus.h">
-			</File>
-			<File
-				RelativePath="..\resource.h">
-			</File>
-			<File
-				RelativePath="..\zlib\zconf.h">
-			</File>
-			<File
-				RelativePath="..\zlib\zlib.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>
-		<Filter
-			Name="Assembly"
-			Filter="">
-			<File
-				RelativePath="..\amxdefn.asm">
-			</File>
-			<File
-				RelativePath="..\amxexecn.asm">
-			</File>
-			<File
-				RelativePath="..\amxjitsn.asm">
-			</File>
-			<File
-				RelativePath="..\natives-amd64.asm">
-			</File>
-			<File
-				RelativePath="..\natives-x86.asm">
-			</File>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

amxmodx/msvc10/amxmodx_mm.sln

@@ -0,0 +1,26 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "amxmodx_mm", "amxmodx_mm.vcxproj", "{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		JITDebug|Win32 = JITDebug|Win32
+		JITDebugBinLog|Win32 = JITDebugBinLog|Win32
+		JITRelease|Win32 = JITRelease|Win32
+		JITReleaseBinLog|Win32 = JITReleaseBinLog|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITDebug|Win32.ActiveCfg = JITDebug|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITDebug|Win32.Build.0 = JITDebug|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITDebugBinLog|Win32.ActiveCfg = JITDebugBinLog|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITDebugBinLog|Win32.Build.0 = JITDebugBinLog|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITRelease|Win32.ActiveCfg = JITRelease|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITRelease|Win32.Build.0 = JITRelease|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITReleaseBinLog|Win32.ActiveCfg = JITReleaseBinLog|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITReleaseBinLog|Win32.Build.0 = JITReleaseBinLog|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

amxmodx/msvc10/amxmodx_mm.vcxproj

@@ -0,0 +1,439 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="JITDebugBinLog|Win32">
+      <Configuration>JITDebugBinLog</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="JITDebug|Win32">
+      <Configuration>JITDebug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="JITReleaseBinLog|Win32">
+      <Configuration>JITReleaseBinLog</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="JITRelease|Win32">
+      <Configuration>JITRelease</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}</ProjectGuid>
+    <RootNamespace>amxmodx</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseOfMfc>false</UseOfMfc>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='JITDebugBinLog|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseOfMfc>false</UseOfMfc>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseOfMfc>false</UseOfMfc>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseOfMfc>false</UseOfMfc>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='JITDebugBinLog|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'">true</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'">false</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='JITDebugBinLog|Win32'">true</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'">false</LinkIncremental>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='JITDebugBinLog|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='JITDebugBinLog|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='JITDebugBinLog|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'" />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\debug/amxmodx.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(METAMOD)\metamod;$(HLSDK)\multiplayer\common;$(HLSDK)\multiplayer\engine;$(HLSDK)\multiplayer\dlls;$(HLSDK)\multiplayer\pm_shared;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;PAWN_CELL_SIZE=32;ASM32;JIT;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <StructMemberAlignment>4Bytes</StructMemberAlignment>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <PrecompiledHeaderFile>amxmodx.h</PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>.\jitdebug/amxmodx.pch</PrecompiledHeaderOutputFile>
+      <AssemblerListingLocation>.\jitdebug/</AssemblerListingLocation>
+      <ObjectFileName>.\jitdebug/</ObjectFileName>
+      <ProgramDataBaseFileName>.\jitdebug/</ProgramDataBaseFileName>
+      <WarningLevel>Level3</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <AdditionalOptions>/MACHINE:I386 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalDependencies>..\zlib\zlib.lib;..\JIT\amxjitsn.obj;..\JIT\amxexecn.obj;..\JIT\natives-x86.obj;%(AdditionalDependencies)</AdditionalDependencies>
+      <Version>0.1</Version>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\extra\lib_win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <IgnoreSpecificDefaultLibraries>LIBC;LIBCD;LIBCMT;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>.\jitdebug/amxx_mm.pdb</ProgramDatabaseFile>
+      <ImportLibrary>.\jitdebug/amxmodx_mm.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\release/amxmodx.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <AdditionalIncludeDirectories>$(METAMOD)\metamod;$(HLSDK)\multiplayer\common;$(HLSDK)\multiplayer\engine;$(HLSDK)\multiplayer\dlls;$(HLSDK)\multiplayer\pm_shared;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT;ASM32;PAWN_CELL_SIZE=32;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <PrecompiledHeaderFile>amxmodx.h</PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>.\jitrelease/amxmodx.pch</PrecompiledHeaderOutputFile>
+      <AssemblerListingLocation>.\jitrelease/</AssemblerListingLocation>
+      <ObjectFileName>.\jitrelease/</ObjectFileName>
+      <ProgramDataBaseFileName>.\jitrelease/</ProgramDataBaseFileName>
+      <WarningLevel>Level3</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+      <ShowIncludes>false</ShowIncludes>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <AdditionalOptions>/MACHINE:I386 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalDependencies>..\zlib\zlib.lib;..\JIT\amxjitsn.obj;..\JIT\amxexecn.obj;..\JIT\natives-x86.obj;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\extra\lib_win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <IgnoreSpecificDefaultLibraries>LIBC;LIBCD;LIBCMTD;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>.\jitrelease/amxmodx_mm.pdb</ProgramDatabaseFile>
+      <GenerateMapFile>true</GenerateMapFile>
+      <ImportLibrary>.\jitrelease/amxmodx_mm.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='JITDebugBinLog|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\debug/amxmodx.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(METAMOD)\metamod;$(HLSDK)\multiplayer\common;$(HLSDK)\multiplayer\engine;$(HLSDK)\multiplayer\dlls;$(HLSDK)\multiplayer\pm_shared;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;PAWN_CELL_SIZE=32;ASM32;JIT;BINLOG_ENABLED;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <StructMemberAlignment>4Bytes</StructMemberAlignment>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <PrecompiledHeaderFile>amxmodx.h</PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>.\jitdebugbinlog/amxmodx.pch</PrecompiledHeaderOutputFile>
+      <AssemblerListingLocation>.\jitdebugbinlog/</AssemblerListingLocation>
+      <ObjectFileName>.\jitdebugbinlog/</ObjectFileName>
+      <ProgramDataBaseFileName>.\jitdebugbinlog/</ProgramDataBaseFileName>
+      <WarningLevel>Level3</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <AdditionalOptions>/MACHINE:I386 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalDependencies>..\zlib\zlib.lib;..\JIT\amxjitsn.obj;..\JIT\amxexecn.obj;..\JIT\natives-x86.obj;%(AdditionalDependencies)</AdditionalDependencies>
+      <Version>0.1</Version>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\extra\lib_win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <IgnoreSpecificDefaultLibraries>LIBC;LIBCD;LIBCMT;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>.\jitdebugbinlog/amxmodx_bl_mm.pdb</ProgramDatabaseFile>
+      <ImportLibrary>.\jitdebugbinlog/amxmodx_bl_mm.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\release/amxmodx.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <AdditionalIncludeDirectories>$(METAMOD)\metamod;$(HLSDK)\multiplayer\common;$(HLSDK)\multiplayer\engine;$(HLSDK)\multiplayer\dlls;$(HLSDK)\multiplayer\pm_shared;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT;ASM32;PAWN_CELL_SIZE=32;BINLOG_ENABLED;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <IgnoreStandardIncludePath>false</IgnoreStandardIncludePath>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <PrecompiledHeaderFile>amxmodx.h</PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>.\jitreleasebinlog/amxmodx.pch</PrecompiledHeaderOutputFile>
+      <AssemblerListingLocation>.\jitreleasebinlog/</AssemblerListingLocation>
+      <ObjectFileName>.\jitreleasebinlog/</ObjectFileName>
+      <ProgramDataBaseFileName>.\jitreleasebinlog/</ProgramDataBaseFileName>
+      <WarningLevel>Level3</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <AdditionalOptions>/MACHINE:I386 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalDependencies>..\zlib\zlib.lib;..\JIT\amxjitsn.obj;..\JIT\amxexecn.obj;..\JIT\natives-x86.obj;%(AdditionalDependencies)</AdditionalDependencies>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <AdditionalLibraryDirectories>..\extra\lib_win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <IgnoreSpecificDefaultLibraries>LIBC;LIBCD;LIBCMTD;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>.\jitreleasebinlog/amxmodx_bl_mm.pdb</ProgramDatabaseFile>
+      <GenerateMapFile>true</GenerateMapFile>
+      <ImportLibrary>.\jitreleasebinlog/amxmodx_bl_mm.lib</ImportLibrary>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\amx.cpp" />
+    <ClCompile Include="..\amxcore.cpp" />
+    <ClCompile Include="..\amxdbg.cpp" />
+    <ClCompile Include="..\amxmod_compat.cpp" />
+    <ClCompile Include="..\amxmodx.cpp" />
+    <ClCompile Include="..\amxtime.cpp" />
+    <ClCompile Include="..\amxxfile.cpp" />
+    <ClCompile Include="..\amxxlog.cpp" />
+    <ClCompile Include="..\binlog.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\CCmd.cpp" />
+    <ClCompile Include="..\CEvent.cpp" />
+    <ClCompile Include="..\CFile.cpp" />
+    <ClCompile Include="..\CFlagManager.cpp" />
+    <ClCompile Include="..\CForward.cpp" />
+    <ClCompile Include="..\CLang.cpp" />
+    <ClCompile Include="..\CLogEvent.cpp" />
+    <ClCompile Include="..\CMenu.cpp" />
+    <ClCompile Include="..\CMisc.cpp" />
+    <ClCompile Include="..\CModule.cpp" />
+    <ClCompile Include="..\CPlugin.cpp" />
+    <ClCompile Include="..\CTask.cpp" />
+    <ClCompile Include="..\CVault.cpp" />
+    <ClCompile Include="..\debugger.cpp" />
+    <ClCompile Include="..\emsg.cpp" />
+    <ClCompile Include="..\fakemeta.cpp" />
+    <ClCompile Include="..\file.cpp" />
+    <ClCompile Include="..\float.cpp" />
+    <ClCompile Include="..\format.cpp">
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'">AssemblyAndSourceCode</AssemblerOutput>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'">AssemblyAndSourceCode</AssemblerOutput>
+    </ClCompile>
+    <ClCompile Include="..\libraries.cpp" />
+    <ClCompile Include="..\md5.cpp" />
+    <ClCompile Include="..\messages.cpp" />
+    <ClCompile Include="..\meta_api.cpp" />
+    <ClCompile Include="..\modules.cpp" />
+    <ClCompile Include="..\natives.cpp" />
+    <ClCompile Include="..\newmenus.cpp" />
+    <ClCompile Include="..\nongpl_matches.cpp" />
+    <ClCompile Include="..\optimizer.cpp" />
+    <ClCompile Include="..\power.cpp" />
+    <ClCompile Include="..\sorting.cpp" />
+    <ClCompile Include="..\srvcmd.cpp" />
+    <ClCompile Include="..\string.cpp">
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'">All</AssemblerOutput>
+      <AssemblerOutput Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'">All</AssemblerOutput>
+    </ClCompile>
+    <ClCompile Include="..\strptime.cpp" />
+    <ClCompile Include="..\trie_natives.cpp" />
+    <ClCompile Include="..\util.cpp" />
+    <ClCompile Include="..\vault.cpp" />
+    <ClCompile Include="..\vector.cpp" />
+    <ClCompile Include="..\datastructs.cpp" />
+    <ClCompile Include="..\sdk\amxxmodule.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='JITDebugBinLog|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='JITDebug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='JITReleaseBinLog|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='JITRelease|Win32'">true</ExcludedFromBuild>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\amx.h" />
+    <ClInclude Include="..\amxdbg.h" />
+    <ClInclude Include="..\amxmod_compat.h" />
+    <ClInclude Include="..\amxmodx.h" />
+    <ClInclude Include="..\amxxfile.h" />
+    <ClInclude Include="..\amxxlog.h" />
+    <ClInclude Include="..\binlog.h" />
+    <ClInclude Include="..\CCmd.h" />
+    <ClInclude Include="..\CEvent.h" />
+    <ClInclude Include="..\CFile.h" />
+    <ClInclude Include="..\CFlagManager.h" />
+    <ClInclude Include="..\CForward.h" />
+    <ClInclude Include="..\CLang.h" />
+    <ClInclude Include="..\CList.h" />
+    <ClInclude Include="..\CLogEvent.h" />
+    <ClInclude Include="..\CMenu.h" />
+    <ClInclude Include="..\CMisc.h" />
+    <ClInclude Include="..\CModule.h" />
+    <ClInclude Include="..\CPlugin.h" />
+    <ClInclude Include="..\CQueue.h" />
+    <ClInclude Include="..\CString.h" />
+    <ClInclude Include="..\CTask.h" />
+    <ClInclude Include="..\CVault.h" />
+    <ClInclude Include="..\CVector.h" />
+    <ClInclude Include="..\datastructs.h" />
+    <ClInclude Include="..\debugger.h" />
+    <ClInclude Include="..\fakemeta.h" />
+    <ClInclude Include="..\format.h" />
+    <ClInclude Include="..\libraries.h" />
+    <ClInclude Include="..\md5.h" />
+    <ClInclude Include="..\messages.h" />
+    <ClInclude Include="..\modules.h" />
+    <ClInclude Include="..\natives.h" />
+    <ClInclude Include="..\newmenus.h" />
+    <ClInclude Include="..\nongpl_matches.h" />
+    <ClInclude Include="..\optimizer.h" />
+    <ClInclude Include="..\resource.h" />
+    <ClInclude Include="..\sh_list.h" />
+    <ClInclude Include="..\sh_stack.h" />
+    <ClInclude Include="..\sh_tinyhash.h" />
+    <ClInclude Include="..\svn_version.h" />
+    <ClInclude Include="..\trie_natives.h" />
+    <ClInclude Include="..\zlib\zconf.h" />
+    <ClInclude Include="..\zlib\zlib.h" />
+    <ClInclude Include="..\sdk\amxxmodule.h" />
+    <ClInclude Include="..\sdk\moduleconfig.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="..\version.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\amxdefn.asm" />
+    <None Include="..\amxexecn.asm" />
+    <None Include="..\amxjitsn.asm" />
+    <None Include="..\helpers-x86.asm" />
+    <None Include="..\natives-amd64.asm" />
+    <None Include="..\natives-x86.asm" />
+    <None Include="..\..\plugins\include\amxconst.inc" />
+    <None Include="..\..\plugins\include\amxmisc.inc" />
+    <None Include="..\..\plugins\include\amxmodx.inc" />
+    <None Include="..\..\plugins\include\core.inc" />
+    <None Include="..\..\plugins\include\file.inc" />
+    <None Include="..\..\plugins\include\float.inc" />
+    <None Include="..\..\plugins\include\lang.inc" />
+    <None Include="..\..\plugins\include\message_const.inc" />
+    <None Include="..\..\plugins\include\message_stocks.inc" />
+    <None Include="..\..\plugins\include\messages.inc" />
+    <None Include="..\..\plugins\include\sorting.inc" />
+    <None Include="..\..\plugins\include\string.inc" />
+    <None Include="..\..\plugins\include\svn_version.inc" />
+    <None Include="..\..\plugins\include\time.inc" />
+    <None Include="..\..\plugins\include\vault.inc" />
+    <None Include="..\..\plugins\include\vector.inc" />
+    <None Include="..\..\plugins\include\xs.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\amxmod.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\maths.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\mysql.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\translator.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\Vexd_Utilities.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\VexdUM.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\VexdUM_const.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\VexdUM_stock.inc" />
+    <None Include="..\..\plugins\include\amxmod_compat\xtrafun.inc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Object Include="..\Jit\helpers-x86.obj" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

amxmodx/msvc10/amxmodx_mm.vcxproj.filters

@@ -0,0 +1,426 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{0d31fe96-c452-4d62-8c7c-0f0f8d69efa8}</UniqueIdentifier>
+      <Extensions>cpp;c;cxx;rc;def;r;odl;idl;hpj;bat</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{6e1c49c6-6432-4873-bb9a-9d30996955b2}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{721333c3-98b9-4888-a3ec-637a2bd46091}</UniqueIdentifier>
+      <Extensions>rc</Extensions>
+    </Filter>
+    <Filter Include="Assembly">
+      <UniqueIdentifier>{e347f4b5-ec94-43d6-b45b-85ab3f146a45}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assembly\Builds">
+      <UniqueIdentifier>{1cec296a-ddcc-44da-97c4-2a4d0f4d6fc7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="SDK">
+      <UniqueIdentifier>{bbfaec3e-7d17-45ea-8b84-093fa5714022}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Pawn Includes">
+      <UniqueIdentifier>{4022451d-eb5f-4f14-b8d8-2ce23fec6e59}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Pawn Includes\AMX Mod Compat">
+      <UniqueIdentifier>{d4419052-0ddd-415e-bb16-4393b99751be}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\amx.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\amxcore.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\amxdbg.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\amxmod_compat.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\amxmodx.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\amxtime.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\amxxfile.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\amxxlog.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\binlog.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CCmd.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CEvent.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CFile.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CFlagManager.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CForward.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CLang.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CLogEvent.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CMenu.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CMisc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CModule.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CPlugin.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CTask.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CVault.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\debugger.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\emsg.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\fakemeta.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\file.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\float.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\format.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\libraries.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\md5.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\messages.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\meta_api.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\modules.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\natives.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\newmenus.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\nongpl_matches.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\optimizer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\power.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\sorting.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\srvcmd.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\string.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\strptime.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\trie_natives.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\vault.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\vector.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\datastructs.cpp">
+      <Filter>Header Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\sdk\amxxmodule.cpp">
+      <Filter>SDK</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\amx.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\amxdbg.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\amxmod_compat.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\amxmodx.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\amxxfile.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\amxxlog.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\binlog.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CCmd.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CEvent.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CFile.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CFlagManager.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CForward.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CLang.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CList.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CLogEvent.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CMenu.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CMisc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CModule.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CPlugin.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CQueue.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CString.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CTask.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CVault.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CVector.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\datastructs.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\debugger.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\fakemeta.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\format.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\libraries.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\md5.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\messages.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\modules.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\natives.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\newmenus.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\nongpl_matches.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\optimizer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\sh_list.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\sh_stack.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\sh_tinyhash.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\svn_version.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\trie_natives.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\zlib\zconf.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\zlib\zlib.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\sdk\amxxmodule.h">
+      <Filter>SDK</Filter>
+    </ClInclude>
+    <ClInclude Include="..\sdk\moduleconfig.h">
+      <Filter>SDK</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="..\version.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\amxdefn.asm">
+      <Filter>Assembly</Filter>
+    </None>
+    <None Include="..\amxexecn.asm">
+      <Filter>Assembly</Filter>
+    </None>
+    <None Include="..\amxjitsn.asm">
+      <Filter>Assembly</Filter>
+    </None>
+    <None Include="..\helpers-x86.asm">
+      <Filter>Assembly</Filter>
+    </None>
+    <None Include="..\natives-amd64.asm">
+      <Filter>Assembly</Filter>
+    </None>
+    <None Include="..\natives-x86.asm">
+      <Filter>Assembly</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxconst.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmisc.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmodx.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\core.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\file.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\float.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\lang.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\message_const.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\message_stocks.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\messages.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\sorting.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\string.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\svn_version.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\time.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\vault.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\vector.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\xs.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\amxmod.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\maths.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\mysql.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\translator.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\Vexd_Utilities.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\VexdUM.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\VexdUM_const.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\VexdUM_stock.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+    <None Include="..\..\plugins\include\amxmod_compat\xtrafun.inc">
+      <Filter>Pawn Includes\AMX Mod Compat</Filter>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Object Include="..\Jit\helpers-x86.obj">
+      <Filter>Assembly\Builds</Filter>
+    </Object>
+  </ItemGroup>
+</Project>

amxmodx/natives.cpp

@@ -29,11 +29,17 @@
 */
 
 #include "amxmodx.h"
-#include "CStack.h"
+#include "sh_stack.h"
 #include "natives.h"
+#include "debugger.h"
+#include "libraries.h"
+#include "format.h"
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__APPLE__)
+#if defined(__linux__)
 #include <malloc.h>
+#endif
+
 #include <stdlib.h>
 #include <sys/mman.h>
 #include "sclinux.h"
@@ -44,12 +50,15 @@
 // Julien "dJeyL" Laurent
 
 CVector<regnative *> g_RegNatives;
-CStack<regnative *> g_NativeStack;
-CVector<String> g_Libraries;
 static char g_errorStr[512] = {0};
-static int g_errorNum = 0;
 bool g_Initialized = false;
 
+/* Stack stuff */
+regnative *g_pCurNative = NULL;
+AMX *g_pCaller = NULL;
+cell g_Params[CALLFUNC_MAXPARAMS];
+int g_CurError = AMX_ERR_NONE;
+
 int amxx_DynaCallback(int idx, AMX *amx, cell *params)
 {
 	if (idx < 0 || idx >= (int)g_RegNatives.size())
@@ -67,39 +76,97 @@ int amxx_DynaCallback(int idx, AMX *amx, cell *params)
 		return 0;
 	}
 
-	//parameter stack
-	pNative->caller = amx;
-
 	CPluginMngr::CPlugin *pPlugin = g_plugins.findPluginFast(amx);
+	CPluginMngr::CPlugin *pNativePlugin = g_plugins.findPluginFast(pNative->amx);
+
+	if (!pNativePlugin->isExecutable(pNative->func))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Called dynanative into a paused plugin.");
+		pPlugin->setStatus(ps_paused);
+		return 0;
+	}
+
+	/* Save old values on ZE STACK */
+	AMX *pSaveCaller = g_pCaller;
+	cell saveParams[CALLFUNC_MAXPARAMS];
+	regnative *pSaveNative = g_pCurNative;
+	int saveError = g_CurError;
+
+	if (pSaveNative)
+	{
+		for (ucell i = 0; i <= g_Params[0] / sizeof(cell); i++)
+		{
+			saveParams[i] = g_Params[i];
+		}
+	}
+
+	/* Save current info */
+	g_CurError = AMX_ERR_NONE;
+	g_pCaller = amx;
+	g_pCurNative = pNative;
 
 	int err = 0;
 	cell ret = 0;
-	g_errorNum = 0;
-	g_NativeStack.push(pNative);
 	if (pNative->style == 0)
 	{
 		amx_Push(pNative->amx, numParams);
 		amx_Push(pNative->amx, pPlugin->getId());
-		for (int i=numParams; i>=1; i--)
+		for (int i=numParams; i>=0; i--)
-			pNative->params[i] = params[i];
+		{
+			g_Params[i] = params[i];
+		}
 	} else if (pNative->style == 1) {
-		//use dJeyL's system .. very clever!
+		/**
+		 * use dJeyL's system .. very clever!
+		 * NOTE: clever, but doesn't work at all since the JIT does bounds checking
+		 * this should REALLY be deprecated
+		 */
 		for (int i=numParams; i>=1; i--)
+		{
 			amx_Push(pNative->amx, params[i]);
+		}
 	}
-	if ( (err=amx_Exec(pNative->amx, &ret, pNative->func)) != AMX_ERR_NONE)
+
+	Debugger *pDebugger = (Debugger *)pNative->amx->userdata[UD_DEBUGGER];
+	if (pDebugger)
 	{
-		g_NativeStack.pop();
+		pDebugger->BeginExec();
-		LogError(pNative->amx, err, "");
-		return 0;
 	}
-	if (g_errorNum)
+
+	err=amx_Exec(pNative->amx, &ret, pNative->func);
+
+	if (err != AMX_ERR_NONE)
 	{
-		g_NativeStack.pop();
+		if (pDebugger && pDebugger->ErrorExists())
-		LogError(amx, g_errorNum, g_errorStr);
+		{
-		return ret;
+			//don't care
+		} else if (err != -1) {
+			//nothing logged the error
+			LogError(pNative->amx, err, NULL);
+		}
+		pNative->amx->error = AMX_ERR_NONE;
+		//furthermore, log an error in the parent plugin.
+		LogError(amx, AMX_ERR_NATIVE, "Unhandled dynamic native error");
+	} else if (g_CurError != AMX_ERR_NONE) {
+		LogError(amx, g_CurError, g_errorStr);
+	}
+
+	if (pDebugger)
+	{
+		pDebugger->EndExec();
+	}
+
+	/* Restore everything */
+	g_pCurNative = pSaveNative;
+	g_CurError = saveError;
+	g_pCaller = pSaveCaller;
+	if (pSaveNative)
+	{
+		for (ucell i = 0; i <= saveParams[0] / sizeof(cell); i++)
+		{
+			g_Params[i] = saveParams[i];
+		}
 	}
-	g_NativeStack.pop();
 
 	return ret;
 }
@@ -107,7 +174,9 @@ int amxx_DynaCallback(int idx, AMX *amx, cell *params)
 AMX_NATIVE_INFO *BuildNativeTable()
 {
 	if (g_RegNatives.size() < 1)
+	{
 		return NULL;
+	}
 
 	AMX_NATIVE_INFO *pNatives = new AMX_NATIVE_INFO[g_RegNatives.size() + 1];
 
@@ -133,7 +202,7 @@ static cell AMX_NATIVE_CALL log_error(AMX *amx, cell *params)
 	char *err = format_amxstring(amx, params, 2, len);
 
 	_snprintf(g_errorStr, sizeof(g_errorStr), "%s", err);
-	g_errorNum = params[1];
+	g_CurError = params[1];
 
 	return 1;
 }
@@ -141,13 +210,12 @@ static cell AMX_NATIVE_CALL log_error(AMX *amx, cell *params)
 //get_string(param, dest[], len)
 static cell AMX_NATIVE_CALL get_string(AMX *amx, cell *params)
 {
-	if (!g_NativeStack.size())
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
 		return 0;
 	}
-	regnative *pNative = g_NativeStack.top();
+	if (g_pCurNative->style)
-	if (pNative->style)
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
 		return 0;
@@ -155,20 +223,19 @@ static cell AMX_NATIVE_CALL get_string(AMX *amx, cell *params)
 	int p = params[1];
 
 	int len;
-	char *str = get_amxstring(pNative->caller, pNative->params[p], 0, len);
+	char *str = get_amxstring(g_pCaller, g_Params[p], 0, len);
 	return set_amxstring(amx, params[2], str, params[3]);
 }
 
 //set_string(param, source[], maxlen)
 static cell AMX_NATIVE_CALL set_string(AMX *amx, cell *params)
 {
-	if (!g_NativeStack.size())
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
 		return 0;
 	}
-	regnative *pNative = g_NativeStack.top();
+	if (g_pCurNative->style)
-	if (pNative->style)
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
 		return 0;
@@ -178,46 +245,44 @@ static cell AMX_NATIVE_CALL set_string(AMX *amx, cell *params)
 	int len;
 	char *str = get_amxstring(amx, params[2], 0, len);
 
-	return set_amxstring(pNative->caller, pNative->params[p], str, params[3]);
+	return set_amxstring(g_pCaller, g_Params[p], str, params[3]);
 }
 
 //get a byvalue parameter
 //get_param(num)
 static cell AMX_NATIVE_CALL get_param(AMX *amx, cell *params)
 {
-	if (!g_NativeStack.size())
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
 		return 0;
 	}
-	regnative *pNative = g_NativeStack.top();
+	if (g_pCurNative->style)
-	if (pNative->style)
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
 		return 0;
 	}
 	int p = params[1];
 
-	return pNative->params[p];
+	return g_Params[p];
 }
 
 //get_param_byref(num)
 static cell AMX_NATIVE_CALL get_param_byref(AMX *amx, cell *params)
 {
-	if (!g_NativeStack.size())
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
 		return 0;
 	}
-	regnative *pNative = g_NativeStack.top();
+	if (g_pCurNative->style)
-	if (pNative->style)
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
 		return 0;
 	}
 	int p = params[1];
 
-	cell *addr = get_amxaddr(pNative->caller, pNative->params[p]);
+	cell *addr = get_amxaddr(g_pCaller, g_Params[p]);
 
 	return addr[0];
 }
@@ -225,20 +290,19 @@ static cell AMX_NATIVE_CALL get_param_byref(AMX *amx, cell *params)
 //set_param_byref(num, val)
 static cell AMX_NATIVE_CALL set_param_byref(AMX *amx, cell *params)
 {
-	if (!g_NativeStack.size())
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
 		return 0;
 	}
-	regnative *pNative = g_NativeStack.top();
+	if (g_pCurNative->style)
-	if (pNative->style)
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
 		return 0;
 	}
 	int p = params[1];
 
-	cell *addr = get_amxaddr(pNative->caller, pNative->params[p]);
+	cell *addr = get_amxaddr(g_pCaller, g_Params[p]);
 
 	addr[0] = params[2];
 
@@ -248,26 +312,24 @@ static cell AMX_NATIVE_CALL set_param_byref(AMX *amx, cell *params)
 //get_array(param, dest[], size)
 static cell AMX_NATIVE_CALL get_array(AMX *amx, cell *params)
 {
-	if (!g_NativeStack.size())
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
 		return 0;
 	}
-	regnative *pNative = g_NativeStack.top();
+	if (g_pCurNative->style)
-	if (pNative->style)
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
 		return 0;
 	}
 	int p = params[1];
 
-	cell *source = get_amxaddr(pNative->caller, pNative->params[p]);
+	cell *source = get_amxaddr(g_pCaller, g_Params[p]);
 	cell *dest = get_amxaddr(amx, params[2]);
 
 	int size = params[3];
 
-	while (size-->0)
+	memcpy(dest, source, size * sizeof(cell));
-		*dest = *source;
 
 	return 1;
 }
@@ -275,50 +337,106 @@ static cell AMX_NATIVE_CALL get_array(AMX *amx, cell *params)
 //set_array(param, source[], size)
 static cell AMX_NATIVE_CALL set_array(AMX *amx, cell *params)
 {
-	if (!g_NativeStack.size())
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
 		return 0;
 	}
-	regnative *pNative = g_NativeStack.top();
+	if (g_pCurNative->style)
-	if (pNative->style)
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
 		return 0;
 	}
 	int p = params[1];
 
-	cell *dest = get_amxaddr(pNative->caller, pNative->params[p]);
+	cell *dest = get_amxaddr(g_pCaller, g_Params[p]);
 	cell *source = get_amxaddr(amx, params[2]);
 
 	int size = params[3];
 
-	while (size-->0)
+	memcpy(dest, source, size * sizeof(cell));
-		*dest = *source;
 
 	return 1;
 }
 
+static cell AMX_NATIVE_CALL vdformat(AMX *amx, cell *params)
+{
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+
+	if (g_pCurNative->style)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
+		return 0;
+	}
+
+	int vargPos = static_cast<int>(params[4]);
+	int fargPos = static_cast<int>(params[3]);
+
+	cell max = g_Params[0] / sizeof(cell);
+	if (vargPos > (int)max + 1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid vararg parameter passed: %d", vargPos);
+		return 0;
+	}
+	if (fargPos > (int)max + 1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid fmtarg parameter passed: %d", fargPos);
+		return 0;
+	}
+
+	/* get destination info */
+	cell *fmt;
+	if (fargPos == 0)
+	{
+		if (params[0] / sizeof(cell) != 5)
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Expected fmtarg as fifth parameter, found none");
+			return 0;
+		}
+		fmt = get_amxaddr(amx, params[5]);
+	} else {
+		fmt = get_amxaddr(g_pCaller, g_Params[fargPos]);
+	}
+	cell *realdest = get_amxaddr(amx, params[1]);
+	size_t maxlen = static_cast<size_t>(params[2]);
+	cell *dest = realdest;
+
+	/* if this is necessary... */
+	static cell cpbuf[4096];
+	dest = cpbuf;
+
+	/* perform format */
+	size_t total = atcprintf(dest, maxlen, fmt, g_pCaller, g_Params, &vargPos);
+
+	/* copy back */
+	memcpy(realdest, dest, (total+1) * sizeof(cell));
+
+	return total;
+}
+
 //This is basically right from dJeyL's lib_convert function
 //This awesome hack modifies the stack frame to have an address offset
 // that will align to the other plugin's memory.
 //I've no idea how he thought of this, but it's great.  No idea how well it works.
 static cell AMX_NATIVE_CALL param_convert(AMX *amx, cell *params)
 {
-	if (!g_NativeStack.size())
+	if (!g_pCurNative || (g_pCurNative->amx != amx))
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
 		return 0;
 	}
-	regnative *pNative = g_NativeStack.top();
+	if (g_pCurNative->style != 1)
-	if (pNative->style != 1)
 	{
 		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
 		return 0;
 	}
 	cell p = params[1];
 
-	AMX *caller = pNative->caller;
+	AMX *caller = g_pCaller;
 
 	unsigned char *data =amx->base+(int)((AMX_HEADER *)amx->base)->dat;
 	unsigned char *realdata = caller->base+(int)((AMX_HEADER *)caller->base)->dat;
@@ -333,7 +451,7 @@ static cell AMX_NATIVE_CALL register_library(AMX *amx, cell *params)
 	int len;
 	char *lib = get_amxstring(amx, params[1], 0, len);
 
-	AddPluginLibrary(lib);
+	AddLibrary(lib, LibType_Library, LibSource_Plugin, g_plugins.findPluginFast(amx));
 
 	return 1;
 }
@@ -364,12 +482,16 @@ static cell AMX_NATIVE_CALL register_native(AMX *amx, cell *params)
 	//we'll apply a safety buffer too
 	//make our function
 	int size = amxx_DynaCodesize();
-#ifndef __linux__
+#if defined(_WIN32)
 	DWORD temp;
 	pNative->pfn = new char[size + 10];
 	VirtualProtect(pNative->pfn, size+10, PAGE_EXECUTE_READWRITE, &temp);
-#else
+#elif defined(__GNUC__)
+# if defined(__APPLE__)
+	pNative->pfn = (char *)valloc(size+10);
+# else
 	pNative->pfn = (char *)memalign(sysconf(_SC_PAGESIZE), size+10);
+# endif
 	mprotect((void *)pNative->pfn, size+10, PROT_READ|PROT_WRITE|PROT_EXEC);
 #endif
 
@@ -386,27 +508,9 @@ static cell AMX_NATIVE_CALL register_native(AMX *amx, cell *params)
 	return 1;
 }
 
-bool LibraryExists(const char *name)
-{
-	for (size_t i=0; i<g_Libraries.size(); i++)
-	{
-		if (stricmp(g_Libraries[i].c_str(), name)==0)
-			return true;
-	}
-
-	return false;
-}
-
-void AddPluginLibrary(const char *name)
-{
-	String f(name);
-	g_Libraries.push_back(f);
-}
-
 void ClearPluginLibraries()
 {
-	g_Libraries.clear();
+	ClearLibraries(LibSource_Plugin);
-
 	for (size_t i=0; i<g_RegNatives.size(); i++)
 	{
 		delete [] g_RegNatives[i]->pfn;
@@ -424,7 +528,7 @@ AMX_NATIVE_INFO g_NativeNatives[] = {
 	{"get_param",		get_param},
 	{"get_param_byref",	get_param_byref},
 	{"set_param_byref",	set_param_byref},
-	{"get_array",		set_array},
+	{"get_array",		get_array},
 	{"set_array",		set_array},
 	//these are dummy functions for floats ;p
 	{"get_param_f",		get_param},
@@ -432,6 +536,7 @@ AMX_NATIVE_INFO g_NativeNatives[] = {
 	{"set_float_byref", set_param_byref},
 	{"get_array_f",		get_array},
 	{"set_array_f",		set_array},
+	{"vdformat",		vdformat},
 	{"param_convert",	param_convert},
 	//////////////////////////
 	{NULL,				NULL},

amxmodx/natives.h

@@ -32,7 +32,9 @@
 #define _INCLUDE_NATIVES_H
 
 //only 16 for now sorry
+#if !defined CALLFUNC_MAXPARAMS
 #define CALLFUNC_MAXPARAMS 16
+#endif
 
 #define CALLFUNC_FLAG_BYREF			1
 #define CALLFUNC_FLAG_BYREF_REUSED	2
@@ -48,9 +50,7 @@ struct regnative
 	String name;
 	char *pfn;
 	int func;
-	AMX *caller;
 	int style;
-	cell params[CALLFUNC_MAXPARAMS];
 };
 
 extern "C" void amxx_DynaInit(void *ptr);
@@ -59,9 +59,7 @@ extern "C" int amxx_DynaFunc(AMX *amx, cell *params);
 extern "C" int amxx_DynaCodesize();
 
 AMX_NATIVE_INFO *BuildNativeTable();
-void AddPluginLibrary(const char *name);
 void ClearPluginLibraries();
-bool LibraryExists(const char *name);
 
 //I couldn't resist :)
 extern AMX_NATIVE_INFO g_NativeNatives[];

amxmodx/newmenus.h

@@ -1,65 +1,152 @@
+/* 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_NEWMENUS_H
 #define _INCLUDE_NEWMENUS_H
 
-#define	MENU_EXIT	-3
+#define	MENU_EXIT		-3
-#define	MENU_BACK	-2
+#define	MENU_BACK		-2
-#define	MENU_MORE	-1
+#define	MENU_MORE		-1
 #define	ITEM_IGNORE		0
 #define	ITEM_ENABLED	1
 #define ITEM_DISABLED	2
 
-#define	MENUITEMS	7
+#define MAX_MENU_ITEMS		10
+
+#define MPROP_PERPAGE	1
+#define MPROP_BACKNAME	2
+#define MPROP_NEXTNAME	3
+#define MPROP_EXITNAME	4
+#define MPROP_TITLE		5
+#define MPROP_EXITALL	6
+#define MPROP_ORDER		7
+#define MPROP_NOCOLORS	8
+#define MPROP_PADMENU	9
+#define MPROP_SET_NUMBER_COLOR	10
 
 typedef int (*MENUITEM_CALLBACK)(int, int, int);
 
+class BlankItem
+{
+private:
+	char *m_text;
+	bool m_num;
+public:
+	BlankItem() : m_text(NULL), m_num(false) { }
+	BlankItem(BlankItem &src) { this->copyFrom(src); } 
+	~BlankItem() { free(m_text); }
+
+	void copyFrom(BlankItem &src)
+	{
+		m_text = src.m_text;
+		m_num = src.m_num;
+		src.m_text = NULL; // stop the src from freeing the buffer
+	}
+	BlankItem &operator = (const BlankItem &src) { this->copyFrom(const_cast<BlankItem&>(src)); return *this; }
+
+	/* is this text instead of a blank */
+	bool IsText() { return m_text != NULL; }
+
+	/* is this a blank instead of text */
+	bool IsBlank() { return m_text == NULL; }
+
+	/* does this item take up a number */
+	bool EatNumber() { return m_num; }
+
+	/* the text this item is to display */
+	const char *GetDisplay() { return m_text == NULL ? "" : m_text; }
+
+	/* sets this item to use a blank */
+	void SetBlank() { free(m_text); m_text = NULL; }
+
+	/* sets this item to display text */
+	void SetText(const char *text) { free(m_text); m_text = strdup(text);  }
+
+	/* sets whether or not this item takes up a line */
+	void SetEatNumber(bool val) { m_num = val; }
+
+};
 struct menuitem
 {
 	String name;
 	String cmd;
+	
 	int access;
 	int handler;
+	
 	MENUITEM_CALLBACK pfn;
 	size_t id;
+
+	CVector<BlankItem> blanks;
 };
 
-typedef unsigned int	menu_t;
+typedef unsigned int menu_t;
-typedef unsigned int	item_t;
+typedef unsigned int item_t;
-typedef unsigned int	page_t;
+typedef unsigned int page_t;
 
 class Menu
 {
 public:
-	Menu(const char *title, int menuId, int thisId);
+	Menu(const char *title, AMX *amx, int fid);
 	~Menu();
+	
 	menuitem *GetMenuItem(item_t item);
 	size_t GetPageCount();
 	size_t GetItemCount();
 	menuitem *AddItem(const char *name, const char *cmd, int access);
+	
 	const char *GetTextString(int player, page_t page, int &keys);
 	bool Display(int player, page_t page);
+	
 	int PagekeyToItem(page_t page, item_t key);
 	int GetMenuMenuid();
-private:
+public:
 	CVector<menuitem * > m_Items;
 	String m_Title;
 	String m_Text;
+
+	String m_OptNames[4];
+
+	String m_ItemColor;
+	bool m_NeverExit;
+	bool m_AutoColors;
+	
 	int menuId;
 	int thisId;
+	int func;
+	bool isDestroying;
+public:
+	unsigned int items_per_page;
 };
 
-/*Menu *CreateMenu(const char *title);
-Menu *GetMenuById(menu_t menu);
-menuitem *GetMenuItem(menu_t menu, item_t item);
-size_t GetMenuPages(menu_t menu);
-size_t GetMenuItems(menu_t menu);
-menuitem *AddMenuItem(menu_t menu, const char *name, const char *cmd, int access);
-bool DisplayMenu(menu_t menu, int player, page_t page);
-int MenuPagekeyToItem(menu_t menu, page_t page, int key);
-int FindByMenuid(int menuid);
-int GetMenuMenuid(menu_t menu);
-const char *GetItemName(menu_t menu, item_t item);
-const char *GetItemCmd(menu_t menu, item_t item);*/
-
 void ClearMenus();
 
 extern CVector<Menu *> g_NewMenus;

amxmodx/nongpl_matches.cpp

@@ -0,0 +1,23 @@
+#include <string.h>
+#include "nongpl_matches.h"
+
+NONGPL_PLUGIN_T NONGPL_PLUGIN_LIST[] = 
+{
+	{"Live", "CZ Gun Game", "czgungame.amxx"},
+	{"Live", "AMXX Gun Game", "czgungame.amxx"},
+	{NULL, NULL, NULL},
+};
+
+NONGPL_CVAR_T NONGPL_CVAR_LIST[] = 
+{
+	{"gg_mode", 0},
+	{"gg_warmuptimer", 0},
+	{"gg_ff", 0},
+	{"gg_fflevel", 0},
+	{"gg_stats", 0},
+	{"gg_dm", 0},
+	{"gg_turbo", 0},
+	{"amx_ggreset", 1},
+	{"amx_gg", 1},
+	{NULL, 0},
+};

amxmodx/nongpl_matches.h

@@ -29,73 +29,23 @@
 *  version.
 */
 
-//by David "BAILOPAN" Anderson
+#ifndef _INCLUDE_AMXMODX_NONGPL_MATCHES_H_
-#ifndef _INCLUDE_CSTACK_H
+#define _INCLUDE_AMXMODX_NONGPL_MATCHES_H_
-#define _INCLUDE_CSTACK_H
 
-template <class T>
+struct NONGPL_PLUGIN_T
-class CStack
 {
-public:
+	const char *author;
-	struct CStackItem
+	const char *title;
-	{
+	const char *filename;
-	public:
-		T item;
-		CStackItem *prev;
-	};
-public:
-	CStack()
-	{
-		mSize = 0;
-		mStack = NULL;
-	}
-	~CStack()
-	{
-		CStackItem *p, *t;
-		p = mStack;
-		while (p)
-		{
-			t = p->prev;
-			delete p;
-			p = t;
-		}
-		mStack = NULL;
-	}
-	bool empty()
-	{
-		return (mSize==0);
-	}
-
-	void push(const T & v)
-	{
-		CStackItem *p = new CStackItem;
-		p->item = v;
-		p->prev = mStack;
-		mStack = p;
-		mSize++;
-	}
-
-	void pop()
-	{
-		CStackItem *p = mStack;
-		mStack = p->prev;
-		delete p;
-		mSize--;
-	}
-
-	T & top()
-	{
-		return mStack->item;
-	}
-
-	size_t size()
-	{
-		return mSize;
-	}
-private:
-	CStackItem *mStack;
-	size_t mSize;
 };
 
-#endif //_INCLUDE_CQUEUE_H
+struct NONGPL_CVAR_T
+{
+	const char *cvar;
+	int type;
+};
 
+extern NONGPL_PLUGIN_T NONGPL_PLUGIN_LIST[];
+extern NONGPL_CVAR_T NONGPL_CVAR_LIST[];
+
+#endif //_INCLUDE_AMXMODX_NONGPL_MATCHES_H_

amxmodx/optimizer.cpp

@@ -0,0 +1,123 @@
+#include <string.h>
+#include "optimizer.h"
+
+int g_opt_level = 0;
+
+#define OP_SYSREQ_C		123
+#define OP_NOP			134
+#define OP_FLOAT_MUL	138
+#define OP_FLOAT_DIV	139
+#define OP_FLOAT_ADD	140
+#define OP_FLOAT_SUB	141
+#define OP_FLOAT_TO		142
+#define OP_FLOAT_ROUND	143
+#define OP_FLOAT_CMP	144
+
+cell op_trans_table[N_Total_FloatOps] =
+{
+	OP_FLOAT_MUL,
+	OP_FLOAT_DIV,
+	OP_FLOAT_ADD,
+	OP_FLOAT_SUB,
+	OP_FLOAT_TO,
+	OP_FLOAT_ROUND,
+	OP_FLOAT_CMP
+};
+
+void OnBrowseRelocate(AMX *amx, cell *oplist, cell *cip)
+{
+	char *codeptr = (char *)amx->base + (long)(((AMX_HEADER *)amx->base)->cod);
+
+	//jump to the parameter;
+	codeptr += *cip;
+	
+	int native = -1;
+	cell n_offs = *(cell *)codeptr;
+	optimizer_s *opt = (optimizer_s *)amx->usertags[UT_OPTIMIZER];
+    for (int i=0; i<N_Total_FloatOps; i++)
+	{
+		if (opt->natives[i] == n_offs)
+		{
+			native = i;
+			break;
+		}
+	}
+
+	if (native != -1)
+	{
+		//we're patching this:
+		// 0x7B 0x??   SYSREQ.C float???
+		//with:
+		// 0x8A        FLOAT.MUL
+		// 0x86	       NOP
+		cell new_opcodes[2];
+		new_opcodes[0] = op_trans_table[native];
+		new_opcodes[1] = OP_NOP;
+		codeptr -= sizeof(cell);
+#if defined __GNUC__ || defined ASM32 || defined JIT
+		*(cell *)codeptr = oplist[new_opcodes[0]];
+		*(cell *)(codeptr + sizeof(cell)) = oplist[new_opcodes[1]];
+#else
+		*(cell *)codeptr = new_opcodes[0];
+		*(cell *)(codeptr + sizeof(cell)) = new_opcodes[1];
+#endif
+	}
+
+	*cip += sizeof(cell);
+	
+	return;
+}
+
+#define FIND_NATIVE(name, bind) \
+	if (amx_FindNative(amx, name, &index) != AMX_ERR_NOTFOUND) \
+		opt->natives[bind] = index;
+
+void _Setup_Optimizer_Stage2(AMX *amx, cell *oplist, cell *cip)
+{
+	int index;
+
+	amx->usertags[UT_BROWSEHOOK] = (void *)OnBrowseRelocate;
+
+	optimizer_s *opt = new optimizer_s;
+	
+	for (int i=0; i<N_Total_FloatOps; i++)
+		opt->natives[i] = -1;
+
+	amx->usertags[UT_OPTIMIZER] = (void *)opt;
+
+	if (g_opt_level & 1)
+	{
+		FIND_NATIVE("floatmul", N_Float_Mul);
+		FIND_NATIVE("floatdiv", N_Float_Div);
+		FIND_NATIVE("floatadd", N_Float_Add);
+		FIND_NATIVE("floatsub", N_Float_Sub);
+	}
+	if (g_opt_level & 4)
+	{
+		FIND_NATIVE("float", N_Float_To);
+		FIND_NATIVE("floatround", N_Float_Round);
+	}
+	if (g_opt_level & 2)
+	{
+#if !defined AMD64
+		if (amxx_CpuSupport())
+		{
+#endif
+			FIND_NATIVE("floatcmp", N_Float_Cmp);
+#if !defined AMD64
+		} else {
+			g_opt_level &= ~(2);
+		}
+#endif
+	}
+	/* we don't do these yet because of radix stuff >:\ */
+	//FIND_NATIVE("floatsin", N_Float_Sin);
+	//FIND_NATIVE("floatcos", N_Float_Cos);
+	//FIND_NATIVE("floattan", N_Float_Tan);
+}
+
+void SetupOptimizer(AMX *amx)
+{
+	amx->usertags[UT_BROWSEHOOK] = (void *)_Setup_Optimizer_Stage2;
+}
+

amxmodx/optimizer.h

@@ -0,0 +1,29 @@
+#ifndef _INCLUDE_AMXMODX_OPTIMIZER_H
+#define _INCLUDE_AMXMODX_OPTIMIZER_H
+
+#include "amx.h"
+
+enum
+{
+	N_Float_Mul=0,
+	N_Float_Div,
+	N_Float_Add,
+	N_Float_Sub,
+	N_Float_To,
+	N_Float_Round,
+	N_Float_Cmp,
+	/* ------------ */
+	N_Total_FloatOps,
+};
+
+struct optimizer_s
+{
+	int natives[N_Total_FloatOps];
+};
+
+void SetupOptimizer(AMX *amx);
+extern "C" int amxx_CpuSupport();
+
+extern int g_opt_level;
+
+#endif //_INCLUDE_AMXMODX_OPTIMIZER_H