1

/* $Id$ */

     2

     3

/** @file macros.h */

     4

     5

#ifndef MACROS_H

     6

#define MACROS_H

     7

    10

/**

    11

 * Fetch n bits from x, started at bit s.

    12

 *

    14

 * s value set the startposition to read. The startposition is

    15

 * count from the LSB and starts at 0. The result starts at a

    16

 * LSB, as this isn't just an and-bitmask but also some

    17

 * bit-shifting operations. GB(0xFF, 2, 1) will so

    18

 * return 0x01 (0000 0001) instead of

    19

 * 0x04 (0000 0100).

    20

 *

    21

 * @param x The value to read some bits.

    22

 * @param s The startposition to read some bits.

    23

 * @param n The number of bits to read.

    24

 * @return The selected bits, aligned to a LSB.

    25

 */

    30

    31

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

    32

 *

    34

 * d. The parameters x, s and n works the same as the parameters of

    35

 * #GB. The result is saved in x again. Unused bits in the window

    36

 * provided by n are set to 0 if the value of b isn't "big" enough.

    37

 * This is not a bug, its a feature.

    38

 *

    39

 * @note Parameter x must be a variable as the result is saved there.

    40

 * @note To avoid unexpecting results the value of b should not use more

    41

 *       space as the provided space of n bits (log2)

    42

 * @param x The variable to change some bits

    43

 * @param s The startposition for the new bits

    44

 * @param n The size/window for the new bits

    45

 * @param d The actually new bits to save in the defined position.

    46

 * @return The new value of x

    47

 */

    54

    55

/** Add i to n bits of x starting at bit s.

    56

 *

    57

 * This add the value of i on n bits of x starting at bit s. The parameters x,

    58

 * s, i are similar to #GB besides x must be a variable as the result are

    59

 * saved there. An overflow does not affect the following bits of the given

    60

 * bit window and is simply ignored.

    61

 *

    62

 * @note Parameter x must be a variable as the result is saved there.

    63

 * @param x The variable to add some bits at some position

    64

 * @param s The startposition of the addition

    65

 * @param n The size/window for the addition

    66

 * @param i The value to add at the given startposition in the given window.

    67

 * @return The new value of x

    68

 */

    70

{

    74

}

    75

    76

/**

    77

 * Checks if a bit in a value is set.

    78

 *

    79

 * This function checks if a bit inside a value is set or not.

    80

 * The y value specific the position of the bit, started at the

    81

 * LSB and count from 0.

    82

 *

    83

 * @param x The value to check

    84

 * @param y The position of the bit to check, started from the LSB

    85

 * @return True if the bit is set, false else.

    86

 */

    88

{

    90

}

    91

    92

/**

    93

 * Set a bit in a variable.

    94

 *

    95

 * This function sets a bit in a variable. The variable is changed

    96

 * and the value is also returned. Parameter y defines the bit and

    97

 * starts at the LSB with 0.

    98

 *

    99

 * @param x The variable to set a bit

   100

 * @param y The bit position to set

   101

 * @return The new value of the old value with the bit set

   102

 */

   104

{

   106

}

   107

   108

/**

   109

 * Clears a bit in a variable.

   110

 *

   111

 * This function clears a bit in a variable. The variable is

   112

 * changed and the value is also returned. Parameter y defines the bit

   113

 * to clear and starts at the LSB with 0.

   114

 *

   115

 * @param x The variable to clear the bit

   116

 * @param y The bit position to clear

   117

 * @return The new value of the old value with the bit cleared

   118

 */

   120

{

   122

}

   123

   124

/**

   125

 * Toggles a bit in a variable.

   126

 *

   127

 * This function toggles a bit in a variable. The variable is

   128

 * changed and the value is also returned. Parameter y defines the bit

   129

 * to toggle and starts at the LSB with 0.

   130

 *

   131

 * @param x The varliable to toggle the bit

   132

 * @param y The bit position to toggle

   133

 * @return The new value of the old value with the bit toggled

   134

 */

   136

{

   138

}

   139

   140

   141

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

   142

/**

   143

 * Check several bits in a value.

   144

 *

   145

 * This macro checks if a value contains at least one bit of an other

   146

 * value.

   147

 *

   148

 * @param x The first value

   149

 * @param y The second value

   150

 * @return True if at least one bit is set in both values, false else.

   151

 */

   152

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

   153

   154

/**

   155

 * Sets several bits in a variable.

   156

 *

   157

 * This macro sets several bits in a variable. The bits to set are provided

   158

 * by a value. The new value is also returned.

   159

 *

   160

 * @param x The variable to set some bits

   161

 * @param y The value with set bits for setting them in the variable

   162

 * @return The new value of x

   163

 */

   164

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

   165

   166

/**

   167

 * Clears several bits in a variable.

   168

 *

   169

 * This macro clears several bits in a variable. The bits to clear are

   170

 * provided by a value. The new value is also returned.

   171

 *

   172

 * @param x The variable to clear some bits

   173

 * @param y The value with set bits for clearing them in the variable

   174

 * @return The new value of x

   175

 */

   176

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

   177

   178

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

   179

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

   180

   181

/**

   182

 * Whether a sprite comes from the original graphics files or a new grf file

   183

 * (either supplied by OpenTTD or supplied by the user).

   184

 *

   185

 * @param sprite The sprite to check

   186

 * @return True if it is a new sprite, or false if it is original.

   187

 */

   188

#define IS_CUSTOM_SPRITE(sprite) ((sprite) >= SPR_SIGNALS_BASE)

   189

   191

   192

/**

   193

 * Returns the first occure of a bit in a 6-bit value (from right).

   194

 *

   195

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

   196

 * LSB. Ie, 110100 returns 2, 000001 returns 0, etc. When x == 0 returns

   197

 * 0.

   198

 *

   199

 * @param x The 6-bit value to check the first zero-bit

   200

 * @return The first position of a bit started from the LSB or 0 if x is 0.

   201

 */

   202

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

   203

   204

/**

   205

 * Finds the position of the first bit in an integer.

   206

 *

   207

 * This function returns the position of the first bit set in the

   208

 * integer. It does only check the bits of the bitmask

   209

 * 0x3F3F (0011111100111111) and checks only the

   210

 * bits of the bitmask 0x3F00 if and only if the

   211

 * lower part 0x00FF is 0. This results the bits at 0x00C0 must

   212

 * be also zero to check the bits at 0x3F00.

   213

 *

   214

 * @param value The value to check the first bits

   215

 * @return The position of the first bit which is set

   216

 * @see FIND_FIRST_BIT

   217

 */

   218

static inline int FindFirstBit2x64(int value)

   219

{

   222

	} else {

   224

	}

   225

}

   226

   227

/**

   228

 * Clear the first bit in an integer.

   229

 *

   230

 * This function returns a value where the first bit (from LSB)

   233

 *

   234

 * @param value The value to clear the first bit

   235

 * @return The new value with the first bit cleared

   236

 */

   238

{

   240

}

   241

   242

/**

   243

 * Counts the number of set bits in a variable.

   244

 *

   245

 * @param value the value to count the number of bits in.

   246

 * @return the number of bits.

   247

 */

   249

{

   250

	uint num;

   251

   252

	/* This loop is only called once for every bit set by clearing the lowest

   253

	 * bit in each loop. The number of bits is therefore equal to the number of

   254

	 * times the loop was called. It was found at the following website:

   255

	 * http://graphics.stanford.edu/~seander/bithacks.html */

   256

   257

	for (num = 0; value != 0; num++) {

   258

		value &= (T)(value - 1);

   259

	}

   260

   261

	return num;

   262

}

   263

   264

/**

   265

 * Flips a coin with a given probability.

   266

 *

   267

 * This macro can be used to get true or false randomized according to a

   268

 * given probability. The parameter a and b create a percent value with

   269

 * (a/b). The macro returns true in (a/b) percent.

   270

 *

   271

 * @param a The numerator of the fraction

   272

 * @param b The denominator of the fraction, must of course not be null

   273

 * @return True in (a/b) percent

   274

 */

   276

   277

/**

   278

 * Flips a coin with a given probability and saves the randomize-number in a variable.

   279

 *

   280

 * This macro uses the same parameters as the CHANCE16 marco. The third parameter

   281

 * must be a variable the randomize-number from Random() is saved in.

   282

 *

   286

 * @param a The numerator of the fraction, see CHANCE16

   287

 * @param b The denominator of the fraction, see CHANCE16

   288

 * @param r The variable to save the randomize-number from Random()

   289

 * @return True in (a/b) percent

   290

 */

   292

   293

/**

   294

 * Checks if a given randomize-number is below a given probability.

   295

 *

   296

 * This macro is used to check if the given probability by the fraction of (a/b)

   302

 *

   303

 * @param a The numerator of the fraction, see CHANCE16

   304

 * @param b The denominator of the fraction, see CHANCE16

   306

 * @return True if v is less or equals (a/b)

   307

 */

   312

   313

   314

#define for_each_bit(_i, _b)            \

   315

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

   316

		if (_b & 1)

   317

   318

   319

static inline uint16 ReadLE16Aligned(const void* x)

   320

{

   321

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

   322

}

   323

   324

static inline uint16 ReadLE16Unaligned(const void* x)

   325

{

   326

#ifdef OTTD_ALIGNMENT

   327

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

   328

#else

   329

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

   330

#endif

   331

}

   332

   333

   334

/**

   337

 * @note Assumes a byte has 8 bits

   341

 */

   346

   347

/**

   354

 */

   359

   360

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

   361

 */

   362

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

   363

   364

#endif /* MACROS_H */