X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fhashcomp.cpp;h=a613a8073eab57502847d10326a65e883a8aa8c5;hb=c681081852491531151e96b4df31f6547755a390;hp=f98446ba6035eb261ee5574bf1123d56ad7bc74d;hpb=6a869d0701bbfe3c7a5e370793adfda4b5b45c65;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp index f98446ba6..a613a8073 100644 --- a/src/hashcomp.cpp +++ b/src/hashcomp.cpp @@ -56,7 +56,7 @@ void nspace::strlower(char *n) if (n) { for (char* t = n; *t; t++) - *t = lowermap[(unsigned char)*t]; + *t = national_case_insensitive_map[(unsigned char)*t]; } } @@ -73,12 +73,12 @@ void nspace::strlower(char *n) /* 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]. + * only with *x replaced with national_case_insensitive_map[*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]; + t = 5 * t + national_case_insensitive_map[(unsigned char)*x]; return t; } @@ -91,7 +91,7 @@ size_t nspace::hash_compare >::operator()(co { register size_t t = 0; for (irc::string::const_iterator x = s.begin(); x != s.end(); ++x) /* ++x not x++, as its faster */ - t = 5 * t + lowermap[(unsigned char)*x]; + t = 5 * t + national_case_insensitive_map[(unsigned char)*x]; return t; } @@ -100,9 +100,9 @@ bool irc::StrHashComp::operator()(const std::string& s1, const std::string& s2) const unsigned char* n1 = (const unsigned char*)s1.c_str(); const unsigned char* n2 = (const unsigned char*)s2.c_str(); for (; *n1 && *n2; n1++, n2++) - if (lowermap[*n1] != lowermap[*n2]) + if (national_case_insensitive_map[*n1] != national_case_insensitive_map[*n2]) return false; - return (lowermap[*n1] == lowermap[*n2]); + return (national_case_insensitive_map[*n1] == national_case_insensitive_map[*n2]); } /****************************************************** @@ -112,33 +112,33 @@ bool irc::StrHashComp::operator()(const std::string& s1, const std::string& s2) * std::string which is not only case-insensitive but * can also do scandanavian comparisons, e.g. { = [, etc. * - * This class depends on the const array 'lowermap'. + * This class depends on the const array 'national_case_insensitive_map'. * ******************************************************/ bool irc::irc_char_traits::eq(char c1st, char c2nd) { - return lowermap[(unsigned char)c1st] == lowermap[(unsigned char)c2nd]; + return national_case_insensitive_map[(unsigned char)c1st] == national_case_insensitive_map[(unsigned char)c2nd]; } bool irc::irc_char_traits::ne(char c1st, char c2nd) { - return lowermap[(unsigned char)c1st] != lowermap[(unsigned char)c2nd]; + return national_case_insensitive_map[(unsigned char)c1st] != national_case_insensitive_map[(unsigned char)c2nd]; } bool irc::irc_char_traits::lt(char c1st, char c2nd) { - return lowermap[(unsigned char)c1st] < lowermap[(unsigned char)c2nd]; + return national_case_insensitive_map[(unsigned char)c1st] < national_case_insensitive_map[(unsigned char)c2nd]; } 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]) + if(national_case_insensitive_map[(unsigned char)*str1] > national_case_insensitive_map[(unsigned char)*str2]) return 1; - if(lowermap[(unsigned char)*str1] < lowermap[(unsigned char)*str2]) + if(national_case_insensitive_map[(unsigned char)*str1] < national_case_insensitive_map[(unsigned char)*str2]) return -1; if(*str1 == 0 || *str2 == 0) @@ -152,7 +152,7 @@ int irc::irc_char_traits::compare(const char* str1, const char* str2, size_t n) const char* irc::irc_char_traits::find(const char* s1, int n, char c) { - while(n-- > 0 && lowermap[(unsigned char)*s1] != lowermap[(unsigned char)c]) + while(n-- > 0 && national_case_insensitive_map[(unsigned char)*s1] != national_case_insensitive_map[(unsigned char)c]) s1++; return s1; } @@ -501,129 +501,3 @@ long irc::portparser::GetToken() } } -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]; - memset(bits, 0, bits_size); -} - -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 - * should only be allocating bitfields on load, the Toggle and - * Get methods are O(1) as these are called much more often. - */ - unsigned char* freebits = this->GetFreeBits(); - for (unsigned char i = 0; i < bits_size; i++) - { - /* Yes, this is right. You'll notice we terminate the loop when !current_pos, - * this is because we logic shift our bit off the end of unsigned char, and its - * lost, making the loop counter 0 when we're done. - */ - 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 */ - - if (bits_size == 255) - /* Oh dear, cant grow it any further */ - throw std::bad_alloc(); - - unsigned char 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; - this->SetFreeBits(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) - { - this->GetFreeBits()[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) -{ - /* Range check the value */ - 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) -{ - /* Range check the value */ - if (pos.first < bits_size) - return (bits[pos.first] & pos.second); - else - /* We can't return false, otherwise we can't - * distinguish between failure and a cleared bit! - * Our only sensible choice is to throw (ew). - */ - throw ModuleException("irc::dynamicbitmask::Get(): Invalid bitfield, out of range"); -} - -unsigned char irc::dynamicbitmask::GetSize() -{ - return bits_size; -} -