1

/* $Id$ */

     2

     3

#ifndef MACROS_H

     4

#define MACROS_H

     5

     6

/// Fetch n bits starting at bit s from x

     7

#define GB(x, s, n) (((x) >> (s)) & ((1U << (n)) - 1))

     8

/// Set n bits starting at bit s in x to d

     9

#define SB(x, s, n, d) ((x) = ((x) & ~(((1U << (n)) - 1) << (s))) | ((d) << (s)))

    10

/// Add i to the n bits starting at bit s in x

    11

#define AB(x, s, n, i) ((x) = ((x) & ~(((1U << (n)) - 1) << (s))) | (((x) + ((i) << (s))) & (((1U << (n)) - 1) << (s))))

    12

    13

#ifdef min

    14

#undef min

    15

#endif

    16

    17

#ifdef max

    18

#undef max

    19

#endif

    20

    21

template <typename T>

    22

static inline T max(T a, T b)

    23

{

    24

	return a >= b ? a : b;

    25

}

    26

    27

static inline int min(int a, int b) { if (a <= b) return a; return b; }

    28

    29

static inline uint minu(uint a, uint b) { if (a <= b) return a; return b; }

    30

    31

    32

static inline int clamp(int a, int min, int max)

    33

{

    34

	if (a <= min) return min;

    35

	if (a >= max) return max;

    36

	return a;

    37

}

    38

    39

static inline uint clampu(uint a, uint min, uint max)

    40

{

    41

	if (a <= min) return min;

    42

	if (a >= max) return max;

    43

	return a;

    44

}

    45

    46

static inline int32 BIGMULSS(int32 a, int32 b, int shift)

    47

{

    48

	return (int32)((int64)a * (int64)b >> shift);

    49

}

    50

    51

static inline uint32 BIGMULUS(uint32 a, uint32 b, int shift)

    52

{

    53

	return (uint32)((uint64)a * (uint64)b >> shift);

    54

}

    55

    56

    57

/* OPT: optimized into an unsigned comparison */

    58

//#define IS_INSIDE_1D(x, base, size) ((x) >= (base) && (x) < (base) + (size))

    59

#define IS_INSIDE_1D(x, base, size) ( (uint)((x) - (base)) < ((uint)(size)) )

    60

    61

template<typename T> static inline bool HASBIT(T x, int y)

    62

{

    63

	return (x & ((T)1 << y)) != 0;

    64

}

    65

    66

template<typename T> static inline T SETBIT(T& x, int y)

    67

{

    68

	return x |= (T)1 << y;

    69

}

    70

    71

template<typename T> static inline T CLRBIT(T& x, int y)

    72

{

    73

	return x &= ~((T)1 << y);

    74

}

    75

    76

template<typename T> static inline T TOGGLEBIT(T& x, int y)

    77

{

    78

	return x ^= (T)1 << y;

    79

}

    80

    81

    82

// checking more bits. Maybe unneccessary, but easy to use

    83

#define HASBITS(x,y) ((x) & (y))

    84

#define SETBITS(x,y) ((x) |= (y))

    85

#define CLRBITS(x,y) ((x) &= ~(y))

    86

    87

#define GENERAL_SPRITE_COLOR(color) ((color) + PALETTE_RECOLOR_START)

    88

#define PLAYER_SPRITE_COLOR(owner) (GENERAL_SPRITE_COLOR(_player_colors[owner]))

    89

    90

extern const byte _ffb_64[128];

    91

/* Returns the position of the first bit that is not zero, counted from the

    92

 * left. Ie, 10110100 returns 2, 00000001 returns 0, etc. When x == 0 returns

    93

 * 0.

    94

 */

    95

#define FIND_FIRST_BIT(x) _ffb_64[(x)]

    96

/* Returns x with the first bit that is not zero, counted from the left, set

    97

 * to zero. So, 10110100 returns 10110000, 00000001 returns 00000000, etc.

    98

 */

    99

#define KILL_FIRST_BIT(x) _ffb_64[(x)+64]

   100

   101

static inline int FindFirstBit2x64(int value)

   102

{

   103

/*

   104

	int i = 0;

   105

	if ( (byte) value == 0) {

   106

		i += 8;

   107

		value >>= 8;

   108

	}

   109

	return i + FIND_FIRST_BIT(value & 0x3F);

   110

   111

Faster ( or at least cleaner ) implementation below?

   112

*/

   113

	if (GB(value, 0, 8) == 0) {

   114

		return FIND_FIRST_BIT(GB(value, 8, 6)) + 8;

   115

	} else {

   116

		return FIND_FIRST_BIT(GB(value, 0, 6));

   117

	}

   118

   119

}

   120

   121

static inline int KillFirstBit2x64(int value)

   122

{

   123

	if (GB(value, 0, 8) == 0) {

   124

		return KILL_FIRST_BIT(GB(value, 8, 6)) << 8;

   125

	} else {

   126

		return value & (KILL_FIRST_BIT(GB(value, 0, 6)) | 0x3F00);

   127

	}

   128

}

   129

   130

/** returns true if value a has only one bit set to 1 */

   131

#define HAS_SINGLE_BIT(a) ( ((a) & ((a) - 1)) == 0)

   132

   133

/* [min,max), strictly less than */

   134

#define IS_BYTE_INSIDE(a,min,max) ((byte)((a)-(min)) < (byte)((max)-(min)))

   135

#define IS_INT_INSIDE(a,min,max) ((uint)((a)-(min)) < (uint)((max)-(min)))

   136

   137

   138

#define CHANCE16(a,b) ((uint16)Random() <= (uint16)((65536 * (a)) / (b)))

   139

#define CHANCE16R(a,b,r) ((uint16)(r=Random()) <= (uint16)((65536 * (a)) / (b)))

   140

#define CHANCE16I(a,b,v) ((uint16)(v) <= (uint16)((65536 * (a)) / (b)))

   141

   142

   143

#define for_each_bit(_i, _b)            \

   144

	for (_i = 0; _b != 0; _i++, _b >>= 1) \

   145

		if (_b & 1)

   146

   147

#define abs myabs

   148

   149

   150

static inline uint16 ReadLE16Aligned(const void* x)

   151

{

   152

	return FROM_LE16(*(const uint16*)x);

   153

}

   154

   155

static inline uint16 ReadLE16Unaligned(const void* x)

   156

{

   157

#ifdef OTTD_ALIGNMENT

   158

	return ((const byte*)x)[0] | ((const byte*)x)[1] << 8;

   159

#else

   160

	return FROM_LE16(*(const uint16*)x);

   161

#endif

   162

}

   163

   164

   165

/**

   166

 * ROtate x Left/Right by n (must be >= 0)

   167

 * @note Assumes a byte has 8 bits

   168

 */

   169

#define ROL(x, n) ((x) << (n) | (x) >> (sizeof(x) * 8 - (n)))

   170

#define ROR(x, n) ((x) >> (n) | (x) << (sizeof(x) * 8 - (n)))

   171

   172

/**

   173

 * Return the smallest multiple of n equal or greater than x

   174

 * @note n must be a power of 2

   175

 */

   176

#define ALIGN(x, n) (((x) + (n) - 1) & ~((n) - 1))

   177

   178

/** return the largest value that can be entered in a variable.

   179

 */

   180

#define MAX_UVALUE(type) ((type)~(type)0)

   181

   182

#endif /* MACROS_H */