1

/* $Id$ */

     2

     3

#ifndef MACROS_H

     4

#define MACROS_H

     5

     6

#include "map.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

    26

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

    27

    28

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

    29

static inline uint maxu(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

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

    48

}

    49

    50

static inline int64 BIGMULSS64(int64 a, int64 b, int shift) {

    51

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

    52

}

    53

    54

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

    55

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

    56

}

    57

    58

static inline int64 BIGMULS(int32 a, int32 b) {

    59

	return (int64)(a) * (int64)(b);

    60

}

    61

    62

/* OPT: optimized into an unsigned comparison */

    63

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

    64

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

    65

    66

    67

#define HASBIT(x,y)    (((x) & (1 << (y))) != 0)

    68

#define SETBIT(x,y)    ((x) |=  (1 << (y)))

    69

#define CLRBIT(x,y)    ((x) &= ~(1 << (y)))

    70

#define TOGGLEBIT(x,y) ((x) ^=  (1 << (y)))

    71

    72

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

    73

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

    74

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

    75

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

    76

    77

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

    78

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

    79

#define SPRITE_PALETTE(x) ((x) | PALETTE_MODIFIER_COLOR)

    80

    81

extern const byte _ffb_64[128];

    82

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

    83

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

    84

 * 0.

    85

 */

    86

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

    87

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

    88

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

    89

 */

    90

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

    91

    92

static inline int FindFirstBit2x64(int value)

    93

{

    94

/*

    95

	int i = 0;

    96

	if ( (byte) value == 0) {

    97

		i += 8;

    98

		value >>= 8;

    99

	}

   100

	return i + FIND_FIRST_BIT(value & 0x3F);

   101

   102

Faster ( or at least cleaner ) implementation below?

   103

*/

   104

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

   105

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

   106

	} else {

   107

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

   108

	}

   109

   110

}

   111

   112

static inline int KillFirstBit2x64(int value)

   113

{

   114

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

   115

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

   116

	} else {

   117

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

   118

	}

   119

}

   120

   121

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

   122

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

   123

   124

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

   125

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

   126

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

   127

   128

   129

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

   130

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

   131

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

   132

   133

   134

#define for_each_bit(_i, _b)            \

   135

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

   136

		if (_b & 1)

   137

   138

#define abs myabs

   139

   140

static inline int intxchg_(int *a, int b) { int t = *a; *a = b; return t; }

   141

#define intswap(a,b) ((b) = intxchg_(&(a), (b)))

   142

static inline int uintxchg_(uint *a, uint b) { uint t = *a; *a = b; return t; }

   143

#define uintswap(a,b) ((b) = uintxchg_(&(a), (b)))

   144

   145

static inline void swap_byte(byte *a, byte *b) { byte t = *a; *a = *b; *b = t; }

   146

static inline void swap_uint16(uint16 *a, uint16 *b) { uint16 t = *a; *a = *b; *b = t; }

   147

static inline void swap_int16(int16 *a, int16 *b) { int16 t = *a; *a = *b; *b = t; }

   148

static inline void swap_uint32(uint32 *a, uint32 *b) { uint32 t = *a; *a = *b; *b = t; }

   149

static inline void swap_int32(int32 *a, int32 *b) { int32 t = *a; *a = *b; *b = t; }

   150

static inline void swap_tile(TileIndex *a, TileIndex *b) { TileIndex t = *a; *a = *b; *b = t; }

   151

   152

   153

static inline uint16 ReadLE16Aligned(const void* x)

   154

{

   155

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

   156

}

   157

   158

static inline uint16 ReadLE16Unaligned(const void* x)

   159

{

   160

#ifdef OTTD_ALIGNMENT

   161

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

   162

#else

   163

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

   164

#endif

   165

}

   166

   167

   168

/**

   169

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

   170

 * @note Assumes a byte has 8 bits

   171

 */

   172

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

   173

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

   174

   175

/**

   176

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

   177

 * @note n must be a power of 2

   178

 */

   179

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

   180

   181

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

   182

 *  known to work for uint32.

   183

 *  used by TGP to set the max value of the _patches.generation_seed in its definition

   184

 */

   185

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

   186

   187

#endif /* MACROS_H */