gronod/OpenTTD
1
0
Fork 0
mirror of https://github.com/OpenTTD/OpenTTD.git synced 2025-03-09 07:29:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

(svn r13606) -Codechange: use "static FORCEINLINE" where possible as default for core functions (big functions use just inline instead)

Browse Source
This commit is contained in:
skidd13 2008-06-22 15:21:51 +00:00
parent 31b002dab0
commit 640e547886
10 changed files with 95 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/core/alloc_func.hpp
View File

@ -24,7 +24,8 @@ void NORETURN ReallocError(size_t size);
* @param num_elements the number of elements to allocate of the given type.
* @return NULL when num_elements == 0, non-NULL otherwise.
*/
template <typename T> FORCEINLINE T* MallocT(size_t num_elements)
template <typename T>
static FORCEINLINE T *MallocT(size_t num_elements)
{
/*
* MorphOS cannot handle 0 elements allocations, or rather that always
@ -48,7 +49,8 @@ template <typename T> FORCEINLINE T* MallocT(size_t num_elements)
* @param num_elements the number of elements to allocate of the given type.
* @return NULL when num_elements == 0, non-NULL otherwise.
*/
template <typename T> FORCEINLINE T* CallocT(size_t num_elements)
template <typename T>
static FORCEINLINE T *CallocT(size_t num_elements)
{
/*
* MorphOS cannot handle 0 elements allocations, or rather that always
@ -73,7 +75,8 @@ template <typename T> FORCEINLINE T* CallocT(size_t num_elements)
* @param num_elements the number of elements to allocate of the given type.
* @return NULL when num_elements == 0, non-NULL otherwise.
*/
template <typename T> FORCEINLINE T* ReallocT(T *t_ptr, size_t num_elements)
template <typename T>
FORCEINLINE T *ReallocT(T *t_ptr, size_t num_elements)
{
/*
* MorphOS cannot handle 0 elements allocations, or rather that always

14
src/core/alloc_type.hpp
View File

@ -37,20 +37,20 @@ struct SmallStackSafeStackAlloc {
* Gets a pointer to the data stored in this wrapper.
* @return the pointer.
*/
inline operator T* () { return data; }
FORCEINLINE operator T* () { return data; }
/**
* Gets a pointer to the data stored in this wrapper.
* @return the pointer.
*/
inline T* operator -> () { return data; }
FORCEINLINE T* operator -> () { return data; }
/**
* Gets a pointer to the last data element stored in this wrapper.
* @note needed because endof does not work properly for pointers.
* @return the 'endof' pointer.
*/
inline T* EndOf() {
FORCEINLINE T* EndOf() {
#if !defined(__NDS__)
return endof(data);
#else
@ -74,14 +74,14 @@ public:
* @param size the amount of bytes to allocate.
* @return the given amounts of bytes zeroed.
*/
void *operator new(size_t size) { return CallocT<byte>(size); }
FORCEINLINE void *operator new(size_t size) { return CallocT<byte>(size); }
/**
* Memory allocator for an array of class instances.
* @param size the amount of bytes to allocate.
* @return the given amounts of bytes zeroed.
*/
void *operator new[](size_t size) { return CallocT<byte>(size); }
FORCEINLINE void *operator new[](size_t size) { return CallocT<byte>(size); }
/**
* Memory release for a single class instance.
@ -91,7 +91,7 @@ public:
* @warning The value of the \a size parameter can only be trusted for
* classes that have their own (virtual) destructor method.
*/
void operator delete(void *ptr, size_t size) { free(ptr); }
FORCEINLINE void operator delete(void *ptr, size_t size) { free(ptr); }
/**
* Memory release for an array of class instances.
@ -101,7 +101,7 @@ public:
* @warning The value of the \a size parameter can only be trusted for
* classes that have their own (virtual) destructor method.
*/
void operator delete[](void *ptr, size_t size) { free(ptr); }
FORCEINLINE void operator delete[](void *ptr, size_t size) { free(ptr); }
};
#endif /* ALLOC_TYPE_HPP */

39
src/core/bitmath_func.hpp
View File

@ -21,7 +21,8 @@
* @param n The number of bits to read.
* @return The selected bits, aligned to a LSB.
*/
template<typename T> static inline uint GB(const T x, const uint8 s, const uint8 n)
template <typename T>
static FORCEINLINE uint GB(const T x, const uint8 s, const uint8 n)
{
return (x >> s) & ((1U << n) - 1);
}
@ -43,7 +44,8 @@ template<typename T> static inline uint GB(const T x, const uint8 s, const uint8
* @param d The actually new bits to save in the defined position.
* @return The new value of x
*/
template<typename T, typename U> static inline T SB(T& x, const uint8 s, const uint8 n, const U d)
template <typename T, typename U>
static FORCEINLINE T SB(T &x, const uint8 s, const uint8 n, const U d)
{
x &= (T)(~(((1U << n) - 1) << s));
x |= (T)(d << s);
@ -64,7 +66,8 @@ template<typename T, typename U> static inline T SB(T& x, const uint8 s, const u
* @param i The value to add at the given startposition in the given window.
* @return The new value of x
*/
template<typename T, typename U> static inline T AB(T& x, const uint8 s, const uint8 n, const U i)
template <typename T, typename U>
static FORCEINLINE T AB(T &x, const uint8 s, const uint8 n, const U i)
{
const T mask = (T)(((1U << n) - 1) << s);
x = (T)((x & ~mask) | ((x + (i << s)) & mask));
@ -82,7 +85,8 @@ template<typename T, typename U> static inline T AB(T& x, const uint8 s, const u
* @param y The position of the bit to check, started from the LSB
* @return True if the bit is set, false else.
*/
template<typename T> static inline bool HasBit(const T x, const uint8 y)
template <typename T>
static FORCEINLINE bool HasBit(const T x, const uint8 y)
{
return (x & ((T)1U << y)) != 0;
}
@ -110,7 +114,8 @@ template<typename T> static inline bool HasBit(const T x, const uint8 y)
* @param y The bit position to set
* @return The new value of the old value with the bit set
*/
template<typename T> static inline T SetBit(T& x, const uint8 y)
template <typename T>
static FORCEINLINE T SetBit(T &x, const uint8 y)
{
return x = (T)(x | (T)(1U << y));
}
@ -138,7 +143,8 @@ template<typename T> static inline T SetBit(T& x, const uint8 y)
* @param y The bit position to clear
* @return The new value of the old value with the bit cleared
*/
template<typename T> static inline T ClrBit(T& x, const uint8 y)
template <typename T>
static FORCEINLINE T ClrBit(T &x, const uint8 y)
{
return x = (T)(x & ~((T)1U << y));
}
@ -166,7 +172,8 @@ template<typename T> static inline T ClrBit(T& x, const uint8 y)
* @param y The bit position to toggle
* @return The new value of the old value with the bit toggled
*/
template<typename T> static inline T ToggleBit(T& x, const uint8 y)
template <typename T>
static FORCEINLINE T ToggleBit(T &x, const uint8 y)
{
return x = (T)(x ^ (T)(1U << y));
}
@ -201,7 +208,7 @@ extern const uint8 _ffb_64[64];
* @return The position of the first bit which is set
* @see FIND_FIRST_BIT
*/
static inline uint8 FindFirstBit2x64(const int value)
static FORCEINLINE uint8 FindFirstBit2x64(const int value)
{
if ((value & 0xFF) == 0) {
return FIND_FIRST_BIT((value >> 8) & 0x3F) + 8;
@ -223,7 +230,8 @@ uint8 FindLastBit(uint64 x);
* @param value The value to clear the first bit
* @return The new value with the first bit cleared
*/
template<typename T> static inline T KillFirstBit(T value)
template <typename T>
static FORCEINLINE T KillFirstBit(T value)
{
return value &= (T)(value - 1);
}
@ -234,7 +242,8 @@ template<typename T> static inline T KillFirstBit(T value)
* @param value the value to count the number of bits in.
* @return the number of bits.
*/
template<typename T> static inline uint CountBits(T value)
template <typename T>
static inline uint CountBits(T value)
{
uint num;
@ -258,7 +267,8 @@ template<typename T> static inline uint CountBits(T value)
* @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)
template <typename T>
static FORCEINLINE T ROL(const T x, const uint8 n)
{
return (T)(x << n | x >> (sizeof(x) * 8 - n));
}
@ -271,7 +281,8 @@ template<typename T> static inline T ROL(const T x, const uint8 n)
* @param n The number how many we waht to rotate
* @return A bit rotated number
*/
template<typename T> static inline T ROR(const T x, const uint8 n)
template <typename T>
static FORCEINLINE T ROR(const T x, const uint8 n)
{
return (T)(x >> n | x << (sizeof(x) * 8 - n));
}
@ -305,7 +316,7 @@ template<typename T> static inline T ROR(const T x, const uint8 n)
* @param x the variable to bitswap
* @return the bitswapped value.
*/
static inline uint32 BSWAP32(uint32 x)
static FORCEINLINE uint32 BSWAP32(uint32 x)
{
return ((x >> 24) & 0xFF) | ((x >> 8) & 0xFF00) | ((x << 8) & 0xFF0000) | ((x << 24) & 0xFF000000);
}
@ -315,7 +326,7 @@ template<typename T> static inline T ROR(const T x, const uint8 n)
* @param x the variable to bitswap
* @return the bitswapped value.
*/
static inline uint16 BSWAP16(uint16 x)
static FORCEINLINE uint16 BSWAP16(uint16 x)
{
return (x >> 8) | (x << 8);
}

4
src/core/endian_func.hpp
View File

@ -33,12 +33,12 @@
#define TO_LE32X(x) (x)
#endif /* TTD_ENDIAN == TTD_BIG_ENDIAN */
static inline uint16 ReadLE16Aligned(const void *x)
static FORCEINLINE uint16 ReadLE16Aligned(const void *x)
{
return FROM_LE16(*(const uint16*)x);
}
static inline uint16 ReadLE16Unaligned(const void *x)
static FORCEINLINE uint16 ReadLE16Unaligned(const void *x)
{
#if OTTD_ALIGNMENT == 1
return ((const byte*)x)[0] | ((const byte*)x)[1] << 8;

3
src/core/enum_type.hpp
View File

@ -73,7 +73,8 @@ struct MakeEnumPropsT {
template <typename Tenum_t> struct TinyEnumT;
/** The general declaration of TinyEnumT<> (above) */
template <typename Tenum_t> struct TinyEnumT
template <typename Tenum_t>
struct TinyEnumT
{
typedef Tenum_t enum_type; ///< expose our enumeration type (i.e. Trackdir) to outside
typedef EnumPropsT<Tenum_t> Props; ///< make easier access to our enumeration propeties

36
src/core/math_func.hpp
View File

@ -27,7 +27,8 @@
* @param b The second value
* @return The greater value or a if equals
*/
template<typename T> static inline T max(const T a, const T b)
template <typename T>
static FORCEINLINE T max(const T a, const T b)
{
return (a >= b) ? a : b;
}
@ -42,7 +43,8 @@ template<typename T> static inline T max(const T a, const T b)
* @param b The second value
* @return The smaller value or b if equals
*/
template<typename T> static inline T min(const T a, const T b)
template <typename T>
static FORCEINLINE T min(const T a, const T b)
{
return (a < b) ? a : b;
}
@ -56,7 +58,7 @@ template<typename T> static inline T min(const T a, const T b)
* @param b The second integer
* @return The smaller value
*/
static inline int min(const int a, const int b)
static FORCEINLINE int min(const int a, const int b)
{
return (a < b) ? a : b;
}
@ -70,7 +72,7 @@ static inline int min(const int a, const int b)
* @param b The second unsigned integer
* @return The smaller value
*/
static inline uint minu(const uint a, const uint b)
static FORCEINLINE uint minu(const uint a, const uint b)
{
return (a < b) ? a : b;
}
@ -82,7 +84,8 @@ static inline uint minu(const uint a, const uint b)
* @param a The value we want to unsign
* @return The unsigned value
*/
template <typename T> static inline T abs(const T a)
template <typename T>
static FORCEINLINE T abs(const T a)
{
return (a < (T)0) ? -a : a;
}
@ -95,7 +98,8 @@ template <typename T> static inline T abs(const T a)
* @param n The base of the number we are searching
* @return The smallest multiple of n equal or greater than x
*/
template<typename T> static inline T Align(const T x, uint n)
template <typename T>
static FORCEINLINE T Align(const T x, uint n)
{
n--;
return (T)((x + n) & ~(n));
@ -117,7 +121,7 @@ template<typename T> static inline T Align(const T x, uint n)
* @returns A value between min and max which is closest to a.
* @see ClampU(uint, uint, uint)
*/
static inline int Clamp(const int a, const int min, const int max)
static FORCEINLINE int Clamp(const int a, const int min, const int max)
{
if (a <= min) return min;
if (a >= max) return max;
@ -140,7 +144,7 @@ static inline int Clamp(const int a, const int min, const int max)
* @returns A value between min and max which is closest to a.
* @see Clamp(int, int, int)
*/
static inline uint ClampU(const uint a, const uint min, const uint max)
static FORCEINLINE uint ClampU(const uint a, const uint min, const uint max)
{
if (a <= min) return min;
if (a >= max) return max;
@ -161,7 +165,7 @@ static inline uint ClampU(const uint a, const uint min, const uint max)
* @return The 64-bit value reduced to a 32-bit value
* @see Clamp(int, int, int)
*/
static inline int32 ClampToI32(const int64 a)
static FORCEINLINE int32 ClampToI32(const int64 a)
{
if (a <= INT32_MIN) return INT32_MIN;
if (a >= INT32_MAX) return INT32_MAX;
@ -175,7 +179,7 @@ static inline int32 ClampToI32(const int64 a)
* @return The 64-bit value reduced to a 16-bit value
* @see ClampU(uint, uint, uint)
*/
static inline uint16 ClampToU16(const uint64 a)
static FORCEINLINE uint16 ClampToU16(const uint64 a)
{
return (uint16)(a <= UINT16_MAX ? a : UINT16_MAX);
}
@ -187,7 +191,8 @@ static inline uint16 ClampToU16(const uint64 a)
* @param b The second scalar
* @return The absolute difference between the given scalars
*/
template <typename T> static inline T Delta(const T a, const T b) {
template <typename T>
static FORCEINLINE T Delta(const T a, const T b) {
return (a < b) ? b - a : a - b;
}
@ -203,7 +208,8 @@ template <typename T> static inline T Delta(const T a, const T b) {
* @param size The size of the interval
* @return True if the value is in the interval, false else.
*/
template<typename T> static inline bool IsInsideBS(const T x, const uint base, const uint size)
template <typename T>
static FORCEINLINE bool IsInsideBS(const T x, const uint base, const uint size)
{
return (uint)(x - base) < size;
}
@ -218,7 +224,8 @@ template<typename T> static inline bool IsInsideBS(const T x, const uint base, c
* @param max The maximum of the interval
* @see IsInsideBS()
*/
template<typename T> static inline bool IsInsideMM(const T x, const uint min, const uint max)
template <typename T>
static FORCEINLINE bool IsInsideMM(const T x, const uint min, const uint max)
{
return (uint)(x - min) < (max - min);
}
@ -228,7 +235,8 @@ template<typename T> static inline bool IsInsideMM(const T x, const uint min, co
* @param a variable to swap with b
* @param b variable to swap with a
*/
template<typename T> void Swap(T& a, T& b)
template <typename T>
static FORCEINLINE void Swap(T &a, T &b)
{
T t = a;
a = b;

16
src/core/mem_func.hpp
View File

@ -16,7 +16,7 @@
* @param num number of items to be copied. (!not number of bytes!)
*/
template <typename T>
FORCEINLINE void MemCpyT(T *destination, const T *source, uint num = 1)
static FORCEINLINE void MemCpyT(T *destination, const T *source, uint num = 1)
{
memcpy(destination, source, num * sizeof(T));
}
@ -29,7 +29,7 @@ FORCEINLINE void MemCpyT(T *destination, const T *source, uint num = 1)
* @param num number of items to be copied. (!not number of bytes!)
*/
template <typename T>
FORCEINLINE void MemMoveT(T *destination, const T *source, uint num = 1)
static FORCEINLINE void MemMoveT(T *destination, const T *source, uint num = 1)
{
memmove(destination, source, num * sizeof(T));
}
@ -42,7 +42,7 @@ FORCEINLINE void MemMoveT(T *destination, const T *source, uint num = 1)
* @param num number of items to be set (!not number of bytes!)
*/
template <typename T>
FORCEINLINE void MemSetT(T *ptr, int value, uint num = 1)
static FORCEINLINE void MemSetT(T *ptr, int value, uint num = 1)
{
memset(ptr, value, num * sizeof(T));
}
@ -56,7 +56,7 @@ FORCEINLINE void MemSetT(T *ptr, int value, uint num = 1)
* @return an int value indicating the relationship between the content of the two buffers
*/
template <typename T>
FORCEINLINE int MemCmpT(const T *ptr1, const T *ptr2, uint num = 1)
static FORCEINLINE int MemCmpT(const T *ptr1, const T *ptr2, uint num = 1)
{
return memcmp(ptr1, ptr2, num * sizeof(T));
}
@ -69,8 +69,8 @@ FORCEINLINE int MemCmpT(const T *ptr1, const T *ptr2, uint num = 1)
* @param ptr1 Start-pointer to the block of memory.
* @param ptr2 End-pointer to the block of memory.
*/
template<typename T>
FORCEINLINE void MemReverseT(T *ptr1, T *ptr2)
template <typename T>
static FORCEINLINE void MemReverseT(T *ptr1, T *ptr2)
{
assert(ptr1 != NULL && ptr2 != NULL);
assert(ptr1 < ptr2);
@ -86,8 +86,8 @@ FORCEINLINE void MemReverseT(T *ptr1, T *ptr2)
* @param ptr Pointer to the block of memory.
* @param num The number of items we want to reverse.
*/
template<typename T>
FORCEINLINE void MemReverseT(T *ptr, uint num)
template <typename T>
static FORCEINLINE void MemReverseT(T *ptr, uint num)
{
assert(ptr != NULL);

14
src/core/random_func.hpp
View File

@ -59,12 +59,12 @@ void SetRandomSeed(uint32 seed);
#define RandomRange(max) DoRandomRange(max, __LINE__, __FILE__)
uint DoRandomRange(uint max, int line, const char *file);
#else
static inline uint32 Random() { return _random.Next(); }
static inline uint32 RandomRange(uint16 max) { return _random.Next(max); }
static FORCEINLINE uint32 Random() { return _random.Next(); }
static FORCEINLINE uint32 RandomRange(uint16 max) { return _random.Next(max); }
#endif
static inline uint32 InteractiveRandom() { return _interactive_random.Next(); }
static inline uint32 InteractiveRandomRange(uint16 max) { return _interactive_random.Next(max); }
static FORCEINLINE uint32 InteractiveRandom() { return _interactive_random.Next(); }
static FORCEINLINE uint32 InteractiveRandomRange(uint16 max) { return _interactive_random.Next(max); }
/**
* Checks if a given randomize-number is below a given probability.
@ -81,7 +81,7 @@ static inline uint32 InteractiveRandomRange(uint16 max) { return _interactive_ra
* @param r The given randomize-number
* @return True if v is less or equals (a/b)
*/
static inline bool Chance16I(const uint a, const uint b, const uint32 r)
static FORCEINLINE bool Chance16I(const uint a, const uint b, const uint32 r)
{
assert(b != 0);
return (uint16)r < (uint16)(((a << 16) + b / 2) / b);
@ -99,7 +99,7 @@ static inline bool Chance16I(const uint a, const uint b, const uint32 r)
* @param b The denominator of the fraction
* @return True in (a/b) percent
*/
static inline bool Chance16(const uint a, const uint b)
static FORCEINLINE bool Chance16(const uint a, const uint b)
{
return Chance16I(a, b, Random());
}
@ -119,7 +119,7 @@ static inline bool Chance16(const uint a, const uint b)
* @param r The variable to save the randomize-number from Random()
* @return True in (a/b) percent
*/
static inline bool Chance16R(const uint a, const uint b, uint32 &r)
static FORCEINLINE bool Chance16R(const uint a, const uint b, uint32 &r)
{
r = Random();
return Chance16I(a, b, r);

24
src/core/smallvec_type.hpp
View File

@ -36,7 +36,7 @@ public:
/**
* Remove all items from the list.
*/
void Clear()
FORCEINLINE void Clear()
{
/* In fact we just reset the item counter avoiding the need to
* probably reallocate the same amount of memory the list was
@ -47,7 +47,7 @@ public:
/**
* Compact the list down to the smallest block size boundary.
*/
void Compact()
FORCEINLINE void Compact()
{
uint capacity = Align(this->items, S);
if (capacity >= this->capacity) return;
@ -59,7 +59,7 @@ public:
/**
* Append an item and return it.
*/
T *Append()
FORCEINLINE T *Append()
{
if (this->items == this->capacity) {
this->capacity += S;
@ -72,7 +72,7 @@ public:
/**
* Get the number of items in the list.
*/
uint Length() const
FORCEINLINE uint Length() const
{
return this->items;
}
@ -82,7 +82,7 @@ public:
*
* @return the pointer to the first item
*/
const T *Begin() const
FORCEINLINE const T *Begin() const
{
return this->data;
}
@ -92,7 +92,7 @@ public:
*
* @return the pointer to the first item
*/
T *Begin()
FORCEINLINE T *Begin()
{
return this->data;
}
@ -102,7 +102,7 @@ public:
*
* @return the pointer behind the last valid item
*/
const T *End() const
FORCEINLINE const T *End() const
{
return &this->data[this->items];
}
@ -112,7 +112,7 @@ public:
*
* @return the pointer behind the last valid item
*/
T *End()
FORCEINLINE T *End()
{
return &this->data[this->items];
}
@ -123,7 +123,7 @@ public:
* @param index the position of the item
* @return the pointer to the item
*/
const T *Get(uint index) const
FORCEINLINE const T *Get(uint index) const
{
return &this->data[index];
}
@ -134,7 +134,7 @@ public:
* @param index the position of the item
* @return the pointer to the item
*/
T *Get(uint index)
FORCEINLINE T *Get(uint index)
{
return &this->data[index];
}
@ -145,7 +145,7 @@ public:
* @param index the positon of the item
* @return the item
*/
const T &operator[](uint index) const
FORCEINLINE const T &operator[](uint index) const
{
return this->data[index];
}
@ -156,7 +156,7 @@ public:
* @param index the positon of the item
* @return the item
*/
T &operator[](uint index)
FORCEINLINE T &operator[](uint index)
{
return this->data[index];
}

8
src/core/sort_func.hpp
View File

@ -20,8 +20,8 @@
* @param comparator Function that compares two elements.
* @param desc Sort descending.
*/
template<typename T>
FORCEINLINE void QSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false)
template <typename T>
static FORCEINLINE void QSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false)
{
if (num < 2) return;
@ -44,8 +44,8 @@ FORCEINLINE void QSortT(T *base, uint num, int (CDECL *comparator)(const T*, con
* @param comparator Function that compares two elements.
* @param desc Sort descending.
*/
template<typename T>
FORCEINLINE void GSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false)
template <typename T>
static inline void GSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false)
{
if (num < 2) return;