Removed STD code

dlls/pgsql/CString.h

@@ -0,0 +1,90 @@
+#ifndef _INCLUDE_CSTRING_H
+#define _INCLUDE_CSTRING_H
+
+//by David "BAILOPAN" Anderson
+class CString
+{
+public:
+	CString() { v = NULL; mSize = 0; }
+	~CString() { if (v) delete [] v; }
+
+	const char *c_str() { return v?v:""; }
+
+	void append(const char *t)
+	{
+		Grow(strlen(v) + strlen(t));
+		strcat(v, t);
+	}
+
+	void append(CString &d)
+	{
+		const char *t = d.c_str();
+		Grow(strlen(v) + strlen(t));
+		strcat(v, t);
+	}
+
+	void assign(const char *d)
+	{
+		if (!d)
+		{
+			Grow(1);
+			strcpy(v, "");
+			return;
+		}
+		Grow(strlen(d));
+		strcpy(v, d);
+	}
+
+	void clear()
+	{
+		if (v)
+			delete [] v;
+		v = NULL;
+		mSize = 0;
+	}
+
+	int compare (const char *d)
+	{
+		if (v) {
+			if (d) {
+				return strcmp(v, d);
+			} else {
+				return strlen(v);
+			}
+		} else {
+			if (d) {
+				return strlen(d);
+			} else {
+				return 0;
+			}
+		}
+	}
+
+	int size()
+	{
+		if (!v)
+			return 0;
+		return strlen(v);
+	}
+
+private:
+	void Grow(int d)
+	{
+		if (d > mSize)
+		{
+			char *t = new char[d+1];
+			if (v) {
+				strcpy(t, v);
+				t[strlen(v)] = 0;
+				delete [] v;
+			}
+			v = t;
+			mSize = d;
+		}
+	}
+
+	char *v;
+	int mSize;
+};
+
+#endif //_INCLUDE_CSTRING_H

dlls/pgsql/CVector.h

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

dlls/pgsql/pgsql.cpp

@@ -31,25 +31,22 @@
 *	version.
 */
 
-#include <vector>
 #include "pgsql_amx.h"
 #include "amxxmodule.h"
 
-using namespace std;
+CVector<SQLResult*> Results;
-
+CVector<SQL*> DBList;
-std::vector<SQLResult*> Results;
-std::vector<SQL*> DBList;
 
 int sql_exists(const char* host,const char* user,const char* pass,const char* dbase) {
-	vector<SQL*>::iterator i;
+	unsigned int i = 0;
 	int id = 0;
-	for (i=DBList.begin(); i!=DBList.end(); i++) {
+	for (i=0; i<=DBList.size(); i++) {
 		id++;
-		if (((*i)->Host.compare(host) == 0) &&
+		if ((DBList[i]->Host.compare(host) == 0) &&
-			((*i)->Username.compare(user) == 0) &&
+			(DBList[i]->Username.compare(user) == 0) &&
-			((*i)->Password.compare(pass) == 0) &&
+			(DBList[i]->Password.compare(pass) == 0) &&
-			((*i)->Database.compare(dbase) == 0) &&
+			(DBList[i]->Database.compare(dbase) == 0) &&
-			(!(*i)->isFree)) {
+			(!DBList[i]->isFree)) {
 				return id;
 		}
 	}

dlls/pgsql/pgsql_amx.cpp

@@ -1,7 +1,5 @@
 #include "pgsql_amx.h"
 
-using namespace std;
-
 bool is_ipaddr(const char *IP)
 {
 	do {

dlls/pgsql/pgsql_amx.h

@@ -1,7 +1,9 @@
-#include <vector>
+#include <stdio.h>
-#include <string>
+#include <stdlib.h>
-#include <map>
+#include <string.h>
 #include <libpq-fe.h>
+#include "CVector.h"
+#include "CString.h"
 #include "amxxmodule.h"
 
 class SQL
@@ -16,14 +18,14 @@ public:
 
 	PGconn *cn;
 
-	std::string ErrorStr;
+	CString ErrorStr;
 	int ErrorCode;
 
-	std::string Host;
+	CString Host;
-	std::string Password;
+	CString Password;
-	std::string Username;
+	CString Username;
-	std::string Database;
+	CString Database;
-	std::string cstr;
+	CString cstr;
 
 	bool isFree;
 };
@@ -45,10 +47,10 @@ public:
 	int RowCount;
 	bool isFree;
 	SQL *sql;
-	std::vector<const char *> Fields;
+	CVector<const char *> Fields;
 };
 
 char *amx_string(AMX *amx, cell &param, int &len);
 
-extern std::vector<SQLResult*> Results;
+extern CVector<SQLResult*> Results;
-extern std::vector<SQL*> DBList;
+extern CVector<SQL*> DBList;

dlls/pgsql/pgsql_amx.vcproj

@@ -188,6 +188,12 @@
 		<Filter
 			Name="Header Files"
 			Filter="h;hpp;hxx;hm;inl">
+			<File
+				RelativePath=".\CString.h">
+			</File>
+			<File
+				RelativePath=".\CVector.h">
+			</File>
 			<File
 				RelativePath="pgsql_amx.h">
 			</File>