Better naming of pseudo-legality and legality testing

No functional change.

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

src/movegen.cpp

@@ -385,20 +385,20 @@ int generate_legal_moves(const Position& pos, MoveStack* mlist) {
 
   // Remove illegal moves from the list
   for (int i = 0; i < n; i++)
-      if (!pos.move_is_legal(mlist[i].move, pinned))
+      if (!pos.pl_move_is_legal(mlist[i].move, pinned))
           mlist[i--].move = mlist[--n].move;
 
   return n;
 }
 
 
-/// generate_move_if_legal() takes a position and a (not necessarily
+/// move_is_legal() takes a position and a (not necessarily pseudo-legal)
-/// pseudo-legal) move and a pinned pieces bitboard as input, and tests
+/// move and a pinned pieces bitboard as input, and tests whether
-/// whether the move is legal.  If the move is legal, the move itself is
+/// the move is legal.  If the move is legal, the move itself is
-/// returned.  If not, the function returns MOVE_NONE.  This function must
+/// returned. If not, the function returns false.  This function must
 /// only be used when the side to move is not in check.
 
-Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
+bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
@@ -413,7 +413,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
   // If the from square is not occupied by a piece belonging to the side to
   // move, the move is obviously not legal.
   if (color_of_piece(pc) != us)
-      return MOVE_NONE;
+      return false;
 
   Square to = move_to(m);
 
@@ -424,13 +424,13 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       // en passant square.
       if (   type_of_piece(pc) != PAWN
           || to != pos.ep_square())
-          return MOVE_NONE;
+          return false;
 
       assert(pos.square_is_empty(to));
       assert(pos.piece_on(to - pawn_push(us)) == pawn_of_color(them));
 
-      // The move is pseudo-legal.  If it is legal, return it.
+      // The move is pseudo-legal, check if it is also legal
-      return (pos.move_is_legal(m, pinned) ? m : MOVE_NONE);
+      return pos.pl_move_is_legal(m, pinned);
   }
 
   // Castling moves
@@ -440,7 +440,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       // the right to castle kingside.
       if (   type_of_piece(pc) != KING
           ||!pos.can_castle_kingside(us))
-          return MOVE_NONE;
+          return false;
 
       assert(from == pos.king_square(us));
       assert(to == pos.initial_kr_square(us));
@@ -464,7 +464,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
           if (s != from && s != to && !pos.square_is_empty(s))
               illegal = true;
 
-      return (!illegal ? m : MOVE_NONE);
+      return !illegal;
   }
 
   if (move_is_long_castle(m))
@@ -473,7 +473,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       // the right to castle kingside.
       if (   type_of_piece(pc) != KING
           ||!pos.can_castle_queenside(us))
-          return MOVE_NONE;
+          return false;
 
       assert(from == pos.king_square(us));
       assert(to == pos.initial_qr_square(us));
@@ -498,14 +498,14 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
               || pos.piece_on(to + DELTA_W) == queen_of_color(them)))
           illegal = true;
 
-      return (!illegal ? m : MOVE_NONE);
+      return !illegal;
   }
 
   // Normal moves
 
   // The destination square cannot be occupied by a friendly piece
   if (pos.color_of_piece_on(to) == us)
-      return MOVE_NONE;
+      return false;
 
   // Proceed according to the type of the moving piece.
   if (type_of_piece(pc) == PAWN)
@@ -515,7 +515,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       if (   (  (square_rank(to) == RANK_8 && us == WHITE)
               ||(square_rank(to) == RANK_1 && us != WHITE))
            && !move_promotion(m))
-          return MOVE_NONE;
+          return false;
 
       // Proceed according to the square delta between the source and
       // destionation squares.
@@ -528,14 +528,14 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       // Capture. The destination square must be occupied by an enemy
       // piece (en passant captures was handled earlier).
           if (pos.color_of_piece_on(to) != them)
-              return MOVE_NONE;
+              return false;
           break;
 
       case DELTA_N:
       case DELTA_S:
       // Pawn push. The destination square must be empty.
           if (!pos.square_is_empty(to))
-              return MOVE_NONE;
+              return false;
           break;
 
       case DELTA_NN:
@@ -545,7 +545,7 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
       if (   square_rank(to) != RANK_4
           || !pos.square_is_empty(to)
           || !pos.square_is_empty(from + DELTA_N))
-          return MOVE_NONE;
+          return false;
           break;
 
       case DELTA_SS:
@@ -555,20 +555,20 @@ Move generate_move_if_legal(const Position& pos, Move m, Bitboard pinned) {
           if (   square_rank(to) != RANK_5
               || !pos.square_is_empty(to)
               || !pos.square_is_empty(from + DELTA_S))
-              return MOVE_NONE;
+              return false;
           break;
 
       default:
-          return MOVE_NONE;
+          return false;
       }
-      // The move is pseudo-legal. Return it if it is legal.
+      // The move is pseudo-legal, check if it is also legal
-      return (pos.move_is_legal(m, pinned) ? m : MOVE_NONE);
+      return pos.pl_move_is_legal(m, pinned);
   }
 
   // Luckly we can handle all the other pieces in one go
   return (   pos.piece_attacks_square(from, to)
-          && pos.move_is_legal(m, pinned)
+          && pos.pl_move_is_legal(m, pinned)
-          && !move_promotion(m) ? m : MOVE_NONE);
+          && !move_promotion(m));
 }
 
 

src/movegen.h

@@ -37,6 +37,6 @@ extern int generate_noncaptures(const Position &pos, MoveStack *mlist);
 extern int generate_checks(const Position &pos, MoveStack *mlist, Bitboard dc);
 extern int generate_evasions(const Position &pos, MoveStack *mlist);
 extern int generate_legal_moves(const Position &pos, MoveStack *mlist);
-extern Move generate_move_if_legal(const Position &pos, Move m, Bitboard pinned);
+extern bool move_is_legal(const Position &pos, const Move m, Bitboard pinned);
 
 #endif // !defined(MOVEGEN_H_INCLUDED)

src/movepick.cpp

@@ -116,7 +116,7 @@ Move MovePicker::get_next_move() {
         if (ttMove != MOVE_NONE)
         {
             assert(move_is_ok(ttMove));
-            if (generate_move_if_legal(pos, ttMove, pinned) != MOVE_NONE)
+            if (move_is_legal(pos, ttMove, pinned))
                 return ttMove;
         }
         break;
@@ -125,7 +125,7 @@ Move MovePicker::get_next_move() {
         if (mateKiller != MOVE_NONE)
         {
             assert(move_is_ok(mateKiller));
-            if (generate_move_if_legal(pos, mateKiller, pinned) != MOVE_NONE)
+            if (move_is_legal(pos, mateKiller, pinned))
                 return mateKiller;
        }
        break;
@@ -333,7 +333,7 @@ Move MovePicker::pick_move_from_list() {
               moves[bestIndex] = moves[movesPicked++];
               if (   move != ttMove
                   && move != mateKiller
-                  && pos.move_is_legal(move, pinned))
+                  && pos.pl_move_is_legal(move, pinned))
                   return move;
           }
       }
@@ -357,7 +357,7 @@ Move MovePicker::pick_move_from_list() {
               moves[bestIndex] = moves[movesPicked++];
               if (   move != ttMove
                   && move != mateKiller
-                  && pos.move_is_legal(move, pinned))
+                  && pos.pl_move_is_legal(move, pinned))
                   return move;
           }
       }
@@ -390,7 +390,7 @@ Move MovePicker::pick_move_from_list() {
           move = badCaptures[badCapturesPicked++].move;
           if (   move != ttMove
               && move != mateKiller
-              && pos.move_is_legal(move, pinned))
+              && pos.pl_move_is_legal(move, pinned))
               return move;
       }
       break;
@@ -408,7 +408,7 @@ Move MovePicker::pick_move_from_list() {
               moves[bestIndex] = moves[movesPicked++];
               // Remember to change the line below if we decide to hash the qsearch!
               // Maybe also postpone the legality check until after futility pruning?
-              if (/* move != ttMove && */ pos.move_is_legal(move, pinned))
+              if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned))
                   return move;
           }
       }
@@ -423,7 +423,7 @@ Move MovePicker::pick_move_from_list() {
       {
           move = moves[movesPicked++].move;
           // Remember to change the line below if we decide to hash the qsearch!
-          if (/* move != ttMove && */ pos.move_is_legal(move, pinned))
+          if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned))
               return move;
       }
       break;

src/position.cpp

@@ -456,18 +456,18 @@ void Position::find_checkers() {
 }
 
 
-/// Position::move_is_legal() tests whether a pseudo-legal move is legal.
+/// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal.
 /// There are two versions of this function:  One which takes only a
 /// move as input, and one which takes a move and a bitboard of pinned
 /// pieces. The latter function is faster, and should always be preferred
 /// when a pinned piece bitboard has already been computed.
 
-bool Position::move_is_legal(Move m)  const {
+bool Position::pl_move_is_legal(Move m)  const {
 
-  return move_is_legal(m, pinned_pieces(side_to_move()));
+  return pl_move_is_legal(m, pinned_pieces(side_to_move()));
 }
 
-bool Position::move_is_legal(Move m, Bitboard pinned) const {
+bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
 
   Color us, them;
   Square ksq, from;

src/position.h

@@ -217,8 +217,8 @@ public:
   bool piece_attacks_square(Square f, Square t) const; // Dispatch at run-time
 
   // Properties of moves
-  bool move_is_legal(Move m) const;
+  bool pl_move_is_legal(Move m) const;
-  bool move_is_legal(Move m, Bitboard pinned) const;
+  bool pl_move_is_legal(Move m, Bitboard pinned) const;
   bool move_is_check(Move m) const;
   bool move_is_check(Move m, Bitboard dcCandidates) const;
   bool move_is_capture(Move m) const;

src/san.cpp

@@ -161,14 +161,14 @@ Move move_from_san(Position &pos, const std::string &movestr) {
   if(movestr == "O-O-O") {
     Move m;
     while((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_long_castle(m) && pos.move_is_legal(m))
+      if(move_is_long_castle(m) && pos.pl_move_is_legal(m))
         return m;
     return MOVE_NONE;
   }
   else if(movestr == "O-O") {
     Move m;
     while((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_short_castle(m) && pos.move_is_legal(m))
+      if(move_is_short_castle(m) && pos.pl_move_is_legal(m))
         return m;
     return MOVE_NONE;
   }
@@ -358,7 +358,7 @@ namespace {
     n = 0;
     while((mv = mp.get_next_move()) != MOVE_NONE)
       if(move_to(mv) == to && pos.piece_on(move_from(mv)) == pc
-         && pos.move_is_legal(mv))
+         && pos.pl_move_is_legal(mv))
         moveList[n++] = mv;
     if(n == 1)
       return AMBIGUITY_NONE;