Tagged 1.71

updated makefile

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, 
-			const char* pinfo , int pflags , int pfunc, 
-			bool pviewable, CmdMngr* pparent ) : commandline(pcmd) , info(pinfo) {
-
+CmdMngr::Command::Command(CPluginMngr::CPlugin* pplugin, const char* pcmd, const char* pinfo, int pflags, 
+							int pfunc, bool pviewable, CmdMngr* pparent) : commandline(pcmd), info(pinfo)
+{
 	char szCmd[64], szArg[64];
-	*szCmd = 0; *szArg=0;
-	sscanf(pcmd,"%s %s",szCmd,szArg);
+	*szCmd = 0; *szArg = 0;
+	sscanf(pcmd, "%s %s", szCmd, szArg);
 	command.assign(szCmd);
 	argument.assign(szArg);
 	plugin = pplugin;
@@ -73,75 +74,68 @@ 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 );
-  if ( b == 0 ) return 0;
-  setCmdLink( &sortedlists[0] , b );
+	Command* b = new Command(plugin, cmd, info, level, func, listable, this);
+	if (b == 0) return 0;
+	setCmdLink(&sortedlists[0], 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 < 0 ){
-		for (CmdMngr::iterator a = begin( type ); a ; ++a){
-			if ( (*a).id == id )
+	//if (id >= 1024 || id < 0) return (Command*)id;
+	if (id < 0)
+	{
+		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) )
+	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) && (*a).getPlugin()->isExecutable((*a).getFunction()) && (*a).isViewable())
 			++buf_num;
 		++a;
 	}
@@ -149,19 +143,19 @@ int CmdMngr::getCmdNum( int type, int access )
 	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 +163,101 @@ void CmdMngr::setCmdLink( CmdLink** a , Command* c, bool sorted  )
 
 		np->next = *a;
 		*a = np;
-	}
-	else 
-	{
-		while ( *a ) a = &(*a)->next;
+	} else {
+		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_ServerCommand: cmdtype |= 2; break;
 	}
-	if ( cmdtype & 1 ) { // ClientCommand
-		parent->setCmdLink( &parent->sortedlists[1] , this );
-		if ( !parent->registerCmdPrefix(  this ) )
-			parent->setCmdLink( &parent->clcmdlist , this , false );
+
+	if (cmdtype & 1)	// ClientCommand
+	{
+		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 );
-		parent->setCmdLink( &parent->srvcmdlist , this , false );
+	
+	if (cmdtype & 2)	// ServerCommand
+	{
+		parent->setCmdLink(&parent->sortedlists[2], this);
+		parent->setCmdLink(&parent->srvcmdlist, this, false);
 	}
 }
 
-const char* CmdMngr::Command::getCmdType() const {
-	switch( cmdtype ){
-	case 1:	return"client";
+const char* CmdMngr::Command::getCmdType() const
+{
+	switch (cmdtype)
+	{
+		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() );
-	if (*b){
-		setCmdLink( &(*b)->list , cc , false );
+	CmdPrefix** b = findPrefix(cc->getCommand());
+
+	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;
-	CmdPrefix** b = findPrefix( nn );
+	if (*nn == 0) return;
+	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(){
-	while(prefixHead){
+void CmdMngr::clearPrefix()
+{
+	while (prefixHead)
+	{
 		CmdPrefix* a = prefixHead->next;
 		delete prefixHead;
 		prefixHead = a;
@@ -264,7 +275,8 @@ void CmdMngr::clear()
 	clearBufforedInfo();
 }
 
-void CmdMngr::clearBufforedInfo() { 
+void CmdMngr::clearBufforedInfo()
+{
 	buf_type = -1; 
 	buf_access = 0; 
 	buf_id = -1; 

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 matchCommand(const char* cmd) {	return (!strcmp(command.c_str(), cmd ));	}
+		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 int getFunction() const { return function; }
-		inline bool gotAccess(int f) const { return (!flags||((flags & f)==flags)); }
+		inline bool gotAccess(int f) const { return (!flags || ((flags & f) == flags)); }
 		inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
 		inline 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(){  parent->clearCmdLink(&list);  }
+		CmdPrefix(const char* nn, CmdMngr* pp): name(nn), parent(pp), list(0), next(0) {}
+		~CmdPrefix() { parent->clearCmdLink(&list); }
 	} *prefixHead;
 
-	bool registerCmdPrefix( Command* cc );
-	CmdPrefix** findPrefix(  const char* nn );
+	bool registerCmdPrefix(Command* cc);
+	CmdPrefix** findPrefix(const char* nn);
 	void clearPrefix();
 
-	void setCmdLink( CmdLink** a , Command* c, bool sorted = true );
-	void clearCmdLink( CmdLink** phead, bool pclear = false  );
+	void setCmdLink(CmdLink** a, Command* c, bool sorted = true);
+	void clearCmdLink(CmdLink** phead, bool pclear = false);
 
 public:
 	CmdMngr();
-	~CmdMngr() {clear();}
+	~CmdMngr() { clear(); }
 
 	// Interface
 
-	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);
-	int getCmdNum( int type, int access );
+	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);
+	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 begin( int type ) const { return iterator(sortedlists[type]); }
+
+	inline iterator clcmdbegin() const { return iterator(clcmdlist); }
+	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

@@ -48,6 +48,7 @@ EventsMngr::ClEvent::ClEvent(CPluginMngr::CPlugin* plugin,  int func, int flags)
 	m_FlagWorld = (flags & 1) ? true : false;			// flag a
 	m_FlagPlayer = (flags & 2) ? true : false;			// flag b
 	m_FlagOnce = (flags & 4) ? true : false;			// flag c
+	
 	if (flags & 24)
 	{
 		m_FlagAlive = (flags & 16) ? true : false;		// flag e
@@ -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 (iValue & condIter->iValue) execute=true; break;
-				case '<': if (iValue < condIter->iValue) execute=true; break;
-				case '>': if (iValue > condIter->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;
 				}
 				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 (fValue < condIter->fValue) execute=true; break;
-				case '>': if (fValue > condIter->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;
 				}
+				
 				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 (strstr(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;
 				}
+				
 				if (execute)
 					break;
 			}
 		}
+		
 		if (anyConditions && !execute)
 			(*iter).m_Done = true;		// don't execute
 	}
@@ -396,40 +411,22 @@ void EventsMngr::parseValue(const char *sz)
 
 void EventsMngr::executeEvents()
 {
-	int err;
-
 	if (!m_ParseFun)
 	{
 		return;
 	}
 
-#ifdef ENABLEEXEPTIONS
-	try
-	{
-#endif		// #ifdef ENABLEEXEPTIONS
 	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;
-
-			if ((err = amx_Exec((*iter).m_Plugin->getAMX(), NULL, (*iter).m_Func, 1, m_ParseVault ? m_ParseVault[0].iValue : 0)) != AMX_ERR_NONE)
-			{
-				LogError((*iter).m_Plugin->getAMX(), err, "");
+		executeForwards((*iter).m_Func, static_cast<cell>(m_ParseVault ? m_ParseVault[0].iValue : 0));
 	}
-		}
-
-#ifdef ENABLEEXEPTIONS
-	}
-	catch( ... )
-	{
-		AMXXLOG_Log( "[AMXX] fatal error at event execution");
-	}
-#endif		// #ifdef ENABLEEXEPTIONS
 
 	m_CurrentMsgType = -1;
 	m_ParseFun = NULL;
@@ -442,30 +439,30 @@ 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: 
-		sprintf( var, "%d", m_ParseVault[a].iValue );
+			sprintf(var, "%d", m_ParseVault[a].iValue);
 			return var;
 		case MSG_STRING: 
 			return m_ParseVault[a].sValue;
 		default:
-		sprintf( var, "%g", m_ParseVault[a].fValue );
+			sprintf(var, "%g", m_ParseVault[a].fValue);
 			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:
 			return m_ParseVault[a].iValue;
@@ -478,15 +475,15 @@ int EventsMngr::getArgInteger(int a) const
 
 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:
-		return m_ParseVault[a].iValue;
+			return static_cast<float>(m_ParseVault[a].iValue);
 		case MSG_STRING:
-		return atof(m_ParseVault[a].sValue);
+			return static_cast<float>(atof(m_ParseVault[a].sValue));
 		default:
 			return m_ParseVault[a].fValue; 
 	}
@@ -498,6 +495,7 @@ void EventsMngr::clearEvents(void)
 	{
 		m_Events[i].clear();
 	}
+	
 	// delete parsevault
 	if (m_ParseVault)
 	{
@@ -516,25 +514,26 @@ int EventsMngr::getEventId(const char* msg)
 		CS_EventsIds id;
 	} table[] =
 	{
-		{ "CS_DeathMsg" ,	CS_DeathMsg  },
-			//		{ "CS_RoundEnd" ,	CS_RoundEnd  },
-			//		{ "CS_RoundStart" , CS_RoundStart  },
-			//		{ "CS_Restart" ,	CS_Restart  },
-		{ "" ,				CS_Null  }
+		{"CS_DeathMsg",		CS_DeathMsg},
+//		{"CS_RoundEnd",		CS_RoundEnd},
+//		{"CS_RoundStart",	CS_RoundStart},
+//		{"CS_Restart",		CS_Restart},
+		{"",				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 )
-		if ( !strcmp( table[ pos ].name , msg ) )
-			return table[ pos ].id;
+	for (pos = 0; table[pos].id != CS_Null; ++pos)
+		if (!strcmp(table[pos].name, msg))
+			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,
@@ -116,6 +117,7 @@ private:
 		const char* sValue;
 		MsgParamType type;
 	};
+
 	MsgDataEntry *m_ParseVault;
 	int m_ParseVaultSize;
 	void NextParam();			// make sure a new parameter can be added
@@ -130,7 +132,7 @@ private:
 	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,70 +36,71 @@
 // *****************************************************
 // 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 )
-    fclose( fp );
+	if (fp)
+		fclose(fp);
 }
 
-File::operator bool ( ) const
+File::operator bool () const
 {
 	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;
 }
 
-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;
 }
 
-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;
 }
 
-
-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;
 }
 
-File& operator>>( File& f, String& n )
+File& operator>>(File& f, String& n)
 {
-  if ( !f ) return f;
+	if (!f) return f;
 	char temp[1024];
-  fscanf( f.fp , "%s", temp );
+	fscanf(f.fp, "%s", temp);
 	n.assign(temp);
 	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;
 }
 
-int File::getline( char* buf, int sz )
+int File::getline(char* buf, int sz)
 {
 	int a = sz;
 	char *origBuf = buf;
-  if ( *this )
+	
+	if (*this)
 	{
 		int c;
-    while ( sz-- && (c = getc( (*this).fp)) && c != EOF && c != '\n'  )
+		while (sz-- && (c = getc((*this).fp)) && c != EOF && c != '\n')
 		*buf++ = c;
 		*buf = 0;
 	}
@@ -115,12 +116,11 @@ int File::getline( char* buf, int sz )
 	return a - sz;
 }
 
-File& File::skipWs( )
+File& File::skipWs()
 {
-  if ( !*this ) return *this;
+	if (!*this) return *this;
 	int c;
-  while( isspace( c = getc( fp ) ) ){};
-  ungetc( c , fp );
+	while (isspace(c = getc(fp))) {};
+	ungetc(c, fp);
 	return *this;
 }
-

amxmodx/CFile.h

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

amxmodx/CForward.cpp

@@ -30,17 +30,22 @@
 */
 
 #include "amxmodx.h"
+#include "debugger.h"
+#include "binlog.h"
 
 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 ((*iter).isValid() && amx_FindPublic((*iter).getAMX(), name, &func) == AMX_ERR_NONE)
@@ -70,47 +75,80 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 	{
 		if (iter->pPlugin->isExecutable(iter->func))
 		{
+			// Get debug info
+			AMX *amx = (*iter).pPlugin->getAMX();
+			Debugger *pDebugger = (Debugger *)amx->userdata[UD_DEBUGGER];
+			
+			if (pDebugger)
+				pDebugger->BeginExec();
+			
 			// handle strings & arrays
-			int i;
+			int i, ax = 0;
+			
 			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(),
-						(m_ParamTypes[i] == FP_STRING) ? strlen(reinterpret_cast<const char*>(params[i]))+1 : STRINGEX_MAXLENGTH,
-						&realParams[i], &tmp);
-					amx_SetString(tmp, (const char *)(params[i]), 0, 0);
+					if (!str)
+						str = "";
+					amx_Allot(iter->pPlugin->getAMX(), (m_ParamTypes[i] == FP_STRING) ? strlen(str) + 1 : STRINGEX_MAXLENGTH, &realParams[i], &tmp);
+					amx_SetStringOld(tmp, str, 0, 0);
 					physAddrs[i] = tmp;
 				}
 				else if (m_ParamTypes[i] == FP_ARRAY)
 				{
 					cell *tmp;
-					amx_Allot(iter->pPlugin->getAMX(), preparedArrays[params[i]].size,
-						&realParams[i], &tmp);
+					amx_Allot(amx, preparedArrays[params[i]].size, &realParams[i], &tmp);
 					physAddrs[i] = tmp;
+					
 					if (preparedArrays[params[i]].type == Type_Cell)
 					{
 						memcpy(tmp, preparedArrays[params[i]].ptr, preparedArrays[params[i]].size * sizeof(cell));
-					}
-					else
-					{
+					} 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--)
+			{
+				amx_Push(amx, realParams[i]);
+			}
+			
 			// exec
 			cell retVal;
-			int err = amx_Execv(iter->pPlugin->getAMX(), &retVal, iter->func, m_NumParams, realParams);
+#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)
-				LogError(iter->pPlugin->getAMX(), err, "");
+			{
+				//Did something else set an error?
+				if (pDebugger && pDebugger->ErrorExists())
+				{
+					//we don't care, something else logged the error.
+				}
+				else if (err != -1)
+				{
+					//nothing logged the error so spit it out anyway
+					LogError(amx, err, NULL);
+				}
+			}
+			
+			amx->error = AMX_ERR_NONE;
+			
+			if (pDebugger)
+				pDebugger->EndExec();
 
 			// cleanup strings & arrays
 			for (i = 0; i < m_NumParams; ++i)
@@ -122,7 +160,7 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 				else if (m_ParamTypes[i] == FP_STRINGEX)
 				{
 					// copy back
-					amx_GetString(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
+					amx_GetStringOld(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
 					amx_Release(iter->pPlugin->getAMX(), realParams[i]);
 				}
 				else if (m_ParamTypes[i] == FP_ARRAY)
@@ -134,10 +172,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);
 						}
@@ -167,6 +204,7 @@ cell CForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 			}
 		}
 	}
+	
 	return globRetVal;
 }
 
@@ -206,45 +244,73 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 	if (!pPlugin->isExecutable(m_Func))
 		return 0;
 
+	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,
-				(m_ParamTypes[i] == FP_STRING) ? strlen(reinterpret_cast<const char*>(params[i]))+1 : STRINGEX_MAXLENGTH,
-				&realParams[i], &tmp);
-			amx_SetString(tmp, (const char *)(params[i]), 0, 0);
+			amx_Allot(m_Amx, (m_ParamTypes[i] == FP_STRING) ? strlen(str) + 1 : STRINGEX_MAXLENGTH, &realParams[i], &tmp);
+			amx_SetStringOld(tmp, str, 0, 0);
 			physAddrs[i] = tmp;
 		}
 		else if (m_ParamTypes[i] == FP_ARRAY)
 		{
 			cell *tmp;
-			amx_Allot(m_Amx, preparedArrays[params[i]].size,
-				&realParams[i], &tmp);
+			amx_Allot(m_Amx, preparedArrays[params[i]].size, &realParams[i], &tmp);
 			physAddrs[i] = tmp;
+			
 			if (preparedArrays[params[i]].type == Type_Cell)
 			{
 				memcpy(tmp, preparedArrays[params[i]].ptr, preparedArrays[params[i]].size * sizeof(cell));
-			}
-			else
-			{
+			} 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--)
+		amx_Push(m_Amx, realParams[i]);
+	
 	// exec
 	cell retVal;
-	amx_Execv(m_Amx, &retVal, m_Func, m_NumParams, realParams);
+#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 (pDebugger && pDebugger->ErrorExists())
+		{
+			//we don't care, something else logged the error.
+		}
+		else if (err != -1)
+		{
+			//nothing logged the error so spit it out anyway
+			LogError(m_Amx, err, NULL);
+		}
+	}
+	
+	if (pDebugger)
+		pDebugger->EndExec();
+	
+	m_Amx->error = AMX_ERR_NONE;
 
 	// cleanup strings & arrays
 	for (i = 0; i < m_NumParams; ++i)
@@ -256,7 +322,7 @@ cell CSPForward::execute(cell *params, ForwardPreparedArray *preparedArrays)
 		else if (m_ParamTypes[i] == FP_STRINGEX)
 		{
 			// copy back
-			amx_GetString(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
+			amx_GetStringOld(reinterpret_cast<char*>(params[i]), physAddrs[i], 0);
 			amx_Release(m_Amx, realParams[i]);
 		}
 		else if (m_ParamTypes[i] == FP_ARRAY)
@@ -268,10 +334,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);
 				}
@@ -287,9 +352,12 @@ int CForwardMngr::registerForward(const char *funcName, ForwardExecType et, int
 {
 	int retVal = m_Forwards.size() << 1;
 	CForward *tmp = new CForward(funcName, et, numParams, paramTypes);
+	
 	if (!tmp)
 		return -1;				// should be invalid
+	
 	m_Forwards.push_back(tmp);
+	
 	return retVal;
 }
 
@@ -297,22 +365,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;
@@ -321,6 +393,7 @@ int CForwardMngr::registerSPForward(int func, AMX *amx, int numParams, const For
 					 
 		m_SPForwards.push_back(pForward);
 	}
+	
 	return retVal;
 }
 
@@ -328,56 +401,58 @@ 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->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) ?
-		(static_cast<size_t>(id >> 1) < m_SPForwards.size()) :
-		(static_cast<size_t>(id >> 1) < m_Forwards.size()));
+	return (id >= 0) && ((id & 1) ? (static_cast<size_t>(id >> 1) < m_SPForwards.size()) : (static_cast<size_t>(id >> 1) < m_Forwards.size()));
 }
 
 cell CForwardMngr::executeForwards(int id, cell *params)
 {
-	int retVal = (id & 1) ? m_SPForwards[id >> 1]->execute(params, m_TmpArrays) : 
-		m_Forwards[id >> 1]->execute(params, m_TmpArrays);
+	int retVal = (id & 1) ? m_SPForwards[id >> 1]->execute(params, m_TmpArrays) : m_Forwards[id >> 1]->execute(params, m_TmpArrays);
 	m_TmpArraysNum = 0;
+	
 	return retVal;
 }
 
 int CForwardMngr::getParamsNum(int id) const
 {
-	return (id & 1) ? m_SPForwards[id >> 1]->getParamsNum() :
-		m_Forwards[id >> 1]->getParamsNum();
+	return (id & 1) ? m_SPForwards[id >> 1]->getParamsNum() : m_Forwards[id >> 1]->getParamsNum();
 }
 
 ForwardParam CForwardMngr::getParamType(int id, int paramNum) const
 {
-	return (id & 1) ? m_SPForwards[id >> 1]->getParamType(paramNum) :
-		m_Forwards[id >> 1]->getParamType(paramNum);
+	return (id & 1) ? m_SPForwards[id >> 1]->getParamType(paramNum) : m_Forwards[id >> 1]->getParamType(paramNum);
 }
 
 void CForwardMngr::clear()
@@ -386,7 +461,9 @@ void CForwardMngr::clear()
 	{
 		delete *iter;
 	}
+	
 	SPForwardVec::iterator spIter;
+	
 	for (spIter = m_SPForwards.begin(); spIter != m_SPForwards.end(); ++spIter)
 	{
 		delete (*spIter);
@@ -394,8 +471,10 @@ void CForwardMngr::clear()
 
 	m_Forwards.clear();
 	m_SPForwards.clear();
+	
 	while (!m_FreeSPForwards.empty())
 		m_FreeSPForwards.pop();
+	
 	m_TmpArraysNum = 0;
 }
 
@@ -407,74 +486,117 @@ 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;
-
 	m_FreeSPForwards.push(id);
 }
 
+int registerForwardC(const char *funcName, ForwardExecType et, 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.registerForward(funcName, et, num, params);
+}
+
 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);
 }
 
@@ -484,9 +606,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)
@@ -497,7 +622,9 @@ cell executeForwards(int id, ...)
 		else
 			params[i] = (cell)va_arg(argptr, cell);
 	}
+	
 	va_end(argptr);
+	
 	return g_forwards.executeForwards(id, params);
 }
 
@@ -505,13 +632,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,6 +46,9 @@
 #ifndef FORWARD_H
 #define FORWARD_H
 
+#include <stdarg.h>
+#include "sh_stack.h"
+
 const int FORWARD_MAX_PARAMS = 32;
 
 enum ForwardExecType
@@ -77,7 +80,9 @@ enum ForwardArrayElemType
 struct ForwardPreparedArray
 {
 	void *ptr;
+	
 	ForwardArrayElemType type;
+	
 	unsigned int size;
 	bool copyBack;
 };
@@ -88,31 +93,39 @@ class CForward
 	const char *m_FuncName;
 	ForwardExecType m_ExecType;
 	int m_NumParams;
+	
 	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()
-	{ }			// leaves everything unitialized'
+	CForward() {}		// leaves everything unitialized'
+	
 	cell execute(cell *params, ForwardPreparedArray *preparedArrays);
+	
 	int getParamsNum() const
 	{
 		return m_NumParams;
 	}
+	
 	int getFuncsNum() const
 	{
 		return m_Funcs.size();
 	}
+	
 	ForwardParam getParamType(int paramId) const
 	{
 		if (paramId < 0 || paramId >= m_NumParams)
 			return FP_DONE;
+		
 		return m_ParamTypes[paramId];
 	}
 };
@@ -122,10 +135,13 @@ class CSPForward
 {
 	const char *m_FuncName;
 	int m_NumParams;
+	
 	ForwardParam m_ParamTypes[FORWARD_MAX_PARAMS];
 	AMX *m_Amx;
+	
 	int m_Func;
 	bool m_HasFunc;
+
 public:
 	bool isFree;
 public:
@@ -134,18 +150,22 @@ 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;
 	}
+	
 	ForwardParam getParamType(int paramId) const
 	{
 		if (paramId < 0 || paramId >= m_NumParams)
 			return FP_DONE;
+		
 		return m_ParamTypes[paramId];
 	}
 };
@@ -154,7 +174,7 @@ 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;
 
@@ -167,8 +187,7 @@ public:
 
 	CForwardMngr()
 	{ m_TmpArraysNum = 0; }
-	~CForwardMngr()
-	{ }
+	~CForwardMngr() {}
 
 	// Interface
 	// Register normal forward
@@ -176,23 +195,28 @@ public:
 	// Register single plugin forward
 	int registerSPForward(const char *funcName, AMX *amx, int numParams, const ForwardParam * paramTypes);
 	int registerSPForward(int func, AMX *amx, int numParams, const ForwardParam * paramTypes);
+	
 	// Unregister single plugin forward
 	void unregisterSPForward(int id);
+	
 	// execute forward
 	cell executeForwards(int id, cell *params);
 	void clear();							// delete all forwards
+	
 	bool isIdValid(int id) const;			// 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
+	
 	ForwardParam getParamType(int id, int paramId) const;
-	cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type,
-		bool copyBack);		// prepare array
+	cell prepareArray(void *ptr, unsigned int size, ForwardArrayElemType type, 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 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 +226,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; }
-	~sKeyDef() { if (def) delete def; }
+	String *definition;
 	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,41 @@ 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(); }
-		// Make a hash from a string; convert to lowercase first if needed
-		static uint32_t MakeHash(const char *src, bool makeLower = false);
+		int Entries();
 	protected:
-
-		// An entry in the language
-		class LangEntry
-		{
-			// the definition hash
-			uint32_t m_DefHash;
-			// index into the lookup table?
-			int key;
-			// the definition
-			String m_pDef;
-			// is this from the cache or not?
-			bool m_isCache;
-		public:
-			// Set
-			void SetKey(int key);
-			void SetDef(const char *pDef);
-			void SetCache(bool c);
-			// Get
-			uint32_t GetDefHash();
-			int GetKey();
-			const char *GetDef();
-			int GetDefLength();
-			bool GetCache();
-
-			// Constructors / destructors
-			LangEntry();
-			LangEntry(int key);
-			LangEntry(int key, const char *pDef);
-			LangEntry(const LangEntry &other);
-			LangEntry(int pKey, uint32_t defHash, const char *pDef);
-
-			// Reset
-			void Clear();
-		};
-
-		// Get (construct if needed) an entry
-		LangEntry * GetEntry(int key);
-
-		typedef CVector<LangEntry*>	LookUpVec;
+		typedef THash<int, defentry> 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);
 	};
 
 	// Merge definitions into a language
-	void MergeDefinitions(const char *lang, CQueue <sKeyDef*> &tmpVec);
+	void MergeDefinitions(const char *lang, CQueue <sKeyDef> &tmpVec);
 	// strip lowercase; make lower if needed
-	static size_t strip(char *str, char *newstr, bool makelower=false);
+	static size_t strip(char *str, char *newstr, bool makelower = false);
 
 	typedef CVector<CLang*> LangVec;
 	typedef CVector<CLang*>::iterator LangVecIter;
@@ -153,7 +139,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 +152,19 @@ class CLangMngr
 public:
 	// Merge a definitions file
 	int MergeDefinitionFile(const char *file);
-	// Get a definition from a lang name and a kyer
-	const char *GetDef(const char *langName, const char *key);
-	// Format a string
-	const char *Format(const char *src, ...);
+	// Get a definition from a lang name and a key
+	const char *GetDef(const char *langName, const char *key, int &status);
 	// Format a string for an AMX plugin
 	char *FormatAmxString(AMX *amx, cell *params, int parm, int &len);
-	char *FormatString(const char *fmt, va_list &ap);
-	// Save
-	bool Save(const char *filename);
-	// Load
-	bool Load(const char *filename);
-	// Cache
-	bool LoadCache(const char *filename);
-	bool SaveCache(const char *filename);
+	void InvalidateCache();
 	// Get index
 	int GetKeyEntry(String &key);
 	int GetKeyEntry(const char *key);
-	int GetKeyHash(int key);
+	int GetKeyIndex(const char *key);
 	// Get key from index
 	const char *GetKey(int key);
 	// Add key
 	int AddKeyEntry(String &key);
-	// Make a hash from a string; convert to lowercase first if needed
-	uint32_t MakeHash(const char *src, bool makeLower);
 
 	// Get the number of languages
 	int GetLangsNum();
@@ -200,6 +176,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>;
-		CList<T,F> *m_pList;			// The list that created this iterator
+		friend class CList<T, F>;
+		
+		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,206 +35,284 @@
 // *****************************************************
 // class LogEventsMngr
 // *****************************************************
-LogEventsMngr::LogEventsMngr() {
+
+LogEventsMngr::LogEventsMngr()
+{
 	logCurrent = logCounter = 0;
 	logcmplist = 0;
 	arelogevents = false;
-  memset( logevents, 0, sizeof(logevents) );
+	memset(logevents, 0, sizeof(logevents));
 }
 
-LogEventsMngr::~LogEventsMngr() {
+LogEventsMngr::~LogEventsMngr()
+{
 	clearLogEvents();
 }
 
-int LogEventsMngr::CLogCmp::compareCondition(const char* string){
-  if ( logid == parent->logCounter )
+int LogEventsMngr::CLogCmp::compareCondition(const char* string)
+{
+	if (logid == parent->logCounter)
 		return result;
+	
 	logid = parent->logCounter;
-  if ( in ) return result = strstr( string , text.c_str() ) ? 0 : 1;
+	
+	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;
 	int pos = atoi(temp);
-	if ( pos < 0 || pos >= MAX_LOGARGS) pos = 0;
+	
+	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 ){
-	CLogCmp *cmp = parent->registerCondition( filter );
-	if ( cmp == 0 ) return;
-	for(LogCond* c = filters; c ; c = c->next){
-		if ( c->argnum == cmp->pos ){
-			c->list = new LogCondEle( cmp , c->list );
+void LogEventsMngr::CLogEvent::registerFilter(char* filter)
+{
+	CLogCmp *cmp = parent->registerCondition(filter);
+	if (cmp == 0) return;
+	
+	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;
-	filters = new LogCond( cmp->pos , aa  , filters );
+	
+	LogCondEle* aa = new LogCondEle(cmp, 0);
+	
+	if (aa == 0)
+		return;
+
+	filters = new LogCond(cmp->pos, aa, filters);
 }
 
-void LogEventsMngr::setLogString( char* frmt, va_list& vaptr ) {
+void LogEventsMngr::setLogString(char* frmt, va_list& vaptr)
+{
 	++logCounter;
-	int len = vsnprintf (logString, 255 , frmt, vaptr );
-	if ( len == - 1) {
+	int len = vsnprintf(logString, 255, frmt, vaptr);
+	
+	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(char* frmt, ...)
+{
 	++logCounter;
 	va_list logArgPtr;
-	va_start ( logArgPtr , frmt );
-	int len = vsnprintf(logString, 255 , frmt, logArgPtr );
-	if ( len == - 1) {
+	va_start(logArgPtr, frmt);
+	int len = vsnprintf(logString, 255, frmt, logArgPtr);
+	
+	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;
-  while( *b && logArgc < MAX_LOGARGS ){
+	
+	while (*b && logArgc < MAX_LOGARGS)
+	{
 		a = 0;
-    if ( *b == '"' ) {
+		
+		if (*b == '"')
+		{
 			++b;
-      while ( *b && *b != '"' && a < 127 ) 
+			
+			while (*b && *b != '"' && a < 127) 
 				logArgs[logArgc][a++] = *b++;
+			
 			logArgs[logArgc++][a] = 0;
-      if ( *b) b+=2; // thanks to double terminator
+			if (*b) b+=2; // thanks to double terminator
 		}
-    else if ( *b == '('  ) {
+		else if (*b == '(')
+		{
 			++b;
-      while ( *b && *b != ')' && a < 127 ) 
+			
+			while (*b && *b != ')' && a < 127) 
 				logArgs[logArgc][a++] = *b++;
+			
 			logArgs[logArgc++][a] = 0;
-      if ( *b) b+=2;
-    }
-    else {
-      while ( *b && *b != '(' && *b != '"' && a < 127 ) 
+			if (*b) b+=2;
+		} else {
+			while (*b && *b != '(' && *b != '"' && a < 127) 
 			logArgs[logArgc][a++] = *b++;
-      if ( *b ) --a;
+			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;
+
 	arelogevents = true;
 	CLogEvent** d = &logevents[pos];
-  while(*d) d = &(*d)->next;
-  return *d = new CLogEvent( plugin , func, this );
+	
+	while (*d)
+		d = &(*d)->next;
+	
+	return *d = new CLogEvent(plugin, func, this);
 }
 
 void LogEventsMngr::executeLogEvents()
 {
-    int err;
 	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;
 		}
 		
 		if (valid)
 		{
-			if ((err = amx_Exec(a->plugin->getAMX(), NULL , a->func , 0)) != AMX_ERR_NONE)
-				LogError(a->plugin->getAMX(), err, "");
+			executeForwards(a->func);
 		}
 	}
 }
 
-void LogEventsMngr::clearLogEvents(){
+void LogEventsMngr::clearLogEvents()
+{
 	logCurrent = logCounter = 0;
 	arelogevents = false;
-  for(int i = 0; i < MAX_LOGARGS + 1; ++i){
+	
+	for (int i = 0; i < MAX_LOGARGS + 1; ++i)
+	{
 		CLogEvent **a = &logevents[i];
-    while(*a){
+		while (*a)
+		{
 			CLogEvent* bb = (*a)->next;
 			delete *a;
 			*a = bb;
 		}
 	}
+	
 	clearConditions();
 }
 
-void LogEventsMngr::clearConditions() {
-  while (logcmplist){
+void LogEventsMngr::clearConditions()
+{
+	while (logcmplist)
+	{
 		CLogCmp* a = logcmplist->next;
 		delete logcmplist;
 		logcmplist = a;
 	}
 }
 
-LogEventsMngr::CLogEvent::LogCond::~LogCond() {  
-	while( list ) {
+LogEventsMngr::CLogEvent::LogCond::~LogCond()
+{
+	while (list)
+	{
 		LogCondEle* cc = list->next;
 		delete list;
 		list = cc;
 	}
 }
 
-LogEventsMngr::CLogEvent::~CLogEvent() {
-	while( filters ) {
+LogEventsMngr::CLogEvent::~CLogEvent()
+{
+	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,8 +40,8 @@
 // class LogEventsMngr
 // *****************************************************
 
-class LogEventsMngr {
-
+class LogEventsMngr
+{
 	char logString[256];
 	char logArgs[MAX_LOGARGS][128];
 	int logArgc;
@@ -53,7 +53,6 @@ public:
 	class CLogCmp;
 	class iterator;
 	class CLogEvent;
-
 	friend class CLogEvent;
 	friend class CLogCmp;
 	friend class iterator;
@@ -62,104 +61,118 @@ public:
 	{
 		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) {
+		
+		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:
 	
+	public:
 		int compareCondition(const char* string);
 	};
 
 private:
-
 	CLogCmp *logcmplist;
-
 public:
 
-  class CLogEvent {
+	class CLogEvent
+	{
 		friend class LogEventsMngr;
 		friend class iterator;
-	struct LogCondEle {
+		
+		struct LogCondEle
+		{
 			CLogCmp *cmp;
 			LogCondEle *next;
-		LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c) , next(n) { }
+			LogCondEle(CLogCmp *c, LogCondEle *n): cmp(c), next(n) {}
 		};
-	struct LogCond {
+	
+		struct LogCond
+		{
 			int argnum;
+			
 			LogCondEle *list;
 			LogCond *next;
-		LogCond( int a , LogCondEle* ee , LogCond* n ) : argnum(a) , list(ee), next(n)  {}
+			LogCond(int a, LogCondEle* ee, LogCond* n) : argnum(a), list(ee), next(n) {}
 			~LogCond();
 		};
+		
 		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(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 );
+		void registerFilter(char* filter);
 		inline int getFunction() { return func; }
 	};
 
 private:
-
-  CLogEvent *logevents[MAX_LOGARGS+1];
-  CLogEvent *getValidLogEvent( CLogEvent * a );
+	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 );
+	CLogEvent* registerLogEvent(CPluginMngr::CPlugin* plugin, int func, int pos);
 	inline bool logEventsExist() { return arelogevents; } 
-  void setLogString( char* frmt, va_list& vaptr );
-  void setLogString( char* frmt , ... );
-  void parseLogString(  );
+	
+	void setLogString(char* frmt, va_list& vaptr);
+	void setLogString(char* frmt, ...);
+	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 ]; }
+	inline const char* getLogArg(int i) { return (i < 0 || i >= logArgc) ? "" : logArgs[i]; }
 	void clearLogEvents();
 
-
-  class iterator {
+	class iterator
+	{
 		CLogEvent* a;
 		LogEventsMngr* b;
+	
 	public:
-	  inline iterator(CLogEvent*aa,LogEventsMngr* bb) : a(aa), b(bb) {}
-	  inline iterator& operator++() {
-		  a = b->getValidLogEvent( a->next );
+		inline iterator(CLogEvent*aa, LogEventsMngr* bb) : a(aa), b(bb) {}
+			
+		inline iterator& operator++()
+		{
+			a = b->getValidLogEvent(a->next);
 			return *this;
 		}
+
 		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; }
-	  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,7 +35,8 @@
 // *****************************************************
 // 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)
+{
 	plugin = a;
 	keys = k;
 	menuid = mi;
@@ -46,32 +47,80 @@ MenuMngr::MenuCommand::MenuCommand( CPluginMngr::CPlugin *a, int mi, int k, int
 MenuMngr::~MenuMngr() 
 {
 	clear();
+	MenuMngr::MenuIdEle::uniqueid = 0;
 }
 
 int MenuMngr::findMenuId(const char* name, AMX* amx)
 {
-  for( MenuIdEle* b = headid; b ; b = b->next) {
-    if ( (!b->amx || amx == b->amx) && strstr(name,b->name.c_str()) )
+	for (MenuIdEle* b = headid; b; b = b->next)
+	{
+		if ((!amx || !b->amx || amx == b->amx) && strstr(name,b->name.c_str()))
 			return b->id;
 	}
+	
 	return 0;
 }
 
-int MenuMngr::registerMenuId(const char* n, AMX* a )
+void MenuMngr::removeMenuId(int id)
 {
-  int id = findMenuId( n, a );
-  if (id) return id;
-  headid = new MenuIdEle( n, a , headid  );
+	MenuIdEle *n = headid;
+	MenuIdEle *l = NULL;
+	while (n)
+	{
+		if (n->id == id)
+		{
+			if (l)
+				l->next = n->next;
+			else
+				headid = n->next;
+			delete n;
+			break;
+		}
+		l = n;
+		n = n->next;
+	}
+
+	MenuCommand *c = headcmd;
+	MenuCommand *lc = NULL;
+	MenuCommand *tmp;
+	while (c)
+	{
+		if (c->menuid == id)
+		{
+			if (lc)
+				lc->next = c->next;
+			else
+				headcmd = c->next;
+			tmp = c->next;
+			delete c;
+			c = tmp;
+		} else {
+			lc = c;
+			c = c->next;
+		}
+	}
+}
+
+int MenuMngr::registerMenuId(const char* n, AMX* a)
+{
+	int id = findMenuId(n, a);
+	
+	if (id)
+		return id;
+	
+	headid = new MenuIdEle(n, a, headid);
+	
 	if (!headid)
 		return 0;			// :TODO: Better error report
+	
 	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) 
 {
 	MenuCommand** temp = &headcmd;
-	while(*temp) temp = &(*temp)->next;
-	*temp = new MenuCommand(a,mi, k,f);
+	while (*temp) temp = &(*temp)->next;
+	*temp = new MenuCommand(a, mi, k, f);
 }
 
 void MenuMngr::clear()

amxmodx/CMenu.h

@@ -43,17 +43,18 @@ class MenuMngr
 		String name;
 		AMX* amx;
 		MenuIdEle* next;
+		
 		int id;
 		static int uniqueid;
-    MenuIdEle( const char* n, AMX* a, MenuIdEle* m ) : name( n ) , amx(a) , next( m ) {
+		
+		MenuIdEle(const char* n, AMX* a, MenuIdEle* m) : name(n), amx(a), next(m)
+		{
 			id = ++uniqueid;
 		}
-	~MenuIdEle() { --uniqueid; }
 	} *headid;
 
 public:
 		class iterator;
-
 private:
 
 	class MenuCommand 
@@ -65,28 +66,29 @@ private:
 		int menuid;
 		int keys;
 		int function;
+		
 		MenuCommand* next;
-	  MenuCommand( CPluginMngr::CPlugin *a, int mi, int k, int f );
+		MenuCommand(CPluginMngr::CPlugin *a, int mi, int k, int f);
 	public:
 		inline int getFunction() { return function; }
 		inline CPluginMngr::CPlugin* getPlugin() { return plugin; }
-	  inline bool matchCommand( int m, int k  ) { return ((m == menuid) && (keys & k)); }
+		inline bool matchCommand(int m, int k) { return ((m == menuid) && (keys & k)); }
 	} *headcmd;
 	
 public:
-	
 	MenuMngr() { headid = 0; headcmd = 0; }
 	~MenuMngr();
 
 	// Interface
 
-
 	int findMenuId(const char* name, AMX* a = 0);
-	int registerMenuId(const char* n, AMX* a );
-	void registerMenuCmd( CPluginMngr::CPlugin *a,int mi, int k , int f  );
+	int registerMenuId(const char* n, AMX* a);
+	void removeMenuId(int id);
+	void registerMenuCmd(CPluginMngr::CPlugin *a, int mi, int k, int f);
 	void clear();
 
-	class iterator {
+	class iterator
+	{
 		MenuCommand* a;
 	public:
 		iterator(MenuCommand*aa) : a(aa) {}
@@ -96,12 +98,9 @@ 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); }
-	
-
 };
 
-#endif
-
-
+#endif //MENUS_H

amxmodx/CMisc.cpp

@@ -29,11 +29,12 @@
 *  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;
@@ -48,6 +49,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,46 +58,107 @@ void CPlayer::Init( edict_t* e , int i )
 	team.clear();
 }
 
-void CPlayer::Disconnect() {
+void CPlayer::Disconnect()
+{
 	ingame = false;
 	initialized = false;
 	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();
+
 	bot = 0;
+	menu = 0;
+	newmenu = -1;
 }
 
-void CPlayer::PutInServer() {
+void CPlayer::PutInServer()
+{
 	playtime = gpGlobals->time;
 	ingame = true;
 }
-bool CPlayer::Connect(const char* connectname,const char* ipaddress) {
+
+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;
 	bot = IsBot();
 	death_killer = 0;
-  memset(flags,0,sizeof(flags));
-  memset(weapons,0,sizeof(weapons));
+	menu = 0;
+	newmenu = -1;
+	
+	memset(flags, 0, sizeof(flags));
+	memset(weapons, 0, sizeof(weapons));
+	
 	initialized = true;
 	authorized = false;
 
-  const char* authid = GETPLAYERAUTHID( pEdict );
+	for (int i=0; i<=4; i++)
+	{
+		channels[i] = 0.0f;
+		hudmap[i] = 0;
+	}
 
-  if ( (authid == 0) || (*authid == 0) 
-	  || (strcmp( authid , "STEAM_ID_PENDING") == 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;
-  if ( a == 0 ) return;
+	if (a == 0) return;
 	a->player = player;
 	a->grenade = grenade;
 	a->time = gpGlobals->time + time;
@@ -103,34 +167,37 @@ void Grenades::put( edict_t* grenade, float time, int type, CPlayer* player  )
 	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;
 	Obj** a = &head;
-  while ( *a ){
-    if ( (*a)->time > gpGlobals->time ) {
-      if ( (*a)->grenade == enemy ) {
+	
+	while (*a)
+	{
+		if ((*a)->time > gpGlobals->time)
+		{
+			if ((*a)->grenade == enemy)
+			{
 				found = true;
 				(*p) = (*a)->player;
 				type = (*a)->type;
 			}
-    }
-    else {
+		} else {
 			Obj* b = (*a)->next;
 			delete *a;
 			*a = b;
-
 			continue;
-
 		}
 		a = &(*a)->next;
 	}
+	
 	return found;
 }
 
 void Grenades::clear()
 {
-  while(head){
+	while (head)
+	{
 		Obj* a = head->next;
 		delete head;
 		head = a;
@@ -140,93 +207,119 @@ void Grenades::clear()
 // *****************************************************
 // 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) {
-	if ( (head[a].amx == p) && (head[a].value == v) )
+	for (int a = 0; a < num; ++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;
 
 	head[num].value = v;
 	head[num].amx = p;
+	
 	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;
-    while( *a ){
-		if ( strcmp((*a)->name.c_str(),n) == 0 ){
-			if (s != -1){
+	
+	while (*a)
+	{
+		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);
+	
+	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 ( !strcmpi(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,47 @@
 #define CMISC_H
 
 #include "CList.h"
+#include "sh_list.h"
 
 // *****************************************************
 // class CCVar
 // *****************************************************
+
 class CCVar
 {
 	cvar_t cvar;
 	String name;
 	String plugin;
+
 public:	
-    CCVar( const char* pname, const char* pplugin, 
-		int pflags, float pvalue ) : name(pname) , plugin(pplugin ) {
+	CCVar(const char* pname, const char* 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); }
 };
 
-
-
 // *****************************************************
 // class CPlayer
 // *****************************************************
 
+struct ClientCvarQuery_Info
+{
+	int resultFwd;
+	int requestId;
+	int paramLen;
+	cell *params;
+};
+
 class CPlayer 
 {
-	
 public:
 	edict_t* pEdict;
 	
@@ -76,11 +85,14 @@ public:
 	bool ingame;
 	bool bot;
 	bool authorized;
+	bool vgui;	
 
 	float time;
 	float playtime;
+	float menuexpire;
 	
-	struct {
+	struct
+	{
 		int ammo;
 		int clip;
 	} weapons[MAX_WEAPONS];
@@ -99,26 +111,38 @@ public:
 	int death_victim;
 	bool death_tk;
 	String death_weapon;
+	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(){
-		return ((pEdict->v.flags & FL_FAKECLIENT)?true:false);
+	bool Connect(const char* connectname, const char* ipaddress);
+
+	inline bool IsBot()
+	{
+		return ((pEdict->v.flags & FL_FAKECLIENT) ? true : false);
 	}
 
-	inline bool IsAlive(){
-		return ((pEdict->v.deadflag==DEAD_NO)&&(pEdict->v.health>0));
+	inline bool IsAlive()
+	{
+		return ((pEdict->v.deadflag == DEAD_NO) && (pEdict->v.health > 0));
 	}
 
 	inline void Authorize() { authorized = true; }
 
+	int NextHUDChannel();
+
 };
 
 // *****************************************************
@@ -136,31 +160,35 @@ class Grenades
 		Obj* next;
 	} *head;
 
-
 public:
 	Grenades() { head = 0; }
 	~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);
+	bool find(edict_t* enemy, CPlayer** p, int& type);
 	void clear();
 };
 
 // *****************************************************
 // class ForceObject
 // *****************************************************
-class ForceObject {
+
+class ForceObject
+{
 	String filename;
 	FORCE_TYPE type;
 	Vector mins;
 	Vector maxs;
 	AMX* amx;
 public:
-    ForceObject(const char* n, FORCE_TYPE c,Vector& mi, Vector& ma, AMX* a) :
-    filename(n) , type(c), mins(mi), maxs(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) {}
+
 	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; }
 };
 
@@ -170,30 +198,38 @@ public:
 
 class XVars
 {
-  struct XVarEle  {
+	struct XVarEle
+	{
 		AMX* amx;
 		cell* value;
 	};
 
 	XVarEle* head;
+	
 	int size;
 	int num;
-
-  int realloc_array( int nsize );
+	int realloc_array(int nsize);
 
 public:
 	XVars() { num = 0; size = 0; head = 0; }
 	~XVars() { clear(); }
+	
 	void clear();
-  int put( AMX* a, cell* v );
-  inline cell getValue( int a ) {
-	  return ( a >= 0 && a < num ) ? *(head[a].value) : 0;
+	int put(AMX* a, cell* v);
+	
+	inline cell getValue(int a)
+	{
+		return (a >= 0 && a < num) ? *(head[a].value) : 0;
 	}
-  inline int setValue( int a, cell v ) { 
-	  if ( a >= 0 && a < num ){
+
+	inline int setValue(int a, cell v)
+	{ 
+		if (a >= 0 && a < num)
+		{
 			*(head[a].value) = v;
 			return 0;
 		}
+
 		return 1;
 	}
 };
@@ -201,34 +237,41 @@ public:
 // *****************************************************
 // 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;
 		char tid;
 		static char uid;
 		TeamEle* next;
-    TeamEle(const char* n, int& i) : name(n) , id(i) , next(0) {
+		
+		TeamEle(const char* n, int& i) : name(n), id(i), next(0)
+		{
 			tid = uid++;
-	};
-	~TeamEle(){ --uid; }
+		}
+		
+		~TeamEle() { --uid; }
 	} *head;
 
 	int newTeam;
@@ -236,15 +279,11 @@ class TeamIds
 public:
 	TeamIds();
 	~TeamIds();
-  void registerTeam( const char* n ,int s );
-  int findTeamId( const char* n);
-  int findTeamIdCase( const char* n);
+	
+	void registerTeam(const char* n, int s);
+	int findTeamId(const char* n);
+	int findTeamIdCase(const char* n);
 	inline bool isNewTeam() { return newTeam ? true : false; }
 };
 
-
-
-#endif
-
-
-
+#endif //CMISC_H

amxmodx/CModule.cpp

@@ -32,14 +32,9 @@
 #include "amxmodx.h"
 
 #ifndef FAR
-#define FAR
+	#define FAR
 #endif
 
-// Old
-typedef int (FAR *QUERYMOD)(module_info_s**);
-typedef int (FAR *ATTACHMOD)(pfnamx_engine_g*,pfnmodule_engine_g*);
-typedef int (FAR *DETACHMOD)(void);
-
 // New
 typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
 typedef int (FAR *QUERYMOD_NEW)(int * /*ifvers*/, amxx_module_info_s * /*modInfo*/);
@@ -47,81 +42,6 @@ typedef int (FAR *ATTACHMOD_NEW)(PFN_REQ_FNPTR /*reqFnptrFunc*/);
 typedef int (FAR *DETACHMOD_NEW)(void);
 typedef void (FAR *PLUGINSLOADED_NEW)(void);
 
-// Old
-// These functions are needed since Small Abstract Machine 2.5.0
-int wamx_FindPublic(AMX *amx, char *name, int *index)
-{ return amx_FindPublic(amx, name, index); }
-
-int wamx_FindPubVar(AMX *amx, char *varname, cell *amx_addr)
-{ return amx_FindPubVar(amx, varname, amx_addr); }
-
-int wamx_GetString(char *dest, cell *source)
-{ return amx_GetString(dest, source, 0); }
-
-AMX_NATIVE_INFO *wamx_NativeInfo(char *name, AMX_NATIVE func)
-{ return amx_NativeInfo(name, func); }
-
-int wamx_SetString(cell *dest, char *source, int pack)
-{ return amx_SetString(dest, source, pack, 0); }
-
-pfnamx_engine_g engAmxFunc = {
-  amx_Align16,
-  amx_Align32,
-  amx_Allot,
-  amx_Callback,
-  amx_Clone,
-  amx_Debug,
-  amx_Exec,
-  amx_Execv,
-  wamx_FindPublic,
-  wamx_FindPubVar,
-  amx_FindTagId,
-  amx_Flags,
-  amx_GetAddr,
-  amx_GetPublic,
-  amx_GetPubVar,
-  wamx_GetString,
-  amx_GetTag,
-  amx_GetUserData,
-  amx_Init,
-  amx_InitJIT,
-  amx_MemInfo,
-  amx_NameLength,
-  wamx_NativeInfo,
-  amx_NumPublics,
-  amx_NumPubVars,
-  amx_NumTags,
-  amx_RaiseError,
-  amx_Register,
-  amx_Release,
-  amx_SetCallback,
-  amx_SetDebugHook,
-  wamx_SetString,
-  amx_SetUserData,
-  amx_StrLen,
-};
-
-pfnmodule_engine_g engModuleFunc = {
-  add_amxnatives,
-  build_pathname,
-  copy_amxmemory,
-  format_amxstring,
-  get_amxaddr,
-  get_amxscript,
-  get_amxscriptname,
-  get_amxstring,
-  get_modname,
-  load_amxscript,
-  print_srvconsole,
-  report_error,
-  set_amxnatives,
-  set_amxstring,
-  amxstring_len,
-  unload_amxscript,
-  alloc_amxmemory,
-  free_amxmemory,
-};
-
 // *****************************************************
 // class CModule
 // *****************************************************
@@ -135,7 +55,7 @@ CModule::CModule(const char* fname)
 CModule::~CModule()
 {
 	// old & new
-	if ( m_Handle )
+	if (m_Handle)
 		DLFREE(m_Handle);
 
 	clear();
@@ -147,11 +67,10 @@ void CModule::clear(bool clearFilename)
 	m_Metamod = false;
 	m_Handle = NULL;
 	m_Status = MODULE_NONE;
+	
 	if (clearFilename)
 		m_Filename.assign("unknown");
 
-	// old
-	m_InfoOld = NULL;
 	// new
 	m_Amxx = false;
 	m_InfoNew.author = "unknown";
@@ -163,6 +82,26 @@ void CModule::clear(bool clearFilename)
 	m_Natives.clear();
 }
 
+bool CModule::attachMetamod(const char *mmfile, PLUG_LOADTIME now)
+{
+	void **handle;
+	void *dummy = NULL;
+
+	if (!m_Handle)
+		handle = &dummy;
+	else
+		handle = (void **)&m_Handle;
+
+	int res = LoadMetamodPlugin(mmfile, handle, now);
+
+	if (!res)
+	{
+		m_Metamod = false;
+	}
+
+	return true;
+}
+
 bool CModule::attachModule()
 {
 	// old & new
@@ -176,6 +115,7 @@ bool CModule::attachModule()
 
 		if (!AttachFunc_New)
 			return false;
+		
 		g_ModuleCallReason = ModuleCall_Attach;
 		g_CurrentlyCalledModule = this;
 		int retVal = (*AttachFunc_New)(Module_ReqFnptr);
@@ -200,17 +140,11 @@ bool CModule::attachModule()
 				m_Status = MODULE_BADLOAD;
 				return false;
 		}
+	} else {
+		m_Status = MODULE_BADLOAD;
 	}
-	else
-	{
-		// old
-		ATTACHMOD AttachFunc = (ATTACHMOD)DLPROC(m_Handle, "AMX_Attach");
 
-		if (AttachFunc)
-			(*AttachFunc)(&engAmxFunc,&engModuleFunc);
-		m_Status = MODULE_LOADED;
-		return true;
-	}
+	return false;
 }
 
 bool CModule::queryModule()
@@ -231,6 +165,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;
@@ -240,6 +175,7 @@ bool CModule::queryModule()
 		int retVal = (*queryFunc_New)(&ifVers, &m_InfoNew);
 		g_CurrentlyCalledModule = NULL;
 		g_ModuleCallReason = ModuleCall_NotCalled;
+		
 		switch (retVal)
 		{
 			case AMXX_PARAM:
@@ -269,48 +205,11 @@ bool CModule::queryModule()
 
 		m_Status = MODULE_QUERY;
 		return true;
-	}
-	else
-	{
-		// old interface not 64 bit compatible
-#if SMALL_CELL_SIZE == 64
-		m_Status = MODULE_NOT64BIT;
-		return false;
-#else
-		// Try old interface
-		QUERYMOD queryFunc_Old = (QUERYMOD)DLPROC(m_Handle,"AMX_Query"); // check what version
-		if (!queryFunc_Old)
-		{
+	} else {
 		m_Status = MODULE_NOQUERY;
+		m_Amxx = false;
 		return false;
 	}
-
-		(*queryFunc_Old)(&m_InfoOld);
-
-		if (!m_InfoOld)
-		{
-			m_Status = MODULE_NOINFO;
-			return false;
-		}
-
-		if (m_InfoOld->ivers != AMX_INTERFACE_VERSION)
-		{
-			m_Status = MODULE_OLD;
-			return false;
-		}
-
-		// Check for attach
-		if (!DLPROC(m_Handle, "AMX_Attach"))
-		{
-			m_Status = MODULE_NOATTACH;
-			return false;
-		}
-
-		m_InfoOld->serial = (long int)this;
-		m_Status = MODULE_QUERY;
-		return true;
-#endif
-	}
 }
 
 bool CModule::detachModule()
@@ -321,6 +220,7 @@ bool CModule::detachModule()
 	if (m_Amxx)
 	{
 		DETACHMOD_NEW detachFunc_New = (DETACHMOD_NEW)DLPROC(m_Handle, "AMXX_Detach");
+		
 		if (detachFunc_New)
 		{
 			g_ModuleCallReason = ModuleCall_Detach;
@@ -330,14 +230,17 @@ bool CModule::detachModule()
 			g_ModuleCallReason = ModuleCall_NotCalled;
 		}
 	}
-	else
+
+#ifndef FAKEMETA
+	if (IsMetamod())
 	{
-		DETACHMOD detachFunc_Old = (DETACHMOD)DLPROC(m_Handle, "AMX_Detach");
-		if (detachFunc_Old)
-			(*detachFunc_Old)();
+		UnloadMetamodPlugin(m_Handle);
 	}
+#endif
+	
 	DLFREE(m_Handle);
 	clear();
+	
 	return true;
 }
 
@@ -350,14 +253,16 @@ 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_QUERY:		return "pending";
@@ -373,5 +278,6 @@ const char* CModule::getStatus() const
 		case MODULE_NOT64BIT:	return "not 64bit";
 		default:				break;
 	}
+	
 	return "unknown";
 }

amxmodx/CModule.h

@@ -36,7 +36,8 @@
 #ifndef CMODULE_H
 #define CMODULE_H
 
-enum MODULE_STATUS {
+enum MODULE_STATUS
+{
 	MODULE_NONE,			// No module loaded
 	MODULE_QUERY,			// Query failed
 	MODULE_BADLOAD,			// Bad file or the module writer messed something up ;]
@@ -57,22 +58,23 @@ struct amxx_module_info_s
 	const char *author;
 	const char *version;
 	int reload;				// reload on mapchange when nonzero
+	const char *logtag;		//added in version 2
 };
 
-
 #define AMXX_OK					0			/* no error */
 #define AMXX_IFVERS				1			/* interface version */
 #define AMXX_PARAM				2			/* Invalid parameter */
 #define AMXX_FUNC_NOT_PRESENT	3			/* Function not present */
 
-#define AMXX_INTERFACE_VERSION 1
+#define AMXX_INTERFACE_VERSION	3
 
 class CModule 
 {
 	String m_Filename;				// Filename
+	
 	bool m_Metamod;					// Using metamod?
 	bool m_Amxx;					// Using new module interface?
-	module_info_s* m_InfoOld;		// module info (old module interface)
+	
 	amxx_module_info_s m_InfoNew;	// module info (new module interface)
 	DLHANDLE m_Handle;				// handle
 	MODULE_STATUS m_Status;			// status
@@ -84,30 +86,32 @@ public:
 	~CModule();
 
 	// Interface
+	
 	bool attachModule();
 	bool queryModule();
 	bool detachModule();
+
+#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_Amxx ? (m_InfoNew.author) : (m_InfoOld ? m_InfoOld->author : "unknown"); }
-	inline const char* getVersion() const { return m_Amxx ? (m_InfoNew.version) : (m_InfoOld ? m_InfoOld->version : "unknown"); }
-	inline const char* getName() const { return m_Amxx ? (m_InfoNew.name) : (m_InfoOld ? m_InfoOld->name : "unknown"); }
-	inline module_info_s* getInfo() const { return m_InfoOld; }	// old
+	inline const char* getAuthor() const { return m_InfoNew.author; }
+	inline const char* getVersion() const { return m_InfoNew.version; }
+	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 isReloadable() { return m_Amxx ? ((m_Status == MODULE_LOADED) && (m_InfoNew.reload != 0)) : ( (m_Status==MODULE_LOADED) && (m_InfoOld->type==RELOAD_MODULE)); }
+	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(); }
-	void CModule::CallPluginsLoaded();
+	inline bool IsMetamod() { return m_Metamod; }
+	
+	void CallPluginsLoaded();
 
 	CList<AMX_NATIVE_INFO*> m_Natives;
 };
 
-
-
-#endif
-
-
-
+#endif //CMODULE_H

amxmodx/CPlugin.cpp

@@ -33,28 +33,61 @@
 #include "CPlugin.h"
 #include "CForward.h"
 #include "CFile.h"
+#include "amx.h"
+#include "natives.h"
+#include "debugger.h"
 
-CPluginMngr::CPlugin* CPluginMngr::loadPlugin(const char* path, const char* name, char* error, int debug) {	
+extern const char *no_function;
+
+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;
 	--pCounter;
 }
 
-int  CPluginMngr::loadPluginsFromFile( const char* filename )
+void CPluginMngr::Finalize()
 {
-	FILE *fp = fopen(build_pathname("%s",filename) , "rt");
+	if (m_Finalized)
+		return;
 	
-	if ( !fp ) 
+	pNatives = BuildNativeTable();
+	CPlugin *a = head;
+	
+	while (a)
 	{
-		AMXXLOG_Log( "[AMXX] Plugins list not found (file \"%s\")",filename);
+		if (a->getStatusCode() == ps_running)
+		{
+			amx_Register(a->getAMX(), pNatives, -1);
+			a->Finalize();
+		}
+		a = a->next;
+	}
+	
+	m_Finalized = true;
+}
+
+int CPluginMngr::loadPluginsFromFile(const char* filename)
+{
+	char file[256];
+	FILE *fp = fopen(build_pathname_r(file, sizeof(file) - 1, "%s", filename), "rt");
+
+	if (!fp) 
+	{
+		AMXXLOG_Log("[AMXX] Plugins list not found (file \"%s\")", filename);
 		return 1;
 	}
 	
@@ -65,22 +98,26 @@ int  CPluginMngr::loadPluginsFromFile( const char* filename )
 	
 	String line;
 
-	while ( !feof(fp) ) 
+	while (!feof(fp)) 
 	{
-		*pluginName = 0;
-		*debug = 0;
+		pluginName[0] = '\0';
+		
+		debug[0] = '\0';
 		debugFlag = 0;
+		
 		line.clear();
 		line._fread(fp);
-		sscanf(line.c_str(),"%s %s",pluginName, debug);
-		if (!isalnum(*pluginName))  continue;
+		sscanf(line.c_str(), "%s %s", pluginName, debug);
+		
+		if (!isalnum(*pluginName))
+			continue;
 
 		if (isalnum(*debug) && strcmp(debug, "debug") == 0)
 		{
 			debugFlag = 1;
 		}
 
-		CPlugin* plugin = loadPlugin( pluginsDir , pluginName  , error,  debugFlag);
+		CPlugin* plugin = loadPlugin(pluginsDir, pluginName, error, debugFlag);
 		
 		if (plugin->getStatusCode() == ps_bad_load)
 		{
@@ -96,46 +133,67 @@ int  CPluginMngr::loadPluginsFromFile( const char* filename )
 	return pCounter;
 }
 
-void CPluginMngr::clear() {
-	CPlugin**a = &head;	
-	while ( *a )
-		unloadPlugin(a);
-}
-
-CPluginMngr::CPlugin* CPluginMngr::findPluginFast(AMX *amx) 
+void CPluginMngr::clear()
 {
-	return (CPlugin*)(amx->userdata[3]); 
+	CPlugin**a = &head;	
+	
+	while (*a)
+		unloadPlugin(a);
+	
+	m_Finalized = false;
+	
+	if (pNatives)
+	{
+		delete [] pNatives;
+		pNatives = NULL;
+	}
 }
 
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx) {
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(AMX *amx)
+{
 	CPlugin*a = head;
-	while ( a && &a->amx != amx )
-		a=a->next;
+	
+	while (a && &a->amx != amx)
+		a = a->next;
+	
 	return a;
 }
 	
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(int index){
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(int index)
+{
 	CPlugin*a = head;
-	while ( a && index--)
-		a=a->next;
+	
+	while (a && index--)
+		a = a->next;
+	
 	return a;
 }
 	
-CPluginMngr::CPlugin* CPluginMngr::findPlugin(const char* name) {
-	if (!name) return 0;
+CPluginMngr::CPlugin* CPluginMngr::findPlugin(const char* name)
+{
+	if (!name)
+		return 0;
+	
 	int len = strlen(name);
-	if (!len) return 0;
+	
+	if (!len)
+		return 0;
+	
 	CPlugin*a = head;
-	while( a && strncmp(a->name.c_str(), name,len) )
-		a=a->next;
+	
+	while (a && strncmp(a->name.c_str(), name, len))
+		a = a->next;
+	
 	return a;
 }
 
-const char* CPluginMngr::CPlugin::getStatus() const {
-	switch(status){
+const char* CPluginMngr::CPlugin::getStatus() const
+{
+	switch (status)
+	{
 		case ps_running: 
 		{
-					if (getAMX()->flags & AMX_FLAG_DEBUG)
+			if (m_Debug)
 			{
 				return "debug";
 			} else {
@@ -148,47 +206,153 @@ const char* CPluginMngr::CPlugin::getStatus() const {
 		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";
+	
 	title.assign(unk);
 	author.assign(unk);
 	version.assign(unk);
-	char* path = build_pathname("%s/%s",p,n);
+	
+	char file[256];
+	char* path = build_pathname_r(file, sizeof(file) - 1, "%s/%s", p, n);
 	code = 0;
-	int err = load_amxscript(&amx,&code,path,e, d);
-	if ( err == AMX_ERR_NONE )
+	memset(&amx, 0, sizeof(AMX));
+	int err = load_amxscript(&amx, &code, path, e, d);
+	
+	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;
-}
-CPluginMngr::CPlugin::~CPlugin( ){
-	unload_amxscript( &amx, &code );
-}
 	
-void CPluginMngr::CPlugin::pauseFunction( int id ) { 
-	if (isValid()){
-		paused_fun |= (1<<id);
-		g_commands.clearBufforedInfo();
+	if (status == ps_running)
+	{
+		m_PauseFwd = registerSPForwardByName(&amx, "plugin_pause");
+		m_UnpauseFwd = registerSPForwardByName(&amx, "plugin_unpause");
+		
+		if (amx.flags & AMX_FLAG_DEBUG)
+		{
+			m_Debug = true;
+		} else {
+			m_Debug = false;
+		}
 	}
 }
 
-void CPluginMngr::CPlugin::unpauseFunction( int id ) {
-	if (isValid()) {
-		paused_fun &= ~(1<<id); 
-		g_commands.clearBufforedInfo();
+CPluginMngr::CPlugin::~CPlugin()
+{
+	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)
+		{
+			Handler *pHandler = (Handler *)amx.userdata[UD_HANDLER];
+			int res = 0;
+			
+			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::setStatus( int a   ) { 
+void CPluginMngr::CPlugin::pauseFunction(int id)
+{ 
+}
+
+void CPluginMngr::CPlugin::unpauseFunction(int id)
+{
+}
+
+void CPluginMngr::CPlugin::setStatus(int a)
+{ 
 	status = a; 
 	g_commands.clearBufforedInfo(); // ugly way
 }
@@ -199,16 +363,8 @@ void CPluginMngr::CPlugin::pausePlugin()
 	if (isValid())
 	{
 		// call plugin_pause if provided
-		int func;
-		cell retval;
-		if (amx_FindPublic(&amx, "plugin_pause", &func) == AMX_ERR_NONE)
-		{
-			if (isExecutable(func))
-			{
-
-				amx_Exec(&amx, &retval, func, 0);
-			}
-		}
+		if (m_PauseFwd != -1)
+			executeForwards(m_PauseFwd);
 	
 		setStatus(ps_paused);
 	}
@@ -220,17 +376,10 @@ void CPluginMngr::CPlugin::unpausePlugin()
 	if (isValid())
 	{
 		// set status first so the function will be marked executable
-
 		setStatus(ps_running);
+		
 		// call plugin_unpause if provided
-		int func;
-		cell retval;
-		if (amx_FindPublic(&amx, "plugin_unpause", &func) == AMX_ERR_NONE)
-		{
-			if (isExecutable(func))
-			{
-				amx_Exec(&amx, &retval, func, 0);
-			}
-		}
+		if (m_UnpauseFwd != -1)
+			executeForwards(m_UnpauseFwd);
 	}
 }

amxmodx/CPlugin.h

@@ -36,18 +36,18 @@
 // class CPluginMngr
 // *****************************************************
 
-enum {
-	ps_bad_load,
-	ps_error,
-	ps_paused,
-	ps_running,
-	ps_stopped,
-	ps_locked
+enum
+{
+	ps_bad_load,	//Load failed
+	ps_error,	//Erroneous state
+	ps_locked,	//UNUSED
+	ps_paused,	//Plugin is temporarily paused
+	ps_stopped,	//Plugin is ... more temporarily paused
+	ps_running,	//Plugin is running
 };
 
 class CPluginMngr
 {
-
 public:
 
 	class iterator;
@@ -59,20 +59,25 @@ public:
 	
 		AMX amx;
 		void* code;
+		
 		String name;
 		String version;
 		String title;
 		String author;
 		String errorMsg;
+		
+		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();}
@@ -82,44 +87,52 @@ 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 setAuthor( const char* n ) { author.assign(n); }
-		inline void setVersion( const char* n ) { version.assign(n); }
-		inline void setError( const char* n ) { errorMsg.assign(n); }
-		inline bool isValid() const { return ((status != ps_bad_load) && (status != ps_locked)); }
-		inline bool isPaused() const { return ( (status == ps_paused) || (status == ps_stopped)); }
-		inline bool isFunctionPaused( int id ) const { return (paused_fun & (1<<id)) ? true : false; 	}
-		inline bool isExecutable(int id) const { 	return (isValid() && !isPaused() && !isFunctionPaused(id));	}
+		inline void setTitle(const char* n) { title.assign(n); }
+		inline void setAuthor(const char* n) { author.assign(n); }
+		inline void setVersion(const char* n) { version.assign(n); }
+		inline void setError(const char* n) { errorMsg.assign(n); }
+		inline bool isValid() const { return (status >= ps_paused); }
+		inline bool isPaused() const { return ((status == ps_paused) || (status == ps_stopped)); }
+		inline bool isExecutable(int id) const { return (isValid() && !isPaused());	}
+		
+		void Finalize();
 		void pausePlugin();
 		void unpausePlugin();
-		void pauseFunction( int id );
-		void unpauseFunction( int id );
-		void setStatus( int a   );
+		void pauseFunction(int id);
+		void unpauseFunction(int id);
+		void setStatus(int a);
+		
 		const char* getStatus() const;
+		inline bool isDebug() const { return m_Debug; }
 	}; 
 	
 private:	
 	CPlugin *head;
 	int pCounter;
-
-
 public:
-	CPluginMngr() { head = 0; pCounter = 0; }
+	CPluginMngr() { head = 0; pCounter = 0; pNatives = NULL; m_Finalized=false;}
 	~CPluginMngr() { clear(); }
 
+	bool m_Finalized;
+	AMX_NATIVE_INFO *pNatives;
+
 	// Interface
 
 	CPlugin* loadPlugin(const char* path, const char* name, char* error, int debug);
-	void unloadPlugin( CPlugin** a );
-	int loadPluginsFromFile( const char* filename );
-	CPlugin* findPluginFast(AMX *amx);
+	void unloadPlugin(CPlugin** a);
+	int loadPluginsFromFile(const char* filename);
+	
+	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) {}
@@ -129,10 +142,9 @@ 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); }
 };
 
-#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

@@ -32,6 +32,9 @@
 #ifndef _INCLUDE_CSTRING_H
 #define _INCLUDE_CSTRING_H
 
+#include <string.h>
+#include <stdio.h>
+
 //by David "BAILOPAN" Anderson
 class String
 {
@@ -39,10 +42,8 @@ public:
 	String() 
 	{
 		v = NULL;
-		mSize = 0;
-		cSize = 0;
-		Grow(2);
-		assign("");
+		a_size = 0;
+		//assign("");
 	}
 
 	~String()
@@ -54,41 +55,45 @@ public:
 	String(const char *src) 
 	{
 		v = NULL; 
-		mSize = 0; 
-		cSize = 0; assign(src); 
+		a_size = 0;
+		assign(src); 
 	}
 
-	String(String &src) 
+	const char * _fread(FILE *fp) 	 
+	{ 	 
+		Grow(512, false); 	 
+		char *ret = fgets(v, 511, fp); 	 
+		return ret; 	 
+	}
+
+	String(const String &src) 
 	{
 		v = NULL;
-		mSize = 0;
-		cSize = 0;
+		a_size = 0;
 		assign(src.c_str()); 
 	}
 
 	const char *c_str() { return v?v:""; }
+
 	const char *c_str() const { return v?v:""; }
 
 	void append(const char *t)
 	{
-		Grow(cSize + strlen(t) + 1);
+		Grow(size() + strlen(t) + 1);
 		strcat(v, t);
-		cSize = strlen(v);
 	}
 
 	void append(const char c)
 	{
-		Grow(cSize + 2);
-		v[cSize] = c;
-		v[++cSize] = 0;
+		size_t len = size();
+		Grow(len + 2);
+		v[len] = c;
+		v[len + 1] = '\0';
 	}
 
 	void append(String &d)
 	{
-		const char *t = d.c_str();
-		Grow(cSize + strlen(t));
-		strcat(v, t);
-		cSize = strlen(v);
+		append(d.c_str());
 	}
 
 	void assign(const String &src)
@@ -100,79 +105,58 @@ public:
 	{
 		if (!d)
 		{
-			Grow(1);
-			cSize = 0;
-			strcpy(v, "");
-			return;
-		}
-		Grow(strlen(d));
-		if (v)
-		{
-			strcpy(v, d);
-			cSize = strlen(v);
+			clear();
 		} else {
-			cSize = 0;
+			size_t len = strlen(d);
+			Grow(len + 1, false);
+			memcpy(v, d, len);
+			v[len] = '\0';
 		}
 	}
 
 	void clear()
 	{
 		if (v)
-		{
-			v[0] = 0;
-			cSize = 0;
-		}
+			v[0] = '\0';
 	}
 
-	int compare (const char *d)
+	int compare (const char *d) const
 	{
-		if (v) {
-			if (d) {
+		if (!v)
+			return strcmp("", d);
+		else
 			return strcmp(v, d);
-			} else {
-				return strlen(v);
-			}
-		} else {
-			if (d) {
-				return strlen(d);
-			} else {
-				return 0;
-			}
-		}
 	}
 
 	//Added this for amxx inclusion
 	bool empty()
 	{
-		if (!v || !cSize)
+		if (!v)
+			return true;
+
+		if (v[0] == '\0')
 			return true;
 
 		return false;
 	}
 
-	int size()
+	size_t size()
 	{
-		if (!v)
+		if (v)
+			return strlen(v);
+		else
 			return 0;
-		return cSize;
-	}
-
-	const char * _fread(FILE *fp)
-	{
-		Grow(512);
-		char * ret = fgets(v, 511, fp);
-		cSize = strlen(v);
-		return ret;
 	}
 
 	int find(const char c, int index = 0)
 	{
-		if (!v)
+		int len = static_cast<int>(size());
+		if (len < 1)
 			return npos;
-		if (index >= (int)cSize || index < 0)
+		if (index >= len || index < 0)
 			return npos;
-		unsigned int i = 0;
-		for (i=index; i<cSize; i++)
+		int i = 0;
+		for (i=index; i<len; i++)
 		{
 			if (v[i] == c)
 			{
@@ -195,14 +179,40 @@ 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)
 			return;
+
 		unsigned int i = 0;
 		unsigned int j = 0;
+		size_t len = strlen(v);
 
-		if (cSize == 1)
+		if (len == 1)
 		{
 			if (is_space(v[i]))
 			{
@@ -215,9 +225,9 @@ public:
 
 		if (is_space(c0))
 		{
-			for (i=0; i<cSize; i++)
+			for (i=0; i<len; i++)
 			{
-				if (!is_space(v[i]) || (is_space(v[i]) && ((unsigned char)i==cSize-1)))
+				if (!is_space(v[i]) || (is_space(v[i]) && ((unsigned char)i==len-1)))
 				{
 					erase(0, i);
 					break;
@@ -225,16 +235,16 @@ public:
 			}
 		}
 
-		cSize = strlen(v);
+		len = strlen(v);
 
-		if (cSize < 1)
+		if (len < 1)
 		{
 			return;
 		}
 
-		if (is_space(v[cSize-1]))
+		if (is_space(v[len-1]))
 		{
-			for (i=cSize-1; i>=0; i--)
+			for (i=len-1; i>=0; i--)
 			{
 				if (!is_space(v[i])
 					|| (is_space(v[i]) && i==0))
@@ -246,7 +256,7 @@ public:
 			}
 		}
 
-		if (cSize == 1)
+		if (len == 1)
 		{
 			if (is_space(v[0]))
 			{
@@ -256,21 +266,22 @@ public:
 		}
 	}
 
-	String & erase(unsigned int start, int num = npos)
+	void erase(unsigned int start, int num = npos)
 	{
 		if (!v)
-			return (*this);
+			return;
 		unsigned int i = 0;
+		size_t len = size();
 		//check for bounds
-		if (num == npos || start+num > cSize-num+1)
-			num = cSize - start;
+		if (num == npos || start+num > len-start)
+			num = len - start;
 		//do the erasing
 		bool copyflag = false;
-		for (i=0; i<cSize; i++)
+		for (i=0; i<len; i++)
 		{
 			if (i>=start && i<start+num)
 			{
-				if (i+num < cSize)
+				if (i+num < len)
 				{	
 					v[i] = v[i+num];
 				} else {
@@ -278,7 +289,7 @@ public:
 				}
 				copyflag = true;
 			} else if (copyflag) {
-				if (i+num < cSize)
+				if (i+num < len)
 				{
 					v[i] = v[i+num];
 				} else {
@@ -286,38 +297,39 @@ public:
 				}
 			}
 		}
-		cSize -= num;
-		v[cSize] = 0;
-
-		return (*this);
+		len -= num;
+		v[len] = 0;
 	}
 
 	String substr(unsigned int index, int num = npos)
 	{
+		if (!v)
+		{
+			String b("");
+			return b;
+		}
+
 		String ns;
 
-		if (index >= cSize || !v)
+		size_t len = size();
+
+		if (index >= len || !v)
 			return ns;
 		
 		if (num == npos)
 		{
-			num = cSize - index;
-		} else if (index+num >= cSize) {
-			num = cSize - index;
+			num = len - index;
+		} else if (index+num >= len) {
+			num = len - index;
 		}
 
-		unsigned int i = 0, j=0;
-		char *s = new char[cSize+1];
+		unsigned int i = 0;
+		unsigned int nslen = num + 2;
+
+		ns.Grow(nslen);
 
 		for (i=index; i<index+num; i++)
-		{
-			s[j++] = v[i];
-		}
-		s[j] = 0;
-
-		ns.assign(s);
-
-		delete [] s;
+			ns.append(v[i]);
 
 		return ns;
 	}
@@ -327,10 +339,11 @@ public:
 		if (!v)
 			return;
 		unsigned int i = 0;
-		for (i=0; i<cSize; i++)
+		size_t len = strlen(v);
+		for (i=0; i<len; i++)
 		{
 			if (v[i] >= 65 && v[i] <= 90)
-				v[i] |= 32;
+				v[i] &= ~(1<<5);
 		}
 	}
 
@@ -349,7 +362,7 @@ public:
 
 	char operator [] (unsigned int index)
 	{
-		if (index > cSize)
+		if (index > size() || !v)
 		{
 			return -1;
 		} else {
@@ -359,7 +372,7 @@ public:
 
 	int at(int a)
 	{
-		if (a < 0 || a >= (int)cSize)
+		if (a < 0 || a >= (int)size() || !v)
 			return -1;
 
 		return v[a];
@@ -367,7 +380,7 @@ public:
 
 	bool at(int at, char c)
 	{
-		if (at < 0 || at >= (int)cSize)
+		if (at < 0 || at >= (int)size() || !v)
 			return false;
 
 		v[at] = c;
@@ -376,27 +389,23 @@ public:
 	}
 
 private:
-	void Grow(unsigned int d)
+	void Grow(unsigned int d, bool copy=true)
 	{
-		if (d<1)
+		if (d <= a_size)
 			return;
-		if (d > mSize)
-		{
-			mSize = d + 16;	// allocate a buffer
-			char *t = new char[d+1];
-			if (v) {
-				strcpy(t, v);
-				t[cSize] = 0;
+		char *n = new char[d + 1];
+		if (copy && v)
+			strcpy(n, v);
+		if (v)
 			delete [] v;
-			}
-			v = t;
-			mSize = d;
-		}
+		else
+			strcpy(n, "");			
+		v = n;
+		a_size = d + 1;
 	}
 
 	char *v;
-	unsigned int mSize;
-	unsigned int cSize;
+	unsigned int a_size;
 public:
 	static const int npos = -1;
 };

amxmodx/CTask.cpp

@@ -33,6 +33,7 @@
 #include "CTask.h"
 
 /*********************** CTask ***********************/
+
 int CTaskMngr::CTask::getTaskId() const
 {
 	return m_iId;
@@ -43,8 +44,9 @@ CPluginMngr::CPlugin *CTaskMngr::CTask::getPlugin() const
 	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)
+void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags, cell iId, float fBase, int iParamsLen, const cell *pParams, int iRepeat, float fCurrentTime)
 {
+	clear();
 	m_bFree = false;
 
 	m_pPlugin = pPlugin;
@@ -52,8 +54,17 @@ void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags,
 	m_iId = iId;
 	m_fBase = fBase;
 
-	m_iRepeat =		(iFlags & 1) ? iRepeat : 0;
-	m_bLoop =		(iFlags & 2) ?  true : false;
+	if (iFlags & 2)
+	{
+		m_bLoop = true;
+		m_iRepeat = -1;
+	}
+	else if (iFlags & 1)
+	{
+		m_bLoop = true;
+		m_iRepeat = iRepeat;
+	}
+	
 	m_bAfterStart =	(iFlags & 4) ? true : false;
 	m_bBeforeEnd = (iFlags & 8) ? true : false;
 
@@ -73,17 +84,30 @@ void CTaskMngr::CTask::set(CPluginMngr::CPlugin *pPlugin, int iFunc, int iFlags,
 
 void CTaskMngr::CTask::clear()
 {
+	m_bFree = true;
+
 	if (m_iFunc >= 0)
 	{
 		unregisterSPForward(m_iFunc);
 		m_iFunc = -1;
 	}
-	m_bFree = true;
+
 	if (m_pParams)
 	{
 		delete [] m_pParams;
 		m_pParams = NULL;
 	}
+
+	m_pPlugin = NULL;
+	m_iId = 0;
+	m_fBase = 0.0f;
+
+	m_iRepeat =	0;
+	m_bLoop = false;
+	m_bAfterStart =	false;
+	m_bBeforeEnd = false;
+
+	m_fNextExecTime = 0.0f;
 }
 
 bool CTaskMngr::CTask::isFree() const
@@ -103,7 +127,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;
+	
 	if (m_bAfterStart)
 	{
 		if (fCurrentTime - fTimeLeft + 1.0f >= m_fBase)
@@ -115,9 +141,14 @@ void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, f
 			execute = true;
 	}
 	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_iParamLen)	// call with parameters
 			{
@@ -126,20 +157,25 @@ void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, f
 			} else {
 				executeForwards(m_iFunc, m_iId);
 			}
+		}
 	
 		if (isFree())
 			return;
 
 		// set new exec time OR remove the task if needed
-		if (m_bLoop || (--m_iRepeat > 0))
+		if (m_bLoop)
 		{
-			m_fNextExecTime += m_fBase;
+			if (m_iRepeat != -1 && --m_iRepeat <= 0)
+				done = true;
+		} else {
+			done = true;
 		}
-		else
+
+		if (done)
 		{
-			unregisterSPForward(m_iFunc);
-			m_iFunc = -1;
-			m_bFree = true;
+			clear();
+		} else {
+			m_fNextExecTime += m_fBase;
 		}
 	}
 }
@@ -147,6 +183,21 @@ void CTaskMngr::CTask::executeIfRequired(float fCurrentTime, float fTimeLimit, f
 CTaskMngr::CTask::CTask()
 {
 	m_bFree = true;
+
+	m_pPlugin = NULL;
+	m_iFunc = -1;
+	m_iId = 0;
+	m_fBase = 0.0f;
+
+	m_iRepeat =	0;
+	m_bLoop = false;
+	m_bAfterStart =	false;
+	m_bBeforeEnd = false;
+
+	m_fNextExecTime = 0.0f;
+
+	m_iParamLen = 0;
+	m_pParams = NULL;
 }
 
 CTaskMngr::CTask::~CTask()
@@ -155,6 +206,7 @@ CTaskMngr::CTask::~CTask()
 }
 
 /*********************** CTaskMngr ***********************/
+
 CTaskMngr::CTaskMngr()
 {
 	m_pTmr_CurrentTime = NULL;
@@ -162,6 +214,11 @@ CTaskMngr::CTaskMngr()
 	m_pTmr_TimeLeft = NULL;
 }
 
+CTaskMngr::~CTaskMngr()
+{
+	clear();
+}
+
 void CTaskMngr::registerTimers(float *pCurrentTime, float *pTimeLimit, float *pTimeLeft)
 {
 	m_pTmr_CurrentTime = pCurrentTime;
@@ -169,21 +226,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);
 	}
@@ -193,13 +251,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();
 		++i;
 		iter = m_Tasks.find(++iter, descriptor);
 	}
+	
 	return i;
 }
 
@@ -207,7 +267,8 @@ 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);
@@ -215,6 +276,7 @@ int CTaskMngr::changeTasks(int iId, AMX *pAmx, float fNewBase)
 		++i;
 		iter = m_Tasks.find(++iter, descriptor);
 	}
+	
 	return i;
 }
 

amxmodx/CTask.h

@@ -39,22 +39,25 @@ private:
 	class CTask
 	{
 		// task settings
+		
 		CPluginMngr::CPlugin *m_pPlugin;
-		int m_iId;
+		cell m_iId;
 		int m_iFunc;
 		int m_iRepeat;
+		
 		bool m_bLoop;
 		bool m_bAfterStart;
 		bool m_bBeforeEnd;
 		float m_fBase;		// for normal tasks, stores the interval, for the others, stores the amount of time before start / after end
 		int m_iParamLen;
+		
 		cell *m_pParams;
 		bool m_bFree;
 
 		// execution
 		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();
 		bool isFree() const;
 
@@ -75,7 +78,7 @@ private:
 	class CTaskDescriptor
 	{
 	public:
-		int m_iId;
+		cell m_iId;
 		AMX *m_pAmx;
 		bool m_bFree;
 
@@ -91,31 +94,32 @@ private:
 			if (right.m_bFree)
 				return left.isFree();
 			
-			return !left.isFree() &&
-				(right.m_pAmx ? left.getPlugin()->getAMX() == right.m_pAmx : true) &&
-				left.getTaskId() == right.m_iId;
+			return !left.isFree() && (right.m_pAmx ? left.getPlugin()->getAMX() == right.m_pAmx : true) && 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;
 public:
 	CTaskMngr();
+	~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
 	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,31 +89,31 @@ 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;
@@ -120,58 +121,57 @@ void Vault::clear()
 	}
 }
 
-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 key[sz+1];
+	char value[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 ) )
-			put( key, value );
+		if (isalpha(*key))
+			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

@@ -45,38 +45,43 @@ class Vault
 	{
 		String key;
 		String value;
+		
 		int number;
 		Obj *next;
-	Obj( const char* k,  const char* v);
+		Obj(const char* k, const char* v);
 	} *head;
 
 	String path;
 
-  Obj** find( const char* n );
+	Obj** find(const char* n);
 
 public:
 
-  Vault() {head=0;}
-  ~Vault() { clear();}
+	Vault() { head = 0; }
+	~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 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();
 
-
-  class iterator {
+	class iterator
+	{
 		Obj * a;
 	public:
-	iterator(Obj*aa) : a(aa) {}
-	iterator& operator++() { if ( a ) a = a->next; return *this; }
+		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; }
@@ -87,7 +92,4 @@ public:
 	inline iterator end() const { return iterator(0); }
 };
 
-#endif
-
-
-
+#endif //VAULT_CUSTOM_H

amxmodx/CVector.h

@@ -48,7 +48,8 @@ template <class T> class CVector
 			return false;
 		if (m_Data)
 		{
-			memcpy(newData, m_Data, m_Size * sizeof(T));
+			for (size_t i=0; i<m_CurrentUsedSize; i++)
+				newData[i] = m_Data[i];
 			delete [] m_Data;
 		}
 		m_Data = newData;
@@ -69,30 +70,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)
 		{
-			memcpy(newData, m_Data, (m_Size < size) ? (m_Size * sizeof(T)) : (size * sizeof(T)));
+			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
 	{
@@ -186,7 +215,7 @@ public:
 
 		iterator & operator-=(size_t offset)
 		{
-			m_Ptr += offset;
+			m_Ptr -= offset;
 			return (*this);
 		}
 
@@ -200,7 +229,7 @@ public:
 		iterator operator-(size_t offset) const
 		{
 			iterator tmp(*this);
-			tmp.m_Ptr += offset;
+			tmp.m_Ptr -= offset;
 			return tmp;
 		}
 
@@ -251,10 +280,11 @@ public:
 	CVector<T>(const CVector<T> & other)
 	{
 		// copy data
-		m_Data = new T [other.m_Size];
-		m_Size = other.m_Size;
+		m_Data = new T [other.m_CurrentUsedSize];
+		m_Size = other.m_CurrentUsedSize;
 		m_CurrentUsedSize = other.m_CurrentUsedSize;
-		memcpy(m_Data, other.m_Data, m_CurrentUsedSize * sizeof(T));
+		for (size_t i=0; i<other.m_CurrentUsedSize; i++)
+			m_Data[i] = other.m_Data[i];
 	}
 
 	~CVector<T>()
@@ -273,12 +303,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);
 	}
@@ -292,7 +322,9 @@ public:
 
 	bool reserve(size_t newSize)
 	{
+		if (newSize > m_Size)
 			return ChangeSize(newSize);
+		return true;
 	}
 
 	bool push_back(const T & elem)
@@ -313,14 +345,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;
 	}
 
@@ -393,15 +426,13 @@ 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))
-			return false;
+		if (where < m_Data || where > (m_Data + m_CurrentUsedSize))
+			return iterator(0);
+
+		size_t ofs = where - begin();
 
 		++m_CurrentUsedSize;
 		if (!GrowIfNeeded())
@@ -410,34 +441,50 @@ public:
 			return false;
 		}
 
-		memmove(where.base() + 1, where.base(), m_CurrentUsedSize - (where - m_Data));
-		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;
+		if (m_Data)
+		{
 			delete [] m_Data;
 			m_Data = NULL;
 		}
+	}
 };
 
 #endif // __CVECTOR_H__

amxmodx/Makefile

@@ -1,123 +1,97 @@
-MODNAME = amxx_mm
-SRCFILES = meta_api.cpp CFile.cpp CString.cpp CVault.cpp vault.cpp\
-float.cpp file.cpp modules.cpp CMisc.cpp CTask.cpp string.cpp\
-amxmodx.cpp CEvent.cpp CCmd.cpp CLogEvent.cpp srvcmd.cpp strptime.cpp\
-CForward.cpp CPlugin.cpp CModule.cpp CMenu.cpp emsg.cpp util.cpp \
-amxcore.cpp amxtime.cpp power.cpp amxxlog.cpp fakemeta.cpp mmgr/mmgr.cpp \
-amxxfile.cpp CLang.cpp md5.cpp amx.cpp
-#use this for amd64, remove the above amx.cpp, and rename amx.cpp to amx.c
-#CSRCFILES = amx.c minilzo/minilzo.c
-CSRCFILES = minilzo/minilzo.c
+#(C)2004-2005 AMX Mod X Development Team
+# Makefile written by David "BAILOPAN" Anderson
 
-EXTRA_LIBS_LINUX =
-EXTRA_LIBS_WIN32 =
-EXTRA_LIBDIRS_LINUX = -Lextra/lib_linux
-EXTRA_LIBDIRS_WIN32 = -Lextra/lib_win32
+HLSDK = ../hlsdk/SourceCode
+MM_ROOT = ../metamod/metamod
 
-EXTRA_INCLUDEDIRS = -Iextra/include
+### EDIT BELOW FOR OTHER PROJECTS ###
 
-EXTRA_FLAGS = -Dstrcmpi=strcasecmp
+OPT_FLAGS = -O2 -funroll-loops -s -fomit-frame-pointer -pipe
+DEBUG_FLAGS = -g -ggdb3
+CPP = gcc
+NAME = amxmodx_mm
 
-SDKTOP=../hlsdk
-METADIR=../metamod/metamod
+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 \
+	srvcmd.cpp strptime.cpp amxcore.cpp amxtime.cpp power.cpp amxxlog.cpp fakemeta.cpp \
+	amxxfile.cpp CLang.cpp md5.cpp emsg.cpp CForward.cpp CPlugin.cpp CModule.cpp \
+	CMenu.cpp util.cpp amx.cpp amxdbg.cpp natives.cpp newmenus.cpp debugger.cpp \
+	optimizer.cpp format.cpp
 
+LINK = -lz /lib/libstdc++.a
 
-SDKSRC=$(SDKTOP)/SourceCode
-OBJDIR_LINUX=obj.linux
-OBJDIR_WIN32=obj.win32
-SRCDIR=.
+INCLUDE = -I. -I$(HLSDK) -I$(HLSDK)/dlls -I$(HLSDK)/engine -I$(HLSDK)/game_shared -I$(HLSDK)/game_shared \
+	-I$(MM_ROOT) -Lzlib -I$(HLSDK)/common
 
-ifdef windir
-	OS=WIN32
+ifeq "$(DEBUG)" "true"
+	BIN_DIR = Debug
+	CFLAGS = $(DEBUG_FLAGS)
 else
-	OS=LINUX
+	BIN_DIR = Release
+	CFLAGS = $(OPT_FLAGS)
 endif
 
-CC_LINUX=gcc
-ifeq "$(OS)" "WIN32"
-	CC_WIN32=gcc
-	LD_WINDLL=dllwrap
-	DEFAULT=win32
-	CLEAN=clean_win32
-else
-	CC_WIN32=/usr/local/cross-tools/i386-mingw32msvc/bin/gcc
-	LD_WINDLL=/usr/local/cross-tools/bin/i386-mingw32msvc-dllwrap
-	DEFAULT=linux win32
-	CLEAN=clean_both
+ifeq "$(MMGR)" "true"
+	OBJECTS += mmgr/mmgr.cpp
+	CFLAGS += -DMEMORY_TEST
 endif
 
+CFLAGS += -DLINUX -DNDEBUG -fPIC -Wno-deprecated -DHAVE_STDINT_H -static-libgcc -fno-rtti -fno-exceptions
 
-#use this for AMD64
-#LIBFILE_LINUX = $(MODNAME)_amd64.so
-LIBFILE_LINUX = $(MODNAME)_i386.so
-LIBFILE_WIN32 = $(MODNAME).dll
-TARGET_LINUX = $(OBJDIR_LINUX)/$(LIBFILE_LINUX)
-TARGET_WIN32 = $(OBJDIR_WIN32)/$(LIBFILE_WIN32)
-
-FILES_ALL = *.cpp *.h [A-Z]* *.rc
-ifeq "$(OS)" "LINUX"
-	ASRCFILES := $(shell ls -t $(SRCFILES))
+ifeq "$(AMD64)" "true"
+	BINARY = $(NAME)_amd64.so
+	CFLAGS += -DPAWN_CELL_SIZE=64 -DHAVE_I64 -DAMD64 -m64 
+	OBJECTS += JIT/natives-amd64.o
 else
-	ASRCFILES := $(shell dir /b)
+	BINARY = $(NAME)_i386.so
+	OBJECTS += JIT/amxexecn.o JIT/amxjitsn.o JIT/natives-x86.o
+	OBJECTS += JIT/helpers-x86.o
+	CFLAGS += -DPAWN_CELL_SIZE=32 -DJIT -DASM32
+	OPT_FLAGS += -march=i586
 endif
-OBJ_LINUX := $(SRCFILES:%.cpp=$(OBJDIR_LINUX)/%.o)
-OBJC_LINUX := $(CSRCFILES:%.c=$(OBJDIR_LINUX)/%.o)
-OBJ_WIN32 := $(SRCFILES:%.cpp=$(OBJDIR_WIN32)/%.o)
-OBJC_WIN32 := $(CSRCFILES:%.c=$(OBJDIR_WIN32)/%.o)
 
-#use this for amd64
-#CCOPT = -m64 -g -ggdb3 -DHAVE_I64 -DSMALL_CELL_SIZE=64
-CCOPT = -march=i386 -s -DNDEBUG -O2 -fomit-frame-pointer -fno-exceptions -fno-rtti -ffast math
+OBJ_LINUX := $(OBJECTS:%.cpp=$(BIN_DIR)/%.o)
 
-INCLUDEDIRS=-I../curl/include -I$(SRCDIR) -I$(METADIR) -I$(SDKSRC)/engine -I$(SDKSRC)/common -I$(SDKSRC)/pm_shared -I$(SDKSRC)/dlls -I$(SDKSRC) $(EXTRA_INCLUDEDIRS)
-CFLAGS=-Wall -Wno-unknown-pragmas
-ODEF = -DOPT_TYPE=\"optimized\"
-CFLAGS:=$(CCOPT) $(CFLAGS) $(ODEF) $(EXTRA_FLAGS)
+$(BIN_DIR)/%.o: %.cpp
+	$(CPP) $(INCLUDE) $(CFLAGS) -o $@ -c $<
 
-DO_CC_LINUX=$(CC_LINUX) $(CFLAGS) -fPIC $(INCLUDEDIRS) -o $@ -c $<
-DO_CC_WIN32=$(CC_WIN32) $(CFLAGS) $(INCLUDEDIRS) -o $@ -c $<
-LINK_LINUX=$(CC_LINUX) $(CFLAGS) -shared -ldl -lm $(OBJ_LINUX) $(OBJC_LINUX) $(EXTRA_LIBDIRS_LINUX) $(EXTRA_LIBS_LINUX) -o $@
-LINK_WIN32=$(LD_WINDLL) -mwindows --def $(MODNAME).def --add-stdcall-alias $(OBJ_WIN32) $(OBJC_WIN32) $(EXTRA_LIBDIRS_WIN32) $(EXTRA_LIBS_WIN32) -o $@
+all:
+	mkdir -p $(BIN_DIR)
+	$(MAKE) amxmodx
 
-$(OBJDIR_LINUX)/%.o: $(SRCDIR)/%.c
-	$(DO_CC_LINUX)
+amd64:
+	rm -f zlib/libz.a
+	$(MAKE) all AMD64=true
 
-$(OBJDIR_LINUX)/%.o: $(SRCDIR)/%.cpp
-	$(DO_CC_LINUX)
+amd64_mmgr:
+	rm -f zlib/libz.a
+	$(MAKE) all AMD64=true MMGR=true
 
-$(OBJDIR_WIN32)/%.o: $(SRCDIR)/%.c
-	$(DO_CC_WIN32)
+amd64_debug_mmgr:
+	rm -f zlib/libz.a
+	$(MAKE) all AMD64=true DEBUG=true MMGR=true
 
-$(OBJDIR_WIN32)/%.o: $(SRCDIR)/%.cpp
-	$(DO_CC_WIN32)
+amd64_debug:
+	rm -f zlib/libz.a
+	$(MAKE) all AMD64=true DEBUG=true
 
-default: $(DEFAULT)
+mmgr:
+	$(MAKE) all MMGR=true
 
-$(TARGET_LINUX): $(OBJDIR_LINUX) $(OBJ_LINUX) $(OBJC_LINUX)
-	$(LINK_LINUX)
+debug_mmgr:
+	$(MAKE) all MMGR=true DEBUG=true
 
-$(TARGET_WIN32): $(OBJDIR_WIN32) $(OBJ_WIN32) $(OBJC_WIN32)
-	$(LINK_WIN32)
+amxmodx: $(OBJ_LINUX)
+	$(CPP) $(INCLUDE) $(CFLAGS) $(OBJ_LINUX) $(LINK) -shared -ldl -lm -o$(BIN_DIR)/$(BINARY)
 
-$(OBJDIR_LINUX):
-	mkdir $@
-	mkdir $@/mmgr
+debug:	
+	$(MAKE) all DEBUG=true
 
-$(OBJDIR_WIN32):
-	mkdir $@
-	mkdir $@/mmgr
-
-win32: $(TARGET_WIN32)
-
-linux: $(TARGET_LINUX)
-
-clean: $(CLEAN)
-
-clean_both:
-	-rm -f $(OBJDIR_LINUX)/*
-	-rm -f $(OBJDIR_WIN32)/*
-
-clean_win32:
-	del /q $(OBJDIR_WIN32)
+default: all
 
+clean:
+	rm -rf Release/*.o
+	rm -rf Release/$(BINARY)
+	rm -rf Debug/*.o
+	rm -rf Debug/$(BINARY)
 

amxmodx/Makefile.pl

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

amxmodx/amx.h

@@ -1,6 +1,6 @@
-/*  Abstract Machine for the Small compiler
+/*  Pawn Abstract Machine (for the Pawn language)
  *
- *  Copyright (c) ITB CompuPhase, 1997-2004
+ *  Copyright (c) ITB CompuPhase, 1997-2005
  *
  *  This software is provided "as-is", without any express or implied warranty.
  *  In no event will the authors be held liable for any damages arising from
@@ -21,20 +21,34 @@
  *  Version: $Id$
  */
 
-#if defined __linux__
+#if defined FREEBSD && !defined __FreeBSD__
+  #define __FreeBSD__
+#endif
+#if defined LINUX || defined __FreeBSD__ || defined __OpenBSD__
   #include <sclinux.h>
 #endif
 
 #ifndef AMX_H_INCLUDED
 #define AMX_H_INCLUDED
 
-#if defined __LCC__ || defined __DMC__ || defined __linux__
+#if defined HAVE_STDINT_H
   #include <stdint.h>
-#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+#else
+  #if defined __LCC__ || defined __DMC__ || defined LINUX
+    #if defined HAVE_INTTYPES_H
+      #include <inttypes.h>
+    #else
+      #include <stdint.h>
+    #endif
+  #elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
     /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
      * here, these types are probably undefined.
      */
-  #if defined __FreeBSD__
+    #if defined __MACH__
+      #include <ppc/types.h>
+      typedef unsigned short int  uint16_t;
+      typedef unsigned long int   uint32_t;
+    #elif defined __FreeBSD__
       #include <inttypes.h>
     #else
       typedef short int           int16_t;
@@ -56,18 +70,32 @@
         #define HAVE_I64
       #endif
     #endif
+  #endif
+  #define HAVE_STDINT_H
+#endif
+#if defined _LP64 || defined WIN64 || defined _WIN64
+  #if !defined __64BIT__
+    #define __64BIT__
+  #endif
 #endif
 
-#if defined __WIN32__ || defined _WIN32 || defined WIN32 /* || defined __MSDOS__ */
-  #if !defined alloca
-    #define alloca(n)   _alloca(n)
-  #endif
+#if !defined arraysize
+  #define arraysize(array)  (sizeof(array) / sizeof((array)[0]))
 #endif
 
 #ifdef  __cplusplus
 extern  "C" {
 #endif
 
+#if defined PAWN_DLL
+  #if !defined AMX_NATIVE_CALL
+    #define AMX_NATIVE_CALL __stdcall
+  #endif
+  #if !defined AMXAPI
+    #define AMXAPI          __stdcall
+  #endif
+#endif
+
 /* calling convention for native functions */
 #if !defined AMX_NATIVE_CALL
   #define AMX_NATIVE_CALL
@@ -78,6 +106,8 @@ extern  "C" {
     #define AMXAPI      __stdcall
   #elif defined CDECL
     #define AMXAPI      __cdecl
+  #elif defined GCC_HASCLASSVISIBILITY
+    #define AMXAPI __attribute__ ((visibility("default")))
   #else
     #define AMXAPI
   #endif
@@ -95,46 +125,39 @@ extern  "C" {
  *   5 (tagnames table)                         4
  *   6 (reformatted header)                     6
  *   7 (name table, opcodes SYMTAG & SYSREQ.D)  7
+ *   8 (opcode STMT, renewed debug interface)   8
  */
-#define CUR_FILE_VERSION  7     /* current file version; also the current AMX version */
+#define CUR_FILE_VERSION  8     /* current file version; also the current AMX version */
 #define MIN_FILE_VERSION  6     /* lowest supported file format version for the current AMX version */
-#define MIN_AMX_VERSION   7     /* minimum AMX version needed to support the current file format */
+#define MIN_AMX_VERSION   8     /* minimum AMX version needed to support the current file format */
 
-#if defined BIT16
-  #define SMALL_CELL_SIZE 16    /* for backward compatibility */
+#if !defined PAWN_CELL_SIZE
+  #define PAWN_CELL_SIZE 32     /* by default, use 32-bit cells */
 #endif
-#if !defined SMALL_CELL_SIZE
-  #define SMALL_CELL_SIZE 32    /* by default, use 32-bit cells */
-#endif
-#if SMALL_CELL_SIZE==16
+#if PAWN_CELL_SIZE==16
   typedef uint16_t  ucell;
   typedef int16_t   cell;
-#elif SMALL_CELL_SIZE==32
+#elif PAWN_CELL_SIZE==32
   typedef uint32_t  ucell;
   typedef int32_t   cell;
-#elif SMALL_CELL_SIZE==64
+#define REAL	float
+#elif PAWN_CELL_SIZE==64
   typedef uint64_t  ucell;
   typedef int64_t   cell;
+#define REAL	double
 #else
-  #error Unsupported cell size (SMALL_CELL_SIZE)
+  #error Unsupported cell size (PAWN_CELL_SIZE)
 #endif
 
-#if SMALL_CELL_SIZE==32
-  #define REAL          float
-#elif SMALL_CELL_SIZE==64
-  #define REAL          double
-#else
-  #error Unsupported cell size
-#endif
-
-#define UNPACKEDMAX   ((1 << (sizeof(cell)-1)*8) - 1)
+#define UNPACKEDMAX   ((1L << (sizeof(cell)-1)*8) - 1)
+#define UNLIMITED     (~1u >> 1)
 
 struct tagAMX;
 typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params);
 typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index,
                                    cell *result, cell *params);
 typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
-typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
+typedef int (AMXAPI *AMX_NATIVE_FILTER)(struct tagAMX *amx, int index);
 #if !defined _FAR
   #define _FAR
 #endif
@@ -148,7 +171,7 @@ typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
 /* Some compilers do not support the #pragma align, which should be fine. Some
  * compilers give a warning on unknown #pragmas, which is not so fine...
  */
-#if defined SN_TARGET_PS2 || defined __GNUC__
+#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN
   #define AMX_NO_ALIGN
 #endif
 
@@ -159,8 +182,10 @@ typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
 #endif
 
 #if !defined AMX_NO_ALIGN
-  #if defined __linux__
+  #if defined LINUX || defined __FreeBSD__
     #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #elif defined MACOS && defined __MWERKS__
+	#pragma options align=mac68k
   #else
     #pragma pack(push)
     #pragma pack(1)         /* structures must be packed (byte-aligned) */
@@ -170,10 +195,10 @@ typedef int (AMXAPI *AMX_DEBUGCALL)(struct tagAMX *amx, int mode);
   #endif
 #endif
 
-typedef struct {
+typedef struct tagAMX_NATIVE_INFO {
   const char _FAR *name PACKED;
   AMX_NATIVE func       PACKED;
-} AMX_NATIVE_INFO;
+} PACKED AMX_NATIVE_INFO;
 
 #define AMX_USERNUM     4
 #define sEXPMAX         19      /* maximum name length for file version <= 6 */
@@ -181,14 +206,19 @@ typedef struct {
 
 typedef struct tagAMX_FUNCSTUB {
   ucell address         PACKED;
-  const char name[sEXPMAX+1] PACKED;
-} AMX_FUNCSTUB;
+  char name[sEXPMAX+1]  PACKED;
+} PACKED AMX_FUNCSTUB;
+
+typedef struct tagFUNCSTUBNT {
+  ucell address         PACKED;
+  ucell nameofs      PACKED;	//we need this for amxx to be backwards comaptible
+} PACKED AMX_FUNCSTUBNT;
 
 /* The AMX structure is the internal structure for many functions. Not all
  * fields are valid at all times; many fields are cached in local variables.
  */
 typedef struct tagAMX {
-  unsigned char _FAR *base PACKED; /* points to the AMX header ("amxhdr") plus the code, optionally also the data */
+  unsigned char _FAR *base PACKED; /* points to the AMX header plus the code, optionally also the data */
   unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */
   AMX_CALLBACK callback PACKED;
   AMX_DEBUG debug       PACKED; /* debug callback */
@@ -200,18 +230,16 @@ typedef struct tagAMX {
   cell stk              PACKED; /* stack pointer: relative to base + amxhdr->dat */
   cell stp              PACKED; /* top of the stack: relative to base + amxhdr->dat */
   int flags             PACKED; /* current status, see amx_Flags() */
-  /* for assertions and debug hook */
-  cell curline          PACKED;
-  cell curfile          PACKED;
-  int dbgcode           PACKED;
-  cell dbgaddr          PACKED;
-  cell dbgparam         PACKED;
-  char _FAR *dbgname    PACKED;
   /* user data */
-  long usertags[AMX_USERNUM] PACKED;
+  void _FAR *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;
+  /* passing parameters requires a "count" field */
+  int paramcount;
   /* the sleep opcode needs to store the full AMX status */
   cell pri              PACKED;
   cell alt              PACKED;
@@ -221,7 +249,7 @@ typedef struct tagAMX {
   /* support variables for the JIT */
   int reloc_size      PACKED; /* required temporary buffer for relocations */
   long code_size      PACKED; /* estimated memory footprint of the native code */
-} AMX;
+} PACKED AMX;
 
 /* The AMX_HEADER structure is both the memory format as the file format. The
  * structure is used internaly.
@@ -243,27 +271,12 @@ typedef struct tagAMX_HEADER {
   int32_t libraries     PACKED; /* offset to the table of libraries */
   int32_t pubvars       PACKED; /* the "public variables" table */
   int32_t tags          PACKED; /* the "public tagnames" table */
-  int32_t nametable     PACKED; /* name table, file version 7 only */
-} AMX_HEADER            PACKED;
+  int32_t nametable     PACKED; /* name table */
+} PACKED AMX_HEADER;
+
+//This is always the same for us
 #define AMX_MAGIC     0xf1e0
 
-//double linked list for stack
-typedef struct tagAMX_TRACE
-{
-  cell					line	PACKED;
-  cell					file	PACKED;
-  struct tagAMX_TRACE	*next	PACKED;
-  struct tagAMX_TRACE	*prev	PACKED;
-} AMX_TRACE				PACKED;
-
-typedef struct tagAMX_DBG
-{
-  int32_t numFiles	PACKED;	/* number of chars in array */
-  char **files		PACKED; /* array of files */
-  AMX_TRACE *head		PACKED;	/* begin of link list */
-  AMX_TRACE *tail		PACKED; /* end of link list */
-} AMX_DBG				PACKED;
-
 enum {
   AMX_ERR_NONE,
   /* reserve the first 15 error codes for exit codes of the abstract machine */
@@ -279,6 +292,8 @@ enum {
   AMX_ERR_NATIVE,       /* native function failed */
   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 */
@@ -291,29 +306,18 @@ enum {
   AMX_ERR_INIT_JIT,     /* cannot initialize the JIT */
   AMX_ERR_PARAMS,       /* parameter error */
   AMX_ERR_DOMAIN,       /* domain error, expression result does not fit in range */
-};
-
-enum {
-  DBG_INIT,             /* query/initialize */
-  DBG_FILE,             /* file number in curfile, filename in name */
-  DBG_LINE,             /* line number in curline, file number in curfile */
-  DBG_SYMBOL,           /* address in dbgaddr, class/type in dbgparam */
-  DBG_CLRSYM,           /* stack address below which locals should be removed. stack address in stk */
-  DBG_CALL,             /* function call, address jumped to in dbgaddr */
-  DBG_RETURN,           /* function returns */
-  DBG_TERMINATE,        /* program ends, code address in dbgaddr, reason in dbgparam */
-  DBG_SRANGE,           /* symbol size and dimensions (arrays); level in dbgaddr (!); length in dbgparam */
-  DBG_SYMTAG,           /* tag of the most recent symbol (if non-zero), tag in dbgparam */
+  AMX_ERR_GENERAL,      /* general error (unknown or unspecific error) */
 };
 
 /*      AMX_FLAG_CHAR16   0x01     no longer used */
 #define AMX_FLAG_DEBUG    0x02  /* symbolic info. available */
 #define AMX_FLAG_COMPACT  0x04  /* compact encoding */
-#define AMX_FLAG_BIGENDIAN 0x08 /* big endian encoding */
-#define AMX_FLAG_NOCHECKS  0x10 /* no array bounds checking */
-#define AMX_FLAG_LINEOPS 0x20 /* line ops are parsed by the JIT [loadtime only flag] */
-#define	AMX_FLAG_TRACED	0x40  /* the file has already been traced */
-#define AMX_FLAG_BROWSE 0x4000  /* browsing/relocating or executing */
+#define AMX_FLAG_BYTEOPC  0x08  /* opcode is a byte (not a cell) */
+#define AMX_FLAG_NOCHECKS 0x10  /* no array bounds checking; no STMT opcode */
+#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 */
+#define AMX_FLAG_BROWSE 0x4000  /* busy browsing */
 #define AMX_FLAG_RELOC  0x8000  /* jump/call addresses relocated */
 
 #define AMX_EXEC_MAIN   -1      /* start at program entry point */
@@ -321,16 +325,29 @@ enum {
 
 #define AMX_USERTAG(a,b,c,d)    ((a) | ((b)<<8) | ((long)(c)<<16) | ((long)(d)<<24))
 
-#define AMX_EXPANDMARGIN  64
+#if !defined AMX_COMPACTMARGIN
+  #define AMX_COMPACTMARGIN 64
+#endif
+
+#define UD_FINDPLUGIN	3
+#define UD_DEBUGGER		2
+#define UD_OPCODELIST	1
+#define	UD_HANDLER		0
+#define	UT_NATIVE		3
+#define UT_OPTIMIZER	2
+#define UT_BROWSEHOOK	1
+#define UT_BINLOGS		0
+
+typedef void (*BROWSEHOOK)(AMX *amx, cell *oplist, cell *cip);
 
 /* for native functions that use floating point parameters, the following
  * two macros are convenient for casting a "cell" into a "float" type _without_
  * changing the bit pattern
  */
-#if SMALL_CELL_SIZE==32
+#if PAWN_CELL_SIZE==32
   #define amx_ftoc(f)   ( * ((cell*)&f) )   /* float to cell */
   #define amx_ctof(c)   ( * ((float*)&c) )  /* cell to float */
-#elif SMALL_CELL_SIZE==64
+#elif PAWN_CELL_SIZE==64
   #define amx_ftoc(f)   ( * ((cell*)&f) )   /* float to cell */
   #define amx_ctof(c)   ( * ((double*)&c) ) /* cell to float */
 #else
@@ -344,7 +361,7 @@ enum {
       amx_StrLen(amx_cstr_, &amx_length_);                                  \
       if (amx_length_ > 0 &&                                                \
           ((result) = (void*)alloca((amx_length_ + 1) * sizeof(*(result)))) != NULL) \
-        amx_GetString((char*)(result), amx_cstr_, sizeof(*(result))>1);     \
+        amx_GetString((char*)(result), amx_cstr_, sizeof(*(result))>1, amx_length_); \
       else (result) = NULL;                                                 \
     } while (0)
 
@@ -353,23 +370,12 @@ uint32_t * AMXAPI amx_Align32(uint32_t *v);
 #if defined _I64_MAX || defined HAVE_I64
   uint64_t * AMXAPI amx_Align64(uint64_t *v);
 #endif
-
-#if SMALL_CELL_SIZE==32
-#define amx_AlignCell amx_Align32
-#elif SMALL_CELL_SIZE==64
-#define amx_AlignCell amx_Align64
-#else
-#error Unsupported cell size
-#endif
-
 int AMXAPI amx_Allot(AMX *amx, int cells, cell *amx_addr, cell **phys_addr);
 int AMXAPI amx_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_Debug(AMX *amx); /* default debug procedure, does nothing */
-int AMXAPI amx_DebugCall(AMX *amx, int mode);
-int AMXAPI amx_Exec(AMX *amx, cell *retval, int index, int numparams, ...);
-int AMXAPI amx_Execv(AMX *amx, cell *retval, int index, int numparams, cell params[]);
+int AMXAPI amx_Exec(AMX *amx, cell *retval, int index);
 int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index);
 int AMXAPI amx_FindPublic(AMX *amx, const char *funcname, int *index);
 int AMXAPI amx_FindPubVar(AMX *amx, const char *varname, cell *amx_addr);
@@ -379,39 +385,71 @@ int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr);
 int AMXAPI amx_GetNative(AMX *amx, int index, char *funcname);
 int AMXAPI amx_GetPublic(AMX *amx, int index, char *funcname);
 int AMXAPI amx_GetPubVar(AMX *amx, int index, char *varname, cell *amx_addr);
-int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar);
+int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar, size_t size);
 int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id);
 int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr);
 int AMXAPI amx_Init(AMX *amx, void *program);
 int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code);
 int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap);
 int AMXAPI amx_NameLength(AMX *amx, int *length);
-AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name,AMX_NATIVE func);
+AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name, AMX_NATIVE func);
 int AMXAPI amx_NumNatives(AMX *amx, int *number);
 int AMXAPI amx_NumPublics(AMX *amx, int *number);
 int AMXAPI amx_NumPubVars(AMX *amx, int *number);
 int AMXAPI amx_NumTags(AMX *amx, int *number);
+int AMXAPI amx_Push(AMX *amx, cell value);
+int AMXAPI amx_PushArray(AMX *amx, cell *amx_addr, cell **phys_addr, const cell array[], int numcells);
+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, AMX_NATIVE_INFO *nativelist, int number);
+int AMXAPI amx_Register(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);
-int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar);
+int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar, size_t size);
 int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr);
-int AMXAPI amx_StrLen(cell *cstring, int *length);
+int AMXAPI amx_StrLen(const cell *cstring, int *length);
+int AMXAPI amx_UTF8Check(const char *string, int *length);
 int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value);
+int AMXAPI amx_UTF8Len(const cell *cstr, int *length);
 int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value);
-int AMXAPI amx_UTF8Check(const char *string);
-void amx_NullNativeTable(AMX *amx);
+int AMXAPI amx_GetLibraries(AMX *amx);
+const char *AMXAPI amx_GetLibrary(AMX *amx, int index, char *buffer, int len);
+int AMXAPI amx_SetStringOld(cell *dest,const char *source,int pack,int use_wchar);
+int AMXAPI amx_GetStringOld(char *dest,const cell *source,int use_wchar);
+
+#if PAWN_CELL_SIZE==16
+  #define amx_AlignCell(v) amx_Align16(v)
+#elif PAWN_CELL_SIZE==32
+  #define amx_AlignCell(v) amx_Align32(v)
+#elif PAWN_CELL_SIZE==64 && (defined _I64_MAX || defined HAVE_I64)
+  #define amx_AlignCell(v) amx_Align64(v)
+#else
+  #error Unsupported cell size
+#endif
+
+#define amx_RegisterFunc(amx, name, func) \
+  amx_Register((amx), amx_NativeInfo((name),(func)), 1);
 
 #if !defined AMX_NO_ALIGN
-  #if defined __linux__
+  #if defined LINUX || defined __FreeBSD__
     #pragma pack()    /* reset default packing */
+  #elif defined MACOS && defined __MWERKS__
+    #pragma options align=reset
   #else
     #pragma pack(pop) /* reset previous packing */
   #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/amx_mm.def

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

amxmodx/amxcore.cpp

@@ -1,6 +1,6 @@
-/*  Core module for the Small AMX
+/*  Core module for the Pawn AMX
  *
- *  Copyright (c) ITB CompuPhase, 1997-2004
+ *  Copyright (c) ITB CompuPhase, 1997-2005
  *
  *  This software is provided "as-is", without any express or implied warranty.
  *  In no event will the authors be held liable for any damages arising from
@@ -34,14 +34,7 @@
 #include <string.h>
 #include <limits.h>
 #include <assert.h>
-
-// this file does not include amxmodx.h, so we have to include the memory manager here
-#ifdef MEMORY_TEST
-#include "mmgr/mmgr.h"
-#endif // MEMORY_TEST
-
 #include "amx.h"
-
 #if defined __WIN32__ || defined _WIN32 || defined WIN32 || defined _Windows
   #include <windows.h>
 #endif
@@ -60,14 +53,13 @@
 # define _tcscpy        strcpy
 # define _tcsdup        strdup
 # define _tcslen        strlen
-# define _stprintf      sprintf
 #endif
 
 
 #define CHARBITS        (8*sizeof(char))
 typedef unsigned char   uchar;
 
-#if !defined NOPROPLIST
+#if !defined AMX_NOPROPLIST
 typedef struct _property_list {
   struct _property_list *next;
   cell id;
@@ -76,7 +68,7 @@ typedef struct _property_list {
   //??? safe AMX (owner of the property)
 } proplist;
 
-static proplist proproot = { NULL };
+static proplist proproot = { NULL, 0, NULL, 0 };
 
 static proplist *list_additem(proplist *root)
 {
@@ -142,15 +134,13 @@ static proplist *list_finditem(proplist *root,cell id,char *name,cell value,
 }
 #endif
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL numargs(AMX *amx, cell *params)
 {
   AMX_HEADER *hdr;
   uchar *data;
   cell bytes;
 
+  (void)params;
   hdr=(AMX_HEADER *)amx->base;
   data=amx->data ? amx->data : amx->base+(int)hdr->dat;
   /* the number of bytes is on the stack, at "frm + 2*cell" */
@@ -190,18 +180,16 @@ 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];
   return 1;
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL heapspace(AMX *amx,cell *params)
 {
+  (void)params;
   return amx->stk - amx->hea;
 }
 
@@ -220,142 +208,22 @@ static cell AMX_NATIVE_CALL funcidx(AMX *amx,cell *params)
     return 0;
   } /* if */
 
-  amx_GetString(name,cstr,0);
+  amx_GetString(name,cstr,0,UNLIMITED);
   err=amx_FindPublic(amx,name,&index);
   if (err!=AMX_ERR_NONE)
     index=-1;   /* this is not considered a fatal error */
   return index;
 }
 
-int amx_StrPack(cell *dest,cell *source)
-{
-  int len;
-
-  amx_StrLen(source,&len);
-  if ((ucell)*source>UNPACKEDMAX) {
-    /* source string is already packed */
-    while (len >= 0) {
-      *dest++ = *source++;
-      len-=sizeof(cell);
-    } /* while */
-  } else {
-    /* pack string, from bottom up */
-    cell c;
-    int i;
-    for (c=0,i=0; i<len; i++) {
-      assert((*source & ~0xffL)==0);
-      c=(c<<CHARBITS) | *source++;
-      if (i%sizeof(cell) == sizeof(cell)-1) {
-        *dest++=c;
-        c=0;
-      } /* if */
-    } /* for */
-    if (i%sizeof(cell) != 0)    /* store remaining packed characters */
-      *dest=c << (sizeof(cell)-i%sizeof(cell))*CHARBITS;
-    else
-      *dest=0;                  /* store full cell of zeros */
-  } /* if */
-  return AMX_ERR_NONE;
-}
-
-int amx_StrUnpack(cell *dest,cell *source)
-{
-  if ((ucell)*source>UNPACKEDMAX) {
-    /* unpack string, from top down (so string can be unpacked in place) */
-    cell c;
-    int i,len;
-    amx_StrLen(source,&len);
-    dest[len]=0;
-    for (i=len-1; i>=0; i--) {
-      c=source[i/sizeof(cell)] >> (sizeof(cell)-i%sizeof(cell)-1)*CHARBITS;
-      dest[i]=c & UCHAR_MAX;
-    } /* for */
-  } else {
-    /* source string is already unpacked */
-    while ((*dest++ = *source++) != 0)
-      /* nothing */;
-  } /* if */
-  return AMX_ERR_NONE;
-}
-
-static int verify_addr(AMX *amx,cell addr)
-{
-  int err;
-  cell *cdest;
-
-  err=amx_GetAddr(amx,addr,&cdest);
-  if (err!=AMX_ERR_NONE)
-    amx_RaiseError(amx,err);
-  return err;
-}
-
-static cell AMX_NATIVE_CALL core_strlen(AMX *amx,cell *params)
-{
-  cell *cptr;
-  int len = 0;
-
-  if (amx_GetAddr(amx,params[1],&cptr)==AMX_ERR_NONE)
-    amx_StrLen(cptr,&len);
-  return len;
-}
-
-static cell AMX_NATIVE_CALL strpack(AMX *amx,cell *params)
-{
-  cell *cdest,*csrc;
-  int len,needed,err;
-  size_t lastaddr;
-
-  /* calculate number of cells needed for (packed) destination */
-  amx_GetAddr(amx,params[2],&csrc);
-  amx_StrLen(csrc,&len);
-  needed=(len+sizeof(cell))/sizeof(cell);     /* # of cells needed */
-  assert(needed>0);
-  lastaddr=(size_t)(params[1]+sizeof(cell)*needed-1);
-  if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE)
-    return 0;
-
-  amx_GetAddr(amx,params[1],&cdest);
-  err=amx_StrPack(cdest,csrc);
-  if (err!=AMX_ERR_NONE)
-    return amx_RaiseError(amx,err);
-
-  return len;
-}
-
-static cell AMX_NATIVE_CALL strunpack(AMX *amx,cell *params)
-{
-  cell *cdest,*csrc;
-  int len,err;
-  size_t lastaddr;
-
-  /* calculate number of cells needed for (packed) destination */
-  amx_GetAddr(amx,params[2],&csrc);
-  amx_StrLen(csrc,&len);
-  assert(len>=0);
-  lastaddr=(size_t)(params[1]+sizeof(cell)*(len+1)-1);
-  if (verify_addr(amx,(cell)lastaddr)!=AMX_ERR_NONE)
-    return 0;
-
-  amx_GetAddr(amx,params[1],&cdest);
-  err=amx_StrUnpack(cdest,csrc);
-  if (err!=AMX_ERR_NONE)
-    return amx_RaiseError(amx,err);
-
-  return len;
-}
-
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
 {
   union {
     cell c;
-    #if SMALL_CELL_SIZE==16
+    #if PAWN_CELL_SIZE==16
       uchar b[2];
-    #elif SMALL_CELL_SIZE==32
+    #elif PAWN_CELL_SIZE==32
       uchar b[4];
-    #elif SMALL_CELL_SIZE==64
+    #elif PAWN_CELL_SIZE==64
       uchar b[8];
 	#else
 	  #error Unsupported cell size
@@ -363,20 +231,21 @@ static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
   } value;
   uchar t;
 
+  (void)amx;
   assert((size_t)params[0]==sizeof(cell));
   value.c = params[1];
-  #if SMALL_CELL_SIZE==16
+  #if PAWN_CELL_SIZE==16
     t = value.b[0];
     value.b[0] = value.b[1];
     value.b[1] = t;
-  #elif SMALL_CELL_SIZE==32
+  #elif PAWN_CELL_SIZE==32
     t = value.b[0];
     value.b[0] = value.b[3];
     value.b[3] = t;
     t = value.b[1];
     value.b[1] = value.b[2];
     value.b[2] = t;
-  #elif SMALL_CELL_SIZE==64
+  #elif PAWN_CELL_SIZE==64
     t = value.b[0];
     value.b[0] = value.b[7];
     value.b[7] = t;
@@ -395,11 +264,9 @@ static cell AMX_NATIVE_CALL swapchars(AMX *amx,cell *params)
   return value.c;
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL core_tolower(AMX *amx,cell *params)
 {
+  (void)amx;
   #if defined __WIN32__ || defined _WIN32 || defined WIN32
     return (cell)CharLower((LPTSTR)params[1]);
   #elif defined _Windows
@@ -409,11 +276,9 @@ static cell AMX_NATIVE_CALL core_tolower(AMX *amx,cell *params)
   #endif
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL core_toupper(AMX *amx,cell *params)
 {
+  (void)amx;
   #if defined __WIN32__ || defined _WIN32 || defined WIN32
     return (cell)CharUpper((LPTSTR)params[1]);
   #elif defined _Windows
@@ -423,19 +288,15 @@ static cell AMX_NATIVE_CALL core_toupper(AMX *amx,cell *params)
   #endif
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL core_min(AMX *amx,cell *params)
 {
+  (void)amx;
   return params[1] <= params[2] ? params[1] : params[2];
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 static cell AMX_NATIVE_CALL core_max(AMX *amx,cell *params)
 {
+  (void)amx;
   return params[1] >= params[2] ? params[1] : params[2];
 }
 
@@ -451,7 +312,7 @@ static cell AMX_NATIVE_CALL core_clamp(AMX *amx,cell *params)
   return value;
 }
 
-#if !defined NOPROPLIST
+#if !defined AMX_NOPROPLIST
 static char *MakePackedString(cell *cptr)
 {
   int len;
@@ -459,10 +320,21 @@ static char *MakePackedString(cell *cptr)
 
   amx_StrLen(cptr,&len);
   dest=(char *)malloc(len+sizeof(cell));
-  amx_GetString(dest,cptr,0);
+  amx_GetString(dest,cptr,0,UNLIMITED);
   return dest;
 }
 
+static int verify_addr(AMX *amx,cell addr)
+{
+  int err;
+  cell *cdest;
+
+  err=amx_GetAddr(amx,addr,&cdest);
+  if (err!=AMX_ERR_NONE)
+    amx_RaiseError(amx,err);
+  return err;
+}
+
 static cell AMX_NATIVE_CALL getproperty(AMX *amx,cell *params)
 {
   cell *cstr;
@@ -480,7 +352,7 @@ static cell AMX_NATIVE_CALL getproperty(AMX *amx,cell *params)
       return 0;
     } /* if */
     amx_GetAddr(amx,params[4],&cstr);
-    amx_SetString(cstr,item->name,1,0);
+    amx_SetString(cstr,item->name,1,0,UNLIMITED);
   } /* if */
   free(name);
   return (item!=NULL) ? item->value : 0;
@@ -545,12 +417,14 @@ static cell AMX_NATIVE_CALL existproperty(AMX *amx,cell *params)
 }
 #endif
 
+#if !defined AMX_NORANDOM
 /* This routine comes from the book "Inner Loops" by Rick Booth, Addison-Wesley
  * (ISBN 0-201-47960-5). This is a "multiplicative congruential random number
  * generator" that has been extended to 31-bits (the standard C version returns
  * only 15-bits).
  */
-static unsigned long IL_StandardRandom_seed = 0L;
+#define INITIAL_SEED  0xcaa938dbL
+static unsigned long IL_StandardRandom_seed = INITIAL_SEED; /* always use a non-zero seed */
 #define IL_RMULT 1103515245L
 #if defined __BORLANDC__ || defined __WATCOMC__
   #pragma argsused
@@ -562,7 +436,7 @@ static cell AMX_NATIVE_CALL core_random(AMX *amx,cell *params)
 
     /* one-time initialization (or, mostly one-time) */
     #if !defined SN_TARGET_PS2 && !defined _WIN32_WCE
-        if (IL_StandardRandom_seed == 0L)
+        if (IL_StandardRandom_seed == INITIAL_SEED)
             IL_StandardRandom_seed=(unsigned long)time(NULL);
     #endif
 
@@ -579,6 +453,7 @@ static cell AMX_NATIVE_CALL core_random(AMX *amx,cell *params)
         result %= params[1];
     return (cell)result;
 }
+#endif
 
 
 AMX_NATIVE_INFO core_Natives[] = {
@@ -587,22 +462,13 @@ AMX_NATIVE_INFO core_Natives[] = {
   { "setarg",        setarg },
   { "heapspace",     heapspace },
   { "funcidx",       funcidx },
-  { "strlen",        core_strlen },
-  { "strpack",       strpack },
-  { "strunpack",     strunpack },
   { "swapchars",     swapchars },
   { "tolower",       core_tolower },
   { "toupper",       core_toupper },
-  { "random",        core_random },
   { "min",           core_min },
   { "max",           core_max },
   { "clamp",         core_clamp },
-#if !defined NOPROPLIST
-  { "getproperty",   getproperty },
-  { "setproperty",   setproperty },
-  { "deleteproperty",delproperty },
-  { "existproperty", existproperty },
-#endif
+  { "random",        core_random },
   { NULL, NULL }        /* terminator */
 };
 
@@ -611,12 +477,10 @@ int AMXEXPORT amx_CoreInit(AMX *amx)
   return amx_Register(amx, core_Natives, -1);
 }
 
-#if defined __BORLANDC__ || defined __WATCOMC__
-  #pragma argsused
-#endif
 int AMXEXPORT amx_CoreCleanup(AMX *amx)
 {
-  #if !defined NOPROPLIST
+  (void)amx;
+  #if !defined AMX_NOPROPLIST
     //??? delete only the properties owned by the AMX
     while (proproot.next!=NULL)
       list_delete(&proproot,proproot.next);

amxmodx/amxdbg.cpp

@@ -0,0 +1,498 @@
+/*  Pawn debugger interface
+ *
+ *  Support functions for debugger applications
+ *
+ *  Copyright (c) ITB CompuPhase, 2005
+ *
+ *  This software is provided "as-is", without any express or implied warranty.
+ *  In no event will the authors be held liable for any damages arising from
+ *  the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1.  The origin of this software must not be misrepresented; you must not
+ *      claim that you wrote the original software. If you use this software in
+ *      a product, an acknowledgment in the product documentation would be
+ *      appreciated but is not required.
+ *  2.  Altered source versions must be plainly marked as such, and must not be
+ *      misrepresented as being the original software.
+ *  3.  This notice may not be removed or altered from any source distribution.
+ *
+ *  Version: $Id$
+ */
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include "osdefs.h"     /* for _MAX_PATH */
+#include "amx.h"
+#include "amxdbg.h"
+
+// this file does not include amxmodx.h, so we have to include the memory manager here
+#ifdef MEMORY_TEST
+#include "mmgr/mmgr.h"
+#endif // MEMORY_TEST
+
+int AMXAPI dbg_FreeInfo(AMX_DBG *amxdbg)
+{
+  assert(amxdbg != NULL);
+  if (amxdbg->hdr != NULL)
+    free(amxdbg->hdr);
+  if (amxdbg->filetbl != NULL)
+    free(amxdbg->filetbl);
+  if (amxdbg->symboltbl != NULL)
+    free(amxdbg->symboltbl);
+  if (amxdbg->tagtbl != NULL)
+    free(amxdbg->tagtbl);
+  if (amxdbg->automatontbl != NULL)
+    free(amxdbg->automatontbl);
+  if (amxdbg->statetbl != NULL)
+    free(amxdbg->statetbl);
+  memset(amxdbg, 0, sizeof(AMX_DBG));
+  return AMX_ERR_NONE;
+}
+
+void memread(void *dest, char **src, size_t size)
+{
+	void *ptr = *src;
+	memcpy(dest, ptr, size);
+	*src += size;
+}
+
+const char *ClipFileName(const char *inp)
+{
+	static char buffer[256];
+	size_t len = strlen(inp);
+	const char *ptr = inp;
+
+	for (size_t i=0; i<len; i++)
+	{
+		if ((inp[i] == '\\' || inp[i] == '/') && (i != len-1))
+			ptr = inp + i + 1;
+	}
+	strcpy(buffer, ptr);
+
+	return buffer;
+}
+
+//Note - I changed this function to read from memory instead.
+// -- BAILOPAN
+int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, void *dbg_addr)
+{
+  AMX_DBG_HDR dbghdr;
+  unsigned char *ptr;
+  int index, dim;
+  AMX_DBG_SYMDIM *symdim;
+
+  assert(amxdbg != NULL);
+
+  char *addr = (char *)(dbg_addr);
+
+  memset(&dbghdr, 0, sizeof(AMX_DBG_HDR));
+  memread(&dbghdr, &addr, sizeof(AMX_DBG_HDR));
+
+  //brabbby graa gragghty graaahhhh
+  #if BYTE_ORDER==BIG_ENDIAN
+    amx_Align32((uint32_t*)&dbghdr.size);
+    amx_Align16(&dbghdr.magic);
+    amx_Align16(&dbghdr.flags);
+    amx_Align16(&dbghdr.files);
+    amx_Align16(&dbghdr.lines);
+    amx_Align16(&dbghdr.symbols);
+    amx_Align16(&dbghdr.tags);
+    amx_Align16(&dbghdr.automatons);
+    amx_Align16(&dbghdr.states);
+  #endif
+
+  if (dbghdr.magic != AMX_DBG_MAGIC)
+    return AMX_ERR_FORMAT;
+
+  /* allocate all memory */
+  memset(amxdbg, 0, sizeof(AMX_DBG));
+  amxdbg->hdr = (AMX_DBG_HDR *)malloc((size_t)dbghdr.size);
+  if (dbghdr.files > 0)
+    amxdbg->filetbl = (AMX_DBG_FILE **)malloc(dbghdr.files * sizeof(AMX_DBG_FILE *));
+  if (dbghdr.symbols > 0)
+    amxdbg->symboltbl = (AMX_DBG_SYMBOL **)malloc(dbghdr.symbols * sizeof(AMX_DBG_SYMBOL *));
+  if (dbghdr.tags > 0)
+    amxdbg->tagtbl = (AMX_DBG_TAG **)malloc(dbghdr.tags * sizeof(AMX_DBG_TAG *));
+  if (dbghdr.automatons > 0)
+    amxdbg->automatontbl = (AMX_DBG_MACHINE **)malloc(dbghdr.automatons * sizeof(AMX_DBG_MACHINE *));
+  if (dbghdr.states > 0)
+    amxdbg->statetbl = (AMX_DBG_STATE **)malloc(dbghdr.states * sizeof(AMX_DBG_STATE *));
+  if (amxdbg->hdr == NULL
+      || (dbghdr.files > 0 && amxdbg->filetbl == NULL)
+      || (dbghdr.symbols > 0 && amxdbg->symboltbl == NULL)
+      || (dbghdr.tags > 0 && amxdbg->tagtbl == NULL)
+      || (dbghdr.states > 0 && amxdbg->statetbl == NULL)
+      || (dbghdr.automatons > 0 && amxdbg->automatontbl == NULL))
+  {
+    dbg_FreeInfo(amxdbg);
+    return AMX_ERR_MEMORY;
+  } /* if */
+
+  /* load the entire symbolic information block into memory */
+  memcpy(amxdbg->hdr, &dbghdr, sizeof dbghdr);
+  ptr = (unsigned char *)(amxdbg->hdr + 1);
+  memread(ptr, &addr, (size_t)(dbghdr.size-sizeof(dbghdr)));
+
+  /* file table */
+  for (index = 0; index < dbghdr.files; index++) {
+    assert(amxdbg->filetbl != NULL);
+    amxdbg->filetbl[index] = (AMX_DBG_FILE *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_AlignCell(&amxdbg->filetbl[index]->address);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_FILE); *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+  } /* for */
+
+  //debug("Files: %d\n", amxdbg->hdr->files);
+  for (index=0;index<amxdbg->hdr->files; index++)
+  {
+	  strcpy((char *)amxdbg->filetbl[index]->name, ClipFileName(amxdbg->filetbl[index]->name));
+	  //debug(" [%d] %s\n", index, amxdbg->filetbl[index]->name);
+  }
+
+  /* line table */
+  amxdbg->linetbl = (AMX_DBG_LINE*)ptr;
+  #if BYTE_ORDER==BIG_ENDIAN
+    for (index = 0; index < dbghdr.lines; index++) {
+      amx_AlignCell(&amxdbg->linetbl[index].address);
+      amx_Align32((uint32_t*)&amxdbg->linetbl[index].line);
+    } /* for */
+  #endif
+  ptr += dbghdr.lines * sizeof(AMX_DBG_LINE);
+
+  /* symbol table (plus index tags) */
+  for (index = 0; index < dbghdr.symbols; index++) {
+    assert(amxdbg->symboltbl != NULL);
+    amxdbg->symboltbl[index] = (AMX_DBG_SYMBOL *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_AlignCell(&amxdbg->symboltbl[index]->address);
+      amx_Align16((uint16_t*)&amxdbg->symboltbl[index]->tag);
+      amx_AlignCell(&amxdbg->symboltbl[index]->codestart);
+      amx_AlignCell(&amxdbg->symboltbl[index]->codeend);
+      amx_Align16((uint16_t*)&amxdbg->symboltbl[index]->dim);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_SYMBOL); *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+    for (dim = 0; dim < amxdbg->symboltbl[index]->dim; dim++) {
+      symdim = (AMX_DBG_SYMDIM *)ptr;
+      amx_Align16((uint16_t*)&symdim->tag);
+      amx_AlignCell(&symdim->size);
+      ptr += sizeof(AMX_DBG_SYMDIM);
+    } /* for */
+  } /* for */
+
+  /* tag name table */
+  for (index = 0; index < dbghdr.tags; index++) {
+    assert(amxdbg->tagtbl != NULL);
+    amxdbg->tagtbl[index] = (AMX_DBG_TAG *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_Align16(&amxdbg->tagtbl[index]->tag);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_TAG) - 1; *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+  } /* for */
+
+  /* automaton name table */
+  for (index = 0; index < dbghdr.automatons; index++) {
+    assert(amxdbg->automatontbl != NULL);
+    amxdbg->automatontbl[index] = (AMX_DBG_MACHINE *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_Align16(&amxdbg->automatontbl[index]->automaton);
+      amx_AlignCell(&amxdbg->automatontbl[index]->address);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_MACHINE) - 1; *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+  } /* for */
+
+  /* state name table */
+  for (index = 0; index < dbghdr.states; index++) {
+    assert(amxdbg->statetbl != NULL);
+    amxdbg->statetbl[index] = (AMX_DBG_STATE *)ptr;
+    #if BYTE_ORDER==BIG_ENDIAN
+      amx_Align16(&amxdbg->statetbl[index]->state);
+      amx_Align16(&amxdbg->automatontbl[index]->automaton);
+    #endif
+    for (ptr = ptr + sizeof(AMX_DBG_STATE) - 1; *ptr != '\0'; ptr++)
+      /* nothing */;
+    ptr++;              /* skip '\0' too */
+  } /* for */
+
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_LookupFile(AMX_DBG *amxdbg, ucell address, const char **filename)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(filename != NULL);
+  *filename = NULL;
+  /* this is a simple linear look-up; a binary search would be possible too */
+  for (index = 0; index < amxdbg->hdr->files && amxdbg->filetbl[index]->address <= address; index++)
+    /* nothing */;
+  /* reset for overrun */
+  if (--index < 0)
+    return AMX_ERR_NOTFOUND;
+
+  *filename = amxdbg->filetbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_LookupLine(AMX_DBG *amxdbg, ucell address, long *line)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(line != NULL);
+  *line = 0;
+  /* this is a simple linear look-up; a binary search would be possible too */
+  for (index = 0; index < amxdbg->hdr->lines && amxdbg->linetbl[index].address <= address; index++)
+    /* nothing */;
+  /* reset for overrun */
+  if (--index < 0)
+    return AMX_ERR_NOTFOUND;
+
+  *line = (long)amxdbg->linetbl[index].line;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_LookupFunction(AMX_DBG *amxdbg, ucell address, const char **funcname)
+{
+  /* dbg_LookupFunction() finds the function a code address is in. It can be
+   * used for stack walking, and for stepping through a function while stepping
+   * over sub-functions
+   */
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(funcname != NULL);
+  *funcname = NULL;
+  for (index = 0; index < amxdbg->hdr->symbols; index++) {
+    if (amxdbg->symboltbl[index]->ident == iFUNCTN
+        && amxdbg->symboltbl[index]->codestart <= address
+        && amxdbg->symboltbl[index]->codeend > address)
+      break;
+  } /* for */
+  if (index >= amxdbg->hdr->symbols)
+    return AMX_ERR_NOTFOUND;
+
+  *funcname = amxdbg->symboltbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetTagName(AMX_DBG *amxdbg, int tag, const char **name)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(name != NULL);
+  *name = NULL;
+  for (index = 0; index < amxdbg->hdr->tags && amxdbg->tagtbl[index]->tag != tag; index++)
+    /* nothing */;
+  if (index >= amxdbg->hdr->tags)
+    return AMX_ERR_NOTFOUND;
+
+  *name = amxdbg->tagtbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetAutomatonName(AMX_DBG *amxdbg, int automaton, const char **name)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(name != NULL);
+  *name = NULL;
+  for (index = 0; index < amxdbg->hdr->automatons && amxdbg->automatontbl[index]->automaton != automaton; index++)
+    /* nothing */;
+  if (index >= amxdbg->hdr->automatons)
+    return AMX_ERR_NOTFOUND;
+
+  *name = amxdbg->automatontbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetStateName(AMX_DBG *amxdbg, int state, const char **name)
+{
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(name != NULL);
+  *name = NULL;
+  for (index = 0; index < amxdbg->hdr->states && amxdbg->statetbl[index]->state != state; index++)
+    /* nothing */;
+  if (index >= amxdbg->hdr->states)
+    return AMX_ERR_NOTFOUND;
+
+  *name = amxdbg->statetbl[index]->name;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetLineAddress(AMX_DBG *amxdbg, long line, const char *filename, ucell *address)
+{
+  /* Find a suitable "breakpoint address" close to the indicated line (and in
+   * the specified file). The address is moved up to the next "breakable" line
+   * if no "breakpoint" is available on the specified line. You can use function
+   * dbg_LookupLine() to find out at which precise line the breakpoint was set.
+   *
+   * The filename comparison is strict (case sensitive and path sensitive); the
+   * "filename" parameter should point into the "filetbl" of the AMX_DBG
+   * structure.
+   */
+  int file, index;
+  ucell bottomaddr,topaddr;
+
+  assert(amxdbg != NULL);
+  assert(filename != NULL);
+  assert(address != NULL);
+  *address = 0;
+
+  index = 0;
+  for (file = 0; file < amxdbg->hdr->files; file++) {
+    /* find the (next) mathing instance of the file */
+    if (strcmp(amxdbg->filetbl[file]->name, filename) != 0)
+      continue;
+    /* get address range for the current file */
+    bottomaddr = amxdbg->filetbl[file]->address;
+    topaddr = (file + 1 < amxdbg->hdr->files) ? amxdbg->filetbl[file+1]->address : (ucell)(cell)-1;
+    /* go to the starting address in the line table */
+    while (index < amxdbg->hdr->lines && amxdbg->linetbl[index].address < bottomaddr)
+      index++;
+    /* browse until the line is found or until the top address is exceeded */
+    while (index < amxdbg->hdr->lines
+           && amxdbg->linetbl[index].line < line
+           && amxdbg->linetbl[index].address < topaddr)
+      index++;
+    if (index >= amxdbg->hdr->lines)
+      return AMX_ERR_NOTFOUND;
+    if (amxdbg->linetbl[index].line >= line)
+      break;
+    /* if not found (and the line table is not yet exceeded) try the next
+     * instance of the same file (a file may appear twice in the file table)
+     */
+  } /* for */
+
+  if (strcmp(amxdbg->filetbl[file]->name, filename) != 0)
+    return AMX_ERR_NOTFOUND;
+
+  assert(index < amxdbg->hdr->lines);
+  *address = amxdbg->linetbl[index].address;
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetFunctionAddress(AMX_DBG *amxdbg, const char *funcname, const char *filename, ucell *address)
+{
+  /* Find a suitable "breakpoint address" close to the indicated line (and in
+   * the specified file). The address is moved up to the first "breakable" line
+   * in the function. You can use function dbg_LookupLine() to find out at which
+   * precise line the breakpoint was set.
+   *
+   * The filename comparison is strict (case sensitive and path sensitive); the
+   * "filename" parameter should point into the "filetbl" of the AMX_DBG
+   * structure. The function name comparison is case sensitive too.
+   */
+  int index, err;
+  const char *tgtfile;
+  ucell funcaddr;
+
+  assert(amxdbg != NULL);
+  assert(funcname != NULL);
+  assert(filename != NULL);
+  assert(address != NULL);
+  *address = 0;
+
+  index = 0;
+  for ( ;; ) {
+    /* find (next) matching function */
+    while (index < amxdbg->hdr->symbols
+           && (amxdbg->symboltbl[index]->ident != iFUNCTN || strcmp(amxdbg->symboltbl[index]->name, funcname) != 0))
+      index++;
+    if (index >= amxdbg->hdr->symbols)
+      return AMX_ERR_NOTFOUND;
+    /* verify that this line falls in the appropriate file */
+    err = dbg_LookupFile(amxdbg, amxdbg->symboltbl[index]->address, &tgtfile);
+    if (err == AMX_ERR_NONE || strcmp(filename, tgtfile) == 0)
+      break;
+    index++;            /* line is the wrong file, search further */
+  } /* for */
+
+  /* now find the first line in the function where we can "break" on */
+  assert(index < amxdbg->hdr->symbols);
+  funcaddr = amxdbg->symboltbl[index]->address;
+  for (index = 0; index < amxdbg->hdr->lines && amxdbg->linetbl[index].address < funcaddr; index++)
+    /* nothing */;
+
+  if (index >= amxdbg->hdr->lines)
+    return AMX_ERR_NOTFOUND;
+  *address = amxdbg->linetbl[index].address;
+
+  return AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetVariable(AMX_DBG *amxdbg, const char *symname, ucell scopeaddr, const AMX_DBG_SYMBOL **sym)
+{
+  ucell codestart,codeend;
+  int index;
+
+  assert(amxdbg != NULL);
+  assert(symname != NULL);
+  assert(sym != NULL);
+  *sym = NULL;
+
+  codestart = codeend = 0;
+  index = 0;
+  for ( ;; ) {
+    /* find (next) matching variable */
+    while (index < amxdbg->hdr->symbols
+           && (amxdbg->symboltbl[index]->ident == iFUNCTN || strcmp(amxdbg->symboltbl[index]->name, symname) != 0)
+           && (amxdbg->symboltbl[index]->codestart > scopeaddr || amxdbg->symboltbl[index]->codeend < scopeaddr))
+      index++;
+    if (index >= amxdbg->hdr->symbols)
+      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
+            || amxdbg->symboltbl[index]->codestart >= codestart && amxdbg->symboltbl[index]->codeend <= codeend))
+    {
+      *sym = amxdbg->symboltbl[index];
+      codestart = amxdbg->symboltbl[index]->codestart;
+      codeend = amxdbg->symboltbl[index]->codeend;
+    } /* if */
+    index++;
+  } /* for */
+
+  return (*sym == NULL) ? AMX_ERR_NOTFOUND : AMX_ERR_NONE;
+}
+
+int AMXAPI dbg_GetArrayDim(AMX_DBG *amxdbg, const AMX_DBG_SYMBOL *sym, const AMX_DBG_SYMDIM **symdim)
+{
+  /* retrieves a pointer to the array dimensions structures of an array symbol */
+  const char *ptr;
+
+  assert(amxdbg != NULL);
+  assert(sym != NULL);
+  assert(symdim != NULL);
+  *symdim = NULL;
+
+  if (sym->ident != iARRAY && sym->ident != iREFARRAY)
+    return AMX_ERR_PARAMS;
+  assert(sym->dim > 0); /* array must have at least one dimension */
+
+  /* find the end of the symbol name */
+  for (ptr = sym->name; *ptr != '\0'; ptr++)
+    /* nothing */;
+  *symdim = (AMX_DBG_SYMDIM *)(ptr + 1);/* skip '\0' too */
+
+  return AMX_ERR_NONE;
+}

amxmodx/amxdbg.h

@@ -0,0 +1,172 @@
+/*  Abstract Machine for the Pawn compiler, debugger support
+ *
+ *  This file contains extra definitions that are convenient for debugger
+ *  support.
+ *
+ *  Copyright (c) ITB CompuPhase, 2005
+ *
+ *  This software is provided "as-is", without any express or implied warranty.
+ *  In no event will the authors be held liable for any damages arising from
+ *  the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1.  The origin of this software must not be misrepresented; you must not
+ *      claim that you wrote the original software. If you use this software in
+ *      a product, an acknowledgment in the product documentation would be
+ *      appreciated but is not required.
+ *  2.  Altered source versions must be plainly marked as such, and must not be
+ *      misrepresented as being the original software.
+ *  3.  This notice may not be removed or altered from any source distribution.
+ *
+ *  Version: $Id$
+ */
+
+#ifndef AMXDBG_H_INCLUDED
+#define AMXDBG_H_INCLUDED
+
+#ifndef AMX_H_INCLUDED
+  #include "amx.h"
+#endif
+
+#ifdef  __cplusplus
+extern  "C" {
+#endif
+
+/* Some compilers do not support the #pragma align, which should be fine. Some
+ * compilers give a warning on unknown #pragmas, which is not so fine...
+ */
+#if defined SN_TARGET_PS2 || defined __GNUC__
+  #define AMX_NO_ALIGN
+#endif
+
+#if defined __GNUC__
+  #define PACKED        __attribute__((packed))
+#else
+  #define PACKED
+#endif
+
+#if !defined AMX_NO_ALIGN
+  #if defined LINUX || defined __FreeBSD__
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #elif defined MACOS && defined __MWERKS__
+	#pragma options align=mac68k
+  #else
+    #pragma pack(push)
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+    #if defined __TURBOC__
+      #pragma option -a-    /* "pack" pragma for older Borland compilers */
+    #endif
+  #endif
+#endif
+
+typedef struct 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    amx_version   PACKED; /* 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 */
+  int16_t symbols       PACKED; /* number of entries in the "symbol" table */
+  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;
+#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 */
+} AMX_DBG_FILE          PACKED;
+
+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;
+
+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    vclass        PACKED; /* class of symbol (global/local) */
+  int16_t dim           PACKED; /* number of dimensions */
+  const char name[1]    PACKED; /* ASCII string, zero-terminated */
+} AMX_DBG_SYMBOL        PACKED;
+
+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;
+
+typedef struct tagAMX_DBG_TAG {
+  int16_t tag           PACKED; /* tag id */
+  const char name[1]    PACKED; /* ASCII string, zero-terminated */
+} AMX_DBG_TAG           PACKED;
+
+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 */
+} AMX_DBG_MACHINE       PACKED;
+
+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 */
+} AMX_DBG_STATE         PACKED;
+
+typedef struct tagAMX_DBG {
+  AMX_DBG_HDR     _FAR *hdr         PACKED; /* points to the AMX_DBG header */
+  AMX_DBG_FILE    _FAR **filetbl    PACKED;
+  AMX_DBG_LINE    _FAR *linetbl     PACKED;
+  AMX_DBG_SYMBOL  _FAR **symboltbl  PACKED;
+  AMX_DBG_TAG     _FAR **tagtbl     PACKED;
+  AMX_DBG_MACHINE _FAR **automatontbl PACKED;
+  AMX_DBG_STATE   _FAR **statetbl   PACKED;
+} AMX_DBG                           PACKED;
+
+#if !defined iVARIABLE
+  #define iVARIABLE  1  /* cell that has an address and that can be fetched directly (lvalue) */
+  #define iREFERENCE 2  /* iVARIABLE, but must be dereferenced */
+  #define iARRAY     3
+  #define iREFARRAY  4  /* an array passed by reference (i.e. a pointer) */
+  #define iFUNCTN    9
+#endif
+
+
+int AMXAPI dbg_FreeInfo(AMX_DBG *amxdbg);
+int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, void *dbg_addr);
+
+int AMXAPI dbg_LookupFile(AMX_DBG *amxdbg, ucell address, const char **filename);
+int AMXAPI dbg_LookupFunction(AMX_DBG *amxdbg, ucell address, const char **funcname);
+int AMXAPI dbg_LookupLine(AMX_DBG *amxdbg, ucell address, long *line);
+
+int AMXAPI dbg_GetFunctionAddress(AMX_DBG *amxdbg, const char *funcname, const char *filename, ucell *address);
+int AMXAPI dbg_GetLineAddress(AMX_DBG *amxdbg, long line, const char *filename, ucell *address);
+int AMXAPI dbg_GetAutomatonName(AMX_DBG *amxdbg, int automaton, const char **name);
+int AMXAPI dbg_GetStateName(AMX_DBG *amxdbg, int state, const char **name);
+int AMXAPI dbg_GetTagName(AMX_DBG *amxdbg, int tag, const char **name);
+int AMXAPI dbg_GetVariable(AMX_DBG *amxdbg, const char *symname, ucell scopeaddr, const AMX_DBG_SYMBOL **sym);
+int AMXAPI dbg_GetArrayDim(AMX_DBG *amxdbg, const AMX_DBG_SYMBOL *sym, const AMX_DBG_SYMDIM **symdim);
+
+
+#if !defined AMX_NO_ALIGN
+  #if defined LINUX || defined __FreeBSD__
+    #pragma pack()    /* reset default packing */
+  #elif defined MACOS && defined __MWERKS__
+    #pragma options align=reset
+  #else
+    #pragma pack(pop) /* reset previous packing */
+  #endif
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* AMXDBG_H_INCLUDED */

amxmodx/amxdefn.asm

@@ -0,0 +1,86 @@
+; Definition of the AMX structure for assembler syntax (NASM)
+
+	struc amx_s
+_base:       resd 1
+_dataseg:    resd 1
+_callback:   resd 1
+_debug:      resd 1
+_cip:        resd 1
+_frm:        resd 1
+_hea:        resd 1
+_hlw:        resd 1
+_stk:        resd 1
+_stp:        resd 1
+_flags:      resd 1
+_usertags:   resd 4	; 4 = AMX_USERNUM (#define'd in amx.h)
+_userdata:   resd 4	; 4 = AMX_USERNUM (#define'd in amx.h)
+_error:      resd 1
+_paramcount: resd 1
+_pri:        resd 1
+_alt:        resd 1
+_reset_stk:  resd 1
+_reset_hea:  resd 1
+_syscall_d:  resd 1
+%ifdef JIT
+        ; the two fields below are for the JIT; they do not exist in
+        ; the non-JIT version of the abstract machine
+_reloc_size: resd 1          ; memory block for relocations
+_code_size:  resd 1          ; memory size of the native code
+%endif
+	endstruc
+
+	struc amxhead_s
+_size:       resd 1  ; size of the "file"
+_magic:      resw 1  ; signature
+_file_version: resb 1; file format version
+_amx_version: resb 1 ; required version of the AMX
+_h_flags:    resw 1
+_defsize:    resw 1  ; size of one public/native function entry
+_cod:        resd 1  ; initial value of COD - code block
+_dat:        resd 1  ; initial value of DAT - data block
+_h_hea:      resd 1  ; initial value of HEA - start of the heap
+_h_stp:      resd 1  ; initial value of STP - stack top
+_h_cip:      resd 1  ; initial value of CIP - the instruction pointer
+_publics:    resd 1  ; offset to the "public functions" table
+_natives:    resd 1  ; offset to the "native functions" table
+_libraries:  resd 1  ; offset to the "library" table
+_pubvars:    resd 1  ; offset to the "public variables" table
+_tags:       resd 1  ; offset to the "public tagnames" table
+_nametable:  resd 1  ; offset to the name table, file version 7 only
+	endstruc
+
+
+AMX_ERR_NONE        EQU 0
+AMX_ERR_EXIT        EQU 1
+AMX_ERR_ASSERT      EQU 2
+AMX_ERR_STACKERR    EQU 3
+AMX_ERR_BOUNDS      EQU 4
+AMX_ERR_MEMACCESS   EQU 5
+AMX_ERR_INVINSTR    EQU 6
+AMX_ERR_STACKLOW    EQU 7
+AMX_ERR_HEAPLOW     EQU 8
+AMX_ERR_CALLBACK    EQU 9
+AMX_ERR_NATIVE      EQU 10
+AMX_ERR_DIVIDE      EQU 11      ; for catching divide errors
+AMX_ERR_SLEEP       EQU 12
+
+AMX_ERR_MEMORY      EQU 16
+AMX_ERR_FORMAT      EQU 17
+AMX_ERR_VERSION     EQU 18
+AMX_ERR_NOTFOUND    EQU 19
+AMX_ERR_INDEX       EQU 20
+AMX_ERR_DEBUG       EQU 21
+AMX_ERR_INIT        EQU 22
+AMX_ERR_USERDATA    EQU 23
+AMX_ERR_INIT_JIT    EQU 24
+AMX_ERR_PARAMS      EQU 25
+AMX_ERR_DOMAIN      EQU 26
+AMX_ERR_GENERAL     EQU 27
+
+AMX_FLAG_DEBUG      EQU 0002h   ; symbolic info. available
+AMX_FLAG_COMPACT    EQU 0004h
+AMX_FLAG_BYTEOPC    EQU 0008h
+AMX_FLAG_NOCHECKS   EQU 0010h
+AMX_FLAG_BROWSE     EQU 4000h
+AMX_FLAG_RELOC      EQU 8000h   ; jump/call addresses relocated
+

amxmodx/amxexecn.asm

@@ -1,4 +1,4 @@
-;       AMXEXECN.ASM    Abstract Machine for the "Small" language
+;       AMXEXECN.ASM    Abstract Machine for the "Pawn" language
 ;
 
 ;Some notes:
@@ -25,7 +25,7 @@
 ;
 ;Copyright and license of use, please read
 ;-----------------------------------------
-;The assembler implementation of the abstract machine for the Small language,
+;The assembler implementation of the abstract machine for the Pawn language,
 ;specifically the file AMXEXEC.ASM, is copyright (c) 1998-2000 by Marc Peter.
 ;
 ;Permission is hereby granted, without written agreement and without paid
@@ -56,6 +56,10 @@
 ;
 ;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
 ;       Corrected a bug in OP_FILL, where a cell preceding the array would
 ;       be overwritten (zero'ed out). This bug was brought to my attention
@@ -95,92 +99,7 @@
   %endif
 %endmacro
 
-
-; I could not get NASM's structure definition to work (it appears to confuse
-; ENDSTRUC with "end segment"). So the definition below uses constants for
-; the field offsets.
-;amx_s   STRUC
-    _base       EQU 00h ;DD ?
-    _dataseg    EQU 04h ;DD ?
-    _callback   EQU 08h ;DD ?
-    _debug      EQU 0ch ;DD ?
-    _cip        EQU 10h ;DD ?
-    _frm        EQU 14h ;DD ?
-    _hea        EQU 18h ;DD ?
-    _hlw        EQU 1ch ;DD ?
-    _stk        EQU 20h ;DD ?
-    _stp        EQU 24h ;DD ?
-    _flags      EQU 28h ;DD ?
-    _curline    EQU 2ch ;DD ?
-    _curfile    EQU 30h ;DD ?
-    _dbgcode    EQU 34h ;DD ?
-    _dbgaddr    EQU 38h ;DD ?
-    _dbgparam   EQU 3ch ;DD ?
-    _dbgname    EQU 40h ;DD ?
-    _usertags1  EQU 44h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _usertags2  EQU 44h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _usertags3  EQU 44h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _usertags4  EQU 44h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _userdata1  EQU 54h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _userdata2  EQU 54h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _userdata3  EQU 54h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _userdata4  EQU 54h ;DD 4 DUP (?)    ; 4 = AMX_USERNUM (#define'd in amx.h)
-    _error      EQU 64h ;DD ?
-    _pri        EQU 68h ;DD ?
-    _alt        EQU 6ch ;DD ?
-    _reset_stk  EQU 70h ;DD ?
-    _reset_hea  EQU 74h ;DD ?
-    _syscall_d  EQU 78h ;DD ?
-    ; the two fields below are for the JIT; they do not exist in
-    ; the non-JIT version of the abstract machine
-;   _reloc_size EQU 7ch ;DD ?            ; memory block for relocations
-;   _code_size  EQU 80h ;DD ?            ; memory size of the native code
-;amx_s   ENDS
-
-
-        AMX_ERR_NONE        EQU 0
-        AMX_ERR_EXIT        EQU 1
-        AMX_ERR_ASSERT      EQU 2
-        AMX_ERR_STACKERR    EQU 3
-        AMX_ERR_BOUNDS      EQU 4
-        AMX_ERR_MEMACCESS   EQU 5
-        AMX_ERR_INVINSTR    EQU 6
-        AMX_ERR_STACKLOW    EQU 7
-        AMX_ERR_HEAPLOW     EQU 8
-        AMX_ERR_CALLBACK    EQU 9
-        AMX_ERR_NATIVE      EQU 10
-        AMX_ERR_DIVIDE      EQU 11      ; MP: added for catching divide errors
-        AMX_ERR_SLEEP       EQU 12      ; (TR)
-
-        AMX_ERR_MEMORY      EQU 16
-        AMX_ERR_FORMAT      EQU 17
-        AMX_ERR_VERSION     EQU 18
-        AMX_ERR_NOTFOUND    EQU 19
-        AMX_ERR_INDEX       EQU 20
-        AMX_ERR_DEBUG       EQU 21
-        AMX_ERR_INIT        EQU 22
-        AMX_ERR_USERDATA    EQU 23
-        AMX_ERR_INIT_JIT    EQU 24
-        AMX_ERR_PARAMS      EQU 25
-        AMX_ERR_DOMAIN      EQU 26
-
-        DBG_INIT            EQU 0
-        DBG_FILE            EQU 1
-        DBG_LINE            EQU 2
-        DBG_SYMBOL          EQU 3
-        DBG_CLRSYM          EQU 4
-        DBG_CALL            EQU 5
-        DBG_RETURN          EQU 6
-        DBG_TERMINATE       EQU 7
-        DBG_SRANGE          EQU 8       ; (TR)
-        DBG_SYMTAG          EQU 9       ; (TR)
-
-        AMX_FLAG_CHAR16     EQU 0001h   ; characters are 16-bit
-        AMX_FLAG_DEBUG      EQU 0002h   ; symbolic info. available
-		AMX_FLAG_LINEOPS	EQU	0020h	; line op information
-		AMX_FLAG_TRACED		EQU	0040h	; 
-        AMX_FLAG_BROWSE     EQU 4000h
-        AMX_FLAG_RELOC      EQU 8000h   ; jump/call addresses relocated
+%include "amxdefn.asm"
 
 ;#define PUSH(v)         ( stk-=sizeof(cell), *(cell *)(data+(int)stk)=v )
 %macro  _PUSH   1
@@ -212,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]
@@ -659,29 +600,6 @@ OP_POP_ALT:
 
 ;good
 OP_STACK:
-        mov     edx,ecx
-        add     ecx,[esi+4]
-        _CHKMARGIN
-        _CHKSTACK
-        mov     ebp,amx
-        test    DWORD [ebp+_flags],AMX_FLAG_DEBUG
-        jz      short op_stk_goon
-        ; update several structure fields and call the debug hook
-        mov     DWORD [ebp+_dbgcode],DBG_CLRSYM
-        mov     [ebp+_stk],ecx
-        push    eax
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax             ; pass parameter via the stack
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-    op_stk_goon:
-        add     esi,8
-        GO_ON
-
-OP_STACK_nodebug:
         mov     edx,ecx
         add     ecx,[esi+4]
         _CHKMARGIN
@@ -711,35 +629,6 @@ OP_PROC:
         GO_ON
 
 OP_RET:
-        _POP    ebx
-        _POP    esi
-        cmp     esi,code        ; verify ESI>=code
-        jb      err_memaccess
-        cmp     esi,codesiz     ; verify ESI<codesiz ("end-of-code" pointer)
-        jae     err_memaccess
-        mov     frm,ebx
-        add     ebx,edi
-        mov     ebp,amx
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_ret_goon
-        ; update several structure fields and call the debug hook
-        mov     DWORD [ebp+_dbgcode],DBG_RETURN
-        mov     [ebp+_dbgparam],eax
-        push    eax
-        mov     [ebp+_stk],ecx  ; store STK
-        mov     eax,hea
-        mov     [ebp+_hea],eax  ; store HEA
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-    op_ret_goon:
-        GO_ON
-
-OP_RET_nodebug:
         _POP    ebx
         _POP    esi
         cmp     esi,code        ; verify ESI>=code
@@ -760,107 +649,17 @@ OP_RETN:
         jae     err_memaccess
         mov     frm,ebx
         add     ebx,edi
-        mov     ebp,amx
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_retn_goon
-        ; update several structure fields and call the debug hook
-        mov     DWORD [ebp+_dbgcode],DBG_RETURN
-        mov     [ebp+_dbgparam],eax
-        push    eax
-        mov     [ebp+_stk],ecx  ; store STK
-        mov     eax,hea
-        mov     [ebp+_hea],eax  ; store HEA
-        mov     eax,ebp         ; parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        ; also send the DBG_CLRSYM code
-        mov     eax,[edi+ecx]
-        lea     ecx,[ecx+eax+4]
-        mov     DWORD [ebp+_dbgcode],DBG_CLRSYM
-        mov     [ebp+_stk],ecx
-        mov     eax,ebp         ; parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-        ; ECX already adjusted
-        GO_ON
-    op_retn_goon:
         mov     ebp,[edi+ecx]
         lea     ecx,[ecx+ebp+4]
         GO_ON
 
-OP_RETN_nodebug:
-        _POP    ebx
-        _POP    esi
-        cmp     esi,code        ; verify ESI>=code
-        jb      err_memaccess
-        cmp     esi,codesiz     ; verify ESI<codesiz ("end-of-code" pointer)
-        jae     err_memaccess
-        mov     frm,ebx
-        mov     ebp,[edi+ecx]
-        add     ebx,edi
-        lea     ecx,[ecx+ebp+4]
-        GO_ON
-
-;good
 OP_CALL:
-        lea     ebp,[esi+8]
-        mov     esi,[esi+4]
-        _PUSH   ebp
-        mov     ebp,amx
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_call_goon
-        ; update several structure fields and call the debug hook
-        push    eax
-        mov     eax,[esp+24]            ; this is "code", but ESP moved
-        mov     [ebp+_dbgaddr],esi
-        sub     [ebp+_dbgaddr],eax      ; dbgaddr = cip - code
-        mov     DWORD [ebp+_dbgcode],DBG_CALL
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-    op_call_goon:
-        GO_ON
-
-OP_CALL_nodebug:
         lea     ebp,[esi+8]
         mov     esi,[esi+4]
         _PUSH   ebp
         GO_ON
 
 OP_CALL_PRI:
-        lea     ebp,[esi+4]
-        mov     esi,eax
-        add     esi,code        ; cip = PRI + code
-        _PUSH   ebp
-        mov     ebp,amx
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_calli_goon
-        ; update several structure fields and call the debug hook
-        mov     [ebp+_dbgaddr],eax      ; dbgaddr = PRI (== cip - code)
-        mov     DWORD [ebp+_dbgcode],DBG_CALL
-        push    eax
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     eax
-    op_calli_goon:
-        GO_ON
-
-OP_CALL_PRI_nodebug:
         lea     ebp,[esi+4]
         mov     esi,eax
         add     esi,code        ; cip = PRI + code
@@ -941,13 +740,13 @@ OP_JSLESS:
 ;good
 OP_JSLEQ:
         cmp     eax,edx
-        jle     short jump_taken
+        jle     near jump_taken
         add     esi,8
         GO_ON
 
 OP_JSGRTR:
         cmp     eax,edx
-        jg      short jump_taken
+        jg      near jump_taken
         add     esi,8
         GO_ON
 
@@ -1350,12 +1149,11 @@ OP_CMPS:
         _VERIFYADDRESS  eax             ; PRI
         _VERIFYADDRESS  edx             ; ALT
         mov     ebp,eax
-        add     ebp,[esi+4]
-        dec     ebp
+        add     ebp,[esi+4]             ; size in bytes
+        dec     ebp                     ; EBP = PRI + size - 1
         _VERIFYADDRESS  ebp             ; PRI + size - 1
-        mov     ebp,edx
-        add     ebp,[esi+4]
-        dec     ebp
+        sub     ebp,eax                 ; EBP = size - 1
+        add     ebp,edx                 ; EBP = ALT + size - 1
         _VERIFYADDRESS  ebp             ; ALT + size - 1
 
         push    ecx
@@ -1422,21 +1220,7 @@ OP_HALT:
         mov     eax,esi         ; EAX=CIP
         sub     eax,code
         mov     [ebp+_cip],eax
-        ; optionally call the debug hook
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short halt_goon
-        mov     DWORD [ebp+_dbgcode],DBG_TERMINATE
-        mov     [ebp+_dbgaddr],eax
-        mov     [ebp+_dbgparam],ebx
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-    halt_goon:
-        mov     eax,ebx         ; return the parameter of the HALT opcode
-        jmp     _return
+        _ABORT	ebx
 
 
 OP_BOUNDS:
@@ -1460,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
@@ -1490,8 +1275,7 @@ OP_SYSREQ_PRI:
         pop     edi             ; restore saved registers
         pop     esi
         pop     ebp
-        cmp     eax,AMX_ERR_NONE
-        jne     near _return    ; return error code, if any
+        _CHKABORT eax			; if result was invalid, leave
 
         mov     eax,pri         ; get retval into eax (PRI)
         mov     edx,alt         ; restore ALT
@@ -1532,8 +1316,8 @@ OP_SYSREQ_D:                    ; (TR)
         pop     edi             ; restore saved registers
         pop     esi
         pop     ebp
-        cmp     DWORD [ebp+_error],AMX_ERR_NONE
-        jne     near _return    ; return error code, if any
+        mov		eax,[ebp+_error]
+        _CHKABORT eax
 
         ; function result is in eax (PRI)
         mov     edx,alt         ; restore ALT
@@ -1549,159 +1333,21 @@ OP_FILE:
 
 OP_LINE:
         add     esi,12
-        mov     ebp,amx
-        push    eax
-        push    edx
-        mov     eax,[esi-8]     ; get curline
-        mov     edx,[esi-4]     ; get curfile
-        mov     [ebp+_curline],eax
-        mov     [ebp+_curfile],edx
-        pop     edx
-        pop     eax
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short line_goon
-        ; update several structure fields
-        mov     [ebp+_pri],eax
-        mov     [ebp+_alt],edx  ; EAX and EDX are now free to use
-        mov     eax,frm
-        mov     edx,hea
-        mov     [ebp+_frm],eax  ; store values in AMX structure (STK, FRM & HEA)
-        mov     [ebp+_hea],edx
-        mov     [ebp+_stk],ecx
-        mov     eax,esi
-        sub     eax,code        ; EAX = CIP (relative to start of code segment)
-        mov     [ebp+_cip],eax
-        ; call the debugger hook
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        cmp     eax,AMX_ERR_NONE
-        je      short line_noabort  ; continue running
-        mov     [ebp+_dbgcode],eax  ; save EAX (error code) before restoring all regs
-        _RESTOREREGS            ; abort run, but restore stack first
-        mov     eax,[ebp+_dbgcode]  ; get error code in EAX back again
-        jmp     _return         ; return error code
-    line_noabort:
-        _RESTOREREGS
-        mov     eax,[ebp+_pri]  ; restore PRI and ALT
-        mov     edx,[ebp+_alt]
-    line_goon:
-        GO_ON
-
-
-OP_LINE_nodebug:
-        add     esi,12
-        mov     ebp,amx
-        push    eax
-        push    edx
-        mov     eax,[esi-8]     ; get curline
-        mov     edx,[esi-4]     ; get curfile
-        mov     [ebp+_curline],eax
-        mov     [ebp+_curfile],edx
-        pop     edx
-        pop     eax
         GO_ON
 
 
 OP_SYMBOL:
-        mov     ebp,amx
-        test    DWORD [ebp+_flags],AMX_FLAG_DEBUG
-        jz      short op_symbol_goon
-        push    eax
-        push    edx
-        mov     eax,[esi+8]     ; address
-        mov     edx,[esi+12]    ; flags
-        mov     [ebp+_dbgaddr],eax
-        mov     [ebp+_dbgparam],edx
-        mov     DWORD [ebp+_dbgcode],DBG_SYMBOL
-        mov     eax,esi
-        add     eax,16          ; start of symbol name
-        mov     [ebp+_dbgname],eax
-        mov     edx,[esp+8]     ; this is FRM, but offset by two PUSH'es
-        mov     [ebp+_frm],edx
-        mov     eax,ebp         ; parameter of the debugger hook
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debugger hook
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     edx
-        pop     eax
-    op_symbol_goon:
-        add     esi,[esi+4]
-        add     esi,8           ; skip "fixed" part
-        GO_ON
-
-
-OP_SYMBOL_nodebug:
         add     esi,[esi+4]
         add     esi,8           ; skip "fixed" part
         GO_ON
 
 
 OP_SRANGE:
-        mov     ebp,amx
-        add     esi,12
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_srange_goon
-        push    eax
-        push    edx
-        mov     eax,[esi-8]     ; get dimensions
-        mov     edx,[esi-4]     ; get size
-        mov     [ebp+_dbgaddr],eax
-        mov     [ebp+_dbgparam],edx
-        mov     DWORD [ebp+_dbgcode],DBG_SRANGE
-        mov     edx,frm
-        mov     [ebp+_frm],edx
-        mov     [ebp+_stk],ecx  ; store values in AMX structure (STK & FRM)
-        ; call the debugger hook
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     edx
-        pop     eax
-    op_srange_goon:
-        GO_ON
-
-
-OP_SRANGE_nodebug:
         add     esi,12
         GO_ON
 
 
 OP_SYMTAG:
-        mov     ebp,amx
-        add     esi,8
-        test    DWORD [ebp+_flags], AMX_FLAG_DEBUG
-        jz      short op_symtag_goon
-        mov     ebp,amx
-        push    eax
-        push    edx
-        mov     eax,[esi-4]     ; get tag
-        mov     edx,frm
-        mov     DWORD [ebp+_dbgcode],DBG_SRANGE
-        mov     [ebp+_dbgparam],eax
-        mov     [ebp+_frm],edx
-        mov     [ebp+_stk],ecx  ; store values in AMX structure (STK & FRM)
-        ; call the debugger hook
-        mov     eax,ebp         ; 1st parm: amx
-        _SAVEREGS
-        push    eax
-        call    [ebp+_debug]    ; call debug function
-        _DROPARGS 4             ; remove arguments from stack
-        _RESTOREREGS
-        pop     edx
-        pop     eax
-    op_symtag_goon:
-        GO_ON
-
-
-OP_SYMTAG_nodebug:              ; (TR)
         add     esi,8
         GO_ON
 
@@ -1759,47 +1405,167 @@ OP_PUSHADDR:
 
 
 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
+		push    0
+		fld     dword [edi+ecx+4]
+		frndint
+		fistp   dword [esp]
+		pop     eax
+		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
+        add     esi,4
+        cmp     DWORD [ebp+_debug], 0
+        jnz     break_calldebug
+        GO_ON                   ; debug hook not active, ignore
+
+    break_calldebug:
+        ; store the status in the AMX (FRM, STK, HEA, CIP, and PRI + ALT)
+        mov     [ebp+_pri],eax
+        mov     [ebp+_alt],edx  ; EAX and EDX are now free to use
+        mov     eax,frm
+        mov     edx,hea
+        mov     [ebp+_frm],eax  ; store values in AMX structure (STK, FRM & HEA)
+        mov     [ebp+_hea],edx
+        mov     [ebp+_stk],ecx
+        mov     eax,esi
+        sub     eax,code        ; EAX = CIP (relative to start of code segment)
+        mov     [ebp+_cip],eax
+        ; call the debug hook
+        mov     eax,ebp         ; 1st parm: amx
+        _SAVEREGS
+        push    eax
+        call    [ebp+_debug]    ; call debug function
+        _DROPARGS 4             ; remove arguments from stack
+        cmp     eax,AMX_ERR_NONE
+        je      short break_noabort; continue running
+        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
+        _FASTABORT
+    break_noabort:
+        _RESTOREREGS
+        mov     eax,[ebp+_pri]  ; restore PRI and ALT
+        mov     edx,[ebp+_alt]
         GO_ON
 
 
 OP_INVALID:
-        mov     eax,AMX_ERR_INVINSTR
-        jmp     _return
+        _ABORT	AMX_ERR_INVINSTR
 
 err_call:
-        mov     eax,AMX_ERR_CALLBACK
-        jmp     _return
+        _ABORT	AMX_ERR_CALLBACK
 
 err_stack:
-        mov     eax,AMX_ERR_STACKERR
-        jmp     _return
+        _ABORT	AMX_ERR_STACKERR
 
 err_stacklow:
-        mov     eax,AMX_ERR_STACKLOW
-        jmp     _return
+        _ABORT	AMX_ERR_STACKLOW
 
 err_memaccess:
-        mov     eax,AMX_ERR_MEMACCESS
-        jmp     _return
+        _ABORT	AMX_ERR_MEMACCESS
 
 err_bounds:
-        mov     eax,AMX_ERR_BOUNDS
-        jmp     _return
+        _ABORT	AMX_ERR_BOUNDS
 
 err_heaplow:
-        mov     eax,AMX_ERR_HEAPLOW
-        jmp     _return
+        _ABORT	AMX_ERR_HEAPLOW
 
 err_divide:
-        mov     eax,AMX_ERR_DIVIDE
-        jmp     _return
-
+        _ABORT	AMX_ERR_DIVIDE
 
 _return:
-        ; save a few paraneters, mostly for the "sleep"function
+        ; 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+_alt],edx  ; store values in AMX structure (PRI, ALT)
+        mov		[ebp+_cip],esi	; get corrected cip for amxmodx
+        mov		eax,[ebp+_error]; get error code
 
         pop     esi             ; remove FRM from stack
 
@@ -1827,6 +1593,12 @@ Start_DATA
 
 lodb_and DD     0ffh, 0ffffh, 0, 0ffffffffh
 
+		GLOBAL g_flags
+g_flags:
+		DD		-1
+		DD		0
+		DD		1
+
         GLOBAL  amx_opcodelist
         GLOBAL  _amx_opcodelist
 amx_opcodelist:
@@ -1967,144 +1739,11 @@ _amx_opcodelist DD OP_INVALID
         DD      OP_NOP
         DD      OP_SYSREQ_D
         DD      OP_SYMTAG
-
-        GLOBAL  amx_opcodelist_nodebug
-        GLOBAL  _amx_opcodelist_nodebug
-amx_opcodelist_nodebug:
-_amx_opcodelist_nodebug DD OP_INVALID
-        DD      OP_LOAD_PRI
-        DD      OP_LOAD_ALT
-        DD      OP_LOAD_S_PRI
-        DD      OP_LOAD_S_ALT
-        DD      OP_LREF_PRI
-        DD      OP_LREF_ALT
-        DD      OP_LREF_S_PRI
-        DD      OP_LREF_S_ALT
-        DD      OP_LOAD_I
-        DD      OP_LODB_I
-        DD      OP_CONST_PRI
-        DD      OP_CONST_ALT
-        DD      OP_ADDR_PRI
-        DD      OP_ADDR_ALT
-        DD      OP_STOR_PRI
-        DD      OP_STOR_ALT
-        DD      OP_STOR_S_PRI
-        DD      OP_STOR_S_ALT
-        DD      OP_SREF_PRI
-        DD      OP_SREF_ALT
-        DD      OP_SREF_S_PRI
-        DD      OP_SREF_S_ALT
-        DD      OP_STOR_I
-        DD      OP_STRB_I
-        DD      OP_LIDX
-        DD      OP_LIDX_B
-        DD      OP_IDXADDR
-        DD      OP_IDXADDR_B
-        DD      OP_ALIGN_PRI
-        DD      OP_ALIGN_ALT
-        DD      OP_LCTRL
-        DD      OP_SCTRL
-        DD      OP_MOVE_PRI
-        DD      OP_MOVE_ALT
-        DD      OP_XCHG
-        DD      OP_PUSH_PRI
-        DD      OP_PUSH_ALT
-        DD      OP_PUSH_R_PRI
-        DD      OP_PUSH_C
-        DD      OP_PUSH
-        DD      OP_PUSH_S
-        DD      OP_POP_PRI
-        DD      OP_POP_ALT
-        DD      OP_STACK_nodebug
-        DD      OP_HEAP
-        DD      OP_PROC
-        DD      OP_RET_nodebug
-        DD      OP_RETN_nodebug
-        DD      OP_CALL_nodebug
-        DD      OP_CALL_PRI_nodebug
-        DD      OP_JUMP
-        DD      OP_JREL
-        DD      OP_JZER
-        DD      OP_JNZ
-        DD      OP_JEQ
-        DD      OP_JNEQ
-        DD      OP_JLESS
-        DD      OP_JLEQ
-        DD      OP_JGRTR
-        DD      OP_JGEQ
-        DD      OP_JSLESS
-        DD      OP_JSLEQ
-        DD      OP_JSGRTR
-        DD      OP_JSGEQ
-        DD      OP_SHL
-        DD      OP_SHR
-        DD      OP_SSHR
-        DD      OP_SHL_C_PRI
-        DD      OP_SHL_C_ALT
-        DD      OP_SHR_C_PRI
-        DD      OP_SHR_C_ALT
-        DD      OP_SMUL
-        DD      OP_SDIV
-        DD      OP_SDIV_ALT
-        DD      OP_UMUL
-        DD      OP_UDIV
-        DD      OP_UDIV_ALT
-        DD      OP_ADD
-        DD      OP_SUB
-        DD      OP_SUB_ALT
-        DD      OP_AND
-        DD      OP_OR
-        DD      OP_XOR
-        DD      OP_NOT
-        DD      OP_NEG
-        DD      OP_INVERT
-        DD      OP_ADD_C
-        DD      OP_SMUL_C
-        DD      OP_ZERO_PRI
-        DD      OP_ZERO_ALT
-        DD      OP_ZERO
-        DD      OP_ZERO_S
-        DD      OP_SIGN_PRI
-        DD      OP_SIGN_ALT
-        DD      OP_EQ
-        DD      OP_NEQ
-        DD      OP_LESS
-        DD      OP_LEQ
-        DD      OP_GRTR
-        DD      OP_GEQ
-        DD      OP_SLESS
-        DD      OP_SLEQ
-        DD      OP_SGRTR
-        DD      OP_SGEQ
-        DD      OP_EQ_C_PRI
-        DD      OP_EQ_C_ALT
-        DD      OP_INC_PRI
-        DD      OP_INC_ALT
-        DD      OP_INC
-        DD      OP_INC_S
-        DD      OP_INC_I
-        DD      OP_DEC_PRI
-        DD      OP_DEC_ALT
-        DD      OP_DEC
-        DD      OP_DEC_S
-        DD      OP_DEC_I
-        DD      OP_MOVS
-        DD      OP_CMPS
-        DD      OP_FILL
-        DD      OP_HALT
-        DD      OP_BOUNDS
-        DD      OP_SYSREQ_PRI
-        DD      OP_SYSREQ_C
-        DD      OP_FILE
-        DD      OP_LINE_nodebug
-        DD      OP_SYMBOL_nodebug
-        DD      OP_SRANGE_nodebug
-        DD      OP_JUMP_PRI
-        DD      OP_SWITCH
-        DD      OP_CASETBL
-        DD      OP_SWAP_PRI
-        DD      OP_SWAP_ALT
-        DD      OP_PUSHADDR
-        DD      OP_NOP
-        DD      OP_SYSREQ_D
-        DD      OP_SYMTAG_nodebug
+        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/amxmodx.h

@@ -32,13 +32,18 @@
 #ifndef AMXMODX_H
 #define AMXMODX_H
 
-
+#ifdef __linux__
+#include <unistd.h>
+#include <stdlib.h>
+#include "sclinux.h"
+#endif
+#include <ctype.h>				//tolower, etc
 #include "string.h"
 #include <extdll.h>
 #include <meta_api.h>
 
 #ifdef MEMORY_TEST
-#include "mmgr/mmgr.h"
+	#include "mmgr/mmgr.h"
 #endif
 
 #include "md5.h"
@@ -62,32 +67,43 @@
 #include "amxxlog.h"
 
 #define AMXXLOG_Log g_log.Log
-#define AMX_VERSION     "0.2"
+#define AMX_VERSION	"1.71"
 
 extern AMX_NATIVE_INFO core_Natives[];
 extern AMX_NATIVE_INFO time_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 float_Natives[];
 extern AMX_NATIVE_INFO string_Natives[];
 extern AMX_NATIVE_INFO vault_Natives[];
 
-
 #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__
-typedef HINSTANCE DLHANDLE;
+#if defined __GNUC__
+	#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
+
+#ifndef __linux__
+	typedef HINSTANCE DLHANDLE;
+#else
+	typedef void* DLHANDLE;
+	#define INFINITE 0xFFFFFFFF
 #endif
 
 #ifndef GETPLAYERAUTHID
@@ -103,29 +119,33 @@ 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_IntToString(int value, char *output);
-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_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);
+
+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;
 	short int ammoSlot;
 };
 
-struct fakecmd_t {
+struct fakecmd_t
+{
 	char args[256];
 	const char *argv[3];
-  //char argv[3][128];
 	int argc;
 	bool fake;
 };
@@ -140,7 +160,8 @@ 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;
@@ -166,6 +187,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;
@@ -214,14 +236,16 @@ 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);
+int loadModules(const char* filename, PLUG_LOADTIME now);
 void detachModules();
 void detachReloadModules();
-void attachModules();
-void attachMetaModModules(PLUG_LOADTIME now, const char* filename);
+
+#ifdef FAKEMETA
+	void attachModules();
+#endif
 
 // Count modules
 enum CountModulesMode
@@ -234,28 +258,31 @@ enum CountModulesMode
 int countModules(CountModulesMode mode);
 void modules_callPluginsLoaded();
 
-int add_amxnatives(module_info_s* info,AMX_NATIVE_INFO*natives);
-cell* get_amxaddr(AMX *amx,cell amx_addr);
-char* build_pathname(char *fmt, ... );
-char* format_amxstring(AMX *amx, cell *params, int parm,int& len);
-AMX* get_amxscript(int, void**,const char**);
+cell* get_amxaddr(AMX *amx, cell amx_addr);
+char* build_pathname(char *fmt, ...);
+char* build_pathname_r(char *buffer, size_t maxlen, char *fmt, ...);
+char* format_amxstring(AMX *amx, cell *params, int parm, int& len);
+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_amxstring(AMX *amx,cell amx_addr,const char *source,int max);
-int unload_amxscript(AMX* amx,void** program);
-void copy_amxmemory(cell* dest,cell* src,int len);
+int set_amxnatives(AMX* amx, char error[64]);
+int set_amxstring(AMX *amx, cell amx_addr, const char *source, int max);
+int unload_amxscript(AMX* amx, void** program);
+
+void copy_amxmemory(cell* dest, cell* src, int len);
 void get_modname(char*);
-void print_srvconsole( char *fmt, ... );
-void report_error( int code, char* fmt, ... );
+void print_srvconsole(char *fmt, ...);
+void report_error(int code, 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
 {
@@ -268,7 +295,9 @@ enum ModuleCallReason
 extern ModuleCallReason g_ModuleCallReason;		// modules.cpp
 extern CModule *g_CurrentlyCalledModule;		// modules.cpp
 extern const char *g_LastRequestedFunc;			// modules.cpp
-extern CQueue<String> CurModuleList;
+
+void Module_CacheFunctions();
+void Module_UncacheFunctions();
 
 void *Module_ReqFnptr(const char *funcName);	// modules.cpp
 
@@ -286,7 +315,17 @@ extern int FF_PluginLog;
 extern int FF_PluginEnd;
 extern int FF_InconsistentFile;
 extern int FF_ClientAuthorized;
+extern int FF_ChangeLevel;
+extern bool g_coloredmenus;
+
+typedef void (*AUTHORIZEFUNC)(int player, const char *authstring);
+
+#define MM_CVAR2_VERS	13
+
+struct func_s
+{
+	void *pfn;
+	const char *desc;
+};
 
-extern CFakeMeta g_FakeMeta;
 #endif // AMXMODX_H
-

amxmodx/amxtime.cpp

@@ -18,6 +18,8 @@
 #	endif
 #endif
 
+#include <stdlib.h>
+
 // this file does not include amxmodx.h, so we have to include the memory manager here
 #ifdef MEMORY_TEST
 #include "mmgr/mmgr.h"

amxmodx/amxxfile.cpp

@@ -3,7 +3,6 @@
 * 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
@@ -36,6 +35,7 @@
 /**********************
  ****** AMXXFILE ******
  **********************/
+
 #if defined __GNUC__
 	#define PACKED		__attribute__((packed))
 #else
@@ -51,10 +51,6 @@
 	#endif
 #endif
 
-typedef char	mint8_t;
-typedef int16_t		mint16_t;
-typedef int32_t		mint32_t;
-
 struct TableEntry
 {
 	mint8_t cellSize PACKED;
@@ -76,6 +72,9 @@ struct TableEntry
 
 CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 {
+	m_Bh.plugins = NULL;
+	m_AmxxFile = false;
+	
 	if (!filename)
 	{
 		m_Status = Err_InvalidParam;
@@ -84,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;
@@ -96,42 +95,71 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 	DATAREAD(&magic, sizeof(magic), 1);
 
 	m_OldFile = false;
-	if (magic != 0x414D5842)
-	{
-		// check for old file
-		AMX_HEADER hdr;
-		rewind(m_pFile);
-		fread(&hdr, sizeof(hdr), 1, m_pFile);
-		amx_Align16(&hdr.magic);
-		if (hdr.magic == AMX_MAGIC)
-		{
-			if (cellsize != 4)
-			{
-				m_Status = Err_SectionNotFound;
-				fclose(m_pFile);
-				m_pFile = NULL;
-				return;
-			}
 	
-			m_OldFile = true;
-			return;
-		}
-		else
+	if (magic == 0x524C4542)
 	{
-			// no known file format
-			m_Status = Err_FileInvalid;
-			fclose(m_pFile);
-			m_pFile = NULL;
-			return;
-		}
-	} else if ( magic == 0x524C4542 ) {
 		//we have an invalid, old, RLEB file
 		m_Status = Err_OldFile;
 		fclose(m_pFile);
 		m_pFile = NULL;
-		return;
-	} else {
 		
+		return;
+	}
+	else if (magic == MAGIC_HEADER2)
+	{
+		DATAREAD(&m_Bh.version, sizeof(int16_t), 1);
+		
+		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++)
+		{
+			pe = &(m_Bh.plugins[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++)
+		{
+			pe = &(m_Bh.plugins[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)
+	{
 		// try to find the section
 		mint8_t numOfPlugins;
 		DATAREAD(&numOfPlugins, sizeof(numOfPlugins), 1);
@@ -140,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);
@@ -149,6 +178,7 @@ CAmxxReader::CAmxxReader(const char *filename, int cellsize)
 				break;
 			}
 		}
+		
 		if (!m_SectionHdrOffset)
 		{
 			m_Status = Err_SectionNotFound;
@@ -158,18 +188,45 @@ 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;
 		}
+	} else {
+		// check for old file
+		AMX_HEADER hdr;
+		rewind(m_pFile);
+		fread(&hdr, sizeof(hdr), 1, m_pFile);
+		amx_Align16(&hdr.magic);
+		
+		if (hdr.magic == AMX_MAGIC)
+		{
+			if (cellsize != 4)
+			{
+				m_Status = Err_SectionNotFound;
+				fclose(m_pFile);
+				m_pFile = NULL;
+				
+				return;
+			}
+
+			m_OldFile = true;
+			
+			return;
+		} else {
+			// no known file format
+			m_Status = Err_FileInvalid;
+			fclose(m_pFile);
+			m_pFile = NULL;
+			
+			return;
+		}
 	} 
 }
 
@@ -180,6 +237,12 @@ CAmxxReader::~CAmxxReader()
 		fclose(m_pFile);
 		m_pFile = NULL;
 	}
+	
+	if (m_Bh.plugins)
+	{
+		delete [] m_Bh.plugins;
+		m_Bh.plugins = NULL;
+	}
 }
 
 CAmxxReader::Error CAmxxReader::GetStatus()
@@ -205,7 +268,6 @@ size_t CAmxxReader::GetBufferSize()
 	if (!m_pFile)
 		return 0;
 
-
 	long save = ftell(m_pFile);
 
 	if (m_OldFile)
@@ -214,14 +276,25 @@ 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)
+	{
+		PluginEntry *pe = &(m_Bh.plugins[m_Entry]);
+		
+		if (pe->imagesize > pe->memsize)
+			return pe->imagesize + 1;
+		
+		return pe->memsize + 1;
+	}
 
 	fseek(m_pFile, m_SectionHdrOffset, SEEK_SET);
 
 	TableEntry entry;
 	DATAREAD(&entry, sizeof(entry), 1);
 	fseek(m_pFile, save, SEEK_SET);
+	
 	return entry.origSize + 1;			// +1 : safe
 }
 
@@ -251,31 +324,51 @@ CAmxxReader::Error CAmxxReader::GetSection(void *buffer)
 		rewind(m_pFile);
 		DATAREAD(buffer, 1, filesize);
 		m_Status = Err_None;
+		
 		return m_Status;
 	}
+	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, (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
 		fseek(m_pFile, m_SectionHdrOffset, SEEK_SET);
 		// go to the offset
 		TableEntry entry;
 		DATAREAD(&entry, sizeof(entry), 1);
 		fseek(m_pFile, entry.offset, SEEK_SET);
-//	AMXXLOG_Log("|||| Offset needed: %d At: %d", entry.offset, ftell(m_pFile));
 		uLongf destLen = GetBufferSize();
 		// read the data to a temporary buffer
 		char *tempBuffer = new char[m_SectionLength + 1];
 		//fread(tempBuffer, sizeof(char), m_SectionLength, m_pFile);
 		DATAREAD((void*)tempBuffer, 1, m_SectionLength);
 		// decompress
-//	AMXXLOG_Log("|||| First Bytes: %d %d %d %d", tempBuffer[0], tempBuffer[1], tempBuffer[2], tempBuffer[3]);
-	int result = uncompress((Bytef *)buffer, &destLen,
-			(Bytef *)tempBuffer, m_SectionLength);
+		int result = uncompress((Bytef *)buffer, &destLen, (Bytef *)tempBuffer, m_SectionLength);
 		delete [] tempBuffer;
-//	AMXXLOG_Log("|||| Result: %d, m_SectionLength=%d, destLen=%d", result, m_SectionLength, destLen);
+		
 		if (result != Z_OK)
 		{
+			AMXXLOG_Log("[AMXX] Zlib error encountered: %d(%d)", result, m_SectionLength);
 			m_Status = Err_Decompress;
+			
 			return Err_Decompress;
 		}
+		
 		return Err_None;
+	}
 }

amxmodx/amxxfile.h

@@ -32,6 +32,31 @@
 #ifndef __AMXXFILE_H__
 #define __AMXXFILE_H__
 
+#define MAGIC_HEADER		0x414D5842
+#define MAGIC_HEADER2		0x414D5858
+#define	MAGIC_VERSION		0x0300
+
+typedef char		mint8_t;
+typedef int16_t		mint16_t;
+typedef int32_t		mint32_t;
+
+struct PluginEntry
+{
+	mint8_t cellsize;	//cell size
+	int32_t imagesize;	//uncompressed image size
+	int32_t disksize;	//compressed image size
+	int32_t memsize;	//memory image size
+	int32_t offs;		//file offset
+};
+
+struct BinHeader
+{
+	int32_t		magic;
+	mint16_t	version;
+	mint8_t		numPlugins;
+	PluginEntry *plugins;
+};
+
 class CAmxxReader
 {
 public:
@@ -53,6 +78,9 @@ private:
 	FILE *m_pFile;
 
 	bool m_OldFile;					// old .amx file
+	bool m_AmxxFile;				// new 'AMXX' header format
+	BinHeader m_Bh;					// binary header
+	int m_Entry;					// entry #
 
 	int m_CellSize;
 	int m_SectionHdrOffset;			// offset to the table in the header that describes the required section
@@ -66,6 +94,4 @@ public:
 	Error GetSection(void *buffer);			// Copy the currently selected section to the buffer
 };
 
-
 #endif // __AMXXFILE_H__
-

amxmodx/amxxlog.cpp

@@ -36,12 +36,12 @@
 
 #include <time.h>
 #ifndef __linux__
-#include <io.h>
+	#include <io.h>
 #endif
 #include "amxmodx.h"
 
 #ifndef __linux__
-#define	vsnprintf	_vsnprintf
+	#define	vsnprintf	_vsnprintf
 #endif
 
 CLog::CLog()
@@ -61,6 +61,7 @@ void CLog::CloseFile()
 	if (!m_LogFile.empty())
 	{
 		FILE *fp = fopen(m_LogFile.c_str(), "r");
+		
 		if (fp)
 		{
 			fclose(fp);
@@ -77,6 +78,7 @@ void CLog::CloseFile()
 			fprintf(fp, "L %s: %s\n", date, "Log file closed.");
 			fclose(fp);
 		}
+		
 		m_LogFile.clear();
 	}
 }
@@ -84,30 +86,36 @@ void CLog::CloseFile()
 void CLog::CreateNewFile()
 {
 	CloseFile();
+	
 	// build filename
 	time_t td;
 	time(&td);
 	tm *curTime = localtime(&td);
 
+	char file[256];
 	int i = 0;
+	
 	while (true)
 	{
-		m_LogFile.assign(build_pathname("%s/L%02d%02d%03d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday, i));
-		FILE *pTmpFile = fopen(m_LogFile.c_str(), "r");		// open for reading to check whether the file exists
+		build_pathname_r(file, sizeof(file)-1, "%s/L%02d%02d%03d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday, i);
+		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/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);
 	}
@@ -115,19 +123,22 @@ void CLog::CreateNewFile()
 
 void CLog::UseFile(const String &fileName)
 {
-	m_LogFile.assign(build_pathname("%s/%s", g_log_dir.c_str(), fileName.c_str()));
+	static char file[256];
+	m_LogFile.assign(build_pathname_r(file, sizeof(file)-1, "%s/%s", g_log_dir.c_str(), fileName.c_str()));
 }
 
 void CLog::MapChange()
 {
 	// create dir if not existing
+	char file[256];
 #ifdef __linux
-	mkdir(build_pathname("%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("%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");
@@ -142,7 +153,7 @@ void CLog::MapChange()
 	}
 	else if (m_LogType == 1)
 	{
-		Log("-------- Mapchange --------");
+		Log("-------- Mapchange to %s --------", STRING(gpGlobals->mapname));
 	}
 	else
 		return;
@@ -150,6 +161,8 @@ void CLog::MapChange()
 
 void CLog::Log(const char *fmt, ...)
 {
+	static char file[256];
+	
 	if (m_LogType == 1 || m_LogType == 2)
 	{
 		// get time
@@ -161,14 +174,14 @@ void CLog::Log(const char *fmt, ...)
 		strftime(date, 31, "%m/%d/%Y - %H:%M:%S", curTime);
 
 		// msg
-		char msg[3072];
+		static char msg[3072];
 
 		va_list arglst;
 		va_start(arglst, fmt);
 		vsnprintf(msg, 3071, fmt, arglst);
 		va_end(arglst);
 
-		FILE *pF;
+		FILE *pF = NULL;
 		if (m_LogType == 2)
 		{
 			pF = fopen(m_LogFile.c_str(), "a+");
@@ -176,6 +189,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());
@@ -183,19 +197,17 @@ void CLog::Log(const char *fmt, ...)
 					return;
 				}
 			}
+		} else {
+			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+");
 		}
-		else
-		{
-			pF = fopen(build_pathname("%s/L%02d%02d.log", g_log_dir.c_str(), curTime->tm_mon + 1, curTime->tm_mday), "a+");
-		}
+		
 		if (pF)
 		{
 			fprintf(pF, "L %s: %s\n", date, msg);
 			fclose(pF);
-		}
-		else
-		{
-			ALERT(at_logged, "[AMXX] Unexpected fatal logging error (couldn't open %s for a+). AMXX Logging disabled for this map.\n", m_LogFile.c_str());
+		} 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;
 		}
@@ -206,12 +218,11 @@ void CLog::Log(const char *fmt, ...)
 	else if (m_LogType == 3)
 	{
 		// build message
-		// :TODO: Overflow possible here
-		char msg[3072];
+		static char msg_[3072];
 		va_list arglst;
 		va_start(arglst, fmt);
-		vsnprintf(msg, 3071, fmt, arglst);
+		vsnprintf(msg_, 3071, fmt, arglst);
 		va_end(arglst);
-		ALERT(at_logged, "%s\n", msg);
+		ALERT(at_logged, "%s\n", msg_);
 	}
 }

amxmodx/amxxlog.h

@@ -42,6 +42,7 @@ private:
 public:
 	CLog();
 	~CLog();
+	
 	void CreateNewFile();
 	void CloseFile();
 	void MapChange();
@@ -49,4 +50,3 @@ public:
 };
 
 #endif // __AMXXLOG_H__
-

amxmodx/binlog.cpp

@@ -0,0 +1,260 @@
+#include <time.h>
+#include "amxmodx.h"
+#include "binlog.h"
+
+#if defined BINLOG_ENABLED
+
+BinLog g_BinLog;
+int g_binlog_level = 0;
+int g_binlog_maxsize = 0;
+
+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__
+			, 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);
+
+	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 native = va_arg(ap, int);
+			int params = va_arg(ap, int);
+			fwrite(&native, sizeof(int), 1, fp);
+			fwrite(&params, 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 num = va_arg(ap, int);
+			fwrite(&num, sizeof(int), 1, fp);
+			break;
+		}
+	case BinLog_SetLine:
+		{
+			int line = va_arg(ap, int);
+			fwrite(&line, 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);
+		len = (char)strlen(pl->getName());
+		fwrite(&len, sizeof(char), 1, fp);
+		len++;
+		fwrite(pl->getName(), sizeof(char), len, fp);
+		int natives, publics;
+		AMX *amx = pl->getAMX();
+		amx_NumNatives(amx, &natives);
+		amx_NumPublics(amx, &publics);
+		fwrite(&natives, sizeof(int), 1, fp);
+		fwrite(&publics, sizeof(int), 1, fp);
+		char name[34];
+		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);
+		}
+	}
+}
+
+#endif //BINLOG_ENABLED

amxmodx/binlog.h

@@ -0,0 +1,77 @@
+#ifndef _INCLUDE_BINLOG_H
+#define _INCLUDE_BINLOG_H
+
+#if defined BINLOG_ENABLED
+
+#include "CString.h"
+
+#define BINLOG_MAGIC	0x414D424C
+#define BINLOG_VERSION	0x0200
+
+/**
+ * Format of binlog:
+ * uint32		magic
+ * uint16		version
+ * uint8		sizeof(time_t)
+ * uint32		num plugins
+ * [
+ *  uint8		status codes
+ *  str[int8]	filename
+ *  uint32		num natives
+ *  uint32		num publics
+ *  [
+ *   str[uint8] native name
+ *  ]
+ *  [
+ *   str[uint8] public name
+ *  ]
+ * ]
+ * [
+ *  uint8		operation code
+ *  time_t		realtime
+ *  float		gametime
+ *  int32		plugin id
+ *  <extra info>
+ * ]
+ */
+
+enum BinLogOp
+{
+	BinLog_Start=1,
+	BinLog_End,
+	BinLog_NativeCall,	//<int32 native id> <int32_t num_params>
+	BinLog_NativeError, //<int32 errornum> <str[int16] string>
+	BinLog_NativeRet,	//<cell value>
+	BinLog_CallPubFunc,	//<int32 public id>
+	BinLog_SetLine,		//<int32 line no#>
+	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/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), used(false), next(NULL), prev(NULL) {};
+			
+			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);
+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 > 0); }
+	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

@@ -58,9 +58,14 @@ WeaponsVault g_weaponsData[MAX_WEAPONS];
 void Client_VGUIMenu(void* mValue)
 {
 	if (!mPlayer) return;
-  switch (mState++){
+
+	mPlayer->vgui = true;
+
+	switch (mState++)
+	{
 		case 0:
 			mPlayer->menu = -(*(int*)mValue);
+			mPlayer->newmenu = -1;
 			break;
 		case 1:
 			mPlayer->keys = *(int*)mValue;
@@ -70,12 +75,20 @@ void Client_VGUIMenu(void* mValue)
 void Client_ShowMenu(void* mValue)
 {
 	if (!mPlayer) return;
-  switch (mState++){
+
+	mPlayer->vgui = true;
+
+	switch (mState++)
+	{
 		case 0:
 			mPlayer->keys = *(int*)mValue;
 			break;
 		case 3:
-    mPlayer->menu = g_menucmds.findMenuId( (char*)mValue );
+			{
+			mPlayer->menu = g_menucmds.findMenuId((char*)mValue);
+			mPlayer->newmenu = -1;
+			break;
+			}
 	}
 }
 
@@ -83,59 +96,74 @@ void Client_TeamInfo(void* mValue)
 {
 	if (mPlayer) return;
 	static int index;
-  switch (mState++) {
+
+	switch (mState++)
+	{
 		case 0:
 			index = *(int*)mValue;
 			break;
 		case 1:
-	if ( index < 1 || index > gpGlobals->maxClients ) break;
+			if (index < 1 || index > gpGlobals->maxClients) break;
 			char* msg = (char*)mValue;
-    g_players[ index ].team.assign( msg );
-	g_teamsIds.registerTeam( msg , -1 );
+			g_players[index].team.assign(msg);
+			g_teamsIds.registerTeam(msg, -1);
 	}
 }
 
 void Client_TextMsg(void* mValue)
 {
-	if ( mPlayer ) return;
-	switch (mState++) {
-	case 1:{
+	if (mPlayer) return;
+	
+	switch (mState++)
+	{
+		case 1:
+		{
 			char * msg = (char*)mValue;
 			if (!msg) break;
-		if ( !strncmp("#Game_C", msg , 7) ) {
+			
+			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;
+				//g_endround_time = gpGlobals->time;
+				//g_newround_time = gpGlobals->time + CVAR_GET_FLOAT("mp_freezetime") + 3;
 			}
-		else if (!strncmp("#Game_w", msg , 7) ) {
+			else if (!strncmp("#Game_w", msg, 7))
+			{
 				g_game_timeleft = -2;
 			}
-		else if ( !strncmp("#game_clan_s", msg , 12)  ){
+			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;
-		   }
-	}
 			
+			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)
@@ -144,7 +172,9 @@ void Client_WeaponList(void* mValue)
 	//static int wpnList2;
 	static int iSlot;
 	static const char* wpnName;
-  switch (mState++) {
+	
+	switch (mState++)
+	{
 		case 0:
 			wpnName = (char*)mValue;
 			break;
@@ -153,24 +183,12 @@ void Client_WeaponList(void* mValue)
 			break;
 		case 7:
 			int iId = *(int*)mValue;
-	/*int* blocker;
-
-	int iwpn = iId;
-	
-	if (iId > 31) {
-		iwpn -= 31;
-		blocker = &wpnList2;
-	}
-	else
-		blocker = &wpnList;*/
-
-    if ( (iId < 0 || iId >= MAX_WEAPONS ) || (wpnList & (1<<iId)) )
+			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);
-
 	}
 }
 
@@ -178,7 +196,9 @@ void Client_CurWeapon(void* mValue)
 {
 	static int iState;
 	static int iId;
-  switch (mState++){
+	
+	switch (mState++)
+	{
 		case 0:
 			iState = *(int*)mValue;
 			break;
@@ -188,7 +208,7 @@ void Client_CurWeapon(void* mValue)
 			break;
 		case 2:
 			if (!mPlayer) return;
-    if (!iState || (iId < 1 || iId >= MAX_WEAPONS ) ) break;
+			if (!iState || (iId < 1 || iId >= MAX_WEAPONS)) break;
 			mPlayer->weapons[iId].clip = *(int*)mValue;
 			mPlayer->current = iId;
 			mPlayer->lastHit = mPlayer->lastTrace;
@@ -197,15 +217,16 @@ void Client_CurWeapon(void* mValue)
 
 void Client_AmmoX(void* mValue)
 {
-
 	static int iAmmo;
-  switch (mState++){
+	
+	switch (mState++)
+	{
 		case 0:
 			iAmmo = *(int*)mValue;
 			break;
 		case 1:
 			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)
 					mPlayer->weapons[i].ammo = *(int*)mValue;
 	}
@@ -214,13 +235,15 @@ void Client_AmmoX(void* mValue)
 void Client_AmmoPickup(void* mValue)
 {
 	static int iSlot;
-  switch (mState++){
+	
+	switch (mState++)
+	{
 		case 0:
 			iSlot = *(int*)mValue;
 			break;
 		case 1:
 			if (!mPlayer) return;
-    for(int i=1;i<MAX_WEAPONS;++i)
+			for (int i = 1; i < MAX_WEAPONS; ++i)
 				if (g_weaponsData[i].ammoSlot==iSlot)
 					mPlayer->weapons[i].ammo += *(int*)mValue;
 	}
@@ -230,7 +253,9 @@ void Client_ScoreInfo(void* mValue)
 {
 	static int index;
 	static int deaths;
-  switch (mState++){
+
+	switch (mState++)
+	{
 		case 0:
 			index = *(int*)mValue;
 			break;
@@ -238,12 +263,12 @@ void Client_ScoreInfo(void* mValue)
 			deaths = *(int*)mValue;
 			break;
 		case 4:
-	if ( index < 1 || index > gpGlobals->maxClients ) break;
-    CPlayer*pPlayer = GET_PLAYER_POINTER_I( index );
+			if (index < 1 || index > gpGlobals->maxClients) break;
+			CPlayer*pPlayer = GET_PLAYER_POINTER_I(index);
 			pPlayer->deaths = deaths;
 			pPlayer->teamId = *(int*)mValue;
-    if ( g_teamsIds.isNewTeam() )
-      g_teamsIds.registerTeam( pPlayer->team.c_str() , pPlayer->teamId );
+			if (g_teamsIds.isNewTeam())
+				g_teamsIds.registerTeam(pPlayer->team.c_str(), pPlayer->teamId);
 	}
 }
 
@@ -251,14 +276,14 @@ 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.parseValue( dead->death_killer  );
-		g_events.parseValue( dead->index  );
-		g_events.parseValue( dead->death_headshot  );
-		g_events.parseValue( dead->death_weapon.c_str()  );
-		g_events.parseValue( dead->death_tk ? 1 : 0  );
+		g_events.parserInit(CS_DEATHMSG, &gpGlobals->time, mPlayer = 0, mPlayerIndex = 0);
+		g_events.parseValue(dead->death_killer);
+		g_events.parseValue(dead->index);
+		g_events.parseValue(dead->death_headshot);
+		g_events.parseValue(dead->death_weapon.c_str());
+		g_events.parseValue(dead->death_tk ? 1 : 0);
 		g_events.executeEvents();
 		dead->death_killer = 0;
 	}
@@ -272,24 +297,21 @@ void Client_DeathMsg(void* mValue)
 	static int victim_id;
 	static int hs;
 	
-	switch (mState++){
+	switch (mState++)
+	{
 		case 0:
 			killer_id = *(int*)mValue;
-		killer = (killer_id > 0 && killer_id < 33) ? 
-			GET_PLAYER_POINTER_I(killer_id) : 0;
+			killer = (killer_id > 0 && killer_id < 33) ? GET_PLAYER_POINTER_I(killer_id) : 0;
 			break;
 		case 1:
 			victim_id = *(int*)mValue;
-		victim = (victim_id > 0 && victim_id < 33) ? 
-			GET_PLAYER_POINTER_I(victim_id) : 0;
+			victim = (victim_id > 0 && victim_id < 33) ? GET_PLAYER_POINTER_I(victim_id) : 0;
 			break;
 		case 2:	
 			hs = *(int*)mValue;
 			break;
 		case 3:
-		
-		if (  !killer || !victim ) break;
-
+			if (!killer || !victim) break;
 			victim->death_killer = killer_id;
 			victim->death_weapon.assign((char*)mValue);
 			victim->death_headshot = hs;

amxmodx/fakemeta.h

@@ -31,199 +31,7 @@
 #ifndef __FAKEMETA_H__
 #define __FAKEMETA_H__
 
-// Fake metamod api for modules
-
-#include "CList.h"
-
-// from mplugin.h (metamod)
-// Flags to indicate current "load" state of plugin.
-// NOTE: order is important, as greater/less comparisons are made.
-typedef enum {
-	PL_EMPTY = 0,		// empty slot
-	PL_VALID,			// has valid info in it
-	PL_BADFILE,			// nonexistent file (open failed), 
-						//    or not a valid plugin file (query failed)
-	PL_OPENED,			// dlopened and queried
-	PL_FAILED,			// opened, but failed to attach or unattach
-	PL_RUNNING,			// attached and running
-	PL_PAUSED,			// attached but paused
-} PLUG_STATUS;
-
-// from h_export.h (metamod)
-// Our GiveFnptrsToDll, called by engine.
-typedef void (WINAPI *GIVE_ENGINE_FUNCTIONS_FN) (enginefuncs_t 
-		*pengfuncsFromEngine, globalvars_t *pGlobals);
-
-
-// *** CFakeMeta
-class CFakeMeta
-{
-private:
-	// Core tables
-	/* DLL_FUNCTIONS m_CoreDllFuncTable;
-	enginefuncs_t m_CoreEngineFuncTable;
-	NEW_DLL_FUNCTIONS m_CoreNewDllFuncTable;
-
-	DLL_FUNCTIONS m_CoreDllFuncTable_Post;
-	enginefuncs_t m_CoreEngineFuncTable_Post;
-	NEW_DLL_FUNCTIONS m_CoreNewDllFuncTable_Post; */
-
-	bool AddCorePlugin();	// Adds the core plugin if needed
-public:
-	class CFakeMetaPlugin
-	{
-	private:
-		// plugin info
-		String m_Path;
-		PLUG_STATUS m_Status;
-		plugin_info_t *m_Info;
-		// Function tables
-		META_FUNCTIONS m_MetaFuncTable;
-
-		DLL_FUNCTIONS m_DllFuncTable;
-		enginefuncs_t m_EngineFuncTable;
-		NEW_DLL_FUNCTIONS m_NewDllFuncTable;
-
-		DLL_FUNCTIONS m_DllFuncTable_Post;
-		enginefuncs_t m_EngineFuncTable_Post;
-		NEW_DLL_FUNCTIONS m_NewDllFuncTable_Post;
-
-		// OS dep handle
-		DLHANDLE m_Handle;
-	public:
-		inline PLUG_STATUS GetStatus() const
-		{ return m_Status; }
-		inline void SetStatus(PLUG_STATUS newStatus)
-		{ m_Status = newStatus; }
-
-
-		inline plugin_info_t * GetInfo()
-		{ return m_Info; }
-		inline const plugin_info_t * GetInfo() const
-		{ return m_Info; }
-		inline void SetInfo(plugin_info_t *newInfo)
-		{ m_Info = newInfo; }
-
-		inline const char * GetPath() 
-		{ return m_Path.c_str(); }
-
-		inline const META_FUNCTIONS &GetMetaFunctions() const
-		{ return m_MetaFuncTable; }
-
-		// Get
-		inline DLL_FUNCTIONS &GetDllFuncTable()
-		{ return m_DllFuncTable; }
-		inline enginefuncs_t &GetEngineFuncTable()
-		{ return m_EngineFuncTable; }
-		inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable()
-		{ return m_NewDllFuncTable; }
-		
-		// Get const
-		inline const DLL_FUNCTIONS &GetDllFuncTable() const
-		{ return m_DllFuncTable; }
-		inline const enginefuncs_t &GetEngineFuncTable() const
-		{ return m_EngineFuncTable; }
-		inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable() const
-		{ return m_NewDllFuncTable; }
-
-		// Get post
-		inline DLL_FUNCTIONS &GetDllFuncTable_Post()
-		{ return m_DllFuncTable_Post; }
-		inline enginefuncs_t &GetEngineFuncTable_Post()
-		{ return m_EngineFuncTable_Post; }
-		inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post()
-		{ return m_NewDllFuncTable_Post; }
-
-		// Get post const
-		inline const DLL_FUNCTIONS &GetDllFuncTable_Post() const
-		{ return m_DllFuncTable_Post; }
-		inline const enginefuncs_t &GetEngineFuncTable_Post() const
-		{ return m_EngineFuncTable_Post; }
-		inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post() const
-		{ return m_NewDllFuncTable_Post; }
-
-		int Query(mutil_funcs_t *pMetaUtilFuncs);	// Also calls GiveFnPtrsToDll
-		int Attach(PLUG_LOADTIME now, meta_globals_t *pMGlobals, gamedll_funcs_t *pGameDllFuncs);
-		int Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
-
-		int GetEntityAPI2(int interfaceVersion);
-		int GetEntityAPI2_Post(int interfaceVersion);
-		int GetEngineFunctions(int interfaceVersion);
-		int GetEngineFunctions_Post(int interfaceVersion);
-		int GetNewDLLFunctions(int interfaceVersion);
-		int GetNewDLLFunctions_Post(int interfaceVersion);
-
-		CFakeMetaPlugin(const char *path);
-		~CFakeMetaPlugin();
-	};	// CFakeMetaPlugin
-
-	CFakeMeta();
-	~CFakeMeta();
-
-	bool AddPlugin(const char *path /*path relative to moddir*/);
-	void ReleasePlugins();
-
-	// This is public because i don't want to declare all the functions as friends :)
-	// :NOTE: The core is now a special, first plugin!
-	CList<CFakeMetaPlugin> m_Plugins;
-
-	// ****** Meta functions ******
-	// Query all added plugins
-	void Meta_Query(mutil_funcs_t *pMetaUtilFuncs);
-	// Attach all added plugins
-	void Meta_Attach(PLUG_LOADTIME now, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs);
-	// Detach all added plugins
-	void Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason);
-	// :NOTE: Meta_Init currently not supported
-	int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable /*from metamod*/, int *interfaceVersion /*from metamod*/,
-		DLL_FUNCTIONS *pAMXXFunctionTable /*Functions amxx needs*/);
-	int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable /*from metamod*/, int *interfaceVersion /*from metamod*/,
-		DLL_FUNCTIONS *pAMXXFunctionTable /*Functions amxx needs*/);
-	int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion,
-		enginefuncs_t *pAMXXFunctionTable /*Fucntions amxx needs*/);
-	int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion,
-		enginefuncs_t *pAMXXFunctionTable /*Fucntions amxx needs*/);
-	int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion,
-		NEW_DLL_FUNCTIONS *pAMXXFunctionTable);
-	int GetNewDLLFunctions_Post(NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion,
-		NEW_DLL_FUNCTIONS *pAMXXFunctionTable);
-
-	// Get
-	/*inline DLL_FUNCTIONS &GetDllFuncTable()
-	{ return m_CoreDllFuncTable; }
-	inline enginefuncs_t &GetEngineFuncTable()
-	{ return m_CoreEngineFuncTable; }
-	inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable()
-	{ return m_CoreNewDllFuncTable; }
-	
-	// Get const
-	inline const DLL_FUNCTIONS &GetDllFuncTable() const
-	{ return m_CoreDllFuncTable; }
-	inline const enginefuncs_t &GetEngineFuncTable() const
-	{ return m_CoreEngineFuncTable; }
-	inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable() const
-	{ return m_CoreNewDllFuncTable; }
-
-	// Get post
-	inline DLL_FUNCTIONS &GetDllFuncTable_Post()
-	{ return m_CoreDllFuncTable_Post; }
-	inline enginefuncs_t &GetEngineFuncTable_Post()
-	{ return m_CoreEngineFuncTable_Post; }
-	inline NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post()
-	{ return m_CoreNewDllFuncTable_Post; }
-
-	// Get post const
-	inline const DLL_FUNCTIONS &GetDllFuncTable_Post() const
-	{ return m_CoreDllFuncTable_Post; }
-	inline const enginefuncs_t &GetEngineFuncTable_Post() const
-	{ return m_CoreEngineFuncTable_Post; }
-	inline const NEW_DLL_FUNCTIONS &GetNewDllFuncTable_Post() const
-	{ return m_CoreNewDllFuncTable_Post; } */
-};	// CFakeMeta
-
-// Fake Metamod
-// defined in meta_api.cpp
-extern CFakeMeta g_FakeMeta;
+int UnloadMetamodPlugin(void *handle);
+int LoadMetamodPlugin(const char *path, void **handle, PLUG_LOADTIME now);
 
 #endif // #ifndef __FAKEMETA_H__
-

amxmodx/float.cpp

@@ -96,7 +96,7 @@ static cell AMX_NATIVE_CALL n_floatstr(AMX *amx,cell *params)
         return 0;
 
     /* Now convert the Small String into a C type null terminated string */
-    amx_GetString(szSource, pString, 0);
+    amx_GetStringOld(szSource, pString, 0);
 
     /* Now convert this to a float. */
     fNum = (REAL)atof(szSource);

amxmodx/format.cpp

@@ -0,0 +1,434 @@
+#include "amxmodx.h"
+#include "format.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 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; \
+	}
+
+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_Log("[AMXX] \"%s\" is an invalid debug language", testlang);
+			validlang = false;
+		}
+				
+		g_langMngr.GetDef(testlang, key, debug_status);
+				
+		if (validlang && debug_status == ERR_BADKEY)
+			AMXXLOG_Log("[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_Log("[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)
+{
+	U		text[32];
+	int		digits;
+	double	signedVal;
+	U		*buf;
+	int		val;
+
+	// get the sign
+	signedVal = fval;
+	if (fval < 0)
+		fval = -fval;
+
+	// write the float number
+	digits = 0;
+	val = (int)fval;
+	do {
+		text[digits++] = '0' + val % 10;
+		val /= 10;
+	} while (val);
+
+	if (signedVal < 0)
+		text[digits++] = '-';
+
+	buf = *buf_p;
+
+	while (digits < width && maxlen)
+	{
+		*buf++ = ' ';
+		width--;
+		maxlen--;
+	}
+
+	while (digits-- && maxlen)
+	{
+		*buf++ = text[digits];
+		maxlen--;
+	}
+
+	*buf_p = buf;
+
+	if (prec < 0)
+		prec = 6;
+	// write the fraction
+	digits = 0;
+	while (digits < prec)
+	{
+		fval -= (int) fval;
+		fval *= 10.0;
+		val = (int) fval;
+		text[digits++] = '0' + val % 10;
+	}
+
+	if (digits > 0 && maxlen)
+	{
+		buf = *buf_p;
+		*buf++ = '.';
+		maxlen--;
+		for (prec = 0; maxlen && prec < digits; prec++)
+		{
+			*buf++ = text[prec];
+			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;
+
+	digits = 0;
+	signedVal = val;
+	if (val < 0)
+		val = -val;
+	do {
+		text[digits++] = '0' + val % 10;
+		val /= 10;
+	} while (val);
+
+	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 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]));
+			arg++;
+			break;
+		case 'd':
+		case 'i':
+			CHECK_ARGS(0);
+			AddInt(&buf_p, llen, *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);
+			arg++;
+			break;
+		case 's':
+			CHECK_ARGS(0);
+			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,8 @@
+#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);
+
+#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/mmgr/mmgr.cpp

@@ -930,7 +930,11 @@ void	*m_allocator(const char *sourceFile, const unsigned int sourceLine, const c
 
 			// Danger Will Robinson!
 
-			if (reservoir == NULL) throw "Unable to allocate RAM for internal memory tracking data";
+			if (reservoir == NULL) 
+			{
+				log("%s: Unable to allocate RAM for internal memory tracking data", ownerString(sourceFile, sourceLine, sourceFunc));
+				throw "Unable to allocate RAM for internal memory tracking data";
+			}
 
 			// Build a linked-list of the elements in our reservoir
 
@@ -998,6 +1002,7 @@ void	*m_allocator(const char *sourceFile, const unsigned int sourceLine, const c
 
 		if (au->actualAddress == NULL)
 		{
+			log("%s: Request for allocation failed. Out of memory.", ownerString(sourceFile, sourceLine, sourceFunc));
 			throw "Request for allocation failed. Out of memory.";
 		}
 
@@ -1108,7 +1113,11 @@ void	*m_reallocator(const char *sourceFile, const unsigned int sourceLine, const
 
 		// If you hit this assert, you tried to reallocate RAM that wasn't allocated by this memory manager.
 		m_assert(au != NULL);
-		if (au == NULL) throw "Request to reallocate RAM that was never allocated";
+		if (au == NULL)
+		{
+			log("%s: Request to reallocate RAM that was never allocated", ownerString(sourceFile, sourceLine, sourceFunc));
+			throw "Request to reallocate RAM that was never allocated";
+		}
 
 		// If you hit this assert, then the allocation unit that is about to be reallocated is damaged. But you probably
 		// already know that from a previous assert you should have seen in validateAllocUnit() :)
@@ -1162,7 +1171,11 @@ void	*m_reallocator(const char *sourceFile, const unsigned int sourceLine, const
 		m_assert(newActualAddress);
 		#endif
 
-		if (!newActualAddress) throw "Request for reallocation failed. Out of memory.";
+		if (!newActualAddress)
+		{
+			log("%s: Request for reallocation failed. Out of memory", ownerString(sourceFile, sourceLine, sourceFunc));
+			throw "Request for reallocation failed. Out of memory.";
+		}
 
 		// Remove this allocation from our stats (we'll add the new reallocation again later)
 
@@ -1291,7 +1304,11 @@ void	m_deallocator(const char *sourceFile, const unsigned int sourceLine, const
 
 		// If you hit this assert, you tried to deallocate RAM that wasn't allocated by this memory manager.
 		m_assert(au != NULL);
-		if (au == NULL) throw "Request to deallocate RAM that was never allocated";
+		if (au == NULL)
+		{
+			log("%s: Request to deallocate RAM that was never allocated", ownerString(sourceFile, sourceLine, sourceFunc));
+			throw "Request to deallocate RAM that was never allocated";
+		}
 
 		// If you hit this assert, then the allocation unit that is about to be deallocated is damaged. But you probably
 		// already know that from a previous assert you should have seen in validateAllocUnit() :)

amxmodx/modules.h

@@ -45,135 +45,41 @@
 #undef C_DLLEXPORT
 #define C_DLLEXPORT extern "C" DLLEXPORT
 
-#define AMX_INTERFACE_VERSION 6
-
 #define RELOAD_MODULE 0
 #define STATIC_MODULE 1
 
-struct module_info_s {
-  const char* name;
-  const char* author;
-  const char* version;
-  int ivers;
-  int type;
-  long int serial;
-};
+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;
 
-// Small scripting language
-struct pfnamx_engine_g {
-  uint16_t*   (*pfnamx_Align16)(uint16_t *);                    // value
-  uint32_t*   (*pfnamx_Align32)(uint32_t *);                    // value
-  int     (*pfnamx_Allot)(AMX*, int, cell*, cell**);              // amx, length, amx_addr, phys_addr
-  int     (*pfnamx_Callback)(AMX*, cell , cell*, cell*);            // amx, index,result,params
-  int     (*pfnamx_Clone)(AMX*, AMX*, void*);                 // amxClone, amxSrc, data
-  int     (*pfnamx_Debug)(AMX*); // default debug procedure, does nothing   // amx
-  int     (*pfnamx_Exec)(AMX*, cell*, int , int , ...);           // amx, return val, index, num_params, ...
-  int     (*pfnamx_Execv)(AMX*, cell*, int , int, cell[]);          // amx, return val, index, num_params, param[]
-  int     (*pfnamx_FindPublic)(AMX*, char*, int*);              // amx, func name, index
-  int     (*pfnamx_FindPubVar)(AMX*, char*, cell*);             // anx, var name, amx_addr
-  int     (*pfnamx_FindTagId)(AMX*, cell , char*);              // amx. tag_id, tagname
-  int     (*pfnamx_Flags)(AMX*,uint16_t *);                 // amx, flags
-  int     (*pfnamx_GetAddr)(AMX*,cell ,cell**);               // amx, amx_addr, phys_addr
-  int     (*pfnamx_GetPublic)(AMX*, int , char*);               // amx, index, funcname
-  int     (*pfnamx_GetPubVar)(AMX*, int , char*, cell*);            // amx, index, varname, amx_addr
-  int     (*pfnamx_GetString)(char*dest,cell*);               // dest, source
-  int     (*pfnamx_GetTag)(AMX*, int , char*, cell*);             // amx, index, tagname, tag_id
-  int     (*pfnamx_GetUserData)(AMX*, long , void **);            // amx, tag, ptr
-  int     (*pfnamx_Init)(AMX*, void *);                   // amx, program
-  int     (*pfnamx_InitJIT)(AMX*, void *, void *);              // amx, reloc_table, native_code
-  int     (*pfnamx_MemInfo)(AMX*, long*, long*, long*);           // amx, codesize, datasize, stackheap
-  int     (*pfnamx_NameLength)(AMX*, int*);                 // amx, length
-  AMX_NATIVE_INFO * (*pfnamx_NativeInfo)(char*,AMX_NATIVE );            // name, func
-  int     (*pfnamx_NumPublics)(AMX*, int*);                 // amx, number
-  int     (*pfnamx_NumPubVars)(AMX*, int*);                 // amx, number
-  int     (*pfnamx_NumTags)(AMX*, int*);                    // amx, number
-  int     (*pfnamx_RaiseError)(AMX*, int );                 // amx, error
-  int     (*pfnamx_Register)(AMX*, AMX_NATIVE_INFO*, int );         // amx, nativelist, number
-  int     (*pfnamx_Release)(AMX*, cell );                   // amx, amx_addr
-  int     (*pfnamx_SetCallback)(AMX*, AMX_CALLBACK );             // amx, callback
-  int     (*pfnamx_SetDebugHook)(AMX*, AMX_DEBUG );             // amx, debug
-  int     (*pfnamx_SetString)(cell*, char*, int );              // dest, source, pack
-  int     (*pfnamx_SetUserData)(AMX*, long , void*);              // amx, tag, prt
-  int     (*pfnamx_StrLen)(cell*, int*);                    // amx, cstring, length
-};
-extern pfnamx_engine_g* g_engAmxFunc;
+int CheckModules(AMX *amx, char error[128]);
+const char *StrCaseStr(const char *as, const char *bs);
 
-#define AMX_ALIGN16       (*g_engAmxFunc->pfnamx_Align16)
-#define AMX_ALIGN32       (*g_engAmxFunc->pfnamx_Align32)
-#define AMX_ALLOT         (*g_engAmxFunc->pfnamx_Allot)
-#define AMX_CALLBACK      (*g_engAmxFunc->pfnamx_Callback)
-#define AMX_CLONE         (*g_engAmxFunc->pfnamx_Clone)
-#define AMX_DEBUG         (*g_engAmxFunc->pfnamx_Debug)
-#define AMX_EXEC          (*g_engAmxFunc->pfnamx_Exec)
-#define AMX_EXECV         (*g_engAmxFunc->pfnamx_Execv)
-#define AMX_FINDPUBLIC    (*g_engAmxFunc->pfnamx_FindPublic)
-#define AMX_FINDPUBVAR    (*g_engAmxFunc->pfnamx_FindPubVar)
-#define AMX_FINDTAGID     (*g_engAmxFunc->pfnamx_FindTagId)
-#define AMX_FLAGS         (*g_engAmxFunc->pfnamx_Flags)
-#define AMX_GETADDR       (*g_engAmxFunc->pfnamx_GetAddr)
-#define AMX_GETPUBLIC     (*g_engAmxFunc->pfnamx_GetPublic)
-#define AMX_GETPUBVAR     (*g_engAmxFunc->pfnamx_GetPubVar)
-#define AMX_GETSTRING     (*g_engAmxFunc->pfnamx_GetString)
-#define AMX_GETTAG        (*g_engAmxFunc->pfnamx_GetTag)
-#define AMX_GETUSERDATA   (*g_engAmxFunc->pfnamx_GetUserData)
-#define AMX_INIT          (*g_engAmxFunc->pfnamx_Init)
-#define AMX_INITJIT       (*g_engAmxFunc->pfnamx_InitJIT)
-#define AMX_MEMINFO       (*g_engAmxFunc->pfnamx_MemInfo)
-#define AMX_NAMELENGTH    (*g_engAmxFunc->pfnamx_NameLength)
-#define AMX_NATIVEINFO    (*g_engAmxFunc->pfnamx_NativeInfo)
-#define AMX_NUMPUBLICS    (*g_engAmxFunc->pfnamx_NumPublics)
-#define AMX_NUMPUBVARS    (*g_engAmxFunc->pfnamx_NumPubVars)
-#define AMX_NUMTAGS       (*g_engAmxFunc->pfnamx_NumTags)
-#define AMX_RAISEERROR    (*g_engAmxFunc->pfnamx_RaiseError)
-#define AMX_REGISTER      (*g_engAmxFunc->pfnamx_Register)
-#define AMX_RELEASE       (*g_engAmxFunc->pfnamx_Release)
-#define AMX_SETCALLBACK   (*g_engAmxFunc->pfnamx_SetCallback)
-#define AMX_SETDEBUGHOOK  (*g_engAmxFunc->pfnamx_SetDebugHook)
-#define AMX_SETSTRING     (*g_engAmxFunc->pfnamx_SetString)
-#define AMX_SETUSERDATA   (*g_engAmxFunc->pfnamx_SetUserData)
-#define AMX_STRLEN        (*g_engAmxFunc->pfnamx_StrLen)
+class Debugger;
+Debugger *DisableDebugHandler(AMX *amx);
+void EnableDebugHandler(AMX *amx, Debugger *pd);
 
-// Modules API
-struct pfnmodule_engine_g {
-  int         (*pfnadd_amxnatives)(module_info_s*,AMX_NATIVE_INFO*);      // list
-  char*       (*pfnbuild_pathname)(char*, ...);                           // format, ....
-  void        (*pfncopy_amxmemory)(cell*,cell*,int);                      // dest, src, len
-  char*       (*pfnformat_amxstring)(AMX*, cell*, int ,int& );            // amx, format, start pos, len
-  cell*       (*pfnget_amxaddr)(AMX*,cell );                              // amx, cell
-  AMX*        (*pfnget_amxscript)(int, void**,const char**);              // id, code, name
-  const char* (*pfnget_amxscriptname)(AMX* amx);                          // amx
-  char*       (*pfnget_amxstring)(AMX*,cell,int, int&);                   // amx, src, buffer (0-3), len
-  void        (*pfnget_modname)(char*);                                   // modname
-  int         (*pfnload_amxscript)(AMX*, void**, const char*, char[64], int);  // amx, code, path, error info
-  void        (*pfnprint_console)(char*, ...);                            // format, ....
-  void      (*pfnreport_error)(int code, char*, ... );
-  int         (*pfnset_amxnatives)(AMX*,char[64]);                        // amx, error info
-  int         (*pfnset_amxstring)(AMX*,cell ,const char*,int);            // amx, dest, string, maxlen
-  int         (*pfnamxstring_length)(cell*);                              // src
-  int         (*pfnunload_amxscript)(AMX* amx,void**);                    // amx, code
-  void*     (*pfnalloc_amxmemory)(void**,int size);
-  void      (*pfnfree_amxmemory)(void**);
-};
-extern pfnmodule_engine_g* g_engModuleFunc;
-
-#define ADD_AMXNATIVES          (*g_engModuleFunc->pfnadd_amxnatives)
-#define AMXSTRING_LENGTH        (*g_engModuleFunc->pfnamxstring_length)
-#define BUILD_PATHNAME          (*g_engModuleFunc->pfnbuild_pathname)
-#define COPY_AMXMEMORY          (*g_engModuleFunc->pfncopy_amxmemory)
-#define FORMAT_AMXSTRING        (*g_engModuleFunc->pfnformat_amxstring)
-#define GET_AMXADDR             (*g_engModuleFunc->pfnget_amxaddr)
-#define GET_AMXSCRIPT           (*g_engModuleFunc->pfnget_amxscript)
-#define GET_AMXSCRIPTNAME       (*g_engModuleFunc->pfnget_amxscriptname)
-#define GET_AMXSTRING           (*g_engModuleFunc->pfnget_amxstring)
-#define GET_MODNAME             (*g_engModuleFunc->pfnget_modname)
-#define LOAD_AMXSCRIPT          (*g_engModuleFunc->pfnload_amxscript)
-#define PRINT_CONSOLE           (*g_engModuleFunc->pfnprint_console)
-#define REPORT_ERROR      (*g_engModuleFunc->pfnreport_error)
-#define SET_AMXNATIVES          (*g_engModuleFunc->pfnset_amxnatives)
-#define SET_AMXSTRING           (*g_engModuleFunc->pfnset_amxstring)
-#define UNLOAD_AMXSCRIPT        (*g_engModuleFunc->pfnunload_amxscript)
-#define ALLOC_AMXMEMORY         (*g_engModuleFunc->pfnalloc_amxmemory)
-#define FREE_AMXMEMORY        (*g_engModuleFunc->pfnfree_amxmemory)
+bool DirExists(const char *dir);
 
+const char* GetFileName(AMX *amx);
 
 #endif // __MODULES_H__

amxmodx/msvc/amxmodx.vcproj

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

amxmodx/msvc/amxmodx_mm.def

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

amxmodx/msvc/amxmodx_mm.sln

@@ -0,0 +1,45 @@
+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
+		JITDebugBinLog = JITDebugBinLog
+		JITMemtestRelease = JITMemtestRelease
+		JITRelease = JITRelease
+		JITReleaseBinLog = JITReleaseBinLog
+		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}.JITDebugBinLog.ActiveCfg = JITDebugBinLog|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITDebugBinLog.Build.0 = JITDebugBinLog|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}.JITReleaseBinLog.ActiveCfg = JITReleaseBinLog|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITReleaseBinLog.Build.0 = JITReleaseBinLog|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

@@ -42,12 +42,13 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalOptions="/MACHINE:I386"
-				AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
+				AdditionalDependencies="..\JIT\natives-x86.obj ..\zlib\zlib.lib"
 				OutputFile="debug/amxmodx_mm.dll"
 				Version="0.1"
 				LinkIncremental="1"
 				SuppressStartupBanner="TRUE"
 				AdditionalLibraryDirectories="..\extra\lib_win32"
+				IgnoreDefaultLibraryNames="MSVCRT"
 				ModuleDefinitionFile=""
 				GenerateDebugInformation="TRUE"
 				ProgramDatabaseFile=".\debug/amxx_mm.pdb"
@@ -112,11 +113,12 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalOptions="/MACHINE:I386"
-				AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
+				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"/>
@@ -162,7 +164,7 @@
 				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"
+				RuntimeLibrary="3"
 				StructMemberAlignment="3"
 				UsePrecompiledHeader="2"
 				PrecompiledHeaderThrough="amxmodx.h"
@@ -179,12 +181,13 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalOptions="/MACHINE:I386"
-				AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
+				AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib ..\JIT\natives-x86.obj"
 				OutputFile="memtestdebug/amxmodx_mm.dll"
-				Version="0.1"
+				Version="1.6.5.0"
 				LinkIncremental="2"
 				SuppressStartupBanner="TRUE"
 				AdditionalLibraryDirectories="..\extra\lib_win32"
+				IgnoreDefaultLibraryNames="MSVCRT"
 				ModuleDefinitionFile=""
 				GenerateDebugInformation="TRUE"
 				ProgramDatabaseFile=".\memtestdebug/amxx_mm.pdb"
@@ -249,13 +252,17 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalOptions="/MACHINE:I386"
-				AdditionalDependencies="odbc32.lib odbccp32.lib ..\zlib\zlib.lib"
+				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="MSVCRT"
 				ModuleDefinitionFile=""
+				GenerateDebugInformation="TRUE"
 				ProgramDatabaseFile=".\memtestrelease/amxx_mm.pdb"
+				GenerateMapFile="TRUE"
+				MapExports="TRUE"
 				ImportLibrary=".\memtestrelease/amxx_mm.lib"/>
 			<Tool
 				Name="VCMIDLTool"
@@ -296,8 +303,8 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				Optimization="0"
-				AdditionalIncludeDirectories="&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\pm_shared&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\dlls&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\engine&quot;;&quot;C:\Hry\Half-Life\SDK\Multiplayer Source\common&quot;;C:\Files\Programming\metamod\metamod"
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;PAWN_CELL_SIZE=32;ASM32;JIT"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="5"
 				StructMemberAlignment="3"
@@ -316,12 +323,13 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalOptions="/MACHINE:I386"
-				AdditionalDependencies="..\jit\jits.obj ..\zlib\zlib.lib"
+				AdditionalDependencies="..\zlib\zlib.lib ..\JIT\amxjitsn.obj ..\JIT\amxexecn.obj ..\JIT\natives-x86.obj"
 				OutputFile="jitdebug/amxmodx_mm.dll"
 				Version="0.1"
-				LinkIncremental="1"
+				LinkIncremental="2"
 				SuppressStartupBanner="TRUE"
 				AdditionalLibraryDirectories="..\extra\lib_win32"
+				IgnoreDefaultLibraryNames="MSVCRT"
 				ModuleDefinitionFile=""
 				GenerateDebugInformation="TRUE"
 				ProgramDatabaseFile=".\jitdebug/amxx_mm.pdb"
@@ -364,11 +372,16 @@
 			CharacterSet="2">
 			<Tool
 				Name="VCCLCompilerTool"
+				Optimization="2"
 				GlobalOptimizations="TRUE"
 				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="TRUE"
 				FavorSizeOrSpeed="1"
+				OmitFramePointers="TRUE"
+				OptimizeForProcessor="0"
 				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"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;JIT;ASM32;PAWN_CELL_SIZE=32"
+				IgnoreStandardIncludePath="FALSE"
 				StringPooling="TRUE"
 				RuntimeLibrary="4"
 				EnableFunctionLevelLinking="TRUE"
@@ -380,19 +393,23 @@
 				ProgramDataBaseFileName=".\jitrelease/"
 				WarningLevel="3"
 				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"
 				CompileAs="0"/>
 			<Tool
 				Name="VCCustomBuildTool"/>
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalOptions="/MACHINE:I386"
-				AdditionalDependencies="..\jit\jits.obj ..\zlib\zlib.lib"
+				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=""
-				ProgramDatabaseFile=".\jitrelease/amxx_mm.pdb"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\jitrelease/amxmodx_mm.pdb"
+				GenerateMapFile="TRUE"
 				ImportLibrary=".\jitrelease/amxx_mm.lib"/>
 			<Tool
 				Name="VCMIDLTool"
@@ -436,7 +453,7 @@
 				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"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;MEMORY_TEST;JIT;ASM32;PAWN_CELL_SIZE=32"
 				StringPooling="TRUE"
 				RuntimeLibrary="4"
 				EnableFunctionLevelLinking="TRUE"
@@ -454,12 +471,14 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalOptions="/MACHINE:I386"
-				AdditionalDependencies="odbc32.lib odbccp32.lib ..\jit\jits.lib ..\zlib\zlib.lib"
+				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
@@ -561,6 +580,153 @@
 			<Tool
 				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
 		</Configuration>
+		<Configuration
+			Name="JITDebugBinLog|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=""
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;amxmodx_EXPORTS;PAWN_CELL_SIZE=32;ASM32;JIT;BINLOG_ENABLED"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				StructMemberAlignment="3"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough="amxmodx.h"
+				PrecompiledHeaderFile=".\jitdebugbinlog/amxmodx.pch"
+				AssemblerListingLocation=".\jitdebugbinlog/"
+				ObjectFile=".\jitdebugbinlog/"
+				ProgramDataBaseFileName=".\jitdebugbinlog/"
+				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="jitdebugbinlog/amxmodx_mm.dll"
+				Version="0.1"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				AdditionalLibraryDirectories="..\extra\lib_win32"
+				IgnoreDefaultLibraryNames="MSVCRT"
+				ModuleDefinitionFile=""
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\jitdebugbinlog/amxx_mm.pdb"
+				ImportLibrary=".\jitdebugbinlog/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="JITReleaseBinLog|Win32"
+			OutputDirectory="$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="TRUE"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="TRUE"
+				OptimizeForProcessor="0"
+				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;BINLOG_ENABLED"
+				IgnoreStandardIncludePath="FALSE"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough="amxmodx.h"
+				PrecompiledHeaderFile=".\jitreleasebinlog/amxmodx.pch"
+				AssemblerListingLocation=".\jitreleasebinlog/"
+				ObjectFile=".\jitreleasebinlog/"
+				ProgramDataBaseFileName=".\jitreleasebinlog/"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"
+				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="jitreleasebinlog/amxmodx_mm.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				AdditionalLibraryDirectories="..\extra\lib_win32"
+				IgnoreDefaultLibraryNames="MSVCRT"
+				ModuleDefinitionFile=""
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\jitreleasebinlog/amxmodx_mm.pdb"
+				GenerateMapFile="TRUE"
+				ImportLibrary=".\jitreleasebinlog/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>
@@ -574,6 +740,9 @@
 			<File
 				RelativePath="..\amxcore.cpp">
 			</File>
+			<File
+				RelativePath="..\amxdbg.cpp">
+			</File>
 			<File
 				RelativePath="..\amxmodx.cpp">
 			</File>
@@ -586,6 +755,9 @@
 			<File
 				RelativePath="..\amxxlog.cpp">
 			</File>
+			<File
+				RelativePath="..\binlog.cpp">
+			</File>
 			<File
 				RelativePath="..\CCmd.cpp">
 			</File>
@@ -618,10 +790,25 @@
 			</File>
 			<File
 				RelativePath="..\CTask.cpp">
+				<FileConfiguration
+					Name="JITRelease|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AssemblerOutput="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="JITReleaseBinLog|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AssemblerOutput="0"/>
+				</FileConfiguration>
 			</File>
 			<File
 				RelativePath="..\CVault.cpp">
 			</File>
+			<File
+				RelativePath="..\debugger.cpp">
+			</File>
 			<File
 				RelativePath="..\emsg.cpp">
 			</File>
@@ -640,6 +827,21 @@
 			<File
 				RelativePath="..\float.cpp">
 			</File>
+			<File
+				RelativePath="..\format.cpp">
+				<FileConfiguration
+					Name="JITRelease|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AssemblerOutput="4"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="JITReleaseBinLog|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AssemblerOutput="4"/>
+				</FileConfiguration>
+			</File>
 			<File
 				RelativePath="..\md5.cpp">
 			</File>
@@ -649,6 +851,15 @@
 			<File
 				RelativePath="..\modules.cpp">
 			</File>
+			<File
+				RelativePath="..\natives.cpp">
+			</File>
+			<File
+				RelativePath="..\newmenus.cpp">
+			</File>
+			<File
+				RelativePath="..\optimizer.cpp">
+			</File>
 			<File
 				RelativePath="..\power.cpp">
 			</File>
@@ -657,6 +868,18 @@
 			</File>
 			<File
 				RelativePath="..\string.cpp">
+				<FileConfiguration
+					Name="JITRelease|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AssemblerOutput="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="JITReleaseBinLog|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AssemblerOutput="2"/>
+				</FileConfiguration>
 			</File>
 			<File
 				RelativePath="..\strptime.cpp">
@@ -702,6 +925,18 @@
 						<Tool
 							Name="VCCLCompilerTool"/>
 					</FileConfiguration>
+					<FileConfiguration
+						Name="JITDebugBinLog|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCLCompilerTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="JITReleaseBinLog|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCLCompilerTool"/>
+					</FileConfiguration>
 				</File>
 			</Filter>
 		</Filter>
@@ -711,6 +946,9 @@
 			<File
 				RelativePath="..\amx.h">
 			</File>
+			<File
+				RelativePath="..\amxdbg.h">
+			</File>
 			<File
 				RelativePath="..\amxmodx.h">
 			</File>
@@ -720,6 +958,9 @@
 			<File
 				RelativePath="..\amxxlog.h">
 			</File>
+			<File
+				RelativePath="..\binlog.h">
+			</File>
 			<File
 				RelativePath="..\CCmd.h">
 			</File>
@@ -756,9 +997,6 @@
 			<File
 				RelativePath="..\CQueue.h">
 			</File>
-			<File
-				RelativePath="..\CRList.h">
-			</File>
 			<File
 				RelativePath="..\CString.h">
 			</File>
@@ -771,15 +1009,51 @@
 			<File
 				RelativePath="..\CVector.h">
 			</File>
+			<File
+				RelativePath="..\debugger.h">
+			</File>
 			<File
 				RelativePath="..\fakemeta.h">
 			</File>
+			<File
+				RelativePath="..\format.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="..\optimizer.h">
+			</File>
+			<File
+				RelativePath="..\resource.h">
+			</File>
+			<File
+				RelativePath="..\sh_list.h">
+			</File>
+			<File
+				RelativePath="..\sh_stack.h">
+			</File>
+			<File
+				RelativePath="..\sh_tinyhash.h">
+			</File>
+			<File
+				RelativePath="..\zlib\zconf.h">
+			</File>
+			<File
+				RelativePath="..\zlib\zlib.h">
+			</File>
 			<Filter
 				Name="mmgr"
 				Filter="">
@@ -798,6 +1072,108 @@
 				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="..\helpers-x86.asm">
+			</File>
+			<File
+				RelativePath="..\natives-amd64.asm">
+			</File>
+			<File
+				RelativePath="..\natives-x86.asm">
+			</File>
+			<Filter
+				Name="Builds"
+				Filter="">
+				<File
+					RelativePath="..\Jit\helpers-x86.obj">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="SDK"
+			Filter="">
+			<File
+				RelativePath="..\sdk\amxxmodule.cpp">
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="MemtestDebug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="MemtestRelease|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="JITMemtestRelease|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="MaximalSpeed|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="JITDebugBinLog|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="JITReleaseBinLog|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\sdk\amxxmodule.h">
+			</File>
+			<File
+				RelativePath="..\sdk\moduleconfig.h">
+			</File>
+		</Filter>
 	</Files>
 	<Globals>
 	</Globals>

amxmodx/msvc8/amxmodx_mm.sln

@@ -0,0 +1,37 @@
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "amxmodx", "amxmodx_mm.vcproj", "{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		JITDebug|Win32 = JITDebug|Win32
+		JITMemtestRelease|Win32 = JITMemtestRelease|Win32
+		JITRelease|Win32 = JITRelease|Win32
+		MaximalSpeed|Win32 = MaximalSpeed|Win32
+		MemtestDebug|Win32 = MemtestDebug|Win32
+		MemtestRelease|Win32 = MemtestRelease|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.Debug|Win32.ActiveCfg = Debug|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.Debug|Win32.Build.0 = Debug|Win32
+		{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}.JITMemtestRelease|Win32.ActiveCfg = JITMemtestRelease|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.JITMemtestRelease|Win32.Build.0 = JITMemtestRelease|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}.MaximalSpeed|Win32.ActiveCfg = MaximalSpeed|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MaximalSpeed|Win32.Build.0 = MaximalSpeed|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MemtestDebug|Win32.ActiveCfg = MemtestDebug|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MemtestDebug|Win32.Build.0 = MemtestDebug|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MemtestRelease|Win32.ActiveCfg = MemtestRelease|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.MemtestRelease|Win32.Build.0 = MemtestRelease|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.Release|Win32.ActiveCfg = Release|Win32
+		{2BF64D1A-AC89-41B0-9D02-FB8CB610F850}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

amxmodx/natives-amd64.asm

@@ -0,0 +1,91 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; (C)2005 by David "BAILOPAN" Anderson		 ;
+; register_native functions for amd64		 ;;;;;;
+; Based on the concept by Julien "dJeyL" Laurent      ;
+; Thanks to T(+)rget for pushing me to implement this ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;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.
+
+;;Initializes the global variable
+
+BITS 64
+
+section .text
+
+global amxx_DynaInit, _amxx_DynaInit
+;void amxx_DynaInit(void *ptr);
+amxx_DynaInit:
+_amxx_DynaInit:
+	mov	[GLOBAL_GATE wrt rip], rdi
+	ret
+	
+;;Assembles the gateway function
+global amxx_DynaMake, _amxx_DynaMake
+;int amxx_DynaMake(char *buffer, int id);
+amxx_DynaMake:
+_amxx_DynaMake:
+	;we're not damaging the stack I think so we should be safe with no prologue
+	
+	;save these two we're about to destroy them
+	push		rsi		;push id
+	push		rdi		;push buffer
+	
+	mov		rsi, _amxx_DynaFuncStart
+	mov		rcx, _amxx_DynaFuncEnd - _amxx_DynaFuncStart
+	cld		;clear direction flag (just in case)
+	rep		movsb
+	
+	pop		rdi		;get buffer as destination
+	pop		rax		;get id
+	;align us to mov rsi, 1234... - on x86-64 this is 2 bytes after the differential
+	add		rdi, (_amxx_DynaFuncStart.move-_amxx_DynaFuncStart) + 2
+	mov		[rdi], qword rax
+	;align rdi to the call
+	add		rdi, (_amxx_DynaFuncStart.call-_amxx_DynaFuncStart.move) 
+	mov		rax, qword [GLOBAL_GATE wrt rip]
+	;copy the real address
+	mov		[rdi], rax
+	
+	ret
+
+;;The gateway function we will re-assemble
+;; This is similar to dJeyL's but a tad more elegant, as it's written in pure assembly
+;; and NASM > GAS :')
+global amxx_DynaFunc, _amxx_DynaFunc
+;int amxx_DynaFunc(AMX *amx, cell *params);
+amxx_DynaFunc:
+_amxx_DynaFunc:
+_amxx_DynaFuncStart:
+	push		rbp
+	mov		rbp, rsp
+	
+	;we're given an amx and params... we're also hardcoded for this though:
+	mov		rdx, rsi	;move 2nd param to 3rd 
+	mov		rsi, rdi	;move 1st param to 2nd
+	;this old trick, we'll move in the real pointer in a bit.
+.move:
+	mov		rdi, qword 1234567812345678h
+.call:
+	mov		rcx, qword 1234567812345678h
+	call		rcx
+	
+	pop		rbp
+	ret
+_amxx_DynaFuncEnd:
+
+;;Just returns the buffer size required
+global _amxx_DynaCodesize, amxx_DynaCodesize
+;int amxx_DynaCodesize()
+amxx_DynaCodesize:
+_amxx_DynaCodesize:
+	; on x86-64 this is 34 bytes
+	mov		rax, _amxx_DynaFuncEnd - _amxx_DynaFuncStart
+	ret
+
+section .data
+	
+GLOBAL_GATE		DQ		0
+

amxmodx/natives-x86.asm

@@ -0,0 +1,100 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; (C)2005 by David "BAILOPAN" Anderson			 ;
+; register_native functions for x86				 ;;;;;;
+; Based on the concept by Julien "dJeyL" Laurent	  ;
+; Thanks to T(+)rget for pushing me to implement this ;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;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.
+
+;;Initializes the global variable
+
+section .text
+
+global amxx_DynaInit, _amxx_DynaInit
+;void amxx_DynaInit(void *ptr);
+amxx_DynaInit:
+_amxx_DynaInit:
+	push	ebp
+	mov		ebp, esp
+	
+	mov		eax, [ebp+8]		;get pointer
+	mov		[GLOBAL_GATE], eax	;store
+	
+	mov		eax, 1
+	pop		ebp
+	ret
+	
+;;Assembles the gateway function
+global amxx_DynaMake, _amxx_DynaMake
+;int amxx_DynaMake(char *buffer, int id);
+amxx_DynaMake:
+_amxx_DynaMake:
+	push	ebp
+	mov		ebp, esp
+	
+	push	edi
+	push	esi
+	
+	mov		edi, [ebp+8]	;buffer
+	mov		esi, _amxx_DynaFuncStart
+	mov		ecx, _amxx_DynaFuncEnd - _amxx_DynaFuncStart
+	cld		;clear direction flag (just in case)
+	rep		movsb
+	
+	mov		edi, [ebp+8]	;get buffer again
+	;align us to mov eax, 1234 - on x86 this is 4 bytes
+	add		edi, (_amxx_DynaMoveOffset-_amxx_DynaFuncStart) + 1
+	mov		eax, [ebp+12]
+	mov		[edi], eax
+	
+	pop		esi
+	pop		edi
+	
+	mov		eax, 1
+	pop		ebp
+	ret
+
+;;The gateway function we will re-assemble
+;; This is similar to dJeyL's but a tad more elegant, as it's written in pure assembly
+;; and NASM > GAS :')
+global amxx_DynaFunc, _amxx_DynaFunc
+;int amxx_DynaFunc(AMX *amx, cell *params);
+amxx_DynaFunc:
+_amxx_DynaFunc:
+_amxx_DynaFuncStart:
+	push	ebp
+	mov		ebp, esp
+	
+	;we're given an amx and params... we're also hardcoded for this though:
+_amxx_DynaMoveOffset:
+	mov		eax, 12345678h		;this old trick, we'll move in the real pointer in a bit.
+	push	dword [ebp+12]		;push params
+	push	dword [ebp+8]		;push amx
+	push	eax					;push the id
+	call	[GLOBAL_GATE]		;pass through teh global gateway.
+	add		esp, 12				;reset stack oops
+	
+	pop		ebp
+	ret
+_amxx_DynaFuncEnd:
+
+;;Just returns the buffer size required
+global _amxx_DynaCodesize, amxx_DynaCodesize
+;int amxx_DynaCodesize()
+amxx_DynaCodesize:
+_amxx_DynaCodesize:
+	push	ebp
+	mov		ebp, esp
+	
+	; on x86 is this 17 bytes
+	mov		eax, _amxx_DynaFuncEnd - _amxx_DynaFuncStart
+	
+	pop		ebp
+	ret
+	
+section .data
+	
+GLOBAL_GATE		DD		0

amxmodx/natives.cpp

@@ -0,0 +1,448 @@
+/* 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 "sh_stack.h"
+#include "natives.h"
+#include "debugger.h"
+
+#ifdef __linux__
+#include <malloc.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include "sclinux.h"
+#endif
+
+//Written by David "BAILOPAN" Anderson
+//With the exception for param_convert, which was written by
+// Julien "dJeyL" Laurent
+
+CStack<int> g_ErrorStk;
+CVector<regnative *> g_RegNatives;
+CStack<regnative *> g_NativeStack;
+CVector<String> g_Libraries;
+static char g_errorStr[512] = {0};
+bool g_Initialized = false;
+
+int amxx_DynaCallback(int idx, AMX *amx, cell *params)
+{
+	if (idx < 0 || idx >= (int)g_RegNatives.size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid dynamic native called");
+		return 0;
+	}
+
+	regnative *pNative = g_RegNatives[idx];
+	int numParams = params[0] / sizeof(cell);
+
+	if (numParams > CALLFUNC_MAXPARAMS)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Called dynanative with too many parameters (%d)", CALLFUNC_MAXPARAMS);
+		return 0;
+	}
+
+	//parameter stack
+	pNative->caller = amx;
+
+	CPluginMngr::CPlugin *pPlugin = g_plugins.findPluginFast(amx);
+
+	int err = 0;
+	cell ret = 0;
+	g_ErrorStk.push(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--)
+			pNative->params[i] = params[i];
+	} else if (pNative->style == 1) {
+		//use dJeyL's system .. very clever!
+		for (int i=numParams; i>=1; i--)
+			amx_Push(pNative->amx, params[i]);
+	}
+	Debugger *pDebugger = (Debugger *)pNative->amx->userdata[UD_DEBUGGER];
+	if (pDebugger)
+		pDebugger->BeginExec();
+	err=amx_Exec(pNative->amx, &ret, pNative->func);
+	if (err != AMX_ERR_NONE)
+	{
+		if (pDebugger && pDebugger->ErrorExists())
+		{
+			//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_ErrorStk.front()) {
+		LogError(amx, g_ErrorStk.front(), g_errorStr);
+	}
+	if (pDebugger)
+		pDebugger->EndExec();
+	g_NativeStack.pop();
+	g_ErrorStk.pop();
+
+	return ret;
+}
+
+AMX_NATIVE_INFO *BuildNativeTable()
+{
+	if (g_RegNatives.size() < 1)
+		return NULL;
+
+	AMX_NATIVE_INFO *pNatives = new AMX_NATIVE_INFO[g_RegNatives.size() + 1];
+
+	AMX_NATIVE_INFO info;
+	regnative *pNative;
+	for (size_t i=0; i<g_RegNatives.size(); i++)
+	{
+		pNative = g_RegNatives[i];
+		info.name = pNative->name.c_str();
+		info.func = (AMX_NATIVE)((void *)(pNative->pfn));
+		pNatives[i] = info;
+	}
+	pNatives[g_RegNatives.size()].name = NULL;
+	pNatives[g_RegNatives.size()].func = NULL;
+
+	//this needs to be deleted
+	return pNatives;
+}
+
+static cell AMX_NATIVE_CALL log_error(AMX *amx, cell *params)
+{
+	int len;
+	char *err = format_amxstring(amx, params, 2, len);
+
+	_snprintf(g_errorStr, sizeof(g_errorStr), "%s", err);
+	g_ErrorStk.pop();
+	g_ErrorStk.push(params[1]);
+
+	return 1;
+}
+
+//get_string(param, dest[], len)
+static cell AMX_NATIVE_CALL get_string(AMX *amx, cell *params)
+{
+	if (!g_NativeStack.size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+	regnative *pNative = g_NativeStack.front();
+	if (pNative->style)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
+		return 0;
+	}
+	int p = params[1];
+
+	int len;
+	char *str = get_amxstring(pNative->caller, pNative->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())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+	regnative *pNative = g_NativeStack.front();
+	if (pNative->style)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
+		return 0;
+	}
+	int p = params[1];
+
+	int len;
+	char *str = get_amxstring(amx, params[2], 0, len);
+
+	return set_amxstring(pNative->caller, pNative->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())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+	regnative *pNative = g_NativeStack.front();
+	if (pNative->style)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
+		return 0;
+	}
+	int p = params[1];
+
+	return pNative->params[p];
+}
+
+//get_param_byref(num)
+static cell AMX_NATIVE_CALL get_param_byref(AMX *amx, cell *params)
+{
+	if (!g_NativeStack.size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+	regnative *pNative = g_NativeStack.front();
+	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]);
+
+	return addr[0];
+}
+
+//set_param_byref(num, val)
+static cell AMX_NATIVE_CALL set_param_byref(AMX *amx, cell *params)
+{
+	if (!g_NativeStack.size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+	regnative *pNative = g_NativeStack.front();
+	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]);
+
+	addr[0] = params[2];
+
+	return 1;
+}
+
+//get_array(param, dest[], size)
+static cell AMX_NATIVE_CALL get_array(AMX *amx, cell *params)
+{
+	if (!g_NativeStack.size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+	regnative *pNative = g_NativeStack.front();
+	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 *dest = get_amxaddr(amx, params[2]);
+
+	int size = params[3];
+
+	memcpy(dest, source, size * sizeof(cell));
+
+	return 1;
+}
+
+//set_array(param, source[], size)
+static cell AMX_NATIVE_CALL set_array(AMX *amx, cell *params)
+{
+	if (!g_NativeStack.size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+	regnative *pNative = g_NativeStack.front();
+	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 *source = get_amxaddr(amx, params[2]);
+
+	int size = params[3];
+
+	memcpy(dest, source, size * sizeof(cell));
+
+	return 1;
+}
+
+//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())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Not currently in a dynamic native");
+		return 0;
+	}
+	regnative *pNative = g_NativeStack.front();
+	if (pNative->style != 1)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Wrong style of dynamic native");
+		return 0;
+	}
+	cell p = params[1];
+
+	AMX *caller = pNative->caller;
+
+	unsigned char *data =amx->base+(int)((AMX_HEADER *)amx->base)->dat;
+	unsigned char *realdata = caller->base+(int)((AMX_HEADER *)caller->base)->dat;
+
+	* (cell *)(data+(int)amx->frm+(p+2)*sizeof(cell)) -= (cell)data-(cell)realdata;
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL register_library(AMX *amx, cell *params)
+{
+	int len;
+	char *lib = get_amxstring(amx, params[1], 0, len);
+
+	AddPluginLibrary(lib);
+
+	return 1;
+}
+
+//register_native(const name[], const handler[])
+static cell AMX_NATIVE_CALL register_native(AMX *amx, cell *params)
+{
+	if (!g_Initialized)
+		amxx_DynaInit((void *)(amxx_DynaCallback));
+
+	g_Initialized = true;
+
+	int len;
+	char *name = get_amxstring(amx, params[1], 0, len);
+	char *func = get_amxstring(amx, params[2], 1, len);
+
+	int idx, err;
+	if ( (err=amx_FindPublic(amx, func, &idx)) != AMX_ERR_NONE)
+	{
+		LogError(amx, err, "Function \"%s\" was not found", func);
+		return 0;
+	}
+
+	regnative *pNative = new regnative;
+	pNative->amx = amx;
+	pNative->func = idx;
+	
+	//we'll apply a safety buffer too
+	//make our function
+	int size = amxx_DynaCodesize();
+#ifndef __linux__
+	DWORD temp;
+	pNative->pfn = new char[size + 10];
+	VirtualProtect(pNative->pfn, size+10, PAGE_EXECUTE_READWRITE, &temp);
+#else
+	pNative->pfn = (char *)memalign(sysconf(_SC_PAGESIZE), size+10);
+	mprotect((void *)pNative->pfn, size+10, PROT_READ|PROT_WRITE|PROT_EXEC);
+#endif
+
+	int id = (int)g_RegNatives.size();
+	
+	amxx_DynaMake(pNative->pfn, id);
+	pNative->func = idx;
+	pNative->style = params[3];
+
+	g_RegNatives.push_back(pNative);
+
+	pNative->name.assign(name);
+
+	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();
+
+	for (size_t i=0; i<g_RegNatives.size(); i++)
+	{
+		delete [] g_RegNatives[i]->pfn;
+		delete g_RegNatives[i];
+	}
+	g_RegNatives.clear();
+}
+
+AMX_NATIVE_INFO g_NativeNatives[] = {
+	{"register_native",	register_native},
+	{"log_error",		log_error},
+	{"register_library",register_library},
+	{"get_string",		get_string},
+	{"set_string",		set_string},
+	{"get_param",		get_param},
+	{"get_param_byref",	get_param_byref},
+	{"set_param_byref",	set_param_byref},
+	{"get_array",		get_array},
+	{"set_array",		set_array},
+	//these are dummy functions for floats ;p
+	{"get_param_f",		get_param},
+	{"get_float_byref",	get_param_byref},
+	{"set_float_byref", set_param_byref},
+	{"get_array_f",		get_array},
+	{"set_array_f",		set_array},
+	{"param_convert",	param_convert},
+	//////////////////////////
+	{NULL,				NULL},
+};

amxmodx/natives.h

@@ -0,0 +1,71 @@
+/* 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_NATIVES_H
+#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
+
+#define N_CELL		1
+#define	N_ARRAY		2
+#define N_BYREF		3
+#define	N_VARARG	4
+
+struct regnative
+{
+	AMX *amx;
+	String name;
+	char *pfn;
+	int func;
+	AMX *caller;
+	int style;
+	cell params[CALLFUNC_MAXPARAMS];
+};
+
+extern "C" void amxx_DynaInit(void *ptr);
+extern "C" void amxx_DynaMake(char *buffer, int id);
+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[];
+
+#endif //_INCLUDE_NATIVES_H

amxmodx/newmenus.cpp

@@ -0,0 +1,871 @@
+/* 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 "newmenus.h"
+
+CVector<Menu *> g_NewMenus;
+CStack<int> g_MenuFreeStack;
+
+void ClearMenus()
+{
+	for (size_t i = 0; i < g_NewMenus.size(); i++)
+		delete g_NewMenus[i];
+	
+	g_NewMenus.clear();
+	while (!g_MenuFreeStack.empty())
+		g_MenuFreeStack.pop();
+}
+
+void validate_menu_text(char *str)
+{
+	if (!g_coloredmenus)
+	{
+		size_t offs = 0;
+		while (*str)
+		{
+			if (*str == '\\')
+			{
+				str++;
+				char c = tolower(*str);
+				if (c == 'r' || c == 'w'
+					|| c== 'w' || c == 'd')
+				{
+					str++;
+					offs += 2;
+					continue;
+				}
+			}
+			if (offs)
+				*(str-offs) = *str;
+			str++;
+		}
+		if (offs)
+			*(str-offs) = '\0';
+	}
+}
+
+Menu::Menu(const char *title, int mid, int tid)
+{
+	m_Title.assign(title);
+	menuId = mid;
+	thisId = tid;
+
+	m_OptNames[abs(MENU_BACK)].assign("Back");
+	m_OptNames[abs(MENU_MORE)].assign("More");
+	m_OptNames[abs(MENU_EXIT)].assign("Exit");
+
+	m_OptOrders[0] = MENU_BACK;
+	m_OptOrders[1] = MENU_MORE;
+	m_OptOrders[2] = MENU_EXIT;
+
+	m_AlwaysExit = false;
+	m_NeverExit = false;
+	m_AutoColors = g_coloredmenus;
+
+	items_per_page = 7;
+	func = 0;
+	padding = 0;
+	isDestroying = false;
+}
+
+Menu::~Menu()
+{
+	for (size_t i = 0; i < m_Items.size(); i++)
+		delete m_Items[i];
+
+	unregisterSPForward(this->func);
+	
+	m_Items.clear();
+}
+
+menuitem *Menu::AddItem(const char *name, const char *cmd, int access)
+{
+	menuitem *pItem = new menuitem;
+
+	pItem->name.assign(name);
+	pItem->cmd.assign(cmd);
+	pItem->access = access;
+	pItem->id = m_Items.size();
+	pItem->handler = -1;
+	pItem->pfn = NULL;
+
+	m_Items.push_back(pItem);
+
+	return pItem;
+}
+
+menuitem *Menu::GetMenuItem(item_t item)
+{
+	if (item >= m_Items.size())
+		return NULL;
+
+	return m_Items[item];
+}
+
+size_t Menu::GetItemCount()
+{
+	return m_Items.size();
+}
+
+size_t Menu::GetPageCount()
+{
+	size_t items = GetItemCount();
+	if (items_per_page == 0)
+		return 1;
+
+	return ((items/items_per_page) + ((items % items_per_page) ? 1 : 0));
+}
+
+int Menu::PagekeyToItem(page_t page, item_t key)
+{
+	size_t start = page * items_per_page;
+	size_t num_pages = GetPageCount();
+
+	if (num_pages == 1 || !items_per_page)
+	{
+		if (m_AlwaysExit && key > m_Items.size())
+			return MENU_EXIT;
+		else
+			return key-1;
+	} else {
+		//first page
+		if (page == 0)
+		{
+			if (key == items_per_page + 1)
+				return MENU_MORE;
+			else if (key == items_per_page + 2)
+				return MENU_EXIT;
+			else
+				return (start + key - 1);
+		} else if (page == num_pages - 1) {
+			//last page
+			size_t remaining = m_Items.size() - start;
+			if (key == remaining + 1)
+			{
+				return MENU_BACK;
+			} else if (key == remaining + 2) {
+				return MENU_EXIT;
+			} else {
+				return (start + key - 1);
+			}
+		} else {
+			if (key > items_per_page && (key-items_per_page<=3))
+			{
+				return m_OptOrders[key-items_per_page-1];
+			} else {
+				return (start + key - 1);
+			}
+		}
+	}
+}
+
+bool Menu::Display(int player, page_t page)
+{
+	int keys = 0;
+	const char *str = GetTextString(player, page, keys);
+
+	if (!str)
+		return false;
+
+	static char buffer[2048];
+	int len = _snprintf(buffer, sizeof(buffer)-1, "%s", str);
+
+	CPlayer *pPlayer = GET_PLAYER_POINTER_I(player);
+
+	pPlayer->keys = keys;
+	pPlayer->menu = menuId;
+	pPlayer->newmenu = thisId;
+	pPlayer->page = (int)page;
+
+	UTIL_ShowMenu(pPlayer->pEdict, keys, -1, buffer, len);
+
+	return true;
+}
+
+const char *Menu::GetTextString(int player, page_t page, int &keys)
+{
+	page_t pages = GetPageCount();
+	item_t numItems = GetItemCount();
+
+	if (page >= pages)
+		return NULL;
+
+	m_Text.clear();
+
+	char buffer[255];
+	if (items_per_page && (pages != 1))
+	{
+		if (m_AutoColors)
+			_snprintf(buffer, sizeof(buffer)-1, "\\y%s %d/%d\n\\w\n", m_Title.c_str(), page + 1, pages);
+		else
+			_snprintf(buffer, sizeof(buffer)-1, "%s %d/%d\n\n", m_Title.c_str(), page + 1, pages);
+	} else {
+		if (m_AutoColors)
+			_snprintf(buffer, sizeof(buffer)-1, "\\y%s\n\\w\n", m_Title.c_str());
+		else
+			_snprintf(buffer, sizeof(buffer)-1, "%s\n\n", m_Title.c_str());
+	}
+	
+	m_Text.append(buffer);
+
+	enum
+	{
+		Display_Back = (1<<0),
+		Display_Next = (1<<1),
+		Display_Exit = (1<<2),
+	};
+
+	int flags = Display_Back|Display_Next;
+	item_t start = page * items_per_page;
+	item_t end = 0;
+	if (items_per_page)
+	{
+		if (start + items_per_page >= numItems)
+		{
+			end = numItems - 1;
+			flags &= ~Display_Next;
+		} else {
+			end = start + items_per_page - 1;
+		}
+		if (!m_NeverExit && (m_AlwaysExit || (page == 0 || page == pages-1)))
+			flags |= Display_Exit;
+	} else {
+		end = numItems - 1;
+		if (end > 10)
+			end = 10;
+		flags = 0;
+	}
+
+	if (page == 0)
+		flags &= ~Display_Back;
+	
+	menuitem *pItem = NULL;
+	
+	int option = 0;
+	keys = 0;
+	bool enabled = true;
+	int ret = 0;
+	int slots = 0;
+	
+	for (item_t i = start; i <= end; i++)
+	{
+		pItem = m_Items[i];
+		
+		if (pItem->access && !(pItem->access & g_players[player].flags[0]))
+			enabled = false;
+		
+		if (pItem->handler != -1)
+		{
+			ret = executeForwards(pItem->handler, static_cast<cell>(player), static_cast<cell>(thisId), static_cast<cell>(i));
+			if (ret == ITEM_ENABLED)
+				enabled = true;
+			else if (ret == ITEM_DISABLED)
+				enabled = false;
+		}
+		
+		if (pItem->pfn)
+		{
+			ret = (pItem->pfn)(player, thisId, i);
+			if (ret == ITEM_ENABLED)
+				enabled = true;
+			else if (ret == ITEM_DISABLED)
+				enabled = false;
+		}
+		
+		if (enabled)
+		{
+			keys |= (1<<option);
+			if (m_AutoColors) 
+				_snprintf(buffer, sizeof(buffer)-1, "\\r%d.\\w %s\n", ++option, pItem->name.c_str());
+			else
+				_snprintf(buffer, sizeof(buffer)-1, "%d. %s\n", ++option, pItem->name.c_str());
+		} else {
+			if (m_AutoColors)
+			{
+				_snprintf(buffer, sizeof(buffer)-1, "\\d%d. %s\n\\w", ++option, pItem->name.c_str());
+			} else {
+				_snprintf(buffer, sizeof(buffer)-1, "#. %s\n", pItem->name.c_str());
+				option++;
+			}
+		}
+		slots++;
+
+		m_Text.append(buffer);
+
+		//attach blanks
+		if (pItem->blanks.size())
+		{
+			for (size_t j=0; j<pItem->blanks.size(); j++)
+			{
+				if (pItem->blanks[j] == 1)
+					option++;
+				m_Text.append("\n");
+				slots++;
+			}
+		}
+	}
+
+	if (padding == 1 && items_per_page)
+	{
+		int pad = items_per_page;
+		if (flags & Display_Back)
+			pad--;
+		if (flags & Display_Next)
+			pad--;
+		if (flags & Display_Exit)
+			pad--;
+		for (int i=slots+1; i<=pad; i++)
+		{
+			m_Text.append("\n");
+			option++;
+		}
+	}
+
+	for (int i=0; i<3; i++)
+	{
+		switch (m_OptOrders[i])
+		{
+		case MENU_BACK:
+			{
+				if (flags & Display_Back)
+				{
+					keys |= (1<<option++);
+					_snprintf(buffer, 
+						sizeof(buffer)-1, 
+						m_AutoColors ? "\\r%d. \\w%s\n" : "%d. %s\n", 
+						option, 
+						m_OptNames[abs(MENU_BACK)].c_str()
+						);
+					m_Text.append(buffer);
+				}
+				break;
+			}
+		case MENU_MORE:
+			{
+				if (flags & Display_Next)
+				{
+					keys |= (1<<option++);
+					_snprintf(buffer, 
+						sizeof(buffer)-1, 
+						m_AutoColors ? "\\r%d. \\w%s\n" : "%d. %s\n", 
+						option, 
+						m_OptNames[abs(MENU_MORE)].c_str()
+						);
+					m_Text.append(buffer);
+				}
+				break;
+			}
+		case MENU_EXIT:
+			{
+				if (flags & Display_Exit)
+				{
+					keys |= (1<<option++);
+					_snprintf(buffer, 
+						sizeof(buffer)-1, 
+						m_AutoColors ? "\\r%d. \\w%s\n" : "%d. %s\n", 
+						option, 
+						m_OptNames[abs(MENU_EXIT)].c_str()
+						);
+					m_Text.append(buffer);
+				}
+				break;
+			}
+		}
+	}
+	
+	return m_Text.c_str();
+}
+
+#define GETMENU(p) if (p >= (int)g_NewMenus.size() || p < 0 || !g_NewMenus[p] || g_NewMenus[p]->isDestroying) { \
+	LogError(amx, AMX_ERR_NATIVE, "Invalid menu id %d(%d)", p, g_NewMenus.size()); \
+	return 0; } \
+	Menu *pMenu = g_NewMenus[p];
+
+//Makes a new menu handle (-1 for failure)
+//native csdm_makemenu(title[]);
+static cell AMX_NATIVE_CALL menu_create(AMX *amx, cell *params)
+{
+	int len;
+	char *title = get_amxstring(amx, params[1], 0, len);
+	validate_menu_text(title);
+	char *handler = get_amxstring(amx, params[2], 1, len);
+
+	int func = registerSPForwardByName(amx, handler, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+	
+	if (func == -1)
+	{
+		LogError(amx, AMX_ERR_NOTFOUND, "Invalid function \"%s\"", handler);
+		return 0;
+	}
+
+	int id = g_menucmds.registerMenuId(title, amx);
+	g_menucmds.registerMenuCmd(g_plugins.findPluginFast(amx), id, 1023, func);
+
+	Menu *pMenu = new Menu(title, id, 0);
+
+	pMenu->func = func;
+
+	if (g_MenuFreeStack.empty())
+	{
+		g_NewMenus.push_back(pMenu);
+		pMenu->thisId = (int)g_NewMenus.size() - 1;
+		return (int)g_NewMenus.size() - 1;
+	} else {
+		int pos = g_MenuFreeStack.front();
+		g_MenuFreeStack.pop();
+		g_NewMenus[pos] = pMenu;
+		pMenu->thisId = pos;
+		return pos;
+	}
+}
+
+static cell AMX_NATIVE_CALL menu_addblank(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+
+	if (params[2] && (!pMenu->items_per_page && pMenu->GetItemCount() >= 10))
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Non-paginated menus are limited to 10 items.");
+		return 0;
+	}
+
+	if (!pMenu->m_Items.size())
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Blanks can only be added after items.");
+		return 0;
+	}
+
+	menuitem *item = pMenu->m_Items[pMenu->m_Items.size() - 1];
+	item->blanks.push_back(params[2]);
+
+	return 1;
+}
+
+//Adds an item to the menu (returns current item count - 1)
+//native menu_additem(menu, const name[], const command[]="", access=0);
+static cell AMX_NATIVE_CALL menu_additem(AMX *amx, cell *params)
+{
+	int len;
+	char *name, *cmd;
+	int access;
+
+	GETMENU(params[1]);
+
+	if (!pMenu->items_per_page && pMenu->GetItemCount() >= 10)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Non-paginated menus are limited to 10 items.");
+		return 0;
+	}
+
+	name = get_amxstring(amx, params[2], 0, len);
+	validate_menu_text(name);
+	cmd = get_amxstring(amx, params[3], 1, len);
+	access = params[4];
+
+	menuitem *pItem = pMenu->AddItem(name, cmd, access);
+
+	pItem->handler = params[5];
+
+	return 1;
+}
+
+//Returns the number of pages in a menu
+//native csdm_menu_pages(menu);
+static cell AMX_NATIVE_CALL menu_pages(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+	return pMenu->GetPageCount();
+}
+
+//Returns the number of items in a menu
+//native csdm_menu_items(menu);
+static cell AMX_NATIVE_CALL menu_items(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+
+	return pMenu->GetItemCount();
+}
+
+//Builds the menu string for a specific page (set title to 0 to not include title)
+//page indices start at 0!
+static cell AMX_NATIVE_CALL menu_display(AMX *amx, cell *params)
+{
+	GETMENU(params[2]);
+	
+	int player = params[1];
+	int page = params[3];
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(player);
+	
+	// This will set the expire time of the menu to infinite
+	pPlayer->menuexpire = INFINITE;
+
+	return pMenu->Display(player, page);
+}
+
+//Finds the id of a menu item for a specific page and key value.
+//Note that key should be from 0-6, as it only displays 7 per page.
+//page indices start at 0
+//native menu_keyid(menu, page, key);
+static cell AMX_NATIVE_CALL menu_find_id(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+
+	page_t page = static_cast<page_t>(params[2]);
+	item_t key = static_cast<item_t>(params[3]);
+
+	return pMenu->PagekeyToItem(page, key);
+}
+
+//Gets info about a menu option
+//native menu_item_getinfo(menu, item, &access, command[], cmdlen, name[]="", namelen=0, &callback);
+static cell AMX_NATIVE_CALL menu_item_getinfo(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+
+	menuitem *pItem = pMenu->GetMenuItem(static_cast<item_t>(params[2]));
+
+	if (!pItem)
+		return 0;
+
+	cell *addr = get_amxaddr(amx, params[3]);
+	addr[0] = pItem->access;
+
+	set_amxstring(amx, params[4], pItem->cmd.c_str(), params[5]);
+	set_amxstring(amx, params[6], pItem->name.c_str(), params[7]);
+
+	if (params[8])
+	{
+		addr = get_amxaddr(amx, params[8]);
+		if (addr)
+			addr[0] = pItem->handler;
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL menu_makecallback(AMX *amx, cell *params)
+{
+	int len;
+	char *name = get_amxstring(amx, params[1], 0, len);
+
+	int id = registerSPForwardByName(amx, name, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+
+	if (id == -1)
+	{
+		LogError(amx, AMX_ERR_NOTFOUND, "Invalid function %s", name);
+		return -1;
+	}
+
+	return id;
+}
+
+static cell AMX_NATIVE_CALL menu_item_setname(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+
+	menuitem *pItem = pMenu->GetMenuItem(static_cast<item_t>(params[2]));
+
+	if (!pItem)
+		return 0;
+
+	int len;
+	char *name;
+
+	name = get_amxstring(amx, params[3], 0, len);
+
+	pItem->name.assign(name);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL menu_item_setcmd(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+
+	menuitem *pItem = pMenu->GetMenuItem(static_cast<item_t>(params[2]));
+
+	if (!pItem)
+		return 0;
+
+	int len;
+	char *cmd;
+
+	cmd = get_amxstring(amx, params[3], 0, len);
+
+	pItem->cmd.assign(cmd);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL menu_item_setcall(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+
+	menuitem *pItem = pMenu->GetMenuItem(static_cast<item_t>(params[2]));
+
+	if (!pItem)
+		return 0;
+
+	pItem->handler = params[3];
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL menu_setprop(AMX *amx, cell *params)
+{
+	GETMENU(params[1]);
+
+	int len = params[0] / sizeof(cell);
+	if (len < 3)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Expected 3 parameters");
+		return 0;
+	}
+
+	switch (params[2])
+	{
+	case MPROP_PERPAGE:
+		{
+			cell count = *get_amxaddr(amx, params[3]);
+			if (count < 0 || count > 7)
+			{
+				LogError(amx, AMX_ERR_NATIVE, "Cannot set %d items per page", count);
+				return 0;
+			}
+			pMenu->items_per_page = count;
+			break;
+		}
+	case MPROP_BACKNAME:
+		{
+			char *str = get_amxstring(amx, params[3], 0, len);
+			validate_menu_text(str);
+			pMenu->m_OptNames[abs(MENU_BACK)].assign(str);
+			break;
+		}
+	case MPROP_NEXTNAME:
+		{
+			char *str = get_amxstring(amx, params[3], 0, len);
+			validate_menu_text(str);
+			pMenu->m_OptNames[abs(MENU_MORE)].assign(str);
+			break;
+		}
+	case MPROP_EXITNAME:
+		{
+			char *str = get_amxstring(amx, params[3], 0, len);
+			validate_menu_text(str);
+			pMenu->m_OptNames[abs(MENU_EXIT)].assign(str);
+			break;
+		}
+	case MPROP_TITLE:
+		{
+			char *str = get_amxstring(amx, params[3], 0, len);
+			int old = pMenu->menuId;
+			g_menucmds.removeMenuId(old);
+			pMenu->m_Title.assign(str);
+			pMenu->menuId = g_menucmds.registerMenuId(str, amx);
+			g_menucmds.registerMenuCmd(
+				g_plugins.findPluginFast(amx),
+				pMenu->menuId,
+				1023,
+				pMenu->func);
+			CPlayer *pl;
+			/**
+			 * NOTE - this is actually bogus
+			 *  the client's screen won't actually match the cmd here 
+			 *  I think, this scenario needs to be tested. 
+			 */
+			for (int i=1; i<=gpGlobals->maxClients; i++)
+			{
+				pl = GET_PLAYER_POINTER_I(i);
+				if (pl->menu == old)
+					pl->menu = pMenu->menuId;
+			}
+			break;
+		}
+	case MPROP_EXITALL:
+		{
+			cell ans = *get_amxaddr(amx, params[3]);
+			if (ans == 1)
+			{
+				pMenu->m_AlwaysExit = true;
+				pMenu->m_NeverExit = false;
+			} else if (ans == 0) {
+				pMenu->m_AlwaysExit = false;
+				pMenu->m_NeverExit = false;
+			} else if (ans == -1) {
+				pMenu->m_NeverExit = true;
+				pMenu->m_AlwaysExit = false;
+			}
+			break;
+		}
+	case MPROP_ORDER:
+		{
+			cell *addr = get_amxaddr(amx, params[3]);
+			pMenu->m_OptOrders[0] = addr[0];
+			pMenu->m_OptOrders[1] = addr[1];
+			pMenu->m_OptOrders[2] = addr[2];
+			break;
+		}
+	case MPROP_NOCOLORS:
+		{
+			pMenu->m_AutoColors = *get_amxaddr(amx, params[3]) ? true : false;
+			break;
+		}
+	case MPROP_PADMENU:
+		{
+			pMenu->padding = *get_amxaddr(amx, params[3]);
+			break;
+		}
+	default:
+		{
+			LogError(amx, AMX_ERR_NATIVE, "Invalid menu setting: %d", params[1]);
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+#define GETMENU_R(p) if (p >= (int)g_NewMenus.size() || p < 0 || !g_NewMenus[p]) { \
+	LogError(amx, AMX_ERR_NATIVE, "Invalid menu id %d(%d)", p, g_NewMenus.size()); \
+	return 0; } \
+	Menu *pMenu = g_NewMenus[p];
+
+static cell AMX_NATIVE_CALL menu_cancel(AMX *amx, cell *params)
+{
+	int index = params[1];
+
+	if (index < 1 || index > gpGlobals->maxClients)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Player %d is not valid", index);
+		return 0;
+	}
+
+	CPlayer *player = GET_PLAYER_POINTER_I(index);
+	if (!player->ingame)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Played %d is not in game", index);
+		return 0;
+	}
+
+	int menu = player->newmenu;
+	if (menu < 0 || menu >= (int)g_NewMenus.size() || !g_NewMenus[menu])
+		return 0;
+
+	Menu *pMenu = g_NewMenus[menu];
+
+	player->newmenu = -1;
+	player->menu = 0;
+	executeForwards(pMenu->func, 
+		static_cast<cell>(index),
+		static_cast<cell>(pMenu->thisId),
+		static_cast<cell>(MENU_EXIT));
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL menu_destroy(AMX *amx, cell *params)
+{
+	GETMENU_R(params[1]);
+
+	if (pMenu->isDestroying)
+		return 0;	//prevent infinite recursion
+
+	pMenu->isDestroying = true;
+	g_menucmds.removeMenuId(pMenu->menuId);
+	CPlayer *player;
+	for (int i=1; i<=gpGlobals->maxClients; i++)
+	{
+		player = GET_PLAYER_POINTER_I(i);
+		if (player->newmenu == pMenu->thisId)
+		{
+			player->newmenu = -1;
+			player->menu = 0;
+			executeForwards(pMenu->func, 
+				static_cast<cell>(i), 
+				static_cast<cell>(pMenu->thisId),
+				static_cast<cell>(MENU_EXIT));
+		}
+	}
+	g_NewMenus[params[1]] = NULL;
+	delete pMenu;
+	g_MenuFreeStack.push(params[1]);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL player_menu_info(AMX *amx, cell *params)
+{
+	if (params[1] < 1 || params[1] > gpGlobals->maxClients)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid player id %d", params[1]);
+		return 0;
+	}
+
+	CPlayer *player = GET_PLAYER_POINTER_I(params[1]);
+	if (!player->ingame)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Player %d is not ingame", params[1]);
+		return 0;
+	}
+
+	cell *m = get_amxaddr(amx, params[2]);
+	cell *n = get_amxaddr(amx, params[3]);
+
+	*m = player->menu;
+	*n = player->newmenu;
+
+	if ( (*m != 0 && *m != -1) || (*n != -1))
+		return 1;
+
+	return 0;
+}
+
+AMX_NATIVE_INFO g_NewMenuNatives[] = 
+{
+	{"menu_create",				menu_create},
+	{"menu_additem",			menu_additem},
+	{"menu_addblank",			menu_addblank},
+	{"menu_pages",				menu_pages},
+	{"menu_items",				menu_items},
+	{"menu_display",			menu_display},
+	{"menu_find_id",			menu_find_id},
+	{"menu_item_getinfo",		menu_item_getinfo},
+	{"menu_makecallback",		menu_makecallback},
+	{"menu_item_setcall",		menu_item_setcall},
+	{"menu_item_setcmd",		menu_item_setcmd},
+	{"menu_item_setname",		menu_item_setname},
+	{"menu_destroy",			menu_destroy},
+	{"menu_setprop",			menu_setprop},
+	{"menu_cancel",				menu_cancel},
+	{"player_menu_info",		player_menu_info},
+	{NULL,						NULL},
+};

amxmodx/newmenus.h

@@ -0,0 +1,115 @@
+/* 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_BACK		-2
+#define	MENU_MORE		-1
+#define	ITEM_IGNORE		0
+#define	ITEM_ENABLED	1
+#define ITEM_DISABLED	2
+
+
+#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
+
+typedef int (*MENUITEM_CALLBACK)(int, int, int);
+
+struct menuitem
+{
+	String name;
+	String cmd;
+	
+	int access;
+	int handler;
+	
+	MENUITEM_CALLBACK pfn;
+	size_t id;
+
+	CVector<int> blanks;
+};
+
+typedef unsigned int menu_t;
+typedef unsigned int item_t;
+typedef unsigned int page_t;
+
+class Menu
+{
+public:
+	Menu(const char *title, int menuId, int thisId);
+	~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();
+public:
+	CVector<menuitem * > m_Items;
+	String m_Title;
+	String m_Text;
+
+	String m_OptNames[4];
+	int m_OptOrders[3];
+
+	bool m_AlwaysExit;
+	bool m_NeverExit;
+	bool m_AutoColors;
+	
+	int menuId;
+	int thisId;
+	int func;
+	int padding;
+	bool isDestroying;
+public:
+	unsigned int items_per_page;
+};
+
+void ClearMenus();
+
+extern CVector<Menu *> g_NewMenus;
+extern AMX_NATIVE_INFO g_NewMenuNatives[];
+
+#endif //_INCLUDE_NEWMENUS_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

amxmodx/power.cpp

@@ -6,6 +6,7 @@
  *  This file may be freely used. No warranties of any kind.
  */
 
+#include <stdlib.h>
 // this file does not include amxmodx.h, so we have to include the memory manager here
 #ifdef MEMORY_TEST
 #include "mmgr/mmgr.h"

amxmodx/sclinux.h

@@ -20,6 +20,13 @@
 #define	stricmp(a,b)    strcasecmp(a,b)
 #define	strnicmp(a,b,c) strncasecmp(a,b,c)
 
+#if defined __linux__  && !defined _snprintf 
+#define _snprintf snprintf
+#endif 
+#if defined __linux__  && !defined _vsnprintf
+//#define _vsnprintf vsnprintf
+#endif
+
 /*
  * WinWorld wants '\'. Unices do not.
  */

amxmodx/sdk/amxxmodule.cpp

@@ -45,8 +45,6 @@
 enginefuncs_t g_engfuncs;
 globalvars_t  *gpGlobals;
 
-
-
 DLL_FUNCTIONS *g_pFunctionTable;
 DLL_FUNCTIONS *g_pFunctionTable_Post;
 enginefuncs_t *g_pengfuncsTable;
@@ -54,7 +52,6 @@ enginefuncs_t *g_pengfuncsTable_Post;
 NEW_DLL_FUNCTIONS *g_pNewFunctionsTable;
 NEW_DLL_FUNCTIONS *g_pNewFunctionsTable_Post;
 
-
 // GetEntityAPI2 functions
 static DLL_FUNCTIONS g_EntityAPI_Table = 
 {
@@ -2421,9 +2418,6 @@ C_DLLEXPORT void __stdcall GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine,
 
 /************* AMXX Stuff *************/
 
-// *** Types ***
-typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
-
 // *** Globals ***
 // Module info
 static amxx_module_info_s g_ModuleInfo = 
@@ -2432,15 +2426,17 @@ static amxx_module_info_s g_ModuleInfo =
 	MODULE_AUTHOR,
 	MODULE_VERSION,
 #ifdef MODULE_RELOAD_ON_MAPCHANGE
-	1
+	1,
 #else // MODULE_RELOAD_ON_MAPCHANGE
-	0
+	0,
 #endif // MODULE_RELOAD_ON_MAPCHANGE
+	MODULE_LOGTAG
 };
 
 // Storage for the requested functions
 PFN_ADD_NATIVES				g_fn_AddNatives;
 PFN_BUILD_PATHNAME			g_fn_BuildPathname;
+PFN_BUILD_PATHNAME_R		g_fn_BuildPathnameR;
 PFN_GET_AMXADDR				g_fn_GetAmxAddr;
 PFN_PRINT_SRVCONSOLE		g_fn_PrintSrvConsole;
 PFN_GET_MODNAME				g_fn_GetModname;
@@ -2482,9 +2478,11 @@ PFN_IS_PLAYER_CONNECTING	g_fn_IsPlayerConnecting;
 PFN_IS_PLAYER_HLTV			g_fn_IsPlayerHLTV;
 PFN_GET_PLAYER_ARMOR		g_fn_GetPlayerArmor;
 PFN_GET_PLAYER_HEALTH		g_fn_GetPlayerHealth;
+#ifdef MEMORY_TEST
 PFN_ALLOCATOR				g_fn_Allocator;
 PFN_REALLOCATOR				g_fn_Reallocator;
 PFN_DEALLOCATOR				g_fn_Deallocator;
+#endif
 PFN_AMX_EXEC				g_fn_AmxExec;
 PFN_AMX_EXECV				g_fn_AmxExecv;
 PFN_AMX_ALLOT				g_fn_AmxAllot;
@@ -2501,6 +2499,13 @@ PFN_AMX_FINDNATIVE			g_fn_AmxFindNative;
 PFN_GETPLAYERFLAGS			g_fn_GetPlayerFlags;
 PFN_GET_PLAYER_EDICT		g_fn_GetPlayerEdict;
 PFN_FORMAT					g_fn_Format;
+PFN_REGISTERFUNCTION		g_fn_RegisterFunction;
+PFN_REQ_FNPTR				g_fn_RequestFunction;
+PFN_AMX_PUSH				g_fn_AmxPush;
+PFN_SET_TEAM_INFO			g_fn_SetTeamInfo;
+PFN_PLAYER_PROP_ADDR		g_fn_PlayerPropAddr;
+PFN_REG_AUTH_FUNC			g_fn_RegAuthFunc;
+PFN_UNREG_AUTH_FUNC			g_fn_UnregAuthFunc;
 
 // *** Exports ***
 C_DLLEXPORT int AMXX_Query(int *interfaceVersion, amxx_module_info_s *moduleInfo)
@@ -2538,15 +2543,19 @@ C_DLLEXPORT int AMXX_Attach(PFN_REQ_FNPTR reqFnptrFunc)
 	if (!reqFnptrFunc)
 		return AMXX_PARAM;
 
+	g_fn_RequestFunction = reqFnptrFunc;
+
 	// Req all known functions
 	// Misc
 	REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME);
+	REQFUNC("BuildPathnameR", g_fn_BuildPathnameR, PFN_BUILD_PATHNAME_R);
 	REQFUNC("PrintSrvConsole", g_fn_PrintSrvConsole, PFN_PRINT_SRVCONSOLE);
 	REQFUNC("GetModname", g_fn_GetModname, PFN_GET_MODNAME);
 	REQFUNC("Log", g_fn_Log, PFN_LOG);
 	REQFUNC("LogError", g_fn_LogErrorFunc, PFN_LOG_ERROR);
 	REQFUNC("MergeDefinitionFile", g_fn_MergeDefinition_File, PFN_MERGEDEFINITION_FILE);
 	REQFUNC("Format", g_fn_Format, PFN_FORMAT);
+	REQFUNC("RegisterFunction", g_fn_RegisterFunction, PFN_REGISTERFUNCTION);
 
 	// Amx scripts
 	REQFUNC("GetAmxScript", g_fn_GetAmxScript, PFN_GET_AMXSCRIPT);
@@ -2605,11 +2614,18 @@ C_DLLEXPORT int AMXX_Attach(PFN_REQ_FNPTR reqFnptrFunc)
 	REQFUNC("GetPlayerHealth", g_fn_GetPlayerHealth, PFN_GET_PLAYER_HEALTH);
 	REQFUNC("GetPlayerFlags", g_fn_GetPlayerFlags, PFN_GETPLAYERFLAGS);
 	REQFUNC("GetPlayerEdict", g_fn_GetPlayerEdict, PFN_GET_PLAYER_EDICT);
+	REQFUNC("amx_Push", g_fn_AmxPush, PFN_AMX_PUSH);
+	REQFUNC("SetPlayerTeamInfo", g_fn_SetTeamInfo, PFN_SET_TEAM_INFO);
+	REQFUNC("PlayerPropAddr", g_fn_PlayerPropAddr, PFN_PLAYER_PROP_ADDR);
+	REQFUNC("RegAuthFunc", g_fn_RegAuthFunc, PFN_REG_AUTH_FUNC);
+	REQFUNC("UnregAuthFunc", g_fn_UnregAuthFunc, PFN_UNREG_AUTH_FUNC);
 
+#ifdef MEMORY_TEST
 	// Memory
 	REQFUNC_OPT("Allocator", g_fn_Allocator, PFN_ALLOCATOR);
 	REQFUNC_OPT("Reallocator", g_fn_Reallocator, PFN_REALLOCATOR);
 	REQFUNC_OPT("Deallocator", g_fn_Deallocator, PFN_DEALLOCATOR);
+#endif
 
 	REQFUNC("CellToReal", g_fn_CellToReal, PFN_CELL_TO_REAL);
 	REQFUNC("RealToCell", g_fn_RealToCell, PFN_REAL_TO_CELL);
@@ -2648,7 +2664,7 @@ void MF_Log(const char *fmt, ...)
 	vsprintf(msg, fmt, arglst);
 	va_end(arglst);
 
-	g_fn_Log("[%s] %s", MODULE_NAME, msg);
+	g_fn_Log("[%s] %s", MODULE_LOGTAG, msg);
 }
 
 void MF_LogError(AMX *amx, int err, const char *fmt, ...)
@@ -2660,7 +2676,7 @@ void MF_LogError(AMX *amx, int err, const char *fmt, ...)
 	vsprintf(msg, fmt, arglst);
 	va_end(arglst);
 
-	g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_NAME, msg);
+	g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_LOGTAG, msg);
 }
 
 
@@ -2670,6 +2686,7 @@ void MF_LogError(AMX *amx, int err, const char *fmt, ...)
 void ValidateMacros_DontCallThis_Smiley()
 {
 	MF_BuildPathname("str", "str", 0);
+	MF_BuildPathnameR(NULL, 0, "%d", 0);
 	MF_FormatAmxString(NULL, 0, 0, NULL);
 	MF_GetAmxAddr(NULL, 0);
 	MF_PrintSrvConsole("str", "str", 0);
@@ -2711,7 +2728,7 @@ void ValidateMacros_DontCallThis_Smiley()
 	MF_IsPlayerHLTV(0);
 	MF_GetPlayerArmor(0);
 	MF_GetPlayerHealth(0);
-	MF_AmxExec(0, 0, 0, 0);
+	MF_AmxExec(0, 0, 0);
 	MF_AmxExecv(0, 0, 0, 0, 0);
 	MF_AmxFindPublic(0, 0, 0);
 	MF_AmxAllot(0, 0, 0, 0);
@@ -2723,9 +2740,16 @@ void ValidateMacros_DontCallThis_Smiley()
 	MF_GetPlayerFrags(0);
 	MF_GetPlayerEdict(0);
 	MF_Format("", 4, "str");
+	MF_RegisterFunction(NULL, "");
+	MF_SetPlayerTeamInfo(0, 0, "");
+	MF_PlayerPropAddr(0, 0);
+	MF_RegAuthFunc(NULL);
+	MF_UnregAuthFunc(NULL);
 }
 #endif
 
+#ifdef MEMORY_TEST
+
 /************* MEMORY *************/
 // undef all defined macros
 #undef new
@@ -2897,6 +2921,30 @@ void	operator delete[](void *reportedAddress)
 	Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete_array, reportedAddress);
 }
 
+#else
+
+#if !defined NO_ALLOC_OVERRIDES && !defined MEMORY_TEST && !defined WIN32
+void * operator new(size_t size) {
+	return(calloc(1, size)); 
+}
+
+void * operator new[](size_t size) {
+	return(calloc(1, size)); 
+}
+
+void operator delete(void * ptr) {
+	if(ptr)
+		free(ptr);
+}
+
+void operator delete[](void * ptr) {
+	if(ptr)
+		free(ptr);
+}
+#endif
+
+#endif //MEMORY_TEST
+
 /************* stuff from dlls/util.cpp *************/
 //				must come here because cbase.h declares it's own operator new
 

amxmodx/sdk/amxxmodule.h

@@ -31,8 +31,10 @@
 
 // ***** AMXX stuff *****
 
-// module interface version is 1
-#define AMXX_INTERFACE_VERSION 1
+// module interface version was 1
+// 2 - added logtag to struct (amxx1.1-rc1)
+// 3 - added new tagAMX structure (amxx1.5)
+#define AMXX_INTERFACE_VERSION 3
 
 // amxx module info
 struct amxx_module_info_s
@@ -41,10 +43,9 @@ struct amxx_module_info_s
 	const char *author;
 	const char *version;
 	int reload;				// reload on mapchange when nonzero
+	const char *logtag;		// added in version 2
 };
 
-
-
 // return values from functions called by amxx
 #define AMXX_OK					0			/* no error */
 #define AMXX_IFVERS				1			/* interface version */
@@ -53,15 +54,26 @@ struct amxx_module_info_s
 
 // *** Small stuff ***
 // The next section is copied from the amx.h file
-// Copyright (c) ITB CompuPhase, 1997-2004
+// Copyright (c) ITB CompuPhase, 1997-2005
 
-#if defined __LCC__ || defined __DMC__ || defined __linux__ || defined __GNUC__
+#if defined HAVE_STDINT_H
   #include <stdint.h>
-#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+#else
+  #if defined __LCC__ || defined __DMC__ || defined LINUX
+    #if defined HAVE_INTTYPES_H
+      #include <inttypes.h>
+    #else
+      #include <stdint.h>
+    #endif
+  #elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
     /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
      * here, these types are probably undefined.
      */
-  #if defined __FreeBSD__
+    #if defined __MACH__
+      #include <ppc/types.h>
+      typedef unsigned short int  uint16_t;
+      typedef unsigned long int   uint32_t;
+    #elif defined __FreeBSD__
       #include <inttypes.h>
     #else
       typedef short int           int16_t;
@@ -83,8 +95,14 @@ struct amxx_module_info_s
         #define HAVE_I64
       #endif
     #endif
+  #endif
+  #define HAVE_STDINT_H
+#endif
+#if defined _LP64 || defined WIN64 || defined _WIN64
+  #if !defined __64BIT__
+    #define __64BIT__
+  #endif
 #endif
-
 
 /* calling convention for native functions */
 #if !defined AMX_NATIVE_CALL
@@ -104,24 +122,26 @@ struct amxx_module_info_s
   #define AMXEXPORT
 #endif
 
-
-
-#if !defined SMALL_CELL_SIZE
-  #define SMALL_CELL_SIZE 32    /* by default, use 32-bit cells */
+#if !defined PAWN_CELL_SIZE
+  #define PAWN_CELL_SIZE 32     /* by default, use 32-bit cells */
 #endif
-#if SMALL_CELL_SIZE==32
+#if PAWN_CELL_SIZE==16
+  typedef uint16_t  ucell;
+  typedef int16_t   cell;
+#elif PAWN_CELL_SIZE==32
   typedef uint32_t  ucell;
   typedef int32_t   cell;
-  typedef float		REAL;
-#elif SMALL_CELL_SIZE==64
+#define REAL	float
+#elif PAWN_CELL_SIZE==64
   typedef uint64_t  ucell;
   typedef int64_t   cell;
-  typedef double	REAL;
+#define REAL	double
 #else
-  #error Unsupported cell size (SMALL_CELL_SIZE)
+  #error Unsupported cell size (PAWN_CELL_SIZE)
 #endif
 
 #define UNPACKEDMAX   ((1 << (sizeof(cell)-1)*8) - 1)
+#define UNLIMITED     (~1u >> 1)
 
 struct tagAMX;
 typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params);
@@ -139,21 +159,24 @@ typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
 #endif
 
 
-#if defined SN_TARGET_PS2 || defined __GNUC__
+/* Some compilers do not support the #pragma align, which should be fine. Some
+ * compilers give a warning on unknown #pragmas, which is not so fine...
+ */
+#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN
   #define AMX_NO_ALIGN
 #endif
 
-
 #if defined __GNUC__
   #define PACKED        __attribute__((packed))
 #else
   #define PACKED
 #endif
 
-
 #if !defined AMX_NO_ALIGN
-  #if defined __linux__
+  #if defined LINUX || defined __FreeBSD__
     #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #elif defined MACOS && defined __MWERKS__
+	#pragma options align=mac68k
   #else
     #pragma pack(push)
     #pragma pack(1)         /* structures must be packed (byte-aligned) */
@@ -174,7 +197,7 @@ typedef struct {
  * fields are valid at all times; many fields are cached in local variables.
  */
 typedef struct tagAMX {
-  unsigned char _FAR *base PACKED; /* points to the AMX header ("amxhdr") plus the code, optionally also the data */
+  unsigned char _FAR *base PACKED; /* points to the AMX header plus the code, optionally also the data */
   unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */
   AMX_CALLBACK callback PACKED;
   AMX_DEBUG debug       PACKED; /* debug callback */
@@ -186,18 +209,15 @@ typedef struct tagAMX {
   cell stk              PACKED; /* stack pointer: relative to base + amxhdr->dat */
   cell stp              PACKED; /* top of the stack: relative to base + amxhdr->dat */
   int flags             PACKED; /* current status, see amx_Flags() */
-  /* for assertions and debug hook */
-  cell curline          PACKED;
-  cell curfile          PACKED;
-  int dbgcode           PACKED;
-  cell dbgaddr          PACKED;
-  cell dbgparam         PACKED;
-  char _FAR *dbgname    PACKED;
   /* user data */
   long usertags[AMX_USERNUM] PACKED;
+  //okay userdata[3] in AMX Mod X is for the CPlugin * pointer
+  //we're also gonna set userdata[2] to a special debug structure
   void _FAR *userdata[AMX_USERNUM] PACKED;
   /* native functions can raise an error */
   int error             PACKED;
+  /* passing parameters requires a "count" field */
+  int paramcount;
   /* the sleep opcode needs to store the full AMX status */
   cell pri              PACKED;
   cell alt              PACKED;
@@ -207,7 +227,7 @@ typedef struct tagAMX {
   /* support variables for the JIT */
   int reloc_size      PACKED; /* required temporary buffer for relocations */
   long code_size      PACKED; /* estimated memory footprint of the native code */
-} AMX;
+} PACKED AMX;
 
 enum {
   AMX_ERR_NONE,
@@ -224,6 +244,7 @@ enum {
   AMX_ERR_NATIVE,       /* native function failed */
   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_MEMORY = 16,  /* out of memory */
   AMX_ERR_FORMAT,       /* invalid file format */
@@ -1883,6 +1904,9 @@ void FN_AMXX_DETACH(void);
 void FN_AMXX_PLUGINSLOADED(void);
 #endif // FN_AMXX_PLUGINSLOADED
 
+// *** Types ***
+typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
+
 // ***** Module funcs stuff *****
 enum ForwardExecType
 {
@@ -1903,9 +1927,34 @@ enum ForwardParam
 	FP_ARRAY,						// array; use the return value of prepareArray.
 };
 
+enum PlayerProp
+{
+	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
+};
+
+typedef void (*AUTHORIZEFUNC)(int player, const char *authstring);
 
 typedef int				(*PFN_ADD_NATIVES)				(const AMX_NATIVE_INFO * /*list*/);
 typedef char *			(*PFN_BUILD_PATHNAME)			(const char * /*format*/, ...);
+typedef char *			(*PFN_BUILD_PATHNAME_R)			(char * /*buffer*/, size_t /* maxlen */, const char * /* format */, ...);
 typedef cell *			(*PFN_GET_AMXADDR)				(AMX * /*amx*/, cell /*offset*/);
 typedef void			(*PFN_PRINT_SRVCONSOLE)			(char * /*format*/, ...);
 typedef const char *	(*PFN_GET_MODNAME)				(void);
@@ -1953,14 +2002,17 @@ typedef edict_t *		(*PFN_GET_PLAYER_EDICT)			(int /*id*/);
 #else
 typedef void *			(*PFN_GET_PLAYER_EDICT)			(int /*id*/);
 #endif
+typedef void *			(*PFN_PLAYER_PROP_ADDR)			(int /*id*/, int /*prop*/);
 
+#ifdef MEMORY_TEST
 typedef void *			(*PFN_ALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
 														 const unsigned int /*type*/, const size_t /*size*/);
 typedef void *			(*PFN_REALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
 														 const unsigned int /*type*/, const size_t /*size*/, void* /*addr*/ );
 typedef void			(*PFN_DEALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
 														 const unsigned int /*type*/, const void* /*addr*/ );
-typedef int				(*PFN_AMX_EXEC)					(AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, ... /*params*/);
+#endif
+typedef int				(*PFN_AMX_EXEC)					(AMX* /*amx*/, cell* /*return val*/, int /*index*/);
 typedef int				(*PFN_AMX_EXECV)				(AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, cell[] /*params*/);
 typedef int				(*PFN_AMX_ALLOT)				(AMX* /*amx*/, int /*length*/, cell* /*amx_addr*/, cell** /*phys_addr*/);
 typedef int				(*PFN_AMX_FINDPUBLIC)			(AMX* /*amx*/, char* /*func name*/, int* /*index*/);
@@ -1974,9 +2026,15 @@ typedef int				(*PFN_REGISTER_SPFORWARD_BYNAME)	(AMX * /*amx*/, const char * /*f
 typedef void			(*PFN_UNREGISTER_SPFORWARD)		(int /*id*/);
 typedef	void			(*PFN_MERGEDEFINITION_FILE)		(const char * /*filename*/);
 typedef const char *	(*PFN_FORMAT)					(const char * /*fmt*/, ... /*params*/);
+typedef void			(*PFN_REGISTERFUNCTION)			(void * /*pfn*/, const char * /*desc*/);
+typedef	int				(*PFN_AMX_PUSH)					(AMX * /*amx*/, cell /*value*/);
+typedef	int				(*PFN_SET_TEAM_INFO)			(int /*player */, int /*teamid */, const char * /*name */);
+typedef void			(*PFN_REG_AUTH_FUNC)			(AUTHORIZEFUNC);
+typedef void			(*PFN_UNREG_AUTH_FUNC)			(AUTHORIZEFUNC);
 
 extern PFN_ADD_NATIVES				g_fn_AddNatives;
 extern PFN_BUILD_PATHNAME			g_fn_BuildPathname;
+extern PFN_BUILD_PATHNAME_R			g_fn_BuildPathnameR;
 extern PFN_GET_AMXADDR				g_fn_GetAmxAddr;
 extern PFN_PRINT_SRVCONSOLE			g_fn_PrintSrvConsole;
 extern PFN_GET_MODNAME				g_fn_GetModname;
@@ -2018,7 +2076,6 @@ extern PFN_IS_PLAYER_HLTV			g_fn_IsPlayerHLTV;
 extern PFN_GET_PLAYER_ARMOR			g_fn_GetPlayerArmor;
 extern PFN_GET_PLAYER_HEALTH		g_fn_GetPlayerHealth;
 extern PFN_AMX_EXEC					g_fn_AmxExec;
-extern PFN_AMX_EXECV				g_fn_AmxExecv;
 extern PFN_AMX_ALLOT				g_fn_AmxAllot;
 extern PFN_AMX_FINDPUBLIC			g_fn_AmxFindPublic;
 extern PFN_LOAD_AMXSCRIPT			g_fn_LoadAmxScript;
@@ -2034,12 +2091,20 @@ extern PFN_GETPLAYERFLAGS		g_fn_GetPlayerFlags;
 extern PFN_GET_PLAYER_EDICT			g_fn_GetPlayerEdict;
 extern PFN_FORMAT					g_fn_Format;
 extern PFN_GET_PLAYER_TEAM			g_fn_GetPlayerTeam;
+extern PFN_REGISTERFUNCTION			g_fn_RegisterFunction;
+extern PFN_REQ_FNPTR				g_fn_RequestFunction;
+extern PFN_AMX_PUSH					g_fn_AmxPush;
+extern PFN_SET_TEAM_INFO			g_fn_SetTeamInfo;
+extern PFN_PLAYER_PROP_ADDR			g_fn_PlayerPropAddr;
+extern PFN_REG_AUTH_FUNC			g_fn_RegAuthFunc;
+extern PFN_UNREG_AUTH_FUNC			g_fn_UnregAuthFunc;
 
 #ifdef MAY_NEVER_BE_DEFINED
 // Function prototypes for intellisense and similar systems
 // They understand #if 0 so we use #ifdef MAY_NEVER_BE_DEFINED
 int				MF_AddNatives				(const AMX_NATIVE_INFO *list) { }
 char *			MF_BuildPathname			(const char * format, ...) { }
+char *			MF_BuildPathnameR			(char *buffer, size_t maxlen, const char *fmt, ...) { }
 cell *			MF_GetAmxAddr				(AMX * amx, cell offset) { }
 void			MF_PrintSrvConsole			(char * format, ...) { }
 const char *	MF_GetModname				(void) { }
@@ -2089,10 +2154,19 @@ void			MF_UnregisterSPForward		(int id) { }
 int				MF_GetPlayerFlags			(int id) { }
 edict_t*		MF_GetPlayerEdict			(int id) { }
 const char *	MF_Format					(const char *fmt, ...) { }
+void			MF_RegisterFunction			(void *pfn, const char *description) { }
+void *			MF_RequestFunction			(const char *description) { }
+int				MF_AmxPush					(AMX *amx, cell *params) { }
+int				MF_AmxExec					(AMX *amx, cell *retval, int idx) { }
+int				MF_SetPlayerTeamInfo		(int id, int teamid, const char *teamname) { }
+void *			MF_PlayerPropAddr			(int id, int prop) { }
+void			MF_RegAuthFunc				(AUTHORIZEFUNC fn) { }
+void			MF_UnregAuthFunc			(AUTHORIZEFUNC fn) { }
 #endif	// MAY_NEVER_BE_DEFINED
 
 #define MF_AddNatives g_fn_AddNatives
 #define MF_BuildPathname g_fn_BuildPathname
+#define MF_BuildPathnameR g_fn_BuildPathnameR
 #define MF_FormatAmxString g_fn_FormatAmxString
 #define MF_GetAmxAddr g_fn_GetAmxAddr
 #define MF_PrintSrvConsole g_fn_PrintSrvConsole
@@ -2150,7 +2224,15 @@ void MF_LogError(AMX *amx, int err, const char *fmt, ...);
 #define MF_GetPlayerFlags g_fn_GetPlayerFlags
 #define MF_GetPlayerEdict g_fn_GetPlayerEdict
 #define MF_Format g_fn_Format
+#define MF_RegisterFunction g_fn_RegisterFunction
+#define MF_RequestFunction g_fn_RequestFunction
+#define MF_AmxPush g_fn_AmxPush
+#define	MF_SetPlayerTeamInfo g_fn_SetTeamInfo
+#define MF_PlayerPropAddr g_fn_PlayerPropAddr
+#define MF_RegAuthFunc g_fn_RegAuthFunc
+#define MF_UnregAuthFunc g_fn_UnregAuthFunc
 
+#ifdef MEMORY_TEST
 /*** Memory ***/
 void	*operator new(size_t reportedSize);
 void	*operator new[](size_t reportedSize);
@@ -2194,4 +2276,6 @@ void	Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, cons
 #define	realloc(ptr,sz)	Mem_Reallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_realloc,sz,ptr)
 #define	free(ptr)	Mem_Deallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_free,ptr)
 
+#endif //MEMORY_TEST
+
 #endif // #ifndef __AMXXMODULE_H__

amxmodx/sdk/moduleconfig.h

@@ -21,13 +21,23 @@
 // metamod plugin?
 // #define USE_METAMOD
 
+// use memory manager/tester?
+// note that if you use this, you cannot construct/allocate 
+// anything before the module attached (OnAmxxAttach).
+// be careful of default constructors using new/malloc!
+// #define MEMORY_TEST
+
+// Unless you use STL or exceptions, keep this commented.
+// It allows you to compile without libstdc++.so as a dependency
+// #define NO_ALLOC_OVERRIDES
+
 // - AMXX Init functions
 // Also consider using FN_META_*
 // AMXX query
 //#define FN_AMXX_QUERY OnAmxxQuery
 // AMXX attach
 //   Do native functions init here (MF_AddNatives)
-// #define FN_AMXX_ATTACH OnAmxxAttach
+//#define FN_AMXX_ATTACH OnAmxxAttach
 // AMXX detach
 //#define FN_AMXX_DETACH OnAmxxDetach
 // All plugins loaded

amxmodx/sh_list.h

@@ -0,0 +1,290 @@
+/* ======== SourceMM ========
+* Copyright (C) 2004-2005 Metamod:Source Development Team
+* No warranties of any kind
+*
+* License: zlib/libpng
+*
+* Author(s): David "BAILOPAN" Anderson
+* ============================
+*/
+
+#ifndef _INCLUDE_SMM_LIST_H
+#define _INCLUDE_SMM_LIST_H
+
+#include <new>
+#include <malloc.h>
+
+//namespace SourceHook
+//{
+	//This class is from CSDM for AMX Mod X
+	/*
+		A circular, doubly-linked list with one sentinel node
+
+		Empty:
+			m_Head = sentinel
+			m_Head->next = m_Head;
+			m_Head->prev = m_Head;
+		One element:
+			m_Head = sentinel
+			m_Head->next = node1
+			m_Head->prev = node1
+			node1->next = m_Head
+			node1->prev = m_Head
+		Two elements:
+			m_Head = sentinel
+			m_Head->next = node1
+			m_Head->prev = node2
+			node1->next = node2
+			node1->prev = m_Head
+			node2->next = m_Head
+			node2->prev = node1
+	*/
+	template <class T>
+	class List
+	{
+	public:
+		class iterator;
+		friend class iterator;
+		class ListNode
+		{
+		public:
+			ListNode(const T & o) : obj(o) { };
+			ListNode() { };
+			T obj;
+			ListNode *next;
+			ListNode *prev;
+		};
+	private:
+		// Initializes the sentinel node.
+		// BAIL used malloc instead of new in order to bypass the need for a constructor.
+		ListNode *_Initialize()
+		{
+			ListNode *n = (ListNode *)malloc(sizeof(ListNode));
+			n->next = n;
+			n->prev = n;
+			return n;
+		}
+	public:
+		List() : m_Head(_Initialize()), m_Size(0)
+		{
+		}
+		List(const List &src) : m_Head(_Initialize()), m_Size(0)
+		{
+			iterator iter;
+			for (iter=src.begin(); iter!=src.end(); iter++)
+				push_back( (*iter) );
+		}
+		~List()
+		{
+			clear();
+
+			// Don't forget to free the sentinel
+			if (m_Head)
+			{
+				free(m_Head);
+				m_Head = NULL;
+			}
+		}
+		void push_back(const T &obj)
+		{
+			ListNode *node = new ListNode(obj);
+
+			node->prev = m_Head->prev;
+			node->next = m_Head;
+			m_Head->prev->next = node;
+			m_Head->prev = node;
+
+			m_Size++;
+		}
+		size_t size()
+		{
+			return m_Size;
+		}
+
+		void clear()
+		{
+			ListNode *node = m_Head->next;
+			ListNode *temp;
+			m_Head->next = m_Head;
+			m_Head->prev = m_Head;
+
+			// Iterate through the nodes until we find g_Head (the sentinel) again
+			while (node != m_Head)
+			{
+				temp = node->next;
+				delete node;
+				node = temp;
+			}
+			m_Size = 0;
+		}
+		bool empty()
+		{
+			return (m_Size == 0);
+		}
+		T & back()
+		{
+			return m_Head->prev->obj;
+		}
+	private:
+		ListNode *m_Head;
+		size_t m_Size;
+	public:
+		class iterator
+		{
+		friend class List;
+		public:
+			iterator()
+			{
+				m_This = NULL;
+			}
+			iterator(const List &src)
+			{
+				m_This = src.m_Head;
+			}
+			iterator(ListNode *n) : m_This(n)
+			{
+			}
+			iterator(const iterator &where)
+			{
+				m_This = where.m_This;
+			}
+			//pre decrement
+			iterator & operator--()
+			{
+				if (m_This)
+					m_This = m_This->prev;
+				return *this;
+			}
+			//post decrement
+			iterator operator--(int)
+			{
+				iterator old(*this);
+				if (m_This)
+					m_This = m_This->prev;
+				return old;
+			}	
+			
+			//pre increment
+			iterator & operator++()
+			{
+				if (m_This)
+					m_This = m_This->next;
+				return *this;
+			}
+			//post increment
+			iterator operator++(int)
+			{
+				iterator old(*this);
+				if (m_This)
+					m_This = m_This->next;
+				return old;
+			}
+			
+			const T & operator * () const
+			{
+				return m_This->obj;
+			}
+			T & operator * ()
+			{
+				return m_This->obj;
+			}
+			
+			T * operator -> ()
+			{
+				return &(m_This->obj);
+			}
+			const T * operator -> () const
+			{
+				return &(m_This->obj);
+			}
+			
+			bool operator != (const iterator &where) const
+			{
+				return (m_This != where.m_This);
+			}
+			bool operator ==(const iterator &where) const
+			{
+				return (m_This == where.m_This);
+			}
+		private:
+			ListNode *m_This;
+		};
+	public:
+		iterator begin() const
+		{
+			return iterator(m_Head->next);
+		}
+		iterator end() const
+		{
+			return iterator(m_Head);
+		}
+		iterator erase(iterator &where)
+		{
+			ListNode *pNode = where.m_This;
+			iterator iter(where);
+			iter++;
+
+
+			// Works for all cases: empty list, erasing first element, erasing tail, erasing in the middle...
+			pNode->prev->next = pNode->next;
+			pNode->next->prev = pNode->prev;
+
+			delete pNode;
+			m_Size--;
+
+			return iter;
+		}
+
+		iterator insert(iterator where, const T &obj)
+		{
+			// Insert obj right before where
+
+			ListNode *node = new ListNode(obj);
+			ListNode *pWhereNode = where.m_This;
+			
+			pWhereNode->prev->next = node;
+			node->prev = pWhereNode->prev;
+			pWhereNode->prev = node;
+			node->next = pWhereNode;
+
+			m_Size++;
+
+			return iterator(node);
+		}
+
+	public:
+		void remove(const T & obj)
+		{
+			iterator b;
+			for (b=begin(); b!=end(); b++)
+			{
+				if ( (*b) == obj )
+				{
+					erase( b );
+					break;
+				}
+			}
+		}
+		template <typename U>
+		iterator find(const U & equ)
+		{
+			iterator iter;
+			for (iter=begin(); iter!=end(); iter++)
+			{
+				if ( (*iter) == equ )
+					return iter;
+			}
+			return end();
+		}
+		List & operator =(const List &src)
+		{
+			clear();
+			iterator iter;
+			for (iter=src.begin(); iter!=src.end(); iter++)
+				push_back( (*iter) );
+			return *this;
+		}
+	};
+//};	//NAMESPACE
+
+#endif //_INCLUDE_CSDM_LIST_H

amxmodx/sh_stack.h

@@ -0,0 +1,219 @@
+/* ======== SourceMM ========
+* Copyright (C) 2004-2005 Metamod:Source Development Team
+* No warranties of any kind
+*
+* License: zlib/libpng
+*
+* Author(s): Pavol "PM OnoTo" Marko
+* ============================
+*/
+
+#ifndef __SH_STACK_H__
+#define __SH_STACK_H__
+
+#define SH_STACK_DEFAULT_SIZE 4
+
+//namespace SourceHook
+//{/
+	// Vector
+	template <class T> class CStack
+	{
+		T *m_Elements;
+		size_t m_AllocatedSize;
+		size_t m_UsedSize;
+	public:
+		friend class iterator;
+		class iterator
+		{
+			CStack<T> *m_pParent;
+			size_t m_Index;
+		public:
+			iterator(CStack<T> *pParent, size_t id) : m_pParent(pParent), m_Index(id)
+			{
+			}
+
+			iterator(CStack<T> *pParent) : m_pParent(pParent), m_Index(0)
+			{
+			}
+			
+			iterator() : m_pParent(NULL), m_Index(0)
+			{
+			}
+
+			T &operator *()
+			{
+				return m_pParent->m_Elements[m_Index];
+			}
+			const T &operator *() const
+			{
+				return m_pParent->m_Elements[m_Index];
+			}
+			
+			T * operator->()
+			{
+				return m_pParent->m_Elements + m_Index;
+			}
+
+			const T * operator->() const
+			{
+				return m_pParent->m_Elements + m_Index;
+			}
+
+			iterator & operator++()		// preincrement
+			{
+				++m_Index;
+				return (*this);
+			}
+
+			iterator operator++(int)	// postincrement
+			{
+				iterator tmp = *this;
+				++m_Index;
+				return tmp;
+			}
+
+			iterator & operator--()		// predecrement
+			{
+				--m_Index;
+				return (*this);
+			}
+
+			iterator operator--(int)	// postdecrememnt
+			{
+				iterator tmp = *this;
+				--m_Index;
+				return tmp;
+			}
+
+			bool operator==(const iterator & right) const
+			{
+				return (m_pParent == right.m_pParent && m_Index == right.m_Index);
+			}
+
+			bool operator!=(const iterator & right) const
+			{
+				return !(*this == right);
+			}
+		};
+		CStack() : m_Elements(new T[SH_STACK_DEFAULT_SIZE]),
+			m_AllocatedSize(SH_STACK_DEFAULT_SIZE),
+			m_UsedSize(0)
+		{
+		}
+		CStack(size_t size) : m_Elements(new T[size]),
+			m_AllocatedSize(size),
+			m_UsedSize(0)
+		{
+		}
+
+		CStack(const CStack &other) : m_Elements(NULL),
+			m_AllocatedSize(0),
+			m_UsedSize(0)
+		{
+			reserve(other.m_AllocatedSize);
+			m_UsedSize = other.m_UsedSize;
+			for (size_t i = 0; i < m_UsedSize; ++i)
+				m_Elements[i] = other.m_Elements[i];
+		}
+
+		~CStack()
+		{
+			if (m_Elements)
+				delete [] m_Elements;
+		}
+		
+		void operator=(const CStack &other)
+		{
+			if (m_AllocatedSize < other.m_AllocatedSize)
+			{
+				if (m_Elements)
+					delete [] m_Elements;
+				m_Elements = new T[other.m_AllocatedSize];
+				m_AllocatedSize = other.m_AllocatedSize;
+			}
+			m_UsedSize = other.m_UsedSize;
+			for (size_t i = 0; i < m_UsedSize; ++i)
+				m_Elements[i] = other.m_Elements[i];
+		}
+
+		bool push(const T &val)
+		{
+			if (m_UsedSize + 1 == m_AllocatedSize)
+			{
+				// zOHNOES! REALLOCATE!
+				m_AllocatedSize *= 2;
+				T *newElements = new T[m_AllocatedSize];
+				if (!newElements)
+				{
+					m_AllocatedSize /= 2;
+					return false;
+				}
+				if (m_Elements)
+				{
+					for (size_t i = 0; i < m_UsedSize; ++i)
+						newElements[i] = m_Elements[i];
+					delete [] m_Elements;
+				}
+				m_Elements = newElements;
+			}
+			m_Elements[m_UsedSize++] = val;
+			return true;
+		}
+		void pop()
+		{
+			--m_UsedSize;
+		}
+
+		T &front()
+		{
+			return m_Elements[m_UsedSize - 1];
+		}
+
+		const T &front() const
+		{
+			return m_Elements[m_UsedSize - 1];
+		}
+
+		iterator begin()
+		{
+			return iterator(this, 0);
+		}
+		iterator end()
+		{
+			return iterator(this, m_UsedSize);
+		}
+
+		size_t size()
+		{
+			return m_UsedSize;
+		}
+		size_t capacity()
+		{
+			return m_AllocatedSize;
+		}
+		bool empty()
+		{
+			return m_UsedSize == 0 ? true : false;
+		}
+		bool reserve(size_t size)
+		{
+			if (size > m_AllocatedSize)
+			{
+				T *newElements = new T[size];
+				if (!newElements)
+					return false;
+				if (m_Elements)
+				{
+					for (size_t i = 0; i < m_UsedSize; ++i)
+						newElements[i] = m_Elements[i];
+					delete [] m_Elements;
+				}
+				m_Elements = newElements;
+				m_AllocatedSize = size;
+			}
+			return true;
+		}
+	};
+//};	//namespace SourceHook
+
+#endif

amxmodx/sh_tinyhash.h

@@ -0,0 +1,526 @@
+/* ======== SourceMM ========
+* Copyright (C) 2004-2005 Metamod:Source Development Team
+* No warranties of any kind
+*
+* License: zlib/libpng
+*
+* Author(s): David "BAILOPAN" Anderson
+* ============================
+*/
+
+#ifndef _INCLUDE_SH_TINYHASH_H_
+#define _INCLUDE_SH_TINYHASH_H_
+
+#include "sh_list.h"
+
+#define _T_INIT_HASH_SIZE	512
+
+//namespace SourceHook
+//{
+	template <class K>
+	int HashFunction(const K & k);
+
+	template <class K>
+	int Compare(const K & k1, const K & k2);
+
+	template <class U, class K>
+	int CompareAlt(const U &k1, const K &k2);
+
+	template <class U>
+	int HashAlt(const U &u);
+
+	/**
+	 * This is a tiny, growable hash class.
+	 * Meant for quick and dirty dictionaries only!
+	 */
+	template <class K, class V>
+	class THash
+	{
+	public:
+		struct THashNode
+		{
+			THashNode(const K & k, const V & v) :
+				key(k), val(v)
+				{
+				};
+			THashNode & operator =(const THashNode &other)
+			{
+				key = other.key;
+				val = other.val;
+			}
+			K key;
+			V val;
+		};
+		typedef List<THashNode *> *	NodePtr;
+	public:
+		class const_iterator;
+		THash() : m_Buckets(NULL), m_numBuckets(0), m_percentUsed(0.0f), m_items(0)
+		{
+			_Refactor();
+		}
+		THash(const THash &other) : m_Buckets(new NodePtr[other.m_numBuckets]),
+			m_numBuckets(other.m_numBuckets), m_percentUsed(other.m_percentUsed), m_items(0)
+		{
+			for (size_t i=0; i<m_numBuckets; i++)
+					m_Buckets[i] = NULL;
+			for (const_iterator iter = other.begin(); iter != other.end(); ++iter)
+				_FindOrInsert(iter->key)->val = iter->val;
+		}
+		void operator=(const THash &other)
+		{
+			clear();
+			for (const_iterator iter = other.begin(); iter != other.end(); ++iter)
+				_FindOrInsert(iter->key)->val = iter->val;
+		}
+
+		~THash()
+		{
+			_Clear();
+		}
+		void clear()
+		{
+			_Clear();
+			_Refactor();
+		}
+		size_t size()
+		{
+			return m_items;
+		}
+		size_t GetBuckets()
+		{
+			return m_numBuckets;
+		}
+		float PercentUsed()
+		{
+			return m_percentUsed;
+		}
+		V & operator [](const K & key)
+		{
+			THashNode *pNode = _FindOrInsert(key);
+			return pNode->val;
+		}
+	private:
+		void _Clear()
+		{
+			typename List<THashNode *>::iterator iter, end;
+			for (size_t i=0; i<m_numBuckets; i++)
+			{
+				if (m_Buckets[i])
+				{
+					end = m_Buckets[i]->end();
+					iter = m_Buckets[i]->begin();
+					while (iter != end)
+					{
+						delete (*iter);
+						iter++;
+					}
+					delete m_Buckets[i];
+					m_Buckets[i] = NULL;
+				}
+			}
+			if (m_Buckets)
+				delete [] m_Buckets;
+			m_Buckets = NULL;
+			m_numBuckets = 0;
+			m_items = 0;
+		}
+	public:
+		template <typename U>
+		V & AltFindOrInsert(const U & ukey)
+		{
+			size_t place = HashAlt(ukey) % m_numBuckets;
+			THashNode *pNode = NULL;
+			if (!m_Buckets[place])
+			{
+				m_Buckets[place] = new List<THashNode *>;
+				pNode = new THashNode(ukey, V());
+				m_Buckets[place]->push_back(pNode);
+				m_percentUsed += (1.0f / (float)m_numBuckets);
+				m_items++;
+			} else {
+				typename List<THashNode *>::iterator iter;
+				for (iter=m_Buckets[place]->begin(); iter!=m_Buckets[place]->end(); iter++)
+				{
+					if (CompareAlt(ukey, (*iter)->key) == 0)
+						return (*iter)->val;
+				}
+				pNode = new THashNode(ukey, V());
+				m_Buckets[place]->push_back(pNode);
+				m_items++;
+			}
+			if (PercentUsed() > 0.75f)
+				_Refactor();
+			return pNode->val;
+		}
+	private:
+		THashNode *_FindOrInsert(const K & key)
+		{
+			size_t place = HashFunction(key) % m_numBuckets;
+			THashNode *pNode = NULL;
+			if (!m_Buckets[place])
+			{
+				m_Buckets[place] = new List<THashNode *>;
+				pNode = new THashNode(key, V());
+				m_Buckets[place]->push_back(pNode);
+				m_percentUsed += (1.0f / (float)m_numBuckets);
+				m_items++;
+			} else {
+				typename List<THashNode *>::iterator iter;
+				for (iter=m_Buckets[place]->begin(); iter!=m_Buckets[place]->end(); iter++)
+				{
+					if (Compare((*iter)->key, key) == 0)
+						return (*iter);
+				}
+				//node does not exist
+				pNode = new THashNode(key, V());
+				m_Buckets[place]->push_back(pNode);
+				m_items++;
+			}
+			if (PercentUsed() > 0.75f)
+				_Refactor();
+			return pNode;
+		}
+		void _Refactor()
+		{
+			m_percentUsed = 0.0f;
+			if (!m_numBuckets)
+			{
+				m_numBuckets = _T_INIT_HASH_SIZE;
+				m_Buckets = new NodePtr[m_numBuckets];
+				for (size_t i=0; i<m_numBuckets; i++)
+					m_Buckets[i] = NULL;
+			} else {
+				size_t oldSize = m_numBuckets;
+				m_numBuckets *= 2;
+				typename List<THashNode *>::iterator iter;
+				size_t place;
+				THashNode *pHashNode;
+				NodePtr *temp = new NodePtr[m_numBuckets];
+				for (size_t i=0; i<m_numBuckets; i++)
+					temp[i] = NULL;
+				//look in old hash table
+				for (size_t i=0; i<oldSize; i++)
+				{
+					//does a bucket have anything?
+					if (m_Buckets[i])
+					{
+						//go through the list of items
+						for (iter = m_Buckets[i]->begin(); iter != m_Buckets[i]->end(); iter++)
+						{
+							pHashNode = (*iter);
+							//rehash it with the new bucket filter
+							place = HashFunction(pHashNode->key) % m_numBuckets;
+							//add it to the new hash table
+							if (!temp[place])
+							{
+								temp[place] = new List<THashNode *>;
+								m_percentUsed += (1.0f / (float)m_numBuckets);
+							}
+							temp[place]->push_back(pHashNode);
+						}
+						//delete that bucket!
+						delete m_Buckets[i];
+						m_Buckets[i] = NULL;
+					}
+				}
+				//reassign bucket table
+				delete [] m_Buckets;
+				m_Buckets = temp;
+			}
+		}
+	public:
+		friend class iterator;
+		friend class const_iterator;
+		class iterator
+		{
+			friend class THash;
+		public:
+			iterator() : curbucket(-1), hash(NULL), end(true)
+			{
+			};
+			iterator(THash *h) : curbucket(-1), hash(h), end(false)
+			{
+				if (!h->m_Buckets)
+					end = true;
+				else
+					_Inc();
+			};
+			//pre increment
+			iterator & operator++()
+			{
+				_Inc();
+				return *this;
+			}
+			//post increment
+			iterator operator++(int)
+			{
+				iterator old(*this);
+				_Inc();
+				return old;
+			}
+			const THashNode & operator * () const
+			{
+				return *(*iter);
+			}
+			THashNode & operator * ()
+			{
+				return *(*iter);
+			}
+			const THashNode * operator ->() const
+			{
+				return (*iter);
+			}
+			THashNode * operator ->()
+			{
+				return (*iter);
+			}
+			bool operator ==(const iterator &where) const
+			{
+				if (where.hash == this->hash
+					&& where.end == this->end
+					&&
+					 (this->end ||
+					   ((where.curbucket == this->curbucket)
+						&& (where.iter == iter))
+						 ))
+					return true;
+				return false;
+			}
+			bool operator !=(const iterator &where) const
+			{
+				return !( (*this) == where );
+			}
+
+			void erase()
+			{
+				if (end || !hash || curbucket < 0 || curbucket >= static_cast<int>(hash->m_numBuckets))
+					return;
+
+				// Remove this element and move to the next one
+				iterator tmp = *this;
+				++tmp;
+				delete (*iter);
+				hash->m_Buckets[curbucket]->erase(iter);
+				*this = tmp;
+
+				// :TODO: Maybe refactor to a lower size if required
+
+				m_items--;
+			}
+		private:
+			void _Inc()
+			{
+				if (end || !hash || curbucket >= static_cast<int>(hash->m_numBuckets))
+					return;
+				if (curbucket < 0)
+				{
+					for (int i=0; i<(int)hash->m_numBuckets; i++)
+					{
+						if (hash->m_Buckets[i])
+						{
+							iter = hash->m_Buckets[i]->begin();
+							if (iter == hash->m_Buckets[i]->end())
+								continue;
+							curbucket = i;
+							break;
+						}
+					}
+					if (curbucket < 0)
+						end = true;
+				} else {
+					if (iter != hash->m_Buckets[curbucket]->end())
+						iter++;
+					if (iter == hash->m_Buckets[curbucket]->end())
+					{
+						int oldbucket = curbucket;
+						for (int i=curbucket+1; i<(int)hash->m_numBuckets; i++)
+						{
+							if (hash->m_Buckets[i])
+							{
+								iter = hash->m_Buckets[i]->begin();
+								if (iter == hash->m_Buckets[i]->end())
+									continue;
+								curbucket = i;
+								break;
+							}
+						}
+						if (curbucket == oldbucket)
+							end = true;
+					}
+				}
+			}
+		private:
+			int curbucket;
+			typename List<THashNode *>::iterator iter;
+			THash *hash;
+			bool end;
+		};
+		class const_iterator
+		{
+			friend class THash;
+		public:
+			const_iterator() : curbucket(-1), hash(NULL), end(true)
+			{
+			};
+			const_iterator(const THash *h) : curbucket(-1), hash(h), end(false)
+			{
+				if (!h->m_Buckets)
+					end = true;
+				else
+					_Inc();
+			};
+			//pre increment
+			const_iterator & operator++()
+			{
+				_Inc();
+				return *this;
+			}
+			//post increment
+			const_iterator operator++(int)
+			{
+				iterator old(*this);
+				_Inc();
+				return old;
+			}
+			const THashNode & operator * () const
+			{
+				return *(*iter);
+			}
+			const THashNode * operator ->() const
+			{
+				return (*iter);
+			}
+			bool operator ==(const const_iterator &where) const
+			{
+				if (where.hash == this->hash
+					&& where.end == this->end
+					&&
+					 (this->end ||
+					   ((where.curbucket == this->curbucket)
+						&& (where.iter == iter))
+						 ))
+					return true;
+				return false;
+			}
+			bool operator !=(const const_iterator &where) const
+			{
+				return !( (*this) == where );
+			}
+		private:
+			void _Inc()
+			{
+				if (end || !hash || curbucket >= static_cast<int>(hash->m_numBuckets))
+					return;
+				if (curbucket < 0)
+				{
+					for (int i=0; i<(int)hash->m_numBuckets; i++)
+					{
+						if (hash->m_Buckets[i])
+						{
+							iter = hash->m_Buckets[i]->begin();
+							if (iter == hash->m_Buckets[i]->end())
+								continue;
+							curbucket = i;
+							break;
+						}
+					}
+					if (curbucket < 0)
+						end = true;
+				} else {
+					if (iter != hash->m_Buckets[curbucket]->end())
+						iter++;
+					if (iter == hash->m_Buckets[curbucket]->end())
+					{
+						int oldbucket = curbucket;
+						for (int i=curbucket+1; i<(int)hash->m_numBuckets; i++)
+						{
+							if (hash->m_Buckets[i])
+							{
+								iter = hash->m_Buckets[i]->begin();
+								if (iter == hash->m_Buckets[i]->end())
+									continue;
+								curbucket = i;
+								break;
+							}
+						}
+						if (curbucket == oldbucket)
+							end = true;
+					}
+				}
+			}
+		private:
+			int curbucket;
+			typename List<THashNode *>::iterator iter;
+			const THash *hash;
+			bool end;
+		};
+	public:
+		iterator begin()
+		{
+			return iterator(this);
+		}
+		iterator end()
+		{
+			iterator iter;
+			iter.hash = this;
+			return iter;
+		}
+
+		const_iterator begin() const
+		{
+			return const_iterator(this);
+		}
+		const_iterator end() const
+		{
+			const_iterator iter;
+			iter.hash = this;
+			return iter;
+		}
+
+		template <typename U>
+		iterator find(const U & u) const
+		{
+			iterator b = begin();
+			iterator e = end();
+			for (iterator iter = b; iter != e; iter++)
+			{
+				if ( (*iter).key == u )
+					return iter;
+			}
+			return end();
+		}
+		template <typename U>
+		iterator find(const U & u)
+		{
+			iterator b = begin();
+			iterator e = end();
+			for (iterator iter = b; iter != e; iter++)
+			{
+				if ( (*iter).key == u )
+					return iter;
+			}
+			return end();
+		}
+
+		iterator erase(iterator where)
+		{
+			where.erase();
+			return where;
+		}
+		template <typename U>
+		void erase(const U & u)
+		{
+			iterator iter = find(u);
+			if (iter == end())
+				return;
+			iter.erase();
+		}
+	private:
+		NodePtr	*m_Buckets;
+		size_t m_numBuckets;
+		float m_percentUsed;
+		size_t m_items;
+	};
+//};
+
+#endif //_INCLUDE_SH_TINYHASH_H_

amxmodx/srvcmd.cpp

@@ -31,161 +31,156 @@
 
 #include "amxmodx.h"
 
-void amx_command(){
-		
+void amx_command()
+{
 	const char* cmd = CMD_ARGV(1);
 		
-		if (!strcmp(cmd,"plugins") || !strcmp(cmd,"list"))
+	if (!strcmp(cmd, "plugins") || !strcmp(cmd, "list"))
 	{
 
-				print_srvconsole( "Currently loaded plugins:\n");
-				print_srvconsole( "       %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n",
-						"name","version","author","file","status");
+		print_srvconsole("Currently loaded plugins:\n");
+		print_srvconsole("       %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n", "name", "version", "author", "file", "status");
 
 		int plugins = 0;
 		int	running = 0;
 
-
 		CPluginMngr::iterator a = g_plugins.begin();
 			
 		while (a) 
 		{
 			++plugins;
-
-						if ( (*a).isValid() && !(*a).isPaused() ) 
+			if ((*a).isValid() && !(*a).isPaused()) 
 				++running;
 
-						print_srvconsole( " [%3d] %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n",
-								plugins,(*a).getTitle(),(*a).getVersion(),
-								(*a).getAuthor(), (*a).getName(), (*a).getStatus() );
-
+			print_srvconsole(" [%3d] %-18.17s %-8.7s %-17.16s %-16.15s %-9.8s\n", plugins, (*a).getTitle(), (*a).getVersion(), (*a).getAuthor(), (*a).getName(), (*a).getStatus());
 			++a;
 		}
 
 		a = g_plugins.begin();
 
+		int num = 0;
 		while (a)
 		{
-					if ( (*a).getStatusCode() == ps_bad_load )
+			num++;
+			if ((*a).getStatusCode() == ps_bad_load)
 			{
 				//error
-						print_srvconsole("Load fails: %s\n", (*a).getError());
+				print_srvconsole("(%3d) Load fails: %s\n", num, (*a).getError());
+			} else if ( (*a).getStatusCode() == ps_error) {
+				//error
+				print_srvconsole("(%3d) Error: %s\n", num, (*a).getError());
 			}
 			++a;
 		}
 
-				print_srvconsole( "%d plugins, %d running\n",plugins,running );
-
+		print_srvconsole("%d plugins, %d running\n", plugins, running);
 	}
-		else if (!strcmp(cmd,"pause") && CMD_ARGC() > 2) 
+	else if (!strcmp(cmd, "pause") && CMD_ARGC() > 2) 
 	{
 		const char* sPlugin = CMD_ARGV(2);
 
 		CPluginMngr::CPlugin *plugin = g_plugins.findPlugin(sPlugin);
 
-				if ( plugin && plugin->isValid() ) 
+		if (plugin && plugin->isValid()) 
 		{
 			plugin->pausePlugin();
-						print_srvconsole("Paused plugin \"%s\"\n",plugin->getName() );
+			print_srvconsole("Paused plugin \"%s\"\n", plugin->getName());
 		}
-				else print_srvconsole("Couldn't find plugin matching \"%s\"\n",sPlugin);
-
+		else 
+			print_srvconsole("Couldn't find plugin matching \"%s\"\n", sPlugin);
 	}
-		else if (!strcmp(cmd,"unpause") && CMD_ARGC() > 2) 
+	else if (!strcmp(cmd, "unpause") && CMD_ARGC() > 2) 
 	{
 		const char* sPlugin = CMD_ARGV(2);
 
 		CPluginMngr::CPlugin *plugin = g_plugins.findPlugin(sPlugin);
 
-				if ( plugin && plugin->isValid() ) 
+		if (plugin && plugin->isValid() && plugin->isPaused()) 
 		{
 			plugin->unpausePlugin();
-						print_srvconsole("Unpaused plugin \"%s\"\n",plugin->getName() );
+			print_srvconsole("Unpaused plugin \"%s\"\n", plugin->getName());
 		}
-				else print_srvconsole("Couldn't find plugin matching \"%s\"\n",sPlugin);
-
-		}
-		else if (!strcmp(cmd,"cvars")) 
+		else if (!plugin)
 		{
-				print_srvconsole( "Registered cvars:\n");
-				print_srvconsole( "       %-24.23s %-24.23s %-16.15s\n",
-						"name","value","plugin");
+			print_srvconsole("Couldn't find plugin matching \"%s\"\n", sPlugin);
+		} else {
+			print_srvconsole("Plugin %s can't be unpaused right now.", sPlugin);
+		}
+	}
+	else if (!strcmp(cmd, "cvars")) 
+	{
+		print_srvconsole("Registered cvars:\n");
+		print_srvconsole("       %-24.23s %-24.23s %-16.15s\n", "name", "value", "plugin");
 
 		int ammount = 0;
 
-				for( CList<CCVar>::iterator a = g_cvars.begin(); a ; ++a )
+		for (CList<CCVar>::iterator a = g_cvars.begin(); a; ++a)
 		{
-						print_srvconsole( " [%3d] %-24.23s %-24.23s %-16.15s\n",++ammount,
-						(*a).getName() ,CVAR_GET_STRING( (*a).getName() ),(*a).getPluginName() );
+			print_srvconsole(" [%3d] %-24.23s %-24.23s %-16.15s\n", ++ammount, (*a).getName(), CVAR_GET_STRING((*a).getName()), (*a).getPluginName());
 		}
 		
-				print_srvconsole( "%d cvars\n",ammount);
+		print_srvconsole("%d cvars\n", ammount);
 	}
-		else if ( !strcmp(cmd,"cmds") ) 
+	else if (!strcmp(cmd, "cmds")) 
 	{
-				
-				print_srvconsole( "Registered commands:\n");
-				print_srvconsole( "       %-24.23s %-16.15s %-8.7s %-16.15s\n", 
-						"name","access" ,"type" ,"plugin");
+		print_srvconsole("Registered commands:\n");
+		print_srvconsole("       %-24.23s %-16.15s %-8.7s %-16.15s\n", "name", "access", "type", "plugin");
 				
 		int ammount = 0;
-				
 		char access[32];
 
-				CmdMngr::iterator a = g_commands.begin( CMD_ConsoleCommand );
+		CmdMngr::iterator a = g_commands.begin(CMD_ConsoleCommand);
 
-				while( a )
+		while (a)
 		{
-						UTIL_GetFlags( access , (*a).getFlags() );
-						print_srvconsole( " [%3d] %-24.23s %-16.15s %-8.7s %-16.15s\n",
-								++ammount,(*a).getCmdLine() , access , (*a).getCmdType() , (*a).getPlugin()->getName());
+			UTIL_GetFlags(access, (*a).getFlags());
+			print_srvconsole(" [%3d] %-24.23s %-16.15s %-8.7s %-16.15s\n", ++ammount, (*a).getCmdLine(), access, (*a).getCmdType(), (*a).getPlugin()->getName());
 			++a;
 		}
 
-				print_srvconsole( "%d commands\n",ammount);
+		print_srvconsole("%d commands\n",ammount);
 	}
-		else if (!strcmp(cmd,"version")) 
+	else if (!strcmp(cmd, "version")) 
 	{
-
-				print_srvconsole( "%s %s\n", Plugin_info.name, Plugin_info.version);
-				print_srvconsole(   "author: %s (%s)\n", Plugin_info.author, Plugin_info.url);
-				print_srvconsole(   "compiled: %s\n", __DATE__ ", " __TIME__);
-#ifdef JIT
-				print_srvconsole(   "Core mode: JIT\n");
+		print_srvconsole("%s %s (%s)\n", Plugin_info.name, Plugin_info.version, Plugin_info.url);
+		print_srvconsole("Authors: David \"BAILOPAN\" Anderson, Pavol \"PM OnoTo\" Marko\n");
+		print_srvconsole("\tFelix \"SniperBeamer\" Geyer, Jonny \"Got His Gun\" Bergstrom\n");
+		print_srvconsole("\tLukasz \"SidLuke\" Wlasinski, Christian \"Basic-Master\" Hammacher\n");
+		print_srvconsole("\tBorja \"faluco\" Ferrer\n");
+		print_srvconsole("Compiled: %s\n", __DATE__ ", " __TIME__);
+#if defined JIT && !defined ASM32
+		print_srvconsole("Core mode: JIT Only\n");
+#elif !defined JIT && defined ASM32
+		print_srvconsole("Core mode: ASM32 Only\n");
+#elif defined JIT && defined ASM32
+		print_srvconsole("Core mode: JIT+ASM32\n");
 #else
-#ifdef ASM32
-				print_srvconsole(   "Core mode: ASM\n");
-#else
-				print_srvconsole(   "Core mode: Normal\n");
-#endif
+		print_srvconsole("Core mode: Normal\n");
 #endif
 	}
-		else if (!strcmp(cmd,"modules"))
+	else if (!strcmp(cmd, "modules"))
 	{
-				print_srvconsole( "Currently loaded modules:\n");
-				print_srvconsole( "      %-23.22s %-8.7s %-20.19s %-11.10s\n",
-						"name", "version", "author", "status");
+		print_srvconsole("Currently loaded modules:\n");
+		print_srvconsole("      %-23.22s %-8.7s %-20.19s %-11.10s\n", "name", "version", "author", "status");
 
 		int running = 0;
 		int modules = 0;
 
 		CList<CModule,const char *>::iterator a = g_modules.begin();
 
-				while ( a )
+		while (a)
 		{
-						if ( (*a).getStatusValue() == MODULE_LOADED )
+			if ((*a).getStatusValue() == MODULE_LOADED)
 				++running;
-
 			++modules;
 
-						print_srvconsole( " [%2d] %-23.22s %-8.7s %-20.19s %-11.10s\n", modules,
-								(*a).getName(), (*a).getVersion(), (*a).getAuthor() , (*a).getStatus() );
-				
+			print_srvconsole(" [%2d] %-23.22s %-8.7s %-20.19s %-11.10s\n", modules, (*a).getName(), (*a).getVersion(), (*a).getAuthor(), (*a).getStatus());
 			++a;
 		}
 
-				print_srvconsole( "%d modules, %d correct\n",modules,running);
-		} else if (!strcmp(cmd, "gpl"))
+		print_srvconsole("%d modules, %d correct\n", modules, running);
+	}
+	else if (!strcmp(cmd, "gpl"))
 	{
 		print_srvconsole("AMX Mod X\n");
 		print_srvconsole("\n");
@@ -242,11 +237,7 @@ void amx_command(){
 		print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x3A\x78\x78\x24\x40\x4E\x4E\x4D\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x5E\x3E\x3E\x3F\x3E\x3E\x3E\x3E\x3B\x3B\x3B\x3A\x3A\x3F\x3E\x3A\x2E\x2E\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2E\x45\x4D\x40\x45\x78\x5E\x33\x68\x33\x2B\n");
 		print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x24\x48\x45\x48\x78\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2B\x4E\x40\x2B\x66\x33\x78\x20\x20\n");
 		print_srvconsole("\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x2B\x2C\x20\x3A\x20\x20\n");
-		}
-		else
-		{
-
-
+	} else {
 		print_srvconsole("Usage: amxx < command > [ argument ]\n");
 		print_srvconsole("Commands:\n");
 		print_srvconsole("   version                - display amxx version info\n");
@@ -257,46 +248,24 @@ void amx_command(){
 		print_srvconsole("   cmds                   - list commands registered by plugins\n");
 		print_srvconsole("   pause < plugin >       - pause a running plugin\n");
 		print_srvconsole("   unpause < plugin >     - unpause a previously paused plugin\n");
-		
 	}
 }
 
-
 void plugin_srvcmd()
 {
-
 	cell ret = 0;
-		int err;
 	const char* cmd = CMD_ARGV(0);
 				
-#ifdef ENABLEEXEPTIONS
-		try{
-#endif
-				
 	CmdMngr::iterator a = g_commands.srvcmdbegin();
 			
-				while ( a )
+	while (a)
 	{
-						if (  (*a).matchCommand( cmd )  && 
-								(*a).getPlugin()->isExecutable( (*a).getFunction() ) )
+		if ((*a).matchCommand(cmd) && (*a).getPlugin()->isExecutable((*a).getFunction()))
 		{
-								
-								if ((err = amx_Exec( (*a).getPlugin()->getAMX(), &ret , (*a).getFunction() 
-										, 3 , g_srvindex , (*a).getFlags() , (*a).getId() )) != AMX_ERR_NONE)
-								{
-									LogError((*a).getPlugin()->getAMX(), err, "");
+			cell ret = executeForwards((*a).getFunction(), static_cast<cell>(g_srvindex),
+				static_cast<cell>((*a).getFlags()), static_cast<cell>((*a).getId()));
+			if (ret) break;
 		}
-								if ( ret ) break;
-						}
-						
 		++a;
 	}
-				
-#ifdef ENABLEEXEPTIONS
-		}catch( ... )
-		{
-				AMXXLOG_Log( "[AMXX] fatal error at forward function execution");
-		}
-#endif
-		
 }

amxmodx/util.cpp

@@ -30,27 +30,47 @@
 */
 
 #include <time.h>
-
 #include "amxmodx.h"
 
+#ifdef __linux__
+	#define _vsnprintf vsnprintf
+#endif
+
+char *UTIL_VarArgs(const char *fmt, ...)
+{
+	va_list ap;
+	static char string[4096];
+
+	va_start(ap, fmt);
+	_vsnprintf(string, sizeof(string)-1, fmt, ap);
+	va_end(ap);
+
+	return string;
+}
+
 int UTIL_ReadFlags(const char* c) 
 {
 	int flags = 0;
-	while (*c) flags |= ( 1 << ( *c++ - 'a' ) );
+	
+	while (*c)
+		flags |= (1<<(*c++ - 'a'));
+	
 	return flags;
 }
 
-void UTIL_GetFlags(char* f,int a)
+void UTIL_GetFlags(char* f, int a)
 {
-	for(int i='a';i<='z';++i){
-		if ( a & 1 ) *f++ = i;
+	for (int i = 'a'; i <= 'z'; ++i)
+	{
+		if (a & 1) *f++ = i;
 		a >>= 1;
 	}
+
 	*f = 0;
 }
 
 /* warning - don't pass here const string */
-void UTIL_ShowMenu( edict_t* pEdict, int slots, int time, char *menu, int mlen )
+void UTIL_ShowMenu(edict_t* pEdict, int slots, int time, char *menu, int mlen)
 {
 	char *n = menu;
 	char c = 0;
@@ -59,17 +79,19 @@ void UTIL_ShowMenu( edict_t* pEdict, int slots, int time, char *menu, int mlen )
 	if (!gmsgShowMenu)
 		return;			// some games don't support ShowMenu (Firearms)
 
-	while ( *n ) {
+	while (*n)
+	{
 		a = mlen;
-		if ( a > 175 ) a = 175;
+		if (a > 175) a = 175;
 		mlen -= a;
 		c = *(n+=a);
 		*n = 0;
-		MESSAGE_BEGIN( MSG_ONE , gmsgShowMenu, NULL, pEdict );
-		WRITE_SHORT( slots );
-		WRITE_CHAR( time );
-		WRITE_BYTE( c ? TRUE : FALSE);
-		WRITE_STRING( menu );
+		
+		MESSAGE_BEGIN(MSG_ONE, gmsgShowMenu, NULL, pEdict);
+		WRITE_SHORT(slots);
+		WRITE_CHAR(time);
+		WRITE_BYTE(c ? TRUE : FALSE);
+		WRITE_STRING(menu);
 		MESSAGE_END();
 		*n = c;
 		menu = n;
@@ -77,14 +99,14 @@ void UTIL_ShowMenu( edict_t* pEdict, int slots, int time, char *menu, int mlen )
 }
 
 /* warning - don't pass here const string */
-void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name)
+void UTIL_ShowMOTD(edict_t *client, char *motd, int mlen, const char *name)
 {
 	if (!gmsgMOTD)
 		return;				// :TODO: Maybe output a warning log?
 
 	if (gmsgServerName)
 	{
-		MESSAGE_BEGIN( MSG_ONE , gmsgServerName, NULL, client );
+		MESSAGE_BEGIN(MSG_ONE, gmsgServerName, NULL, client);
 		WRITE_STRING(name);
 		MESSAGE_END();
 	}
@@ -93,15 +115,17 @@ void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name)
 	char c = 0;
 	int a;
 
-	while ( *n ) {
+	while (*n)
+	{
 		a = mlen;
-		if ( a > 175 ) a = 175;
+		if (a > 175) a = 175;
 		mlen -= a;
-		c = *(n+=a);
+		c = *(n += a);
 		*n = 0;
-		MESSAGE_BEGIN( MSG_ONE , gmsgMOTD, NULL, client );
-		WRITE_BYTE( c ? FALSE : TRUE );
-		WRITE_STRING( motd );
+		
+		MESSAGE_BEGIN(MSG_ONE, gmsgMOTD, NULL, client);
+		WRITE_BYTE(c ? FALSE : TRUE);
+		WRITE_STRING(motd);
 		MESSAGE_END();
 		*n = c;
 		motd = n;
@@ -109,42 +133,52 @@ void UTIL_ShowMOTD( edict_t *client , char *motd, int mlen, const char *name)
 
 	if (gmsgServerName)
 	{
-		MESSAGE_BEGIN( MSG_ONE , gmsgServerName, NULL, client );
-		WRITE_STRING( hostname->string );
+		MESSAGE_BEGIN(MSG_ONE, gmsgServerName, NULL, client);
+		WRITE_STRING(hostname->string);
 		MESSAGE_END();
 	}
 }
 
 void UTIL_IntToString(int value, char *output)
 {
-	static const char *words[] = {"zero ","one ","two ","three ","four ",
+	static const char *words[] = 
+		{"zero ","one ","two ","three ","four ",
 		"five ", "six ","seven ","eight ","nine ","ten ",
 		"eleven ","twelve ","thirteen ","fourteen ","fifteen ",
 		"sixteen ","seventeen ","eighteen ","nineteen ",
 		"twenty ","thirty ","fourty ", "fifty ","sixty ",
 		"seventy ","eighty ","ninety ",
 		"hundred ","thousand "};
+	
 	*output = 0;
 	if (value < 0) value = -value;
 	int tho = value / 1000;
 	int aaa = 0;
-	if (tho){
-		aaa += sprintf(&output[aaa], words[ tho ] );
-		aaa += sprintf(&output[aaa], words[29] );
+	
+	if (tho)
+	{
+		aaa += sprintf(&output[aaa], words[tho]);
+		aaa += sprintf(&output[aaa], words[29]);
 		value = value % 1000;
 	}
+
 	int hun = value / 100;
-	if (hun) {
-		aaa += sprintf(&output[aaa], words[ hun ] );
-		aaa += sprintf(&output[aaa], words[28] );
+	
+	if (hun)
+	{
+		aaa += sprintf(&output[aaa], words[hun]);
+		aaa += sprintf(&output[aaa], words[28]);
 		value = value % 100;
 	}
+
 	int ten = value / 10;
 	int unit = value % 10;
-	if ( ten )  
-		aaa += sprintf(&output[aaa], words[ ( ten > 1 ) ? ( ten + 18 ) : ( unit + 10 ) ] );
-	if ( ten != 1 && ( unit || (!value && !hun && !tho) ) ) 
-		sprintf(&output[aaa], words[ unit ] );
+	
+	if (ten)
+		aaa += sprintf(&output[aaa], words[(ten > 1) ? (ten + 18) : (unit + 10)]);
+	
+	if (ten != 1 && (unit || (!value && !hun && !tho))) 
+		sprintf(&output[aaa], words[unit]);
 }
 
 char* UTIL_SplitHudMessage(const char *src)
@@ -152,50 +186,57 @@ char* UTIL_SplitHudMessage(const char *src)
 	static char message[512];
 	short b = 0, d = 0, e = 0, c = -1;
 
-	while ( src[ d ] && e < 480 ) {
-		if ( src[ d ] == ' ' ) {
+	while (src[d] && e < 480)
+	{
+		if (src[d] == ' ')
+		{
 			c = e;
 		}
-		else if ( src[ d ] == '\n' ) {
+		else if (src[d] == '\n')
+		{
 			c = -1;
 			b = 0;
 		}
-		message[ e++ ] = src[ d++ ];
-		if ( ++b == 69 ) {
-			if ( c == -1 )   {
-				message[ e++ ] = '\n';
+		
+		message[e++] = src[d++];
+		
+		if (++b == 69)
+		{
+			if (c == -1)
+			{
+				message[e++] = '\n';
 				b = 0;
-			}
-			else  {
-				message[ c ] = '\n';
+			} else {
+				message[c] = '\n';
 				b = e - c - 1;
 				c = -1;
 			}
 		}
 	}
-	message[ e ] = 0;
+
+	message[e] = 0;
 	return message;
 }
 
-unsigned short FixedUnsigned16( float value, float scale )
+unsigned short FixedUnsigned16(float value, float scale)
 {
 	int output = (int)(value * scale);
 
-	if ( output < 0 )
+	if (output < 0)
 		output = 0;
-	else if ( output > 0xFFFF )
+	else if (output > 0xFFFF)
 		output = 0xFFFF;
 
 	return (unsigned short)output;
 }
 
-short FixedSigned16( float value, float scale )
+short FixedSigned16(float value, float scale)
 {
 	int output = (int)(value * scale);
 
-	if ( output > 32767 )
+	if (output > 32767)
 		output = 32767;
-	else if ( output < -32768 )
+	else if (output < -32768)
 		output = -32768;
 
 	return (short)output;
@@ -203,15 +244,15 @@ short FixedSigned16( float value, float scale )
 
 void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pMessage)
 {
-	if ( pEntity )
-		MESSAGE_BEGIN( MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, NULL, pEntity );
+	if (pEntity)
+		MESSAGE_BEGIN(MSG_ONE_UNRELIABLE, SVC_TEMPENTITY, NULL, pEntity);
 	else
-		MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
+		MESSAGE_BEGIN(MSG_BROADCAST, SVC_TEMPENTITY);
 
 	WRITE_BYTE(29);
 	WRITE_BYTE(textparms.channel & 0xFF);
-	WRITE_SHORT(FixedSigned16(textparms.x, (1<<13) ));
-	WRITE_SHORT(FixedSigned16(textparms.y, (1<<13) ));
+	WRITE_SHORT(FixedSigned16(textparms.x, (1<<13)));
+	WRITE_SHORT(FixedSigned16(textparms.y, (1<<13)));
 	WRITE_BYTE(textparms.effect);
 	WRITE_BYTE(textparms.r1);
 	WRITE_BYTE(textparms.g1);
@@ -221,30 +262,34 @@ void UTIL_HudMessage(edict_t *pEntity, const hudtextparms_t &textparms, char *pM
 	WRITE_BYTE(255);
 	WRITE_BYTE(250);
 	WRITE_BYTE(0);
-	WRITE_SHORT(FixedUnsigned16(textparms.fadeinTime, (1<<8) ));
-	WRITE_SHORT(FixedUnsigned16(textparms.fadeoutTime, (1<<8) ));
-	WRITE_SHORT(FixedUnsigned16(textparms.holdTime, (1<<8) ));
-	if (textparms.effect==2)
-		WRITE_SHORT(FixedUnsigned16(textparms.fxTime, (1<<8) ) );
+	WRITE_SHORT(FixedUnsigned16(textparms.fadeinTime, (1<<8)));
+	WRITE_SHORT(FixedUnsigned16(textparms.fadeoutTime, (1<<8)));
+	WRITE_SHORT(FixedUnsigned16(textparms.holdTime, (1<<8)));
+	
+	if (textparms.effect == 2)
+		WRITE_SHORT(FixedUnsigned16(textparms.fxTime, (1<<8)));
+	
 	WRITE_STRING(pMessage);
 	MESSAGE_END();
 }
 
 /* warning - buffer of msg must be longer than 190 chars!
 (here in AMX it is always longer) */
-void UTIL_ClientPrint( edict_t *pEntity, int msg_dest,  char *msg )
+void UTIL_ClientPrint(edict_t *pEntity, int msg_dest, char *msg)
 {
 	if (!gmsgTextMsg)
 		return;				// :TODO: Maybe output a warning log?
 
 	char c = msg[190];
 	msg[190] = 0;			// truncate without checking with strlen()
-	if ( pEntity )
-		MESSAGE_BEGIN( MSG_ONE, gmsgTextMsg, NULL, pEntity );
+	
+	if (pEntity)
+		MESSAGE_BEGIN(MSG_ONE, gmsgTextMsg, NULL, pEntity);
 	else
-		MESSAGE_BEGIN( MSG_BROADCAST , gmsgTextMsg);
-	WRITE_BYTE( msg_dest );
-	WRITE_STRING( msg );
+		MESSAGE_BEGIN(MSG_BROADCAST, gmsgTextMsg);
+	
+	WRITE_BYTE(msg_dest);
+	WRITE_STRING(msg);
 	MESSAGE_END();
 	msg[190] = c;
 }
@@ -260,17 +305,6 @@ void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1,
 {
 	if (!cmd) 
 		return;						// no command 
- /*
-	char clCmd[256]; 
-	snprintf(g_fakecmd.args, 255, "%s%s%s%s%s", cmd, 
-		arg1 ? " " : "", arg1 ? arg1 : "",  
-		arg2 ? " " : "", arg2 ? arg2 : ""); 
-	clCmd[255] = 0; 
-	CLIENT_COMMAND(pEdict, clCmd); 
-	return; 
-	*/
-	if (!cmd)
-		return;						// no command
 
 	// store command
 	g_fakecmd.argv[0] = cmd;
@@ -299,7 +333,7 @@ void UTIL_FakeClientCommand(edict_t *pEdict, const char *cmd, const char *arg1,
 		// store argument
 		g_fakecmd.argv[1] = arg1;
 		// build argument line
-		snprintf( g_fakecmd.args, 255, "%s", arg1);
+		snprintf(g_fakecmd.args, 255, "%s", arg1);
 		// if snprintf reached 255 chars limit, this will make sure there will be no access violation
 		g_fakecmd.args[255] = 0;
 	}

amxmodx/vault.cpp

@@ -34,52 +34,49 @@
 
 Vault g_vault;
 
-static cell AMX_NATIVE_CALL set_vaultdata(AMX *amx,cell *params)
+static cell AMX_NATIVE_CALL set_vaultdata(AMX *amx, cell *params)
 {
 	int iLen;
 
-  g_vault.put( get_amxstring(amx,params[1],0,iLen) , get_amxstring(amx,params[2],1,iLen) );
+	g_vault.put(get_amxstring(amx, params[1], 0, iLen), get_amxstring(amx, params[2], 1, iLen));
 	g_vault.saveVault();
 
 	return 1;
 }
 
-static cell AMX_NATIVE_CALL get_vaultdata(AMX *amx,cell *params)
+static cell AMX_NATIVE_CALL get_vaultdata(AMX *amx, cell *params)
 {
 	int iLen;
+	const char* key = get_amxstring(amx, params[1], 0, iLen);
 
-  const char* key = get_amxstring(amx,params[1],0,iLen);
+	if (params[3])
+		return set_amxstring(amx, params[2], g_vault.get(key), params[3]);
 
-  if ( params[3] )
-    return set_amxstring( amx , params[2] , g_vault.get( key ) , params[3] );
-
-  return g_vault.get_number( key );
+	return g_vault.get_number(key);
 }
 
-static cell AMX_NATIVE_CALL remove_vaultdata(AMX *amx,cell *params)
+static cell AMX_NATIVE_CALL remove_vaultdata(AMX *amx, cell *params)
 {
 	int iLen;
 
-  g_vault.remove( get_amxstring(amx,params[1],0,iLen) );
+	g_vault.remove(get_amxstring(amx, params[1], 0, iLen));
 	g_vault.saveVault();
 
 	return 1;
 }
 
-static cell AMX_NATIVE_CALL vaultdata_exists(AMX *amx,cell *params)
+static cell AMX_NATIVE_CALL vaultdata_exists(AMX *amx, cell *params)
 {
 	int iLen;
-
-  return g_vault.exists( get_amxstring(amx,params[1],0,iLen) ) ? 1 : 0;
+	return g_vault.exists(get_amxstring(amx, params[1], 0, iLen)) ? 1 : 0;
 }
 
-AMX_NATIVE_INFO vault_Natives[] = {
-  { "set_vaultdata",  set_vaultdata },
-  { "get_vaultdata",  get_vaultdata },
-  { "remove_vaultdata", remove_vaultdata  },
-  { "delete_vaultdata", remove_vaultdata  },
-  { "vaultdata_exists", vaultdata_exists  },
-  { 0, 0 }
+AMX_NATIVE_INFO vault_Natives[] =
+{
+	{"set_vaultdata",		set_vaultdata},
+	{"get_vaultdata",		get_vaultdata},
+	{"remove_vaultdata",	remove_vaultdata},
+	{"delete_vaultdata",	remove_vaultdata},
+	{"vaultdata_exists",	vaultdata_exists},
+	{0,						0}
 };
-
-

amxmodx/version.rc

@@ -1,8 +1,34 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
 #include "winres.h"
 
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 0,2,0,0
- PRODUCTVERSION 0,2,0,0
+ FILEVERSION 1,7,1,0
+ PRODUCTVERSION 1,7,1,0
  FILEFLAGSMASK 0x17L
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -17,14 +43,14 @@ BEGIN
     BEGIN
         BLOCK "000004b0"
         BEGIN
-   VALUE "Comments", "AMX Mod X\0"
-   VALUE "FileDescription", "AMX Mod X\0"
-   VALUE "FileVersion", "0.20\0"
-   VALUE "InternalName", "amxmodx\0"
-   VALUE "LegalCopyright", "Copyright (c) 2004, AMX Mod X Dev Team\0"
-   VALUE "OriginalFilename", "amxx_mm.dll\0"
-   VALUE "ProductName", "AMX Mod X\0"
-   VALUE "ProductVersion", "0.20\0"
+            VALUE "Comments", "AMX Mod X"
+            VALUE "FileDescription", "AMX Mod X"
+            VALUE "FileVersion", "1.71"
+            VALUE "InternalName", "amxmodx"
+            VALUE "LegalCopyright", "Copyright (c) 2004-2006, AMX Mod X Dev Team"
+            VALUE "OriginalFilename", "amxmodx_mm.dll"
+            VALUE "ProductName", "AMX Mod X"
+            VALUE "ProductVersion", "1.71"
         END
     END
     BLOCK "VarFileInfo"
@@ -32,3 +58,45 @@ BEGIN
         VALUE "Translation", 0x0, 1200
     END
 END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+