summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/3rdparty/squirrel/include/squirrel.h4
-rw-r--r--src/aircraft.h2
-rw-r--r--src/base_station_base.h20
-rw-r--r--src/cargo_type.h8
-rw-r--r--src/cargopacket.cpp4
-rw-r--r--src/cargopacket.h28
-rw-r--r--src/cargotype.h8
-rw-r--r--src/command_type.h12
-rw-r--r--src/company_base.h6
-rw-r--r--src/core/alloc_func.hpp6
-rw-r--r--src/core/alloc_type.hpp16
-rw-r--r--src/core/bitmath_func.hpp30
-rw-r--r--src/core/endian_func.hpp4
-rw-r--r--src/core/enum_type.hpp38
-rw-r--r--src/core/math_func.hpp42
-rw-r--r--src/core/mem_func.hpp12
-rw-r--r--src/core/overflowsafe_type.hpp122
-rw-r--r--src/core/pool_type.hpp30
-rw-r--r--src/core/random_func.hpp14
-rw-r--r--src/core/smallmap_type.hpp20
-rw-r--r--src/core/smallvec_type.hpp42
-rw-r--r--src/core/sort_func.hpp2
-rw-r--r--src/depot_base.h4
-rw-r--r--src/engine_base.h2
-rw-r--r--src/gfx.cpp6
-rw-r--r--src/goal_base.h4
-rw-r--r--src/ground_vehicle.hpp46
-rw-r--r--src/house.h2
-rw-r--r--src/industry.h2
-rw-r--r--src/misc/array.hpp20
-rw-r--r--src/misc/binaryheap.hpp26
-rw-r--r--src/misc/blob.hpp78
-rw-r--r--src/misc/countedptr.hpp38
-rw-r--r--src/misc/fixedsizearray.hpp24
-rw-r--r--src/misc/hashtable.hpp24
-rw-r--r--src/misc/str.hpp18
-rw-r--r--src/newgrf.cpp10
-rw-r--r--src/newgrf_airport.h2
-rw-r--r--src/newgrf_config.h2
-rw-r--r--src/newgrf_gui.cpp2
-rw-r--r--src/pathfinder/follow_track.hpp36
-rw-r--r--src/pathfinder/npf/queue.h4
-rw-r--r--src/pathfinder/pf_performance_timer.hpp22
-rw-r--r--src/pathfinder/yapf/nodelist.hpp26
-rw-r--r--src/pathfinder/yapf/yapf.hpp2
-rw-r--r--src/pathfinder/yapf/yapf_base.hpp34
-rw-r--r--src/pathfinder/yapf/yapf_common.hpp8
-rw-r--r--src/pathfinder/yapf/yapf_costbase.hpp2
-rw-r--r--src/pathfinder/yapf/yapf_costcache.hpp26
-rw-r--r--src/pathfinder/yapf/yapf_costrail.hpp22
-rw-r--r--src/pathfinder/yapf/yapf_destrail.hpp18
-rw-r--r--src/pathfinder/yapf/yapf_node.hpp28
-rw-r--r--src/pathfinder/yapf/yapf_node_rail.hpp34
-rw-r--r--src/pathfinder/yapf/yapf_rail.cpp20
-rw-r--r--src/pathfinder/yapf/yapf_road.cpp26
-rw-r--r--src/pathfinder/yapf/yapf_ship.cpp6
-rw-r--r--src/roadstop_base.h24
-rw-r--r--src/roadveh.h28
-rw-r--r--src/roadveh_cmd.cpp2
-rw-r--r--src/saveload/saveload.cpp4
-rw-r--r--src/script/api/script_companymode.hpp8
-rw-r--r--src/smallmap_gui.cpp6
-rw-r--r--src/station_base.h20
-rw-r--r--src/stdafx.h7
-rw-r--r--src/subsidy_base.h6
-rw-r--r--src/tilearea_type.h4
-rw-r--r--src/tilematrix_type.hpp2
-rw-r--r--src/town.h2
-rw-r--r--src/train.h32
-rw-r--r--src/train_gui.cpp2
-rw-r--r--src/vehicle_base.h68
-rw-r--r--src/vehicle_gui.cpp4
-rw-r--r--src/waypoint_base.h6
-rw-r--r--src/widget_type.h26
-rw-r--r--src/window_gui.h4
75 files changed, 675 insertions, 674 deletions
diff --git a/src/3rdparty/squirrel/include/squirrel.h b/src/3rdparty/squirrel/include/squirrel.h
index fbbaa8e64..3be425304 100644
--- a/src/3rdparty/squirrel/include/squirrel.h
+++ b/src/3rdparty/squirrel/include/squirrel.h
@@ -35,6 +35,10 @@ to the following restrictions:
extern "C" {
#endif
+#if defined(_MSC_VER)
+# define inline __forceinline
+#endif /* _MSC_VER */
+
#if defined(_MSC_VER) && _MSC_VER >= 1400 // MSVC 2005 safety checks
# pragma warning(disable: 4996) // '_wfopen' was declared deprecated
# define _CRT_SECURE_NO_DEPRECATE // all deprecated 'unsafe string functions
diff --git a/src/aircraft.h b/src/aircraft.h
index 3e155eaf9..f47febd62 100644
--- a/src/aircraft.h
+++ b/src/aircraft.h
@@ -90,7 +90,7 @@ struct Aircraft FINAL : public SpecializedVehicle<Aircraft, VEH_AIRCRAFT> {
* @return Returns true if the aircraft is a helicopter/airplane and
* 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,
* but since value can only be 0 or 2, it is sufficient to only check <= 2
diff --git a/src/base_station_base.h b/src/base_station_base.h
index c94212087..7cfd8c2e9 100644
--- a/src/base_station_base.h
+++ b/src/base_station_base.h
@@ -139,7 +139,7 @@ struct BaseStation : StationPool::PoolItem<&_station_pool> {
* @param tile The tile to get the base station from.
* @return the station associated with that tile.
*/
- static FORCEINLINE BaseStation *GetByTile(TileIndex tile)
+ static inline BaseStation *GetByTile(TileIndex tile)
{
return BaseStation::Get(GetStationIndex(tile));
}
@@ -150,7 +150,7 @@ struct BaseStation : StationPool::PoolItem<&_station_pool> {
* facilities left.
* @return true if still in use
*/
- FORCEINLINE bool IsInUse() const
+ inline bool IsInUse() const
{
return (this->facilities & ~FACIL_WAYPOINT) != 0;
}
@@ -172,7 +172,7 @@ struct SpecializedStation : public BaseStation {
* Set station type correctly
* @param tile The base tile of the station.
*/
- FORCEINLINE SpecializedStation<T, Tis_waypoint>(TileIndex tile) :
+ inline SpecializedStation<T, Tis_waypoint>(TileIndex tile) :
BaseStation(tile)
{
this->facilities = EXPECTED_FACIL;
@@ -183,7 +183,7 @@ struct SpecializedStation : public BaseStation {
* @param st the station to check.
* @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;
}
@@ -193,7 +193,7 @@ struct SpecializedStation : public BaseStation {
* @param index tested index
* @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));
}
@@ -202,7 +202,7 @@ struct SpecializedStation : public BaseStation {
* Gets station with given index
* @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);
}
@@ -211,7 +211,7 @@ struct SpecializedStation : public BaseStation {
* 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
*/
- static FORCEINLINE T *GetIfValid(size_t index)
+ static inline T *GetIfValid(size_t index)
{
return IsValidID(index) ? Get(index) : NULL;
}
@@ -221,7 +221,7 @@ struct SpecializedStation : public BaseStation {
* @param tile The tile to get the station from.
* @return the station associated with that tile.
*/
- static FORCEINLINE T *GetByTile(TileIndex tile)
+ static inline T *GetByTile(TileIndex tile)
{
return GetIfValid(GetStationIndex(tile));
}
@@ -231,7 +231,7 @@ struct SpecializedStation : public BaseStation {
* @param st BaseStation pointer
* @return pointer to SpecializedStation
*/
- static FORCEINLINE T *From(BaseStation *st)
+ static inline T *From(BaseStation *st)
{
assert(IsExpected(st));
return (T *)st;
@@ -242,7 +242,7 @@ struct SpecializedStation : public BaseStation {
* @param st BaseStation pointer
* @return pointer to SpecializedStation
*/
- static FORCEINLINE const T *From(const BaseStation *st)
+ static inline const T *From(const BaseStation *st)
{
assert(IsExpected(st));
return (const T *)st;
diff --git a/src/cargo_type.h b/src/cargo_type.h
index c28f798ca..5d3fa9ae5 100644
--- a/src/cargo_type.h
+++ b/src/cargo_type.h
@@ -77,13 +77,13 @@ private:
public:
/** Default constructor. */
- FORCEINLINE CargoArray()
+ inline CargoArray()
{
this->Clear();
}
/** Reset all entries. */
- FORCEINLINE void Clear()
+ inline void Clear()
{
memset(this->amount, 0, sizeof(this->amount));
}
@@ -92,7 +92,7 @@ public:
* Read/write access to an amount of a specific cargo type.
* @param cargo Cargo type to access.
*/
- FORCEINLINE uint &operator[](CargoID cargo)
+ inline uint &operator[](CargoID cargo)
{
return this->amount[cargo];
}
@@ -101,7 +101,7 @@ public:
* Read-only access to an amount of a specific cargo type.
* @param cargo Cargo type to access.
*/
- FORCEINLINE const uint &operator[](CargoID cargo) const
+ inline const uint &operator[](CargoID cargo) const
{
return this->amount[cargo];
}
diff --git a/src/cargopacket.cpp b/src/cargopacket.cpp
index 8bd6b651d..0b92de0c8 100644
--- a/src/cargopacket.cpp
+++ b/src/cargopacket.cpp
@@ -82,7 +82,7 @@ CargoPacket::CargoPacket(uint16 count, byte days_in_transit, StationID source, T
* @param new_size Size of the remaining part.
* @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;
@@ -97,7 +97,7 @@ FORCEINLINE CargoPacket *CargoPacket::Split(uint new_size)
* Merge another packet into this one.
* @param cp Packet to be merged in.
*/
-FORCEINLINE void CargoPacket::Merge(CargoPacket *cp)
+inline void CargoPacket::Merge(CargoPacket *cp)
{
this->count += cp->count;
this->feeder_share += cp->feeder_share;
diff --git a/src/cargopacket.h b/src/cargopacket.h
index 1e3008475..7964ea76a 100644
--- a/src/cargopacket.h
+++ b/src/cargopacket.h
@@ -69,7 +69,7 @@ public:
* Gets the number of 'items' in this packet.
* @return Item count.
*/
- FORCEINLINE uint16 Count() const
+ inline uint16 Count() const
{
return this->count;
}
@@ -79,7 +79,7 @@ public:
* the feeder chain.
* @return Feeder share.
*/
- FORCEINLINE Money FeederShare() const
+ inline Money FeederShare() const
{
return this->feeder_share;
}
@@ -90,7 +90,7 @@ public:
* it is capped at 255.
* @return Length this cargo has been in transit.
*/
- FORCEINLINE byte DaysInTransit() const
+ inline byte DaysInTransit() const
{
return this->days_in_transit;
}
@@ -99,7 +99,7 @@ public:
* Gets the type of the cargo's source. industry, town or head quarter.
* @return Source type.
*/
- FORCEINLINE SourceType SourceSubsidyType() const
+ inline SourceType SourceSubsidyType() const
{
return this->source_type;
}
@@ -108,7 +108,7 @@ public:
* Gets the ID of the cargo's source. An IndustryID, TownID or CompanyID.
* @return Source ID.
*/
- FORCEINLINE SourceID SourceSubsidyID() const
+ inline SourceID SourceSubsidyID() const
{
return this->source_id;
}
@@ -117,7 +117,7 @@ public:
* Gets the ID of the station where the cargo was loaded for the first time.
* @return StationID.
*/
- FORCEINLINE SourceID SourceStation() const
+ inline SourceID SourceStation() const
{
return this->source;
}
@@ -126,7 +126,7 @@ public:
* Gets the coordinates of the cargo's source station.
* @return Source station's coordinates.
*/
- FORCEINLINE TileIndex SourceStationXY() const
+ inline TileIndex SourceStationXY() const
{
return this->source_xy;
}
@@ -135,7 +135,7 @@ public:
* Gets the coordinates of the cargo's last loading station.
* @return Last loading station's coordinates.
*/
- FORCEINLINE TileIndex LoadedAtXY() const
+ inline TileIndex LoadedAtXY() const
{
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).
* @return Pointer to the packet list.
*/
- FORCEINLINE const List *Packets() const
+ inline const List *Packets() const
{
return &this->packets;
}
@@ -212,7 +212,7 @@ public:
* Checks whether this 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;
}
@@ -221,7 +221,7 @@ public:
* Returns the number of cargo entities in this list.
* @return The before mentioned number.
*/
- FORCEINLINE uint Count() const
+ inline uint Count() const
{
return this->count;
}
@@ -230,7 +230,7 @@ public:
* Returns source of the first cargo packet in this list.
* @return The before mentioned source.
*/
- FORCEINLINE StationID Source() const
+ inline StationID Source() const
{
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.
* @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;
}
@@ -277,7 +277,7 @@ public:
* Returns total sum of the feeder share for all packets.
* @return The before mentioned number.
*/
- FORCEINLINE Money FeederShare() const
+ inline Money FeederShare() const
{
return this->feeder_share;
}
diff --git a/src/cargotype.h b/src/cargotype.h
index 1f19d10b3..9521f29d5 100644
--- a/src/cargotype.h
+++ b/src/cargotype.h
@@ -85,7 +85,7 @@ struct CargoSpec {
* Determines index of this cargospec
* @return index (in the CargoSpec::array array)
*/
- FORCEINLINE CargoID Index() const
+ inline CargoID Index() const
{
return this - CargoSpec::array;
}
@@ -95,7 +95,7 @@ struct CargoSpec {
* @return is this cargospec valid?
* @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;
}
@@ -104,7 +104,7 @@ struct CargoSpec {
* Total number of cargospecs, both valid and invalid
* @return length of CargoSpec::array
*/
- static FORCEINLINE size_t GetArraySize()
+ static inline size_t GetArraySize()
{
return lengthof(CargoSpec::array);
}
@@ -114,7 +114,7 @@ struct CargoSpec {
* @param index ID of cargo
* @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));
return &CargoSpec::array[index];
diff --git a/src/command_type.h b/src/command_type.h
index 2e50c5eae..152f66618 100644
--- a/src/command_type.h
+++ b/src/command_type.h
@@ -58,7 +58,7 @@ public:
* Adds the given cost to the cost of the command.
* @param cost the cost to add
*/
- FORCEINLINE void AddCost(const Money &cost)
+ inline void AddCost(const Money &cost)
{
this->cost += cost;
}
@@ -69,7 +69,7 @@ public:
* Multiplies the cost of the command by the given factor.
* @param factor factor to multiply the costs with
*/
- FORCEINLINE void MultiplyCost(int factor)
+ inline void MultiplyCost(int factor)
{
this->cost *= factor;
}
@@ -78,7 +78,7 @@ public:
* The costs as made up to this moment
* @return the costs
*/
- FORCEINLINE Money GetCost() const
+ inline Money GetCost() const
{
return this->cost;
}
@@ -87,7 +87,7 @@ public:
* The expense type of the cost
* @return the expense type
*/
- FORCEINLINE ExpensesType GetExpensesType() const
+ inline ExpensesType GetExpensesType() const
{
return this->expense_type;
}
@@ -137,7 +137,7 @@ public:
* Did this command succeed?
* @return true if and only if it succeeded
*/
- FORCEINLINE bool Succeeded() const
+ inline bool Succeeded() const
{
return this->success;
}
@@ -146,7 +146,7 @@ public:
* Did this command fail?
* @return true if and only if it failed
*/
- FORCEINLINE bool Failed() const
+ inline bool Failed() const
{
return !this->success;
}
diff --git a/src/company_base.h b/src/company_base.h
index f44ae8c22..a5e89e1c8 100644
--- a/src/company_base.h
+++ b/src/company_base.h
@@ -124,7 +124,7 @@ struct Company : CompanyPool::PoolItem<&_company_pool>, CompanyProperties {
* @param index Index in the pool.
* @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);
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.
* @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);
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.
* @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;
}
diff --git a/src/core/alloc_func.hpp b/src/core/alloc_func.hpp
index 4ba8c5f53..c7e17421f 100644
--- a/src/core/alloc_func.hpp
+++ b/src/core/alloc_func.hpp
@@ -56,7 +56,7 @@ static inline void CheckAllocationConstraints(size_t num_elements)
* @return NULL when num_elements == 0, non-NULL otherwise.
*/
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
@@ -84,7 +84,7 @@ static FORCEINLINE T *MallocT(size_t num_elements)
* @return NULL when num_elements == 0, non-NULL otherwise.
*/
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
@@ -110,7 +110,7 @@ static FORCEINLINE T *CallocT(size_t num_elements)
* @return NULL when num_elements == 0, non-NULL otherwise.
*/
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
diff --git a/src/core/alloc_type.hpp b/src/core/alloc_type.hpp
index 9cac62758..6caaf916a 100644
--- a/src/core/alloc_type.hpp
+++ b/src/core/alloc_type.hpp
@@ -48,7 +48,7 @@ struct SmallStackSafeStackAlloc {
* Gets a pointer to the data stored in this wrapper.
* @return the pointer.
*/
- FORCEINLINE operator T *()
+ inline operator T *()
{
return data;
}
@@ -57,7 +57,7 @@ struct SmallStackSafeStackAlloc {
* Gets a pointer to the data stored in this wrapper.
* @return the pointer.
*/
- FORCEINLINE T *operator -> ()
+ inline T *operator -> ()
{
return data;
}
@@ -67,7 +67,7 @@ struct SmallStackSafeStackAlloc {
* @note needed because endof does not work properly for pointers.
* @return the 'endof' pointer.
*/
- FORCEINLINE T *EndOf()
+ inline T *EndOf()
{
#if !defined(__NDS__)
return endof(data);
@@ -137,7 +137,7 @@ public:
* Get the currently allocated buffer.
* @return the buffer
*/
- FORCEINLINE const T *GetBuffer() const
+ inline const T *GetBuffer() const
{
return this->buffer;
}
@@ -158,26 +158,26 @@ public:
* @param size the amount of bytes to allocate.
* @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.
* @param size the amount of bytes to allocate.
* @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.
* @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.
* @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 */
diff --git a/src/core/bitmath_func.hpp b/src/core/bitmath_func.hpp
index d10003007..533f7f279 100644
--- a/src/core/bitmath_func.hpp
+++ b/src/core/bitmath_func.hpp
@@ -29,7 +29,7 @@
* @return The selected bits, aligned to a LSB.
*/
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);
}
@@ -53,7 +53,7 @@ static FORCEINLINE uint GB(const T x, const uint8 s, const uint8 n)
* @return The new value of \a x
*/
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)(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
*/
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);
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.
*/
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;
}
@@ -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
*/
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));
}
@@ -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
*/
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));
}
@@ -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
*/
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));
}
@@ -205,7 +205,7 @@ extern const uint8 _ffb_64[64];
* @return The position of the first bit which is set
* @see FIND_FIRST_BIT
*/
-static FORCEINLINE uint8 FindFirstBit2x64(const int value)
+static inline uint8 FindFirstBit2x64(const int value)
{
if ((value & 0xFF) == 0) {
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
*/
template <typename T>
-static FORCEINLINE T KillFirstBit(T value)
+static inline T KillFirstBit(T value)
{
return value &= (T)(value - 1);
}
@@ -263,7 +263,7 @@ static inline uint CountBits(T value)
* @return does \a value have exactly 1 bit set?
*/
template <typename T>
-static FORCEINLINE bool HasExactlyOneBit(T value)
+static inline bool HasExactlyOneBit(T value)
{
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?
*/
template <typename T>
-static FORCEINLINE bool HasAtMostOneBit(T value)
+static inline bool HasAtMostOneBit(T value)
{
return (value & (value - 1)) == 0;
}
@@ -289,7 +289,7 @@ static FORCEINLINE bool HasAtMostOneBit(T value)
* @return A bit rotated number
*/
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));
}
@@ -303,7 +303,7 @@ static FORCEINLINE T ROL(const T x, const uint8 n)
* @return A bit rotated number
*/
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));
}
@@ -365,7 +365,7 @@ static FORCEINLINE T ROR(const T x, const uint8 n)
* @param x the variable to bitswap
* @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))
/* 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
* @return the bitswapped value.
*/
- static FORCEINLINE uint16 BSWAP16(uint16 x)
+ static inline uint16 BSWAP16(uint16 x)
{
return (x >> 8) | (x << 8);
}
diff --git a/src/core/endian_func.hpp b/src/core/endian_func.hpp
index 186cb2a3b..ab5b18150 100644
--- a/src/core/endian_func.hpp
+++ b/src/core/endian_func.hpp
@@ -40,12 +40,12 @@
#define TO_LE32X(x) (x)
#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);
}
-static FORCEINLINE uint16 ReadLE16Unaligned(const void *x)
+static inline uint16 ReadLE16Unaligned(const void *x)
{
#if OTTD_ALIGNMENT == 1
return ((const byte*)x)[0] | ((const byte*)x)[1] << 8;
diff --git a/src/core/enum_type.hpp b/src/core/enum_type.hpp
index 21518d269..a6332296a 100644
--- a/src/core/enum_type.hpp
+++ b/src/core/enum_type.hpp
@@ -14,13 +14,13 @@
/** Some enums need to have allowed incrementing (i.e. StationClassID) */
#define DECLARE_POSTFIX_INCREMENT(type) \
- FORCEINLINE type operator ++(type& e, int) \
+ inline type operator ++(type& e, int) \
{ \
type e_org = e; \
e = (type)((int)e + 1); \
return e_org; \
} \
- FORCEINLINE type operator --(type& e, int) \
+ inline type operator --(type& e, int) \
{ \
type e_org = e; \
e = (type)((int)e - 1); \
@@ -31,13 +31,13 @@
/** Operators to allow to work with enum as with type safe bit set in C++ */
# define DECLARE_ENUM_AS_BIT_SET(mask_t) \
- FORCEINLINE 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);} \
- FORCEINLINE 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;} \
- FORCEINLINE 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;} \
- FORCEINLINE mask_t operator ~(mask_t m) {return (mask_t)(~(int)m);}
+ inline 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);} \
+ inline 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) {m1 = m1 | m2; return m1;} \
+ inline 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;} \
+ 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
/** 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;
}
/** Assignment operator (from Tenum_t type) */
- FORCEINLINE TinyEnumT& operator = (enum_type e)
+ inline TinyEnumT& operator = (enum_type e)
{
m_val = (storage_type)e;
return *this;
}
/** Assignment operator (from Tenum_t type) */
- FORCEINLINE TinyEnumT& operator = (uint u)
+ inline TinyEnumT& operator = (uint u)
{
m_val = (storage_type)u;
return *this;
}
/** postfix ++ operator on tiny type */
- FORCEINLINE TinyEnumT operator ++ (int)
+ inline TinyEnumT operator ++ (int)
{
TinyEnumT org = *this;
if (++m_val >= end) m_val -= (storage_type)(end - begin);
@@ -126,7 +126,7 @@ struct TinyEnumT {
}
/** prefix ++ operator on tiny type */
- FORCEINLINE TinyEnumT& operator ++ ()
+ inline TinyEnumT& operator ++ ()
{
if (++m_val >= end) m_val -= (storage_type)(end - begin);
return *this;
@@ -140,34 +140,34 @@ struct SimpleTinyEnumT {
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 */
- FORCEINLINE operator enum_type () const
+ inline operator enum_type () const
{
return (enum_type)this->m_val;
}
/** Assignment operator (from enum_type) */
- FORCEINLINE SimpleTinyEnumT &operator = (enum_type e)
+ inline SimpleTinyEnumT &operator = (enum_type e)
{
this->m_val = (storage_type)e;
return *this;
}
/** Assignment operator (from general uint) */
- FORCEINLINE SimpleTinyEnumT &operator = (uint u)
+ inline SimpleTinyEnumT &operator = (uint u)
{
this->m_val = (storage_type)u;
return *this;
}
/** 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);
return *this;
}
/** 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);
return *this;
diff --git a/src/core/math_func.hpp b/src/core/math_func.hpp
index 42c41abad..b613d1e6a 100644
--- a/src/core/math_func.hpp
+++ b/src/core/math_func.hpp
@@ -35,7 +35,7 @@
* @return The greater value or a if equals
*/
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;
}
@@ -51,7 +51,7 @@ static FORCEINLINE T max(const T a, const T b)
* @return The smaller value or b if equals
*/
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;
}
@@ -65,7 +65,7 @@ static FORCEINLINE T min(const T a, const T b)
* @param b The second integer
* @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);
}
@@ -79,7 +79,7 @@ static FORCEINLINE int min(const int a, const int b)
* @param b The second unsigned integer
* @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);
}
@@ -92,7 +92,7 @@ static FORCEINLINE uint minu(const uint a, const uint b)
* @return The unsigned value
*/
template <typename T>
-static FORCEINLINE T abs(const T a)
+static inline T abs(const T 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
*/
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);
n--;
@@ -124,7 +124,7 @@ static FORCEINLINE T Align(const T x, uint n)
* @see Align()
*/
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 *));
return (T *)Align((size_t)x, n);
@@ -148,7 +148,7 @@ static FORCEINLINE T *AlignPtr(T *x, uint n)
* @see Clamp(int, int, int)
*/
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);
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.
* @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);
}
@@ -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.
* @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);
}
@@ -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
* @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);
}
@@ -224,7 +224,7 @@ static FORCEINLINE int32 ClampToI32(const int64 a)
* @return The 64-bit value reduced to a 16-bit value
* @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
* 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
*/
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;
}
@@ -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.
*/
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;
}
@@ -275,7 +275,7 @@ static FORCEINLINE bool IsInsideBS(const T x, const uint base, const uint size)
* @see IsInsideBS()
*/
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);
}
@@ -286,7 +286,7 @@ static FORCEINLINE bool IsInsideMM(const T x, const uint min, const uint max)
* @param b variable to swap with a
*/
template <typename T>
-static FORCEINLINE void Swap(T &a, T &b)
+static inline void Swap(T &a, T &b)
{
T t = a;
a = b;
@@ -298,7 +298,7 @@ static FORCEINLINE void Swap(T &a, T &b)
* @param i value to convert, range 0..255
* @return value in range 0..100
*/
-static FORCEINLINE uint ToPercent8(uint i)
+static inline uint ToPercent8(uint i)
{
assert(i < 256);
return i * 101 >> 8;
@@ -309,7 +309,7 @@ static FORCEINLINE uint ToPercent8(uint i)
* @param i value to convert, range 0..65535
* @return value in range 0..100
*/
-static FORCEINLINE uint ToPercent16(uint i)
+static inline uint ToPercent16(uint i)
{
assert(i < 65536);
return i * 101 >> 16;
@@ -324,7 +324,7 @@ int GreatestCommonDivisor(int a, int b);
* @param b Denominator
* @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;
}
@@ -335,7 +335,7 @@ static FORCEINLINE uint CeilDiv(uint a, uint b)
* @param b Denominator
* @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;
}
@@ -346,7 +346,7 @@ static FORCEINLINE uint Ceil(uint a, uint b)
* @param b Denominator
* @return Quotient, rounded to nearest
*/
-static FORCEINLINE int RoundDivSU(int a, uint b)
+static inline int RoundDivSU(int a, uint b)
{
if (a > 0) {
/* 0.5 is rounded to 1 */
diff --git a/src/core/mem_func.hpp b/src/core/mem_func.hpp
index 42e7b42f4..687871164 100644
--- a/src/core/mem_func.hpp
+++ b/src/core/mem_func.hpp
@@ -22,7 +22,7 @@
* @param num number of items to be copied. (!not number of bytes!)
*/
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));
}
@@ -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!)
*/
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));
}
@@ -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!)
*/
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));
}
@@ -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
*/
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));
}
@@ -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.
*/
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 < ptr2);
@@ -93,7 +93,7 @@ static FORCEINLINE void MemReverseT(T *ptr1, T *ptr2)
* @param num The number of items we want to reverse.
*/
template <typename T>
-static FORCEINLINE void MemReverseT(T *ptr, size_t num)
+static inline void MemReverseT(T *ptr, size_t num)
{
assert(ptr != NULL);
diff --git a/src/core/overflowsafe_type.hpp b/src/core/overflowsafe_type.hpp
index e6a31395a..dda08d96c 100644
--- a/src/core/overflowsafe_type.hpp
+++ b/src/core/overflowsafe_type.hpp
@@ -33,9 +33,9 @@ public:
OverflowSafeInt(const OverflowSafeInt& other) { this->m_value = other.m_value; }
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.
@@ -43,7 +43,7 @@ public:
* @note when the addition would yield more than T_MAX (or less than 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) &&
(this->m_value < 0) == (other.m_value < 0)) {
@@ -55,18 +55,18 @@ public:
}
/* Operators for addition and substraction */
- FORCEINLINE 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; }
- FORCEINLINE OverflowSafeInt operator + (const uint other) const { OverflowSafeInt result = *this; result += (int64)other; return result; }
- FORCEINLINE OverflowSafeInt& operator -= (const OverflowSafeInt& other) { return *this += (-other); }
- FORCEINLINE 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; }
- FORCEINLINE OverflowSafeInt operator - (const uint other) const { OverflowSafeInt result = *this; result -= (int64)other; return result; }
-
- FORCEINLINE OverflowSafeInt& operator ++ () { return *this += 1; }
- FORCEINLINE OverflowSafeInt& operator -- () { return *this += -1; }
- FORCEINLINE OverflowSafeInt operator ++ (int) { OverflowSafeInt org = *this; *this += 1; return org; }
- FORCEINLINE OverflowSafeInt operator -- (int) { OverflowSafeInt org = *this; *this += -1; return org; }
+ inline OverflowSafeInt operator + (const OverflowSafeInt& other) const { OverflowSafeInt result = *this; result += other; return result; }
+ inline OverflowSafeInt operator + (const int 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; }
+ inline OverflowSafeInt& operator -= (const OverflowSafeInt& other) { return *this += (-other); }
+ inline OverflowSafeInt operator - (const OverflowSafeInt& other) const { OverflowSafeInt result = *this; result -= other; return result; }
+ inline OverflowSafeInt operator - (const int 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; }
+
+ inline OverflowSafeInt& operator ++ () { return *this += 1; }
+ inline OverflowSafeInt& operator -- () { return *this += -1; }
+ inline 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.
@@ -74,7 +74,7 @@ public:
* @note when the multiplication would yield more than T_MAX (or less than 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)) {
this->m_value = ((this->m_value < 0) == (factor < 0)) ? T_MAX : T_MIN ;
@@ -85,70 +85,70 @@ public:
}
/* Operators for multiplication */
- FORCEINLINE 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; }
- FORCEINLINE 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; }
- FORCEINLINE OverflowSafeInt operator * (const byte factor) const { OverflowSafeInt result = *this; result *= (int64)factor; return result; }
+ inline OverflowSafeInt operator * (const int64 factor) const { OverflowSafeInt result = *this; result *= factor; return result; }
+ inline OverflowSafeInt operator * (const int 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; }
+ inline OverflowSafeInt operator * (const uint16 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 */
- FORCEINLINE 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; }
- FORCEINLINE 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 int64 divisor) { this->m_value /= divisor; return *this; }
+ inline OverflowSafeInt operator / (const OverflowSafeInt& divisor) const { OverflowSafeInt result = *this; result /= divisor.m_value; return result; }
+ inline OverflowSafeInt operator / (const int divisor) const { OverflowSafeInt result = *this; result /= divisor; return result; }
+ inline OverflowSafeInt operator / (const uint divisor) const { OverflowSafeInt result = *this; result /= (int)divisor; return result; }
/* Operators for modulo */
- FORCEINLINE 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) { this->m_value %= divisor; return *this; }
+ inline OverflowSafeInt operator % (const int divisor) const { OverflowSafeInt result = *this; result %= divisor; return result; }
/* Operators for shifting */
- FORCEINLINE 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; }
- FORCEINLINE 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) { this->m_value <<= shift; return *this; }
+ inline OverflowSafeInt operator << (const int shift) const { OverflowSafeInt result = *this; result <<= shift; return result; }
+ inline OverflowSafeInt& operator >>= (const int shift) { this->m_value >>= shift; return *this; }
+ inline OverflowSafeInt operator >> (const int shift) const { OverflowSafeInt result = *this; result >>= shift; return result; }
/* Operators for (in)equality when comparing overflow safe ints */
- FORCEINLINE bool operator == (const OverflowSafeInt& other) const { return this->m_value == other.m_value; }
- FORCEINLINE bool operator != (const OverflowSafeInt& other) const { return !(*this == other); }
- FORCEINLINE 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; }
- FORCEINLINE 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->m_value == other.m_value; }
+ inline bool operator != (const OverflowSafeInt& other) const { return !(*this == other); }
+ inline 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; }
+ inline 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 */
- FORCEINLINE bool operator == (const int other) const { return this->m_value == other; }
- FORCEINLINE bool operator != (const int other) const { return !(*this == other); }
- FORCEINLINE bool operator > (const int other) const { return this->m_value > other; }
- FORCEINLINE bool operator >= (const int other) const { return this->m_value >= other; }
- FORCEINLINE bool operator < (const int other) const { return !(*this >= other); }
- FORCEINLINE bool operator <= (const int other) const { return !(*this > other); }
-
- FORCEINLINE operator int64 () const { return this->m_value; }
+ inline bool operator == (const int other) const { return this->m_value == other; }
+ inline bool operator != (const int other) const { return !(*this == other); }
+ inline bool operator > (const int other) const { return this->m_value > other; }
+ inline bool operator >= (const int other) const { return this->m_value >= other; }
+ inline bool operator < (const int other) const { return !(*this >= other); }
+ inline bool operator <= (const int other) const { return !(*this > other); }
+
+ inline operator int64 () const { return this->m_value; }
};
/* 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> 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> 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> 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 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> 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> 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 */
-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> 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> 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> 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 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> 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> 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 */
-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> 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> 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> 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 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> 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> 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 */
-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> 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> 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> 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 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> 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> 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;
diff --git a/src/core/pool_type.hpp b/src/core/pool_type.hpp
index f9b1e8230..f4b155842 100644
--- a/src/core/pool_type.hpp
+++ b/src/core/pool_type.hpp
@@ -98,7 +98,7 @@ struct Pool : PoolBase {
* @return pointer to Titem
* @pre index < this->first_unused
*/
- FORCEINLINE Titem *Get(size_t index)
+ inline Titem *Get(size_t index)
{
assert(index < this->first_unused);
return this->data[index];
@@ -109,7 +109,7 @@ struct Pool : PoolBase {
* @param index index to examine
* @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;
}
@@ -119,7 +119,7 @@ struct Pool : PoolBase {
* @param n number of items we want to allocate
* @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;
#ifdef OTTD_ASSERT
@@ -142,7 +142,7 @@ struct Pool : PoolBase {
* @return pointer to allocated memory
* @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);
}
@@ -152,7 +152,7 @@ struct Pool : PoolBase {
* @param p memory to free
* @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;
assert(pn == Tpool->Get(pn->index));
@@ -167,7 +167,7 @@ struct Pool : PoolBase {
* @note can never fail (return NULL), use CanAllocate() to check first!
* @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);
}
@@ -180,7 +180,7 @@ struct Pool : PoolBase {
* @note use of this is strongly discouraged
* @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++) {
/* Don't allow creating new objects over existing.
@@ -202,7 +202,7 @@ struct Pool : PoolBase {
* @param n number of items we want to allocate
* @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);
}
@@ -211,7 +211,7 @@ struct Pool : PoolBase {
* Returns current state of pool cleaning - yes or no
* @return true iff we are cleaning the pool now
*/
- static FORCEINLINE bool CleaningPool()
+ static inline bool CleaningPool()
{
return Tpool->cleaning;
}
@@ -221,7 +221,7 @@ struct Pool : PoolBase {
* @param index index to examine
* @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);
}
@@ -232,7 +232,7 @@ struct Pool : PoolBase {
* @return pointer to Titem
* @pre index < this->first_unused
*/
- static FORCEINLINE Titem *Get(size_t index)
+ static inline Titem *Get(size_t index)
{
return Tpool->Get(index);
}
@@ -243,7 +243,7 @@ struct Pool : PoolBase {
* @return pointer to Titem
* @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;
}
@@ -253,7 +253,7 @@ struct Pool : PoolBase {
* all pool items.
* @return first unused index
*/
- static FORCEINLINE size_t GetPoolSize()
+ static inline size_t GetPoolSize()
{
return Tpool->first_unused;
}
@@ -262,7 +262,7 @@ struct Pool : PoolBase {
* Returns 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;
}
@@ -274,7 +274,7 @@ struct Pool : PoolBase {
* @note when this function is called, PoolItem::Get(index) == NULL.
* @note it's called only when !CleaningPool()
*/
- static FORCEINLINE void PostDestructor(size_t index) { }
+ static inline void PostDestructor(size_t index) { }
};
private:
diff --git a/src/core/random_func.hpp b/src/core/random_func.hpp
index 597efcdc7..8c3bed166 100644
--- a/src/core/random_func.hpp
+++ b/src/core/random_func.hpp
@@ -81,23 +81,23 @@ void SetRandomSeed(uint32 seed);
#define RandomRange(max) DoRandomRange(max, __LINE__, __FILE__)
uint32 DoRandomRange(uint32 max, int line, const char *file);
#else
- static FORCEINLINE uint32 Random()
+ static inline uint32 Random()
{
return _random.Next();
}
- static FORCEINLINE uint32 RandomRange(uint32 max)
+ static inline uint32 RandomRange(uint32 max)
{
return _random.Next(max);
}
#endif
-static FORCEINLINE uint32 InteractiveRandom()
+static inline uint32 InteractiveRandom()
{
return _interactive_random.Next();
}
-static FORCEINLINE uint32 InteractiveRandomRange(uint32 max)
+static inline uint32 InteractiveRandomRange(uint32 max)
{
return _interactive_random.Next(max);
}
@@ -117,7 +117,7 @@ static FORCEINLINE uint32 InteractiveRandomRange(uint32 max)
* @param r The given randomize-number
* @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);
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
#define Chance16(a, b) Chance16I(a, b, DoRandom(__LINE__, __FILE__))
#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());
}
@@ -160,7 +160,7 @@ static FORCEINLINE bool Chance16(const uint a, const uint b)
#ifdef RANDOM_DEBUG
#define Chance16R(a, b, r) (r = DoRandom(__LINE__, __FILE__), Chance16I(a, b, r))
#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();
return Chance16I(a, b, r);
diff --git a/src/core/smallmap_type.hpp b/src/core/smallmap_type.hpp
index f72a8800d..57373c442 100644
--- a/src/core/smallmap_type.hpp
+++ b/src/core/smallmap_type.hpp
@@ -26,7 +26,7 @@ struct SmallPair {
U second;
/** 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;
/** Creates new SmallMap. Data are initialized in SmallVector constructor */
- FORCEINLINE SmallMap() { }
+ inline SmallMap() { }
/** Data are freed in SmallVector destructor */
- FORCEINLINE ~SmallMap() { }
+ inline ~SmallMap() { }
/**
* Finds given key in this map
* @param key key to find
* @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++) {
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
* @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();
}
@@ -77,7 +77,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @param pair pair to remove
* @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());
*pair = this->data[--this->items];
@@ -89,7 +89,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @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!
*/
- FORCEINLINE bool Erase(const T &key)
+ inline bool Erase(const T &key)
{
for (uint i = 0; i < this->items; i++) {
if (key == this->data[i].first) {
@@ -106,7 +106,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @param data data
* @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;
Pair *n = this->Append();
@@ -121,7 +121,7 @@ struct SmallMap : SmallVector<SmallPair<T, U>, S> {
* @return data belonging to this key
* @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++) {
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;
}
- FORCEINLINE void SortByKey()
+ inline void SortByKey()
{
QSortT(this->Begin(), this->items, KeySorter);
}
diff --git a/src/core/smallvec_type.hpp b/src/core/smallvec_type.hpp
index 40793788d..c230b4750 100644
--- a/src/core/smallvec_type.hpp
+++ b/src/core/smallvec_type.hpp
@@ -65,7 +65,7 @@ public:
/**
* Remove all items from the list.
*/
- FORCEINLINE void Clear()
+ inline void Clear()
{
/* In fact we just reset the item counter avoiding the need to
* 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.
*/
- FORCEINLINE void Reset()
+ inline void Reset()
{
this->items = 0;
this->capacity = 0;
@@ -87,7 +87,7 @@ public:
/**
* Compact the list down to the smallest block size boundary.
*/
- FORCEINLINE void Compact()
+ inline void Compact()
{
uint capacity = Align(this->items, S);
if (capacity >= this->capacity) return;
@@ -101,7 +101,7 @@ public:
* @param to_add the number of items to append
* @return pointer to newly allocated item
*/
- FORCEINLINE T *Append(uint to_add = 1)
+ inline T *Append(uint to_add = 1)
{
uint begin = this->items;
this->items += to_add;
@@ -120,7 +120,7 @@ public:
* @param item Item to search for
* @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 *end = this->End();
@@ -134,7 +134,7 @@ public:
* @param item Item to search for
* @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();
const T *end = this->End();
@@ -148,7 +148,7 @@ public:
* @param item Item to search for
* @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;
T *pos = this->Begin();
@@ -166,7 +166,7 @@ public:
* @param item Item to test for
* @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();
}
@@ -176,7 +176,7 @@ public:
* @param item item to remove
* @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());
*item = this->data[--this->items];
@@ -188,7 +188,7 @@ public:
* @param item Item to test for
* @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);
if (!is_member) *this->Append() = item;
@@ -198,7 +198,7 @@ public:
/**
* Get the number of items in the list.
*/
- FORCEINLINE uint Length() const
+ inline uint Length() const
{
return this->items;
}
@@ -208,7 +208,7 @@ public:
*
* @return the pointer to the first item
*/
- FORCEINLINE const T *Begin() const
+ inline const T *Begin() const
{
return this->data;
}
@@ -218,7 +218,7 @@ public:
*
* @return the pointer to the first item
*/
- FORCEINLINE T *Begin()
+ inline T *Begin()
{
return this->data;
}
@@ -228,7 +228,7 @@ public:
*
* @return the pointer behind the last valid item
*/
- FORCEINLINE const T *End() const
+ inline const T *End() const
{
return &this->data[this->items];
}
@@ -238,7 +238,7 @@ public:
*
* @return the pointer behind the last valid item
*/
- FORCEINLINE T *End()
+ inline T *End()
{
return &this->data[this->items];
}
@@ -249,7 +249,7 @@ public:
* @param index the position of 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 */
assert(index <= this->items);
@@ -262,7 +262,7 @@ public:
* @param index the position of 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 */
assert(index <= this->items);
@@ -275,7 +275,7 @@ public:
* @param index the position of the item
* @return the item
*/
- FORCEINLINE const T &operator[](uint index) const
+ inline const T &operator[](uint index) const
{
assert(index < this->items);
return this->data[index];
@@ -287,7 +287,7 @@ public:
* @param index the position of the item
* @return the item
*/
- FORCEINLINE T &operator[](uint index)
+ inline T &operator[](uint index)
{
assert(index < this->items);
return this->data[index];
@@ -316,7 +316,7 @@ public:
/**
* Remove all items from the list.
*/
- FORCEINLINE void Clear()
+ inline void Clear()
{
for (uint i = 0; i < this->items; i++) {
free(this->data[i]);
@@ -347,7 +347,7 @@ public:
/**
* Remove all items from the list.
*/
- FORCEINLINE void Clear()
+ inline void Clear()
{
for (uint i = 0; i < this->items; i++) {
delete this->data[i];
diff --git a/src/core/sort_func.hpp b/src/core/sort_func.hpp
index 94aef195f..4181fd63a 100644
--- a/src/core/sort_func.hpp
+++ b/src/core/sort_func.hpp
@@ -25,7 +25,7 @@
* @param desc Sort descending.
*/
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;
diff --git a/src/depot_base.h b/src/depot_base.h
index 04957c8cb..e5eb3b622 100644
--- a/src/depot_base.h
+++ b/src/depot_base.h
@@ -29,7 +29,7 @@ struct Depot : DepotPool::PoolItem<&_depot_pool> {
Depot(TileIndex xy = INVALID_TILE) : xy(xy) {}
~Depot();
- static FORCEINLINE Depot *GetByTile(TileIndex tile)
+ static inline Depot *GetByTile(TileIndex tile)
{
return Depot::Get(GetDepotIndex(tile));
}
@@ -40,7 +40,7 @@ struct Depot : DepotPool::PoolItem<&_depot_pool> {
* @param d The depot to compare to.
* @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);
}
diff --git a/src/engine_base.h b/src/engine_base.h
index ab4d8252d..b512d4c1b 100644
--- a/src/engine_base.h
+++ b/src/engine_base.h
@@ -116,7 +116,7 @@ struct Engine : EnginePool::PoolItem<&_engine_pool> {
* Check if the engine is a ground 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;
}
diff --git a/src/gfx.cpp b/src/gfx.cpp
index 61fc5ea33..5bb6b38b6 100644
--- a/src/gfx.cpp
+++ b/src/gfx.cpp
@@ -69,7 +69,7 @@ struct DrawStringParams {
* Switch to new colour \a c.
* @param c New colour to use.
*/
- FORCEINLINE void SetColour(TextColour c)
+ inline void SetColour(TextColour c)
{
assert(c >= TC_BLUE && c <= TC_BLACK);
this->prev_colour = this->cur_colour;
@@ -77,7 +77,7 @@ struct DrawStringParams {
}
/** Switch to previous colour. */
- FORCEINLINE void SetPreviousColour()
+ inline void SetPreviousColour()
{
Swap(this->cur_colour, this->prev_colour);
}
@@ -86,7 +86,7 @@ struct DrawStringParams {
* Switch to using a new font \a f.
* @param f New font to use.
*/
- FORCEINLINE void SetFontSize(FontSize f)
+ inline void SetFontSize(FontSize f)
{
this->fontsize = f;
}
diff --git a/src/goal_base.h b/src/goal_base.h
index 7b789abde..13776d22c 100644
--- a/src/goal_base.h
+++ b/src/goal_base.h
@@ -30,12 +30,12 @@ struct Goal : GoalPool::PoolItem<&_goal_pool> {
/**
* 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
*/
- 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)
diff --git a/src/ground_vehicle.hpp b/src/ground_vehicle.hpp
index 94e0c31bb..7f8f2eb25 100644
--- a/src/ground_vehicle.hpp
+++ b/src/ground_vehicle.hpp
@@ -111,7 +111,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
* Calculates the total slope resistance for this vehicle.
* @return Slope resistance.
*/
- FORCEINLINE int32 GetSlopeResistance() const
+ inline int32 GetSlopeResistance() const
{
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,
* directed towards tile centre
*/
- FORCEINLINE void UpdateZPositionAndInclination()
+ inline void UpdateZPositionAndInclination()
{
this->z_pos = GetSlopePixelZ(this->x_pos, this->y_pos);
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
* reversing on a sloped tile.
*/
- FORCEINLINE void UpdateZPosition()
+ inline void UpdateZPosition()
{
#if 0
/* The following code does this: */
@@ -229,7 +229,7 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
* @param turned Indicates if the vehicle has turned.
* @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;
@@ -246,99 +246,99 @@ struct GroundVehicle : public SpecializedVehicle<T, Type> {
/**
* 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.
*/
- FORCEINLINE void ClearFrontEngine() { ClrBit(this->subtype, GVSF_FRONT); }
+ inline void ClearFrontEngine() { ClrBit(this->subtype, GVSF_FRONT); }
/**
* 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.
*/
- 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.
*/
- FORCEINLINE void SetWagon() { SetBit(this->subtype, GVSF_WAGON); }
+ inline void SetWagon() { SetBit(this->subtype, GVSF_WAGON); }
/**
* Clear wagon property.
*/
- FORCEINLINE void ClearWagon() { ClrBit(this->subtype, GVSF_WAGON); }
+ inline void ClearWagon() { ClrBit(this->subtype, GVSF_WAGON); }
/**
* Set engine status.
*/
- FORCEINLINE void SetEngine() { SetBit(this->subtype, GVSF_ENGINE); }
+ inline void SetEngine() { SetBit(this->subtype, GVSF_ENGINE); }
/**
* 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.
*/
- 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.
*/
- 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.
*/
- FORCEINLINE void SetMultiheaded() { SetBit(this->subtype, GVSF_MULTIHEADED); }
+ inline void SetMultiheaded() { SetBit(this->subtype, GVSF_MULTIHEADED); }
/**
* 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).
* @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).
* @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.
* @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.
* @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.
* @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.
* Also mark the widget dirty when that is needed, i.e. when
* the speed of this vehicle has changed.
*/
- FORCEINLINE void SetLastSpeed()
+ inline void SetLastSpeed()
{
if (this->cur_speed != this->gcache.last_speed) {
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.
* @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;
this->subspeed = (byte)spd;
diff --git a/src/house.h b/src/house.h
index f7d2c2ae4..7cb2d291b 100644
--- a/src/house.h
+++ b/src/house.h
@@ -124,7 +124,7 @@ struct HouseSpec {
Money GetRemovalCost() const;
- static FORCEINLINE HouseSpec *Get(size_t house_id)
+ static inline HouseSpec *Get(size_t house_id)
{
assert(house_id < HOUSE_MAX);
extern HouseSpec _house_specs[];
diff --git a/src/industry.h b/src/industry.h
index 85d86a110..92ec7c47c 100644
--- a/src/industry.h
+++ b/src/industry.h
@@ -93,7 +93,7 @@ struct Industry : IndustryPool::PoolItem<&_industry_pool> {
* @pre IsTileType(t, MP_INDUSTRY)
* @return the industry
*/
- static FORCEINLINE Industry *GetByTile(TileIndex tile)
+ static inline Industry *GetByTile(TileIndex tile)
{
return Industry::Get(GetIndustryIndex(tile));
}
diff --git a/src/misc/array.hpp b/src/misc/array.hpp
index 5eae3e488..a3f243e10 100644
--- a/src/misc/array.hpp
+++ b/src/misc/array.hpp
@@ -30,7 +30,7 @@ protected:
SuperArray data; ///< array of arrays of items
/** return first sub-array with free space for new item */
- FORCEINLINE SubArray& FirstFreeSubArray()
+ inline SubArray& FirstFreeSubArray()
{
uint super_size = data.Length();
if (super_size > 0) {
@@ -42,11 +42,11 @@ protected:
public:
/** implicit constructor */
- FORCEINLINE SmallArray() { }
+ inline SmallArray() { }
/** Clear (destroy) all items */
- FORCEINLINE void Clear() {data.Clear();}
+ inline void Clear() {data.Clear();}
/** Return actual number of items */
- FORCEINLINE uint Length() const
+ inline uint Length() const
{
uint super_size = data.Length();
if (super_size == 0) return 0;
@@ -54,22 +54,22 @@ public:
return (super_size - 1) * B + sub_size;
}
/** return true if array is empty */
- FORCEINLINE bool IsEmpty() { return data.IsEmpty(); }
+ inline bool IsEmpty() { return data.IsEmpty(); }
/** 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 */
- FORCEINLINE T *Append() { return FirstFreeSubArray().Append(); }
+ inline T *Append() { return FirstFreeSubArray().Append(); }
/** allocate and construct new item */
- FORCEINLINE T *AppendC() { return FirstFreeSubArray().AppendC(); }
+ inline T *AppendC() { return FirstFreeSubArray().AppendC(); }
/** indexed access (non-const) */
- FORCEINLINE T& operator [] (uint index)
+ inline T& operator [] (uint index)
{
const SubArray& s = data[index / B];
T& item = s[index % B];
return item;
}
/** indexed access (const) */
- FORCEINLINE const T& operator [] (uint index) const
+ inline const T& operator [] (uint index) const
{
const SubArray& s = data[index / B];
const T& item = s[index % B];
diff --git a/src/misc/binaryheap.hpp b/src/misc/binaryheap.hpp
index 55730a2ce..0a2e02ed0 100644
--- a/src/misc/binaryheap.hpp
+++ b/src/misc/binaryheap.hpp
@@ -85,7 +85,7 @@ protected:
* @param item The proposed item for filling the gap
* @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);
@@ -121,7 +121,7 @@ protected:
* @param item The proposed item for filling the gap
* @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);
@@ -142,7 +142,7 @@ protected:
#if BINARYHEAP_CHECK
/** Verify the heap consistency */
- FORCEINLINE void CheckConsistency()
+ inline void CheckConsistency()
{
for (uint child = 2; child <= this->items; child++) {
uint parent = child / 2;
@@ -157,28 +157,28 @@ public:
*
* @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.
*
* @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.
*
* @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.
*
* @return The smallest item, or throw assert if empty.
*/
- FORCEINLINE T *Begin()
+ inline T *Begin()
{
assert(!this->IsEmpty());
return this->data[1];
@@ -191,7 +191,7 @@ public:
*
* @return The last item
*/
- FORCEINLINE T *End()
+ inline T *End()
{
return this->data[1 + this->items];
}
@@ -201,7 +201,7 @@ public:
*
* @param new_item The pointer to the new item
*/
- FORCEINLINE void Include(T *new_item)
+ inline void Include(T *new_item)
{
if (this->IsFull()) {
assert(this->capacity < UINT_MAX / 2);
@@ -222,7 +222,7 @@ public:
*
* @return The pointer to the removed item
*/
- FORCEINLINE T *Shift()
+ inline T *Shift()
{
assert(!this->IsEmpty());
@@ -244,7 +244,7 @@ public:
*
* @param index The position of the item in the heap
*/
- FORCEINLINE void Remove(uint index)
+ inline void Remove(uint index)
{
if (index < this->items) {
assert(index != 0);
@@ -272,7 +272,7 @@ public:
* @param item The reference to the item
* @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;
for (T **ppI = this->data + 1, **ppLast = ppI + this->items; ppI <= ppLast; ppI++) {
@@ -287,7 +287,7 @@ public:
* Make the priority queue empty.
* All remaining items will remain untouched.
*/
- FORCEINLINE void Clear() { this->items = 0; }
+ inline void Clear() { this->items = 0; }
};
#endif /* BINARYHEAP_HPP */
diff --git a/src/misc/blob.hpp b/src/misc/blob.hpp
index 94459a365..0b14a7eae 100644
--- a/src/misc/blob.hpp
+++ b/src/misc/blob.hpp
@@ -71,17 +71,17 @@ public:
static const size_t header_size = sizeof(BlobHeader);
/** default constructor - initializes empty blob */
- FORCEINLINE ByteBlob() { InitEmpty(); }
+ inline ByteBlob() { InitEmpty(); }
/** copy constructor */
- FORCEINLINE ByteBlob(const ByteBlob &src)
+ inline ByteBlob(const ByteBlob &src)
{
InitEmpty();
AppendRaw(src);
}
/** move constructor - take ownership of blob data */
- FORCEINLINE ByteBlob(BlobHeader * const & src)
+ inline ByteBlob(BlobHeader * const & src)
{
assert(src != NULL);
header = src;
@@ -89,14 +89,14 @@ public:
}
/** destructor */
- FORCEINLINE ~ByteBlob()
+ inline ~ByteBlob()
{
Free();
}
protected:
/** 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);
}
@@ -105,13 +105,13 @@ protected:
* Return header pointer to the static BlobHeader with
* both items and capacity containing zero
*/
- static FORCEINLINE BlobHeader *Zero()
+ static inline BlobHeader *Zero()
{
return const_cast<BlobHeader *>(&ByteBlob::hdrEmpty[1]);
}
/** 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 << 5)) return (1 << 5);
@@ -130,7 +130,7 @@ protected:
}
/** 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. */
assert(p != ByteBlob::hdrEmpty);
@@ -140,74 +140,74 @@ protected:
}
/** initialize the empty blob */
- FORCEINLINE void InitEmpty()
+ inline void InitEmpty()
{
header = Zero();
}
/** 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];
}
/** blob header accessor - use it rather than using the pointer arithmetics directly - non-const version */
- FORCEINLINE BlobHeader& Hdr()
+ inline BlobHeader& Hdr()
{
return *(header - 1);
}
/** 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 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;
}
public:
/** return true if blob doesn't contain valid data */
- FORCEINLINE bool IsEmpty() const
+ inline bool IsEmpty() const
{
return Length() == 0;
}
/** return the number of valid data bytes in the blob */
- FORCEINLINE size_t Length() const
+ inline size_t Length() const
{
return Hdr().items;
}
/** return the current blob capacity in bytes */
- FORCEINLINE size_t Capacity() const
+ inline size_t Capacity() const
{
return Hdr().capacity;
}
/** return pointer to the first byte of data - non-const version */
- FORCEINLINE byte *Begin()
+ inline byte *Begin()
{
return data;
}
/** return pointer to the first byte of data - const version */
- FORCEINLINE const byte *Begin() const
+ inline const byte *Begin() const
{
return data;
}
/** invalidate blob's data - doesn't free buffer */
- FORCEINLINE void Clear()
+ inline void Clear()
{
LengthRef() = 0;
}
/** free the blob's memory */
- FORCEINLINE void Free()
+ inline void Free()
{
if (Capacity() > 0) {
RawFree(&Hdr());
@@ -216,7 +216,7 @@ public:
}
/** 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);
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 */
- FORCEINLINE void AppendRaw(const ByteBlob& src)
+ inline void AppendRaw(const ByteBlob& src)
{
if (!src.IsEmpty()) {
memcpy(Append(src.Length()), src.Begin(), src.Length());
@@ -236,7 +236,7 @@ public:
* Reallocate if there is no free space for num_bytes bytes.
* @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;
if (new_size > Capacity()) SmartAlloc(new_size);
@@ -247,7 +247,7 @@ public:
* Increase Length() by num_bytes.
* @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);
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 */
- FORCEINLINE void FixTail() const
+ inline void FixTail() const
{
if (Capacity() > 0) {
byte *p = &data[Length()];
@@ -317,73 +317,73 @@ public:
};
/** Default constructor - makes new Blob ready to accept any data */
- FORCEINLINE CBlobT()
+ inline CBlobT()
: base()
{}
/** Take ownership constructor */
- FORCEINLINE CBlobT(const OnTransfer& ot)
+ inline CBlobT(const OnTransfer& ot)
: base(ot.header)
{}
/** Destructor - ensures that allocated memory (if any) is freed */
- FORCEINLINE ~CBlobT()
+ inline ~CBlobT()
{
Free();
}
/** 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());
}
/** Return pointer to the first data item - non-const version */
- FORCEINLINE T *Data()
+ inline T *Data()
{
return (T*)base::Begin();
}
/** 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 pointer to the index-th data item - non-const version */
- FORCEINLINE T *Data(size_t index)
+ inline T *Data(size_t index)
{
CheckIdx(index);
return (Data() + index);
}
/** 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);
return (Data() + index);
}
/** Return number of items in the Blob */
- FORCEINLINE size_t Size() const
+ inline size_t Size() const
{
return (base::Length() / type_size);
}
/** 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 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);
}
/** 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);
}
@@ -392,12 +392,12 @@ public:
* Ensures that given number of items can be added to the end of Blob. Returns pointer to the
* 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);
}
- FORCEINLINE OnTransfer Transfer()
+ inline OnTransfer Transfer()
{
return OnTransfer(*this);
}
diff --git a/src/misc/countedptr.hpp b/src/misc/countedptr.hpp
index fbf2a40df..0187422df 100644
--- a/src/misc/countedptr.hpp
+++ b/src/misc/countedptr.hpp
@@ -35,64 +35,64 @@ protected:
public:
/** 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) */
- 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 */
- FORCEINLINE ~CCountedPtr() {Release();}
+ inline ~CCountedPtr() {Release();}
protected:
/** 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:
/** 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 */
- 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 */
- 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 */
- 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 */
- FORCEINLINE operator Tcls*() {return m_pT;}
+ inline operator Tcls*() {return m_pT;}
/** 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 */
- FORCEINLINE CCountedPtr& operator = (Tcls *pT) {Assign(pT); return *this;}
+ inline CCountedPtr& operator = (Tcls *pT) {Assign(pT); return *this;}
/** 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 */
- FORCEINLINE void Assign(Tcls *pT);
+ inline void Assign(Tcls *pT);
/** 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 */
- //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 */
- //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 */
- 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 */
- 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_>
-FORCEINLINE void CCountedPtr<Tcls_>::Assign(Tcls *pT)
+inline void CCountedPtr<Tcls_>::Assign(Tcls *pT)
{
/* if they are the same, we do nothing */
if (pT != m_pT) {
diff --git a/src/misc/fixedsizearray.hpp b/src/misc/fixedsizearray.hpp
index a6f4d0c42..4216570b8 100644
--- a/src/misc/fixedsizearray.hpp
+++ b/src/misc/fixedsizearray.hpp
@@ -41,13 +41,13 @@ protected:
T *data;
/** 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) */
- 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 */
- FORCEINLINE uint& RefCnt() { return Hdr().reference_count; }
+ inline uint& RefCnt() { return Hdr().reference_count; }
/** return reference to number of used items */
- FORCEINLINE uint& SizeRef() { return Hdr().items; }
+ inline uint& SizeRef() { return Hdr().items; }
public:
/** Default constructor. Preallocate space for items and header, then initialize header. */
@@ -83,7 +83,7 @@ public:
}
/** Clear (destroy) all items */
- FORCEINLINE void Clear()
+ inline void Clear()
{
/* 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
@@ -96,19 +96,19 @@ public:
}
/** 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 */
- FORCEINLINE bool IsFull() const { return Length() >= C; }
+ inline bool IsFull() const { return Length() >= C; }
/** 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 */
- FORCEINLINE T *Append() { assert(!IsFull()); return &data[SizeRef()++]; }
+ inline T *Append() { assert(!IsFull()); return &data[SizeRef()++]; }
/** 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) */
- 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) */
- 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 */
diff --git a/src/misc/hashtable.hpp b/src/misc/hashtable.hpp
index c59187f4e..60bdcec25 100644
--- a/src/misc/hashtable.hpp
+++ b/src/misc/hashtable.hpp
@@ -21,13 +21,13 @@ struct CHashTableSlotT
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 */
- 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 */
- 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()) {
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 */
- FORCEINLINE Titem_ *Find(const Key& key)
+ inline Titem_ *Find(const Key& key)
{
for (Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
if (pItem->GetKey() == key) {
@@ -51,7 +51,7 @@ struct CHashTableSlotT
}
/** 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);
new_item.SetHashNext(m_pFirst);
@@ -59,7 +59,7 @@ struct CHashTableSlotT
}
/** 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) {
m_pFirst = item_to_remove.GetHashNext();
@@ -81,7 +81,7 @@ struct CHashTableSlotT
}
/** 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? */
if (m_pFirst == NULL) {
@@ -150,13 +150,13 @@ protected:
public:
/* default constructor */
- FORCEINLINE CHashTableT() : m_num_items(0)
+ inline CHashTableT() : m_num_items(0)
{
}
protected:
/** 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();
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 */
- FORCEINLINE static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());}
+ inline static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());}
public:
/** 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() */
- 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 Titem_ *Find(const Tkey& key) const
diff --git a/src/misc/str.hpp b/src/misc/str.hpp
index 1d58b63ae..b109b4e82 100644
--- a/src/misc/str.hpp
+++ b/src/misc/str.hpp
@@ -24,24 +24,24 @@ struct CStrA : public CBlobT<char>
typedef CBlobT<char> base; ///< base class
/** Create an empty CStrT */
- FORCEINLINE CStrA()
+ inline CStrA()
{
}
/** Copy constructor */
- FORCEINLINE CStrA(const CStrA &src) : base(src)
+ inline CStrA(const CStrA &src) : base(src)
{
base::FixTail();
}
/** Take over ownership constructor */
- FORCEINLINE CStrA(const OnTransfer& ot)
+ inline CStrA(const OnTransfer& ot)
: base(ot)
{
}
/** 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);
base::FixTail();
@@ -49,7 +49,7 @@ struct CStrA : public CBlobT<char>
}
/** Append zero-ended C string. */
- FORCEINLINE void AppendStr(const char *str)
+ inline void AppendStr(const char *str)
{
if (!StrEmpty(str)) {
base::AppendRaw(str, strlen(str));
@@ -58,7 +58,7 @@ struct CStrA : public CBlobT<char>
}
/** Append another CStrA. */
- FORCEINLINE void Append(const CStrA &src)
+ inline void Append(const CStrA &src)
{
if (src.Length() > 0) {
base::AppendRaw(src);
@@ -67,7 +67,7 @@ struct CStrA : public CBlobT<char>
}
/** Assignment from C string. */
- FORCEINLINE CStrA &operator = (const char *src)
+ inline CStrA &operator = (const char *src)
{
base::Clear();
AppendStr(src);
@@ -75,7 +75,7 @@ struct CStrA : public CBlobT<char>
}
/** Assignment from another CStrA. */
- FORCEINLINE CStrA &operator = (const CStrA &src)
+ inline CStrA &operator = (const CStrA &src)
{
if (&src != this) {
base::Clear();
@@ -86,7 +86,7 @@ struct CStrA : public CBlobT<char>
}
/** 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;
}
diff --git a/src/newgrf.cpp b/src/newgrf.cpp
index 10fe40359..4d58fe590 100644
--- a/src/newgrf.cpp
+++ b/src/newgrf.cpp
@@ -207,7 +207,7 @@ protected:
public:
ByteReader(byte *data, byte *end) : data(data), end(end) { }
- FORCEINLINE byte ReadByte()
+ inline byte ReadByte()
{
if (data < end) return *(data)++;
throw OTTDByteReaderSignal();
@@ -261,22 +261,22 @@ public:
return string;
}
- FORCEINLINE size_t Remaining() const
+ inline size_t Remaining() const
{
return end - data;
}
- FORCEINLINE bool HasData(size_t count = 1) const
+ inline bool HasData(size_t count = 1) const
{
return data + count <= end;
}
- FORCEINLINE byte *Data()
+ inline byte *Data()
{
return data;
}
- FORCEINLINE void Skip(size_t len)
+ inline void Skip(size_t len)
{
data += len;
/* It is valid to move the buffer to exactly the end of the data,
diff --git a/src/newgrf_airport.h b/src/newgrf_airport.h
index ebd40c9cd..d3899779d 100644
--- a/src/newgrf_airport.h
+++ b/src/newgrf_airport.h
@@ -45,7 +45,7 @@ public:
{
}
- FORCEINLINE TileIterator& operator ++()
+ inline TileIterator& operator ++()
{
this->att++;
if (this->att->ti.x == -0x80) {
diff --git a/src/newgrf_config.h b/src/newgrf_config.h
index 2f54a9958..432f6679d 100644
--- a/src/newgrf_config.h
+++ b/src/newgrf_config.h
@@ -89,7 +89,7 @@ struct GRFIdentifier {
* @param md5sum Expected md5sum, may be \c NULL (in which case, do not check it).
* @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 (md5sum == NULL) return true;
diff --git a/src/newgrf_gui.cpp b/src/newgrf_gui.cpp
index b60bd080f..8bc4bf3fc 100644
--- a/src/newgrf_gui.cpp
+++ b/src/newgrf_gui.cpp
@@ -839,7 +839,7 @@ struct NewGRFWindow : public QueryStringBaseWindow, NewGRFScanCallback {
* @param c grf to display.
* @return Palette for the sprite.
*/
- FORCEINLINE PaletteID GetPalette(const GRFConfig *c) const
+ inline PaletteID GetPalette(const GRFConfig *c) const
{
PaletteID pal;
diff --git a/src/pathfinder/follow_track.hpp b/src/pathfinder/follow_track.hpp
index c32b7b704..1050521d9 100644
--- a/src/pathfinder/follow_track.hpp
+++ b/src/pathfinder/follow_track.hpp
@@ -53,25 +53,25 @@ struct CFollowTrackT
CPerformanceTimer *m_pPerf;
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);
}
- 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;
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));
m_veh = v;
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));
m_veh_owner = o;
@@ -86,16 +86,16 @@ struct CFollowTrackT
m_railtypes = railtype_override;
}
- FORCEINLINE static TransportType TT() {return Ttr_type_;}
- FORCEINLINE static bool IsWaterTT() {return TT() == TRANSPORT_WATER;}
- FORCEINLINE static bool IsRailTT() {return TT() == TRANSPORT_RAIL;}
- FORCEINLINE bool IsTram() {return IsRoadTT() && HasBit(RoadVehicle::From(m_veh)->compatible_roadtypes, ROADTYPE_TRAM);}
- FORCEINLINE static bool IsRoadTT() {return TT() == TRANSPORT_ROAD;}
- FORCEINLINE static bool Allow90degTurns() {return T90deg_turns_allowed_;}
- FORCEINLINE static bool DoTrackMasking() {return IsRailTT() && Tmask_reserved_tracks;}
+ inline static TransportType TT() {return Ttr_type_;}
+ inline static bool IsWaterTT() {return TT() == TRANSPORT_WATER;}
+ inline static bool IsRailTT() {return TT() == TRANSPORT_RAIL;}
+ inline bool IsTram() {return IsRoadTT() && HasBit(RoadVehicle::From(m_veh)->compatible_roadtypes, ROADTYPE_TRAM);}
+ inline static bool IsRoadTT() {return TT() == TRANSPORT_ROAD;}
+ inline static bool Allow90degTurns() {return T90deg_turns_allowed_;}
+ inline static bool DoTrackMasking() {return IsRailTT() && Tmask_reserved_tracks;}
/** 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
@@ -189,7 +189,7 @@ struct CFollowTrackT
protected:
/** 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_tiles_skipped = 0;
@@ -227,7 +227,7 @@ protected:
}
/** stores track status (available trackdirs) for the new tile into m_new_td_bits */
- FORCEINLINE bool QueryNewTileTrackStatus()
+ inline bool QueryNewTileTrackStatus()
{
CPerfStart perf(*m_pPerf);
if (IsRailTT() && IsPlainRailTile(m_new_tile)) {
@@ -257,7 +257,7 @@ protected:
}
/** 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 */
if (IsRoadTT() && IsStandardRoadStopTile(m_old_tile)) {
@@ -289,7 +289,7 @@ protected:
}
/** return true if we can enter m_new_tile from m_exitdir */
- FORCEINLINE bool CanEnterNewTile()
+ inline bool CanEnterNewTile()
{
if (IsRoadTT() && IsStandardRoadStopTile(m_new_tile)) {
/* 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) */
- FORCEINLINE bool ForcedReverse()
+ inline bool ForcedReverse()
{
/* rail and road depots cause reversing */
if (!IsWaterTT() && IsDepotTypeTile(m_old_tile, TT())) {
@@ -417,7 +417,7 @@ protected:
}
/** return true if we successfully reversed at end of road/track */
- FORCEINLINE bool TryReverse()
+ inline bool TryReverse()
{
if (IsRoadTT() && !IsTram()) {
/* if we reached the end of road, we can reverse the RV and continue moving */
diff --git a/src/pathfinder/npf/queue.h b/src/pathfinder/npf/queue.h
index aae70f393..3a5bd1ce9 100644
--- a/src/pathfinder/npf/queue.h
+++ b/src/pathfinder/npf/queue.h
@@ -43,7 +43,7 @@ struct BinaryHeap {
* @param i Element to access (starts at offset \c 1).
* @return Value of the element.
*/
- FORCEINLINE BinaryHeapNode &GetElement(uint i)
+ inline BinaryHeapNode &GetElement(uint i)
{
assert(i > 0);
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.
*/
- FORCEINLINE uint GetSize() const
+ inline uint GetSize() const
{
return this->size;
}
diff --git a/src/pathfinder/pf_performance_timer.hpp b/src/pathfinder/pf_performance_timer.hpp
index 2f4662cbb..808542d25 100644
--- a/src/pathfinder/pf_performance_timer.hpp
+++ b/src/pathfinder/pf_performance_timer.hpp
@@ -21,27 +21,27 @@ struct CPerformanceTimer
CPerformanceTimer() : m_start(0), m_acc(0) {}
- FORCEINLINE void Start()
+ inline void Start()
{
m_start = QueryTime();
}
- FORCEINLINE void Stop()
+ inline void Stop()
{
m_acc += QueryTime() - m_start;
}
- FORCEINLINE int Get(int64 coef)
+ inline int Get(int64 coef)
{
return (int)(m_acc * coef / QueryFrequency());
}
- FORCEINLINE int64 QueryTime()
+ inline int64 QueryTime()
{
return ottd_rdtsc();
}
- FORCEINLINE int64 QueryFrequency()
+ inline int64 QueryFrequency()
{
return ((int64)2200 * 1000000);
}
@@ -51,17 +51,17 @@ struct CPerfStartReal
{
CPerformanceTimer *m_pperf;
- FORCEINLINE CPerfStartReal(CPerformanceTimer& perf) : m_pperf(&perf)
+ inline CPerfStartReal(CPerformanceTimer& perf) : m_pperf(&perf)
{
if (m_pperf != NULL) m_pperf->Start();
}
- FORCEINLINE ~CPerfStartReal()
+ inline ~CPerfStartReal()
{
Stop();
}
- FORCEINLINE void Stop()
+ inline void Stop()
{
if (m_pperf != NULL) {
m_pperf->Stop();
@@ -72,9 +72,9 @@ struct CPerfStartReal
struct CPerfStartFake
{
- FORCEINLINE CPerfStartFake(CPerformanceTimer& perf) {}
- FORCEINLINE ~CPerfStartFake() {}
- FORCEINLINE void Stop() {}
+ inline CPerfStartFake(CPerformanceTimer& perf) {}
+ inline ~CPerfStartFake() {}
+ inline void Stop() {}
};
typedef CPerfStartFake CPerfStart;
diff --git a/src/pathfinder/yapf/nodelist.hpp b/src/pathfinder/yapf/nodelist.hpp
index b81fd65e0..f0924a414 100644
--- a/src/pathfinder/yapf/nodelist.hpp
+++ b/src/pathfinder/yapf/nodelist.hpp
@@ -62,26 +62,26 @@ public:
}
/** return number of open nodes */
- FORCEINLINE int OpenCount()
+ inline int OpenCount()
{
return m_open.Count();
}
/** return number of closed nodes */
- FORCEINLINE int ClosedCount()
+ inline int ClosedCount()
{
return m_closed.Count();
}
/** allocate new data item from m_arr */
- FORCEINLINE Titem_ *CreateNewNode()
+ inline Titem_ *CreateNewNode()
{
if (m_new_node == NULL) m_new_node = m_arr.AppendC();
return m_new_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 */
if (&item == m_new_node) {
@@ -91,7 +91,7 @@ public:
}
/** 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);
m_open.Push(item);
@@ -102,7 +102,7 @@ public:
}
/** return the best open node */
- FORCEINLINE Titem_ *GetBestOpenNode()
+ inline Titem_ *GetBestOpenNode()
{
if (!m_open_queue.IsEmpty()) {
return m_open_queue.Begin();
@@ -111,7 +111,7 @@ public:
}
/** remove and return the best open node */
- FORCEINLINE Titem_ *PopBestOpenNode()
+ inline Titem_ *PopBestOpenNode()
{
if (!m_open_queue.IsEmpty()) {
Titem_ *item = m_open_queue.Shift();
@@ -122,14 +122,14 @@ public:
}
/** 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);
return item;
}
/** 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);
uint idxPop = m_open_queue.FindIndex(item);
@@ -138,23 +138,23 @@ public:
}
/** close node */
- FORCEINLINE void InsertClosedNode(Titem_& item)
+ inline void InsertClosedNode(Titem_& item)
{
assert(m_open.Find(item.GetKey()) == NULL);
m_closed.Push(item);
}
/** 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);
return item;
}
/** The number of items. */
- FORCEINLINE int TotalCount() {return m_arr.Length();}
+ inline int TotalCount() {return m_arr.Length();}
/** 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. */
template <class D> void Dump(D &dmp) const
diff --git a/src/pathfinder/yapf/yapf.hpp b/src/pathfinder/yapf/yapf.hpp
index d3aa53438..be438fc49 100644
--- a/src/pathfinder/yapf/yapf.hpp
+++ b/src/pathfinder/yapf/yapf.hpp
@@ -18,7 +18,7 @@
#include "yapf.h"
//#undef FORCEINLINE
-//#define FORCEINLINE inline
+//#define inline inline
#include "../../misc/blob.hpp"
#include "../../misc/str.hpp"
diff --git a/src/pathfinder/yapf/yapf_base.hpp b/src/pathfinder/yapf/yapf_base.hpp
index b15d563b6..4702c9451 100644
--- a/src/pathfinder/yapf/yapf_base.hpp
+++ b/src/pathfinder/yapf/yapf_base.hpp
@@ -37,11 +37,11 @@ extern int _total_pf_time_us;
* Requrements to your pathfinder class derived from CYapfBaseT:
* -------------------------------------------------------------
* Your pathfinder derived class needs to implement following methods:
- * FORCEINLINE void PfSetStartupNodes()
- * FORCEINLINE void PfFollowNode(Node& org)
- * FORCEINLINE bool PfCalcCost(Node& n)
- * FORCEINLINE bool PfCalcEstimate(Node& n)
- * FORCEINLINE bool PfDetectDestination(Node& n)
+ * inline void PfSetStartupNodes()
+ * inline void PfFollowNode(Node& org)
+ * inline bool PfCalcCost(Node& n)
+ * inline bool PfCalcEstimate(Node& n)
+ * inline bool PfDetectDestination(Node& n)
*
* For more details about those methods, look at the end of CYapfBaseT
* declaration. There are some examples. For another example look at
@@ -80,7 +80,7 @@ public:
public:
/** default constructor */
- FORCEINLINE CYapfBaseT()
+ inline CYapfBaseT()
: m_pBestDestNode(NULL)
, m_pBestIntermediateNode(NULL)
, m_settings(&_settings_game.pf.yapf)
@@ -97,14 +97,14 @@ public:
protected:
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
public:
/** return current settings (can be custom - company based - but later) */
- FORCEINLINE const YAPFSettings& PfGetSettings() const
+ inline const YAPFSettings& PfGetSettings() const
{
return *m_settings;
}
@@ -182,7 +182,7 @@ public:
* 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).
*/
- FORCEINLINE Node *GetBestNode()
+ inline Node *GetBestNode()
{
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
* as argument for AddStartupNode() or AddNewNode()
*/
- FORCEINLINE Node& CreateNewNode()
+ inline Node& CreateNewNode()
{
Node& node = *m_nodes.CreateNewNode();
return node;
}
/** 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);
/* insert the new node only if it is not there */
@@ -212,7 +212,7 @@ public:
}
/** 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);
for (TrackdirBits rtds = tf.m_new_td_bits; rtds != TRACKDIR_BIT_NONE; rtds = KillFirstBit(rtds)) {
@@ -315,7 +315,7 @@ public:
#if 0
/** Example: PfSetStartupNodes() - set source (origin) nodes */
- FORCEINLINE void PfSetStartupNodes()
+ inline void PfSetStartupNodes()
{
/* example: */
Node& n1 = *base::m_nodes.CreateNewNode();
@@ -326,7 +326,7 @@ public:
}
/** 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) {
Node& n = *base::m_nodes.CreateNewNode();
@@ -339,7 +339,7 @@ public:
}
/** 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 */
int cost = ...;
@@ -349,7 +349,7 @@ public:
}
/** 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 */
int distance = ...;
@@ -359,7 +359,7 @@ public:
}
/** 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);
return bDest;
diff --git a/src/pathfinder/yapf/yapf_common.hpp b/src/pathfinder/yapf/yapf_common.hpp
index 12bca905a..b3e9da01c 100644
--- a/src/pathfinder/yapf/yapf_common.hpp
+++ b/src/pathfinder/yapf/yapf_common.hpp
@@ -26,7 +26,7 @@ protected:
TrackdirBits m_orgTrackdirs; ///< origin trackdir mask
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
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
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
@@ -104,7 +104,7 @@ public:
}
/** 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;
}
@@ -140,7 +140,7 @@ protected:
public:
/** 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);
return bDest;
diff --git a/src/pathfinder/yapf/yapf_costbase.hpp b/src/pathfinder/yapf/yapf_costbase.hpp
index 6e249e336..316d1476c 100644
--- a/src/pathfinder/yapf/yapf_costbase.hpp
+++ b/src/pathfinder/yapf/yapf_costbase.hpp
@@ -20,7 +20,7 @@ struct CYapfCostBase {
* @param td The track direction to check.
* @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 (IsBridgeTile(tile)) {
diff --git a/src/pathfinder/yapf/yapf_costcache.hpp b/src/pathfinder/yapf/yapf_costcache.hpp
index ee4cee25c..7a568b703 100644
--- a/src/pathfinder/yapf/yapf_costcache.hpp
+++ b/src/pathfinder/yapf/yapf_costcache.hpp
@@ -30,7 +30,7 @@ public:
* 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
*/
- FORCEINLINE bool PfNodeCacheFetch(Node& n)
+ inline bool PfNodeCacheFetch(Node& n)
{
return false;
}
@@ -39,7 +39,7 @@ public:
* Called by YAPF to flush the cached segment cost data back into cache storage.
* 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;
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
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.
* @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());
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.
* 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;
Heap m_heap;
- FORCEINLINE CSegmentCostCacheT() {}
+ inline CSegmentCostCacheT() {}
/** flush (clear) the cache */
- FORCEINLINE void Flush()
+ inline void Flush()
{
m_map.Clear();
m_heap.Clear();
}
- FORCEINLINE Tsegment& Get(Key& key, bool *found)
+ inline Tsegment& Get(Key& key, bool *found)
{
Tsegment *item = m_map.Find(key);
if (item == NULL) {
@@ -177,15 +177,15 @@ public:
protected:
Cache& m_global_cache;
- FORCEINLINE CYapfSegmentCostCacheGlobalT() : m_global_cache(stGetGlobalCache()) {};
+ inline CYapfSegmentCostCacheGlobalT() : m_global_cache(stGetGlobalCache()) {};
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
- FORCEINLINE static Cache& stGetGlobalCache()
+ inline static Cache& stGetGlobalCache()
{
static int last_rail_change_counter = 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.
* @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)) {
return Tlocal::PfNodeCacheFetch(n);
@@ -227,7 +227,7 @@ public:
* Called by YAPF to flush the cached segment cost data back into cache storage.
* Current cache implementation doesn't use that.
*/
- FORCEINLINE void PfNodeCacheFlush(Node& n)
+ inline void PfNodeCacheFlush(Node& n)
{
}
};
diff --git a/src/pathfinder/yapf/yapf_costrail.hpp b/src/pathfinder/yapf/yapf_costrail.hpp
index f1b6565f2..44647443b 100644
--- a/src/pathfinder/yapf/yapf_costrail.hpp
+++ b/src/pathfinder/yapf/yapf_costrail.hpp
@@ -96,14 +96,14 @@ protected:
}
public:
- FORCEINLINE int SlopeCost(TileIndex tile, Trackdir td)
+ inline int SlopeCost(TileIndex tile, Trackdir td)
{
CPerfStart perf_cost(Yapf().m_perf_slope_cost);
if (!stSlopeCost(tile, td)) return 0;
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(td2));
@@ -119,7 +119,7 @@ public:
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)) {
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). */
- FORCEINLINE int OneTileCost(TileIndex& tile, Trackdir trackdir)
+ inline int OneTileCost(TileIndex& tile, Trackdir trackdir)
{
int cost = 0;
/* set base cost */
@@ -155,7 +155,7 @@ public:
}
/** 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)));
for (; skipped >= 0; skipped--, tile += diff) {
@@ -165,7 +165,7 @@ public:
}
/** 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 (!IsPbsSignal(n.m_last_signal_type)) return 0;
@@ -251,7 +251,7 @@ public:
return cost;
}
- FORCEINLINE int PlatformLengthPenalty(int platform_length)
+ inline int PlatformLengthPenalty(int platform_length)
{
int cost = 0;
const Train *v = Yapf().GetVehicle();
@@ -270,7 +270,7 @@ public:
}
public:
- FORCEINLINE void SetMaxCost(int max_cost)
+ inline void SetMaxCost(int 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
* 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(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;
}
- FORCEINLINE bool CanUseGlobalCache(Node& n) const
+ inline bool CanUseGlobalCache(Node& n) const
{
return !m_disable_cache
&& (n.m_parent != NULL)
&& (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;
if (n.m_segment->m_cost < 0) {
diff --git a/src/pathfinder/yapf/yapf_destrail.hpp b/src/pathfinder/yapf/yapf_destrail.hpp
index 45e425435..901e026d8 100644
--- a/src/pathfinder/yapf/yapf_destrail.hpp
+++ b/src/pathfinder/yapf/yapf_destrail.hpp
@@ -51,13 +51,13 @@ public:
}
/** 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());
}
/** 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);
return bDest;
@@ -67,7 +67,7 @@ public:
* 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
*/
- FORCEINLINE bool PfCalcEstimate(Node& n)
+ inline bool PfCalcEstimate(Node& n)
{
n.m_estimate = n.m_cost;
return true;
@@ -91,13 +91,13 @@ public:
}
/** 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());
}
/** 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()) &&
IsWaitingPositionFree(Yapf().GetVehicle(), tile, td, !TrackFollower::Allow90degTurns());
@@ -107,7 +107,7 @@ public:
* 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.
*/
- FORCEINLINE bool PfCalcEstimate(Node& n)
+ inline bool PfCalcEstimate(Node& n)
{
n.m_estimate = n.m_cost;
return true;
@@ -164,13 +164,13 @@ public:
}
/** 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());
}
/** 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;
if (m_dest_station_id != INVALID_STATION) {
@@ -188,7 +188,7 @@ public:
* 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
*/
- 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_y_offs[] = {0, 1, 0, -1};
diff --git a/src/pathfinder/yapf/yapf_node.hpp b/src/pathfinder/yapf/yapf_node.hpp
index 0eb9802de..39f393381 100644
--- a/src/pathfinder/yapf/yapf_node.hpp
+++ b/src/pathfinder/yapf/yapf_node.hpp
@@ -18,15 +18,15 @@ struct CYapfNodeKeyExitDir {
Trackdir m_td;
DiagDirection m_exitdir;
- FORCEINLINE void Set(TileIndex tile, Trackdir td)
+ inline void Set(TileIndex tile, Trackdir td)
{
m_tile = tile;
m_td = td;
m_exitdir = (m_td == INVALID_TRACKDIR) ? INVALID_DIAGDIR : TrackdirToExitdir(m_td);
}
- FORCEINLINE 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 int CalcHash() const {return m_exitdir | (m_tile << 2);}
+ inline bool operator == (const CYapfNodeKeyExitDir& other) const {return (m_tile == other.m_tile) && (m_exitdir == other.m_exitdir);}
void Dump(DumpTarget &dmp) const
{
@@ -38,8 +38,8 @@ struct CYapfNodeKeyExitDir {
struct CYapfNodeKeyTrackDir : public CYapfNodeKeyExitDir
{
- FORCEINLINE 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 int CalcHash() const {return m_td | (m_tile << 4);}
+ inline bool operator == (const CYapfNodeKeyTrackDir& other) const {return (m_tile == other.m_tile) && (m_td == other.m_td);}
};
/** Yapf Node base */
@@ -54,7 +54,7 @@ struct CYapfNodeT {
int m_cost;
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_hash_next = NULL;
@@ -63,14 +63,14 @@ struct CYapfNodeT {
m_estimate = 0;
}
- FORCEINLINE Node *GetHashNext() {return m_hash_next;}
- FORCEINLINE void SetHashNext(Node *pNext) {m_hash_next = pNext;}
- FORCEINLINE TileIndex GetTile() const {return m_key.m_tile;}
- FORCEINLINE Trackdir GetTrackdir() const {return m_key.m_td;}
- FORCEINLINE const Tkey_& GetKey() const {return m_key;}
- FORCEINLINE int GetCost() const {return m_cost;}
- FORCEINLINE int GetCostEstimate() const {return m_estimate;}
- FORCEINLINE bool operator < (const Node& other) const {return m_estimate < other.m_estimate;}
+ inline Node *GetHashNext() {return m_hash_next;}
+ inline void SetHashNext(Node *pNext) {m_hash_next = pNext;}
+ inline TileIndex GetTile() const {return m_key.m_tile;}
+ inline Trackdir GetTrackdir() const {return m_key.m_td;}
+ inline const Tkey_& GetKey() const {return m_key;}
+ inline int GetCost() const {return m_cost;}
+ inline int GetCostEstimate() const {return m_estimate;}
+ inline bool operator < (const Node& other) const {return m_estimate < other.m_estimate;}
void Dump(DumpTarget &dmp) const
{
diff --git a/src/pathfinder/yapf/yapf_node_rail.hpp b/src/pathfinder/yapf/yapf_node_rail.hpp
index 275133bd8..765fa0daf 100644
--- a/src/pathfinder/yapf/yapf_node_rail.hpp
+++ b/src/pathfinder/yapf/yapf_node_rail.hpp
@@ -17,39 +17,39 @@ struct CYapfRailSegmentKey
{
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);
}
- FORCEINLINE void Set(const CYapfRailSegmentKey& src)
+ inline void Set(const CYapfRailSegmentKey& src)
{
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;
}
- FORCEINLINE int32 CalcHash() const
+ inline int32 CalcHash() const
{
return m_value;
}
- FORCEINLINE TileIndex GetTile() const
+ inline TileIndex GetTile() const
{
return (TileIndex)(m_value >> 4);
}
- FORCEINLINE Trackdir GetTrackdir() const
+ inline Trackdir GetTrackdir() const
{
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;
}
@@ -144,7 +144,7 @@ struct CYapfRailSegment
EndSegmentReasonBits m_end_segment_reason;
CYapfRailSegment *m_hash_next;
- FORCEINLINE CYapfRailSegment(const CYapfRailSegmentKey& key)
+ inline CYapfRailSegment(const CYapfRailSegmentKey& key)
: m_key(key)
, m_last_tile(INVALID_TILE)
, m_last_td(INVALID_TRACKDIR)
@@ -155,22 +155,22 @@ struct CYapfRailSegment
, m_hash_next(NULL)
{}
- FORCEINLINE const Key& GetKey() const
+ inline const Key& GetKey() const
{
return m_key;
}
- FORCEINLINE TileIndex GetTile() const
+ inline TileIndex GetTile() const
{
return m_key.GetTile();
}
- FORCEINLINE CYapfRailSegment *GetHashNext()
+ inline CYapfRailSegment *GetHashNext()
{
return m_hash_next;
}
- FORCEINLINE void SetHashNext(CYapfRailSegment *next)
+ inline void SetHashNext(CYapfRailSegment *next)
{
m_hash_next = next;
}
@@ -208,7 +208,7 @@ struct CYapfRailNodeT
SignalType m_last_red_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);
m_segment = NULL;
@@ -236,19 +236,19 @@ struct CYapfRailNodeT
flags_u.flags_s.m_choice_seen |= is_choice;
}
- FORCEINLINE TileIndex GetLastTile() const
+ inline TileIndex GetLastTile() const
{
assert(m_segment != NULL);
return m_segment->m_last_tile;
}
- FORCEINLINE Trackdir GetLastTrackdir() const
+ inline Trackdir GetLastTrackdir() const
{
assert(m_segment != NULL);
return m_segment->m_last_td;
}
- FORCEINLINE void SetLastTileTrackdir(TileIndex tile, Trackdir td)
+ inline void SetLastTileTrackdir(TileIndex tile, Trackdir td)
{
assert(m_segment != NULL);
m_segment->m_last_tile = tile;
diff --git a/src/pathfinder/yapf/yapf_rail.cpp b/src/pathfinder/yapf/yapf_rail.cpp
index 5c7509899..48417b2b3 100644
--- a/src/pathfinder/yapf/yapf_rail.cpp
+++ b/src/pathfinder/yapf/yapf_rail.cpp
@@ -47,7 +47,7 @@ public:
protected:
/** to access inherited pathfinder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
@@ -197,7 +197,7 @@ public:
protected:
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
@@ -217,7 +217,7 @@ public:
}
/** return debug report character to identify the transportation type */
- FORCEINLINE char TransportTypeChar() const
+ inline char TransportTypeChar() const
{
return 't';
}
@@ -252,7 +252,7 @@ public:
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 */
Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, true);
@@ -293,7 +293,7 @@ public:
protected:
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
@@ -313,7 +313,7 @@ public:
}
/** Return debug report character to identify the transportation type */
- FORCEINLINE char TransportTypeChar() const
+ inline char TransportTypeChar() const
{
return 't';
}
@@ -376,7 +376,7 @@ public:
protected:
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
@@ -396,7 +396,7 @@ public:
}
/** return debug report character to identify the transportation type */
- FORCEINLINE char TransportTypeChar() const
+ inline char TransportTypeChar() const
{
return 't';
}
@@ -422,7 +422,7 @@ public:
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;
@@ -480,7 +480,7 @@ public:
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
* set origin and destination nodes */
diff --git a/src/pathfinder/yapf/yapf_road.cpp b/src/pathfinder/yapf/yapf_road.cpp
index 9a0b40f5b..82493241f 100644
--- a/src/pathfinder/yapf/yapf_road.cpp
+++ b/src/pathfinder/yapf/yapf_road.cpp
@@ -51,7 +51,7 @@ protected:
}
/** return one tile cost */
- FORCEINLINE int OneTileCost(TileIndex tile, Trackdir trackdir)
+ inline int OneTileCost(TileIndex tile, Trackdir trackdir)
{
int cost = 0;
/* set base cost */
@@ -100,7 +100,7 @@ public:
* Calculates only the cost of given node, adds it to the parent node cost
* 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;
uint tiles = 0;
@@ -181,13 +181,13 @@ public:
}
/** 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);
return bDest;
}
- FORCEINLINE bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir)
+ inline bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir)
{
return IsRoadDepotTile(tile);
}
@@ -196,7 +196,7 @@ public:
* 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
*/
- FORCEINLINE bool PfCalcEstimate(Node& n)
+ inline bool PfCalcEstimate(Node& n)
{
n.m_estimate = n.m_cost;
return true;
@@ -245,12 +245,12 @@ protected:
public:
/** 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);
}
- FORCEINLINE bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir)
+ inline bool PfDetectDestinationTile(TileIndex tile, Trackdir trackdir)
{
if (m_dest_station != INVALID_STATION) {
return IsTileType(tile, MP_STATION) &&
@@ -305,7 +305,7 @@ public:
protected:
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
@@ -326,7 +326,7 @@ public:
}
/** return debug report character to identify the transportation type */
- FORCEINLINE char TransportTypeChar() const
+ inline char TransportTypeChar() const
{
return 'r';
}
@@ -337,7 +337,7 @@ public:
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.
* However, when going to a station the (initial) destination
@@ -384,7 +384,7 @@ public:
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 */
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. */
- FORCEINLINE bool SetOriginFromVehiclePos(const RoadVehicle *v)
+ inline bool SetOriginFromVehiclePos(const RoadVehicle *v)
{
/* set origin (tile, trackdir) */
TileIndex src_tile = v->tile;
@@ -434,7 +434,7 @@ public:
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 */
Yapf().SetOrigin(tile, TrackdirToTrackdirBits(td));
diff --git a/src/pathfinder/yapf/yapf_ship.cpp b/src/pathfinder/yapf/yapf_ship.cpp
index 46b3e9bf7..dfcda3858 100644
--- a/src/pathfinder/yapf/yapf_ship.cpp
+++ b/src/pathfinder/yapf/yapf_ship.cpp
@@ -27,7 +27,7 @@ public:
protected:
/** to access inherited path finder */
- FORCEINLINE Tpf& Yapf()
+ inline Tpf& Yapf()
{
return *static_cast<Tpf*>(this);
}
@@ -47,7 +47,7 @@ public:
}
/** return debug report character to identify the transportation type */
- FORCEINLINE char TransportTypeChar() const
+ inline char TransportTypeChar() const
{
return 'w';
}
@@ -123,7 +123,7 @@ public:
* Calculates only the cost of given node, adds it to the parent node cost
* 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 */
int c = IsDiagonalTrackdir(n.GetTrackdir()) ? YAPF_TILE_LENGTH : YAPF_TILE_CORNER_LENGTH;
diff --git a/src/roadstop_base.h b/src/roadstop_base.h
index 6470f537c..1273bbe66 100644
--- a/src/roadstop_base.h
+++ b/src/roadstop_base.h
@@ -46,7 +46,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* Get the length of this drive through stop.
* @return the length in tile units.
*/
- FORCEINLINE int GetLength() const
+ inline int GetLength() const
{
return this->length;
}
@@ -55,7 +55,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* Get the amount of occupied space in this drive through stop.
* @return the occupied space in tile units.
*/
- FORCEINLINE int GetOccupied() const
+ inline int GetOccupied() const
{
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
/** Initializes a RoadStop */
- FORCEINLINE RoadStop(TileIndex tile = INVALID_TILE) :
+ inline RoadStop(TileIndex tile = INVALID_TILE) :
xy(tile),
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
* @return is at least one bay free?
*/
- FORCEINLINE bool HasFreeBay() const
+ inline bool HasFreeBay() const
{
return GB(this->status, 0, RSSFB_BAY_COUNT) != 0;
}
@@ -92,7 +92,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* @param nr bay to check
* @return is given bay free?
*/
- FORCEINLINE bool IsFreeBay(uint nr) const
+ inline bool IsFreeBay(uint nr) const
{
assert(nr < RSSFB_BAY_COUNT);
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
* @return is entrance busy?
*/
- FORCEINLINE bool IsEntranceBusy() const
+ inline bool IsEntranceBusy() const
{
return HasBit(this->status, RSSFB_ENTRY_BUSY);
}
@@ -111,7 +111,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* Makes an entrance occupied or free
* @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);
}
@@ -121,7 +121,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* @param direction the direciton to get the entry for
* @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;
}
@@ -131,7 +131,7 @@ struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
* @param direction the direciton to get the entry for
* @return the entry
*/
- FORCEINLINE Entry *GetEntry(DiagDirection dir)
+ inline Entry *GetEntry(DiagDirection dir)
{
return HasBit((int)dir, 1) ? this->west : this->east;
}
@@ -157,7 +157,7 @@ private:
* @return the allocated bay number
* @pre this->HasFreeBay()
*/
- FORCEINLINE uint AllocateBay()
+ inline uint AllocateBay()
{
assert(this->HasFreeBay());
@@ -173,7 +173,7 @@ private:
* Allocates a bay in a drive-through road stop
* @param nr the number of the bay to allocate
*/
- FORCEINLINE void AllocateDriveThroughBay(uint nr)
+ inline void AllocateDriveThroughBay(uint nr)
{
assert(nr < RSSFB_BAY_COUNT);
ClrBit(this->status, nr);
@@ -183,7 +183,7 @@ private:
* Frees the given bay
* @param nr the number of the bay to free
*/
- FORCEINLINE void FreeBay(uint nr)
+ inline void FreeBay(uint nr)
{
assert(nr < RSSFB_BAY_COUNT);
SetBit(this->status, nr);
diff --git a/src/roadveh.h b/src/roadveh.h
index 4a6b59218..6358cef7f 100644
--- a/src/roadveh.h
+++ b/src/roadveh.h
@@ -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.
* @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 */
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.
* @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;
}
@@ -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.
* @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;
@@ -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.
* @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. */
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.
* @return Area of the engine in m^2.
*/
- FORCEINLINE byte GetAirDragArea() const
+ inline byte GetAirDragArea() const
{
return 6;
}
@@ -191,7 +191,7 @@ protected: // These functions should not be called outside acceleration code.
* Gets the air drag coefficient of this vehicle.
* @return Air drag value from the engine.
*/
- FORCEINLINE byte GetAirDrag() const
+ inline byte GetAirDrag() const
{
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.
* @return Acceleration status.
*/
- FORCEINLINE AccelStatus GetAccelerationStatus() const
+ inline AccelStatus GetAccelerationStatus() const
{
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.
* @return Current speed in km/h-ish.
*/
- FORCEINLINE uint16 GetCurrentSpeed() const
+ inline uint16 GetCurrentSpeed() const
{
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.
* @return Rolling friction coefficient in [1e-4].
*/
- FORCEINLINE uint32 GetRollingFriction() const
+ inline uint32 GetRollingFriction() const
{
/* Trams have a slightly greater friction coefficient than trains.
* 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.
* @return Zero, road vehicles always use a normal acceleration method.
*/
- FORCEINLINE int GetAccelerationType() const
+ inline int GetAccelerationType() const
{
return 0;
}
@@ -241,7 +241,7 @@ protected: // These functions should not be called outside acceleration code.
* Returns the slope steepness used by this vehicle.
* @return Slope steepness used by the vehicle.
*/
- FORCEINLINE uint32 GetSlopeSteepness() const
+ inline uint32 GetSlopeSteepness() const
{
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.
* @return Since roads don't limit road vehicle speed, it returns always zero.
*/
- FORCEINLINE uint16 GetMaxTrackSpeed() const
+ inline uint16 GetMaxTrackSpeed() const
{
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.
* @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);
TrackBits trackbits = TrackStatusToTrackBits(ts);
@@ -274,7 +274,7 @@ protected: // These functions should not be called outside acceleration code.
* even if it is not reversing.
* @return are we (possibly) reversing?
*/
- FORCEINLINE bool HasToUseGetSlopePixelZ()
+ inline bool HasToUseGetSlopePixelZ()
{
const RoadVehicle *rv = this->First();
diff --git a/src/roadveh_cmd.cpp b/src/roadveh_cmd.cpp
index e4b093bec..96fdab63e 100644
--- a/src/roadveh_cmd.cpp
+++ b/src/roadveh_cmd.cpp
@@ -416,7 +416,7 @@ void RoadVehicle::UpdateDeltaXY(Direction direction)
* Calculates the maximum speed of the vehicle under its current conditions.
* @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;
diff --git a/src/saveload/saveload.cpp b/src/saveload/saveload.cpp
index 7bac45391..0beefbae3 100644
--- a/src/saveload/saveload.cpp
+++ b/src/saveload/saveload.cpp
@@ -278,7 +278,7 @@ struct ReadBuffer {
{
}
- FORCEINLINE byte ReadByte()
+ inline byte ReadByte()
{
if (this->bufp == this->bufe) {
size_t len = this->reader->Read(this->buf, lengthof(this->buf));
@@ -318,7 +318,7 @@ struct MemoryDumper {
* Write a single byte into the dumper.
* @param b The byte to write.
*/
- FORCEINLINE void WriteByte(byte b)
+ inline void WriteByte(byte b)
{
/* Are we at the end of this chunk? */
if (this->buf == this->bufe) {
diff --git a/src/script/api/script_companymode.hpp b/src/script/api/script_companymode.hpp
index 2615494d8..67787f258 100644
--- a/src/script/api/script_companymode.hpp
+++ b/src/script/api/script_companymode.hpp
@@ -19,10 +19,10 @@
* If you create an instance of this class, the company will be switched.
* The original company is stored and recovered from when ever the
* instance is destroyed.
- * All actions performed within the scope of this mode, will be executed
- * on behalf of the company you switched to. This includes any costs
- * 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
+ * All actions performed within the scope of this mode, will be executed
+ * on behalf of the company you switched to. This includes any costs
+ * 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
* real player is executing the commands.
* If the company is not valid during an action, the error
* ERR_PRECONDITION_INVALID_COMPANY will be returned. You can switch to
diff --git a/src/smallmap_gui.cpp b/src/smallmap_gui.cpp
index 2c43c33de..a04693f1a 100644
--- a/src/smallmap_gui.cpp
+++ b/src/smallmap_gui.cpp
@@ -598,7 +598,7 @@ class SmallMapWindow : public Window {
static const uint8 FORCE_REFRESH_PERIOD = 0x1F; ///< map is redrawn after that many 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;
pt.x = (y - x) * 2;
@@ -612,7 +612,7 @@ class SmallMapWindow : public Window {
* @param tile_y Y coordinate of the tile.
* @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 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.
* @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.
diff --git a/src/station_base.h b/src/station_base.h
index a495f1691..d49c6491d 100644
--- a/src/station_base.h
+++ b/src/station_base.h
@@ -89,7 +89,7 @@ struct Airport : public TileArea {
}
/** Check if this airport has at least one hangar. */
- FORCEINLINE bool HasHangar() const
+ inline bool HasHangar() const
{
return this->GetSpec()->nof_depots > 0;
}
@@ -102,7 +102,7 @@ struct Airport : public TileArea {
* @param tidc The tilediff to add to the airport tile.
* @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();
switch (this->rotation) {
@@ -124,7 +124,7 @@ struct Airport : public TileArea {
* @pre hangar_num < GetNumHangars().
* @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();
for (uint i = 0; i < as->nof_depots; i++) {
@@ -141,7 +141,7 @@ struct Airport : public TileArea {
* @pre IsHangarTile(tile).
* @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 HangarTileTable *htt = GetHangarDataByTile(tile);
@@ -154,14 +154,14 @@ struct Airport : public TileArea {
* @pre IsHangarTile(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);
return htt->hangar_num;
}
/** Get the number of hangars on this airport. */
- FORCEINLINE uint GetNumHangars() const
+ inline uint GetNumHangars() const
{
uint num = 0;
uint counted = 0;
@@ -182,7 +182,7 @@ private:
* @return The requested hangar information.
* @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();
for (uint i = 0; i < as->nof_depots; i++) {
@@ -245,12 +245,12 @@ public:
uint GetCatchmentRadius() 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;
}
- FORCEINLINE bool TileBelongsToAirport(TileIndex tile) const
+ inline bool TileBelongsToAirport(TileIndex tile) const
{
return IsAirportTile(tile) && GetStationIndex(tile) == this->index;
}
@@ -277,7 +277,7 @@ public:
if (!st->TileBelongsToAirport(this->tile)) ++(*this);
}
- FORCEINLINE TileIterator& operator ++()
+ inline TileIterator& operator ++()
{
(*this).OrthogonalTileIterator::operator++();
while (this->tile != INVALID_TILE && !st->TileBelongsToAirport(this->tile)) {
diff --git a/src/stdafx.h b/src/stdafx.h
index c75e4ca48..68f7b5d88 100644
--- a/src/stdafx.h
+++ b/src/stdafx.h
@@ -121,7 +121,6 @@
/* Stuff for GCC */
#if defined(__GNUC__)
#define NORETURN __attribute__ ((noreturn))
- #define FORCEINLINE inline
#define CDECL
#define __int64 long long
#define GCC_PACK __attribute__((packed))
@@ -137,7 +136,6 @@
#if defined(__WATCOMC__)
#define NORETURN
- #define FORCEINLINE inline
#define CDECL
#define GCC_PACK
#define WARN_FORMAT(string, args)
@@ -185,8 +183,7 @@
#include <malloc.h> // alloca()
#define NORETURN __declspec(noreturn)
- #define FORCEINLINE __forceinline
- #define inline _inline
+ #define inline __forceinline
#if !defined(WINCE)
#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.
* @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));
}
diff --git a/src/subsidy_base.h b/src/subsidy_base.h
index 5c09260ad..d0f1fa655 100644
--- a/src/subsidy_base.h
+++ b/src/subsidy_base.h
@@ -33,18 +33,18 @@ struct Subsidy : SubsidyPool::PoolItem<&_subsidy_pool> {
/**
* 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
*/
- FORCEINLINE ~Subsidy() { }
+ inline ~Subsidy() { }
/**
* Tests whether this subsidy has been awarded to someone
* @return is this subsidy awarded?
*/
- FORCEINLINE bool IsAwarded() const
+ inline bool IsAwarded() const
{
return this->awarded != INVALID_COMPANY;
}
diff --git a/src/tilearea_type.h b/src/tilearea_type.h
index 1b3832a84..4596514dd 100644
--- a/src/tilearea_type.h
+++ b/src/tilearea_type.h
@@ -85,7 +85,7 @@ public:
* Get the tile we are currently at.
* @return The tile we are at, or INVALID_TILE when we're done.
*/
- FORCEINLINE operator TileIndex () const
+ inline operator TileIndex () const
{
return this->tile;
}
@@ -120,7 +120,7 @@ public:
/**
* Move ourselves to the next tile in the rectange on the map.
*/
- FORCEINLINE TileIterator& operator ++()
+ inline TileIterator& operator ++()
{
assert(this->tile != INVALID_TILE);
diff --git a/src/tilematrix_type.hpp b/src/tilematrix_type.hpp
index 047d701b6..fd5a94abc 100644
--- a/src/tilematrix_type.hpp
+++ b/src/tilematrix_type.hpp
@@ -137,7 +137,7 @@ public:
}
/** Array access operator, see #Get. */
- FORCEINLINE T &operator[](TileIndex tile)
+ inline T &operator[](TileIndex tile)
{
return *this->Get(tile);
}
diff --git a/src/town.h b/src/town.h
index 068a2053a..f91f6b9af 100644
--- a/src/town.h
+++ b/src/town.h
@@ -133,7 +133,7 @@ struct Town : TownPool::PoolItem<&_town_pool> {
void UpdateVirtCoord();
- static FORCEINLINE Town *GetByTile(TileIndex tile)
+ static inline Town *GetByTile(TileIndex tile)
{
return Town::Get(GetTownIndex(tile));
}
diff --git a/src/train.h b/src/train.h
index 37f64a2dc..6571544b0 100644
--- a/src/train.h
+++ b/src/train.h
@@ -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.
* @return Next vehicle in the consist.
*/
- FORCEINLINE Train *GetNextUnit() const
+ inline Train *GetNextUnit() const
{
Train *v = this->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.
* @return Previous vehicle in the consist.
*/
- FORCEINLINE Train *GetPrevUnit()
+ inline Train *GetPrevUnit()
{
Train *v = this->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.
* @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 */
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.
* @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) */
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.
* @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;
@@ -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.
* @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);
}
@@ -228,7 +228,7 @@ protected: // These functions should not be called outside acceleration code.
* Gets the area used for calculating air drag.
* @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. */
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.
* @return Air drag value from the engine.
*/
- FORCEINLINE byte GetAirDrag() const
+ inline byte GetAirDrag() const
{
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.
* @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;
}
@@ -256,7 +256,7 @@ protected: // These functions should not be called outside acceleration code.
* Calculates the current speed of this vehicle.
* @return Current speed in km/h-ish.
*/
- FORCEINLINE uint16 GetCurrentSpeed() const
+ inline uint16 GetCurrentSpeed() const
{
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.
* @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%.
* 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.
* @return Acceleration type of the vehicle.
*/
- FORCEINLINE int GetAccelerationType() const
+ inline int GetAccelerationType() const
{
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.
* @return Slope steepness used by the vehicle.
*/
- FORCEINLINE uint32 GetSlopeSteepness() const
+ inline uint32 GetSlopeSteepness() const
{
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.
* @return Maximum speed allowed.
*/
- FORCEINLINE uint16 GetMaxTrackSpeed() const
+ inline uint16 GetMaxTrackSpeed() const
{
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.
* @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. */
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.
* @return false
*/
- FORCEINLINE bool HasToUseGetSlopePixelZ()
+ inline bool HasToUseGetSlopePixelZ()
{
return false;
}
diff --git a/src/train_gui.cpp b/src/train_gui.cpp
index a12bca0dd..1fde0e98f 100644
--- a/src/train_gui.cpp
+++ b/src/train_gui.cpp
@@ -166,7 +166,7 @@ struct CargoSummaryItem {
StationID source; ///< One of the source stations
/** 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;
}
diff --git a/src/vehicle_base.h b/src/vehicle_base.h
index 0723817fc..16d258832 100644
--- a/src/vehicle_base.h
+++ b/src/vehicle_base.h
@@ -295,7 +295,7 @@ public:
* @param speed Direction-independent unscaled speed.
* @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;
}
@@ -312,7 +312,7 @@ public:
* @param speed Direction-independent unscaled speed.
* @return speed, scaled to match #GetAdvanceDistance().
*/
- static FORCEINLINE uint GetAdvanceSpeed(uint speed)
+ static inline uint GetAdvanceSpeed(uint speed)
{
return speed * 3 / 4;
}
@@ -324,7 +324,7 @@ public:
*
* @return distance to drive for a movement step on the map.
*/
- FORCEINLINE uint GetAdvanceDistance()
+ inline uint GetAdvanceDistance()
{
return (this->direction & 1) ? 192 : 256;
}
@@ -361,7 +361,7 @@ public:
* Invalidates cached NewGRF variables
* @see InvalidateNewGRFCacheOfChain
*/
- FORCEINLINE void InvalidateNewGRFCache()
+ inline void InvalidateNewGRFCache()
{
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)
* @see InvalidateNewGRFCache
*/
- FORCEINLINE void InvalidateNewGRFCacheOfChain()
+ inline void InvalidateNewGRFCacheOfChain()
{
for (Vehicle *u = this; u != NULL; u = u->Next()) {
u->InvalidateNewGRFCache();
@@ -381,7 +381,7 @@ public:
* Check if the vehicle is a ground 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;
}
@@ -739,7 +739,7 @@ public:
* Check 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);
}
@@ -748,7 +748,7 @@ public:
* Check if the vehicle is an articulated part of an engine.
* @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);
}
@@ -757,7 +757,7 @@ public:
* Check if an 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();
}
@@ -767,7 +767,7 @@ public:
* @return Next part of the articulated engine.
* @pre The vehicle is an articulated engine.
*/
- FORCEINLINE Vehicle *GetNextArticulatedPart() const
+ inline Vehicle *GetNextArticulatedPart() const
{
assert(this->HasArticulatedPart());
return this->Next();
@@ -777,7 +777,7 @@ public:
* Get the first part of an articulated engine.
* @return First part of the engine.
*/
- FORCEINLINE Vehicle *GetFirstEnginePart()
+ inline Vehicle *GetFirstEnginePart()
{
Vehicle *v = this;
while (v->IsArticulatedPart()) v = v->Previous();
@@ -788,7 +788,7 @@ public:
* Get the first part of an articulated engine.
* @return First part of the engine.
*/
- FORCEINLINE const Vehicle *GetFirstEnginePart() const
+ inline const Vehicle *GetFirstEnginePart() const
{
const Vehicle *v = this;
while (v->IsArticulatedPart()) v = v->Previous();
@@ -799,7 +799,7 @@ public:
* Get the last part of an articulated engine.
* @return Last part of the engine.
*/
- FORCEINLINE Vehicle *GetLastEnginePart()
+ inline Vehicle *GetLastEnginePart()
{
Vehicle *v = this;
while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
@@ -810,7 +810,7 @@ public:
* Get the next real (non-articulated part) vehicle in the consist.
* @return Next vehicle in the consist.
*/
- FORCEINLINE Vehicle *GetNextVehicle() const
+ inline Vehicle *GetNextVehicle() const
{
const Vehicle *v = this;
while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
@@ -823,7 +823,7 @@ public:
* Get the previous real (non-articulated part) vehicle in the consist.
* @return Previous vehicle in the consist.
*/
- FORCEINLINE Vehicle *GetPrevVehicle() const
+ inline Vehicle *GetPrevVehicle() const
{
Vehicle *v = this->Previous();
while (v != NULL && v->IsArticulatedPart()) v = v->Previous();
@@ -858,88 +858,88 @@ struct SpecializedVehicle : public Vehicle {
/**
* Set vehicle type correctly
*/
- FORCEINLINE SpecializedVehicle<T, Type>() : Vehicle(Type) { }
+ inline SpecializedVehicle<T, Type>() : Vehicle(Type) { }
/**
* Get the 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
* @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
* @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
* @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
* @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.
* @return Next part of the 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.
* @return Next part of the 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.
* @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.
* @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.
* @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.
* @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.
* @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
* @param index tested index
* @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;
}
@@ -948,7 +948,7 @@ struct SpecializedVehicle : public Vehicle {
* Gets vehicle with given index
* @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);
}
@@ -957,7 +957,7 @@ struct SpecializedVehicle : public Vehicle {
* 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
*/
- static FORCEINLINE T *GetIfValid(size_t index)
+ static inline T *GetIfValid(size_t index)
{
return IsValidID(index) ? Get(index) : NULL;
}
@@ -967,7 +967,7 @@ struct SpecializedVehicle : public Vehicle {
* @param v Vehicle pointer
* @return pointer to SpecializedVehicle
*/
- static FORCEINLINE T *From(Vehicle *v)
+ static inline T *From(Vehicle *v)
{
assert(v->type == Type);
return (T *)v;
@@ -978,7 +978,7 @@ struct SpecializedVehicle : public Vehicle {
* @param v Vehicle pointer
* @return pointer to SpecializedVehicle
*/
- static FORCEINLINE const T *From(const Vehicle *v)
+ static inline const T *From(const Vehicle *v)
{
assert(v->type == Type);
return (const T *)v;
@@ -989,7 +989,7 @@ struct SpecializedVehicle : public Vehicle {
* @param moved Was the vehicle moved?
* @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);
diff --git a/src/vehicle_gui.cpp b/src/vehicle_gui.cpp
index 81e17e694..006f6278b 100644
--- a/src/vehicle_gui.cpp
+++ b/src/vehicle_gui.cpp
@@ -297,7 +297,7 @@ struct RefitOption {
* @param other Compare to this #RefitOption.
* @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;
}
@@ -307,7 +307,7 @@ struct RefitOption {
* @param other Compare to this #RefitOption.
* @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;
}
diff --git a/src/waypoint_base.h b/src/waypoint_base.h
index 01c0ae173..c97c6089c 100644
--- a/src/waypoint_base.h
+++ b/src/waypoint_base.h
@@ -27,7 +27,7 @@ struct Waypoint FINAL : SpecializedStation<Waypoint, true> {
void UpdateVirtCoord();
- /* virtual */ FORCEINLINE bool TileBelongsToRailStation(TileIndex tile) const
+ /* virtual */ inline bool TileBelongsToRailStation(TileIndex tile) const
{
return IsRailWaypointTile(tile) && GetStationIndex(tile) == this->index;
}
@@ -50,7 +50,7 @@ struct Waypoint FINAL : SpecializedStation<Waypoint, true> {
* Is this a single tile waypoint?
* @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;
}
@@ -61,7 +61,7 @@ struct Waypoint FINAL : SpecializedStation<Waypoint, true> {
* @param wp The waypoint to compare to.
* @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;
}
diff --git a/src/widget_type.h b/src/widget_type.h
index 80e6d5c03..e77a7a131 100644
--- a/src/widget_type.h
+++ b/src/widget_type.h
@@ -143,7 +143,7 @@ public:
* @param bottom Amount of additional space below 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_right = right;
@@ -151,8 +151,8 @@ public:
this->padding_left = left;
}
- FORCEINLINE uint GetHorizontalStepSize(SizingType sizing) const;
- FORCEINLINE uint GetVerticalStepSize(SizingType sizing) const;
+ inline uint GetHorizontalStepSize(SizingType sizing) const;
+ inline uint GetVerticalStepSize(SizingType sizing) const;
virtual void Draw(const Window *w) = 0;
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.
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.
* @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;
}
@@ -199,7 +199,7 @@ FORCEINLINE uint NWidgetBase::GetHorizontalStepSize(SizingType sizing) const
* Get the vertical sizing step.
* @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;
}
@@ -212,7 +212,7 @@ FORCEINLINE uint NWidgetBase::GetVerticalStepSize(SizingType sizing) const
* @param given_width Width 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_y = y;
@@ -607,7 +607,7 @@ public:
* Gets the number of elements in the list
* @return the number of elements
*/
- FORCEINLINE uint16 GetCount() const
+ inline uint16 GetCount() const
{
return this->count;
}
@@ -616,7 +616,7 @@ public:
* Gets the number of visible elements of the scrollbar
* @return the number of visible elements
*/
- FORCEINLINE uint16 GetCapacity() const
+ inline uint16 GetCapacity() const
{
return this->cap;
}
@@ -625,7 +625,7 @@ public:
* Gets the position of the first visible element in the list
* @return the position of the element
*/
- FORCEINLINE uint16 GetPosition() const
+ inline uint16 GetPosition() const
{
return this->pos;
}
@@ -635,7 +635,7 @@ public:
* @param item to check
* @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());
}
@@ -644,7 +644,7 @@ public:
* Is the scrollbar vertical or not?
* @return True iff the scrollbar is vertical.
*/
- FORCEINLINE bool IsVertical() const
+ inline bool IsVertical() const
{
return this->is_vertical;
}
@@ -789,7 +789,7 @@ private:
* @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.
*/
-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 (step == 1) return max_space;
diff --git a/src/window_gui.h b/src/window_gui.h
index a0c03805d..1e5fb5a39 100644
--- a/src/window_gui.h
+++ b/src/window_gui.h
@@ -263,7 +263,7 @@ public:
* to destruct them all at the same time too, which is kinda hard.
* @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();
}
@@ -273,7 +273,7 @@ public:
* Don't free the window directly; it corrupts the linked list when iterating
* @param ptr the pointer not to free
*/
- FORCEINLINE void operator delete(void *ptr)
+ inline void operator delete(void *ptr)
{
}