Use simple macro to enable operators

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

src/color.h

@@ -38,7 +38,7 @@ enum SquareColor {
   LIGHT
 };
 
-ENABLE_OPERATORS_ON(Color);
+ENABLE_OPERATORS_ON(Color)
 
 
 ////

src/depth.h

@@ -38,6 +38,6 @@ enum Depth {
   DEPTH_NONE = -127 * ONE_PLY
 };
 
-ENABLE_OPERATORS_ON(Depth);
+ENABLE_OPERATORS_ON(Depth)
 
 #endif // !defined(DEPTH_H_INCLUDED)

src/piece.h

@@ -46,8 +46,8 @@ enum Piece {
   BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16
 };
 
-ENABLE_OPERATORS_ON(PieceType);
+ENABLE_OPERATORS_ON(PieceType)
-ENABLE_OPERATORS_ON(Piece);
+ENABLE_OPERATORS_ON(Piece)
 
 
 ////

src/square.h

@@ -68,10 +68,10 @@ enum SquareDelta {
   DELTA_NW = DELTA_N + DELTA_W
 };
 
-ENABLE_OPERATORS_ON(Square);
+ENABLE_OPERATORS_ON(Square)
-ENABLE_OPERATORS_ON(File);
+ENABLE_OPERATORS_ON(File)
-ENABLE_OPERATORS_ON(Rank);
+ENABLE_OPERATORS_ON(Rank)
-ENABLE_OPERATORS_ON(SquareDelta);
+ENABLE_OPERATORS_ON(SquareDelta)
 
 
 ////

src/types.h

@@ -117,64 +117,20 @@ inline void __cpuid(int CPUInfo[4], int)
 }
 #endif
 
+// Operators used by enum types like Depth, Piece, Square and so on.
 
-// Templetized operators used by enum types like Depth, Piece, Square and so on.
+#define ENABLE_OPERATORS_ON(T) \
-// We don't want to write the same inline for each different enum. Note that we
+inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); } \
-// pass by value to silence scaring warnings when using volatiles.
+inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); } \
-// Because these templates override common operators and are included in all the
+inline T operator* (int i, const T d) {  return T(i * int(d)); } \
-// files, there is a possibility that the compiler silently performs some unwanted
+inline T operator* (const T d, int i) {  return T(int(d) * i); } \
-// overrides. To avoid possible very nasty bugs the templates are disabled by default
+inline T operator/ (const T d, int i) { return T(int(d) / i); } \
-// and must be enabled for each type on a case by case base. The enabling trick
+inline T operator- (const T d) { return T(-int(d)); } \
-// uses template specialization, namely we just declare following struct.
+inline T operator++ (T& d, int) {d = T(int(d) + 1); return d; } \
-template<typename T> struct TempletizedOperator;
+inline T operator-- (T& d, int) { d = T(int(d) - 1); return d; } \
-
+inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; } \
-// Then to enable the enum type we use following macro that defines a specialization
+inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; } \
-// of TempletizedOperator for the given enum T. Here is defined typedef Not_Enabled.
+inline void operator*= (T& d, int i) { d = T(int(d) * i); } \
-// Name of typedef is chosen to produce somewhat informative compile error messages.
+inline void operator/= (T& d, int i) { d = T(int(d) / i); }
-#define ENABLE_OPERATORS_ON(T)  \
-        template<> struct TempletizedOperator<T> { 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<T>::Not_Enabled Type
-
-template<typename T>
-inline T operator+ (const T d1, const T d2) { OK(T); return T(int(d1) + int(d2)); }
-
-template<typename T>
-inline T operator- (const T d1, const T d2) { OK(T); return T(int(d1) - int(d2)); }
-
-template<typename T>
-inline T operator* (int i, const T d) { OK(T); return T(i * int(d)); }
-
-template<typename T>
-inline T operator* (const T d, int i) { OK(T); return T(int(d) * i); }
-
-template<typename T>
-inline T operator/ (const T d, int i) { OK(T); return T(int(d) / i); }
-
-template<typename T>
-inline T operator- (const T d) { OK(T); return T(-int(d)); }
-
-template<typename T>
-inline T operator++ (T& d, int) { OK(T); d = T(int(d) + 1); return d; }
-
-template<typename T>
-inline T operator-- (T& d, int) { OK(T); d = T(int(d) - 1); return d; }
-
-template<typename T>
-inline void operator+= (T& d1, const T d2) { OK(T); d1 = d1 + d2; }
-
-template<typename T>
-inline void operator-= (T& d1, const T d2) { OK(T); d1 = d1 - d2; }
-
-template<typename T>
-inline void operator*= (T& d, int i) { OK(T); d = T(int(d) * i); }
-
-template<typename T>
-inline void operator/= (T& d, int i) { OK(T); d = T(int(d) / i); }
-
-#undef OK
 
 #endif // !defined(TYPES_H_INCLUDED)

src/value.h

@@ -43,7 +43,7 @@ enum Value {
   VALUE_ENSURE_SIGNED = -1
 };
 
-ENABLE_OPERATORS_ON(Value);
+ENABLE_OPERATORS_ON(Value)
 
 
 enum ScaleFactor {
@@ -66,9 +66,6 @@ enum Score {
     SCORE_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
 // implementation defined and so is a right shift of a signed integer.
@@ -91,6 +88,17 @@ inline Score operator/(Score s, int i) { return make_score(mg_value(s) / i, eg_v
 // a very high risk of overflow. So user should explicitly convert to integer.
 inline Score operator*(Score s1, Score s2);
 
+// Rest of operators are standard:
+inline Score operator+ (const Score d1, const Score d2) { return Score(int(d1) + int(d2)); }
+inline Score operator- (const Score d1, const Score d2) { return Score(int(d1) - int(d2)); }
+inline Score operator* (int i, const Score d) {  return Score(i * int(d)); }
+inline Score operator* (const Score d, int i) {  return Score(int(d) * i); }
+inline Score operator- (const Score d) { return Score(-int(d)); }
+inline void operator+= (Score& d1, const Score d2) { d1 = d1 + d2; }
+inline void operator-= (Score& d1, const Score d2) { d1 = d1 - d2; }
+inline void operator*= (Score& d, int i) { d = Score(int(d) * i); }
+inline void operator/= (Score& d, int i) { d = Score(int(d) / i); }
+
 
 ////
 //// Inline functions