Fix operator++ definition

ENABLE_OPERATORS_ON has incorrect definitions of
post-increment and post-decrement operators.

In particularly the returned value is the variable
already incremented/decremented, while instead they
should return the variable _before_ inc/dec.

This has no real effect because are only used in loops
and where the returned value is never used, neverthless
it is wrong. The fix would be to copy the variable to a
dummy, then inc/dec the variable, then return the dummy.

So instead, rename to pre-increment that can be implemented
without the dummy, actually the current implementation
it is already the correct pre-increment, with the only change
to return a reference (an l-value) and not a copy, so
to properly mimic the pre-increment on native integers.

Spotted by Kojirion.

No functional change.

diff --git a/src/bitboard.cpp b/src/bitboard.cpp
index 9598aa706552f5f38da88c50bc7b734dd6b35919..a377703b5b170dbbed3b99ab07892516fe639cc1 100644 (file)
--- a/src/bitboard.cpp
+++ b/src/bitboard.cpp
@@ -132,11 +132,11 @@ void Bitboards::print(Bitboard b) {
 
   sync_cout;
 
-  for (Rank rank = RANK_8; rank >= RANK_1; rank--)
+  for (Rank rank = RANK_8; rank >= RANK_1; --rank)
   {
       std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
 
-      for (File file = FILE_A; file <= FILE_H; file++)
+      for (File file = FILE_A; file <= FILE_H; ++file)
           std::cout << "| " << (b & (file | rank) ? "X " : "  ");
 
       std::cout << "|\n";
@@ -157,7 +157,7 @@ void Bitboards::init() {
   for (int i = 0; i < 64; i++)
       BSFTable[bsf_index(1ULL << i)] = Square(i);
 
-  for (Square s = SQ_A1; s <= SQ_H8; s++)
+  for (Square s = SQ_A1; s <= SQ_H8; ++s)
       SquareBB[s] = 1ULL << s;
 
   FileBB[FILE_A] = FileABB;
@@ -169,22 +169,22 @@ void Bitboards::init() {
       RankBB[i] = RankBB[i - 1] << 8;
   }
 
-  for (File f = FILE_A; f <= FILE_H; f++)
+  for (File f = FILE_A; f <= FILE_H; ++f)
       AdjacentFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
 
-  for (Rank r = RANK_1; r < RANK_8; r++)
+  for (Rank r = RANK_1; r < RANK_8; ++r)
       InFrontBB[WHITE][r] = ~(InFrontBB[BLACK][r + 1] = InFrontBB[BLACK][r] | RankBB[r]);
 
-  for (Color c = WHITE; c <= BLACK; c++)
-      for (Square s = SQ_A1; s <= SQ_H8; s++)
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
       {
           ForwardBB[c][s]      = InFrontBB[c][rank_of(s)] & FileBB[file_of(s)];
           PawnAttackSpan[c][s] = InFrontBB[c][rank_of(s)] & AdjacentFilesBB[file_of(s)];
           PassedPawnMask[c][s] = ForwardBB[c][s] | PawnAttackSpan[c][s];
       }
 
-  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+      for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
       {
           SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
           if (s1 != s2)
@@ -194,9 +194,9 @@ void Bitboards::init() {
   int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
                      {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };
 
-  for (Color c = WHITE; c <= BLACK; c++)
-      for (PieceType pt = PAWN; pt <= KING; pt++)
-          for (Square s = SQ_A1; s <= SQ_H8; s++)
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (PieceType pt = PAWN; pt <= KING; ++pt)
+          for (Square s = SQ_A1; s <= SQ_H8; ++s)
               for (int k = 0; steps[pt][k]; k++)
               {
                   Square to = s + Square(c == WHITE ? steps[pt][k] : -steps[pt][k]);
@@ -211,14 +211,14 @@ void Bitboards::init() {
   init_magics(RTable, RAttacks, RMagics, RMasks, RShifts, RDeltas, magic_index<ROOK>);
   init_magics(BTable, BAttacks, BMagics, BMasks, BShifts, BDeltas, magic_index<BISHOP>);
 
-  for (Square s = SQ_A1; s <= SQ_H8; s++)
+  for (Square s = SQ_A1; s <= SQ_H8; ++s)
   {
       PseudoAttacks[QUEEN][s]  = PseudoAttacks[BISHOP][s] = attacks_bb<BISHOP>(s, 0);
       PseudoAttacks[QUEEN][s] |= PseudoAttacks[  ROOK][s] = attacks_bb<  ROOK>(s, 0);
   }
 
-  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+      for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
           if (PseudoAttacks[QUEEN][s1] & s2)
           {
               Square delta = (s2 - s1) / square_distance(s1, s2);
@@ -281,7 +281,7 @@ namespace {
     // attacks[s] is a pointer to the beginning of the attacks table for square 's'
     attacks[SQ_A1] = table;
 
-    for (Square s = SQ_A1; s <= SQ_H8; s++)
+    for (Square s = SQ_A1; s <= SQ_H8; ++s)
     {
         // Board edges are not considered in the relevant occupancies
         edges = ((Rank1BB | Rank8BB) & ~rank_bb(s)) | ((FileABB | FileHBB) & ~file_bb(s));

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index a16fc3592453b588ac5c4e1bfb95d9a8512f4e15..912c05fc8b394942e46a864235dd9c29dda5d8e0 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -622,11 +622,11 @@ Value do_evaluate(const Position& pos, Value& margin) {
     // type of attacking piece, from knights to queens. Kings are not
     // considered because are already handled in king evaluation.
     if (weakEnemies)
-        for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
+        for (PieceType pt1 = KNIGHT; pt1 < KING; ++pt1)
         {
             b = ei.attackedBy[Us][pt1] & weakEnemies;
             if (b)
-                for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
+                for (PieceType pt2 = PAWN; pt2 < KING; ++pt2)
                     if (b & pos.pieces(pt2))
                         score += Threat[pt1][pt2];
         }
@@ -908,7 +908,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
 
     // Step 1. Hunt for unstoppable passed pawns. If we find at least one,
     // record how many plies are required for promotion.
-    for (c = WHITE; c <= BLACK; c++)
+    for (c = WHITE; c <= BLACK; ++c)
     {
         // Skip if other side has non-pawn pieces
         if (pos.non_pawn_material(~c))

diff --git a/src/position.cpp b/src/position.cpp
index fd3f8035f30251c18211e633b835fc8fb49fc410..2266f2a573dfa05e313b0913d903578d1e4ebb2d 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -120,12 +120,12 @@ void Position::init() {
 
   RKISS rk;
 
-  for (Color c = WHITE; c <= BLACK; c++)
-      for (PieceType pt = PAWN; pt <= KING; pt++)
-          for (Square s = SQ_A1; s <= SQ_H8; s++)
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (PieceType pt = PAWN; pt <= KING; ++pt)
+          for (Square s = SQ_A1; s <= SQ_H8; ++s)
               Zobrist::psq[c][pt][s] = rk.rand<Key>();
 
-  for (File f = FILE_A; f <= FILE_H; f++)
+  for (File f = FILE_A; f <= FILE_H; ++f)
       Zobrist::enpassant[f] = rk.rand<Key>();
 
   for (int cr = CASTLES_NONE; cr <= ALL_CASTLES; cr++)
@@ -141,14 +141,14 @@ void Position::init() {
   Zobrist::side = rk.rand<Key>();
   Zobrist::exclusion  = rk.rand<Key>();
 
-  for (PieceType pt = PAWN; pt <= KING; pt++)
+  for (PieceType pt = PAWN; pt <= KING; ++pt)
   {
       PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
       PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
 
       Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
 
-      for (Square s = SQ_A1; s <= SQ_H8; s++)
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
       {
          psq[WHITE][pt][ s] =  (v + PSQT[pt][s]);
          psq[BLACK][pt][~s] = -(v + PSQT[pt][s]);
@@ -233,7 +233,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) {
       else if ((p = PieceToChar.find(token)) != string::npos)
       {
           put_piece(sq, color_of(Piece(p)), type_of(Piece(p)));
-          sq++;
+          ++sq;
       }
   }
 
@@ -255,10 +255,10 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) {
       token = char(toupper(token));
 
       if (token == 'K')
-          for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; rsq--) {}
+          for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; --rsq) {}
 
       else if (token == 'Q')
-          for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; rsq++) {}
+          for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; ++rsq) {}
 
       else if (token >= 'A' && token <= 'H')
           rsq = File(token - 'A') | relative_rank(c, RANK_1);
@@ -317,11 +317,11 @@ void Position::set_castle_right(Color c, Square rfrom) {
   Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1);
   Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1);
 
-  for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
+  for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s)
       if (s != kfrom && s != rfrom)
           castlePath[c][cs] |= s;
 
-  for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
+  for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
       if (s != kfrom && s != rfrom)
           castlePath[c][cs] |= s;
 }
@@ -334,9 +334,9 @@ const string Position::fen() const {
 
   std::ostringstream ss;
 
-  for (Rank rank = RANK_8; rank >= RANK_1; rank--)
+  for (Rank rank = RANK_8; rank >= RANK_1; --rank)
   {
-      for (File file = FILE_A; file <= FILE_H; file++)
+      for (File file = FILE_A; file <= FILE_H; ++file)
       {
           Square sq = file | rank;
 
@@ -344,7 +344,7 @@ const string Position::fen() const {
           {
               int emptyCnt = 1;
 
-              for ( ; file < FILE_H && is_empty(sq++); file++)
+              for ( ; file < FILE_H && is_empty(++sq); ++file)
                   emptyCnt++;
 
               ss << emptyCnt;
@@ -1210,9 +1210,9 @@ Key Position::compute_material_key() const {
 
   Key k = 0;
 
-  for (Color c = WHITE; c <= BLACK; c++)
-      for (PieceType pt = PAWN; pt <= QUEEN; pt++)
-          for (int cnt = 0; cnt < pieceCount[c][pt]; cnt++)
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (PieceType pt = PAWN; pt <= QUEEN; ++pt)
+          for (int cnt = 0; cnt < pieceCount[c][pt]; ++cnt)
               k ^= Zobrist::psq[c][pt][cnt];
 
   return k;
@@ -1248,7 +1248,7 @@ Value Position::compute_non_pawn_material(Color c) const {
 
   Value value = VALUE_ZERO;
 
-  for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
+  for (PieceType pt = KNIGHT; pt <= QUEEN; ++pt)
       value += pieceCount[c][pt] * PieceValue[MG][pt];
 
   return value;
@@ -1302,7 +1302,7 @@ void Position::flip() {
   string f, token;
   std::stringstream ss(fen());
 
-  for (Rank rank = RANK_8; rank >= RANK_1; rank--) // Piece placement
+  for (Rank rank = RANK_8; rank >= RANK_1; --rank) // Piece placement
   {
       std::getline(ss, token, rank > RANK_1 ? '/' : ' ');
       f.insert(0, token + (f.empty() ? " " : "/"));
@@ -1366,7 +1366,7 @@ bool Position::pos_is_ok(int* failedStep) const {
   {
       int kingCount[COLOR_NB] = {};
 
-      for (Square s = SQ_A1; s <= SQ_H8; s++)
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
           if (type_of(piece_on(s)) == KING)
               kingCount[color_of(piece_on(s))]++;
 
@@ -1393,8 +1393,8 @@ bool Position::pos_is_ok(int* failedStep) const {
           return false;
 
       // Separate piece type bitboards must have empty intersections
-      for (PieceType p1 = PAWN; p1 <= KING; p1++)
-          for (PieceType p2 = PAWN; p2 <= KING; p2++)
+      for (PieceType p1 = PAWN; p1 <= KING; ++p1)
+          for (PieceType p2 = PAWN; p2 <= KING; ++p2)
               if (p1 != p2 && (pieces(p1) & pieces(p2)))
                   return false;
   }
@@ -1420,21 +1420,21 @@ bool Position::pos_is_ok(int* failedStep) const {
           return false;
 
   if ((*step)++, debugPieceCounts)
-      for (Color c = WHITE; c <= BLACK; c++)
-          for (PieceType pt = PAWN; pt <= KING; pt++)
+      for (Color c = WHITE; c <= BLACK; ++c)
+          for (PieceType pt = PAWN; pt <= KING; ++pt)
               if (pieceCount[c][pt] != popcount<Full>(pieces(c, pt)))
                   return false;
 
   if ((*step)++, debugPieceList)
-      for (Color c = WHITE; c <= BLACK; c++)
-          for (PieceType pt = PAWN; pt <= KING; pt++)
+      for (Color c = WHITE; c <= BLACK; ++c)
+          for (PieceType pt = PAWN; pt <= KING; ++pt)
               for (int i = 0; i < pieceCount[c][pt]; i++)
                   if (   board[pieceList[c][pt][i]] != make_piece(c, pt)
                       || index[pieceList[c][pt][i]] != i)
                       return false;
 
   if ((*step)++, debugCastleSquares)
-      for (Color c = WHITE; c <= BLACK; c++)
+      for (Color c = WHITE; c <= BLACK; ++c)
           for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
           {
               CastleRight cr = make_castle_right(c, s);

diff --git a/src/types.h b/src/types.h
index 4e5de7f72f71214aa63c6616b960c7cd18464c58..a648e6514ed67dd906d3a71dde7270e3a2a97514 100644 (file)
--- a/src/types.h
+++ b/src/types.h
@@ -279,10 +279,10 @@ inline T& operator-=(T& d1, const T d2) { d1 = d1 - d2; return d1; }        \
 inline T& operator*=(T& d, int i) { d = T(int(d) * i); return d; }
 
 #define ENABLE_OPERATORS_ON(T) ENABLE_SAFE_OPERATORS_ON(T)                  \
-inline T operator++(T& d, int) { d = T(int(d) + 1); return d; }             \
-inline T operator--(T& d, int) { d = T(int(d) - 1); return d; }             \
+inline T& operator++(T& d) { return d = T(int(d) + 1); }                    \
+inline T& operator--(T& d) { return d = T(int(d) - 1); }                    \
 inline T operator/(const T d, int i) { return T(int(d) / i); }              \
-inline T& operator/=(T& d, int i) { d = T(int(d) / i); return d; }
+inline T& operator/=(T& d, int i) { return d = T(int(d) / i); }
 
 ENABLE_OPERATORS_ON(Value)
 ENABLE_OPERATORS_ON(PieceType)