mirrors
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

(svn r23640) -Fix: stop using FORCEINLINE (1/3rd of the instances were, the others were still regular inline), but make sure inline is always a 'forced' inline (I am looking at you MSVC)

This commit is contained in:
truebrain 2011-12-20 17:57:56 +00:00
parent 7a38642a1c
commit 1c9bec1999
75 changed files with 673 additions and 672 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/3rdparty/squirrel/include/squirrel.h vendored
View File

@ -35,6 +35,10 @@ to the following restrictions:
extern "C" { extern "C" {
#endif #endif
#if defined(_MSC_VER)
# define inline __forceinline
#endif /* _MSC_VER */
#if defined(_MSC_VER) && _MSC_VER >= 1400 // MSVC 2005 safety checks #if defined(_MSC_VER) && _MSC_VER >= 1400 // MSVC 2005 safety checks
# pragma warning(disable: 4996) // '_wfopen' was declared deprecated # pragma warning(disable: 4996) // '_wfopen' was declared deprecated
# define _CRT_SECURE_NO_DEPRECATE // all deprecated 'unsafe string functions # define _CRT_SECURE_NO_DEPRECATE // all deprecated 'unsafe string functions

2
src/aircraft.h
View File

@ -90,7 +90,7 @@ struct Aircraft FINAL : public SpecializedVehicle<Aircraft, VEH_AIRCRAFT> {
* @return Returns true if the aircraft is a helicopter/airplane and * @return Returns true if the aircraft is a helicopter/airplane and
* false if it is a shadow or a rotor * false if it is a shadow or a rotor
*/ */
FORCEINLINE bool IsNormalAircraft() const inline bool IsNormalAircraft() const
{ {
/* To be fully correct the commented out functionality is the proper one, /* To be fully correct the commented out functionality is the proper one,
* but since value can only be 0 or 2, it is sufficient to only check <= 2 * but since value can only be 0 or 2, it is sufficient to only check <= 2

20
src/base_station_base.h
View File

@ -139,7 +139,7 @@ struct BaseStation : StationPool::PoolItem<&_station_pool> {
* @param tile The tile to get the base station from. * @param tile The tile to get the base station from.
* @return the station associated with that tile. * @return the station associated with that tile.
*/ */
static FORCEINLINE BaseStation *GetByTile(TileIndex tile) static inline BaseStation *GetByTile(TileIndex tile)
{ {
return BaseStation::Get(GetStationIndex(tile)); return BaseStation::Get(GetStationIndex(tile));
} }
@ -150,7 +150,7 @@ struct BaseStation : StationPool::PoolItem<&_station_pool> {
* facilities left. * facilities left.
* @return true if still in use * @return true if still in use
*/ */
FORCEINLINE bool IsInUse() const inline bool IsInUse() const
{ {
return (this->facilities & ~FACIL_WAYPOINT) != 0; return (this->facilities & ~FACIL_WAYPOINT) != 0;
} }
@ -172,7 +172,7 @@ struct SpecializedStation : public BaseStation {
* Set station type correctly * Set station type correctly
* @param tile The base tile of the station. * @param tile The base tile of the station.
*/ */
FORCEINLINE SpecializedStation<T, Tis_waypoint>(TileIndex tile) : inline SpecializedStation<T, Tis_waypoint>(TileIndex tile) :
BaseStation(tile) BaseStation(tile)
{ {
this->facilities = EXPECTED_FACIL; this->facilities = EXPECTED_FACIL;
@ -183,7 +183,7 @@ struct SpecializedStation : public BaseStation {
* @param st the station to check. * @param st the station to check.
* @return true if the station is the type we expect it to be. * @return true if the station is the type we expect it to be.
*/ */
static FORCEINLINE bool IsExpected(const BaseStation *st) static inline bool IsExpected(const BaseStation *st)
{ {
return (st->facilities & FACIL_WAYPOINT) == EXPECTED_FACIL; return (st->facilities & FACIL_WAYPOINT) == EXPECTED_FACIL;
} }
@ -193,7 +193,7 @@ struct SpecializedStation : public BaseStation {
* @param index tested index * @param index tested index
* @return is this index valid index of T? * @return is this index valid index of T?
*/ */
static FORCEINLINE bool IsValidID(size_t index) static inline bool IsValidID(size_t index)
{ {
return BaseStation::IsValidID(index) && IsExpected(BaseStation::Get(index)); return BaseStation::IsValidID(index) && IsExpected(BaseStation::Get(index));
} }
@ -202,7 +202,7 @@ struct SpecializedStation : public BaseStation {
* Gets station with given index * Gets station with given index
* @return pointer to station with given index casted to T * * @return pointer to station with given index casted to T *
*/ */
static FORCEINLINE T *Get(size_t index) static inline T *Get(size_t index)
{ {
return (T *)BaseStation::Get(index); return (T *)BaseStation::Get(index);
} }
@ -211,7 +211,7 @@ struct SpecializedStation : public BaseStation {
* Returns station if the index is a valid index for this station type * Returns station if the index is a valid index for this station type
* @return pointer to station with given index if it's a station of this type * @return pointer to station with given index if it's a station of this type
*/ */
static FORCEINLINE T *GetIfValid(size_t index) static inline T *GetIfValid(size_t index)
{ {
return IsValidID(index) ? Get(index) : NULL; return IsValidID(index) ? Get(index) : NULL;
} }
@ -221,7 +221,7 @@ struct SpecializedStation : public BaseStation {
* @param tile The tile to get the station from. * @param tile The tile to get the station from.
* @return the station associated with that tile. * @return the station associated with that tile.
*/ */
static FORCEINLINE T *GetByTile(TileIndex tile) static inline T *GetByTile(TileIndex tile)
{ {
return GetIfValid(GetStationIndex(tile)); return GetIfValid(GetStationIndex(tile));
} }
@ -231,7 +231,7 @@ struct SpecializedStation : public BaseStation {
* @param st BaseStation pointer * @param st BaseStation pointer
* @return pointer to SpecializedStation * @return pointer to SpecializedStation
*/ */
static FORCEINLINE T *From(BaseStation *st) static inline T *From(BaseStation *st)
{ {
assert(IsExpected(st)); assert(IsExpected(st));
return (T *)st; return (T *)st;
@ -242,7 +242,7 @@ struct SpecializedStation : public BaseStation {
* @param st BaseStation pointer * @param st BaseStation pointer
* @return pointer to SpecializedStation * @return pointer to SpecializedStation
*/ */
static FORCEINLINE const T *From(const BaseStation *st) static inline const T *From(const BaseStation *st)
{ {
assert(IsExpected(st)); assert(IsExpected(st));
return (const T *)st; return (const T *)st;

8
src/cargo_type.h
View File

@ -77,13 +77,13 @@ private:
public: public:
/** Default constructor. */ /** Default constructor. */
FORCEINLINE CargoArray() inline CargoArray()
{ {
this->Clear(); this->Clear();
} }
/** Reset all entries. */ /** Reset all entries. */
FORCEINLINE void Clear() inline void Clear()
{ {
memset(this->amount, 0, sizeof(this->amount)); memset(this->amount, 0, sizeof(this->amount));
} }
@ -92,7 +92,7 @@ public:
* Read/write access to an amount of a specific cargo type. * Read/write access to an amount of a specific cargo type.
* @param cargo Cargo type to access. * @param cargo Cargo type to access.
*/ */
FORCEINLINE uint &operator[](CargoID cargo) inline uint &operator[](CargoID cargo)
{ {
return this->amount[cargo]; return this->amount[cargo];
} }
@ -101,7 +101,7 @@ public:
* Read-only access to an amount of a specific cargo type. * Read-only access to an amount of a specific cargo type.
* @param cargo Cargo type to access. * @param cargo Cargo type to access.
*/ */
FORCEINLINE const uint &operator[](CargoID cargo) const inline const uint &operator[](CargoID cargo) const
{ {
return this->amount[cargo]; return this->amount[cargo];
} }

4
src/cargopacket.cpp
View File

@ -82,7 +82,7 @@ CargoPacket::CargoPacket(uint16 count, byte days_in_transit, StationID source, T
* @param new_size Size of the remaining part. * @param new_size Size of the remaining part.
* @return Split off part, or NULL if no packet could be allocated! * @return Split off part, or NULL if no packet could be allocated!
*/ */
FORCEINLINE CargoPacket *CargoPacket::Split(uint new_size) inline CargoPacket *CargoPacket::Split(uint new_size)
{ {
if (!CargoPacket::CanAllocateItem()) return NULL; if (!CargoPacket::CanAllocateItem()) return NULL;
@ -97,7 +97,7 @@ FORCEINLINE CargoPacket *CargoPacket::Split(uint new_size)
* Merge another packet into this one. * Merge another packet into this one.
* @param cp Packet to be merged in. * @param cp Packet to be merged in.
*/ */
FORCEINLINE void CargoPacket::Merge(CargoPacket *cp) inline void CargoPacket::Merge(CargoPacket *cp)
{ {
this->count += cp->count; this->count += cp->count;
this->feeder_share += cp->feeder_share; this->feeder_share += cp->feeder_share;

28
src/cargopacket.h
View File

@ -69,7 +69,7 @@ public:
* Gets the number of 'items' in this packet. * Gets the number of 'items' in this packet.
* @return Item count. * @return Item count.
*/ */
FORCEINLINE uint16 Count() const inline uint16 Count() const
{ {
return this->count; return this->count;
} }
@ -79,7 +79,7 @@ public:
* the feeder chain. * the feeder chain.
* @return Feeder share. * @return Feeder share.
*/ */
FORCEINLINE Money FeederShare() const inline Money FeederShare() const
{ {
return this->feeder_share; return this->feeder_share;
} }
@ -90,7 +90,7 @@ public:
* it is capped at 255. * it is capped at 255.
* @return Length this cargo has been in transit. * @return Length this cargo has been in transit.
*/ */
FORCEINLINE byte DaysInTransit() const inline byte DaysInTransit() const
{ {
return this->days_in_transit; return this->days_in_transit;
} }
@ -99,7 +99,7 @@ public:
* Gets the type of the cargo's source. industry, town or head quarter. * Gets the type of the cargo's source. industry, town or head quarter.
* @return Source type. * @return Source type.
*/ */
FORCEINLINE SourceType SourceSubsidyType() const inline SourceType SourceSubsidyType() const
{ {
return this->source_type; return this->source_type;
} }
@ -108,7 +108,7 @@ public:
* Gets the ID of the cargo's source. An IndustryID, TownID or CompanyID. * Gets the ID of the cargo's source. An IndustryID, TownID or CompanyID.
* @return Source ID. * @return Source ID.
*/ */
FORCEINLINE SourceID SourceSubsidyID() const inline SourceID SourceSubsidyID() const
{ {
return this->source_id; return this->source_id;
} }
@ -117,7 +117,7 @@ public:
* Gets the ID of the station where the cargo was loaded for the first time. * Gets the ID of the station where the cargo was loaded for the first time.
* @return StationID. * @return StationID.
*/ */
FORCEINLINE SourceID SourceStation() const inline SourceID SourceStation() const
{ {
return this->source; return this->source;
} }
@ -126,7 +126,7 @@ public:
* Gets the coordinates of the cargo's source station. * Gets the coordinates of the cargo's source station.
* @return Source station's coordinates. * @return Source station's coordinates.
*/ */
FORCEINLINE TileIndex SourceStationXY() const inline TileIndex SourceStationXY() const
{ {
return this->source_xy; return this->source_xy;
} }
@ -135,7 +135,7 @@ public:
* Gets the coordinates of the cargo's last loading station. * Gets the coordinates of the cargo's last loading station.
* @return Last loading station's coordinates. * @return Last loading station's coordinates.
*/ */
FORCEINLINE TileIndex LoadedAtXY() const inline TileIndex LoadedAtXY() const
{ {
return this->loaded_at_xy; return this->loaded_at_xy;
} }
@ -203,7 +203,7 @@ public:
* Returns a pointer to the cargo packet list (so you can iterate over it etc). * Returns a pointer to the cargo packet list (so you can iterate over it etc).
* @return Pointer to the packet list. * @return Pointer to the packet list.
*/ */
FORCEINLINE const List *Packets() const inline const List *Packets() const
{ {
return &this->packets; return &this->packets;
} }
@ -212,7 +212,7 @@ public:
* Checks whether this list is empty. * Checks whether this list is empty.
* @return True if and only if the list is empty. * @return True if and only if the list is empty.
*/ */
FORCEINLINE bool Empty() const inline bool Empty() const
{ {
return this->count == 0; return this->count == 0;
} }
@ -221,7 +221,7 @@ public:
* Returns the number of cargo entities in this list. * Returns the number of cargo entities in this list.
* @return The before mentioned number. * @return The before mentioned number.
*/ */
FORCEINLINE uint Count() const inline uint Count() const
{ {
return this->count; return this->count;
} }
@ -230,7 +230,7 @@ public:
* Returns source of the first cargo packet in this list. * Returns source of the first cargo packet in this list.
* @return The before mentioned source. * @return The before mentioned source.
*/ */
FORCEINLINE StationID Source() const inline StationID Source() const
{ {
return this->Empty() ? INVALID_STATION : this->packets.front()->source; return this->Empty() ? INVALID_STATION : this->packets.front()->source;
} }
@ -239,7 +239,7 @@ public:
* Returns average number of days in transit for a cargo entity. * Returns average number of days in transit for a cargo entity.
* @return The before mentioned number. * @return The before mentioned number.
*/ */
FORCEINLINE uint DaysInTransit() const inline uint DaysInTransit() const
{ {
return this->count == 0 ? 0 : this->cargo_days_in_transit / this->count; return this->count == 0 ? 0 : this->cargo_days_in_transit / this->count;
} }
@ -277,7 +277,7 @@ public:
* Returns total sum of the feeder share for all packets. * Returns total sum of the feeder share for all packets.
* @return The before mentioned number. * @return The before mentioned number.
*/ */
FORCEINLINE Money FeederShare() const inline Money FeederShare() const
{ {
return this->feeder_share; return this->feeder_share;
} }

8
src/cargotype.h
View File

@ -85,7 +85,7 @@ struct CargoSpec {
* Determines index of this cargospec * Determines index of this cargospec
* @return index (in the CargoSpec::array array) * @return index (in the CargoSpec::array array)
*/ */
FORCEINLINE CargoID Index() const inline CargoID Index() const
{ {
return this - CargoSpec::array; return this - CargoSpec::array;
} }
@ -95,7 +95,7 @@ struct CargoSpec {
* @return is this cargospec valid? * @return is this cargospec valid?
* @note assert(cs->IsValid()) can be triggered when GRF config is modified * @note assert(cs->IsValid()) can be triggered when GRF config is modified
*/ */
FORCEINLINE bool IsValid() const inline bool IsValid() const
{ {
return this->bitnum != INVALID_CARGO; return this->bitnum != INVALID_CARGO;
} }
@ -104,7 +104,7 @@ struct CargoSpec {
* Total number of cargospecs, both valid and invalid * Total number of cargospecs, both valid and invalid
* @return length of CargoSpec::array * @return length of CargoSpec::array
*/ */
static FORCEINLINE size_t GetArraySize() static inline size_t GetArraySize()
{ {
return lengthof(CargoSpec::array); return lengthof(CargoSpec::array);
} }
@ -114,7 +114,7 @@ struct CargoSpec {
* @param index ID of cargo * @param index ID of cargo
* @pre index is a valid cargo ID * @pre index is a valid cargo ID
*/ */
static FORCEINLINE CargoSpec *Get(size_t index) static inline CargoSpec *Get(size_t index)
{ {
assert(index < lengthof(CargoSpec::array)); assert(index < lengthof(CargoSpec::array));
return &CargoSpec::array[index]; return &CargoSpec::array[index];

12
src/command_type.h
View File

@ -58,7 +58,7 @@ public:
* Adds the given cost to the cost of the command. * Adds the given cost to the cost of the command.
* @param cost the cost to add * @param cost the cost to add
*/ */
FORCEINLINE void AddCost(const Money &cost) inline void AddCost(const Money &cost)
{ {
this->cost += cost; this->cost += cost;
} }
@ -69,7 +69,7 @@ public:
* Multiplies the cost of the command by the given factor. * Multiplies the cost of the command by the given factor.
* @param factor factor to multiply the costs with * @param factor factor to multiply the costs with
*/ */
FORCEINLINE void MultiplyCost(int factor) inline void MultiplyCost(int factor)
{ {
this->cost *= factor; this->cost *= factor;
} }
@ -78,7 +78,7 @@ public:
* The costs as made up to this moment * The costs as made up to this moment
* @return the costs * @return the costs
*/ */
FORCEINLINE Money GetCost() const inline Money GetCost() const
{ {
return this->cost; return this->cost;
} }
@ -87,7 +87,7 @@ public:
* The expense type of the cost * The expense type of the cost
* @return the expense type * @return the expense type
*/ */
FORCEINLINE ExpensesType GetExpensesType() const inline ExpensesType GetExpensesType() const
{ {
return this->expense_type; return this->expense_type;
} }
@ -137,7 +137,7 @@ public:
* Did this command succeed? * Did this command succeed?
* @return true if and only if it succeeded * @return true if and only if it succeeded
*/ */
FORCEINLINE bool Succeeded() const inline bool Succeeded() const
{ {
return this->success; return this->success;
} }
@ -146,7 +146,7 @@ public:
* Did this command fail? * Did this command fail?
* @return true if and only if it failed * @return true if and only if it failed
*/ */
FORCEINLINE bool Failed() const inline bool Failed() const
{ {
return !this->success; return !this->success;
} }

6
src/company_base.h
View File

@ -124,7 +124,7 @@ struct Company : CompanyPool::PoolItem<&_company_pool>, CompanyProperties {
* @param index Index in the pool. * @param index Index in the pool.
* @return \c true if it is a valid, computer controlled company, else \c false. * @return \c true if it is a valid, computer controlled company, else \c false.
*/ */
static FORCEINLINE bool IsValidAiID(size_t index) static inline bool IsValidAiID(size_t index)
{ {
const Company *c = Company::GetIfValid(index); const Company *c = Company::GetIfValid(index);
return c != NULL && c->is_ai; return c != NULL && c->is_ai;
@ -136,7 +136,7 @@ struct Company : CompanyPool::PoolItem<&_company_pool>, CompanyProperties {
* @return \c true if it is a valid, human controlled company, else \c false. * @return \c true if it is a valid, human controlled company, else \c false.
* @note If you know that \a index refers to a valid company, you can use #IsHumanID() instead. * @note If you know that \a index refers to a valid company, you can use #IsHumanID() instead.
*/ */
static FORCEINLINE bool IsValidHumanID(size_t index) static inline bool IsValidHumanID(size_t index)
{ {
const Company *c = Company::GetIfValid(index); const Company *c = Company::GetIfValid(index);
return c != NULL && !c->is_ai; return c != NULL && !c->is_ai;
@ -149,7 +149,7 @@ struct Company : CompanyPool::PoolItem<&_company_pool>, CompanyProperties {
* @pre \a index must be a valid CompanyID. * @pre \a index must be a valid CompanyID.
* @note If you don't know whether \a index refers to a valid company, you should use #IsValidHumanID() instead. * @note If you don't know whether \a index refers to a valid company, you should use #IsValidHumanID() instead.
*/ */
static FORCEINLINE bool IsHumanID(size_t index) static inline bool IsHumanID(size_t index)
{ {
return !Company::Get(index)->is_ai; return !Company::Get(index)->is_ai;
} }

6
src/core/alloc_func.hpp
View File

@ -56,7 +56,7 @@ static inline void CheckAllocationConstraints(size_t num_elements)
* @return NULL when num_elements == 0, non-NULL otherwise. * @return NULL when num_elements == 0, non-NULL otherwise.
*/ */
template <typename T> template <typename T>
static FORCEINLINE T *MallocT(size_t num_elements) static inline T *MallocT(size_t num_elements)
{ {
/* /*
* MorphOS cannot handle 0 elements allocations, or rather that always * MorphOS cannot handle 0 elements allocations, or rather that always
@ -84,7 +84,7 @@ static FORCEINLINE T *MallocT(size_t num_elements)
* @return NULL when num_elements == 0, non-NULL otherwise. * @return NULL when num_elements == 0, non-NULL otherwise.
*/ */
template <typename T> template <typename T>
static FORCEINLINE T *CallocT(size_t num_elements) static inline T *CallocT(size_t num_elements)
{ {
/* /*
* MorphOS cannot handle 0 elements allocations, or rather that always * MorphOS cannot handle 0 elements allocations, or rather that always
@ -110,7 +110,7 @@ static FORCEINLINE T *CallocT(size_t num_elements)
* @return NULL when num_elements == 0, non-NULL otherwise. * @return NULL when num_elements == 0, non-NULL otherwise.
*/ */
template <typename T> template <typename T>
static FORCEINLINE T *ReallocT(T *t_ptr, size_t num_elements) static inline T *ReallocT(T *t_ptr, size_t num_elements)
{ {
/* /*
* MorphOS cannot handle 0 elements allocations, or rather that always * MorphOS cannot handle 0 elements allocations, or rather that always

16
src/core/alloc_type.hpp
View File

@ -48,7 +48,7 @@ struct SmallStackSafeStackAlloc {
* Gets a pointer to the data stored in this wrapper. * Gets a pointer to the data stored in this wrapper.
* @return the pointer. * @return the pointer.
*/ */
FORCEINLINE operator T *() inline operator T *()
{ {
return data; return data;
} }
@ -57,7 +57,7 @@ struct SmallStackSafeStackAlloc {
* Gets a pointer to the data stored in this wrapper. * Gets a pointer to the data stored in this wrapper.
* @return the pointer. * @return the pointer.
*/ */
FORCEINLINE T *operator -> () inline T *operator -> ()
{ {
return data; return data;
} }
@ -67,7 +67,7 @@ struct SmallStackSafeStackAlloc {
* @note needed because endof does not work properly for pointers. * @note needed because endof does not work properly for pointers.
* @return the 'endof' pointer. * @return the 'endof' pointer.
*/ */
FORCEINLINE T *EndOf() inline T *EndOf()
{ {
#if !defined(__NDS__) #if !defined(__NDS__)
return endof(data); return endof(data);
@ -137,7 +137,7 @@ public:
* Get the currently allocated buffer. * Get the currently allocated buffer.
* @return the buffer * @return the buffer
*/ */
FORCEINLINE const T *GetBuffer() const inline const T *GetBuffer() const
{ {
return this->buffer; return this->buffer;
} }
@ -158,26 +158,26 @@ public:
* @param size the amount of bytes to allocate. * @param size the amount of bytes to allocate.
* @return the given amounts of bytes zeroed. * @return the given amounts of bytes zeroed.
*/ */
FORCEINLINE void *operator new(size_t size) { return CallocT<byte>(size); } inline void *operator new(size_t size) { return CallocT<byte>(size); }
/** /**
* Memory allocator for an array of class instances. * Memory allocator for an array of class instances.
* @param size the amount of bytes to allocate. * @param size the amount of bytes to allocate.
* @return the given amounts of bytes zeroed. * @return the given amounts of bytes zeroed.
*/ */
FORCEINLINE void *operator new[](size_t size) { return CallocT<byte>(size); } inline void *operator new[](size_t size) { return CallocT<byte>(size); }
/** /**
* Memory release for a single class instance. * Memory release for a single class instance.
* @param ptr the memory to free. * @param ptr the memory to free.
*/ */
FORCEINLINE void operator delete(void *ptr) { free(ptr); } inline void operator delete(void *ptr) { free(ptr); }
/** /**
* Memory release for an array of class instances. * Memory release for an array of class instances.
* @param ptr the memory to free. * @param ptr the memory to free.
*/ */
FORCEINLINE void operator delete[](void *ptr) { free(ptr); } inline void operator delete[](void *ptr) { free(ptr); }
}; };
#endif /* ALLOC_TYPE_HPP */ #endif /* ALLOC_TYPE_HPP */

30
src/core/bitmath_func.hpp
View File

@ -29,7 +29,7 @@
* @return The selected bits, aligned to a LSB. * @return The selected bits, aligned to a LSB.
*/ */
template <typename T> template <typename T>
static FORCEINLINE uint GB(const T x, const uint8 s, const uint8 n) static inline uint GB(const T x, const uint8 s, const uint8 n)
{ {
return (x >> s) & (((T)1U << n) - 1); return (x >> s) & (((T)1U << n) - 1);
} }
@ -53,7 +53,7 @@ static FORCEINLINE uint GB(const T x, const uint8 s, const uint8 n)
* @return The new value of \a x * @return The new value of \a x
*/ */
template <typename T, typename U> template <typename T, typename U>
static FORCEINLINE T SB(T &x, const uint8 s, const uint8 n, const U d) static inline T SB(T &x, const uint8 s, const uint8 n, const U d)
{ {
x &= (T)(~((((T)1U << n) - 1) << s)); x &= (T)(~((((T)1U << n) - 1) << s));
x |= (T)(d << s); x |= (T)(d << s);
@ -76,7 +76,7 @@ static FORCEINLINE T SB(T &x, const uint8 s, const uint8 n, const U d)
* @return The new value of x * @return The new value of x
*/ */
template <typename T, typename U> template <typename T, typename U>
static FORCEINLINE T AB(T &x, const uint8 s, const uint8 n, const U i) static inline T AB(T &x, const uint8 s, const uint8 n, const U i)
{ {
const T mask = ((((T)1U << n) - 1) << s); const T mask = ((((T)1U << n) - 1) << s);
x = (T)((x & ~mask) | ((x + (i << s)) & mask)); x = (T)((x & ~mask) | ((x + (i << s)) & mask));
@ -95,7 +95,7 @@ static FORCEINLINE T AB(T &x, const uint8 s, const uint8 n, const U i)
* @return True if the bit is set, false else. * @return True if the bit is set, false else.
*/ */
template <typename T> template <typename T>
static FORCEINLINE bool HasBit(const T x, const uint8 y) static inline bool HasBit(const T x, const uint8 y)
{ {
return (x & ((T)1U << y)) != 0; return (x & ((T)1U << y)) != 0;
} }
@ -112,7 +112,7 @@ static FORCEINLINE bool HasBit(const T x, const uint8 y)
* @return The new value of the old value with the bit set * @return The new value of the old value with the bit set
*/ */
template <typename T> template <typename T>
static FORCEINLINE T SetBit(T &x, const uint8 y) static inline T SetBit(T &x, const uint8 y)
{ {
return x = (T)(x | ((T)1U << y)); return x = (T)(x | ((T)1U << y));
} }
@ -141,7 +141,7 @@ static FORCEINLINE T SetBit(T &x, const uint8 y)
* @return The new value of the old value with the bit cleared * @return The new value of the old value with the bit cleared
*/ */
template <typename T> template <typename T>
static FORCEINLINE T ClrBit(T &x, const uint8 y) static inline T ClrBit(T &x, const uint8 y)
{ {
return x = (T)(x & ~((T)1U << y)); return x = (T)(x & ~((T)1U << y));
} }
@ -170,7 +170,7 @@ static FORCEINLINE T ClrBit(T &x, const uint8 y)
* @return The new value of the old value with the bit toggled * @return The new value of the old value with the bit toggled
*/ */
template <typename T> template <typename T>
static FORCEINLINE T ToggleBit(T &x, const uint8 y) static inline T ToggleBit(T &x, const uint8 y)
{ {
return x = (T)(x ^ ((T)1U << y)); return x = (T)(x ^ ((T)1U << y));
} }
@ -205,7 +205,7 @@ extern const uint8 _ffb_64[64];
* @return The position of the first bit which is set * @return The position of the first bit which is set
* @see FIND_FIRST_BIT * @see FIND_FIRST_BIT
*/ */
static FORCEINLINE uint8 FindFirstBit2x64(const int value) static inline uint8 FindFirstBit2x64(const int value)
{ {
if ((value & 0xFF) == 0) { if ((value & 0xFF) == 0) {
return FIND_FIRST_BIT((value >> 8) & 0x3F) + 8; return FIND_FIRST_BIT((value >> 8) & 0x3F) + 8;
@ -228,7 +228,7 @@ uint8 FindLastBit(uint64 x);
* @return The new value with the first bit cleared * @return The new value with the first bit cleared
*/ */
template <typename T> template <typename T>
static FORCEINLINE T KillFirstBit(T value) static inline T KillFirstBit(T value)
{ {
return value &= (T)(value - 1); return value &= (T)(value - 1);
} }
@ -263,7 +263,7 @@ static inline uint CountBits(T value)
* @return does \a value have exactly 1 bit set? * @return does \a value have exactly 1 bit set?
*/ */
template <typename T> template <typename T>
static FORCEINLINE bool HasExactlyOneBit(T value) static inline bool HasExactlyOneBit(T value)
{ {
return value != 0 && (value & (value - 1)) == 0; return value != 0 && (value & (value - 1)) == 0;
} }
@ -275,7 +275,7 @@ static FORCEINLINE bool HasExactlyOneBit(T value)
* @return does \a value have at most 1 bit set? * @return does \a value have at most 1 bit set?
*/ */
template <typename T> template <typename T>
static FORCEINLINE bool HasAtMostOneBit(T value) static inline bool HasAtMostOneBit(T value)
{ {
return (value & (value - 1)) == 0; return (value & (value - 1)) == 0;
} }
@ -289,7 +289,7 @@ static FORCEINLINE bool HasAtMostOneBit(T value)
* @return A bit rotated number * @return A bit rotated number
*/ */
template <typename T> template <typename T>
static FORCEINLINE T ROL(const T x, const uint8 n) static inline T ROL(const T x, const uint8 n)
{ {
return (T)(x << n | x >> (sizeof(x) * 8 - n)); return (T)(x << n | x >> (sizeof(x) * 8 - n));
} }
@ -303,7 +303,7 @@ static FORCEINLINE T ROL(const T x, const uint8 n)
* @return A bit rotated number * @return A bit rotated number
*/ */
template <typename T> template <typename T>
static FORCEINLINE T ROR(const T x, const uint8 n) static inline T ROR(const T x, const uint8 n)
{ {
return (T)(x >> n | x << (sizeof(x) * 8 - n)); return (T)(x >> n | x << (sizeof(x) * 8 - n));
} }
@ -365,7 +365,7 @@ static FORCEINLINE T ROR(const T x, const uint8 n)
* @param x the variable to bitswap * @param x the variable to bitswap
* @return the bitswapped value. * @return the bitswapped value.
*/ */
static FORCEINLINE uint32 BSWAP32(uint32 x) static inline uint32 BSWAP32(uint32 x)
{ {
#if !defined(__ICC) && defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && __GNUC_MINOR__ >= 3)) #if !defined(__ICC) && defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && __GNUC_MINOR__ >= 3))
/* GCC >= 4.3 provides a builtin, resulting in faster code */ /* GCC >= 4.3 provides a builtin, resulting in faster code */
@ -380,7 +380,7 @@ static FORCEINLINE T ROR(const T x, const uint8 n)
* @param x the variable to bitswap * @param x the variable to bitswap
* @return the bitswapped value. * @return the bitswapped value.
*/ */
static FORCEINLINE uint16 BSWAP16(uint16 x) static inline uint16 BSWAP16(uint16 x)
{ {
return (x >> 8) | (x << 8); return (x >> 8) | (x << 8);
} }

4
src/core/endian_func.hpp
View File

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

38
src/core/enum_type.hpp
View File

@ -14,13 +14,13 @@
/** Some enums need to have allowed incrementing (i.e. StationClassID) */ /** Some enums need to have allowed incrementing (i.e. StationClassID) */
#define DECLARE_POSTFIX_INCREMENT(type) \ #define DECLARE_POSTFIX_INCREMENT(type) \
FORCEINLINE type operator ++(type& e, int) \ inline type operator ++(type& e, int) \
{ \ { \
type e_org = e; \ type e_org = e; \
e = (type)((int)e + 1); \ e = (type)((int)e + 1); \
return e_org; \ return e_org; \
} \ } \
FORCEINLINE type operator --(type& e, int) \ inline type operator --(type& e, int) \
{ \ { \
type e_org = e; \ type e_org = e; \
e = (type)((int)e - 1); \ e = (type)((int)e - 1); \
@ -31,13 +31,13 @@
/** Operators to allow to work with enum as with type safe bit set in C++ */ /** Operators to allow to work with enum as with type safe bit set in C++ */
# define DECLARE_ENUM_AS_BIT_SET(mask_t) \ # define DECLARE_ENUM_AS_BIT_SET(mask_t) \
FORCEINLINE mask_t operator | (mask_t m1, mask_t m2) {return (mask_t)((int)m1 | m2);} \ inline mask_t operator | (mask_t m1, mask_t m2) {return (mask_t)((int)m1 | m2);} \
FORCEINLINE mask_t operator & (mask_t m1, mask_t m2) {return (mask_t)((int)m1 & m2);} \ inline mask_t operator & (mask_t m1, mask_t m2) {return (mask_t)((int)m1 & m2);} \
FORCEINLINE mask_t operator ^ (mask_t m1, mask_t m2) {return (mask_t)((int)m1 ^ m2);} \ inline mask_t operator ^ (mask_t m1, mask_t m2) {return (mask_t)((int)m1 ^ m2);} \
FORCEINLINE mask_t& operator |= (mask_t& m1, mask_t m2) {m1 = m1 | m2; return m1;} \ inline mask_t& operator |= (mask_t& m1, mask_t m2) {m1 = m1 | m2; return m1;} \
FORCEINLINE mask_t& operator &= (mask_t& m1, mask_t m2) {m1 = m1 & m2; return m1;} \ inline mask_t& operator &= (mask_t& m1, mask_t m2) {m1 = m1 & m2; return m1;} \
FORCEINLINE mask_t& operator ^= (mask_t& m1, mask_t m2) {m1 = m1 ^ m2; return m1;} \ inline mask_t& operator ^= (mask_t& m1, mask_t m2) {m1 = m1 ^ m2; return m1;} \
FORCEINLINE mask_t operator ~(mask_t m) {return (mask_t)(~(int)m);} inline mask_t operator ~(mask_t m) {return (mask_t)(~(int)m);}
/** /**
@ -98,27 +98,27 @@ struct TinyEnumT {
storage_type m_val; ///< here we hold the actual value in small (i.e. byte) form storage_type m_val; ///< here we hold the actual value in small (i.e. byte) form
/** Cast operator - invoked then the value is assigned to the Tenum_t type */ /** Cast operator - invoked then the value is assigned to the Tenum_t type */
FORCEINLINE operator enum_type () const inline operator enum_type () const
{ {
return (enum_type)m_val; return (enum_type)m_val;
} }
/** Assignment operator (from Tenum_t type) */ /** Assignment operator (from Tenum_t type) */
FORCEINLINE TinyEnumT& operator = (enum_type e) inline TinyEnumT& operator = (enum_type e)
{ {
m_val = (storage_type)e; m_val = (storage_type)e;
return *this; return *this;
} }
/** Assignment operator (from Tenum_t type) */ /** Assignment operator (from Tenum_t type) */
FORCEINLINE TinyEnumT& operator = (uint u) inline TinyEnumT& operator = (uint u)
{ {
m_val = (storage_type)u; m_val = (storage_type)u;
return *this; return *this;
} }
/** postfix ++ operator on tiny type */ /** postfix ++ operator on tiny type */
FORCEINLINE TinyEnumT operator ++ (int) inline TinyEnumT operator ++ (int)
{ {
TinyEnumT org = *this; TinyEnumT org = *this;
if (++m_val >= end) m_val -= (storage_type)(end - begin); if (++m_val >= end) m_val -= (storage_type)(end - begin);
@ -126,7 +126,7 @@ struct TinyEnumT {
} }
/** prefix ++ operator on tiny type */ /** prefix ++ operator on tiny type */
FORCEINLINE TinyEnumT& operator ++ () inline TinyEnumT& operator ++ ()
{ {
if (++m_val >= end) m_val -= (storage_type)(end - begin); if (++m_val >= end) m_val -= (storage_type)(end - begin);
return *this; return *this;
@ -140,34 +140,34 @@ struct SimpleTinyEnumT {
storage_type m_val; ///< here we hold the actual value in small (i.e. byte) form storage_type m_val; ///< here we hold the actual value in small (i.e. byte) form
/** Cast operator - invoked then the value is assigned to the storage_type */ /** Cast operator - invoked then the value is assigned to the storage_type */
FORCEINLINE operator enum_type () const inline operator enum_type () const
{ {
return (enum_type)this->m_val; return (enum_type)this->m_val;
} }
/** Assignment operator (from enum_type) */ /** Assignment operator (from enum_type) */
FORCEINLINE SimpleTinyEnumT &operator = (enum_type e) inline SimpleTinyEnumT &operator = (enum_type e)
{ {
this->m_val = (storage_type)e; this->m_val = (storage_type)e;
return *this; return *this;
} }
/** Assignment operator (from general uint) */ /** Assignment operator (from general uint) */
FORCEINLINE SimpleTinyEnumT &operator = (uint u) inline SimpleTinyEnumT &operator = (uint u)
{ {
this->m_val = (storage_type)u; this->m_val = (storage_type)u;
return *this; return *this;
} }
/** Bit math (or) assignment operator (from enum_type) */ /** Bit math (or) assignment operator (from enum_type) */
FORCEINLINE SimpleTinyEnumT &operator |= (enum_type e) inline SimpleTinyEnumT &operator |= (enum_type e)
{ {
this->m_val = (storage_type)((enum_type)this->m_val | e); this->m_val = (storage_type)((enum_type)this->m_val | e);
return *this; return *this;
} }
/** Bit math (and) assignment operator (from enum_type) */ /** Bit math (and) assignment operator (from enum_type) */
FORCEINLINE SimpleTinyEnumT &operator &= (enum_type e) inline SimpleTinyEnumT &operator &= (enum_type e)
{ {
this->m_val = (storage_type)((enum_type)this->m_val & e); this->m_val = (storage_type)((enum_type)this->m_val & e);
return *this; return *this;

42
src/core/math_func.hpp
View File

@ -35,7 +35,7 @@
* @return The greater value or a if equals * @return The greater value or a if equals
*/ */
template <typename T> template <typename T>
static FORCEINLINE T max(const T a, const T b) static inline T max(const T a, const T b)
{ {
return (a >= b) ? a : b; return (a >= b) ? a : b;
} }
@ -51,7 +51,7 @@ static FORCEINLINE T max(const T a, const T b)
* @return The smaller value or b if equals * @return The smaller value or b if equals
*/ */
template <typename T> template <typename T>
static FORCEINLINE T min(const T a, const T b) static inline T min(const T a, const T b)
{ {
return (a < b) ? a : b; return (a < b) ? a : b;
} }
@ -65,7 +65,7 @@ static FORCEINLINE T min(const T a, const T b)
* @param b The second integer * @param b The second integer
* @return The smaller value * @return The smaller value
*/ */
static FORCEINLINE int min(const int a, const int b) static inline int min(const int a, const int b)
{ {
return min<int>(a, b); return min<int>(a, b);
} }
@ -79,7 +79,7 @@ static FORCEINLINE int min(const int a, const int b)
* @param b The second unsigned integer * @param b The second unsigned integer
* @return The smaller value * @return The smaller value
*/ */
static FORCEINLINE uint minu(const uint a, const uint b) static inline uint minu(const uint a, const uint b)
{ {
return min<uint>(a, b); return min<uint>(a, b);
} }
@ -92,7 +92,7 @@ static FORCEINLINE uint minu(const uint a, const uint b)
* @return The unsigned value * @return The unsigned value
*/ */
template <typename T> template <typename T>
static FORCEINLINE T abs(const T a) static inline T abs(const T a)
{ {
return (a < (T)0) ? -a : a; return (a < (T)0) ? -a : a;
} }
@ -106,7 +106,7 @@ static FORCEINLINE T abs(const T a)
* @return The smallest multiple of n equal or greater than x * @return The smallest multiple of n equal or greater than x
*/ */
template <typename T> template <typename T>
static FORCEINLINE T Align(const T x, uint n) static inline T Align(const T x, uint n)
{ {
assert((n & (n - 1)) == 0 && n != 0); assert((n & (n - 1)) == 0 && n != 0);
n--; n--;
@ -124,7 +124,7 @@ static FORCEINLINE T Align(const T x, uint n)
* @see Align() * @see Align()
*/ */
template <typename T> template <typename T>
static FORCEINLINE T *AlignPtr(T *x, uint n) static inline T *AlignPtr(T *x, uint n)
{ {
assert_compile(sizeof(size_t) == sizeof(void *)); assert_compile(sizeof(size_t) == sizeof(void *));
return (T *)Align((size_t)x, n); return (T *)Align((size_t)x, n);
@ -148,7 +148,7 @@ static FORCEINLINE T *AlignPtr(T *x, uint n)
* @see Clamp(int, int, int) * @see Clamp(int, int, int)
*/ */
template <typename T> template <typename T>
static FORCEINLINE T Clamp(const T a, const T min, const T max) static inline T Clamp(const T a, const T min, const T max)
{ {
assert(min <= max); assert(min <= max);
if (a <= min) return min; if (a <= min) return min;
@ -172,7 +172,7 @@ static FORCEINLINE T Clamp(const T a, const T min, const T max)
* @returns A value between min and max which is closest to a. * @returns A value between min and max which is closest to a.
* @see ClampU(uint, uint, uint) * @see ClampU(uint, uint, uint)
*/ */
static FORCEINLINE int Clamp(const int a, const int min, const int max) static inline int Clamp(const int a, const int min, const int max)
{ {
return Clamp<int>(a, min, max); return Clamp<int>(a, min, max);
} }
@ -193,7 +193,7 @@ static FORCEINLINE int Clamp(const int a, const int min, const int max)
* @returns A value between min and max which is closest to a. * @returns A value between min and max which is closest to a.
* @see Clamp(int, int, int) * @see Clamp(int, int, int)
*/ */
static FORCEINLINE uint ClampU(const uint a, const uint min, const uint max) static inline uint ClampU(const uint a, const uint min, const uint max)
{ {
return Clamp<uint>(a, min, max); return Clamp<uint>(a, min, max);
} }
@ -212,7 +212,7 @@ static FORCEINLINE uint ClampU(const uint a, const uint min, const uint max)
* @return The 64-bit value reduced to a 32-bit value * @return The 64-bit value reduced to a 32-bit value
* @see Clamp(int, int, int) * @see Clamp(int, int, int)
*/ */
static FORCEINLINE int32 ClampToI32(const int64 a) static inline int32 ClampToI32(const int64 a)
{ {
return (int32)Clamp<int64>(a, INT32_MIN, INT32_MAX); return (int32)Clamp<int64>(a, INT32_MIN, INT32_MAX);
} }
@ -224,7 +224,7 @@ static FORCEINLINE int32 ClampToI32(const int64 a)
* @return The 64-bit value reduced to a 16-bit value * @return The 64-bit value reduced to a 16-bit value
* @see ClampU(uint, uint, uint) * @see ClampU(uint, uint, uint)
*/ */
static FORCEINLINE uint16 ClampToU16(const uint64 a) static inline uint16 ClampToU16(const uint64 a)
{ {
/* MSVC thinks, in its infinite wisdom, that int min(int, int) is a better /* MSVC thinks, in its infinite wisdom, that int min(int, int) is a better
* match for min(uint64, uint) than uint64 min(uint64, uint64). As such we * match for min(uint64, uint) than uint64 min(uint64, uint64). As such we
@ -241,7 +241,7 @@ static FORCEINLINE uint16 ClampToU16(const uint64 a)
* @return The absolute difference between the given scalars * @return The absolute difference between the given scalars
*/ */
template <typename T> template <typename T>
static FORCEINLINE T Delta(const T a, const T b) static inline T Delta(const T a, const T b)
{ {
return (a < b) ? b - a : a - b; return (a < b) ? b - a : a - b;
} }
@ -259,7 +259,7 @@ static FORCEINLINE T Delta(const T a, const T b)
* @return True if the value is in the interval, false else. * @return True if the value is in the interval, false else.
*/ */
template <typename T> template <typename T>
static FORCEINLINE bool IsInsideBS(const T x, const uint base, const uint size) static inline bool IsInsideBS(const T x, const uint base, const uint size)
{ {
return (uint)(x - base) < size; return (uint)(x - base) < size;
} }
@ -275,7 +275,7 @@ static FORCEINLINE bool IsInsideBS(const T x, const uint base, const uint size)
* @see IsInsideBS() * @see IsInsideBS()
*/ */
template <typename T> template <typename T>
static FORCEINLINE bool IsInsideMM(const T x, const uint min, const uint max) static inline bool IsInsideMM(const T x, const uint min, const uint max)
{ {
return (uint)(x - min) < (max - min); return (uint)(x - min) < (max - min);
} }
@ -286,7 +286,7 @@ static FORCEINLINE bool IsInsideMM(const T x, const uint min, const uint max)
* @param b variable to swap with a * @param b variable to swap with a
*/ */
template <typename T> template <typename T>
static FORCEINLINE void Swap(T &a, T &b) static inline void Swap(T &a, T &b)
{ {
T t = a; T t = a;
a = b; a = b;
@ -298,7 +298,7 @@ static FORCEINLINE void Swap(T &a, T &b)
* @param i value to convert, range 0..255 * @param i value to convert, range 0..255
* @return value in range 0..100 * @return value in range 0..100
*/ */
static FORCEINLINE uint ToPercent8(uint i) static inline uint ToPercent8(uint i)
{ {
assert(i < 256); assert(i < 256);
return i * 101 >> 8; return i * 101 >> 8;
@ -309,7 +309,7 @@ static FORCEINLINE uint ToPercent8(uint i)
* @param i value to convert, range 0..65535 * @param i value to convert, range 0..65535
* @return value in range 0..100 * @return value in range 0..100
*/ */
static FORCEINLINE uint ToPercent16(uint i) static inline uint ToPercent16(uint i)
{ {
assert(i < 65536); assert(i < 65536);
return i * 101 >> 16; return i * 101 >> 16;
@ -324,7 +324,7 @@ int GreatestCommonDivisor(int a, int b);
* @param b Denominator * @param b Denominator
* @return Quotient, rounded up * @return Quotient, rounded up
*/ */
static FORCEINLINE uint CeilDiv(uint a, uint b) static inline uint CeilDiv(uint a, uint b)
{ {
return (a + b - 1) / b; return (a + b - 1) / b;
} }
@ -335,7 +335,7 @@ static FORCEINLINE uint CeilDiv(uint a, uint b)
* @param b Denominator * @param b Denominator
* @return a rounded up to the nearest multiple of b. * @return a rounded up to the nearest multiple of b.
*/ */
static FORCEINLINE uint Ceil(uint a, uint b) static inline uint Ceil(uint a, uint b)
{ {
return CeilDiv(a, b) * b; return CeilDiv(a, b) * b;
} }
@ -346,7 +346,7 @@ static FORCEINLINE uint Ceil(uint a, uint b)
* @param b Denominator * @param b Denominator
* @return Quotient, rounded to nearest * @return Quotient, rounded to nearest
*/ */
static FORCEINLINE int RoundDivSU(int a, uint b) static inline int RoundDivSU(int a, uint b)
{ {
if (a > 0) { if (a > 0) {
/* 0.5 is rounded to 1 */ /* 0.5 is rounded to 1 */

12
src/core/mem_func.hpp
View File

@ -22,7 +22,7 @@
* @param num number of items to be copied. (!not number of bytes!) * @param num number of items to be copied. (!not number of bytes!)
*/ */
template <typename T> template <typename T>
static FORCEINLINE void MemCpyT(T *destination, const T *source, size_t num = 1) static inline void MemCpyT(T *destination, const T *source, size_t num = 1)
{ {
memcpy(destination, source, num * sizeof(T)); memcpy(destination, source, num * sizeof(T));
} }
@ -35,7 +35,7 @@ static FORCEINLINE void MemCpyT(T *destination, const T *source, size_t num = 1)
* @param num number of items to be copied. (!not number of bytes!) * @param num number of items to be copied. (!not number of bytes!)
*/ */
template <typename T> template <typename T>
static FORCEINLINE void MemMoveT(T *destination, const T *source, size_t num = 1) static inline void MemMoveT(T *destination, const T *source, size_t num = 1)
{ {
memmove(destination, source, num * sizeof(T)); memmove(destination, source, num * sizeof(T));
} }
@ -48,7 +48,7 @@ static FORCEINLINE void MemMoveT(T *destination, const T *source, size_t num = 1
* @param num number of items to be set (!not number of bytes!) * @param num number of items to be set (!not number of bytes!)
*/ */
template <typename T> template <typename T>
static FORCEINLINE void MemSetT(T *ptr, byte value, size_t num = 1) static inline void MemSetT(T *ptr, byte value, size_t num = 1)
{ {
memset(ptr, value, num * sizeof(T)); memset(ptr, value, num * sizeof(T));
} }
@ -62,7 +62,7 @@ static FORCEINLINE void MemSetT(T *ptr, byte value, size_t num = 1)
* @return an int value indicating the relationship between the content of the two buffers * @return an int value indicating the relationship between the content of the two buffers
*/ */
template <typename T> template <typename T>
static FORCEINLINE int MemCmpT(const T *ptr1, const T *ptr2, size_t num = 1) static inline int MemCmpT(const T *ptr1, const T *ptr2, size_t num = 1)
{ {
return memcmp(ptr1, ptr2, num * sizeof(T)); return memcmp(ptr1, ptr2, num * sizeof(T));
} }
@ -76,7 +76,7 @@ static FORCEINLINE int MemCmpT(const T *ptr1, const T *ptr2, size_t num = 1)
* @param ptr2 End-pointer to the block of memory. * @param ptr2 End-pointer to the block of memory.
*/ */
template <typename T> template <typename T>
static FORCEINLINE void MemReverseT(T *ptr1, T *ptr2) static inline void MemReverseT(T *ptr1, T *ptr2)
{ {
assert(ptr1 != NULL && ptr2 != NULL); assert(ptr1 != NULL && ptr2 != NULL);
assert(ptr1 < ptr2); assert(ptr1 < ptr2);
@ -93,7 +93,7 @@ static FORCEINLINE void MemReverseT(T *ptr1, T *ptr2)
* @param num The number of items we want to reverse. * @param num The number of items we want to reverse.
*/ */
template <typename T> template <typename T>
static FORCEINLINE void MemReverseT(T *ptr, size_t num) static inline void MemReverseT(T *ptr, size_t num)
{ {
assert(ptr != NULL); assert(ptr != NULL);

118
src/core/overflowsafe_type.hpp
View File

@ -33,9 +33,9 @@ public:
OverflowSafeInt(const OverflowSafeInt& other) { this->m_value = other.m_value; } OverflowSafeInt(const OverflowSafeInt& other) { this->m_value = other.m_value; }
OverflowSafeInt(const int64 int_) { this->m_value = int_; } OverflowSafeInt(const int64 int_) { this->m_value = int_; }
FORCEINLINE OverflowSafeInt& operator = (const OverflowSafeInt& other) { this->m_value = other.m_value; return *this; } inline OverflowSafeInt& operator = (const OverflowSafeInt& other) { this->m_value = other.m_value; return *this; }
FORCEINLINE OverflowSafeInt operator - () const { return OverflowSafeInt(-this->m_value); } inline OverflowSafeInt operator - () const { return OverflowSafeInt(-this->m_value); }
/** /**
* Safe implementation of addition. * Safe implementation of addition.
@ -43,7 +43,7 @@ public:
* @note when the addition would yield more than T_MAX (or less than T_MIN), * @note when the addition would yield more than T_MAX (or less than T_MIN),
* it will be T_MAX (respectively T_MIN). * it will be T_MAX (respectively T_MIN).
*/ */
FORCEINLINE OverflowSafeInt& operator += (const OverflowSafeInt& other) inline OverflowSafeInt& operator += (const OverflowSafeInt& other)
{ {
if ((T_MAX - abs(other.m_value)) < abs(this->m_value) && if ((T_MAX - abs(other.m_value)) < abs(this->m_value) &&
(this->m_value < 0) == (other.m_value < 0)) { (this->m_value < 0) == (other.m_value < 0)) {
@ -55,18 +55,18 @@ public:
} }
/* Operators for addition and substraction */ /* Operators for addition and substraction */
FORCEINLINE OverflowSafeInt operator + (const OverflowSafeInt& other) const { OverflowSafeInt result = *this; result += other; return result; } inline OverflowSafeInt operator + (const OverflowSafeInt& other) const { OverflowSafeInt result = *this; result += other; return result; }
FORCEINLINE OverflowSafeInt operator + (const int other) const { OverflowSafeInt result = *this; result += (int64)other; return result; } inline OverflowSafeInt operator + (const int other) const { OverflowSafeInt result = *this; result += (int64)other; return result; }
FORCEINLINE OverflowSafeInt operator + (const uint other) const { OverflowSafeInt result = *this; result += (int64)other; return result; } inline OverflowSafeInt operator + (const uint other) const { OverflowSafeInt result = *this; result += (int64)other; return result; }
FORCEINLINE OverflowSafeInt& operator -= (const OverflowSafeInt& other) { return *this += (-other); } inline OverflowSafeInt& operator -= (const OverflowSafeInt& other) { return *this += (-other); }
FORCEINLINE OverflowSafeInt operator - (const OverflowSafeInt& other) const { OverflowSafeInt result = *this; result -= other; return result; } inline OverflowSafeInt operator - (const OverflowSafeInt& other) const { OverflowSafeInt result = *this; result -= other; return result; }
FORCEINLINE OverflowSafeInt operator - (const int other) const { OverflowSafeInt result = *this; result -= (int64)other; return result; } inline OverflowSafeInt operator - (const int other) const { OverflowSafeInt result = *this; result -= (int64)other; return result; }
FORCEINLINE OverflowSafeInt operator - (const uint other) const { OverflowSafeInt result = *this; result -= (int64)other; return result; } inline OverflowSafeInt operator - (const uint other) const { OverflowSafeInt result = *this; result -= (int64)other; return result; }
FORCEINLINE OverflowSafeInt& operator ++ () { return *this += 1; } inline OverflowSafeInt& operator ++ () { return *this += 1; }
FORCEINLINE OverflowSafeInt& operator -- () { return *this += -1; } inline OverflowSafeInt& operator -- () { return *this += -1; }
FORCEINLINE OverflowSafeInt operator ++ (int) { OverflowSafeInt org = *this; *this += 1; return org; } inline OverflowSafeInt operator ++ (int) { OverflowSafeInt org = *this; *this += 1; return org; }
FORCEINLINE OverflowSafeInt operator -- (int) { OverflowSafeInt org = *this; *this += -1; return org; } inline OverflowSafeInt operator -- (int) { OverflowSafeInt org = *this; *this += -1; return org; }
/** /**
* Safe implementation of multiplication. * Safe implementation of multiplication.
@ -74,7 +74,7 @@ public:
* @note when the multiplication would yield more than T_MAX (or less than T_MIN), * @note when the multiplication would yield more than T_MAX (or less than T_MIN),
* it will be T_MAX (respectively T_MIN). * it will be T_MAX (respectively T_MIN).
*/ */
FORCEINLINE OverflowSafeInt& operator *= (const int factor) inline OverflowSafeInt& operator *= (const int factor)
{ {
if (factor != 0 && (T_MAX / abs(factor)) < abs(this->m_value)) { if (factor != 0 && (T_MAX / abs(factor)) < abs(this->m_value)) {
this->m_value = ((this->m_value < 0) == (factor < 0)) ? T_MAX : T_MIN ; this->m_value = ((this->m_value < 0) == (factor < 0)) ? T_MAX : T_MIN ;
@ -85,70 +85,70 @@ public:
} }
/* Operators for multiplication */ /* Operators for multiplication */
FORCEINLINE OverflowSafeInt operator * (const int64 factor) const { OverflowSafeInt result = *this; result *= factor; return result; } inline OverflowSafeInt operator * (const int64 factor) const { OverflowSafeInt result = *this; result *= factor; return result; }
FORCEINLINE OverflowSafeInt operator * (const int factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; } inline OverflowSafeInt operator * (const int factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; }
FORCEINLINE OverflowSafeInt operator * (const uint factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; } inline OverflowSafeInt operator * (const uint factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; }
FORCEINLINE OverflowSafeInt operator * (const uint16 factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; } inline OverflowSafeInt operator * (const uint16 factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; }
FORCEINLINE OverflowSafeInt operator * (const byte factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; } inline OverflowSafeInt operator * (const byte factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; }
/* Operators for division */ /* Operators for division */
FORCEINLINE OverflowSafeInt& operator /= (const int64 divisor) { this->m_value /= divisor; return *this; } inline OverflowSafeInt& operator /= (const int64 divisor) { this->m_value /= divisor; return *this; }
FORCEINLINE OverflowSafeInt operator / (const OverflowSafeInt& divisor) const { OverflowSafeInt result = *this; result /= divisor.m_value; return result; } inline OverflowSafeInt operator / (const OverflowSafeInt& divisor) const { OverflowSafeInt result = *this; result /= divisor.m_value; return result; }
FORCEINLINE OverflowSafeInt operator / (const int divisor) const { OverflowSafeInt result = *this; result /= divisor; return result; } inline OverflowSafeInt operator / (const int divisor) const { OverflowSafeInt result = *this; result /= divisor; return result; }
FORCEINLINE OverflowSafeInt operator / (const uint divisor) const { OverflowSafeInt result = *this; result /= (int)divisor; return result; } inline OverflowSafeInt operator / (const uint divisor) const { OverflowSafeInt result = *this; result /= (int)divisor; return result; }
/* Operators for modulo */ /* Operators for modulo */
FORCEINLINE OverflowSafeInt& operator %= (const int divisor) { this->m_value %= divisor; return *this; } inline OverflowSafeInt& operator %= (const int divisor) { this->m_value %= divisor; return *this; }
FORCEINLINE OverflowSafeInt operator % (const int divisor) const { OverflowSafeInt result = *this; result %= divisor; return result; } inline OverflowSafeInt operator % (const int divisor) const { OverflowSafeInt result = *this; result %= divisor; return result; }
/* Operators for shifting */ /* Operators for shifting */
FORCEINLINE OverflowSafeInt& operator <<= (const int shift) { this->m_value <<= shift; return *this; } inline OverflowSafeInt& operator <<= (const int shift) { this->m_value <<= shift; return *this; }
FORCEINLINE OverflowSafeInt operator << (const int shift) const { OverflowSafeInt result = *this; result <<= shift; return result; } inline OverflowSafeInt operator << (const int shift) const { OverflowSafeInt result = *this; result <<= shift; return result; }
FORCEINLINE OverflowSafeInt& operator >>= (const int shift) { this->m_value >>= shift; return *this; } inline OverflowSafeInt& operator >>= (const int shift) { this->m_value >>= shift; return *this; }
FORCEINLINE OverflowSafeInt operator >> (const int shift) const { OverflowSafeInt result = *this; result >>= shift; return result; } inline OverflowSafeInt operator >> (const int shift) const { OverflowSafeInt result = *this; result >>= shift; return result; }
/* Operators for (in)equality when comparing overflow safe ints */ /* Operators for (in)equality when comparing overflow safe ints */
FORCEINLINE bool operator == (const OverflowSafeInt& other) const { return this->m_value == other.m_value; } inline bool operator == (const OverflowSafeInt& other) const { return this->m_value == other.m_value; }
FORCEINLINE bool operator != (const OverflowSafeInt& other) const { return !(*this == other); } inline bool operator != (const OverflowSafeInt& other) const { return !(*this == other); }
FORCEINLINE bool operator > (const OverflowSafeInt& other) const { return this->m_value > other.m_value; } inline bool operator > (const OverflowSafeInt& other) const { return this->m_value > other.m_value; }
FORCEINLINE bool operator >= (const OverflowSafeInt& other) const { return this->m_value >= other.m_value; } inline bool operator >= (const OverflowSafeInt& other) const { return this->m_value >= other.m_value; }
FORCEINLINE bool operator < (const OverflowSafeInt& other) const { return !(*this >= other); } inline bool operator < (const OverflowSafeInt& other) const { return !(*this >= other); }
FORCEINLINE bool operator <= (const OverflowSafeInt& other) const { return !(*this > other); } inline bool operator <= (const OverflowSafeInt& other) const { return !(*this > other); }
/* Operators for (in)equality when comparing non-overflow safe ints */ /* Operators for (in)equality when comparing non-overflow safe ints */
FORCEINLINE bool operator == (const int other) const { return this->m_value == other; } inline bool operator == (const int other) const { return this->m_value == other; }
FORCEINLINE bool operator != (const int other) const { return !(*this == other); } inline bool operator != (const int other) const { return !(*this == other); }
FORCEINLINE bool operator > (const int other) const { return this->m_value > other; } inline bool operator > (const int other) const { return this->m_value > other; }
FORCEINLINE bool operator >= (const int other) const { return this->m_value >= other; } inline bool operator >= (const int other) const { return this->m_value >= other; }
FORCEINLINE bool operator < (const int other) const { return !(*this >= other); } inline bool operator < (const int other) const { return !(*this >= other); }
FORCEINLINE bool operator <= (const int other) const { return !(*this > other); } inline bool operator <= (const int other) const { return !(*this > other); }
FORCEINLINE operator int64 () const { return this->m_value; } inline operator int64 () const { return this->m_value; }
}; };
/* Sometimes we got int64 operator OverflowSafeInt instead of vice versa. Handle that properly */ /* Sometimes we got int64 operator OverflowSafeInt instead of vice versa. Handle that properly */
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator + (int64 a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b + a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator + (int64 a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b + a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator - (int64 a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return -b + a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator - (int64 a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return -b + a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator * (int64 a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b * a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator * (int64 a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b * a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator / (int64 a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return (OverflowSafeInt<T, T_MAX, T_MIN>)a / (int)b; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator / (int64 a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return (OverflowSafeInt<T, T_MAX, T_MIN>)a / (int)b; }
/* Sometimes we got int operator OverflowSafeInt instead of vice versa. Handle that properly */ /* Sometimes we got int operator OverflowSafeInt instead of vice versa. Handle that properly */
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator + (int a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b + a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator + (int a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b + a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator - (int a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return -b + a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator - (int a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return -b + a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator * (int a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b * a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator * (int a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b * a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator / (int a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return (OverflowSafeInt<T, T_MAX, T_MIN>)a / (int)b; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator / (int a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return (OverflowSafeInt<T, T_MAX, T_MIN>)a / (int)b; }
/* Sometimes we got uint operator OverflowSafeInt instead of vice versa. Handle that properly */ /* Sometimes we got uint operator OverflowSafeInt instead of vice versa. Handle that properly */
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator + (uint a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b + a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator + (uint a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b + a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator - (uint a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return -b + a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator - (uint a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return -b + a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator * (uint a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b * a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator * (uint a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b * a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator / (uint a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return (OverflowSafeInt<T, T_MAX, T_MIN>)a / (int)b; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator / (uint a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return (OverflowSafeInt<T, T_MAX, T_MIN>)a / (int)b; }
/* Sometimes we got byte operator OverflowSafeInt instead of vice versa. Handle that properly */ /* Sometimes we got byte operator OverflowSafeInt instead of vice versa. Handle that properly */
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator + (byte a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b + (uint)a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator + (byte a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b + (uint)a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator - (byte a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return -b + (uint)a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator - (byte a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return -b + (uint)a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator * (byte a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b * (uint)a; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator * (byte a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return b * (uint)a; }
template <class T, int64 T_MAX, int64 T_MIN> FORCEINLINE OverflowSafeInt<T, T_MAX, T_MIN> operator / (byte a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return (OverflowSafeInt<T, T_MAX, T_MIN>)a / (int)b; } template <class T, int64 T_MAX, int64 T_MIN> inline OverflowSafeInt<T, T_MAX, T_MIN> operator / (byte a, OverflowSafeInt<T, T_MAX, T_MIN> b) { return (OverflowSafeInt<T, T_MAX, T_MIN>)a / (int)b; }
typedef OverflowSafeInt<int64, INT64_MAX, INT64_MIN> OverflowSafeInt64; typedef OverflowSafeInt<int64, INT64_MAX, INT64_MIN> OverflowSafeInt64;

30
src/core/pool_type.hpp
View File

@ -98,7 +98,7 @@ struct Pool : PoolBase {
* @return pointer to Titem * @return pointer to Titem
* @pre index < this->first_unused * @pre index < this->first_unused
*/ */
FORCEINLINE Titem *Get(size_t index) inline Titem *Get(size_t index)
{ {
assert(index < this->first_unused); assert(index < this->first_unused);
return this->data[index]; return this->data[index];
@ -109,7 +109,7 @@ struct Pool : PoolBase {
* @param index index to examine * @param index index to examine
* @return true if PoolItem::Get(index) will return non-NULL pointer * @return true if PoolItem::Get(index) will return non-NULL pointer
*/ */
FORCEINLINE bool IsValidID(size_t index) inline bool IsValidID(size_t index)
{ {
return index < this->first_unused && this->Get(index) != NULL; return index < this->first_unused && this->Get(index) != NULL;
} }
@ -119,7 +119,7 @@ struct Pool : PoolBase {
* @param n number of items we want to allocate * @param n number of items we want to allocate
* @return true if 'n' items can be allocated * @return true if 'n' items can be allocated
*/ */
FORCEINLINE bool CanAllocate(size_t n = 1) inline bool CanAllocate(size_t n = 1)
{ {
bool ret = this->items <= Tmax_size - n; bool ret = this->items <= Tmax_size - n;
#ifdef OTTD_ASSERT #ifdef OTTD_ASSERT
@ -142,7 +142,7 @@ struct Pool : PoolBase {
* @return pointer to allocated memory * @return pointer to allocated memory
* @note can never fail (return NULL), use CanAllocate() to check first! * @note can never fail (return NULL), use CanAllocate() to check first!
*/ */
FORCEINLINE void *operator new(size_t size) inline void *operator new(size_t size)
{ {
return Tpool->GetNew(size); return Tpool->GetNew(size);
} }
@ -152,7 +152,7 @@ struct Pool : PoolBase {
* @param p memory to free * @param p memory to free
* @note the item has to be allocated in the pool! * @note the item has to be allocated in the pool!
*/ */
FORCEINLINE void operator delete(void *p) inline void operator delete(void *p)
{ {
Titem *pn = (Titem *)p; Titem *pn = (Titem *)p;
assert(pn == Tpool->Get(pn->index)); assert(pn == Tpool->Get(pn->index));
@ -167,7 +167,7 @@ struct Pool : PoolBase {
* @note can never fail (return NULL), use CanAllocate() to check first! * @note can never fail (return NULL), use CanAllocate() to check first!
* @pre index has to be unused! Else it will crash * @pre index has to be unused! Else it will crash
*/ */
FORCEINLINE void *operator new(size_t size, size_t index) inline void *operator new(size_t size, size_t index)
{ {
return Tpool->GetNew(size, index); return Tpool->GetNew(size, index);
} }
@ -180,7 +180,7 @@ struct Pool : PoolBase {
* @note use of this is strongly discouraged * @note use of this is strongly discouraged
* @pre the memory must not be allocated in the Pool! * @pre the memory must not be allocated in the Pool!
*/ */
FORCEINLINE void *operator new(size_t size, void *ptr) inline void *operator new(size_t size, void *ptr)
{ {
for (size_t i = 0; i < Tpool->first_unused; i++) { for (size_t i = 0; i < Tpool->first_unused; i++) {
/* Don't allow creating new objects over existing. /* Don't allow creating new objects over existing.
@ -202,7 +202,7 @@ struct Pool : PoolBase {
* @param n number of items we want to allocate * @param n number of items we want to allocate
* @return true if 'n' items can be allocated * @return true if 'n' items can be allocated
*/ */
static FORCEINLINE bool CanAllocateItem(size_t n = 1) static inline bool CanAllocateItem(size_t n = 1)
{ {
return Tpool->CanAllocate(n); return Tpool->CanAllocate(n);
} }
@ -211,7 +211,7 @@ struct Pool : PoolBase {
* Returns current state of pool cleaning - yes or no * Returns current state of pool cleaning - yes or no
* @return true iff we are cleaning the pool now * @return true iff we are cleaning the pool now
*/ */
static FORCEINLINE bool CleaningPool() static inline bool CleaningPool()
{ {
return Tpool->cleaning; return Tpool->cleaning;
} }
@ -221,7 +221,7 @@ struct Pool : PoolBase {
* @param index index to examine * @param index index to examine
* @return true if PoolItem::Get(index) will return non-NULL pointer * @return true if PoolItem::Get(index) will return non-NULL pointer
*/ */
static FORCEINLINE bool IsValidID(size_t index) static inline bool IsValidID(size_t index)
{ {
return Tpool->IsValidID(index); return Tpool->IsValidID(index);
} }
@ -232,7 +232,7 @@ struct Pool : PoolBase {
* @return pointer to Titem * @return pointer to Titem
* @pre index < this->first_unused * @pre index < this->first_unused
*/ */
static FORCEINLINE Titem *Get(size_t index) static inline Titem *Get(size_t index)
{ {
return Tpool->Get(index); return Tpool->Get(index);
} }
@ -243,7 +243,7 @@ struct Pool : PoolBase {
* @return pointer to Titem * @return pointer to Titem
* @note returns NULL for invalid index * @note returns NULL for invalid index
*/ */
static FORCEINLINE Titem *GetIfValid(size_t index) static inline Titem *GetIfValid(size_t index)
{ {
return index < Tpool->first_unused ? Tpool->Get(index) : NULL; return index < Tpool->first_unused ? Tpool->Get(index) : NULL;
} }
@ -253,7 +253,7 @@ struct Pool : PoolBase {
* all pool items. * all pool items.
* @return first unused index * @return first unused index
*/ */
static FORCEINLINE size_t GetPoolSize() static inline size_t GetPoolSize()
{ {
return Tpool->first_unused; return Tpool->first_unused;
} }
@ -262,7 +262,7 @@ struct Pool : PoolBase {
* Returns number of valid items in the pool * Returns number of valid items in the pool
* @return number of valid items in the pool * @return number of valid items in the pool
*/ */
static FORCEINLINE size_t GetNumItems() static inline size_t GetNumItems()
{ {
return Tpool->items; return Tpool->items;
} }
@ -274,7 +274,7 @@ struct Pool : PoolBase {
* @note when this function is called, PoolItem::Get(index) == NULL. * @note when this function is called, PoolItem::Get(index) == NULL.
* @note it's called only when !CleaningPool() * @note it's called only when !CleaningPool()
*/ */
static FORCEINLINE void PostDestructor(size_t index) { } static inline void PostDestructor(size_t index) { }
}; };
private: private:

14
src/core/random_func.hpp
View File

@ -81,23 +81,23 @@ void SetRandomSeed(uint32 seed);
#define RandomRange(max) DoRandomRange(max, __LINE__, __FILE__) #define RandomRange(max) DoRandomRange(max, __LINE__, __FILE__)
uint32 DoRandomRange(uint32 max, int line, const char *file); uint32 DoRandomRange(uint32 max, int line, const char *file);
#else #else
static FORCEINLINE uint32 Random() static inline uint32 Random()
{ {
return _random.Next(); return _random.Next();
} }
static FORCEINLINE uint32 RandomRange(uint32 max) static inline uint32 RandomRange(uint32 max)
{ {
return _random.Next(max); return _random.Next(max);
} }
#endif #endif
static FORCEINLINE uint32 InteractiveRandom() static inline uint32 InteractiveRandom()
{ {
return _interactive_random.Next(); return _interactive_random.Next();
} }
static FORCEINLINE uint32 InteractiveRandomRange(uint32 max) static inline uint32 InteractiveRandomRange(uint32 max)
{ {
return _interactive_random.Next(max); return _interactive_random.Next(max);
} }
@ -117,7 +117,7 @@ static FORCEINLINE uint32 InteractiveRandomRange(uint32 max)
* @param r The given randomize-number * @param r The given randomize-number
* @return True if the probability given by r is less or equal to (a/b) * @return True if the probability given by r is less or equal to (a/b)
*/ */
static FORCEINLINE bool Chance16I(const uint a, const uint b, const uint32 r) static inline bool Chance16I(const uint a, const uint b, const uint32 r)
{ {
assert(b != 0); assert(b != 0);
return (((uint16)r * b + b / 2) >> 16) < a; return (((uint16)r * b + b / 2) >> 16) < a;
@ -136,7 +136,7 @@ static FORCEINLINE bool Chance16I(const uint a, const uint b, const uint32 r)
#ifdef RANDOM_DEBUG #ifdef RANDOM_DEBUG
#define Chance16(a, b) Chance16I(a, b, DoRandom(__LINE__, __FILE__)) #define Chance16(a, b) Chance16I(a, b, DoRandom(__LINE__, __FILE__))
#else #else
static FORCEINLINE bool Chance16(const uint a, const uint b) static inline bool Chance16(const uint a, const uint b)
{ {
return Chance16I(a, b, Random()); return Chance16I(a, b, Random());
} }
@ -160,7 +160,7 @@ static FORCEINLINE bool Chance16(const uint a, const uint b)
#ifdef RANDOM_DEBUG #ifdef RANDOM_DEBUG
#define Chance16R(a, b, r) (r = DoRandom(__LINE__, __FILE__), Chance16I(a, b, r)) #define Chance16R(a, b, r) (r = DoRandom(__LINE__, __FILE__), Chance16I(a, b, r))
#else #else
static FORCEINLINE bool Chance16R(const uint a, const uint b, uint32 &r) static inline bool Chance16R(const uint a, const uint b, uint32 &r)
{ {
r = Random(); r = Random();
return Chance16I(a, b, r); return Chance16I(a, b, r);

20
src/core/smallmap_type.hpp
View File

@ -26,7 +26,7 @@ struct SmallPair {
U second; U second;
/** Initializes this Pair with data */ /** Initializes this Pair with data */
FORCEINLINE SmallPair(const T &first, const U &second) : first(first), second(second) { } inline SmallPair(const T &first, const U &second) : first(first), second(second) { }
}; };
/** /**
@ -45,16 +45,16 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
typedef const Pair *const_iterator; typedef const Pair *const_iterator;
/** Creates new SmallMap. Data are initialized in SmallVector constructor */ /** Creates new SmallMap. Data are initialized in SmallVector constructor */
FORCEINLINE SmallMap() { } inline SmallMap() { }
/** Data are freed in SmallVector destructor */ /** Data are freed in SmallVector destructor */
FORCEINLINE ~SmallMap() { } inline ~SmallMap() { }
/** /**
* Finds given key in this map * Finds given key in this map
* @param key key to find * @param key key to find
* @return &Pair(key, data) if found, this->End() if not * @return &Pair(key, data) if found, this->End() if not
*/ */
FORCEINLINE Pair *Find(const T &key) inline Pair *Find(const T &key)
{ {
for (uint i = 0; i < this->items; i++) { for (uint i = 0; i < this->items; i++) {
if (key == this->data[i].first) return &this->data[i]; if (key == this->data[i].first) return &this->data[i];
@ -67,7 +67,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @param key key to test * @param key key to test
* @return true iff the item is present * @return true iff the item is present
*/ */
FORCEINLINE bool Contains(const T &key) inline bool Contains(const T &key)
{ {
return this->Find(key) != this->End(); return this->Find(key) != this->End();
} }
@ -77,7 +77,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @param pair pair to remove * @param pair pair to remove
* @note it has to be pointer to pair in this map. It is overwritten by the last item. * @note it has to be pointer to pair in this map. It is overwritten by the last item.
*/ */
FORCEINLINE void Erase(Pair *pair) inline void Erase(Pair *pair)
{ {
assert(pair >= this->Begin() && pair < this->End()); assert(pair >= this->Begin() && pair < this->End());
*pair = this->data[--this->items]; *pair = this->data[--this->items];
@ -89,7 +89,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @return true iff the key was found * @return true iff the key was found
* @note last item is moved to its place, so don't increase your iterator if true is returned! * @note last item is moved to its place, so don't increase your iterator if true is returned!
*/ */
FORCEINLINE bool Erase(const T &key) inline bool Erase(const T &key)
{ {
for (uint i = 0; i < this->items; i++) { for (uint i = 0; i < this->items; i++) {
if (key == this->data[i].first) { if (key == this->data[i].first) {
@ -106,7 +106,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @param data data * @param data data
* @return true iff the key wasn't already present * @return true iff the key wasn't already present
*/ */
FORCEINLINE bool Insert(const T &key, const U &data) inline bool Insert(const T &key, const U &data)
{ {
if (this->Contains(key)) return false; if (this->Contains(key)) return false;
Pair *n = this->Append(); Pair *n = this->Append();
@ -121,7 +121,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @return data belonging to this key * @return data belonging to this key
* @note if this key wasn't present, new entry is created * @note if this key wasn't present, new entry is created
*/ */
FORCEINLINE U &operator[](const T &key) inline U &operator[](const T &key)
{ {
for (uint i = 0; i < this->items; i++) { for (uint i = 0; i < this->items; i++) {
if (key == this->data[i].first) return this->data[i].second; if (key == this->data[i].first) return this->data[i].second;
@ -131,7 +131,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
return n->second; return n->second;
} }
FORCEINLINE void SortByKey() inline void SortByKey()
{ {
QSortT(this->Begin(), this->items, KeySorter); QSortT(this->Begin(), this->items, KeySorter);
} }

42
src/core/smallvec_type.hpp
View File

@ -65,7 +65,7 @@ public:
/** /**
* Remove all items from the list. * Remove all items from the list.
*/ */
FORCEINLINE void Clear() inline void Clear()
{ {
/* In fact we just reset the item counter avoiding the need to /* In fact we just reset the item counter avoiding the need to
* probably reallocate the same amount of memory the list was * probably reallocate the same amount of memory the list was
@ -76,7 +76,7 @@ public:
/** /**
* Remove all items from the list and free allocated memory. * Remove all items from the list and free allocated memory.
*/ */
FORCEINLINE void Reset() inline void Reset()
{ {
this->items = 0; this->items = 0;
this->capacity = 0; this->capacity = 0;
@ -87,7 +87,7 @@ public:
/** /**
* Compact the list down to the smallest block size boundary. * Compact the list down to the smallest block size boundary.
*/ */
FORCEINLINE void Compact() inline void Compact()
{ {
uint capacity = Align(this->items, S); uint capacity = Align(this->items, S);
if (capacity >= this->capacity) return; if (capacity >= this->capacity) return;
@ -101,7 +101,7 @@ public:
* @param to_add the number of items to append * @param to_add the number of items to append
* @return pointer to newly allocated item * @return pointer to newly allocated item
*/ */
FORCEINLINE T *Append(uint to_add = 1) inline T *Append(uint to_add = 1)
{ {
uint begin = this->items; uint begin = this->items;
this->items += to_add; this->items += to_add;
@ -120,7 +120,7 @@ public:
* @param item Item to search for * @param item Item to search for
* @return The position of the item, or End() when not present * @return The position of the item, or End() when not present
*/ */
FORCEINLINE const T *Find(const T &item) const inline const T *Find(const T &item) const
{ {
const T *pos = this->Begin(); const T *pos = this->Begin();
const T *end = this->End(); const T *end = this->End();
@ -134,7 +134,7 @@ public:
* @param item Item to search for * @param item Item to search for
* @return The position of the item, or End() when not present * @return The position of the item, or End() when not present
*/ */
FORCEINLINE T *Find(const T &item) inline T *Find(const T &item)
{ {
T *pos = this->Begin(); T *pos = this->Begin();
const T *end = this->End(); const T *end = this->End();
@ -148,7 +148,7 @@ public:
* @param item Item to search for * @param item Item to search for
* @return The position of the item, or -1 when not present * @return The position of the item, or -1 when not present
*/ */
FORCEINLINE int FindIndex(const T &item) inline int FindIndex(const T &item)
{ {
int index = 0; int index = 0;
T *pos = this->Begin(); T *pos = this->Begin();
@ -166,7 +166,7 @@ public:
* @param item Item to test for * @param item Item to test for
* @return true iff the item is present * @return true iff the item is present
*/ */
FORCEINLINE bool Contains(const T &item) const inline bool Contains(const T &item) const
{ {
return this->Find(item) != this->End(); return this->Find(item) != this->End();
} }
@ -176,7 +176,7 @@ public:
* @param item item to remove * @param item item to remove
* @note it has to be pointer to item in this map. It is overwritten by the last item. * @note it has to be pointer to item in this map. It is overwritten by the last item.
*/ */
FORCEINLINE void Erase(T *item) inline void Erase(T *item)
{ {
assert(item >= this->Begin() && item < this->End()); assert(item >= this->Begin() && item < this->End());
*item = this->data[--this->items]; *item = this->data[--this->items];
@ -188,7 +188,7 @@ public:
* @param item Item to test for * @param item Item to test for
* @return true iff the item is was already present * @return true iff the item is was already present
*/ */
FORCEINLINE bool Include(const T &item) inline bool Include(const T &item)
{ {
bool is_member = this->Contains(item); bool is_member = this->Contains(item);
if (!is_member) *this->Append() = item; if (!is_member) *this->Append() = item;
@ -198,7 +198,7 @@ public:
/** /**
* Get the number of items in the list. * Get the number of items in the list.
*/ */
FORCEINLINE uint Length() const inline uint Length() const
{ {
return this->items; return this->items;
} }
@ -208,7 +208,7 @@ public:
* *
* @return the pointer to the first item * @return the pointer to the first item
*/ */
FORCEINLINE const T *Begin() const inline const T *Begin() const
{ {
return this->data; return this->data;
} }
@ -218,7 +218,7 @@ public:
* *
* @return the pointer to the first item * @return the pointer to the first item
*/ */
FORCEINLINE T *Begin() inline T *Begin()
{ {
return this->data; return this->data;
} }
@ -228,7 +228,7 @@ public:
* *
* @return the pointer behind the last valid item * @return the pointer behind the last valid item
*/ */
FORCEINLINE const T *End() const inline const T *End() const
{ {
return &this->data[this->items]; return &this->data[this->items];
} }
@ -238,7 +238,7 @@ public:
* *
* @return the pointer behind the last valid item * @return the pointer behind the last valid item
*/ */
FORCEINLINE T *End() inline T *End()
{ {
return &this->data[this->items]; return &this->data[this->items];
} }
@ -249,7 +249,7 @@ public:
* @param index the position of the item * @param index the position of the item
* @return the pointer to the item * @return the pointer to the item
*/ */
FORCEINLINE const T *Get(uint index) const inline const T *Get(uint index) const
{ {
/* Allow access to the 'first invalid' item */ /* Allow access to the 'first invalid' item */
assert(index <= this->items); assert(index <= this->items);
@ -262,7 +262,7 @@ public:
* @param index the position of the item * @param index the position of the item
* @return the pointer to the item * @return the pointer to the item
*/ */
FORCEINLINE T *Get(uint index) inline T *Get(uint index)
{ {
/* Allow access to the 'first invalid' item */ /* Allow access to the 'first invalid' item */
assert(index <= this->items); assert(index <= this->items);
@ -275,7 +275,7 @@ public:
* @param index the position of the item * @param index the position of the item
* @return the item * @return the item
*/ */
FORCEINLINE const T &operator[](uint index) const inline const T &operator[](uint index) const
{ {
assert(index < this->items); assert(index < this->items);
return this->data[index]; return this->data[index];
@ -287,7 +287,7 @@ public:
* @param index the position of the item * @param index the position of the item
* @return the item * @return the item
*/ */
FORCEINLINE T &operator[](uint index) inline T &operator[](uint index)
{ {
assert(index < this->items); assert(index < this->items);
return this->data[index]; return this->data[index];
@ -316,7 +316,7 @@ public:
/** /**
* Remove all items from the list. * Remove all items from the list.
*/ */
FORCEINLINE void Clear() inline void Clear()
{ {
for (uint i = 0; i < this->items; i++) { for (uint i = 0; i < this->items; i++) {
free(this->data[i]); free(this->data[i]);
@ -347,7 +347,7 @@ public:
/** /**
* Remove all items from the list. * Remove all items from the list.
*/ */
FORCEINLINE void Clear() inline void Clear()
{ {
for (uint i = 0; i < this->items; i++) { for (uint i = 0; i < this->items; i++) {
delete this->data[i]; delete this->data[i];

2
src/core/sort_func.hpp
View File

@ -25,7 +25,7 @@
* @param desc Sort descending. * @param desc Sort descending.
*/ */
template <typename T> template <typename T>
static FORCEINLINE void QSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false) static inline void QSortT(T *base, uint num, int (CDECL *comparator)(const T*, const T*), bool desc = false)
{ {
if (num < 2) return; if (num < 2) return;

4
src/depot_base.h
View File

@ -29,7 +29,7 @@ struct Depot : DepotPool::PoolItem<&_depot_pool> {
Depot(TileIndex xy = INVALID_TILE) : xy(xy) {} Depot(TileIndex xy = INVALID_TILE) : xy(xy) {}
~Depot(); ~Depot();
static FORCEINLINE Depot *GetByTile(TileIndex tile) static inline Depot *GetByTile(TileIndex tile)
{ {
return Depot::Get(GetDepotIndex(tile)); return Depot::Get(GetDepotIndex(tile));
} }
@ -40,7 +40,7 @@ struct Depot : DepotPool::PoolItem<&_depot_pool> {
* @param d The depot to compare to. * @param d The depot to compare to.
* @return true iff their types are equal. * @return true iff their types are equal.
*/ */
FORCEINLINE bool IsOfType(const Depot *d) const inline bool IsOfType(const Depot *d) const
{ {
return GetTileType(d->xy) == GetTileType(this->xy); return GetTileType(d->xy) == GetTileType(this->xy);
} }

2
src/engine_base.h
View File

@ -116,7 +116,7 @@ struct Engine : EnginePool::PoolItem<&_engine_pool> {
* Check if the engine is a ground vehicle. * Check if the engine is a ground vehicle.
* @return True iff the engine is a train or a road vehicle. * @return True iff the engine is a train or a road vehicle.
*/ */
FORCEINLINE bool IsGroundVehicle() const inline bool IsGroundVehicle() const
{ {
return this->type == VEH_TRAIN || this->type == VEH_ROAD; return this->type == VEH_TRAIN || this->type == VEH_ROAD;
} }

6
src/gfx.cpp
View File

@ -69,7 +69,7 @@ struct DrawStringParams {
* Switch to new colour \a c. * Switch to new colour \a c.
* @param c New colour to use. * @param c New colour to use.
*/ */
FORCEINLINE void SetColour(TextColour c) inline void SetColour(TextColour c)
{ {
assert(c >= TC_BLUE && c <= TC_BLACK); assert(c >= TC_BLUE && c <= TC_BLACK);
this->prev_colour = this->cur_colour; this->prev_colour = this->cur_colour;
@ -77,7 +77,7 @@ struct DrawStringParams {
} }
/** Switch to previous colour. */ /** Switch to previous colour. */
FORCEINLINE void SetPreviousColour() inline void SetPreviousColour()
{ {
Swap(this->cur_colour, this->prev_colour); Swap(this->cur_colour, this->prev_colour);
} }
@ -86,7 +86,7 @@ struct DrawStringParams {
* Switch to using a new font \a f. * Switch to using a new font \a f.
* @param f New font to use. * @param f New font to use.
*/ */
FORCEINLINE void SetFontSize(FontSize f) inline void SetFontSize(FontSize f)
{ {
this->fontsize = f; this->fontsize = f;
} }

4
src/goal_base.h
View File

@ -30,12 +30,12 @@ struct Goal : GoalPool::PoolItem<&_goal_pool> {
/** /**
* We need an (empty) constructor so struct isn't zeroed (as C++ standard states) * We need an (empty) constructor so struct isn't zeroed (as C++ standard states)
*/ */
FORCEINLINE Goal() { } inline Goal() { }
/** /**
* (Empty) destructor has to be defined else operator delete might be called with NULL parameter * (Empty) destructor has to be defined else operator delete might be called with NULL parameter
*/ */
FORCEINLINE ~Goal() { free(this->text); } inline ~Goal() { free(this->text); }
}; };
#define FOR_ALL_GOALS_FROM(var, start) FOR_ALL_ITEMS_FROM(Goal, goal_index, var, start) #define FOR_ALL_GOALS_FROM(var, start) FOR_ALL_ITEMS_FROM(Goal, goal_index, var, start)

46
src/ground_vehicle.hpp
View File

@ -111,7 +111,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
* Calculates the total slope resistance for this vehicle. * Calculates the total slope resistance for this vehicle.
* @return Slope resistance. * @return Slope resistance.
*/ */
FORCEINLINE int32 GetSlopeResistance() const inline int32 GetSlopeResistance() const
{ {
int32 incl = 0; int32 incl = 0;
@ -132,7 +132,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
* @pre The vehicle has to be at (or near to) a border of the tile, * @pre The vehicle has to be at (or near to) a border of the tile,
* directed towards tile centre * directed towards tile centre
*/ */
FORCEINLINE void UpdateZPositionAndInclination() inline void UpdateZPositionAndInclination()
{ {
this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos); this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos);
ClrBit(this->gv_flags, GVF_GOINGUP_BIT); ClrBit(this->gv_flags, GVF_GOINGUP_BIT);
@ -157,7 +157,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
* The faster code is used for trains and road vehicles unless they are * The faster code is used for trains and road vehicles unless they are
* reversing on a sloped tile. * reversing on a sloped tile.
*/ */
FORCEINLINE void UpdateZPosition() inline void UpdateZPosition()
{ {
#if 0 #if 0
/* The following code does this: */ /* The following code does this: */
@ -229,7 +229,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
* @param turned Indicates if the vehicle has turned. * @param turned Indicates if the vehicle has turned.
* @return Old height of the vehicle. * @return Old height of the vehicle.
*/ */
FORCEINLINE byte UpdateInclination(bool new_tile, bool turned) inline byte UpdateInclination(bool new_tile, bool turned)
{ {
byte old_z = this->z_pos; byte old_z = this->z_pos;
@ -246,99 +246,99 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
/** /**
* Set front engine state. * Set front engine state.
*/ */
FORCEINLINE void SetFrontEngine() { SetBit(this->subtype, GVSF_FRONT); } inline void SetFrontEngine() { SetBit(this->subtype, GVSF_FRONT); }
/** /**
* Remove the front engine state. * Remove the front engine state.
*/ */
FORCEINLINE void ClearFrontEngine() { ClrBit(this->subtype, GVSF_FRONT); } inline void ClearFrontEngine() { ClrBit(this->subtype, GVSF_FRONT); }
/** /**
* Set a vehicle to be an articulated part. * Set a vehicle to be an articulated part.
*/ */
FORCEINLINE void SetArticulatedPart() { SetBit(this->subtype, GVSF_ARTICULATED_PART); } inline void SetArticulatedPart() { SetBit(this->subtype, GVSF_ARTICULATED_PART); }
/** /**
* Clear a vehicle from being an articulated part. * Clear a vehicle from being an articulated part.
*/ */
FORCEINLINE void ClearArticulatedPart() { ClrBit(this->subtype, GVSF_ARTICULATED_PART); } inline void ClearArticulatedPart() { ClrBit(this->subtype, GVSF_ARTICULATED_PART); }
/** /**
* Set a vehicle to be a wagon. * Set a vehicle to be a wagon.
*/ */
FORCEINLINE void SetWagon() { SetBit(this->subtype, GVSF_WAGON); } inline void SetWagon() { SetBit(this->subtype, GVSF_WAGON); }
/** /**
* Clear wagon property. * Clear wagon property.
*/ */
FORCEINLINE void ClearWagon() { ClrBit(this->subtype, GVSF_WAGON); } inline void ClearWagon() { ClrBit(this->subtype, GVSF_WAGON); }
/** /**
* Set engine status. * Set engine status.
*/ */
FORCEINLINE void SetEngine() { SetBit(this->subtype, GVSF_ENGINE); } inline void SetEngine() { SetBit(this->subtype, GVSF_ENGINE); }
/** /**
* Clear engine status. * Clear engine status.
*/ */
FORCEINLINE void ClearEngine() { ClrBit(this->subtype, GVSF_ENGINE); } inline void ClearEngine() { ClrBit(this->subtype, GVSF_ENGINE); }
/** /**
* Set a vehicle as a free wagon. * Set a vehicle as a free wagon.
*/ */
FORCEINLINE void SetFreeWagon() { SetBit(this->subtype, GVSF_FREE_WAGON); } inline void SetFreeWagon() { SetBit(this->subtype, GVSF_FREE_WAGON); }
/** /**
* Clear a vehicle from being a free wagon. * Clear a vehicle from being a free wagon.
*/ */
FORCEINLINE void ClearFreeWagon() { ClrBit(this->subtype, GVSF_FREE_WAGON); } inline void ClearFreeWagon() { ClrBit(this->subtype, GVSF_FREE_WAGON); }
/** /**
* Set a vehicle as a multiheaded engine. * Set a vehicle as a multiheaded engine.
*/ */
FORCEINLINE void SetMultiheaded() { SetBit(this->subtype, GVSF_MULTIHEADED); } inline void SetMultiheaded() { SetBit(this->subtype, GVSF_MULTIHEADED); }
/** /**
* Clear multiheaded engine property. * Clear multiheaded engine property.
*/ */
FORCEINLINE void ClearMultiheaded() { ClrBit(this->subtype, GVSF_MULTIHEADED); } inline void ClearMultiheaded() { ClrBit(this->subtype, GVSF_MULTIHEADED); }
/** /**
* Check if the vehicle is a free wagon (got no engine in front of it). * Check if the vehicle is a free wagon (got no engine in front of it).
* @return Returns true if the vehicle is a free wagon. * @return Returns true if the vehicle is a free wagon.
*/ */
FORCEINLINE bool IsFreeWagon() const { return HasBit(this->subtype, GVSF_FREE_WAGON); } inline bool IsFreeWagon() const { return HasBit(this->subtype, GVSF_FREE_WAGON); }
/** /**
* Check if a vehicle is an engine (can be first in a consist). * Check if a vehicle is an engine (can be first in a consist).
* @return Returns true if vehicle is an engine. * @return Returns true if vehicle is an engine.
*/ */
FORCEINLINE bool IsEngine() const { return HasBit(this->subtype, GVSF_ENGINE); } inline bool IsEngine() const { return HasBit(this->subtype, GVSF_ENGINE); }
/** /**
* Check if a vehicle is a wagon. * Check if a vehicle is a wagon.
* @return Returns true if vehicle is a wagon. * @return Returns true if vehicle is a wagon.
*/ */
FORCEINLINE bool IsWagon() const { return HasBit(this->subtype, GVSF_WAGON); } inline bool IsWagon() const { return HasBit(this->subtype, GVSF_WAGON); }
/** /**
* Check if the vehicle is a multiheaded engine. * Check if the vehicle is a multiheaded engine.
* @return Returns true if the vehicle is a multiheaded engine. * @return Returns true if the vehicle is a multiheaded engine.
*/ */
FORCEINLINE bool IsMultiheaded() const { return HasBit(this->subtype, GVSF_MULTIHEADED); } inline bool IsMultiheaded() const { return HasBit(this->subtype, GVSF_MULTIHEADED); }
/** /**
* Tell if we are dealing with the rear end of a multiheaded engine. * Tell if we are dealing with the rear end of a multiheaded engine.
* @return True if the engine is the rear part of a dualheaded engine. * @return True if the engine is the rear part of a dualheaded engine.
*/ */
FORCEINLINE bool IsRearDualheaded() const { return this->IsMultiheaded() && !this->IsEngine(); } inline bool IsRearDualheaded() const { return this->IsMultiheaded() && !this->IsEngine(); }
/** /**
* Update the GUI variant of the current speed of the vehicle. * Update the GUI variant of the current speed of the vehicle.
* Also mark the widget dirty when that is needed, i.e. when * Also mark the widget dirty when that is needed, i.e. when
* the speed of this vehicle has changed. * the speed of this vehicle has changed.
*/ */
FORCEINLINE void SetLastSpeed() inline void SetLastSpeed()
{ {
if (this->cur_speed != this->gcache.last_speed) { if (this->cur_speed != this->gcache.last_speed) {
SetWindowWidgetDirty(WC_VEHICLE_VIEW, this->index, WID_VV_START_STOP); SetWindowWidgetDirty(WC_VEHICLE_VIEW, this->index, WID_VV_START_STOP);
@ -360,7 +360,7 @@ protected:
* @param max_speed The maximum speed here, in vehicle specific units. * @param max_speed The maximum speed here, in vehicle specific units.
* @return Distance to drive. * @return Distance to drive.
*/ */
FORCEINLINE uint DoUpdateSpeed(uint accel, int min_speed, int max_speed) inline uint DoUpdateSpeed(uint accel, int min_speed, int max_speed)
{ {
uint spd = this->subspeed + accel; uint spd = this->subspeed + accel;
this->subspeed = (byte)spd; this->subspeed = (byte)spd;

2
src/house.h
View File

@ -124,7 +124,7 @@ struct HouseSpec {
Money GetRemovalCost() const; Money GetRemovalCost() const;
static FORCEINLINE HouseSpec *Get(size_t house_id) static inline HouseSpec *Get(size_t house_id)
{ {
assert(house_id < HOUSE_MAX); assert(house_id < HOUSE_MAX);
extern HouseSpec _house_specs[]; extern HouseSpec _house_specs[];

2
src/industry.h
View File

@ -93,7 +93,7 @@ struct Industry : IndustryPool::PoolItem<&_industry_pool> {
* @pre IsTileType(t, MP_INDUSTRY) * @pre IsTileType(t, MP_INDUSTRY)
* @return the industry * @return the industry
*/ */
static FORCEINLINE Industry *GetByTile(TileIndex tile) static inline Industry *GetByTile(TileIndex tile)
{ {
return Industry::Get(GetIndustryIndex(tile)); return Industry::Get(GetIndustryIndex(tile));
} }

20
src/misc/array.hpp
View File

@ -30,7 +30,7 @@ protected:
SuperArray data; ///< array of arrays of items SuperArray data; ///< array of arrays of items
/** return first sub-array with free space for new item */ /** return first sub-array with free space for new item */
FORCEINLINE SubArray& FirstFreeSubArray() inline SubArray& FirstFreeSubArray()
{ {
uint super_size = data.Length(); uint super_size = data.Length();
if (super_size > 0) { if (super_size > 0) {
@ -42,11 +42,11 @@ protected:
public: public:
/** implicit constructor */ /** implicit constructor */
FORCEINLINE SmallArray() { } inline SmallArray() { }
/** Clear (destroy) all items */ /** Clear (destroy) all items */
FORCEINLINE void Clear() {data.Clear();} inline void Clear() {data.Clear();}
/** Return actual number of items */ /** Return actual number of items */
FORCEINLINE uint Length() const inline uint Length() const
{ {
uint super_size = data.Length(); uint super_size = data.Length();
if (super_size == 0) return 0; if (super_size == 0) return 0;
@ -54,22 +54,22 @@ public:
return (super_size - 1) * B + sub_size; return (super_size - 1) * B + sub_size;
} }
/** return true if array is empty */ /** return true if array is empty */
FORCEINLINE bool IsEmpty() { return data.IsEmpty(); } inline bool IsEmpty() { return data.IsEmpty(); }
/** return true if array is full */ /** return true if array is full */
FORCEINLINE bool IsFull() { return data.IsFull() && data[N - 1].IsFull(); } inline bool IsFull() { return data.IsFull() && data[N - 1].IsFull(); }
/** allocate but not construct new item */ /** allocate but not construct new item */
FORCEINLINE T *Append() { return FirstFreeSubArray().Append(); } inline T *Append() { return FirstFreeSubArray().Append(); }
/** allocate and construct new item */ /** allocate and construct new item */
FORCEINLINE T *AppendC() { return FirstFreeSubArray().AppendC(); } inline T *AppendC() { return FirstFreeSubArray().AppendC(); }
/** indexed access (non-const) */ /** indexed access (non-const) */
FORCEINLINE T& operator [] (uint index) inline T& operator [] (uint index)
{ {
const SubArray& s = data[index / B]; const SubArray& s = data[index / B];
T& item = s[index % B]; T& item = s[index % B];
return item; return item;
} }
/** indexed access (const) */ /** indexed access (const) */
FORCEINLINE const T& operator [] (uint index) const inline const T& operator [] (uint index) const
{ {
const SubArray& s = data[index / B]; const SubArray& s = data[index / B];
const T& item = s[index % B]; const T& item = s[index % B];

26
src/misc/binaryheap.hpp
View File

@ -85,7 +85,7 @@ protected:
* @param item The proposed item for filling the gap * @param item The proposed item for filling the gap
* @return The (gap)position where the item fits * @return The (gap)position where the item fits
*/ */
FORCEINLINE uint HeapifyDown(uint gap, T *item) inline uint HeapifyDown(uint gap, T *item)
{ {
assert(gap != 0); assert(gap != 0);
@ -121,7 +121,7 @@ protected:
* @param item The proposed item for filling the gap * @param item The proposed item for filling the gap
* @return The (gap)position where the item fits * @return The (gap)position where the item fits
*/ */
FORCEINLINE uint HeapifyUp(uint gap, T *item) inline uint HeapifyUp(uint gap, T *item)
{ {
assert(gap != 0); assert(gap != 0);
@ -142,7 +142,7 @@ protected:
#if BINARYHEAP_CHECK #if BINARYHEAP_CHECK
/** Verify the heap consistency */ /** Verify the heap consistency */
FORCEINLINE void CheckConsistency() inline void CheckConsistency()
{ {
for (uint child = 2; child <= this->items; child++) { for (uint child = 2; child <= this->items; child++) {
uint parent = child / 2; uint parent = child / 2;
@ -157,28 +157,28 @@ public:
* *
* @return The number of items in the queue * @return The number of items in the queue
*/ */
FORCEINLINE uint Length() const { return this->items; } inline uint Length() const { return this->items; }
/** /**
* Test if the priority queue is empty. * Test if the priority queue is empty.
* *
* @return True if empty * @return True if empty
*/ */
FORCEINLINE bool IsEmpty() const { return this->items == 0; } inline bool IsEmpty() const { return this->items == 0; }
/** /**
* Test if the priority queue is full. * Test if the priority queue is full.
* *
* @return True if full. * @return True if full.
*/ */
FORCEINLINE bool IsFull() const { return this->items >= this->capacity; } inline bool IsFull() const { return this->items >= this->capacity; }
/** /**
* Get the smallest item in the binary tree. * Get the smallest item in the binary tree.
* *
* @return The smallest item, or throw assert if empty. * @return The smallest item, or throw assert if empty.
*/ */
FORCEINLINE T *Begin() inline T *Begin()
{ {
assert(!this->IsEmpty()); assert(!this->IsEmpty());
return this->data[1]; return this->data[1];
@ -191,7 +191,7 @@ public:
* *
* @return The last item * @return The last item
*/ */
FORCEINLINE T *End() inline T *End()
{ {
return this->data[1 + this->items]; return this->data[1 + this->items];
} }
@ -201,7 +201,7 @@ public:
* *
* @param new_item The pointer to the new item * @param new_item The pointer to the new item
*/ */
FORCEINLINE void Include(T *new_item) inline void Include(T *new_item)
{ {
if (this->IsFull()) { if (this->IsFull()) {
assert(this->capacity < UINT_MAX / 2); assert(this->capacity < UINT_MAX / 2);
@ -222,7 +222,7 @@ public:
* *
* @return The pointer to the removed item * @return The pointer to the removed item
*/ */
FORCEINLINE T *Shift() inline T *Shift()
{ {
assert(!this->IsEmpty()); assert(!this->IsEmpty());
@ -244,7 +244,7 @@ public:
* *
* @param index The position of the item in the heap * @param index The position of the item in the heap
*/ */
FORCEINLINE void Remove(uint index) inline void Remove(uint index)
{ {
if (index < this->items) { if (index < this->items) {
assert(index != 0); assert(index != 0);
@ -272,7 +272,7 @@ public:
* @param item The reference to the item * @param item The reference to the item
* @return The index of the item or zero if not found * @return The index of the item or zero if not found
*/ */
FORCEINLINE uint FindIndex(const T &item) const inline uint FindIndex(const T &item) const
{ {
if (this->IsEmpty()) return 0; if (this->IsEmpty()) return 0;
for (T **ppI = this->data + 1, **ppLast = ppI + this->items; ppI <= ppLast; ppI++) { for (T **ppI = this->data + 1, **ppLast = ppI + this->items; ppI <= ppLast; ppI++) {
@ -287,7 +287,7 @@ public:
* Make the priority queue empty. * Make the priority queue empty.
* All remaining items will remain untouched. * All remaining items will remain untouched.
*/ */
FORCEINLINE void Clear() { this->items = 0; } inline void Clear() { this->items = 0; }
}; };
#endif /* BINARYHEAP_HPP */ #endif /* BINARYHEAP_HPP */

78
src/misc/blob.hpp
View File

@ -71,17 +71,17 @@ public:
static const size_t header_size = sizeof(BlobHeader); static const size_t header_size = sizeof(BlobHeader);
/** default constructor - initializes empty blob */ /** default constructor - initializes empty blob */
FORCEINLINE ByteBlob() { InitEmpty(); } inline ByteBlob() { InitEmpty(); }
/** copy constructor */ /** copy constructor */
FORCEINLINE ByteBlob(const ByteBlob &src) inline ByteBlob(const ByteBlob &src)
{ {
InitEmpty(); InitEmpty();
AppendRaw(src); AppendRaw(src);
} }
/** move constructor - take ownership of blob data */ /** move constructor - take ownership of blob data */
FORCEINLINE ByteBlob(BlobHeader * const & src) inline ByteBlob(BlobHeader * const & src)
{ {
assert(src != NULL); assert(src != NULL);
header = src; header = src;
@ -89,14 +89,14 @@ public:
} }
/** destructor */ /** destructor */
FORCEINLINE ~ByteBlob() inline ~ByteBlob()
{ {
Free(); Free();
} }
protected: protected:
/** all allocation should happen here */ /** all allocation should happen here */
static FORCEINLINE BlobHeader *RawAlloc(size_t num_bytes) static inline BlobHeader *RawAlloc(size_t num_bytes)
{ {
return (BlobHeader*)MallocT<byte>(num_bytes); return (BlobHeader*)MallocT<byte>(num_bytes);
} }
@ -105,13 +105,13 @@ protected:
* Return header pointer to the static BlobHeader with * Return header pointer to the static BlobHeader with
* both items and capacity containing zero * both items and capacity containing zero
*/ */
static FORCEINLINE BlobHeader *Zero() static inline BlobHeader *Zero()
{ {
return const_cast<BlobHeader *>(&ByteBlob::hdrEmpty[1]); return const_cast<BlobHeader *>(&ByteBlob::hdrEmpty[1]);
} }
/** simple allocation policy - can be optimized later */ /** simple allocation policy - can be optimized later */
static FORCEINLINE size_t AllocPolicy(size_t min_alloc) static inline size_t AllocPolicy(size_t min_alloc)
{ {
if (min_alloc < (1 << 9)) { if (min_alloc < (1 << 9)) {
if (min_alloc < (1 << 5)) return (1 << 5); if (min_alloc < (1 << 5)) return (1 << 5);
@ -130,7 +130,7 @@ protected:
} }
/** all deallocations should happen here */ /** all deallocations should happen here */
static FORCEINLINE void RawFree(BlobHeader *p) static inline void RawFree(BlobHeader *p)
{ {
/* Just to silence an unsilencable GCC 4.4+ warning. */ /* Just to silence an unsilencable GCC 4.4+ warning. */
assert(p != ByteBlob::hdrEmpty); assert(p != ByteBlob::hdrEmpty);
@ -140,74 +140,74 @@ protected:
} }
/** initialize the empty blob */ /** initialize the empty blob */
FORCEINLINE void InitEmpty() inline void InitEmpty()
{ {
header = Zero(); header = Zero();
} }
/** initialize blob by attaching it to the given header followed by data */ /** initialize blob by attaching it to the given header followed by data */
FORCEINLINE void Init(BlobHeader *src) inline void Init(BlobHeader *src)
{ {
header = &src[1]; header = &src[1];
} }
/** blob header accessor - use it rather than using the pointer arithmetics directly - non-const version */ /** blob header accessor - use it rather than using the pointer arithmetics directly - non-const version */
FORCEINLINE BlobHeader& Hdr() inline BlobHeader& Hdr()
{ {
return *(header - 1); return *(header - 1);
} }
/** blob header accessor - use it rather than using the pointer arithmetics directly - const version */ /** blob header accessor - use it rather than using the pointer arithmetics directly - const version */
FORCEINLINE const BlobHeader& Hdr() const inline const BlobHeader& Hdr() const
{ {
return *(header - 1); return *(header - 1);
} }
/** return reference to the actual blob size - used when the size needs to be modified */ /** return reference to the actual blob size - used when the size needs to be modified */
FORCEINLINE size_t& LengthRef() inline size_t& LengthRef()
{ {
return Hdr().items; return Hdr().items;
} }
public: public:
/** return true if blob doesn't contain valid data */ /** return true if blob doesn't contain valid data */
FORCEINLINE bool IsEmpty() const inline bool IsEmpty() const
{ {
return Length() == 0; return Length() == 0;
} }
/** return the number of valid data bytes in the blob */ /** return the number of valid data bytes in the blob */
FORCEINLINE size_t Length() const inline size_t Length() const
{ {
return Hdr().items; return Hdr().items;
} }
/** return the current blob capacity in bytes */ /** return the current blob capacity in bytes */
FORCEINLINE size_t Capacity() const inline size_t Capacity() const
{ {
return Hdr().capacity; return Hdr().capacity;
} }
/** return pointer to the first byte of data - non-const version */ /** return pointer to the first byte of data - non-const version */
FORCEINLINE byte *Begin() inline byte *Begin()
{ {
return data; return data;
} }
/** return pointer to the first byte of data - const version */ /** return pointer to the first byte of data - const version */
FORCEINLINE const byte *Begin() const inline const byte *Begin() const
{ {
return data; return data;
} }
/** invalidate blob's data - doesn't free buffer */ /** invalidate blob's data - doesn't free buffer */
FORCEINLINE void Clear() inline void Clear()
{ {
LengthRef() = 0; LengthRef() = 0;
} }
/** free the blob's memory */ /** free the blob's memory */
FORCEINLINE void Free() inline void Free()
{ {
if (Capacity() > 0) { if (Capacity() > 0) {
RawFree(&Hdr()); RawFree(&Hdr());
@ -216,7 +216,7 @@ public:
} }
/** append new bytes at the end of existing data bytes - reallocates if necessary */ /** append new bytes at the end of existing data bytes - reallocates if necessary */
FORCEINLINE void AppendRaw(const void *p, size_t num_bytes) inline void AppendRaw(const void *p, size_t num_bytes)
{ {
assert(p != NULL); assert(p != NULL);
if (num_bytes > 0) { if (num_bytes > 0) {
@ -225,7 +225,7 @@ public:
} }
/** append bytes from given source blob to the end of existing data bytes - reallocates if necessary */ /** append bytes from given source blob to the end of existing data bytes - reallocates if necessary */
FORCEINLINE void AppendRaw(const ByteBlob& src) inline void AppendRaw(const ByteBlob& src)
{ {
if (!src.IsEmpty()) { if (!src.IsEmpty()) {
memcpy(Append(src.Length()), src.Begin(), src.Length()); memcpy(Append(src.Length()), src.Begin(), src.Length());
@ -236,7 +236,7 @@ public:
* Reallocate if there is no free space for num_bytes bytes. * Reallocate if there is no free space for num_bytes bytes.
* @return pointer to the new data to be added * @return pointer to the new data to be added
*/ */
FORCEINLINE byte *Prepare(size_t num_bytes) inline byte *Prepare(size_t num_bytes)
{ {
size_t new_size = Length() + num_bytes; size_t new_size = Length() + num_bytes;
if (new_size > Capacity()) SmartAlloc(new_size); if (new_size > Capacity()) SmartAlloc(new_size);
@ -247,7 +247,7 @@ public:
* Increase Length() by num_bytes. * Increase Length() by num_bytes.
* @return pointer to the new data added * @return pointer to the new data added
*/ */
FORCEINLINE byte *Append(size_t num_bytes) inline byte *Append(size_t num_bytes)
{ {
byte *pNewData = Prepare(num_bytes); byte *pNewData = Prepare(num_bytes);
LengthRef() += num_bytes; LengthRef() += num_bytes;
@ -281,7 +281,7 @@ public:
} }
/** fixing the four bytes at the end of blob data - useful when blob is used to hold string */ /** fixing the four bytes at the end of blob data - useful when blob is used to hold string */
FORCEINLINE void FixTail() const inline void FixTail() const
{ {
if (Capacity() > 0) { if (Capacity() > 0) {
byte *p = &data[Length()]; byte *p = &data[Length()];
@ -317,73 +317,73 @@ public:
}; };
/** Default constructor - makes new Blob ready to accept any data */ /** Default constructor - makes new Blob ready to accept any data */
FORCEINLINE CBlobT() inline CBlobT()
: base() : base()
{} {}
/** Take ownership constructor */ /** Take ownership constructor */
FORCEINLINE CBlobT(const OnTransfer& ot) inline CBlobT(const OnTransfer& ot)
: base(ot.header) : base(ot.header)
{} {}
/** Destructor - ensures that allocated memory (if any) is freed */ /** Destructor - ensures that allocated memory (if any) is freed */
FORCEINLINE ~CBlobT() inline ~CBlobT()
{ {
Free(); Free();
} }
/** Check the validity of item index (only in debug mode) */ /** Check the validity of item index (only in debug mode) */
FORCEINLINE void CheckIdx(size_t index) const inline void CheckIdx(size_t index) const
{ {
assert(index < Size()); assert(index < Size());
} }
/** Return pointer to the first data item - non-const version */ /** Return pointer to the first data item - non-const version */
FORCEINLINE T *Data() inline T *Data()
{ {
return (T*)base::Begin(); return (T*)base::Begin();
} }
/** Return pointer to the first data item - const version */ /** Return pointer to the first data item - const version */
FORCEINLINE const T *Data() const inline const T *Data() const
{ {
return (const T*)base::Begin(); return (const T*)base::Begin();
} }
/** Return pointer to the index-th data item - non-const version */ /** Return pointer to the index-th data item - non-const version */
FORCEINLINE T *Data(size_t index) inline T *Data(size_t index)
{ {
CheckIdx(index); CheckIdx(index);
return (Data() + index); return (Data() + index);
} }
/** Return pointer to the index-th data item - const version */ /** Return pointer to the index-th data item - const version */
FORCEINLINE const T *Data(size_t index) const inline const T *Data(size_t index) const
{ {
CheckIdx(index); CheckIdx(index);
return (Data() + index); return (Data() + index);
} }
/** Return number of items in the Blob */ /** Return number of items in the Blob */
FORCEINLINE size_t Size() const inline size_t Size() const
{ {
return (base::Length() / type_size); return (base::Length() / type_size);
} }
/** Return total number of items that can fit in the Blob without buffer reallocation */ /** Return total number of items that can fit in the Blob without buffer reallocation */
FORCEINLINE size_t MaxSize() const inline size_t MaxSize() const
{ {
return (base::Capacity() / type_size); return (base::Capacity() / type_size);
} }
/** Return number of additional items that can fit in the Blob without buffer reallocation */ /** Return number of additional items that can fit in the Blob without buffer reallocation */
FORCEINLINE size_t GetReserve() const inline size_t GetReserve() const
{ {
return ((base::Capacity() - base::Length()) / type_size); return ((base::Capacity() - base::Length()) / type_size);
} }
/** Grow number of data items in Blob by given number - doesn't construct items */ /** Grow number of data items in Blob by given number - doesn't construct items */
FORCEINLINE T *GrowSizeNC(size_t num_items) inline T *GrowSizeNC(size_t num_items)
{ {
return (T*)base::Append(num_items * type_size); return (T*)base::Append(num_items * type_size);
} }
@ -392,12 +392,12 @@ public:
* Ensures that given number of items can be added to the end of Blob. Returns pointer to the * Ensures that given number of items can be added to the end of Blob. Returns pointer to the
* first free (unused) item * first free (unused) item
*/ */
FORCEINLINE T *MakeFreeSpace(size_t num_items) inline T *MakeFreeSpace(size_t num_items)
{ {
return (T*)base::Prepare(num_items * type_size); return (T*)base::Prepare(num_items * type_size);
} }
FORCEINLINE OnTransfer Transfer() inline OnTransfer Transfer()
{ {
return OnTransfer(*this); return OnTransfer(*this);
} }

38
src/misc/countedptr.hpp
View File

@ -35,64 +35,64 @@ protected:
public: public:
/** default (NULL) construct or construct from a raw pointer */ /** default (NULL) construct or construct from a raw pointer */
FORCEINLINE CCountedPtr(Tcls *pObj = NULL) : m_pT(pObj) {AddRef();} inline CCountedPtr(Tcls *pObj = NULL) : m_pT(pObj) {AddRef();}
/** copy constructor (invoked also when initializing from another smart ptr) */ /** copy constructor (invoked also when initializing from another smart ptr) */
FORCEINLINE CCountedPtr(const CCountedPtr& src) : m_pT(src.m_pT) {AddRef();} inline CCountedPtr(const CCountedPtr& src) : m_pT(src.m_pT) {AddRef();}
/** destructor releasing the reference */ /** destructor releasing the reference */
FORCEINLINE ~CCountedPtr() {Release();} inline ~CCountedPtr() {Release();}
protected: protected:
/** add one ref to the underlaying object */ /** add one ref to the underlaying object */
FORCEINLINE void AddRef() {if (m_pT != NULL) m_pT->AddRef();} inline void AddRef() {if (m_pT != NULL) m_pT->AddRef();}
public: public:
/** release smart pointer (and decrement ref count) if not null */ /** release smart pointer (and decrement ref count) if not null */
FORCEINLINE void Release() {if (m_pT != NULL) {Tcls *pT = m_pT; m_pT = NULL; pT->Release();}} inline void Release() {if (m_pT != NULL) {Tcls *pT = m_pT; m_pT = NULL; pT->Release();}}
/** dereference of smart pointer - const way */ /** dereference of smart pointer - const way */
FORCEINLINE const Tcls *operator -> () const {assert(m_pT != NULL); return m_pT;} inline const Tcls *operator -> () const {assert(m_pT != NULL); return m_pT;}
/** dereference of smart pointer - non const way */ /** dereference of smart pointer - non const way */
FORCEINLINE Tcls *operator -> () {assert(m_pT != NULL); return m_pT;} inline Tcls *operator -> () {assert(m_pT != NULL); return m_pT;}
/** raw pointer casting operator - const way */ /** raw pointer casting operator - const way */
FORCEINLINE operator const Tcls*() const {assert(m_pT == NULL); return m_pT;} inline operator const Tcls*() const {assert(m_pT == NULL); return m_pT;}
/** raw pointer casting operator - non-const way */ /** raw pointer casting operator - non-const way */
FORCEINLINE operator Tcls*() {return m_pT;} inline operator Tcls*() {return m_pT;}
/** operator & to support output arguments */ /** operator & to support output arguments */
FORCEINLINE Tcls** operator &() {assert(m_pT == NULL); return &m_pT;} inline Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}
/** assignment operator from raw ptr */ /** assignment operator from raw ptr */
FORCEINLINE CCountedPtr& operator = (Tcls *pT) {Assign(pT); return *this;} inline CCountedPtr& operator = (Tcls *pT) {Assign(pT); return *this;}
/** assignment operator from another smart ptr */ /** assignment operator from another smart ptr */
FORCEINLINE CCountedPtr& operator = (const CCountedPtr& src) {Assign(src.m_pT); return *this;} inline CCountedPtr& operator = (const CCountedPtr& src) {Assign(src.m_pT); return *this;}
/** assignment operator helper */ /** assignment operator helper */
FORCEINLINE void Assign(Tcls *pT); inline void Assign(Tcls *pT);
/** one way how to test for NULL value */ /** one way how to test for NULL value */
FORCEINLINE bool IsNull() const {return m_pT == NULL;} inline bool IsNull() const {return m_pT == NULL;}
/** another way how to test for NULL value */ /** another way how to test for NULL value */
//FORCEINLINE bool operator == (const CCountedPtr& sp) const {return m_pT == sp.m_pT;} //inline bool operator == (const CCountedPtr& sp) const {return m_pT == sp.m_pT;}
/** yet another way how to test for NULL value */ /** yet another way how to test for NULL value */
//FORCEINLINE bool operator != (const CCountedPtr& sp) const {return m_pT != sp.m_pT;} //inline bool operator != (const CCountedPtr& sp) const {return m_pT != sp.m_pT;}
/** assign pointer w/o incrementing ref count */ /** assign pointer w/o incrementing ref count */
FORCEINLINE void Attach(Tcls *pT) {Release(); m_pT = pT;} inline void Attach(Tcls *pT) {Release(); m_pT = pT;}
/** detach pointer w/o decrementing ref count */ /** detach pointer w/o decrementing ref count */
FORCEINLINE Tcls *Detach() {Tcls *pT = m_pT; m_pT = NULL; return pT;} inline Tcls *Detach() {Tcls *pT = m_pT; m_pT = NULL; return pT;}
}; };
template <class Tcls_> template <class Tcls_>
FORCEINLINE void CCountedPtr<Tcls_>::Assign(Tcls *pT) inline void CCountedPtr<Tcls_>::Assign(Tcls *pT)
{ {
/* if they are the same, we do nothing */ /* if they are the same, we do nothing */
if (pT != m_pT) { if (pT != m_pT) {

24
src/misc/fixedsizearray.hpp
View File

@ -41,13 +41,13 @@ protected:
T *data; T *data;
/** return reference to the array header (non-const) */ /** return reference to the array header (non-const) */
FORCEINLINE ArrayHeader& Hdr() { return *(ArrayHeader*)(((byte*)data) - HeaderSize); } inline ArrayHeader& Hdr() { return *(ArrayHeader*)(((byte*)data) - HeaderSize); }
/** return reference to the array header (const) */ /** return reference to the array header (const) */
FORCEINLINE const ArrayHeader& Hdr() const { return *(ArrayHeader*)(((byte*)data) - HeaderSize); } inline const ArrayHeader& Hdr() const { return *(ArrayHeader*)(((byte*)data) - HeaderSize); }
/** return reference to the block reference counter */ /** return reference to the block reference counter */
FORCEINLINE uint& RefCnt() { return Hdr().reference_count; } inline uint& RefCnt() { return Hdr().reference_count; }
/** return reference to number of used items */ /** return reference to number of used items */
FORCEINLINE uint& SizeRef() { return Hdr().items; } inline uint& SizeRef() { return Hdr().items; }
public: public:
/** Default constructor. Preallocate space for items and header, then initialize header. */ /** Default constructor. Preallocate space for items and header, then initialize header. */
@ -83,7 +83,7 @@ public:
} }
/** Clear (destroy) all items */ /** Clear (destroy) all items */
FORCEINLINE void Clear() inline void Clear()
{ {
/* Walk through all allocated items backward and destroy them /* Walk through all allocated items backward and destroy them
* Note: this->Length() can be zero. In that case data[this->Length() - 1] is evaluated unsigned * Note: this->Length() can be zero. In that case data[this->Length() - 1] is evaluated unsigned
@ -96,19 +96,19 @@ public:
} }
/** return number of used items */ /** return number of used items */
FORCEINLINE uint Length() const { return Hdr().items; } inline uint Length() const { return Hdr().items; }
/** return true if array is full */ /** return true if array is full */
FORCEINLINE bool IsFull() const { return Length() >= C; } inline bool IsFull() const { return Length() >= C; }
/** return true if array is empty */ /** return true if array is empty */
FORCEINLINE bool IsEmpty() const { return Length() <= 0; } inline bool IsEmpty() const { return Length() <= 0; }
/** add (allocate), but don't construct item */ /** add (allocate), but don't construct item */
FORCEINLINE T *Append() { assert(!IsFull()); return &data[SizeRef()++]; } inline T *Append() { assert(!IsFull()); return &data[SizeRef()++]; }
/** add and construct item using default constructor */ /** add and construct item using default constructor */
FORCEINLINE T *AppendC() { T *item = Append(); new(item)T; return item; } inline T *AppendC() { T *item = Append(); new(item)T; return item; }
/** return item by index (non-const version) */ /** return item by index (non-const version) */
FORCEINLINE T& operator [] (uint index) { assert(index < Length()); return data[index]; } inline T& operator [] (uint index) { assert(index < Length()); return data[index]; }
/** return item by index (const version) */ /** return item by index (const version) */
FORCEINLINE const T& operator [] (uint index) const { assert(index < Length()); return data[index]; } inline const T& operator [] (uint index) const { assert(index < Length()); return data[index]; }
}; };
#endif /* FIXEDSIZEARRAY_HPP */ #endif /* FIXEDSIZEARRAY_HPP */

24
src/misc/hashtable.hpp
View File

@ -21,13 +21,13 @@ struct CHashTableSlotT
Titem_ *m_pFirst; Titem_ *m_pFirst;
FORCEINLINE CHashTableSlotT() : m_pFirst(NULL) {} inline CHashTableSlotT() : m_pFirst(NULL) {}
/** hash table slot helper - clears the slot by simple forgetting its items */ /** hash table slot helper - clears the slot by simple forgetting its items */
FORCEINLINE void Clear() {m_pFirst = NULL;} inline void Clear() {m_pFirst = NULL;}
/** hash table slot helper - linear search for item with given key through the given blob - const version */ /** hash table slot helper - linear search for item with given key through the given blob - const version */
FORCEINLINE const Titem_ *Find(const Key& key) const inline const Titem_ *Find(const Key& key) const
{ {
for (const Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) { for (const Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
if (pItem->GetKey() == key) { if (pItem->GetKey() == key) {
@ -39,7 +39,7 @@ struct CHashTableSlotT
} }
/** hash table slot helper - linear search for item with given key through the given blob - non-const version */ /** hash table slot helper - linear search for item with given key through the given blob - non-const version */
FORCEINLINE Titem_ *Find(const Key& key) inline Titem_ *Find(const Key& key)
{ {
for (Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) { for (Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
if (pItem->GetKey() == key) { if (pItem->GetKey() == key) {
@ -51,7 +51,7 @@ struct CHashTableSlotT
} }
/** hash table slot helper - add new item to the slot */ /** hash table slot helper - add new item to the slot */
FORCEINLINE void Attach(Titem_& new_item) inline void Attach(Titem_& new_item)
{ {
assert(new_item.GetHashNext() == NULL); assert(new_item.GetHashNext() == NULL);
new_item.SetHashNext(m_pFirst); new_item.SetHashNext(m_pFirst);
@ -59,7 +59,7 @@ struct CHashTableSlotT
} }
/** hash table slot helper - remove item from a slot */ /** hash table slot helper - remove item from a slot */
FORCEINLINE bool Detach(Titem_& item_to_remove) inline bool Detach(Titem_& item_to_remove)
{ {
if (m_pFirst == &item_to_remove) { if (m_pFirst == &item_to_remove) {
m_pFirst = item_to_remove.GetHashNext(); m_pFirst = item_to_remove.GetHashNext();
@ -81,7 +81,7 @@ struct CHashTableSlotT
} }
/** hash table slot helper - remove and return item from a slot */ /** hash table slot helper - remove and return item from a slot */
FORCEINLINE Titem_ *Detach(const Key& key) inline Titem_ *Detach(const Key& key)
{ {
/* do we have any items? */ /* do we have any items? */
if (m_pFirst == NULL) { if (m_pFirst == NULL) {
@ -150,13 +150,13 @@ protected:
public: public:
/* default constructor */ /* default constructor */
FORCEINLINE CHashTableT() : m_num_items(0) inline CHashTableT() : m_num_items(0)
{ {
} }
protected: protected:
/** static helper - return hash for the given key modulo number of slots */ /** static helper - return hash for the given key modulo number of slots */
FORCEINLINE static int CalcHash(const Tkey& key) inline static int CalcHash(const Tkey& key)
{ {
int32 hash = key.CalcHash(); int32 hash = key.CalcHash();
if ((8 * Thash_bits) < 32) hash ^= hash >> (min(8 * Thash_bits, 31)); if ((8 * Thash_bits) < 32) hash ^= hash >> (min(8 * Thash_bits, 31));
@ -168,14 +168,14 @@ protected:
} }
/** static helper - return hash for the given item modulo number of slots */ /** static helper - return hash for the given item modulo number of slots */
FORCEINLINE static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());} inline static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());}
public: public:
/** item count */ /** item count */
FORCEINLINE int Count() const {return m_num_items;} inline int Count() const {return m_num_items;}
/** simple clear - forget all items - used by CSegmentCostCacheT.Flush() */ /** simple clear - forget all items - used by CSegmentCostCacheT.Flush() */
FORCEINLINE void Clear() {for (int i = 0; i < Tcapacity; i++) m_slots[i].Clear();} inline void Clear() {for (int i = 0; i < Tcapacity; i++) m_slots[i].Clear();}
/** const item search */ /** const item search */
const Titem_ *Find(const Tkey& key) const const Titem_ *Find(const Tkey& key) const

18
src/misc/str.hpp
View File

@ -24,24 +24,24 @@ struct CStrA : public CBlobT<char>
typedef CBlobT<char> base; ///< base class typedef CBlobT<char> base; ///< base class
/** Create an empty CStrT */ /** Create an empty CStrT */
FORCEINLINE CStrA() inline CStrA()
{ {
} }
/** Copy constructor */ /** Copy constructor */
FORCEINLINE CStrA(const CStrA &src) : base(src) inline CStrA(const CStrA &src) : base(src)
{ {
base::FixTail(); base::FixTail();
} }
/** Take over ownership constructor */ /** Take over ownership constructor */
FORCEINLINE CStrA(const OnTransfer& ot) inline CStrA(const OnTransfer& ot)
: base(ot) : base(ot)
{ {
} }
/** Grow the actual buffer and fix the trailing zero at the end. */ /** Grow the actual buffer and fix the trailing zero at the end. */
FORCEINLINE char *GrowSizeNC(uint count) inline char *GrowSizeNC(uint count)
{ {
char *ret = base::GrowSizeNC(count); char *ret = base::GrowSizeNC(count);
base::FixTail(); base::FixTail();
@ -49,7 +49,7 @@ struct CStrA : public CBlobT<char>
} }
/** Append zero-ended C string. */ /** Append zero-ended C string. */
FORCEINLINE void AppendStr(const char *str) inline void AppendStr(const char *str)
{ {
if (!StrEmpty(str)) { if (!StrEmpty(str)) {
base::AppendRaw(str, strlen(str)); base::AppendRaw(str, strlen(str));
@ -58,7 +58,7 @@ struct CStrA : public CBlobT<char>
} }
/** Append another CStrA. */ /** Append another CStrA. */
FORCEINLINE void Append(const CStrA &src) inline void Append(const CStrA &src)
{ {
if (src.Length() > 0) { if (src.Length() > 0) {
base::AppendRaw(src); base::AppendRaw(src);
@ -67,7 +67,7 @@ struct CStrA : public CBlobT<char>
} }
/** Assignment from C string. */ /** Assignment from C string. */
FORCEINLINE CStrA &operator = (const char *src) inline CStrA &operator = (const char *src)
{ {
base::Clear(); base::Clear();
AppendStr(src); AppendStr(src);
@ -75,7 +75,7 @@ struct CStrA : public CBlobT<char>
} }
/** Assignment from another CStrA. */ /** Assignment from another CStrA. */
FORCEINLINE CStrA &operator = (const CStrA &src) inline CStrA &operator = (const CStrA &src)
{ {
if (&src != this) { if (&src != this) {
base::Clear(); base::Clear();
@ -86,7 +86,7 @@ struct CStrA : public CBlobT<char>
} }
/** Lower-than operator (to support stl collections) */ /** Lower-than operator (to support stl collections) */
FORCEINLINE bool operator < (const CStrA &other) const inline bool operator < (const CStrA &other) const
{ {
return strcmp(base::Data(), other.Data()) < 0; return strcmp(base::Data(), other.Data()) < 0;
} }

10
src/newgrf.cpp
View File

@ -207,7 +207,7 @@ protected:
public: public:
ByteReader(byte *data, byte *end) : data(data), end(end) { } ByteReader(byte *data, byte *end) : data(data), end(end) { }
FORCEINLINE byte ReadByte() inline byte ReadByte()
{ {
if (data < end) return *(data)++; if (data < end) return *(data)++;
throw OTTDByteReaderSignal(); throw OTTDByteReaderSignal();
@ -261,22 +261,22 @@ public:
return string; return string;
} }
FORCEINLINE size_t Remaining() const inline size_t Remaining() const
{ {
return end - data; return end - data;
} }
FORCEINLINE bool HasData(size_t count = 1) const inline bool HasData(size_t count = 1) const
{ {
return data + count <= end; return data + count <= end;
} }
FORCEINLINE byte *Data() inline byte *Data()
{ {
return data; return data;
} }
FORCEINLINE void Skip(size_t len) inline void Skip(size_t len)
{ {
data += len; data += len;
/* It is valid to move the buffer to exactly the end of the data, /* It is valid to move the buffer to exactly the end of the data,

2
src/newgrf_airport.h
View File

@ -45,7 +45,7 @@ public:
{ {
} }
FORCEINLINE TileIterator& operator ++() inline TileIterator& operator ++()
{ {
this->att++; this->att++;
if (this->att->ti.x == -0x80) { if (this->att->ti.x == -0x80) {

2
src/newgrf_config.h
View File

@ -89,7 +89,7 @@ struct GRFIdentifier {
* @param md5sum Expected md5sum, may be \c NULL (in which case, do not check it). * @param md5sum Expected md5sum, may be \c NULL (in which case, do not check it).
* @return the object has the provided grfid and md5sum. * @return the object has the provided grfid and md5sum.
*/ */
FORCEINLINE bool HasGrfIdentifier(uint32 grfid, const uint8 *md5sum) const inline bool HasGrfIdentifier(uint32 grfid, const uint8 *md5sum) const
{ {
if (this->grfid != grfid) return false; if (this->grfid != grfid) return false;
if (md5sum == NULL) return true; if (md5sum == NULL) return true;

2
src/newgrf_gui.cpp
View File

@ -839,7 +839,7 @@ struct NewGRFWindow : public QueryStringBaseWindow, NewGRFScanCallback {
* @param c grf to display. * @param c grf to display.
* @return Palette for the sprite. * @return Palette for the sprite.
*/ */
FORCEINLINE PaletteID GetPalette(const GRFConfig *c) const inline PaletteID GetPalette(const GRFConfig *c) const
{ {
PaletteID pal; PaletteID pal;

36
src/pathfinder/follow_track.hpp
View File

@ -53,25 +53,25 @@ struct CFollowTrackT
CPerformanceTimer *m_pPerf; CPerformanceTimer *m_pPerf;
RailTypes m_railtypes; RailTypes m_railtypes;
FORCEINLINE CFollowTrackT(const VehicleType *v = NULL, RailTypes railtype_override = INVALID_RAILTYPES, CPerformanceTimer *pPerf = NULL) inline CFollowTrackT(const VehicleType *v = NULL, RailTypes railtype_override = INVALID_RAILTYPES, CPerformanceTimer *pPerf = NULL)
{ {
Init(v, railtype_override, pPerf); Init(v, railtype_override, pPerf);
} }
FORCEINLINE CFollowTrackT(Owner o, RailTypes railtype_override = INVALID_RAILTYPES, CPerformanceTimer *pPerf = NULL) inline CFollowTrackT(Owner o, RailTypes railtype_override = INVALID_RAILTYPES, CPerformanceTimer *pPerf = NULL)
{ {
m_veh = NULL; m_veh = NULL;
Init(o, railtype_override, pPerf); Init(o, railtype_override, pPerf);
} }
FORCEINLINE void Init(const VehicleType *v, RailTypes railtype_override, CPerformanceTimer *pPerf) inline void Init(const VehicleType *v, RailTypes railtype_override, CPerformanceTimer *pPerf)
{ {
assert(!IsRailTT() || (v != NULL && v->type == VEH_TRAIN)); assert(!IsRailTT() || (v != NULL && v->type == VEH_TRAIN));
m_veh = v; m_veh = v;
Init(v != NULL ? v->owner : INVALID_OWNER, IsRailTT() && railtype_override == INVALID_RAILTYPES ? Train::From(v)->compatible_railtypes : railtype_override, pPerf); Init(v != NULL ? v->owner : INVALID_OWNER, IsRailTT() && railtype_override == INVALID_RAILTYPES ? Train::From(v)->compatible_railtypes : railtype_override, pPerf);
} }
FORCEINLINE void Init(Owner o, RailTypes railtype_override, CPerformanceTimer *pPerf) inline void Init(Owner o, RailTypes railtype_override, CPerformanceTimer *pPerf)
{ {
assert((!IsRoadTT() || m_veh != NULL) && (!IsRailTT() || railtype_override != INVALID_RAILTYPES)); assert((!IsRoadTT() || m_veh != NULL) && (!IsRailTT() || railtype_override != INVALID_RAILTYPES));
m_veh_owner = o; m_veh_owner = o;
@ -86,16 +86,16 @@ struct CFollowTrackT
m_railtypes = railtype_override; m_railtypes = railtype_override;
} }
FORCEINLINE static TransportType TT() {return Ttr_type_;} inline static TransportType TT() {return Ttr_type_;}
FORCEINLINE static bool IsWaterTT() {return TT() == TRANSPORT_WATER;} inline static bool IsWaterTT() {return TT() == TRANSPORT_WATER;}
FORCEINLINE static bool IsRailTT() {return TT() == TRANSPORT_RAIL;} inline static bool IsRailTT() {return TT() == TRANSPORT_RAIL;}
FORCEINLINE bool IsTram() {return IsRoadTT() && HasBit(RoadVehicle::From(m_veh)->compatible_roadtypes, ROADTYPE_TRAM);} inline bool IsTram() {return IsRoadTT() && HasBit(RoadVehicle::From(m_veh)->compatible_roadtypes, ROADTYPE_TRAM);}
FORCEINLINE static bool IsRoadTT() {return TT() == TRANSPORT_ROAD;} inline static bool IsRoadTT() {return TT() == TRANSPORT_ROAD;}
FORCEINLINE static bool Allow90degTurns() {return T90deg_turns_allowed_;} inline static bool Allow90degTurns() {return T90deg_turns_allowed_;}
FORCEINLINE static bool DoTrackMasking() {return IsRailTT() && Tmask_reserved_tracks;} inline static bool DoTrackMasking() {return IsRailTT() && Tmask_reserved_tracks;}
/** Tests if a tile is a road tile with a single tramtrack (tram can reverse) */ /** Tests if a tile is a road tile with a single tramtrack (tram can reverse) */
FORCEINLINE DiagDirection GetSingleTramBit(TileIndex tile) inline DiagDirection GetSingleTramBit(TileIndex tile)
{ {
assert(IsTram()); // this function shouldn't be called in other cases assert(IsTram()); // this function shouldn't be called in other cases
@ -189,7 +189,7 @@ struct CFollowTrackT
protected: protected:
/** Follow the m_exitdir from m_old_tile and fill m_new_tile and m_tiles_skipped */ /** Follow the m_exitdir from m_old_tile and fill m_new_tile and m_tiles_skipped */
FORCEINLINE void FollowTileExit() inline void FollowTileExit()
{ {
m_is_station = m_is_bridge = m_is_tunnel = false; m_is_station = m_is_bridge = m_is_tunnel = false;
m_tiles_skipped = 0; m_tiles_skipped = 0;
@ -227,7 +227,7 @@ protected:
} }
/** stores track status (available trackdirs) for the new tile into m_new_td_bits */ /** stores track status (available trackdirs) for the new tile into m_new_td_bits */
FORCEINLINE bool QueryNewTileTrackStatus() inline bool QueryNewTileTrackStatus()
{ {
CPerfStart perf(*m_pPerf); CPerfStart perf(*m_pPerf);
if (IsRailTT() && IsPlainRailTile(m_new_tile)) { if (IsRailTT() && IsPlainRailTile(m_new_tile)) {
@ -257,7 +257,7 @@ protected:
} }
/** return true if we can leave m_old_tile in m_exitdir */ /** return true if we can leave m_old_tile in m_exitdir */
FORCEINLINE bool CanExitOldTile() inline bool CanExitOldTile()
{ {
/* road stop can be left at one direction only unless it's a drive-through stop */ /* road stop can be left at one direction only unless it's a drive-through stop */
if (IsRoadTT() && IsStandardRoadStopTile(m_old_tile)) { if (IsRoadTT() && IsStandardRoadStopTile(m_old_tile)) {
@ -289,7 +289,7 @@ protected:
} }
/** return true if we can enter m_new_tile from m_exitdir */ /** return true if we can enter m_new_tile from m_exitdir */
FORCEINLINE bool CanEnterNewTile() inline bool CanEnterNewTile()
{ {
if (IsRoadTT() && IsStandardRoadStopTile(m_new_tile)) { if (IsRoadTT() && IsStandardRoadStopTile(m_new_tile)) {
/* road stop can be entered from one direction only unless it's a drive-through stop */ /* road stop can be entered from one direction only unless it's a drive-through stop */
@ -386,7 +386,7 @@ protected:
} }
/** return true if we must reverse (in depots and single tram bits) */ /** return true if we must reverse (in depots and single tram bits) */
FORCEINLINE bool ForcedReverse() inline bool ForcedReverse()
{ {
/* rail and road depots cause reversing */ /* rail and road depots cause reversing */
if (!IsWaterTT() && IsDepotTypeTile(m_old_tile, TT())) { if (!IsWaterTT() && IsDepotTypeTile(m_old_tile, TT())) {
@ -417,7 +417,7 @@ protected:
} }
/** return true if we successfully reversed at end of road/track */ /** return true if we successfully reversed at end of road/track */
FORCEINLINE bool TryReverse() inline bool TryReverse()
{ {
if (IsRoadTT() && !IsTram()) { if (IsRoadTT() && !IsTram()) {
/* if we reached the end of road, we can reverse the RV and continue moving */ /* if we reached the end of road, we can reverse the RV and continue moving */

4
src/pathfinder/npf/queue.h
View File

@ -43,7 +43,7 @@ struct BinaryHeap {
* @param i Element to access (starts at offset \c 1). * @param i Element to access (starts at offset \c 1).
* @return Value of the element. * @return Value of the element.
*/ */
FORCEINLINE BinaryHeapNode &GetElement(uint i) inline BinaryHeapNode &GetElement(uint i)
{ {
assert(i > 0); assert(i > 0);
return this->elements[(i - 1) >> BINARY_HEAP_BLOCKSIZE_BITS][(i - 1) & BINARY_HEAP_BLOCKSIZE_MASK]; return this->elements[(i - 1) >> BINARY_HEAP_BLOCKSIZE_BITS][(i - 1) & BINARY_HEAP_BLOCKSIZE_MASK];
@ -96,7 +96,7 @@ struct Hash {
/** /**
* Gets the current size of the hash. * Gets the current size of the hash.
*/ */
FORCEINLINE uint GetSize() const inline uint GetSize() const
{ {
return this->size; return this->size;
} }

22
src/pathfinder/pf_performance_timer.hpp
View File

@ -21,27 +21,27 @@ struct CPerformanceTimer
CPerformanceTimer() : m_start(0), m_acc(0) {} CPerformanceTimer() : m_start(0), m_acc(0) {}
FORCEINLINE void Start() inline void Start()
{ {
m_start = QueryTime(); m_start = QueryTime();
} }
FORCEINLINE void Stop() inline void Stop()
{ {
m_acc += QueryTime() - m_start; m_acc += QueryTime() - m_start;
} }
FORCEINLINE int Get(int64 coef) inline int Get(int64 coef)
{ {
return (int)(m_acc * coef / QueryFrequency()); return (int)(m_acc * coef / QueryFrequency());
} }
FORCEINLINE int64 QueryTime() inline int64 QueryTime()
{ {
return ottd_rdtsc(); return ottd_rdtsc();
} }
FORCEINLINE int64 QueryFrequency() inline int64 QueryFrequency()
{ {
return ((int64)2200 * 1000000); return ((int64)2200 * 1000000);
} }
@ -51,17 +51,17 @@ struct CPerfStartReal
{ {
CPerformanceTimer *m_pperf; CPerformanceTimer *m_pperf;
FORCEINLINE CPerfStartReal(CPerformanceTimer& perf) : m_pperf(&perf) inline CPerfStartReal(CPerformanceTimer& perf) : m_pperf(&perf)
{ {
if (m_pperf != NULL) m_pperf->Start(); if (m_pperf != NULL) m_pperf->Start();
} }
FORCEINLINE ~CPerfStartReal() inline ~CPerfStartReal()
{ {
Stop(); Stop();
} }
FORCEINLINE void Stop() inline void Stop()
{ {
if (m_pperf != NULL) { if (m_pperf != NULL) {
m_pperf->Stop(); m_pperf->Stop();
@ -72,9 +72,9 @@ struct CPerfStartReal
struct CPerfStartFake struct CPerfStartFake
{ {
FORCEINLINE CPerfStartFake(CPerformanceTimer& perf) {} inline CPerfStartFake(CPerformanceTimer& perf) {}
FORCEINLINE ~CPerfStartFake() {} inline ~CPerfStartFake() {}
FORCEINLINE void Stop() {} inline void Stop() {}
}; };
typedef CPerfStartFake CPerfStart; typedef CPerfStartFake CPerfStart;

26
src/pathfinder/yapf/nodelist.hpp
View File

@ -62,26 +62,26 @@ public:
} }
/** return number of open nodes */ /** return number of open nodes */
FORCEINLINE int OpenCount() inline int OpenCount()
{ {
return m_open.Count(); return m_open.Count();
} }
/** return number of closed nodes */ /** return number of closed nodes */
FORCEINLINE int ClosedCount() inline int ClosedCount()
{ {
return m_closed.Count(); return m_closed.Count();
} }
/** allocate new data item from m_arr */ /** allocate new data item from m_arr */
FORCEINLINE Titem_ *CreateNewNode() inline Titem_ *CreateNewNode()
{ {
if (m_new_node == NULL) m_new_node = m_arr.AppendC(); if (m_new_node == NULL) m_new_node = m_arr.AppendC();
return m_new_node; return m_new_node;
} }
/** Notify the nodelist that we don't want to discard the given node. */ /** Notify the nodelist that we don't want to discard the given node. */
FORCEINLINE void FoundBestNode(Titem_& item) inline void FoundBestNode(Titem_& item)
{ {
/* for now it is enough to invalidate m_new_node if it is our given node */ /* for now it is enough to invalidate m_new_node if it is our given node */
if (&item == m_new_node) { if (&item == m_new_node) {
@ -91,7 +91,7 @@ public:
} }
/** insert given item as open node (into m_open and m_open_queue) */ /** insert given item as open node (into m_open and m_open_queue) */
FORCEINLINE void InsertOpenNode(Titem_& item) inline void InsertOpenNode(Titem_& item)
{ {
assert(m_closed.Find(item.GetKey()) == NULL); assert(m_closed.Find(item.GetKey()) == NULL);
m_open.Push(item); m_open.Push(item);
@ -102,7 +102,7 @@ public:
} }
/** return the best open node */ /** return the best open node */
FORCEINLINE Titem_ *GetBestOpenNode() inline Titem_ *GetBestOpenNode()
{ {
if (!m_open_queue.IsEmpty()) { if (!m_open_queue.IsEmpty()) {
return m_open_queue.Begin(); return m_open_queue.Begin();
@ -111,7 +111,7 @@ public:
} }
/** remove and return the best open node */ /** remove and return the best open node */
FORCEINLINE Titem_ *PopBestOpenNode() inline Titem_ *PopBestOpenNode()
{ {
if (!m_open_queue.IsEmpty()) { if (!m_open_queue.IsEmpty()) {
Titem_ *item = m_open_queue.Shift(); Titem_ *item = m_open_queue.Shift();
@ -122,14 +122,14 @@ public:
} }
/** return the open node specified by a key or NULL if not found */ /** return the open node specified by a key or NULL if not found */
FORCEINLINE Titem_ *FindOpenNode(const Key& key) inline Titem_ *FindOpenNode(const Key& key)
{ {
Titem_ *item = m_open.Find(key); Titem_ *item = m_open.Find(key);
return item; return item;
} }
/** remove and return the open node specified by a key */ /** remove and return the open node specified by a key */
FORCEINLINE Titem_& PopOpenNode(const Key& key) inline Titem_& PopOpenNode(const Key& key)
{ {
Titem_& item = m_open.Pop(key); Titem_& item = m_open.Pop(key);
uint idxPop = m_open_queue.FindIndex(item); uint idxPop = m_open_queue.FindIndex(item);
@ -138,23 +138,23 @@ public:
} }
/** close node */ /** close node */
FORCEINLINE void InsertClosedNode(Titem_& item) inline void InsertClosedNode(Titem_& item)
{ {
assert(m_open.Find(item.GetKey()) == NULL); assert(m_open.Find(item.GetKey()) == NULL);
m_closed.Push(item); m_closed.Push(item);
} }
/** return the closed node specified by a key or NULL if not found */ /** return the closed node specified by a key or NULL if not found */
FORCEINLINE Titem_ *FindClosedNode(const Key& key) inline Titem_ *FindClosedNode(const Key& key)
{ {
Titem_ *item = m_closed.Find(key); Titem_ *item = m_closed.Find(key);
return item; return item;
} }
/** The number of items. */ /** The number of items. */
FORCEINLINE int TotalCount() {return m_arr.Length();} inline int TotalCount() {return m_arr.Length();}
/** Get a particular item. */ /** Get a particular item. */
FORCEINLINE Titem_& ItemAt(int idx) {return m_arr[idx];} inline Titem_& ItemAt(int idx) {return m_arr[idx];}
/** Helper for creating output of this array. */ /** Helper for creating output of this array. */
template <class D> void Dump(D &dmp) const template <class D> void Dump(D &dmp) const

2
src/pathfinder/yapf/yapf.hpp
View File

@ -18,7 +18,7 @@
#include "yapf.h" #include "yapf.h"
//#undef FORCEINLINE //#undef FORCEINLINE
//#define FORCEINLINE inline //#define inline inline
#include "../../misc/blob.hpp" #include "../../misc/blob.hpp"
#include "../../misc/str.hpp" #include "../../misc/str.hpp"

34
src/pathfinder/yapf/yapf_base.hpp
View File

@ -37,11 +37,11 @@ extern int _total_pf_time_us;
* Requrements to your pathfinder class derived from CYapfBaseT: * Requrements to your pathfinder class derived from CYapfBaseT:
* ------------------------------------------------------------- * -------------------------------------------------------------
* Your pathfinder derived class needs to implement following methods: * Your pathfinder derived class needs to implement following methods:
* FORCEINLINE void PfSetStartupNodes() * inline void PfSetStartupNodes()
* FORCEINLINE void PfFollowNode(Node& org) * inline void PfFollowNode(Node& org)
* FORCEINLINE bool PfCalcCost(Node& n) * inline bool PfCalcCost(Node& n)
* FORCEINLINE bool PfCalcEstimate(Node& n) * inline bool PfCalcEstimate(Node& n)
* FORCEINLINE bool PfDetectDestination(Node& n) * inline bool PfDetectDestination(Node& n)
* *
* For more details about those methods, look at the end of CYapfBaseT * For more details about those methods, look at the end of CYapfBaseT
* declaration. There are some examples. For another example look at * declaration. There are some examples. For another example look at
@ -80,7 +80,7 @@ public:
public: public:
/** default constructor */ /** default constructor */
FORCEINLINE CYapfBaseT() inline CYapfBaseT()
: m_pBestDestNode(NULL) : m_pBestDestNode(NULL)
, m_pBestIntermediateNode(NULL) , m_pBestIntermediateNode(NULL)
, m_settings(&_settings_game.pf.yapf) , m_settings(&_settings_game.pf.yapf)
@ -97,14 +97,14 @@ public:
protected: protected:
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
public: public:
/** return current settings (can be custom - company based - but later) */ /** return current settings (can be custom - company based - but later) */
FORCEINLINE const YAPFSettings& PfGetSettings() const inline const YAPFSettings& PfGetSettings() const
{ {
return *m_settings; return *m_settings;
} }
@ -182,7 +182,7 @@ public:
* If path was found return the best node that has reached the destination. Otherwise * If path was found return the best node that has reached the destination. Otherwise
* return the best visited node (which was nearest to the destination). * return the best visited node (which was nearest to the destination).
*/ */
FORCEINLINE Node *GetBestNode() inline Node *GetBestNode()
{ {
return (m_pBestDestNode != NULL) ? m_pBestDestNode : m_pBestIntermediateNode; return (m_pBestDestNode != NULL) ? m_pBestDestNode : m_pBestIntermediateNode;
} }
@ -191,14 +191,14 @@ public:
* Calls NodeList::CreateNewNode() - allocates new node that can be filled and used * Calls NodeList::CreateNewNode() - allocates new node that can be filled and used
* as argument for AddStartupNode() or AddNewNode() * as argument for AddStartupNode() or AddNewNode()
*/ */
FORCEINLINE Node& CreateNewNode() inline Node& CreateNewNode()
{ {
Node& node = *m_nodes.CreateNewNode(); Node& node = *m_nodes.CreateNewNode();
return node; return node;
} }
/** Add new node (created by CreateNewNode and filled with data) into open list */ /** Add new node (created by CreateNewNode and filled with data) into open list */
FORCEINLINE void AddStartupNode(Node& n) inline void AddStartupNode(Node& n)
{ {
Yapf().PfNodeCacheFetch(n); Yapf().PfNodeCacheFetch(n);
/* insert the new node only if it is not there */ /* insert the new node only if it is not there */
@ -212,7 +212,7 @@ public:
} }
/** add multiple nodes - direct children of the given node */ /** add multiple nodes - direct children of the given node */
FORCEINLINE void AddMultipleNodes(Node *parent, const TrackFollower &tf) inline void AddMultipleNodes(Node *parent, const TrackFollower &tf)
{ {
bool is_choice = (KillFirstBit(tf.m_new_td_bits) != TRACKDIR_BIT_NONE); bool is_choice = (KillFirstBit(tf.m_new_td_bits) != TRACKDIR_BIT_NONE);
for (TrackdirBits rtds = tf.m_new_td_bits; rtds != TRACKDIR_BIT_NONE; rtds = KillFirstBit(rtds)) { for (TrackdirBits rtds = tf.m_new_td_bits; rtds != TRACKDIR_BIT_NONE; rtds = KillFirstBit(rtds)) {
@ -315,7 +315,7 @@ public:
#if 0 #if 0
/** Example: PfSetStartupNodes() - set source (origin) nodes */ /** Example: PfSetStartupNodes() - set source (origin) nodes */
FORCEINLINE void PfSetStartupNodes() inline void PfSetStartupNodes()
{ {
/* example: */ /* example: */
Node& n1 = *base::m_nodes.CreateNewNode(); Node& n1 = *base::m_nodes.CreateNewNode();
@ -326,7 +326,7 @@ public:
} }
/** Example: PfFollowNode() - set following (child) nodes of the given node */ /** Example: PfFollowNode() - set following (child) nodes of the given node */
FORCEINLINE void PfFollowNode(Node& org) inline void PfFollowNode(Node& org)
{ {
for (each follower of node org) { for (each follower of node org) {
Node& n = *base::m_nodes.CreateNewNode(); Node& n = *base::m_nodes.CreateNewNode();
@ -339,7 +339,7 @@ public:
} }
/** Example: PfCalcCost() - set path cost from origin to the given node */ /** Example: PfCalcCost() - set path cost from origin to the given node */
FORCEINLINE bool PfCalcCost(Node& n) inline bool PfCalcCost(Node& n)
{ {
/* evaluate last step cost */ /* evaluate last step cost */
int cost = ...; int cost = ...;
@ -349,7 +349,7 @@ public:
} }
/** Example: PfCalcEstimate() - set path cost estimate from origin to the target through given node */ /** Example: PfCalcEstimate() - set path cost estimate from origin to the target through given node */
FORCEINLINE bool PfCalcEstimate(Node& n) inline bool PfCalcEstimate(Node& n)
{ {
/* evaluate the distance to our destination */ /* evaluate the distance to our destination */
int distance = ...; int distance = ...;
@ -359,7 +359,7 @@ public:
} }
/** Example: PfDetectDestination() - return true if the given node is our destination */ /** Example: PfDetectDestination() - return true if the given node is our destination */
FORCEINLINE bool PfDetectDestination(Node& n) inline bool PfDetectDestination(Node& n)
{ {
bool bDest = (n.m_key.m_x == m_x2) && (n.m_key.m_y == m_y2); bool bDest = (n.m_key.m_x == m_x2) && (n.m_key.m_y == m_y2);
return bDest; return bDest;

8
src/pathfinder/yapf/yapf_common.hpp
View File

@ -26,7 +26,7 @@ protected:
TrackdirBits m_orgTrackdirs; ///< origin trackdir mask TrackdirBits m_orgTrackdirs; ///< origin trackdir mask
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -70,7 +70,7 @@ protected:
bool m_treat_first_red_two_way_signal_as_eol; ///< in some cases (leaving station) we need to handle first two-way signal differently bool m_treat_first_red_two_way_signal_as_eol; ///< in some cases (leaving station) we need to handle first two-way signal differently
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -104,7 +104,7 @@ public:
} }
/** return true if first two-way signal should be treated as dead end */ /** return true if first two-way signal should be treated as dead end */
FORCEINLINE bool TreatFirstRedTwoWaySignalAsEOL() inline bool TreatFirstRedTwoWaySignalAsEOL()
{ {
return Yapf().PfGetSettings().rail_firstred_twoway_eol && m_treat_first_red_two_way_signal_as_eol; return Yapf().PfGetSettings().rail_firstred_twoway_eol && m_treat_first_red_two_way_signal_as_eol;
} }
@ -140,7 +140,7 @@ protected:
public: public:
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(Node& n) inline bool PfDetectDestination(Node& n)
{ {
bool bDest = (n.m_key.m_tile == m_destTile) && ((m_destTrackdirs & TrackdirToTrackdirBits(n.GetTrackdir())) != TRACKDIR_BIT_NONE); bool bDest = (n.m_key.m_tile == m_destTile) && ((m_destTrackdirs & TrackdirToTrackdirBits(n.GetTrackdir())) != TRACKDIR_BIT_NONE);
return bDest; return bDest;

2
src/pathfinder/yapf/yapf_costbase.hpp
View File

@ -20,7 +20,7 @@ struct CYapfCostBase {
* @param td The track direction to check. * @param td The track direction to check.
* @return True if there's a slope, otherwise false. * @return True if there's a slope, otherwise false.
*/ */
FORCEINLINE static bool stSlopeCost(TileIndex tile, Trackdir td) inline static bool stSlopeCost(TileIndex tile, Trackdir td)
{ {
if (IsDiagonalTrackdir(td)) { if (IsDiagonalTrackdir(td)) {
if (IsBridgeTile(tile)) { if (IsBridgeTile(tile)) {

26
src/pathfinder/yapf/yapf_costcache.hpp
View File

@ -30,7 +30,7 @@ public:
* Called by YAPF to attach cached or local segment cost data to the given node. * Called by YAPF to attach cached or local segment cost data to the given node.
* @return true if globally cached data were used or false if local data was used * @return true if globally cached data were used or false if local data was used
*/ */
FORCEINLINE bool PfNodeCacheFetch(Node& n) inline bool PfNodeCacheFetch(Node& n)
{ {
return false; return false;
} }
@ -39,7 +39,7 @@ public:
* Called by YAPF to flush the cached segment cost data back into cache storage. * Called by YAPF to flush the cached segment cost data back into cache storage.
* Current cache implementation doesn't use that. * Current cache implementation doesn't use that.
*/ */
FORCEINLINE void PfNodeCacheFlush(Node& n) inline void PfNodeCacheFlush(Node& n)
{ {
} }
}; };
@ -65,7 +65,7 @@ protected:
LocalCache m_local_cache; LocalCache m_local_cache;
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -75,7 +75,7 @@ public:
* Called by YAPF to attach cached or local segment cost data to the given node. * Called by YAPF to attach cached or local segment cost data to the given node.
* @return true if globally cached data were used or false if local data was used * @return true if globally cached data were used or false if local data was used
*/ */
FORCEINLINE bool PfNodeCacheFetch(Node& n) inline bool PfNodeCacheFetch(Node& n)
{ {
CacheKey key(n.GetKey()); CacheKey key(n.GetKey());
Yapf().ConnectNodeToCachedData(n, *new (m_local_cache.Append()) CachedData(key)); Yapf().ConnectNodeToCachedData(n, *new (m_local_cache.Append()) CachedData(key));
@ -86,7 +86,7 @@ public:
* Called by YAPF to flush the cached segment cost data back into cache storage. * Called by YAPF to flush the cached segment cost data back into cache storage.
* Current cache implementation doesn't use that. * Current cache implementation doesn't use that.
*/ */
FORCEINLINE void PfNodeCacheFlush(Node& n) inline void PfNodeCacheFlush(Node& n)
{ {
} }
}; };
@ -133,16 +133,16 @@ struct CSegmentCostCacheT
HashTable m_map; HashTable m_map;
Heap m_heap; Heap m_heap;
FORCEINLINE CSegmentCostCacheT() {} inline CSegmentCostCacheT() {}
/** flush (clear) the cache */ /** flush (clear) the cache */
FORCEINLINE void Flush() inline void Flush()
{ {
m_map.Clear(); m_map.Clear();
m_heap.Clear(); m_heap.Clear();
} }
FORCEINLINE Tsegment& Get(Key& key, bool *found) inline Tsegment& Get(Key& key, bool *found)
{ {
Tsegment *item = m_map.Find(key); Tsegment *item = m_map.Find(key);
if (item == NULL) { if (item == NULL) {
@ -177,15 +177,15 @@ public:
protected: protected:
Cache& m_global_cache; Cache& m_global_cache;
FORCEINLINE CYapfSegmentCostCacheGlobalT() : m_global_cache(stGetGlobalCache()) {}; inline CYapfSegmentCostCacheGlobalT() : m_global_cache(stGetGlobalCache()) {};
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
FORCEINLINE static Cache& stGetGlobalCache() inline static Cache& stGetGlobalCache()
{ {
static int last_rail_change_counter = 0; static int last_rail_change_counter = 0;
static Date last_date = 0; static Date last_date = 0;
@ -211,7 +211,7 @@ public:
* Called by YAPF to attach cached or local segment cost data to the given node. * Called by YAPF to attach cached or local segment cost data to the given node.
* @return true if globally cached data were used or false if local data was used * @return true if globally cached data were used or false if local data was used
*/ */
FORCEINLINE bool PfNodeCacheFetch(Node& n) inline bool PfNodeCacheFetch(Node& n)
{ {
if (!Yapf().CanUseGlobalCache(n)) { if (!Yapf().CanUseGlobalCache(n)) {
return Tlocal::PfNodeCacheFetch(n); return Tlocal::PfNodeCacheFetch(n);
@ -227,7 +227,7 @@ public:
* Called by YAPF to flush the cached segment cost data back into cache storage. * Called by YAPF to flush the cached segment cost data back into cache storage.
* Current cache implementation doesn't use that. * Current cache implementation doesn't use that.
*/ */
FORCEINLINE void PfNodeCacheFlush(Node& n) inline void PfNodeCacheFlush(Node& n)
{ {
} }
}; };

22
src/pathfinder/yapf/yapf_costrail.hpp
View File

@ -96,14 +96,14 @@ protected:
} }
public: public:
FORCEINLINE int SlopeCost(TileIndex tile, Trackdir td) inline int SlopeCost(TileIndex tile, Trackdir td)
{ {
CPerfStart perf_cost(Yapf().m_perf_slope_cost); CPerfStart perf_cost(Yapf().m_perf_slope_cost);
if (!stSlopeCost(tile, td)) return 0; if (!stSlopeCost(tile, td)) return 0;
return Yapf().PfGetSettings().rail_slope_penalty; return Yapf().PfGetSettings().rail_slope_penalty;
} }
FORCEINLINE int CurveCost(Trackdir td1, Trackdir td2) inline int CurveCost(Trackdir td1, Trackdir td2)
{ {
assert(IsValidTrackdir(td1)); assert(IsValidTrackdir(td1));
assert(IsValidTrackdir(td2)); assert(IsValidTrackdir(td2));
@ -119,7 +119,7 @@ public:
return cost; return cost;
} }
FORCEINLINE int SwitchCost(TileIndex tile1, TileIndex tile2, DiagDirection exitdir) inline int SwitchCost(TileIndex tile1, TileIndex tile2, DiagDirection exitdir)
{ {
if (IsPlainRailTile(tile1) && IsPlainRailTile(tile2)) { if (IsPlainRailTile(tile1) && IsPlainRailTile(tile2)) {
bool t1 = KillFirstBit(GetTrackBits(tile1) & DiagdirReachesTracks(ReverseDiagDir(exitdir))) != TRACK_BIT_NONE; bool t1 = KillFirstBit(GetTrackBits(tile1) & DiagdirReachesTracks(ReverseDiagDir(exitdir))) != TRACK_BIT_NONE;
@ -130,7 +130,7 @@ public:
} }
/** Return one tile cost (base cost + level crossing penalty). */ /** Return one tile cost (base cost + level crossing penalty). */
FORCEINLINE int OneTileCost(TileIndex& tile, Trackdir trackdir) inline int OneTileCost(TileIndex& tile, Trackdir trackdir)
{ {
int cost = 0; int cost = 0;
/* set base cost */ /* set base cost */
@ -155,7 +155,7 @@ public:
} }
/** Check for a reserved station platform. */ /** Check for a reserved station platform. */
FORCEINLINE bool IsAnyStationTileReserved(TileIndex tile, Trackdir trackdir, int skipped) inline bool IsAnyStationTileReserved(TileIndex tile, Trackdir trackdir, int skipped)
{ {
TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(trackdir))); TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(trackdir)));
for (; skipped >= 0; skipped--, tile += diff) { for (; skipped >= 0; skipped--, tile += diff) {
@ -165,7 +165,7 @@ public:
} }
/** The cost for reserved tiles, including skipped ones. */ /** The cost for reserved tiles, including skipped ones. */
FORCEINLINE int ReservationCost(Node& n, TileIndex tile, Trackdir trackdir, int skipped) inline int ReservationCost(Node& n, TileIndex tile, Trackdir trackdir, int skipped)
{ {
if (n.m_num_signals_passed >= m_sig_look_ahead_costs.Size() / 2) return 0; if (n.m_num_signals_passed >= m_sig_look_ahead_costs.Size() / 2) return 0;
if (!IsPbsSignal(n.m_last_signal_type)) return 0; if (!IsPbsSignal(n.m_last_signal_type)) return 0;
@ -251,7 +251,7 @@ public:
return cost; return cost;
} }
FORCEINLINE int PlatformLengthPenalty(int platform_length) inline int PlatformLengthPenalty(int platform_length)
{ {
int cost = 0; int cost = 0;
const Train *v = Yapf().GetVehicle(); const Train *v = Yapf().GetVehicle();
@ -270,7 +270,7 @@ public:
} }
public: public:
FORCEINLINE void SetMaxCost(int max_cost) inline void SetMaxCost(int max_cost)
{ {
m_max_cost = max_cost; m_max_cost = max_cost;
} }
@ -280,7 +280,7 @@ public:
* Calculates only the cost of given node, adds it to the parent node cost * Calculates only the cost of given node, adds it to the parent node cost
* and stores the result into Node::m_cost member * and stores the result into Node::m_cost member
*/ */
FORCEINLINE bool PfCalcCost(Node &n, const TrackFollower *tf) inline bool PfCalcCost(Node &n, const TrackFollower *tf)
{ {
assert(!n.flags_u.flags_s.m_targed_seen); assert(!n.flags_u.flags_s.m_targed_seen);
assert(tf->m_new_tile == n.m_key.m_tile); assert(tf->m_new_tile == n.m_key.m_tile);
@ -613,14 +613,14 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th
return true; return true;
} }
FORCEINLINE bool CanUseGlobalCache(Node& n) const inline bool CanUseGlobalCache(Node& n) const
{ {
return !m_disable_cache return !m_disable_cache
&& (n.m_parent != NULL) && (n.m_parent != NULL)
&& (n.m_parent->m_num_signals_passed >= m_sig_look_ahead_costs.Size()); && (n.m_parent->m_num_signals_passed >= m_sig_look_ahead_costs.Size());
} }
FORCEINLINE void ConnectNodeToCachedData(Node& n, CachedData& ci) inline void ConnectNodeToCachedData(Node& n, CachedData& ci)
{ {
n.m_segment = &ci; n.m_segment = &ci;
if (n.m_segment->m_cost < 0) { if (n.m_segment->m_cost < 0) {

18
src/pathfinder/yapf/yapf_destrail.hpp
View File

@ -51,13 +51,13 @@ public:
} }
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(Node& n) inline bool PfDetectDestination(Node& n)
{ {
return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir()); return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
} }
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td) inline bool PfDetectDestination(TileIndex tile, Trackdir td)
{ {
bool bDest = IsRailDepotTile(tile); bool bDest = IsRailDepotTile(tile);
return bDest; return bDest;
@ -67,7 +67,7 @@ public:
* Called by YAPF to calculate cost estimate. Calculates distance to the destination * Called by YAPF to calculate cost estimate. Calculates distance to the destination
* adds it to the actual cost from origin and stores the sum to the Node::m_estimate * adds it to the actual cost from origin and stores the sum to the Node::m_estimate
*/ */
FORCEINLINE bool PfCalcEstimate(Node& n) inline bool PfCalcEstimate(Node& n)
{ {
n.m_estimate = n.m_cost; n.m_estimate = n.m_cost;
return true; return true;
@ -91,13 +91,13 @@ public:
} }
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(Node& n) inline bool PfDetectDestination(Node& n)
{ {
return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir()); return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
} }
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td) inline bool PfDetectDestination(TileIndex tile, Trackdir td)
{ {
return IsSafeWaitingPosition(Yapf().GetVehicle(), tile, td, true, !TrackFollower::Allow90degTurns()) && return IsSafeWaitingPosition(Yapf().GetVehicle(), tile, td, true, !TrackFollower::Allow90degTurns()) &&
IsWaitingPositionFree(Yapf().GetVehicle(), tile, td, !TrackFollower::Allow90degTurns()); IsWaitingPositionFree(Yapf().GetVehicle(), tile, td, !TrackFollower::Allow90degTurns());
@ -107,7 +107,7 @@ public:
* Called by YAPF to calculate cost estimate. Calculates distance to the destination * Called by YAPF to calculate cost estimate. Calculates distance to the destination
* adds it to the actual cost from origin and stores the sum to the Node::m_estimate. * adds it to the actual cost from origin and stores the sum to the Node::m_estimate.
*/ */
FORCEINLINE bool PfCalcEstimate(Node& n) inline bool PfCalcEstimate(Node& n)
{ {
n.m_estimate = n.m_cost; n.m_estimate = n.m_cost;
return true; return true;
@ -164,13 +164,13 @@ public:
} }
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(Node& n) inline bool PfDetectDestination(Node& n)
{ {
return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir()); return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
} }
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td) inline bool PfDetectDestination(TileIndex tile, Trackdir td)
{ {
bool bDest; bool bDest;
if (m_dest_station_id != INVALID_STATION) { if (m_dest_station_id != INVALID_STATION) {
@ -188,7 +188,7 @@ public:
* Called by YAPF to calculate cost estimate. Calculates distance to the destination * Called by YAPF to calculate cost estimate. Calculates distance to the destination
* adds it to the actual cost from origin and stores the sum to the Node::m_estimate * adds it to the actual cost from origin and stores the sum to the Node::m_estimate
*/ */
FORCEINLINE bool PfCalcEstimate(Node& n) inline bool PfCalcEstimate(Node& n)
{ {
static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0}; static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
static const int dg_dir_to_y_offs[] = {0, 1, 0, -1}; static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};

28
src/pathfinder/yapf/yapf_node.hpp
View File

@ -18,15 +18,15 @@ struct CYapfNodeKeyExitDir {
Trackdir m_td; Trackdir m_td;
DiagDirection m_exitdir; DiagDirection m_exitdir;
FORCEINLINE void Set(TileIndex tile, Trackdir td) inline void Set(TileIndex tile, Trackdir td)
{ {
m_tile = tile; m_tile = tile;
m_td = td; m_td = td;
m_exitdir = (m_td == INVALID_TRACKDIR) ? INVALID_DIAGDIR : TrackdirToExitdir(m_td); m_exitdir = (m_td == INVALID_TRACKDIR) ? INVALID_DIAGDIR : TrackdirToExitdir(m_td);
} }
FORCEINLINE int CalcHash() const {return m_exitdir | (m_tile << 2);} inline int CalcHash() const {return m_exitdir | (m_tile << 2);}
FORCEINLINE bool operator == (const CYapfNodeKeyExitDir& other) const {return (m_tile == other.m_tile) && (m_exitdir == other.m_exitdir);} inline bool operator == (const CYapfNodeKeyExitDir& other) const {return (m_tile == other.m_tile) && (m_exitdir == other.m_exitdir);}
void Dump(DumpTarget &dmp) const void Dump(DumpTarget &dmp) const
{ {
@ -38,8 +38,8 @@ struct CYapfNodeKeyExitDir {
struct CYapfNodeKeyTrackDir : public CYapfNodeKeyExitDir struct CYapfNodeKeyTrackDir : public CYapfNodeKeyExitDir
{ {
FORCEINLINE int CalcHash() const {return m_td | (m_tile << 4);} inline int CalcHash() const {return m_td | (m_tile << 4);}
FORCEINLINE bool operator == (const CYapfNodeKeyTrackDir& other) const {return (m_tile == other.m_tile) && (m_td == other.m_td);} inline bool operator == (const CYapfNodeKeyTrackDir& other) const {return (m_tile == other.m_tile) && (m_td == other.m_td);}
}; };
/** Yapf Node base */ /** Yapf Node base */
@ -54,7 +54,7 @@ struct CYapfNodeT {
int m_cost; int m_cost;
int m_estimate; int m_estimate;
FORCEINLINE void Set(Node *parent, TileIndex tile, Trackdir td, bool is_choice) inline void Set(Node *parent, TileIndex tile, Trackdir td, bool is_choice)
{ {
m_key.Set(tile, td); m_key.Set(tile, td);
m_hash_next = NULL; m_hash_next = NULL;
@ -63,14 +63,14 @@ struct CYapfNodeT {
m_estimate = 0; m_estimate = 0;
} }
FORCEINLINE Node *GetHashNext() {return m_hash_next;} inline Node *GetHashNext() {return m_hash_next;}
FORCEINLINE void SetHashNext(Node *pNext) {m_hash_next = pNext;} inline void SetHashNext(Node *pNext) {m_hash_next = pNext;}
FORCEINLINE TileIndex GetTile() const {return m_key.m_tile;} inline TileIndex GetTile() const {return m_key.m_tile;}
FORCEINLINE Trackdir GetTrackdir() const {return m_key.m_td;} inline Trackdir GetTrackdir() const {return m_key.m_td;}
FORCEINLINE const Tkey_& GetKey() const {return m_key;} inline const Tkey_& GetKey() const {return m_key;}
FORCEINLINE int GetCost() const {return m_cost;} inline int GetCost() const {return m_cost;}
FORCEINLINE int GetCostEstimate() const {return m_estimate;} inline int GetCostEstimate() const {return m_estimate;}
FORCEINLINE bool operator < (const Node& other) const {return m_estimate < other.m_estimate;} inline bool operator < (const Node& other) const {return m_estimate < other.m_estimate;}
void Dump(DumpTarget &dmp) const void Dump(DumpTarget &dmp) const
{ {

34
src/pathfinder/yapf/yapf_node_rail.hpp
View File

@ -17,39 +17,39 @@ struct CYapfRailSegmentKey
{ {
uint32 m_value; uint32 m_value;
FORCEINLINE CYapfRailSegmentKey(const CYapfRailSegmentKey& src) : m_value(src.m_value) {} inline CYapfRailSegmentKey(const CYapfRailSegmentKey& src) : m_value(src.m_value) {}
FORCEINLINE CYapfRailSegmentKey(const CYapfNodeKeyTrackDir& node_key) inline CYapfRailSegmentKey(const CYapfNodeKeyTrackDir& node_key)
{ {
Set(node_key); Set(node_key);
} }
FORCEINLINE void Set(const CYapfRailSegmentKey& src) inline void Set(const CYapfRailSegmentKey& src)
{ {
m_value = src.m_value; m_value = src.m_value;
} }
FORCEINLINE void Set(const CYapfNodeKeyTrackDir& node_key) inline void Set(const CYapfNodeKeyTrackDir& node_key)
{ {
m_value = (((int)node_key.m_tile) << 4) | node_key.m_td; m_value = (((int)node_key.m_tile) << 4) | node_key.m_td;
} }
FORCEINLINE int32 CalcHash() const inline int32 CalcHash() const
{ {
return m_value; return m_value;
} }
FORCEINLINE TileIndex GetTile() const inline TileIndex GetTile() const
{ {
return (TileIndex)(m_value >> 4); return (TileIndex)(m_value >> 4);
} }
FORCEINLINE Trackdir GetTrackdir() const inline Trackdir GetTrackdir() const
{ {
return (Trackdir)(m_value & 0x0F); return (Trackdir)(m_value & 0x0F);
} }
FORCEINLINE bool operator == (const CYapfRailSegmentKey& other) const inline bool operator == (const CYapfRailSegmentKey& other) const
{ {
return m_value == other.m_value; return m_value == other.m_value;
} }
@ -144,7 +144,7 @@ struct CYapfRailSegment
EndSegmentReasonBits m_end_segment_reason; EndSegmentReasonBits m_end_segment_reason;
CYapfRailSegment *m_hash_next; CYapfRailSegment *m_hash_next;
FORCEINLINE CYapfRailSegment(const CYapfRailSegmentKey& key) inline CYapfRailSegment(const CYapfRailSegmentKey& key)
: m_key(key) : m_key(key)
, m_last_tile(INVALID_TILE) , m_last_tile(INVALID_TILE)
, m_last_td(INVALID_TRACKDIR) , m_last_td(INVALID_TRACKDIR)
@ -155,22 +155,22 @@ struct CYapfRailSegment
, m_hash_next(NULL) , m_hash_next(NULL)
{} {}
FORCEINLINE const Key& GetKey() const inline const Key& GetKey() const
{ {
return m_key; return m_key;
} }
FORCEINLINE TileIndex GetTile() const inline TileIndex GetTile() const
{ {
return m_key.GetTile(); return m_key.GetTile();
} }
FORCEINLINE CYapfRailSegment *GetHashNext() inline CYapfRailSegment *GetHashNext()
{ {
return m_hash_next; return m_hash_next;
} }
FORCEINLINE void SetHashNext(CYapfRailSegment *next) inline void SetHashNext(CYapfRailSegment *next)
{ {
m_hash_next = next; m_hash_next = next;
} }
@ -208,7 +208,7 @@ struct CYapfRailNodeT
SignalType m_last_red_signal_type; SignalType m_last_red_signal_type;
SignalType m_last_signal_type; SignalType m_last_signal_type;
FORCEINLINE void Set(CYapfRailNodeT *parent, TileIndex tile, Trackdir td, bool is_choice) inline void Set(CYapfRailNodeT *parent, TileIndex tile, Trackdir td, bool is_choice)
{ {
base::Set(parent, tile, td, is_choice); base::Set(parent, tile, td, is_choice);
m_segment = NULL; m_segment = NULL;
@ -236,19 +236,19 @@ struct CYapfRailNodeT
flags_u.flags_s.m_choice_seen |= is_choice; flags_u.flags_s.m_choice_seen |= is_choice;
} }
FORCEINLINE TileIndex GetLastTile() const inline TileIndex GetLastTile() const
{ {
assert(m_segment != NULL); assert(m_segment != NULL);
return m_segment->m_last_tile; return m_segment->m_last_tile;
} }
FORCEINLINE Trackdir GetLastTrackdir() const inline Trackdir GetLastTrackdir() const
{ {
assert(m_segment != NULL); assert(m_segment != NULL);
return m_segment->m_last_td; return m_segment->m_last_td;
} }
FORCEINLINE void SetLastTileTrackdir(TileIndex tile, Trackdir td) inline void SetLastTileTrackdir(TileIndex tile, Trackdir td)
{ {
assert(m_segment != NULL); assert(m_segment != NULL);
m_segment->m_last_tile = tile; m_segment->m_last_tile = tile;

20
src/pathfinder/yapf/yapf_rail.cpp
View File

@ -47,7 +47,7 @@ public:
protected: protected:
/** to access inherited pathfinder */ /** to access inherited pathfinder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -197,7 +197,7 @@ public:
protected: protected:
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -217,7 +217,7 @@ public:
} }
/** return debug report character to identify the transportation type */ /** return debug report character to identify the transportation type */
FORCEINLINE char TransportTypeChar() const inline char TransportTypeChar() const
{ {
return 't'; return 't';
} }
@ -252,7 +252,7 @@ public:
return result1; return result1;
} }
FORCEINLINE bool FindNearestDepotTwoWay(const Train *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int max_penalty, int reverse_penalty, TileIndex *depot_tile, bool *reversed) inline bool FindNearestDepotTwoWay(const Train *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int max_penalty, int reverse_penalty, TileIndex *depot_tile, bool *reversed)
{ {
/* set origin and destination nodes */ /* set origin and destination nodes */
Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, true); Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, true);
@ -293,7 +293,7 @@ public:
protected: protected:
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -313,7 +313,7 @@ public:
} }
/** Return debug report character to identify the transportation type */ /** Return debug report character to identify the transportation type */
FORCEINLINE char TransportTypeChar() const inline char TransportTypeChar() const
{ {
return 't'; return 't';
} }
@ -376,7 +376,7 @@ public:
protected: protected:
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -396,7 +396,7 @@ public:
} }
/** return debug report character to identify the transportation type */ /** return debug report character to identify the transportation type */
FORCEINLINE char TransportTypeChar() const inline char TransportTypeChar() const
{ {
return 't'; return 't';
} }
@ -422,7 +422,7 @@ public:
return result1; return result1;
} }
FORCEINLINE Trackdir ChooseRailTrack(const Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found, bool reserve_track, PBSTileInfo *target) inline Trackdir ChooseRailTrack(const Train *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found, bool reserve_track, PBSTileInfo *target)
{ {
if (target != NULL) target->tile = INVALID_TILE; if (target != NULL) target->tile = INVALID_TILE;
@ -480,7 +480,7 @@ public:
return result1; return result1;
} }
FORCEINLINE bool CheckReverseTrain(const Train *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty) inline bool CheckReverseTrain(const Train *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty)
{ {
/* create pathfinder instance /* create pathfinder instance
* set origin and destination nodes */ * set origin and destination nodes */

26
src/pathfinder/yapf/yapf_road.cpp
View File

@ -51,7 +51,7 @@ protected:
} }
/** return one tile cost */ /** return one tile cost */
FORCEINLINE int OneTileCost(TileIndex tile, Trackdir trackdir) inline int OneTileCost(TileIndex tile, Trackdir trackdir)
{ {
int cost = 0; int cost = 0;
/* set base cost */ /* set base cost */
@ -100,7 +100,7 @@ public:
* Calculates only the cost of given node, adds it to the parent node cost * Calculates only the cost of given node, adds it to the parent node cost
* and stores the result into Node::m_cost member * and stores the result into Node::m_cost member
*/ */
FORCEINLINE bool PfCalcCost(Node& n, const TrackFollower *tf) inline bool PfCalcCost(Node& n, const TrackFollower *tf)
{ {
int segment_cost = 0; int segment_cost = 0;
uint tiles = 0; uint tiles = 0;
@ -181,13 +181,13 @@ public:
} }
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(Node& n) inline bool PfDetectDestination(Node& n)
{ {
bool bDest = IsRoadDepotTile(n.m_segment_last_tile); bool bDest = IsRoadDepotTile(n.m_segment_last_tile);
return bDest; return bDest;
} }
FORCEINLINE bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir) inline bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir)
{ {
return IsRoadDepotTile(tile); return IsRoadDepotTile(tile);
} }
@ -196,7 +196,7 @@ public:
* Called by YAPF to calculate cost estimate. Calculates distance to the destination * Called by YAPF to calculate cost estimate. Calculates distance to the destination
* adds it to the actual cost from origin and stores the sum to the Node::m_estimate * adds it to the actual cost from origin and stores the sum to the Node::m_estimate
*/ */
FORCEINLINE bool PfCalcEstimate(Node& n) inline bool PfCalcEstimate(Node& n)
{ {
n.m_estimate = n.m_cost; n.m_estimate = n.m_cost;
return true; return true;
@ -245,12 +245,12 @@ protected:
public: public:
/** Called by YAPF to detect if node ends in the desired destination */ /** Called by YAPF to detect if node ends in the desired destination */
FORCEINLINE bool PfDetectDestination(Node& n) inline bool PfDetectDestination(Node& n)
{ {
return PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td); return PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td);
} }
FORCEINLINE bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir) inline bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir)
{ {
if (m_dest_station != INVALID_STATION) { if (m_dest_station != INVALID_STATION) {
return IsTileType(tile, MP_STATION) && return IsTileType(tile, MP_STATION) &&
@ -305,7 +305,7 @@ public:
protected: protected:
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -326,7 +326,7 @@ public:
} }
/** return debug report character to identify the transportation type */ /** return debug report character to identify the transportation type */
FORCEINLINE char TransportTypeChar() const inline char TransportTypeChar() const
{ {
return 'r'; return 'r';
} }
@ -337,7 +337,7 @@ public:
return pf.ChooseRoadTrack(v, tile, enterdir, path_found); return pf.ChooseRoadTrack(v, tile, enterdir, path_found);
} }
FORCEINLINE Trackdir ChooseRoadTrack(const RoadVehicle *v, TileIndex tile, DiagDirection enterdir, bool &path_found) inline Trackdir ChooseRoadTrack(const RoadVehicle *v, TileIndex tile, DiagDirection enterdir, bool &path_found)
{ {
/* Handle special case - when next tile is destination tile. /* Handle special case - when next tile is destination tile.
* However, when going to a station the (initial) destination * However, when going to a station the (initial) destination
@ -384,7 +384,7 @@ public:
return pf.DistanceToTile(v, tile); return pf.DistanceToTile(v, tile);
} }
FORCEINLINE uint DistanceToTile(const RoadVehicle *v, TileIndex dst_tile) inline uint DistanceToTile(const RoadVehicle *v, TileIndex dst_tile)
{ {
/* handle special case - when current tile is the destination tile */ /* handle special case - when current tile is the destination tile */
if (dst_tile == v->tile) { if (dst_tile == v->tile) {
@ -414,7 +414,7 @@ public:
} }
/** Return true if the valid origin (tile/trackdir) was set from the current vehicle position. */ /** Return true if the valid origin (tile/trackdir) was set from the current vehicle position. */
FORCEINLINE bool SetOriginFromVehiclePos(const RoadVehicle *v) inline bool SetOriginFromVehiclePos(const RoadVehicle *v)
{ {
/* set origin (tile, trackdir) */ /* set origin (tile, trackdir) */
TileIndex src_tile = v->tile; TileIndex src_tile = v->tile;
@ -434,7 +434,7 @@ public:
return pf.FindNearestDepot(v, tile, td, max_distance, depot_tile); return pf.FindNearestDepot(v, tile, td, max_distance, depot_tile);
} }
FORCEINLINE bool FindNearestDepot(const RoadVehicle *v, TileIndex tile, Trackdir td, int max_distance, TileIndex *depot_tile) inline bool FindNearestDepot(const RoadVehicle *v, TileIndex tile, Trackdir td, int max_distance, TileIndex *depot_tile)
{ {
/* set origin and destination nodes */ /* set origin and destination nodes */
Yapf().SetOrigin(tile, TrackdirToTrackdirBits(td)); Yapf().SetOrigin(tile, TrackdirToTrackdirBits(td));

6
src/pathfinder/yapf/yapf_ship.cpp
View File

@ -27,7 +27,7 @@ public:
protected: protected:
/** to access inherited path finder */ /** to access inherited path finder */
FORCEINLINE Tpf& Yapf() inline Tpf& Yapf()
{ {
return *static_cast<Tpf*>(this); return *static_cast<Tpf*>(this);
} }
@ -47,7 +47,7 @@ public:
} }
/** return debug report character to identify the transportation type */ /** return debug report character to identify the transportation type */
FORCEINLINE char TransportTypeChar() const inline char TransportTypeChar() const
{ {
return 'w'; return 'w';
} }
@ -123,7 +123,7 @@ public:
* Calculates only the cost of given node, adds it to the parent node cost * Calculates only the cost of given node, adds it to the parent node cost
* and stores the result into Node::m_cost member * and stores the result into Node::m_cost member
*/ */
FORCEINLINE bool PfCalcCost(Node& n, const TrackFollower *tf) inline bool PfCalcCost(Node& n, const TrackFollower *tf)
{ {
/* base tile cost depending on distance */ /* base tile cost depending on distance */
int c = IsDiagonalTrackdir(n.GetTrackdir()) ? YAPF_TILE_LENGTH : YAPF_TILE_CORNER_LENGTH; int c = IsDiagonalTrackdir(n.GetTrackdir()) ? YAPF_TILE_LENGTH : YAPF_TILE_CORNER_LENGTH;

24
src/roadstop_base.h
View File

@ -46,7 +46,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* Get the length of this drive through stop. * Get the length of this drive through stop.
* @return the length in tile units. * @return the length in tile units.
*/ */
FORCEINLINE int GetLength() const inline int GetLength() const
{ {
return this->length; return this->length;
} }
@ -55,7 +55,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* Get the amount of occupied space in this drive through stop. * Get the amount of occupied space in this drive through stop.
* @return the occupied space in tile units. * @return the occupied space in tile units.
*/ */
FORCEINLINE int GetOccupied() const inline int GetOccupied() const
{ {
return this->occupied; return this->occupied;
} }
@ -71,7 +71,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
struct RoadStop *next; ///< Next stop of the given type at this station struct RoadStop *next; ///< Next stop of the given type at this station
/** Initializes a RoadStop */ /** Initializes a RoadStop */
FORCEINLINE RoadStop(TileIndex tile = INVALID_TILE) : inline RoadStop(TileIndex tile = INVALID_TILE) :
xy(tile), xy(tile),
status((1 << RSSFB_BAY_COUNT) - 1) status((1 << RSSFB_BAY_COUNT) - 1)
{ } { }
@ -82,7 +82,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* Checks whether there is a free bay in this road stop * Checks whether there is a free bay in this road stop
* @return is at least one bay free? * @return is at least one bay free?
*/ */
FORCEINLINE bool HasFreeBay() const inline bool HasFreeBay() const
{ {
return GB(this->status, 0, RSSFB_BAY_COUNT) != 0; return GB(this->status, 0, RSSFB_BAY_COUNT) != 0;
} }
@ -92,7 +92,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* @param nr bay to check * @param nr bay to check
* @return is given bay free? * @return is given bay free?
*/ */
FORCEINLINE bool IsFreeBay(uint nr) const inline bool IsFreeBay(uint nr) const
{ {
assert(nr < RSSFB_BAY_COUNT); assert(nr < RSSFB_BAY_COUNT);
return HasBit(this->status, nr); return HasBit(this->status, nr);
@ -102,7 +102,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* Checks whether the entrance of the road stop is occupied by a vehicle * Checks whether the entrance of the road stop is occupied by a vehicle
* @return is entrance busy? * @return is entrance busy?
*/ */
FORCEINLINE bool IsEntranceBusy() const inline bool IsEntranceBusy() const
{ {
return HasBit(this->status, RSSFB_ENTRY_BUSY); return HasBit(this->status, RSSFB_ENTRY_BUSY);
} }
@ -111,7 +111,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* Makes an entrance occupied or free * Makes an entrance occupied or free
* @param busy if true, marks busy; free otherwise * @param busy if true, marks busy; free otherwise
*/ */
FORCEINLINE void SetEntranceBusy(bool busy) inline void SetEntranceBusy(bool busy)
{ {
SB(this->status, RSSFB_ENTRY_BUSY, 1, busy); SB(this->status, RSSFB_ENTRY_BUSY, 1, busy);
} }
@ -121,7 +121,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* @param direction the direciton to get the entry for * @param direction the direciton to get the entry for
* @return the entry * @return the entry
*/ */
FORCEINLINE const Entry *GetEntry(DiagDirection dir) const inline const Entry *GetEntry(DiagDirection dir) const
{ {
return HasBit((int)dir, 1) ? this->west : this->east; return HasBit((int)dir, 1) ? this->west : this->east;
} }
@ -131,7 +131,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* @param direction the direciton to get the entry for * @param direction the direciton to get the entry for
* @return the entry * @return the entry
*/ */
FORCEINLINE Entry *GetEntry(DiagDirection dir) inline Entry *GetEntry(DiagDirection dir)
{ {
return HasBit((int)dir, 1) ? this->west : this->east; return HasBit((int)dir, 1) ? this->west : this->east;
} }
@ -157,7 +157,7 @@ private:
* @return the allocated bay number * @return the allocated bay number
* @pre this->HasFreeBay() * @pre this->HasFreeBay()
*/ */
FORCEINLINE uint AllocateBay() inline uint AllocateBay()
{ {
assert(this->HasFreeBay()); assert(this->HasFreeBay());
@ -173,7 +173,7 @@ private:
* Allocates a bay in a drive-through road stop * Allocates a bay in a drive-through road stop
* @param nr the number of the bay to allocate * @param nr the number of the bay to allocate
*/ */
FORCEINLINE void AllocateDriveThroughBay(uint nr) inline void AllocateDriveThroughBay(uint nr)
{ {
assert(nr < RSSFB_BAY_COUNT); assert(nr < RSSFB_BAY_COUNT);
ClrBit(this->status, nr); ClrBit(this->status, nr);
@ -183,7 +183,7 @@ private:
* Frees the given bay * Frees the given bay
* @param nr the number of the bay to free * @param nr the number of the bay to free
*/ */
FORCEINLINE void FreeBay(uint nr) inline void FreeBay(uint nr)
{ {
assert(nr < RSSFB_BAY_COUNT); assert(nr < RSSFB_BAY_COUNT);
SetBit(this->status, nr); SetBit(this->status, nr);

28
src/roadveh.h
View File

@ -132,7 +132,7 @@ protected: // These functions should not be called outside acceleration code.
* Allows to know the power value that this vehicle will use. * Allows to know the power value that this vehicle will use.
* @return Power value from the engine in HP, or zero if the vehicle is not powered. * @return Power value from the engine in HP, or zero if the vehicle is not powered.
*/ */
FORCEINLINE uint16 GetPower() const inline uint16 GetPower() const
{ {
/* Power is not added for articulated parts */ /* Power is not added for articulated parts */
if (!this->IsArticulatedPart()) { if (!this->IsArticulatedPart()) {
@ -146,7 +146,7 @@ protected: // These functions should not be called outside acceleration code.
* Returns a value if this articulated part is powered. * Returns a value if this articulated part is powered.
* @return Zero, because road vehicles don't have powered parts. * @return Zero, because road vehicles don't have powered parts.
*/ */
FORCEINLINE uint16 GetPoweredPartPower(const RoadVehicle *head) const inline uint16 GetPoweredPartPower(const RoadVehicle *head) const
{ {
return 0; return 0;
} }
@ -155,7 +155,7 @@ protected: // These functions should not be called outside acceleration code.
* Allows to know the weight value that this vehicle will use. * Allows to know the weight value that this vehicle will use.
* @return Weight value from the engine in tonnes. * @return Weight value from the engine in tonnes.
*/ */
FORCEINLINE uint16 GetWeight() const inline uint16 GetWeight() const
{ {
uint16 weight = (CargoSpec::Get(this->cargo_type)->weight * this->cargo.Count()) / 16; uint16 weight = (CargoSpec::Get(this->cargo_type)->weight * this->cargo.Count()) / 16;
@ -172,7 +172,7 @@ protected: // These functions should not be called outside acceleration code.
* Allows to know the tractive effort value that this vehicle will use. * Allows to know the tractive effort value that this vehicle will use.
* @return Tractive effort value from the engine. * @return Tractive effort value from the engine.
*/ */
FORCEINLINE byte GetTractiveEffort() const inline byte GetTractiveEffort() const
{ {
/* The tractive effort coefficient is in units of 1/256. */ /* The tractive effort coefficient is in units of 1/256. */
return GetVehicleProperty(this, PROP_ROADVEH_TRACTIVE_EFFORT, RoadVehInfo(this->engine_type)->tractive_effort); return GetVehicleProperty(this, PROP_ROADVEH_TRACTIVE_EFFORT, RoadVehInfo(this->engine_type)->tractive_effort);
@ -182,7 +182,7 @@ protected: // These functions should not be called outside acceleration code.
* Gets the area used for calculating air drag. * Gets the area used for calculating air drag.
* @return Area of the engine in m^2. * @return Area of the engine in m^2.
*/ */
FORCEINLINE byte GetAirDragArea() const inline byte GetAirDragArea() const
{ {
return 6; return 6;
} }
@ -191,7 +191,7 @@ protected: // These functions should not be called outside acceleration code.
* Gets the air drag coefficient of this vehicle. * Gets the air drag coefficient of this vehicle.
* @return Air drag value from the engine. * @return Air drag value from the engine.
*/ */
FORCEINLINE byte GetAirDrag() const inline byte GetAirDrag() const
{ {
return RoadVehInfo(this->engine_type)->air_drag; return RoadVehInfo(this->engine_type)->air_drag;
} }
@ -200,7 +200,7 @@ protected: // These functions should not be called outside acceleration code.
* Checks the current acceleration status of this vehicle. * Checks the current acceleration status of this vehicle.
* @return Acceleration status. * @return Acceleration status.
*/ */
FORCEINLINE AccelStatus GetAccelerationStatus() const inline AccelStatus GetAccelerationStatus() const
{ {
return (this->vehstatus & VS_STOPPED) ? AS_BRAKE : AS_ACCEL; return (this->vehstatus & VS_STOPPED) ? AS_BRAKE : AS_ACCEL;
} }
@ -209,7 +209,7 @@ protected: // These functions should not be called outside acceleration code.
* Calculates the current speed of this vehicle. * Calculates the current speed of this vehicle.
* @return Current speed in km/h-ish. * @return Current speed in km/h-ish.
*/ */
FORCEINLINE uint16 GetCurrentSpeed() const inline uint16 GetCurrentSpeed() const
{ {
return this->cur_speed / 2; return this->cur_speed / 2;
} }
@ -218,7 +218,7 @@ protected: // These functions should not be called outside acceleration code.
* Returns the rolling friction coefficient of this vehicle. * Returns the rolling friction coefficient of this vehicle.
* @return Rolling friction coefficient in [1e-4]. * @return Rolling friction coefficient in [1e-4].
*/ */
FORCEINLINE uint32 GetRollingFriction() const inline uint32 GetRollingFriction() const
{ {
/* Trams have a slightly greater friction coefficient than trains. /* Trams have a slightly greater friction coefficient than trains.
* The rest of road vehicles have bigger values. */ * The rest of road vehicles have bigger values. */
@ -232,7 +232,7 @@ protected: // These functions should not be called outside acceleration code.
* Allows to know the acceleration type of a vehicle. * Allows to know the acceleration type of a vehicle.
* @return Zero, road vehicles always use a normal acceleration method. * @return Zero, road vehicles always use a normal acceleration method.
*/ */
FORCEINLINE int GetAccelerationType() const inline int GetAccelerationType() const
{ {
return 0; return 0;
} }
@ -241,7 +241,7 @@ protected: // These functions should not be called outside acceleration code.
* Returns the slope steepness used by this vehicle. * Returns the slope steepness used by this vehicle.
* @return Slope steepness used by the vehicle. * @return Slope steepness used by the vehicle.
*/ */
FORCEINLINE uint32 GetSlopeSteepness() const inline uint32 GetSlopeSteepness() const
{ {
return _settings_game.vehicle.roadveh_slope_steepness; return _settings_game.vehicle.roadveh_slope_steepness;
} }
@ -250,7 +250,7 @@ protected: // These functions should not be called outside acceleration code.
* Gets the maximum speed allowed by the track for this vehicle. * Gets the maximum speed allowed by the track for this vehicle.
* @return Since roads don't limit road vehicle speed, it returns always zero. * @return Since roads don't limit road vehicle speed, it returns always zero.
*/ */
FORCEINLINE uint16 GetMaxTrackSpeed() const inline uint16 GetMaxTrackSpeed() const
{ {
return 0; return 0;
} }
@ -259,7 +259,7 @@ protected: // These functions should not be called outside acceleration code.
* Checks if the vehicle is at a tile that can be sloped. * Checks if the vehicle is at a tile that can be sloped.
* @return True if the tile can be sloped. * @return True if the tile can be sloped.
*/ */
FORCEINLINE bool TileMayHaveSlopedTrack() const inline bool TileMayHaveSlopedTrack() const
{ {
TrackStatus ts = GetTileTrackStatus(this->tile, TRANSPORT_ROAD, this->compatible_roadtypes); TrackStatus ts = GetTileTrackStatus(this->tile, TRANSPORT_ROAD, this->compatible_roadtypes);
TrackBits trackbits = TrackStatusToTrackBits(ts); TrackBits trackbits = TrackStatusToTrackBits(ts);
@ -274,7 +274,7 @@ protected: // These functions should not be called outside acceleration code.
* even if it is not reversing. * even if it is not reversing.
* @return are we (possibly) reversing? * @return are we (possibly) reversing?
*/ */
FORCEINLINE bool HasToUseGetSlopePixelZ() inline bool HasToUseGetSlopePixelZ()
{ {
const RoadVehicle *rv = this->First(); const RoadVehicle *rv = this->First();

2
src/roadveh_cmd.cpp
View File

@ -416,7 +416,7 @@ void RoadVehicle::UpdateDeltaXY(Direction direction)
* Calculates the maximum speed of the vehicle under its current conditions. * Calculates the maximum speed of the vehicle under its current conditions.
* @return Maximum speed of the vehicle. * @return Maximum speed of the vehicle.
*/ */
FORCEINLINE int RoadVehicle::GetCurrentMaxSpeed() const inline int RoadVehicle::GetCurrentMaxSpeed() const
{ {
if (_settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) return this->vcache.cached_max_speed; if (_settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) return this->vcache.cached_max_speed;

4
src/saveload/saveload.cpp
View File

@ -278,7 +278,7 @@ struct ReadBuffer {
{ {
} }
FORCEINLINE byte ReadByte() inline byte ReadByte()
{ {
if (this->bufp == this->bufe) { if (this->bufp == this->bufe) {
size_t len = this->reader->Read(this->buf, lengthof(this->buf)); size_t len = this->reader->Read(this->buf, lengthof(this->buf));
@ -318,7 +318,7 @@ struct MemoryDumper {
* Write a single byte into the dumper. * Write a single byte into the dumper.
* @param b The byte to write. * @param b The byte to write.
*/ */
FORCEINLINE void WriteByte(byte b) inline void WriteByte(byte b)
{ {
/* Are we at the end of this chunk? */ /* Are we at the end of this chunk? */
if (this->buf == this->bufe) { if (this->buf == this->bufe) {

8
src/script/api/script_companymode.hpp
View File

@ -19,10 +19,10 @@
* If you create an instance of this class, the company will be switched. * If you create an instance of this class, the company will be switched.
* The original company is stored and recovered from when ever the * The original company is stored and recovered from when ever the
* instance is destroyed. * instance is destroyed.
* All actions performed within the scope of this mode, will be executed * All actions performed within the scope of this mode, will be executed
* on behalf of the company you switched to. This includes any costs * on behalf of the company you switched to. This includes any costs
* attached to the action performed. If the company does not have the * attached to the action performed. If the company does not have the
* funds the action will be aborted. In other words, this is like the * funds the action will be aborted. In other words, this is like the
* real player is executing the commands. * real player is executing the commands.
* If the company is not valid during an action, the error * If the company is not valid during an action, the error
* ERR_PRECONDITION_INVALID_COMPANY will be returned. You can switch to * ERR_PRECONDITION_INVALID_COMPANY will be returned. You can switch to

6
src/smallmap_gui.cpp
View File

@ -598,7 +598,7 @@ class SmallMapWindow : public Window {
static const uint8 FORCE_REFRESH_PERIOD = 0x1F; ///< map is redrawn after that many ticks static const uint8 FORCE_REFRESH_PERIOD = 0x1F; ///< map is redrawn after that many ticks
uint8 refresh; ///< refresh counter, zeroed every FORCE_REFRESH_PERIOD ticks uint8 refresh; ///< refresh counter, zeroed every FORCE_REFRESH_PERIOD ticks
FORCEINLINE Point SmallmapRemapCoords(int x, int y) const inline Point SmallmapRemapCoords(int x, int y) const
{ {
Point pt; Point pt;
pt.x = (y - x) * 2; pt.x = (y - x) * 2;
@ -612,7 +612,7 @@ class SmallMapWindow : public Window {
* @param tile_y Y coordinate of the tile. * @param tile_y Y coordinate of the tile.
* @return Position to draw on. * @return Position to draw on.
*/ */
FORCEINLINE Point RemapTile(int tile_x, int tile_y) const inline Point RemapTile(int tile_x, int tile_y) const
{ {
int x_offset = tile_x - this->scroll_x / (int)TILE_SIZE; int x_offset = tile_x - this->scroll_x / (int)TILE_SIZE;
int y_offset = tile_y - this->scroll_y / (int)TILE_SIZE; int y_offset = tile_y - this->scroll_y / (int)TILE_SIZE;
@ -636,7 +636,7 @@ class SmallMapWindow : public Window {
* @return Tile being displayed at the given position relative to #scroll_x and #scroll_y. * @return Tile being displayed at the given position relative to #scroll_x and #scroll_y.
* @note The #subscroll offset is already accounted for. * @note The #subscroll offset is already accounted for.
*/ */
FORCEINLINE Point PixelToTile(int px, int py, int *sub, bool add_sub = true) const inline Point PixelToTile(int px, int py, int *sub, bool add_sub = true) const
{ {
if (add_sub) px += this->subscroll; // Total horizontal offset. if (add_sub) px += this->subscroll; // Total horizontal offset.

20
src/station_base.h
View File

@ -89,7 +89,7 @@ struct Airport : public TileArea {
} }
/** Check if this airport has at least one hangar. */ /** Check if this airport has at least one hangar. */
FORCEINLINE bool HasHangar() const inline bool HasHangar() const
{ {
return this->GetSpec()->nof_depots > 0; return this->GetSpec()->nof_depots > 0;
} }
@ -102,7 +102,7 @@ struct Airport : public TileArea {
* @param tidc The tilediff to add to the airport tile. * @param tidc The tilediff to add to the airport tile.
* @return The tile of this airport plus the rotated offset. * @return The tile of this airport plus the rotated offset.
*/ */
FORCEINLINE TileIndex GetRotatedTileFromOffset(TileIndexDiffC tidc) const inline TileIndex GetRotatedTileFromOffset(TileIndexDiffC tidc) const
{ {
const AirportSpec *as = this->GetSpec(); const AirportSpec *as = this->GetSpec();
switch (this->rotation) { switch (this->rotation) {
@ -124,7 +124,7 @@ struct Airport : public TileArea {
* @pre hangar_num < GetNumHangars(). * @pre hangar_num < GetNumHangars().
* @return A tile with the given hangar. * @return A tile with the given hangar.
*/ */
FORCEINLINE TileIndex GetHangarTile(uint hangar_num) const inline TileIndex GetHangarTile(uint hangar_num) const
{ {
const AirportSpec *as = this->GetSpec(); const AirportSpec *as = this->GetSpec();
for (uint i = 0; i < as->nof_depots; i++) { for (uint i = 0; i < as->nof_depots; i++) {
@ -141,7 +141,7 @@ struct Airport : public TileArea {
* @pre IsHangarTile(tile). * @pre IsHangarTile(tile).
* @return The exit direction of the hangar, taking airport rotation into account. * @return The exit direction of the hangar, taking airport rotation into account.
*/ */
FORCEINLINE Direction GetHangarExitDirection(TileIndex tile) const inline Direction GetHangarExitDirection(TileIndex tile) const
{ {
const AirportSpec *as = this->GetSpec(); const AirportSpec *as = this->GetSpec();
const HangarTileTable *htt = GetHangarDataByTile(tile); const HangarTileTable *htt = GetHangarDataByTile(tile);
@ -154,14 +154,14 @@ struct Airport : public TileArea {
* @pre IsHangarTile(tile). * @pre IsHangarTile(tile).
* @return The hangar number of the hangar at the given tile. * @return The hangar number of the hangar at the given tile.
*/ */
FORCEINLINE uint GetHangarNum(TileIndex tile) const inline uint GetHangarNum(TileIndex tile) const
{ {
const HangarTileTable *htt = GetHangarDataByTile(tile); const HangarTileTable *htt = GetHangarDataByTile(tile);
return htt->hangar_num; return htt->hangar_num;
} }
/** Get the number of hangars on this airport. */ /** Get the number of hangars on this airport. */
FORCEINLINE uint GetNumHangars() const inline uint GetNumHangars() const
{ {
uint num = 0; uint num = 0;
uint counted = 0; uint counted = 0;
@ -182,7 +182,7 @@ private:
* @return The requested hangar information. * @return The requested hangar information.
* @pre The \a tile must be at a hangar tile at an airport. * @pre The \a tile must be at a hangar tile at an airport.
*/ */
FORCEINLINE const HangarTileTable *GetHangarDataByTile(TileIndex tile) const inline const HangarTileTable *GetHangarDataByTile(TileIndex tile) const
{ {
const AirportSpec *as = this->GetSpec(); const AirportSpec *as = this->GetSpec();
for (uint i = 0; i < as->nof_depots; i++) { for (uint i = 0; i < as->nof_depots; i++) {
@ -245,12 +245,12 @@ public:
uint GetCatchmentRadius() const; uint GetCatchmentRadius() const;
Rect GetCatchmentRect() const; Rect GetCatchmentRect() const;
/* virtual */ FORCEINLINE bool TileBelongsToRailStation(TileIndex tile) const /* virtual */ inline bool TileBelongsToRailStation(TileIndex tile) const
{ {
return IsRailStationTile(tile) && GetStationIndex(tile) == this->index; return IsRailStationTile(tile) && GetStationIndex(tile) == this->index;
} }
FORCEINLINE bool TileBelongsToAirport(TileIndex tile) const inline bool TileBelongsToAirport(TileIndex tile) const
{ {
return IsAirportTile(tile) && GetStationIndex(tile) == this->index; return IsAirportTile(tile) && GetStationIndex(tile) == this->index;
} }
@ -277,7 +277,7 @@ public:
if (!st->TileBelongsToAirport(this->tile)) ++(*this); if (!st->TileBelongsToAirport(this->tile)) ++(*this);
} }
FORCEINLINE TileIterator& operator ++() inline TileIterator& operator ++()
{ {
(*this).OrthogonalTileIterator::operator++(); (*this).OrthogonalTileIterator::operator++();
while (this->tile != INVALID_TILE && !st->TileBelongsToAirport(this->tile)) { while (this->tile != INVALID_TILE && !st->TileBelongsToAirport(this->tile)) {

7
src/stdafx.h
View File

@ -121,7 +121,6 @@
/* Stuff for GCC */ /* Stuff for GCC */
#if defined(__GNUC__) #if defined(__GNUC__)
#define NORETURN __attribute__ ((noreturn)) #define NORETURN __attribute__ ((noreturn))
#define FORCEINLINE inline
#define CDECL #define CDECL
#define __int64 long long #define __int64 long long
#define GCC_PACK __attribute__((packed)) #define GCC_PACK __attribute__((packed))
@ -137,7 +136,6 @@
#if defined(__WATCOMC__) #if defined(__WATCOMC__)
#define NORETURN #define NORETURN
#define FORCEINLINE inline
#define CDECL #define CDECL
#define GCC_PACK #define GCC_PACK
#define WARN_FORMAT(string, args) #define WARN_FORMAT(string, args)
@ -185,8 +183,7 @@
#include <malloc.h> // alloca() #include <malloc.h> // alloca()
#define NORETURN __declspec(noreturn) #define NORETURN __declspec(noreturn)
#define FORCEINLINE __forceinline #define inline __forceinline
#define inline _inline
#if !defined(WINCE) #if !defined(WINCE)
#define CDECL _cdecl #define CDECL _cdecl
@ -448,7 +445,7 @@ void NORETURN CDECL error(const char *str, ...) WARN_FORMAT(1, 2);
* Version of the standard free that accepts const pointers. * Version of the standard free that accepts const pointers.
* @param ptr The data to free. * @param ptr The data to free.
*/ */
static FORCEINLINE void free(const void *ptr) static inline void free(const void *ptr)
{ {
free(const_cast<void *>(ptr)); free(const_cast<void *>(ptr));
} }

6
src/subsidy_base.h
View File

@ -33,18 +33,18 @@ struct Subsidy : SubsidyPool::PoolItem<&_subsidy_pool> {
/** /**
* We need an (empty) constructor so struct isn't zeroed (as C++ standard states) * We need an (empty) constructor so struct isn't zeroed (as C++ standard states)
*/ */
FORCEINLINE Subsidy() { } inline Subsidy() { }
/** /**
* (Empty) destructor has to be defined else operator delete might be called with NULL parameter * (Empty) destructor has to be defined else operator delete might be called with NULL parameter
*/ */
FORCEINLINE ~Subsidy() { } inline ~Subsidy() { }
/** /**
* Tests whether this subsidy has been awarded to someone * Tests whether this subsidy has been awarded to someone
* @return is this subsidy awarded? * @return is this subsidy awarded?
*/ */
FORCEINLINE bool IsAwarded() const inline bool IsAwarded() const
{ {
return this->awarded != INVALID_COMPANY; return this->awarded != INVALID_COMPANY;
} }

4
src/tilearea_type.h
View File

@ -85,7 +85,7 @@ public:
* Get the tile we are currently at. * Get the tile we are currently at.
* @return The tile we are at, or INVALID_TILE when we're done. * @return The tile we are at, or INVALID_TILE when we're done.
*/ */
FORCEINLINE operator TileIndex () const inline operator TileIndex () const
{ {
return this->tile; return this->tile;
} }
@ -120,7 +120,7 @@ public:
/** /**
* Move ourselves to the next tile in the rectange on the map. * Move ourselves to the next tile in the rectange on the map.
*/ */
FORCEINLINE TileIterator& operator ++() inline TileIterator& operator ++()
{ {
assert(this->tile != INVALID_TILE); assert(this->tile != INVALID_TILE);

2
src/tilematrix_type.hpp
View File

@ -137,7 +137,7 @@ public:
} }
/** Array access operator, see #Get. */ /** Array access operator, see #Get. */
FORCEINLINE T &operator[](TileIndex tile) inline T &operator[](TileIndex tile)
{ {
return *this->Get(tile); return *this->Get(tile);
} }

2
src/town.h
View File

@ -133,7 +133,7 @@ struct Town : TownPool::PoolItem<&_town_pool> {
void UpdateVirtCoord(); void UpdateVirtCoord();
static FORCEINLINE Town *GetByTile(TileIndex tile) static inline Town *GetByTile(TileIndex tile)
{ {
return Town::Get(GetTownIndex(tile)); return Town::Get(GetTownIndex(tile));
} }

32
src/train.h
View File

@ -128,7 +128,7 @@ struct Train FINAL : public GroundVehicle<Train, VEH_TRAIN> {
* Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist. * Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.
* @return Next vehicle in the consist. * @return Next vehicle in the consist.
*/ */
FORCEINLINE Train *GetNextUnit() const inline Train *GetNextUnit() const
{ {
Train *v = this->GetNextVehicle(); Train *v = this->GetNextVehicle();
if (v != NULL && v->IsRearDualheaded()) v = v->GetNextVehicle(); if (v != NULL && v->IsRearDualheaded()) v = v->GetNextVehicle();
@ -140,7 +140,7 @@ struct Train FINAL : public GroundVehicle<Train, VEH_TRAIN> {
* Get the previous real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist. * Get the previous real (non-articulated part and non rear part of dualheaded engine) vehicle in the consist.
* @return Previous vehicle in the consist. * @return Previous vehicle in the consist.
*/ */
FORCEINLINE Train *GetPrevUnit() inline Train *GetPrevUnit()
{ {
Train *v = this->GetPrevVehicle(); Train *v = this->GetPrevVehicle();
if (v != NULL && v->IsRearDualheaded()) v = v->GetPrevVehicle(); if (v != NULL && v->IsRearDualheaded()) v = v->GetPrevVehicle();
@ -167,7 +167,7 @@ protected: // These functions should not be called outside acceleration code.
* Allows to know the power value that this vehicle will use. * Allows to know the power value that this vehicle will use.
* @return Power value from the engine in HP, or zero if the vehicle is not powered. * @return Power value from the engine in HP, or zero if the vehicle is not powered.
*/ */
FORCEINLINE uint16 GetPower() const inline uint16 GetPower() const
{ {
/* Power is not added for articulated parts */ /* Power is not added for articulated parts */
if (!this->IsArticulatedPart() && HasPowerOnRail(this->railtype, GetRailType(this->tile))) { if (!this->IsArticulatedPart() && HasPowerOnRail(this->railtype, GetRailType(this->tile))) {
@ -184,7 +184,7 @@ protected: // These functions should not be called outside acceleration code.
* Returns a value if this articulated part is powered. * Returns a value if this articulated part is powered.
* @return Power value from the articulated part in HP, or zero if it is not powered. * @return Power value from the articulated part in HP, or zero if it is not powered.
*/ */
FORCEINLINE uint16 GetPoweredPartPower(const Train *head) const inline uint16 GetPoweredPartPower(const Train *head) const
{ {
/* For powered wagons the engine defines the type of engine (i.e. railtype) */ /* For powered wagons the engine defines the type of engine (i.e. railtype) */
if (HasBit(this->flags, VRF_POWEREDWAGON) && HasPowerOnRail(head->railtype, GetRailType(this->tile))) { if (HasBit(this->flags, VRF_POWEREDWAGON) && HasPowerOnRail(head->railtype, GetRailType(this->tile))) {
@ -198,7 +198,7 @@ protected: // These functions should not be called outside acceleration code.
* Allows to know the weight value that this vehicle will use. * Allows to know the weight value that this vehicle will use.
* @return Weight value from the engine in tonnes. * @return Weight value from the engine in tonnes.
*/ */
FORCEINLINE uint16 GetWeight() const inline uint16 GetWeight() const
{ {
uint16 weight = (CargoSpec::Get(this->cargo_type)->weight * this->cargo.Count() * FreightWagonMult(this->cargo_type)) / 16; uint16 weight = (CargoSpec::Get(this->cargo_type)->weight * this->cargo.Count() * FreightWagonMult(this->cargo_type)) / 16;
@ -219,7 +219,7 @@ protected: // These functions should not be called outside acceleration code.
* Allows to know the tractive effort value that this vehicle will use. * Allows to know the tractive effort value that this vehicle will use.
* @return Tractive effort value from the engine. * @return Tractive effort value from the engine.
*/ */
FORCEINLINE byte GetTractiveEffort() const inline byte GetTractiveEffort() const
{ {
return GetVehicleProperty(this, PROP_TRAIN_TRACTIVE_EFFORT, RailVehInfo(this->engine_type)->tractive_effort); return GetVehicleProperty(this, PROP_TRAIN_TRACTIVE_EFFORT, RailVehInfo(this->engine_type)->tractive_effort);
} }
@ -228,7 +228,7 @@ protected: // These functions should not be called outside acceleration code.
* Gets the area used for calculating air drag. * Gets the area used for calculating air drag.
* @return Area of the engine in m^2. * @return Area of the engine in m^2.
*/ */
FORCEINLINE byte GetAirDragArea() const inline byte GetAirDragArea() const
{ {
/* Air drag is higher in tunnels due to the limited cross-section. */ /* Air drag is higher in tunnels due to the limited cross-section. */
return (this->track == TRACK_BIT_WORMHOLE && this->vehstatus & VS_HIDDEN) ? 28 : 14; return (this->track == TRACK_BIT_WORMHOLE && this->vehstatus & VS_HIDDEN) ? 28 : 14;
@ -238,7 +238,7 @@ protected: // These functions should not be called outside acceleration code.
* Gets the air drag coefficient of this vehicle. * Gets the air drag coefficient of this vehicle.
* @return Air drag value from the engine. * @return Air drag value from the engine.
*/ */
FORCEINLINE byte GetAirDrag() const inline byte GetAirDrag() const
{ {
return RailVehInfo(this->engine_type)->air_drag; return RailVehInfo(this->engine_type)->air_drag;
} }
@ -247,7 +247,7 @@ protected: // These functions should not be called outside acceleration code.
* Checks the current acceleration status of this vehicle. * Checks the current acceleration status of this vehicle.
* @return Acceleration status. * @return Acceleration status.
*/ */
FORCEINLINE AccelStatus GetAccelerationStatus() const inline AccelStatus GetAccelerationStatus() const
{ {
return (this->vehstatus & VS_STOPPED) || HasBit(this->flags, VRF_REVERSING) || HasBit(this->flags, VRF_TRAIN_STUCK) ? AS_BRAKE : AS_ACCEL; return (this->vehstatus & VS_STOPPED) || HasBit(this->flags, VRF_REVERSING) || HasBit(this->flags, VRF_TRAIN_STUCK) ? AS_BRAKE : AS_ACCEL;
} }
@ -256,7 +256,7 @@ protected: // These functions should not be called outside acceleration code.
* Calculates the current speed of this vehicle. * Calculates the current speed of this vehicle.
* @return Current speed in km/h-ish. * @return Current speed in km/h-ish.
*/ */
FORCEINLINE uint16 GetCurrentSpeed() const inline uint16 GetCurrentSpeed() const
{ {
return this->cur_speed; return this->cur_speed;
} }
@ -265,7 +265,7 @@ protected: // These functions should not be called outside acceleration code.
* Returns the rolling friction coefficient of this vehicle. * Returns the rolling friction coefficient of this vehicle.
* @return Rolling friction coefficient in [1e-4]. * @return Rolling friction coefficient in [1e-4].
*/ */
FORCEINLINE uint32 GetRollingFriction() const inline uint32 GetRollingFriction() const
{ {
/* Rolling friction for steel on steel is between 0.1% and 0.2%. /* Rolling friction for steel on steel is between 0.1% and 0.2%.
* The friction coefficient increases with speed in a way that * The friction coefficient increases with speed in a way that
@ -277,7 +277,7 @@ protected: // These functions should not be called outside acceleration code.
* Allows to know the acceleration type of a vehicle. * Allows to know the acceleration type of a vehicle.
* @return Acceleration type of the vehicle. * @return Acceleration type of the vehicle.
*/ */
FORCEINLINE int GetAccelerationType() const inline int GetAccelerationType() const
{ {
return GetRailTypeInfo(this->railtype)->acceleration_type; return GetRailTypeInfo(this->railtype)->acceleration_type;
} }
@ -286,7 +286,7 @@ protected: // These functions should not be called outside acceleration code.
* Returns the slope steepness used by this vehicle. * Returns the slope steepness used by this vehicle.
* @return Slope steepness used by the vehicle. * @return Slope steepness used by the vehicle.
*/ */
FORCEINLINE uint32 GetSlopeSteepness() const inline uint32 GetSlopeSteepness() const
{ {
return _settings_game.vehicle.train_slope_steepness; return _settings_game.vehicle.train_slope_steepness;
} }
@ -295,7 +295,7 @@ protected: // These functions should not be called outside acceleration code.
* Gets the maximum speed allowed by the track for this vehicle. * Gets the maximum speed allowed by the track for this vehicle.
* @return Maximum speed allowed. * @return Maximum speed allowed.
*/ */
FORCEINLINE uint16 GetMaxTrackSpeed() const inline uint16 GetMaxTrackSpeed() const
{ {
return GetRailTypeInfo(GetRailType(this->tile))->max_speed; return GetRailTypeInfo(GetRailType(this->tile))->max_speed;
} }
@ -304,7 +304,7 @@ protected: // These functions should not be called outside acceleration code.
* Checks if the vehicle is at a tile that can be sloped. * Checks if the vehicle is at a tile that can be sloped.
* @return True if the tile can be sloped. * @return True if the tile can be sloped.
*/ */
FORCEINLINE bool TileMayHaveSlopedTrack() const inline bool TileMayHaveSlopedTrack() const
{ {
/* Any track that isn't TRACK_BIT_X or TRACK_BIT_Y cannot be sloped. */ /* Any track that isn't TRACK_BIT_X or TRACK_BIT_Y cannot be sloped. */
return this->track == TRACK_BIT_X || this->track == TRACK_BIT_Y; return this->track == TRACK_BIT_X || this->track == TRACK_BIT_Y;
@ -315,7 +315,7 @@ protected: // These functions should not be called outside acceleration code.
* have always the same direction as the track under them. * have always the same direction as the track under them.
* @return false * @return false
*/ */
FORCEINLINE bool HasToUseGetSlopePixelZ() inline bool HasToUseGetSlopePixelZ()
{ {
return false; return false;
} }

2
src/train_gui.cpp
View File

@ -166,7 +166,7 @@ struct CargoSummaryItem {
StationID source; ///< One of the source stations StationID source; ///< One of the source stations
/** Used by CargoSummary::Find() and similiar functions */ /** Used by CargoSummary::Find() and similiar functions */
FORCEINLINE bool operator != (const CargoSummaryItem &other) const inline bool operator != (const CargoSummaryItem &other) const
{ {
return this->cargo != other.cargo || this->subtype != other.subtype; return this->cargo != other.cargo || this->subtype != other.subtype;
} }

68
src/vehicle_base.h
View File

@ -295,7 +295,7 @@ public:
* @param speed Direction-independent unscaled speed. * @param speed Direction-independent unscaled speed.
* @return speed scaled by movement direction. 256 units are required for each movement step. * @return speed scaled by movement direction. 256 units are required for each movement step.
*/ */
FORCEINLINE uint GetOldAdvanceSpeed(uint speed) inline uint GetOldAdvanceSpeed(uint speed)
{ {
return (this->direction & 1) ? speed : speed * 3 / 4; return (this->direction & 1) ? speed : speed * 3 / 4;
} }
@ -312,7 +312,7 @@ public:
* @param speed Direction-independent unscaled speed. * @param speed Direction-independent unscaled speed.
* @return speed, scaled to match #GetAdvanceDistance(). * @return speed, scaled to match #GetAdvanceDistance().
*/ */
static FORCEINLINE uint GetAdvanceSpeed(uint speed) static inline uint GetAdvanceSpeed(uint speed)
{ {
return speed * 3 / 4; return speed * 3 / 4;
} }
@ -324,7 +324,7 @@ public:
* *
* @return distance to drive for a movement step on the map. * @return distance to drive for a movement step on the map.
*/ */
FORCEINLINE uint GetAdvanceDistance() inline uint GetAdvanceDistance()
{ {
return (this->direction & 1) ? 192 : 256; return (this->direction & 1) ? 192 : 256;
} }
@ -361,7 +361,7 @@ public:
* Invalidates cached NewGRF variables * Invalidates cached NewGRF variables
* @see InvalidateNewGRFCacheOfChain * @see InvalidateNewGRFCacheOfChain
*/ */
FORCEINLINE void InvalidateNewGRFCache() inline void InvalidateNewGRFCache()
{ {
this->grf_cache.cache_valid = 0; this->grf_cache.cache_valid = 0;
} }
@ -370,7 +370,7 @@ public:
* Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle) * Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
* @see InvalidateNewGRFCache * @see InvalidateNewGRFCache
*/ */
FORCEINLINE void InvalidateNewGRFCacheOfChain() inline void InvalidateNewGRFCacheOfChain()
{ {
for (Vehicle *u = this; u != NULL; u = u->Next()) { for (Vehicle *u = this; u != NULL; u = u->Next()) {
u->InvalidateNewGRFCache(); u->InvalidateNewGRFCache();
@ -381,7 +381,7 @@ public:
* Check if the vehicle is a ground vehicle. * Check if the vehicle is a ground vehicle.
* @return True iff the vehicle is a train or a road vehicle. * @return True iff the vehicle is a train or a road vehicle.
*/ */
FORCEINLINE bool IsGroundVehicle() const inline bool IsGroundVehicle() const
{ {
return this->type == VEH_TRAIN || this->type == VEH_ROAD; return this->type == VEH_TRAIN || this->type == VEH_ROAD;
} }
@ -739,7 +739,7 @@ public:
* Check if the vehicle is a front engine. * Check if the vehicle is a front engine.
* @return Returns true if the vehicle is a front engine. * @return Returns true if the vehicle is a front engine.
*/ */
FORCEINLINE bool IsFrontEngine() const inline bool IsFrontEngine() const
{ {
return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT); return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
} }
@ -748,7 +748,7 @@ public:
* Check if the vehicle is an articulated part of an engine. * Check if the vehicle is an articulated part of an engine.
* @return Returns true if the vehicle is an articulated part. * @return Returns true if the vehicle is an articulated part.
*/ */
FORCEINLINE bool IsArticulatedPart() const inline bool IsArticulatedPart() const
{ {
return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART); return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
} }
@ -757,7 +757,7 @@ public:
* Check if an engine has an articulated part. * Check if an engine has an articulated part.
* @return True if the engine has an articulated part. * @return True if the engine has an articulated part.
*/ */
FORCEINLINE bool HasArticulatedPart() const inline bool HasArticulatedPart() const
{ {
return this->Next() != NULL && this->Next()->IsArticulatedPart(); return this->Next() != NULL && this->Next()->IsArticulatedPart();
} }
@ -767,7 +767,7 @@ public:
* @return Next part of the articulated engine. * @return Next part of the articulated engine.
* @pre The vehicle is an articulated engine. * @pre The vehicle is an articulated engine.
*/ */
FORCEINLINE Vehicle *GetNextArticulatedPart() const inline Vehicle *GetNextArticulatedPart() const
{ {
assert(this->HasArticulatedPart()); assert(this->HasArticulatedPart());
return this->Next(); return this->Next();
@ -777,7 +777,7 @@ public:
* Get the first part of an articulated engine. * Get the first part of an articulated engine.
* @return First part of the engine. * @return First part of the engine.
*/ */
FORCEINLINE Vehicle *GetFirstEnginePart() inline Vehicle *GetFirstEnginePart()
{ {
Vehicle *v = this; Vehicle *v = this;
while (v->IsArticulatedPart()) v = v->Previous(); while (v->IsArticulatedPart()) v = v->Previous();
@ -788,7 +788,7 @@ public:
* Get the first part of an articulated engine. * Get the first part of an articulated engine.
* @return First part of the engine. * @return First part of the engine.
*/ */
FORCEINLINE const Vehicle *GetFirstEnginePart() const inline const Vehicle *GetFirstEnginePart() const
{ {
const Vehicle *v = this; const Vehicle *v = this;
while (v->IsArticulatedPart()) v = v->Previous(); while (v->IsArticulatedPart()) v = v->Previous();
@ -799,7 +799,7 @@ public:
* Get the last part of an articulated engine. * Get the last part of an articulated engine.
* @return Last part of the engine. * @return Last part of the engine.
*/ */
FORCEINLINE Vehicle *GetLastEnginePart() inline Vehicle *GetLastEnginePart()
{ {
Vehicle *v = this; Vehicle *v = this;
while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart(); while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
@ -810,7 +810,7 @@ public:
* Get the next real (non-articulated part) vehicle in the consist. * Get the next real (non-articulated part) vehicle in the consist.
* @return Next vehicle in the consist. * @return Next vehicle in the consist.
*/ */
FORCEINLINE Vehicle *GetNextVehicle() const inline Vehicle *GetNextVehicle() const
{ {
const Vehicle *v = this; const Vehicle *v = this;
while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart(); while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
@ -823,7 +823,7 @@ public:
* Get the previous real (non-articulated part) vehicle in the consist. * Get the previous real (non-articulated part) vehicle in the consist.
* @return Previous vehicle in the consist. * @return Previous vehicle in the consist.
*/ */
FORCEINLINE Vehicle *GetPrevVehicle() const inline Vehicle *GetPrevVehicle() const
{ {
Vehicle *v = this->Previous(); Vehicle *v = this->Previous();
while (v != NULL && v->IsArticulatedPart()) v = v->Previous(); while (v != NULL && v->IsArticulatedPart()) v = v->Previous();
@ -858,88 +858,88 @@ struct SpecializedVehicle : public Vehicle {
/** /**
* Set vehicle type correctly * Set vehicle type correctly
*/ */
FORCEINLINE SpecializedVehicle<T, Type>() : Vehicle(Type) { } inline SpecializedVehicle<T, Type>() : Vehicle(Type) { }
/** /**
* Get the first vehicle in the chain * Get the first vehicle in the chain
* @return first vehicle in the chain * @return first vehicle in the chain
*/ */
FORCEINLINE T *First() const { return (T *)this->Vehicle::First(); } inline T *First() const { return (T *)this->Vehicle::First(); }
/** /**
* Get the last vehicle in the chain * Get the last vehicle in the chain
* @return last vehicle in the chain * @return last vehicle in the chain
*/ */
FORCEINLINE T *Last() { return (T *)this->Vehicle::Last(); } inline T *Last() { return (T *)this->Vehicle::Last(); }
/** /**
* Get the last vehicle in the chain * Get the last vehicle in the chain
* @return last vehicle in the chain * @return last vehicle in the chain
*/ */
FORCEINLINE const T *Last() const { return (const T *)this->Vehicle::Last(); } inline const T *Last() const { return (const T *)this->Vehicle::Last(); }
/** /**
* Get next vehicle in the chain * Get next vehicle in the chain
* @return next vehicle in the chain * @return next vehicle in the chain
*/ */
FORCEINLINE T *Next() const { return (T *)this->Vehicle::Next(); } inline T *Next() const { return (T *)this->Vehicle::Next(); }
/** /**
* Get previous vehicle in the chain * Get previous vehicle in the chain
* @return previous vehicle in the chain * @return previous vehicle in the chain
*/ */
FORCEINLINE T *Previous() const { return (T *)this->Vehicle::Previous(); } inline T *Previous() const { return (T *)this->Vehicle::Previous(); }
/** /**
* Get the next part of an articulated engine. * Get the next part of an articulated engine.
* @return Next part of the articulated engine. * @return Next part of the articulated engine.
* @pre The vehicle is an articulated engine. * @pre The vehicle is an articulated engine.
*/ */
FORCEINLINE T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); } inline T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
/** /**
* Get the next part of an articulated engine. * Get the next part of an articulated engine.
* @return Next part of the articulated engine. * @return Next part of the articulated engine.
* @pre The vehicle is an articulated engine. * @pre The vehicle is an articulated engine.
*/ */
FORCEINLINE T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); } inline T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
/** /**
* Get the first part of an articulated engine. * Get the first part of an articulated engine.
* @return First part of the engine. * @return First part of the engine.
*/ */
FORCEINLINE T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); } inline T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
/** /**
* Get the first part of an articulated engine. * Get the first part of an articulated engine.
* @return First part of the engine. * @return First part of the engine.
*/ */
FORCEINLINE const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); } inline const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
/** /**
* Get the last part of an articulated engine. * Get the last part of an articulated engine.
* @return Last part of the engine. * @return Last part of the engine.
*/ */
FORCEINLINE T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); } inline T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
/** /**
* Get the next real (non-articulated part) vehicle in the consist. * Get the next real (non-articulated part) vehicle in the consist.
* @return Next vehicle in the consist. * @return Next vehicle in the consist.
*/ */
FORCEINLINE T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); } inline T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
/** /**
* Get the previous real (non-articulated part) vehicle in the consist. * Get the previous real (non-articulated part) vehicle in the consist.
* @return Previous vehicle in the consist. * @return Previous vehicle in the consist.
*/ */
FORCEINLINE T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); } inline T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
/** /**
* Tests whether given index is a valid index for vehicle of this type * Tests whether given index is a valid index for vehicle of this type
* @param index tested index * @param index tested index
* @return is this index valid index of T? * @return is this index valid index of T?
*/ */
static FORCEINLINE bool IsValidID(size_t index) static inline bool IsValidID(size_t index)
{ {
return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type; return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
} }
@ -948,7 +948,7 @@ struct SpecializedVehicle : public Vehicle {
* Gets vehicle with given index * Gets vehicle with given index
* @return pointer to vehicle with given index casted to T * * @return pointer to vehicle with given index casted to T *
*/ */
static FORCEINLINE T *Get(size_t index) static inline T *Get(size_t index)
{ {
return (T *)Vehicle::Get(index); return (T *)Vehicle::Get(index);
} }
@ -957,7 +957,7 @@ struct SpecializedVehicle : public Vehicle {
* Returns vehicle if the index is a valid index for this vehicle type * Returns vehicle if the index is a valid index for this vehicle type
* @return pointer to vehicle with given index if it's a vehicle of this type * @return pointer to vehicle with given index if it's a vehicle of this type
*/ */
static FORCEINLINE T *GetIfValid(size_t index) static inline T *GetIfValid(size_t index)
{ {
return IsValidID(index) ? Get(index) : NULL; return IsValidID(index) ? Get(index) : NULL;
} }
@ -967,7 +967,7 @@ struct SpecializedVehicle : public Vehicle {
* @param v Vehicle pointer * @param v Vehicle pointer
* @return pointer to SpecializedVehicle * @return pointer to SpecializedVehicle
*/ */
static FORCEINLINE T *From(Vehicle *v) static inline T *From(Vehicle *v)
{ {
assert(v->type == Type); assert(v->type == Type);
return (T *)v; return (T *)v;
@ -978,7 +978,7 @@ struct SpecializedVehicle : public Vehicle {
* @param v Vehicle pointer * @param v Vehicle pointer
* @return pointer to SpecializedVehicle * @return pointer to SpecializedVehicle
*/ */
static FORCEINLINE const T *From(const Vehicle *v) static inline const T *From(const Vehicle *v)
{ {
assert(v->type == Type); assert(v->type == Type);
return (const T *)v; return (const T *)v;
@ -989,7 +989,7 @@ struct SpecializedVehicle : public Vehicle {
* @param moved Was the vehicle moved? * @param moved Was the vehicle moved?
* @param turned Did the vehicle direction change? * @param turned Did the vehicle direction change?
*/ */
FORCEINLINE void UpdateViewport(bool moved, bool turned) inline void UpdateViewport(bool moved, bool turned)
{ {
extern void VehicleMove(Vehicle *v, bool update_viewport); extern void VehicleMove(Vehicle *v, bool update_viewport);

4
src/vehicle_gui.cpp
View File

@ -297,7 +297,7 @@ struct RefitOption {
* @param other Compare to this #RefitOption. * @param other Compare to this #RefitOption.
* @return True if both #RefitOption are different. * @return True if both #RefitOption are different.
*/ */
FORCEINLINE bool operator != (const RefitOption &other) const inline bool operator != (const RefitOption &other) const
{ {
return other.cargo != this->cargo || other.value != this->value; return other.cargo != this->cargo || other.value != this->value;
} }
@ -307,7 +307,7 @@ struct RefitOption {
* @param other Compare to this #RefitOption. * @param other Compare to this #RefitOption.
* @return True if both #RefitOption are equal. * @return True if both #RefitOption are equal.
*/ */
FORCEINLINE bool operator == (const RefitOption &other) const inline bool operator == (const RefitOption &other) const
{ {
return other.cargo == this->cargo && other.value == this->value; return other.cargo == this->cargo && other.value == this->value;
} }

6
src/waypoint_base.h
View File

@ -27,7 +27,7 @@ struct Waypoint FINAL : SpecializedStation<Waypoint, true> {
void UpdateVirtCoord(); void UpdateVirtCoord();
/* virtual */ FORCEINLINE bool TileBelongsToRailStation(TileIndex tile) const /* virtual */ inline bool TileBelongsToRailStation(TileIndex tile) const
{ {
return IsRailWaypointTile(tile) && GetStationIndex(tile) == this->index; return IsRailWaypointTile(tile) && GetStationIndex(tile) == this->index;
} }
@ -50,7 +50,7 @@ struct Waypoint FINAL : SpecializedStation<Waypoint, true> {
* Is this a single tile waypoint? * Is this a single tile waypoint?
* @return true if it is. * @return true if it is.
*/ */
FORCEINLINE bool IsSingleTile() const inline bool IsSingleTile() const
{ {
return (this->facilities & FACIL_TRAIN) != 0 && this->train_station.w == 1 && this->train_station.h == 1; return (this->facilities & FACIL_TRAIN) != 0 && this->train_station.w == 1 && this->train_station.h == 1;
} }
@ -61,7 +61,7 @@ struct Waypoint FINAL : SpecializedStation<Waypoint, true> {
* @param wp The waypoint to compare to. * @param wp The waypoint to compare to.
* @return true iff their types are equal. * @return true iff their types are equal.
*/ */
FORCEINLINE bool IsOfType(const Waypoint *wp) const inline bool IsOfType(const Waypoint *wp) const
{ {
return this->string_id == wp->string_id; return this->string_id == wp->string_id;
} }

26
src/widget_type.h
View File

@ -143,7 +143,7 @@ public:
* @param bottom Amount of additional space below the widget. * @param bottom Amount of additional space below the widget.
* @param left Amount of additional space left of the widget. * @param left Amount of additional space left of the widget.
*/ */
FORCEINLINE void SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left) inline void SetPadding(uint8 top, uint8 right, uint8 bottom, uint8 left)
{ {
this->padding_top = top; this->padding_top = top;
this->padding_right = right; this->padding_right = right;
@ -151,8 +151,8 @@ public:
this->padding_left = left; this->padding_left = left;
} }
FORCEINLINE uint GetHorizontalStepSize(SizingType sizing) const; inline uint GetHorizontalStepSize(SizingType sizing) const;
FORCEINLINE uint GetVerticalStepSize(SizingType sizing) const; inline uint GetVerticalStepSize(SizingType sizing) const;
virtual void Draw(const Window *w) = 0; virtual void Draw(const Window *w) = 0;
virtual void SetDirty(const Window *w) const; virtual void SetDirty(const Window *w) const;
@ -183,14 +183,14 @@ public:
uint8 padding_left; ///< Paddings added to the left of the widget. Managed by parent container widget. uint8 padding_left; ///< Paddings added to the left of the widget. Managed by parent container widget.
protected: protected:
FORCEINLINE void StoreSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height); inline void StoreSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height);
}; };
/** /**
* Get the horizontal sizing step. * Get the horizontal sizing step.
* @param sizing Type of resize being performed. * @param sizing Type of resize being performed.
*/ */
FORCEINLINE uint NWidgetBase::GetHorizontalStepSize(SizingType sizing) const inline uint NWidgetBase::GetHorizontalStepSize(SizingType sizing) const
{ {
return (sizing == ST_RESIZE) ? this->resize_x : this->fill_x; return (sizing == ST_RESIZE) ? this->resize_x : this->fill_x;
} }
@ -199,7 +199,7 @@ FORCEINLINE uint NWidgetBase::GetHorizontalStepSize(SizingType sizing) const
* Get the vertical sizing step. * Get the vertical sizing step.
* @param sizing Type of resize being performed. * @param sizing Type of resize being performed.
*/ */
FORCEINLINE uint NWidgetBase::GetVerticalStepSize(SizingType sizing) const inline uint NWidgetBase::GetVerticalStepSize(SizingType sizing) const
{ {
return (sizing == ST_RESIZE) ? this->resize_y : this->fill_y; return (sizing == ST_RESIZE) ? this->resize_y : this->fill_y;
} }
@ -212,7 +212,7 @@ FORCEINLINE uint NWidgetBase::GetVerticalStepSize(SizingType sizing) const
* @param given_width Width allocated to the widget. * @param given_width Width allocated to the widget.
* @param given_height Height allocated to the widget. * @param given_height Height allocated to the widget.
*/ */
FORCEINLINE void NWidgetBase::StoreSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height) inline void NWidgetBase::StoreSizePosition(SizingType sizing, uint x, uint y, uint given_width, uint given_height)
{ {
this->pos_x = x; this->pos_x = x;
this->pos_y = y; this->pos_y = y;
@ -607,7 +607,7 @@ public:
* Gets the number of elements in the list * Gets the number of elements in the list
* @return the number of elements * @return the number of elements
*/ */
FORCEINLINE uint16 GetCount() const inline uint16 GetCount() const
{ {
return this->count; return this->count;
} }
@ -616,7 +616,7 @@ public:
* Gets the number of visible elements of the scrollbar * Gets the number of visible elements of the scrollbar
* @return the number of visible elements * @return the number of visible elements
*/ */
FORCEINLINE uint16 GetCapacity() const inline uint16 GetCapacity() const
{ {
return this->cap; return this->cap;
} }
@ -625,7 +625,7 @@ public:
* Gets the position of the first visible element in the list * Gets the position of the first visible element in the list
* @return the position of the element * @return the position of the element
*/ */
FORCEINLINE uint16 GetPosition() const inline uint16 GetPosition() const
{ {
return this->pos; return this->pos;
} }
@ -635,7 +635,7 @@ public:
* @param item to check * @param item to check
* @return true iff the item is visible * @return true iff the item is visible
*/ */
FORCEINLINE bool IsVisible(uint16 item) const inline bool IsVisible(uint16 item) const
{ {
return IsInsideBS(item, this->GetPosition(), this->GetCapacity()); return IsInsideBS(item, this->GetPosition(), this->GetCapacity());
} }
@ -644,7 +644,7 @@ public:
* Is the scrollbar vertical or not? * Is the scrollbar vertical or not?
* @return True iff the scrollbar is vertical. * @return True iff the scrollbar is vertical.
*/ */
FORCEINLINE bool IsVertical() const inline bool IsVertical() const
{ {
return this->is_vertical; return this->is_vertical;
} }
@ -789,7 +789,7 @@ private:
* @param step Stepsize of the widget. * @param step Stepsize of the widget.
* @return Biggest possible size of the widget, assuming that \a base may only be incremented by \a step size steps. * @return Biggest possible size of the widget, assuming that \a base may only be incremented by \a step size steps.
*/ */
static FORCEINLINE uint ComputeMaxSize(uint base, uint max_space, uint step) static inline uint ComputeMaxSize(uint base, uint max_space, uint step)
{ {
if (base >= max_space || step == 0) return base; if (base >= max_space || step == 0) return base;
if (step == 1) return max_space; if (step == 1) return max_space;

4
src/window_gui.h
View File

@ -263,7 +263,7 @@ public:
* to destruct them all at the same time too, which is kinda hard. * to destruct them all at the same time too, which is kinda hard.
* @param size the amount of space not to allocate * @param size the amount of space not to allocate
*/ */
FORCEINLINE void *operator new[](size_t size) inline void *operator new[](size_t size)
{ {
NOT_REACHED(); NOT_REACHED();
} }
@ -273,7 +273,7 @@ public:
* Don't free the window directly; it corrupts the linked list when iterating * Don't free the window directly; it corrupts the linked list when iterating
* @param ptr the pointer not to free * @param ptr the pointer not to free
*/ */
FORCEINLINE void operator delete(void *ptr) inline void operator delete(void *ptr)
{ {
} }