diff options
| -rw-r--r-- | src/macros.h | 117 |
1 files changed, 75 insertions, 42 deletions
diff --git a/src/macros.h b/src/macros.h index 1982e939e..2f5a9b48f 100644 --- a/src/macros.h +++ b/src/macros.h @@ -8,7 +8,7 @@ /** * Fetch n bits from x, started at bit s. * - * This macro can be used to fetch n bits from the value x. The + * This function can be used to fetch n bits from the value x. The * s value set the startposition to read. The startposition is * count from the LSB and starts at 0. The result starts at a * LSB, as this isn't just an and-bitmask but also some @@ -21,11 +21,14 @@ * @param n The number of bits to read. * @return The selected bits, aligned to a LSB. */ -#define GB(x, s, n) (((x) >> (s)) & ((1U << (n)) - 1)) +template<typename T> static inline uint GB(const T x, const uint8 s, const uint8 n) +{ + return (x >> s) & ((1U << n) - 1); +} /** Set n bits from x starting at bit s to d * - * This macro sets n bits from x which started as bit s to the value of + * This function sets n bits from x which started as bit s to the value of * d. The parameters x, s and n works the same as the parameters of * #GB. The result is saved in x again. Unused bits in the window * provided by n are set to 0 if the value of b isn't "big" enough. @@ -40,7 +43,12 @@ * @param d The actually new bits to save in the defined position. * @return The new value of x */ -#define SB(x, s, n, d) ((x) = ((x) & ~(((1U << (n)) - 1) << (s))) | ((d) << (s))) +template<typename T, typename U> static inline T SB(T& x, const uint8 s, const uint8 n, const U d) +{ + x &= (T)(~(((1U << n) - 1) << s)); + x |= (T)(d << s); + return x; +} /** Add i to n bits of x starting at bit s. * @@ -56,7 +64,13 @@ * @param i The value to add at the given startposition in the given window. * @return The new value of x */ -#define AB(x, s, n, i) ((x) = ((x) & ~(((1U << (n)) - 1) << (s))) | (((x) + ((i) << (s))) & (((1U << (n)) - 1) << (s)))) +template<typename T, typename U> static inline T AB(T& x, const uint8 s, const uint8 n, const U i) +{ + const T tmp = (T)(((1U << n) - 1) << s); + x &= ~tmp; + x |= (T)((x + (i << s)) & tmp); + return x; +} #ifdef min #undef min @@ -223,23 +237,6 @@ static inline uint32 BIGMULUS(const uint32 a, const uint32 b, const uint8 shift) return (uint32)((uint64)a * (uint64)b >> shift); } - -/** - * Checks if a value is between a window started at some base point. - * - * This macro checks if the value x is between the value of base - * and base+size. If x equals base this returns true. If x equals - * base+size this returns false. - * - * @param x The value to check - * @param base The base value of the interval - * @param size The size of the interval - * @return True if the value is in the interval, false else. - */ -/* OPT: optimized into an unsigned comparison */ -//#define IS_INSIDE_1D(x, base, size) ((x) >= (base) && (x) < (base) + (size)) -#define IS_INSIDE_1D(x, base, size) ( (uint)((x) - (base)) < ((uint)(size)) ) - /** * Checks if a bit in a value is set. * @@ -384,20 +381,10 @@ extern const byte _ffb_64[64]; */ static inline int FindFirstBit2x64(int value) { -/* - int i = 0; - if ( (byte) value == 0) { - i += 8; - value >>= 8; - } - return i + FIND_FIRST_BIT(value & 0x3F); - -Faster ( or at least cleaner ) implementation below? -*/ - if (GB(value, 0, 8) == 0) { - return FIND_FIRST_BIT(GB(value, 8, 6)) + 8; + if ((value & 0xFF) == 0) { + return FIND_FIRST_BIT((value >> 8) & 0x3F) + 8; } else { - return FIND_FIRST_BIT(GB(value, 0, 6)); + return FIND_FIRST_BIT(value & 0x3F); } } @@ -424,7 +411,7 @@ template<typename T> static inline T KillFirstBit(T value) */ template<typename T> static inline uint CountBits(T value) { - register uint num; + uint num; /* This loop is only called once for every bit set by clearing the lowest * bit in each loop. The number of bits is therefore equal to the number of @@ -439,6 +426,23 @@ template<typename T> static inline uint CountBits(T value) } /** + * Checks if a value is between a window started at some base point. + * + * This function checks if the value x is between the value of base + * and base+size. If x equals base this returns true. If x equals + * base+size this returns false. + * + * @param x The value to check + * @param base The base value of the interval + * @param size The size of the interval + * @return True if the value is in the interval, false else. + */ +template<typename T> static inline bool IS_INSIDE_1D(const T x, const int base, const uint size) +{ + return (uint)(x - base) < size; +} + +/** * Checks if a byte is in an interval. * * This macro returns true if a byte value is in the interval of [min, max). @@ -496,10 +500,13 @@ template<typename T> static inline uint CountBits(T value) * * @param a The numerator of the fraction, see CHANCE16 * @param b The denominator of the fraction, see CHANCE16 - * @param v The given randomize-number + * @param r The given randomize-number * @return True if v is less or equals (a/b) */ -#define CHANCE16I(a, b, v) ((uint16)(v) <= (uint16)((65536 * (a)) / (b))) +static inline bool CHANCE16I(const uint a, const uint b, const uint32 r) +{ + return (uint16)r <= (uint16)((65536 * a) / b); +} #define for_each_bit(_i, _b) \ @@ -525,17 +532,43 @@ static inline uint16 ReadLE16Unaligned(const void* x) /** - * ROtate x Left/Right by n (must be >= 0) + * ROtate x Left by n + * + * @note Assumes a byte has 8 bits + * @param x The value which we want to rotate + * @param n The number how many we waht to rotate + * @return A bit rotated number + */ +template<typename T> static inline T ROL(const T x, const uint8 n) +{ + return (T)(x << n | x >> (sizeof(x) * 8 - n)); +} + +/** + * ROtate x Right by n + * * @note Assumes a byte has 8 bits + * @param x The value which we want to rotate + * @param n The number how many we waht to rotate + * @return A bit rotated number */ -#define ROL(x, n) ((x) << (n) | (x) >> (sizeof(x) * 8 - (n))) -#define ROR(x, n) ((x) >> (n) | (x) << (sizeof(x) * 8 - (n))) +template<typename T> static inline T ROR(const T x, const uint8 n) +{ + return (T)(x >> n | x << (sizeof(x) * 8 - n)); +} /** * Return the smallest multiple of n equal or greater than x + * * @note n must be a power of 2 + * @param x The min value + * @param n The base of the number we are searching + * @return The smallest multiple of n equal or greater than x */ -#define ALIGN(x, n) (((x) + (n) - 1) & ~((n) - 1)) +template<typename T> static inline T ALIGN(const T x, uint n) { + n--; + return (T)((x + n) & ~(n)); +} /** return the largest value that can be entered in a variable. */ |