X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fhashcomp.cpp;h=71d9f0ca920b421edc9823fbef335644b03f22af;hb=af7e1a1ca8b36064593becf62b1a91468ad32237;hp=a0394b0f95667d61e8ae710f9136694dc004ee87;hpb=9cf56d917d92959701694477f7944d45ad2c38ed;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp
index a0394b0f9..71d9f0ca9 100644
--- a/src/hashcomp.cpp
+++ b/src/hashcomp.cpp
@@ -2,7 +2,7 @@
  *       | Inspire Internet Relay Chat Daemon |
  *       +------------------------------------+
  *
- *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
+ *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
  * See: http://www.inspircd.org/wiki/index.php/Credits
  *
  * This program is free but copyrighted software; see
@@ -11,6 +11,8 @@
  * ---------------------------------------------------
  */
 
+/* $Core: libIRCDhash */
+
 #include "inspircd.h"
 #include "hashcomp.h"
 #ifndef WIN32
@@ -47,8 +49,6 @@ using stdext::hash_map;
  *
  ******************************************************/
 
-using namespace irc::sockets;
-
 /* convert a string to lowercase. Note following special circumstances
  * taken from RFC 1459. Many "official" server branches still hold to this
  * rule so i will too;
@@ -68,9 +68,9 @@ void nspace::strlower(char *n)
 }
 
 #ifndef WIN32
-size_t nspace::hash<string>::operator()(const string &s) const
+size_t nspace::hash<std::string>::operator()(const std::string &s) const
 #else
-size_t nspace::hash_compare<string, std::less<string> >::operator()(const string &s) const
+size_t nspace::hash_compare<std::string, std::less<std::string> >::operator()(const std::string &s) const
 #endif
 {
 	/* XXX: NO DATA COPIES! :)
@@ -138,15 +138,15 @@ int irc::irc_char_traits::compare(const char* str1, const char* str2, size_t n)
 	for(unsigned int i = 0; i < n; i++)
 	{
 		if(lowermap[(unsigned char)*str1] > lowermap[(unsigned char)*str2])
-       			return 1;
+			return 1;
 
 		if(lowermap[(unsigned char)*str1] < lowermap[(unsigned char)*str2])
-		       	return -1;
+			return -1;
 
 		if(*str1 == 0 || *str2 == 0)
-		      	return 0;
+		   	return 0;
 
-	       	str1++;
+		str1++;
 		str2++;
 	}
 	return 0;
@@ -211,17 +211,41 @@ bool irc::tokenstream::GetToken(std::string &token)
 
 		n++;
 	}
-	token = "";
+	token.clear();
 	return false;
 }
 
+bool irc::tokenstream::GetToken(irc::string &token)
+{
+	std::string stdstring;
+	bool returnval = GetToken(stdstring);
+	token = assign(stdstring);
+	return returnval;
+}
+
+bool irc::tokenstream::GetToken(int &token)
+{
+	std::string tok;
+	bool returnval = GetToken(tok);
+	token = ConvToInt(tok);
+	return returnval;
+}
+
+bool irc::tokenstream::GetToken(long &token)
+{
+	std::string tok;
+	bool returnval = GetToken(tok);
+	token = ConvToInt(tok);
+	return returnval;
+}
+
 irc::sepstream::sepstream(const std::string &source, char seperator) : tokens(source), sep(seperator)
 {
 	last_starting_position = tokens.begin();
 	n = tokens.begin();
 }
 
-const std::string irc::sepstream::GetToken()
+bool irc::sepstream::GetToken(std::string &token)
 {
 	std::string::iterator lsp = last_starting_position;
 
@@ -230,18 +254,22 @@ const std::string irc::sepstream::GetToken()
 		if ((*n == sep) || (n+1 == tokens.end()))
 		{
 			last_starting_position = n+1;
-			std::string strip = std::string(lsp, n+1 == tokens.end() ? n+1  : n++);
+			token = std::string(lsp, n+1 == tokens.end() ? n+1  : n++);
 
-			while ((strip.length()) && (strip.find_last_of(sep) == strip.length() - 1))
-				strip.erase(strip.end() - 1);
+			while ((token.length()) && (token.find_last_of(sep) == token.length() - 1))
+				token.erase(token.end() - 1);
 
-			return strip;
+			if (token.empty())
+				n++;
+
+			return n == tokens.end() ? false : true;
 		}
 
 		n++;
 	}
 
-	return "";
+	token = "";
+	return false;
 }
 
 const std::string irc::sepstream::GetRemaining()
@@ -266,19 +294,17 @@ std::string irc::hex(const unsigned char *raw, size_t rawsz)
 	/* EWW! This used to be using sprintf, which is WAY inefficient. -Special */
 	
 	const char *hex = "0123456789abcdef";
-
-	std::string buf;
-	buf.reserve(rawsz * 2 + 1);
+	static char hexbuf[MAXBUF];
 
 	size_t i, j;
 	for (i = 0, j = 0; j < rawsz; ++j)
 	{
-		buf[i++] = hex[raw[j] / 16];
-		buf[i++] = hex[raw[j] % 16];
+		hexbuf[i++] = hex[raw[j] / 16];
+		hexbuf[i++] = hex[raw[j] % 16];
 	}
-	buf[i] = '\0';
+	hexbuf[i] = 0;
 
-	return buf;
+	return hexbuf;
 }
 
 CoreExport const char* irc::Spacify(const char* n)
@@ -336,7 +362,7 @@ int irc::modestacker::GetStackedLine(std::deque<std::string> &result, int max_li
 	if (sequence.size() > 1)
 		nextsize = sequence[1].length() + 2;
 
-	while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < MAXMODES+1) && ((size + nextsize) < max_line_size))
+	while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < MAXMODES) && ((size + nextsize) < max_line_size))
 	{
 		result[0] += *(sequence[0].begin());
 		if (!sequence[1].empty())
@@ -431,16 +457,15 @@ long irc::portparser::GetToken()
 			in_range = 0;
 	}
 
-	std::string x = sep->GetToken();
+	std::string x;
+	sep->GetToken(x);
 
-	if (x == "")
+	if (x.empty())
 		return 0;
 
 	while (Overlaps(atoi(x.c_str())))
 	{
-		x = sep->GetToken();
-
-		if (x == "")
+		if (!sep->GetToken(x))
 			return 0;
 	}
 
@@ -484,7 +509,7 @@ irc::dynamicbitmask::~dynamicbitmask()
 	/* Tidy up the entire used memory on delete */
 	delete[] bits;
 }
-		          
+
 irc::bitfield irc::dynamicbitmask::Allocate()
 {
 	/* Yeah, this isnt too efficient, however a module or the core