Rename attacks_to() in attackers_to()

These functions return bitboard of attacking pieces,
not the attacks themselfs so reflect this in the name.

No functional change.

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

src/movegen.cpp

@@ -235,7 +235,7 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin
   // Find squares attacked by slider checkers, we will
   // remove them from king evasions set so to avoid a couple
   // of cycles in the slow king evasions legality check loop
-  // and to be able to use attacks_to().
+  // and to be able to use attackers_to().
   Bitboard checkers = pos.checkers();
   Bitboard checkersAttacks = EmptyBoardBB;
   Bitboard b = checkers & pos.pieces(BISHOP, QUEEN);
@@ -257,9 +257,9 @@ MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pin
   while (b1)
   {
       to = pop_1st_bit(&b1);
-      // Note that we can use attacks_to() only because we
+      // Note that we can use attackers_to() only because we
       // have already removed slider checkers.
-      if (!pos.attacks_to(to, them))
+      if (!pos.attackers_to(to, them))
           (*mlist++).move = make_move(ksq, to);
   }
 
@@ -441,7 +441,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
       // is occupied or under attack.
       for (s = Min(from, g1); s <= Max(from, g1); s++)
           if (  (s != from && s != to && !pos.square_is_empty(s))
-              || pos.attacks_to(s, them))
+              || pos.attackers_to(s, them))
               illegal = true;
 
       // Check if any of the squares between king and rook
@@ -472,7 +472,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
       for (s = Min(from, c1); s <= Max(from, c1); s++)
           if(  (s != from && s != to && !pos.square_is_empty(s))
-             || pos.attacks_to(s, them))
+             || pos.attackers_to(s, them))
               illegal = true;
 
       for (s = Min(to, d1); s <= Max(to, d1); s++)
@@ -942,7 +942,7 @@ namespace {
         // It is a bit complicated to correctly handle Chess960
         for (s = Min(ksq, s1); s <= Max(ksq, s1); s++)
             if (  (s != ksq && s != rsq && pos.square_is_occupied(s))
-                || pos.attacks_to(s, them))
+                || pos.attackers_to(s, them))
                 illegal = true;
 
         for (s = Min(rsq, s2); s <= Max(rsq, s2); s++)

src/position.cpp

@@ -379,10 +379,10 @@ Bitboard Position::discovered_check_candidates(Color c) const {
   return hidden_checkers<false>(c);
 }
 
-/// Position::attacks_to() computes a bitboard containing all pieces which
+/// Position::attackers_to() computes a bitboard containing all pieces which
 /// attacks a given square.
 
-Bitboard Position::attacks_to(Square s) const {
+Bitboard Position::attackers_to(Square s) const {
 
   return  (pawn_attacks(s, BLACK)   & pieces(PAWN, WHITE))
         | (pawn_attacks(s, WHITE)   & pieces(PAWN, BLACK))
@@ -446,14 +446,14 @@ bool Position::move_attacks_square(Move m, Square s) const {
 
 /// Position::find_checkers() computes the checkersBB bitboard, which
 /// contains a nonzero bit for each checking piece (0, 1 or 2). It
-/// currently works by calling Position::attacks_to, which is probably
+/// currently works by calling Position::attackers_to, which is probably
 /// inefficient. Consider rewriting this function to use the last move
 /// played, like in non-bitboard versions of Glaurung.
 
 void Position::find_checkers() {
 
   Color us = side_to_move();
-  st->checkersBB = attacks_to(king_square(us), opposite_color(us));
+  st->checkersBB = attackers_to(king_square(us), opposite_color(us));
 }
 
 
@@ -510,7 +510,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
   // If the moving piece is a king, check whether the destination
   // square is attacked by the opponent.
   if (type_of_piece_on(from) == KING)
-      return !attacks_to(move_to(m), opposite_color(us));
+      return !attackers_to(move_to(m), opposite_color(us));
 
   // A non-king move is legal if and only if it is not pinned or it
   // is moving along the ray towards or away from the king.
@@ -864,7 +864,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
 
   // Update checkers bitboard, piece must be already moved
   if (ep | pm)
-      st->checkersBB = attacks_to(king_square(them), us);
+      st->checkersBB = attackers_to(king_square(them), us);
   else
   {
       st->checkersBB = EmptyBoardBB;
@@ -1041,7 +1041,7 @@ void Position::do_castle_move(Move m) {
   st->rule50 = 0;
 
   // Update checkers BB
-  st->checkersBB = attacks_to(king_square(them), us);
+  st->checkersBB = attackers_to(king_square(them), us);
 
   // Finish
   sideToMove = opposite_color(sideToMove);
@@ -1923,7 +1923,7 @@ bool Position::is_ok(int* failedStep) const {
       Color us = side_to_move();
       Color them = opposite_color(us);
       Square ksq = king_square(them);
-      if (attacks_to(ksq, us))
+      if (attackers_to(ksq, us))
           return false;
   }
 

src/position.h

@@ -196,8 +196,8 @@ public:
   Square piece_list(Color c, PieceType pt, int index) const;
 
   // Attack information to a given square
-  Bitboard attacks_to(Square s) const;
-  Bitboard attacks_to(Square s, Color c) const;
+  Bitboard attackers_to(Square s) const;
+  Bitboard attackers_to(Square s, Color c) const;
   template<PieceType> Bitboard piece_attacks(Square s) const;
   Bitboard pawn_attacks(Square s, Color c) const;
 
@@ -483,9 +483,9 @@ inline Bitboard Position::piece_attacks_square(Square f, Square t) const {
   return bit_is_set(piece_attacks<Piece>(f), t);
 }
 
-inline Bitboard Position::attacks_to(Square s, Color c) const {
+inline Bitboard Position::attackers_to(Square s, Color c) const {
 
-  return attacks_to(s) & pieces_of_color(c);
+  return attackers_to(s) & pieces_of_color(c);
 }
 
 inline bool Position::pawn_is_passed(Color c, Square s) const {

src/search.cpp

@@ -2439,8 +2439,9 @@ namespace {
     n = Slowdown;
     for (i = 0; i < n; i++)  {
         Square s = Square(i&63);
-        if (count_1s(pos.attacks_to(s)) > 63)
-            std::cout << "This can't happen, but I put this string here anyway, in order to prevent the compiler from optimizing away the useless computation." << std::endl;
+        if (count_1s(pos.attackers_to(s)) > 63)
+            std::cout << "This can't happen, but I put this string here anyway, in order to "
+                         "prevent the compiler from optimizing away the useless computation." << std::endl;
     }
   }