X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fhashcomp.cpp;h=ff2bf0572fab3bb5a8b721bb9542cb00dc74023e;hb=bc8ba059b9463d21112510325700db0c7a50df3f;hp=168bcbe0fec879ee9e6d957405b06d2f5cd5e02b;hpb=68af3d922102d2e9ff6ba2e5820544dfa3469394;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp index 168bcbe0f..ff2bf0572 100644 --- a/src/hashcomp.cpp +++ b/src/hashcomp.cpp @@ -86,10 +86,10 @@ size_t nspace::hash::operator()(const string &s) const * only with *x replaced with lowermap[*x]. * This avoids a copy to use hash */ - unsigned long t = 0; - for (const char* x = s.c_str(); *x; x++) + 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 size_t(t); + 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 :, @@ -309,3 +314,273 @@ const char* irc::Spacify(char* n) } +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() +{ + /* We start with 4 bytes allocated which is room + * for 4 items. Something makes me doubt its worth + * allocating less than 4 bytes. + */ + bits_size = 4; + 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; + printf("Just allocate at %d:%2x\n", i, current_pos); + return std::make_pair(i, current_pos); + } + } + } + printf("Grow set to size %d\n", bits_size + 1); + /* 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; + freebits[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; + } +} + +bool irc::dynamicbitmask::Get(irc::bitfield &pos) +{ + if (pos.first < bits_size) + return (bits[pos.first] & pos.second); + else + return false; +} + +size_t irc::dynamicbitmask::GetSize() +{ + return bits_size; +} +