1

/* $Id$ */

     2

     3

/** @file macros.h */

     4

     5

#ifndef MACROS_H

     6

#define MACROS_H

     7

     8

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

     9

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

    10

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

    11

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

    12

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

    13

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

    14

    15

#ifdef min

    16

#undef min

    17

#endif

    18

    19

#ifdef max

    20

#undef max

    21

#endif

    22

    23

template <typename T>

    24

static inline T max(T a, T b)

    25

{

    26

	return a >= b ? a : b;

    27

}

    28

    29

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

    30

    31

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

    32

    33

    34

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

    35

{

    36

	if (a <= min) return min;

    37

	if (a >= max) return max;

    38

	return a;

    39

}

    40

    41

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

    42

{

    43

	if (a <= min) return min;

    44

	if (a >= max) return max;

    45

	return a;

    46

}

    47

    48

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

    49

{

    50

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

    51

}

    52

    53

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

    54

{

    55

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

    56

}

    57

    58

    59

/* OPT: optimized into an unsigned comparison */

    60

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

    61

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

    62

    63

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

    64

{

    65

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

    66

}

    67

    68

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

    69

{

    70

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

    71

}

    72

    73

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

    74

{

    75

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

    76

}

    77

    78

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

    79

{

    80

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

    81

}

    82

    83

    84

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

    88

    89

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

    90

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

    91

    92

extern const byte _ffb_64[128];

    93

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

    94

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

    95

 * 0.

    96

 */

    97

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

    98

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

    99

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

   100

 */

   102

   103

static inline int FindFirstBit2x64(int value)

   104

{

   105

/*

   106

	int i = 0;

   107

	if ( (byte) value == 0) {

   108

		i += 8;

   109

		value >>= 8;

   110

	}

   111

	return i + FIND_FIRST_BIT(value & 0x3F);

   112

   113

Faster ( or at least cleaner ) implementation below?

   114

*/

   115

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

   116

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

   117

	} else {

   118

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

   119

	}

   120

   121

}

   122

   123

static inline int KillFirstBit2x64(int value)

   124

{

   125

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

   126

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

   127

	} else {

   128

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

   129

	}

   130

}

   131

   132

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

   133

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

   134

   135

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

   138

   139

   143

   144

   145

#define for_each_bit(_i, _b)            \

   146

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

   147

		if (_b & 1)

   148

   149

#define abs myabs

   150

   151

   152

static inline uint16 ReadLE16Aligned(const void* x)

   153

{

   154

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

   155

}

   156

   157

static inline uint16 ReadLE16Unaligned(const void* x)

   158

{

   159

#ifdef OTTD_ALIGNMENT

   160

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

   161

#else

   162

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

   163

#endif

   164

}

   165

   166

   167

/**

   168

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

   169

 * @note Assumes a byte has 8 bits

   170

 */

   171

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

   172

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

   173

   174

/**

   175

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

   176

 * @note n must be a power of 2

   177

 */

   178

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

   179

   180

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

   181

 */

   182

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

   183

   184

#endif /* MACROS_H */