From: Marco Costalba Date: Thu, 19 Aug 2010 06:38:13 +0000 (+0100) Subject: Disable templetized operators by default X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=a5ae7fe26030bdd73a95fde3ebe841abfe84ec5e Disable templetized operators by default To avoid nasty bugs due to silently overriding of common operator we enable the templates on a type by type base using partial template specialization. No functional change, zero overhead at runtime. Signed-off-by: Marco Costalba --- diff --git a/src/book.cpp b/src/book.cpp index dbd03788..ad0d406d 100644 --- a/src/book.cpp +++ b/src/book.cpp @@ -366,7 +366,7 @@ void Book::open(const string& fName) { // Get the book size in number of entries seekg(0, ios::end); - bookSize = tellg() / EntrySize; + bookSize = long(tellg()) / EntrySize; seekg(0, ios::beg); if (!good()) diff --git a/src/color.h b/src/color.h index c946a548..c6897a2e 100644 --- a/src/color.h +++ b/src/color.h @@ -21,6 +21,7 @@ #if !defined(COLOR_H_INCLUDED) #define COLOR_H_INCLUDED +#include "types.h" //// //// Types @@ -37,6 +38,8 @@ enum SquareColor { LIGHT }; +ENABLE_OPERATORS_ON(Color); + //// //// Inline functions diff --git a/src/depth.h b/src/depth.h index ab88f652..f77dd0d3 100644 --- a/src/depth.h +++ b/src/depth.h @@ -21,6 +21,8 @@ #if !defined(DEPTH_H_INCLUDED) #define DEPTH_H_INCLUDED +#include "types.h" + //// //// Types //// @@ -33,5 +35,6 @@ enum Depth { DEPTH_NONE = -127 * ONE_PLY }; +ENABLE_OPERATORS_ON(Depth); #endif // !defined(DEPTH_H_INCLUDED) diff --git a/src/direction.h b/src/direction.h index 399a628b..0500840a 100644 --- a/src/direction.h +++ b/src/direction.h @@ -45,6 +45,8 @@ enum SignedDirection { SIGNED_DIR_NONE = 8 }; +ENABLE_OPERATORS_ON(SignedDirection); + //// //// Variables diff --git a/src/piece.h b/src/piece.h index 40a01e10..6592de1a 100644 --- a/src/piece.h +++ b/src/piece.h @@ -43,6 +43,9 @@ enum Piece { BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16 }; +ENABLE_OPERATORS_ON(PieceType); +ENABLE_OPERATORS_ON(Piece); + //// //// Constants diff --git a/src/square.h b/src/square.h index d539e005..4d427e8e 100644 --- a/src/square.h +++ b/src/square.h @@ -64,6 +64,11 @@ enum SquareDelta { DELTA_NN = 020, DELTA_NNE = 021 }; +ENABLE_OPERATORS_ON(Square); +ENABLE_OPERATORS_ON(File); +ENABLE_OPERATORS_ON(Rank); +ENABLE_OPERATORS_ON(SquareDelta); + //// //// Constants diff --git a/src/types.h b/src/types.h index 226d76e4..a85aa7f7 100644 --- a/src/types.h +++ b/src/types.h @@ -112,43 +112,61 @@ inline void __cpuid(int CPUInfo[4], int) // Templetized operators used by enum types like Depth, Piece, Square and so on. // We don't want to write the same inline for each different enum. Note that we -// pass by value (to silence scaring warnings on volatiles), so you really should -// use only enum types with these functions to avoid hidden copies. +// pass by value to silence scaring warnings when using volatiles. +// Because these templates override common operators and are included in all the +// files, there is a possibility that the compiler silently performs some unwanted +// overrides. To avoid possible very nasty bugs the templates are disabled by default +// and must be enabled for each type on a case by case base. The enabling trick +// uses template specialization, namely we just declare following struct. +template struct TempletizedOperator; + +// Then to enable the enum type we use following macro that defines a specialization +// of TempletizedOperator for the given enum T. Here is defined typedef Not_Enabled. +// Name of typedef is chosen to produce somewhat informative compile error messages. +#define ENABLE_OPERATORS_ON(T) \ + template<> struct TempletizedOperator { typedef T Not_Enabled; } + +// Finally we use macro OK(T) to check if type T is enabled. The macro simply +// tries to use Not_Enabled, if was not previously defined a compile error occurs. +// The check is done fully at compile time and there is zero overhead at runtime. +#define OK(T) typedef typename TempletizedOperator::Not_Enabled Type template -inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); } +inline T operator+ (const T d1, const T d2) { OK(T); return T(int(d1) + int(d2)); } template -inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); } +inline T operator- (const T d1, const T d2) { OK(T); return T(int(d1) - int(d2)); } template -inline T operator* (int i, const T d) { return T(i * int(d)); } +inline T operator* (int i, const T d) { OK(T); return T(i * int(d)); } template -inline T operator* (const T d, int i) { return T(int(d) * i); } +inline T operator* (const T d, int i) { OK(T); return T(int(d) * i); } template -inline T operator/ (const T d, int i) { return T(int(d) / i); } +inline T operator/ (const T d, int i) { OK(T); return T(int(d) / i); } template -inline T operator- (const T d) { return T(-int(d)); } +inline T operator- (const T d) { OK(T); return T(-int(d)); } template -inline void operator++ (T& d, int) { d = T(int(d) + 1); } +inline void operator++ (T& d, int) { OK(T); d = T(int(d) + 1); } template -inline void operator-- (T& d, int) { d = T(int(d) - 1); } +inline void operator-- (T& d, int) { OK(T); d = T(int(d) - 1); } template -inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; } +inline void operator+= (T& d1, const T d2) { OK(T); d1 = d1 + d2; } template -inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; } +inline void operator-= (T& d1, const T d2) { OK(T); d1 = d1 - d2; } template -inline void operator*= (T& d, int i) { d = T(int(d) * i); } +inline void operator*= (T& d, int i) { OK(T); d = T(int(d) * i); } template -inline void operator/= (T& d, int i) { d = T(int(d) / i); } +inline void operator/= (T& d, int i) { OK(T); d = T(int(d) / i); } + +#undef OK #endif // !defined(TYPES_H_INCLUDED) diff --git a/src/value.h b/src/value.h index d47ad544..d86a8bb9 100644 --- a/src/value.h +++ b/src/value.h @@ -50,6 +50,8 @@ enum Value { VALUE_ENSURE_SIGNED = -1 }; +ENABLE_OPERATORS_ON(Value); + enum ScaleFactor { SCALE_FACTOR_ZERO = 0, @@ -65,7 +67,13 @@ enum ScaleFactor { // Compiler is free to choose the enum type as long as can keep // its data, so ensure Score to be an integer type. -enum Score { ENSURE_32_BITS_SIZE_P = (1 << 16), ENSURE_32_BITS_SIZE_N = -(1 << 16)}; +enum Score { + ENSURE_32_BITS_SIZE_P = (1 << 16), + ENSURE_32_BITS_SIZE_N = -(1 << 16) +}; + +ENABLE_OPERATORS_ON(Score); + // Extracting the _signed_ lower and upper 16 bits it not so trivial // because according to the standard a simple cast to short is