From 640e5478862e3b83d85db6332e0d82a45a95e4ed Mon Sep 17 00:00:00 2001 From: skidd13 Date: Sun, 22 Jun 2008 15:21:51 +0000 Subject: (svn r13606) -Codechange: use "static FORCEINLINE" where possible as default for core functions (big functions use just inline instead) --- src/core/alloc_func.hpp | 9 ++++++--- src/core/alloc_type.hpp | 14 +++++++------- src/core/bitmath_func.hpp | 39 +++++++++++++++++++++++++-------------- src/core/endian_func.hpp | 4 ++-- src/core/enum_type.hpp | 3 ++- src/core/math_func.hpp | 36 ++++++++++++++++++++++-------------- src/core/mem_func.hpp | 16 ++++++++-------- src/core/random_func.hpp | 14 +++++++------- src/core/smallvec_type.hpp | 24 ++++++++++++------------ src/core/sort_func.hpp | 8 ++++---- 10 files changed, 95 insertions(+), 72 deletions(-) diff --git a/src/core/alloc_func.hpp b/src/core/alloc_func.hpp index ec30ffb6e..45c0036d9 100644 --- a/src/core/alloc_func.hpp +++ b/src/core/alloc_func.hpp @@ -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 FORCEINLINE T* MallocT(size_t num_elements) +template +static FORCEINLINE T *MallocT(size_t num_elements) { /* * MorphOS cannot handle 0 elements allocations, or rather that always @@ -48,7 +49,8 @@ template 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 FORCEINLINE T* CallocT(size_t num_elements) +template +static FORCEINLINE T *CallocT(size_t num_elements) { /* * MorphOS cannot handle 0 elements allocations, or rather that always @@ -73,7 +75,8 @@ template 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 FORCEINLINE T* ReallocT(T *t_ptr, size_t num_elements) +template +FORCEINLINE T *ReallocT(T *t_ptr, size_t num_elements) { /* * MorphOS cannot handle 0 elements allocations, or rather that always diff --git a/src/core/alloc_type.hpp b/src/core/alloc_type.hpp index 1710e9a4d..fe9c3b81d 100644 --- a/src/core/alloc_type.hpp +++ b/src/core/alloc_type.hpp @@ -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(size); } + FORCEINLINE void *operator new(size_t size) { return CallocT(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(size); } + FORCEINLINE void *operator new[](size_t size) { return CallocT(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 */ diff --git a/src/core/bitmath_func.hpp b/src/core/bitmath_func.hpp index dd93b11d9..167a863c8 100644 --- a/src/core/bitmath_func.hpp +++ b/src/core/bitmath_func.hpp @@ -21,7 +21,8 @@ * @param n The number of bits to read. * @return The selected bits, aligned to a LSB. */ -template static inline uint GB(const T x, const uint8 s, const uint8 n) +template +static FORCEINLINE uint GB(const T x, const uint8 s, const uint8 n) { return (x >> s) & ((1U << n) - 1); } @@ -43,7 +44,8 @@ template 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 static inline T SB(T& x, const uint8 s, const uint8 n, const U d) +template +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 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 static inline T AB(T& x, const uint8 s, const uint8 n, const U i) +template +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 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 static inline bool HasBit(const T x, const uint8 y) +template +static FORCEINLINE bool HasBit(const T x, const uint8 y) { return (x & ((T)1U << y)) != 0; } @@ -110,7 +114,8 @@ template 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 static inline T SetBit(T& x, const uint8 y) +template +static FORCEINLINE T SetBit(T &x, const uint8 y) { return x = (T)(x | (T)(1U << y)); } @@ -138,7 +143,8 @@ template 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 static inline T ClrBit(T& x, const uint8 y) +template +static FORCEINLINE T ClrBit(T &x, const uint8 y) { return x = (T)(x & ~((T)1U << y)); } @@ -166,7 +172,8 @@ template 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 static inline T ToggleBit(T& x, const uint8 y) +template +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 static inline T KillFirstBit(T value) +template +static FORCEINLINE T KillFirstBit(T value) { return value &= (T)(value - 1); } @@ -234,7 +242,8 @@ template static inline T KillFirstBit(T value) * @param value the value to count the number of bits in. * @return the number of bits. */ -template static inline uint CountBits(T value) +template +static inline uint CountBits(T value) { uint num; @@ -258,7 +267,8 @@ template static inline uint CountBits(T value) * @param n The number how many we waht to rotate * @return A bit rotated number */ -template static inline T ROL(const T x, const uint8 n) +template +static FORCEINLINE T ROL(const T x, const uint8 n) { return (T)(x << n | x >> (sizeof(x) * 8 - n)); } @@ -271,7 +281,8 @@ template 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 static inline T ROR(const T x, const uint8 n) +template +static FORCEINLINE T ROR(const T x, const uint8 n) { return (T)(x >> n | x << (sizeof(x) * 8 - n)); } @@ -305,7 +316,7 @@ template 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 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); } diff --git a/src/core/endian_func.hpp b/src/core/endian_func.hpp index 9032b4cef..2b80ccc68 100644 --- a/src/core/endian_func.hpp +++ b/src/core/endian_func.hpp @@ -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; diff --git a/src/core/enum_type.hpp b/src/core/enum_type.hpp index de83b6d55..717f2c5eb 100644 --- a/src/core/enum_type.hpp +++ b/src/core/enum_type.hpp @@ -73,7 +73,8 @@ struct MakeEnumPropsT { template struct TinyEnumT; /** The general declaration of TinyEnumT<> (above) */ -template struct TinyEnumT +template +struct TinyEnumT { typedef Tenum_t enum_type; ///< expose our enumeration type (i.e. Trackdir) to outside typedef EnumPropsT Props; ///< make easier access to our enumeration propeties diff --git a/src/core/math_func.hpp b/src/core/math_func.hpp index 35aeeee1e..6b91b3ddb 100644 --- a/src/core/math_func.hpp +++ b/src/core/math_func.hpp @@ -27,7 +27,8 @@ * @param b The second value * @return The greater value or a if equals */ -template static inline T max(const T a, const T b) +template +static FORCEINLINE T max(const T a, const T b) { return (a >= b) ? a : b; } @@ -42,7 +43,8 @@ template static inline T max(const T a, const T b) * @param b The second value * @return The smaller value or b if equals */ -template static inline T min(const T a, const T b) +template +static FORCEINLINE T min(const T a, const T b) { return (a < b) ? a : b; } @@ -56,7 +58,7 @@ template 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 static inline T abs(const T a) +template +static FORCEINLINE T abs(const T a) { return (a < (T)0) ? -a : a; } @@ -95,7 +98,8 @@ template 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 static inline T Align(const T x, uint n) +template +static FORCEINLINE T Align(const T x, uint n) { n--; return (T)((x + n) & ~(n)); @@ -117,7 +121,7 @@ template 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 static inline T Delta(const T a, const T b) { +template +static FORCEINLINE T Delta(const T a, const T b) { return (a < b) ? b - a : a - b; } @@ -203,7 +208,8 @@ template 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 static inline bool IsInsideBS(const T x, const uint base, const uint size) +template +static FORCEINLINE bool IsInsideBS(const T x, const uint base, const uint size) { return (uint)(x - base) < size; } @@ -218,7 +224,8 @@ template static inline bool IsInsideBS(const T x, const uint base, c * @param max The maximum of the interval * @see IsInsideBS() */ -template static inline bool IsInsideMM(const T x, const uint min, const uint max) +template +static FORCEINLINE bool IsInsideMM(const T x, const uint min, const uint max) { return (uint)(x - min) < (max - min); } @@ -228,7 +235,8 @@ template 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 void Swap(T& a, T& b) +template +static FORCEINLINE void Swap(T &a, T &b) { T t = a; a = b; diff --git a/src/core/mem_func.hpp b/src/core/mem_func.hpp index 3d87f4290..e56ad365d 100644 --- a/src/core/mem_func.hpp +++ b/src/core/mem_func.hpp @@ -16,7 +16,7 @@ * @param num number of items to be copied. (!not number of bytes!) */ template -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 -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 -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 -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 -FORCEINLINE void MemReverseT(T *ptr1, T *ptr2) +template +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 -FORCEINLINE void MemReverseT(T *ptr, uint num) +template +static FORCEINLINE void MemReverseT(T *ptr, uint num) { assert(ptr != NULL); diff --git a/src/core/random_func.hpp b/src/core/random_func.hpp index cd273cb08..18cde93d3 100644 --- a/src/core/random_func.hpp +++ b/src/core/random_func.hpp @@ -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); diff --git a/src/core/smallvec_type.hpp b/src/core/smallvec_type.hpp index ce41af9fd..4da1a66a8 100644 --- a/src/core/smallvec_type.hpp +++ b/src/core/smallvec_type.hpp @@ -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]; } diff --git a/src/core/sort_func.hpp b/src/core/sort_func.hpp index 826fa278d..0ccd92a73 100644 --- a/src/core/sort_func.hpp +++ b/src/core/sort_func.hpp @@ -20,8 +20,8 @@ * @param comparator Function that compares two elements. * @param desc Sort descending. */ -template -FORCEINLINE void QSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false) +template +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 -FORCEINLINE void GSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false) +template +static inline void GSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false) { if (num < 2) return; -- cgit v1.2.3-70-g09d2