X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fhashcomp.cpp;h=23d4928a627873607f3670c20df54828b26e4866;hb=11f73970236f910a63ff77fbc8e2ee4a8ee23bc3;hp=d3db02da488d448d08eee6a2a3f23caa5bb1b1dd;hpb=d4af574074d05cb5705cd261c8fb97f52290e56a;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp index d3db02da4..23d4928a6 100644 --- a/src/hashcomp.cpp +++ b/src/hashcomp.cpp @@ -80,16 +80,16 @@ size_t nspace::hash::operator()(const insp_inaddr &a) const size_t nspace::hash::operator()(const string &s) const { - char a[s.length()]; - size_t t = 0; - static struct hash strhash; - - for (const char* x = s.c_str(); *x; x++) /* Faster to do it this way than */ - a[t++] = lowermap[(unsigned char)*x]; /* Seperate strlcpy and strlower */ - - a[t] = 0; - - return strhash(a); + /* XXX: NO DATA COPIES! :) + * The hash function here is practically + * a copy of the one in STL's hash_fun.h, + * only with *x replaced with lowermap[*x]. + * This avoids a copy to use hash + */ + register size_t t = 0; + for (std::string::const_iterator x = s.begin(); x != s.end(); ++x) /* ++x not x++, as its faster */ + t = 5 * t + lowermap[(unsigned char)*x]; + return t; } bool irc::StrHashComp::operator()(const std::string& s1, const std::string& s2) const @@ -217,6 +217,11 @@ const std::string irc::tokenstream::GetToken() while (n != tokens.end()) { + /** Skip multi space, converting " " into " " + */ + while ((n+1 != tokens.end()) && (*n == ' ') && (*(n+1) == ' ')) + n++; + if ((last_pushed) && (*n == ':')) { /* If we find a token thats not the first and starts with :, @@ -248,22 +253,27 @@ const std::string irc::tokenstream::GetToken() return ""; } -irc::commasepstream::commasepstream(const std::string &source) : tokens(source) +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::commasepstream::GetToken() +const std::string irc::sepstream::GetToken() { std::string::iterator lsp = last_starting_position; while (n != tokens.end()) { - if ((*n == ',') || (n+1 == tokens.end())) + if ((*n == sep) || (n+1 == tokens.end())) { last_starting_position = n+1; - return std::string(lsp, n+1 == tokens.end() ? n+1 : n++); + std::string strip = 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); + + return strip; } n++; @@ -272,7 +282,7 @@ const std::string irc::commasepstream::GetToken() return ""; } -irc::commasepstream::~commasepstream() +irc::sepstream::~sepstream() { } @@ -293,3 +303,268 @@ std::string irc::hex(const unsigned char *raw, size_t rawsz) return buf; } +const char* irc::Spacify(char* n) +{ + static char x[MAXBUF]; + strlcpy(x,n,MAXBUF); + for (char* y = x; *y; y++) + if (*y == '_') + *y = ' '; + return x; +} + + +irc::modestacker::modestacker(bool add) : adding(add) +{ + sequence.clear(); + sequence.push_back(""); +} + +void irc::modestacker::Push(char modeletter, const std::string ¶meter) +{ + *(sequence.begin()) += modeletter; + sequence.push_back(parameter); +} + +void irc::modestacker::Push(char modeletter) +{ + this->Push(modeletter,""); +} + +void irc::modestacker::PushPlus() +{ + this->Push('+',""); +} + +void irc::modestacker::PushMinus() +{ + this->Push('-',""); +} + +int irc::modestacker::GetStackedLine(std::deque &result) +{ + int n = 0; + result.clear(); + result.push_back(adding ? "+" : "-"); + + while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < MAXMODES+1)) + { + result[0] += *(sequence[0].begin()); + if (!sequence[1].empty()) + result.push_back(sequence[1]); + sequence[0].erase(sequence[0].begin()); + sequence.erase(sequence.begin() + 1); + n++; + } + + return n; +} + +irc::stringjoiner::stringjoiner(const std::string &seperator, const std::vector &sequence, int begin, int end) +{ + for (int v = begin; v < end; v++) + joined.append(sequence[v]).append(seperator); + joined.append(sequence[end]); +} + +irc::stringjoiner::stringjoiner(const std::string &seperator, const std::deque &sequence, int begin, int end) +{ + for (int v = begin; v < end; v++) + joined.append(sequence[v]).append(seperator); + joined.append(sequence[end]); +} + +irc::stringjoiner::stringjoiner(const std::string &seperator, const char** sequence, int begin, int end) +{ + for (int v = begin; v < end; v++) + joined.append(sequence[v]).append(seperator); + joined.append(sequence[end]); +} + +std::string& irc::stringjoiner::GetJoined() +{ + return joined; +} + +irc::portparser::portparser(const std::string &source, bool allow_overlapped) : in_range(0), range_begin(0), range_end(0), overlapped(allow_overlapped) +{ + sep = new irc::commasepstream(source); + overlap_set.clear(); +} + +irc::portparser::~portparser() +{ + delete sep; +} + +bool irc::portparser::Overlaps(long val) +{ + if (!overlapped) + return false; + + if (overlap_set.find(val) == overlap_set.end()) + { + overlap_set[val] = true; + return false; + } + else + return true; +} + +long irc::portparser::GetToken() +{ + if (in_range > 0) + { + in_range++; + if (in_range <= range_end) + { + if (!Overlaps(in_range)) + { + return in_range; + } + else + { + while (((Overlaps(in_range)) && (in_range <= range_end))) + in_range++; + + if (in_range <= range_end) + return in_range; + } + } + else + in_range = 0; + } + + std::string x = sep->GetToken(); + + if (x == "") + return 0; + + while (Overlaps(atoi(x.c_str()))) + { + x = sep->GetToken(); + + if (x == "") + return 0; + } + + std::string::size_type dash = x.rfind('-'); + if (dash != std::string::npos) + { + std::string sbegin = x.substr(0, dash); + std::string send = x.substr(dash+1, x.length()); + range_begin = atoi(sbegin.c_str()); + range_end = atoi(send.c_str()); + + if ((range_begin > 0) && (range_end > 0) && (range_begin < 65536) && (range_end < 65536) && (range_begin < range_end)) + { + in_range = range_begin; + return in_range; + } + else + { + /* Assume its just the one port */ + return atoi(sbegin.c_str()); + } + } + else + { + return atoi(x.c_str()); + } +} + +irc::dynamicbitmask::dynamicbitmask() : bits_size(4) +{ + /* We start with 4 bytes allocated which is room + * for 4 items. Something makes me doubt its worth + * allocating less than 4 bytes. + */ + bits = new unsigned char[bits_size]; + freebits = new unsigned char[bits_size]; + memset(bits, 0, bits_size); + memset(freebits, 0, bits_size); +} + +irc::dynamicbitmask::~dynamicbitmask() +{ + /* Tidy up the entire used memory on delete */ + delete[] bits; + delete[] freebits; +} + +irc::bitfield irc::dynamicbitmask::Allocate() +{ + for (size_t i = 0; i < bits_size; i++) + { + for (unsigned char current_pos = 1; current_pos; current_pos = current_pos << 1) + { + if (!(freebits[i] & current_pos)) + { + freebits[i] |= current_pos; + return std::make_pair(i, current_pos); + } + } + } + /* We dont have any free space left, increase by one */ + int old_bits_size = bits_size; + bits_size++; + /* Allocate new bitfield space */ + unsigned char* temp_bits = new unsigned char[bits_size]; + unsigned char* temp_freebits = new unsigned char[bits_size]; + /* Copy the old data in */ + memcpy(temp_bits, bits, old_bits_size); + memcpy(temp_freebits, freebits, old_bits_size); + /* Delete the old data pointers */ + delete[] bits; + delete[] freebits; + /* Swap the pointers over so now the new + * pointers point to our member values + */ + bits = temp_bits; + freebits = temp_freebits; + /* Initialize the new byte on the end of + * the bitfields, pre-allocate the one bit + * for this allocation + */ + bits[old_bits_size] = 0; + bits[old_bits_size] = 1; + /* We already know where we just allocated + * the bitfield, so no loop needed + */ + return std::make_pair(old_bits_size, 1); +} + +bool irc::dynamicbitmask::Deallocate(irc::bitfield &pos) +{ + /* We dont bother to shrink the bitfield + * on deallocation, the most we could do + * is save one byte (!) and this would cost + * us a loop (ugly O(n) stuff) so we just + * clear the bit and leave the memory + * claimed -- nobody will care about one + * byte. + */ + if (pos.first < bits_size) + { + freebits[pos.first] &= ~pos.second; + return true; + } + /* They gave a bitfield outside of the + * length of our array. BAD programmer. + */ + return false; +} + +void irc::dynamicbitmask::Toggle(irc::bitfield &pos, bool state) +{ + if (pos.first < bits_size) + { + if (state) + /* Set state, OR the state in */ + bits[pos.first] |= pos.second; + else + /* Clear state, AND the !state out */ + bits[pos.first] &= ~pos.second; + } +} +