hydrar/mistserver
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Library code style update + some minor backports from Pro edition

Browse source
This commit is contained in:
Erik Zandvliet 2018-12-03 23:51:48 +01:00 • committed by Thulinma
parent 593b291e85
commit 2607113727
68 changed files with 4538 additions and 4665 deletions
Download patch file Download diff file Expand all files Collapse all files

74
lib/bitfields.cpp
View file

@ -1,33 +1,32 @@
#include "bitfields.h"
#include <string.h>
/// Takes a pointer, offset bitcount and data bitcount, returning the unsigned int read from the givens.
/// offsetBits may be > 7, in which case offsetBits / 8 is added to the pointer automatically.
/// This function assumes Most Significant Bits first.
/// If dataBits > 64, only the last 64 bits are returned.
unsigned long long Bit::getMSB(char * pointer, unsigned int offsetBits, unsigned int dataBits){
//If the offset is a whole byte or more, add the whole bytes to the pointer instead.
/// Takes a pointer, offset bitcount and data bitcount, returning the unsigned int read from the
/// givens. offsetBits may be > 7, in which case offsetBits / 8 is added to the pointer
/// automatically. This function assumes Most Significant Bits first. If dataBits > 64, only the
/// last 64 bits are returned.
unsigned long long Bit::getMSB(char *pointer, unsigned int offsetBits, unsigned int dataBits){
// If the offset is a whole byte or more, add the whole bytes to the pointer instead.
pointer += offsetBits >> 3;
//The offset is now guaranteed less than a whole byte.
// The offset is now guaranteed less than a whole byte.
offsetBits &= 0x07;
unsigned long long retVal = 0;
//Now we parse the remaining bytes
// Now we parse the remaining bytes
while (dataBits){
//Calculate how many bits we're reading from this byte
//We assume all except for the offset
// Calculate how many bits we're reading from this byte
// We assume all except for the offset
unsigned int curBits = 8 - offsetBits;
//If that is too much, we use the remainder instead
if (curBits > dataBits){
curBits = dataBits;
}
//First, shift the current return value by the amount of bits we're adding
// If that is too much, we use the remainder instead
if (curBits > dataBits){curBits = dataBits;}
// First, shift the current return value by the amount of bits we're adding
retVal <<= curBits;
//Next, add those bits from the current pointer position at the correct offset, increasing the pointer by one
// Next, add those bits from the current pointer position at the correct offset, increasing the
// pointer by one
retVal |= ((int)(*(pointer++)) << offsetBits) >> (8 - curBits);
//Finally, set the offset to zero and remove curBits from dataBits.
// Finally, set the offset to zero and remove curBits from dataBits.
offsetBits = 0;
dataBits -= curBits;
}//Loop until we run out of dataBits, then return the result
}// Loop until we run out of dataBits, then return the result
return retVal;
}
@ -36,45 +35,42 @@ unsigned long long Bit::getMSB(char * pointer, unsigned int offsetBits, unsigned
/// This function assumes Most Significant Bits first.
/// WARNING: UNFINISHED. DO NOT USE.
/// \todo Finish writing this - untested atm.
void Bit::setMSB(char * pointer, unsigned int offsetBits, unsigned int dataBits, unsigned long long value){
//Set the pointer to the last byte we need to be setting
void Bit::setMSB(char *pointer, unsigned int offsetBits, unsigned int dataBits,
unsigned long long value){
// Set the pointer to the last byte we need to be setting
pointer += (offsetBits + dataBits) >> 3;
//The offset is now guaranteed less than a whole byte.
// The offset is now guaranteed less than a whole byte.
offsetBits = (offsetBits + dataBits) & 0x07;
unsigned long long retVal = 0;
//Now we set the remaining bytes
// Now we set the remaining bytes
while (dataBits){
//Calculate how many bits we're setting in this byte
//We assume all that will fit in the current byte
// Calculate how many bits we're setting in this byte
// We assume all that will fit in the current byte
unsigned int curBits = offsetBits;
//If that is too much, we use the remainder instead
if (curBits > dataBits){
curBits = dataBits;
}
//Set the current pointer position at the correct offset, increasing the pointer by one
// If that is too much, we use the remainder instead
if (curBits > dataBits){curBits = dataBits;}
// Set the current pointer position at the correct offset, increasing the pointer by one
retVal |= ((int)(*(pointer++)) << offsetBits) >> (8 - curBits);
*pointer = (((*pointer) << offsetBits) >> offsetBits) | ((value & 0xFF) << (8 - offsetBits));
--pointer;
//Finally, shift the current value by the amount of bits we're adding
// Finally, shift the current value by the amount of bits we're adding
value >>= offsetBits;
//... and set the offset to eight and remove curBits from dataBits.
offsetBits = 8;
dataBits -= curBits;
}//Loop until we run out of dataBits, then return the result
}// Loop until we run out of dataBits, then return the result
}
/// Parses a string reference to a boolean.
/// Returns true if the string, with whitespace removed and converted to lowercase, prefix-matches any of: "1", "yes", "true", "cont".
/// Returns false otherwise.
bool Util::stringToBool(std::string & str){
/// Returns true if the string, with whitespace removed and converted to lowercase, prefix-matches
/// any of: "1", "yes", "true", "cont". Returns false otherwise.
bool Util::stringToBool(std::string &str){
std::string tmp;
tmp.reserve(4);
for (unsigned int i = 0; i < str.size() && tmp.size() < 4; ++i){
if (!::isspace(str[i])){
tmp.push_back((char)tolower(str[i]));
}
if (!::isspace(str[i])){tmp.push_back((char)tolower(str[i]));}
}
return (strncmp(tmp.c_str(), "1", 1) == 0 || strncmp(tmp.c_str(), "yes", 3) == 0 || strncmp(tmp.c_str(), "true", 4) == 0 || strncmp(tmp.c_str(), "cont", 4) == 0);
return (strncmp(tmp.c_str(), "1", 1) == 0 || strncmp(tmp.c_str(), "yes", 3) == 0 ||
strncmp(tmp.c_str(), "true", 4) == 0 || strncmp(tmp.c_str(), "cont", 4) == 0);
}