--- a/src/core/alloc_func.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/alloc_func.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -24,7 +24,8 @@
  * @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 @@
  * @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 @@
  * @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

--- a/src/core/alloc_type.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/alloc_type.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -37,20 +37,20 @@
 	 * 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 @@
 	 * @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 @@
 	 * @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 @@
 	 * @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 */

--- a/src/core/bitmath_func.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/bitmath_func.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
 	 * @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 @@
 	 * @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);
 	}

--- a/src/core/endian_func.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/endian_func.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -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;

--- a/src/core/enum_type.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/enum_type.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -73,7 +73,8 @@
 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

--- a/src/core/math_func.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/math_func.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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;

--- a/src/core/mem_func.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/mem_func.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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 @@
  * @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);
 

--- a/src/core/random_func.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/random_func.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -59,12 +59,12 @@
 	#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 @@
  * @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 @@
  * @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 @@
  * @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);

--- a/src/core/smallvec_type.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/smallvec_type.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -36,7 +36,7 @@
 	/**
 	 * 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 @@
 	/**
 	 * 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 @@
 	/**
 	 * Append an item and return it.
 	 */
-	T *Append()
+	FORCEINLINE T *Append()
 	{
 		if (this->items == this->capacity) {
 			this->capacity += S;
@@ -72,7 +72,7 @@
 	/**
 	 * Get the number of items in the list.
 	 */
-	uint Length() const
+	FORCEINLINE uint Length() const
 	{
 		return this->items;
 	}
@@ -82,7 +82,7 @@
 	 *
 	 * @return the pointer to the first item
 	 */
-	const T *Begin() const
+	FORCEINLINE const T *Begin() const
 	{
 		return this->data;
 	}
@@ -92,7 +92,7 @@
 	 *
 	 * @return the pointer to the first item
 	 */
-	T *Begin()
+	FORCEINLINE T *Begin()
 	{
 		return this->data;
 	}
@@ -102,7 +102,7 @@
 	 *
 	 * @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 @@
 	 *
 	 * @return the pointer behind the last valid item
 	 */
-	T *End()
+	FORCEINLINE T *End()
 	{
 		return &this->data[this->items];
 	}
@@ -123,7 +123,7 @@
 	 * @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 @@
 	 * @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 @@
 	 * @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 @@
 	 * @param index the positon of the item
 	 * @return the item
 	 */
-	T &operator[](uint index)
+	FORCEINLINE T &operator[](uint index)
 	{
 		return this->data[index];
 	}

--- a/src/core/sort_func.hpp	Sat Jun 21 23:59:38 2008 +0000
+++ b/src/core/sort_func.hpp	Sun Jun 22 15:21:51 2008 +0000
@@ -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 @@
  * @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;