Unify some template specializations

No functional change.

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

diff --git a/src/movegen.cpp b/src/movegen.cpp
index 0ec1fceabbf7a132fbd931d5e7481b37affc0c52..64c44f28a0eba0d4d985854339e3aa50bd2f130f 100644 (file)
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -141,12 +141,13 @@ namespace {
         else
             (void)ksq; // Silence a warning under MSVC
     }
         else
             (void)ksq; // Silence a warning under MSVC
     }

+

     return mlist;
   }
 
 
   template<Color Us, MoveType Type>
     return mlist;
   }
 
 
   template<Color Us, MoveType Type>

-  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard target, Square ksq) {
+  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard target, Square ksq = SQ_NONE) {

 
     // Calculate our parametrized parameters at compile time, named according to
     // the point of view of white side.
 
     // Calculate our parametrized parameters at compile time, named according to
     // the point of view of white side.


@@ -251,14 +252,13 @@ namespace {
                                            Color us, const CheckInfo& ci) {
     assert(Pt != KING && Pt != PAWN);
 
                                            Color us, const CheckInfo& ci) {
     assert(Pt != KING && Pt != PAWN);
 

-    Bitboard checkSqs, b;

     Square from;
     const Square* pl = pos.piece_list(us, Pt);
 
     if ((from = *pl++) == SQ_NONE)
         return mlist;
 
     Square from;
     const Square* pl = pos.piece_list(us, Pt);
 
     if ((from = *pl++) == SQ_NONE)
         return mlist;
 

-    checkSqs = ci.checkSq[Pt] & pos.empty_squares();
+    Bitboard checkSqs = ci.checkSq[Pt] & pos.empty_squares();

 
     do
     {
 
     do
     {


@@ -269,7 +269,7 @@ namespace {
         if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
             continue;
 
         if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
             continue;
 

-        b = pos.attacks_from<Pt>(from) & checkSqs;
+        Bitboard b = pos.attacks_from<Pt>(from) & checkSqs;

         SERIALIZE(b);
 
     } while ((from = *pl++) != SQ_NONE);
         SERIALIZE(b);
 
     } while ((from = *pl++) != SQ_NONE);


@@ -278,24 +278,6 @@ namespace {
   }
 
 
   }
 
 

-  template<>
-  FORCE_INLINE MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m,
-                                                       Color us, const CheckInfo& ci) {
-
-    return us == WHITE ? generate_pawn_moves<WHITE, MV_NON_CAPTURE_CHECK>(p, m, ci.dcCandidates, ci.ksq)
-                       : generate_pawn_moves<BLACK, MV_NON_CAPTURE_CHECK>(p, m, ci.dcCandidates, ci.ksq);
-  }
-
-
-  template<PieceType Pt, MoveType Type>
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us, Bitboard t) {
-
-    assert(Pt == PAWN);
-    return us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m, t, SQ_NONE)
-                       : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE);
-  }
-
-

   template<PieceType Pt>
   FORCE_INLINE MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
 
   template<PieceType Pt>
   FORCE_INLINE MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
 


@@ -311,6 +293,7 @@ namespace {
             SERIALIZE(b);
         } while (*++pl != SQ_NONE);
     }
             SERIALIZE(b);
         } while (*++pl != SQ_NONE);
     }

+

     return mlist;
   }
 
     return mlist;
   }
 


@@ -354,7 +337,9 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
   else if (Type == MV_NON_EVASION)
       target = pos.pieces(~us) | pos.empty_squares();
 
   else if (Type == MV_NON_EVASION)
       target = pos.pieces(~us) | pos.empty_squares();
 

-  mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target);
+  mlist = (us == WHITE ? generate_pawn_moves<WHITE, Type>(pos, mlist, target)
+                       : generate_pawn_moves<BLACK, Type>(pos, mlist, target));
+

   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
   mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
   mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
   mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
   mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);


@@ -403,7 +388,9 @@ MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist)
      SERIALIZE(b);
   }
 
      SERIALIZE(b);
   }
 

-  mlist = generate_direct_checks<PAWN>(pos, mlist, us, ci);
+  mlist = (us == WHITE ? generate_pawn_moves<WHITE, MV_NON_CAPTURE_CHECK>(pos, mlist, ci.dcCandidates, ci.ksq)
+                       : generate_pawn_moves<BLACK, MV_NON_CAPTURE_CHECK>(pos, mlist, ci.dcCandidates, ci.ksq));
+

   mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, ci);
   mlist = generate_direct_checks<BISHOP>(pos, mlist, us, ci);
   mlist = generate_direct_checks<ROOK>(pos, mlist, us, ci);
   mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, ci);
   mlist = generate_direct_checks<BISHOP>(pos, mlist, us, ci);
   mlist = generate_direct_checks<ROOK>(pos, mlist, us, ci);


@@ -480,7 +467,9 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
   // Blocking evasions or captures of the checking piece
   target = squares_between(checksq, ksq) | checkers;
 
   // Blocking evasions or captures of the checking piece
   target = squares_between(checksq, ksq) | checkers;
 

-  mlist = generate_piece_moves<PAWN, MV_EVASION>(pos, mlist, us, target);
+  mlist = (us == WHITE ? generate_pawn_moves<WHITE, MV_EVASION>(pos, mlist, target)
+                       : generate_pawn_moves<BLACK, MV_EVASION>(pos, mlist, target));
+

   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
   mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
   mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
   mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
   mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);

diff --git a/src/position.h b/src/position.h
index c391d8247c72f4530d78d942a1d087eb1d472180..bcbfc850d0c8b15eb4677f63b447996fde6fdeca 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -342,29 +342,17 @@ inline Square Position::castle_rook_square(CastleRight f) const {
   return castleRookSquare[f];
 }
 
   return castleRookSquare[f];
 }
 

-template<>
-inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
-  return StepAttacksBB[make_piece(c, PAWN)][s];
-}
-
-template<PieceType Piece> // Knight and King and white pawns
+template<PieceType Pt>

 inline Bitboard Position::attacks_from(Square s) const {
 inline Bitboard Position::attacks_from(Square s) const {

-  return StepAttacksBB[Piece][s];
+  return  Pt == BISHOP ? bishop_attacks_bb(s, occupied_squares())
+        : Pt == ROOK   ? rook_attacks_bb(s, occupied_squares())
+        : Pt == QUEEN  ? attacks_from<ROOK>(s) | attacks_from<BISHOP>(s)
+                       : StepAttacksBB[Pt][s];

 }
 
 template<>
 }
 
 template<>

-inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
-  return bishop_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<ROOK>(Square s) const {
-  return rook_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
-  return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
+inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
+  return StepAttacksBB[make_piece(c, PAWN)][s];

 }
 
 inline Bitboard Position::attacks_from(Piece p, Square s) const {
 }
 
 inline Bitboard Position::attacks_from(Piece p, Square s) const {