Skip to content

Commit

Permalink
Fix operator++ definition
Browse files Browse the repository at this point in the history 
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.
  • Loading branch information
@mcostalba
mcostalba committed Sep 15, 2013
1 parent 82f6779 commit 7a1ff6d
Show file tree
Hide file tree
Showing 4 changed files with 49 additions and 49 deletions.
32 changes: 16 additions & 16 deletions src/bitboard.cpp
View file
Expand Up @@ -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";
Expand All @@ -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;
Expand All @@ -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)
Expand All @@ -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]);
Expand All @@ -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);
Expand Down Expand Up @@ -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));
Expand Down
6 changes: 3 additions & 3 deletions src/evaluate.cpp
View file
Expand Up @@ -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];
}
Expand Down Expand Up @@ -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))
Expand Down
54 changes: 27 additions & 27 deletions src/position.cpp
View file
Expand Up @@ -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++)
Expand All @@ -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]);
Expand Down Expand Up @@ -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;
}
}

Expand All @@ -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);
Expand Down Expand Up @@ -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;
}
Expand All @@ -334,17 +334,17 @@ 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;

if (is_empty(sq))
{
int emptyCnt = 1;

for ( ; file < FILE_H && is_empty(sq++); file++)
for ( ; file < FILE_H && is_empty(++sq); ++file)
emptyCnt++;

ss << emptyCnt;
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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() ? " " : "/"));
Expand Down Expand Up @@ -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))]++;

Expand All @@ -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;
}
Expand All @@ -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);
Expand Down
6 changes: 3 additions & 3 deletions src/types.h
View file
Expand Up @@ -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)
Expand Down

0 comments on commit 7a1ff6d

Please sign in to comment.