X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovegen.cpp;h=ced938e8c2b9e835ef3b44e16088a7d2f4a31a2c;hp=4ae16b4b37eb71ede0d8abf96fee0695f153e3ec;hb=6e840f8033aab2b73c8b99b00cb91a20ed578e2b;hpb=dc88cd691f5b393fe52c1b2be93d467def7391ea

diff --git a/src/movegen.cpp b/src/movegen.cpp
index 4ae16b4b..ced938e8 100644
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -25,10 +25,10 @@
 
 /// Simple macro to wrap a very common while loop, no facny, no flexibility,
 /// hardcoded names 'mlist' and 'from'.
-#define SERIALIZE(b) while (b) (*mlist++).move = make_move(from, pop_1st_bit(&b))
+#define SERIALIZE(b) while (b) (*mlist++).move = make_move(from, pop_lsb(&b))
 
 /// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
-#define SERIALIZE_PAWNS(b, d) while (b) { Square to = pop_1st_bit(&b); \
+#define SERIALIZE_PAWNS(b, d) while (b) { Square to = pop_lsb(&b); \
                                          (*mlist++).move = make_move(to - (d), to); }
 namespace {
 
@@ -87,7 +87,7 @@ namespace {
 
     while (b)
     {
-        Square to = pop_1st_bit(&b);
+        Square to = pop_lsb(&b);
 
         if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
             (*mlist++).move = make<PROMOTION>(to - Delta, to, QUEEN);
@@ -207,7 +207,7 @@ namespace {
             assert(b1);
 
             while (b1)
-                (*mlist++).move = make<ENPASSANT>(pop_1st_bit(&b1), pos.ep_square());
+                (*mlist++).move = make<ENPASSANT>(pop_lsb(&b1), pos.ep_square());
         }
     }
 
@@ -215,61 +215,40 @@ namespace {
   }
 
 
-  template<PieceType Pt>
-  inline MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist,
-                                           Color us, const CheckInfo& ci) {
+  template<PieceType Pt, bool OnlyChecks> FORCE_INLINE
+  MoveStack* generate_moves(const Position& pos, MoveStack* mlist, Color us,
+                            Bitboard target, const CheckInfo* ci = NULL) {
+
     assert(Pt != KING && Pt != PAWN);
 
-    Bitboard b, target;
-    Square from;
     const Square* pl = pos.piece_list(us, Pt);
 
-    if (*pl != SQ_NONE)
+    for (Square from = *pl; from != SQ_NONE; from = *++pl)
     {
-        target = ci.checkSq[Pt] & ~pos.pieces(); // Non capture checks only
-
-        do {
-            from = *pl;
-
+        if (OnlyChecks)
+        {
             if (    (Pt == BISHOP || Pt == ROOK || Pt == QUEEN)
-                && !(PseudoAttacks[Pt][from] & target))
+                && !(PseudoAttacks[Pt][from] & target & ci->checkSq[Pt]))
                 continue;
 
-            if (ci.dcCandidates && (ci.dcCandidates & from))
+            if (ci->dcCandidates && (ci->dcCandidates & from))
                 continue;
+        }
 
-            b = pos.attacks_from<Pt>(from) & target;
-            SERIALIZE(b);
-        } while (*++pl != SQ_NONE);
-    }
-
-    return mlist;
-  }
-
+        Bitboard b = pos.attacks_from<Pt>(from) & target;
 
-  template<PieceType Pt>
-  FORCE_INLINE MoveStack* generate_moves(const Position& pos, MoveStack* mlist,
-                                         Color us, Bitboard target) {
-    assert(Pt != KING && Pt != PAWN);
+        if (OnlyChecks)
+            b &= ci->checkSq[Pt];
 
-    Bitboard b;
-    Square from;
-    const Square* pl = pos.piece_list(us, Pt);
-
-    if (*pl != SQ_NONE)
-        do {
-            from = *pl;
-            b = pos.attacks_from<Pt>(from) & target;
-            SERIALIZE(b);
-        } while (*++pl != SQ_NONE);
+        SERIALIZE(b);
+    }
 
     return mlist;
   }
 
-
-  template<>
-  FORCE_INLINE MoveStack* generate_moves<KING>(const Position& pos, MoveStack* mlist,
-                                               Color us, Bitboard target) {
+  template<> FORCE_INLINE
+  MoveStack* generate_moves<KING, false>(const Position& pos, MoveStack* mlist, Color us,
+                                         Bitboard target, const CheckInfo*) {
     Square from = pos.king_square(us);
     Bitboard b = pos.attacks_from<KING>(from) & target;
     SERIALIZE(b);
@@ -309,15 +288,15 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
   mlist = (us == WHITE ? generate_pawn_moves<WHITE, Type>(pos, mlist, target)
                        : generate_pawn_moves<BLACK, Type>(pos, mlist, target));
 
-  mlist = generate_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_moves<ROOK>(pos, mlist, us, target);
-  mlist = generate_moves<QUEEN>(pos, mlist, us, target);
-  mlist = generate_moves<KING>(pos, mlist, us, target);
+  mlist = generate_moves<KNIGHT, false>(pos, mlist, us, target);
+  mlist = generate_moves<BISHOP, false>(pos, mlist, us, target);
+  mlist = generate_moves<ROOK,   false>(pos, mlist, us, target);
+  mlist = generate_moves<QUEEN,  false>(pos, mlist, us, target);
+  mlist = generate_moves<KING,   false>(pos, mlist, us, target);
 
   if (Type != CAPTURES && pos.can_castle(us))
   {
-      mlist = generate_castle<KING_SIDE, false>(pos, mlist, us);
+      mlist = generate_castle<KING_SIDE,  false>(pos, mlist, us);
       mlist = generate_castle<QUEEN_SIDE, false>(pos, mlist, us);
   }
 
@@ -339,11 +318,12 @@ MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
 
   Color us = pos.side_to_move();
   CheckInfo ci(pos);
+  Bitboard empty = ~pos.pieces();
   Bitboard dc = ci.dcCandidates;
 
   while (dc)
   {
-     Square from = pop_1st_bit(&dc);
+     Square from = pop_lsb(&dc);
      PieceType pt = type_of(pos.piece_on(from));
 
      if (pt == PAWN)
@@ -360,14 +340,14 @@ MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
   mlist = (us == WHITE ? generate_pawn_moves<WHITE, QUIET_CHECKS>(pos, mlist, ci.dcCandidates, ci.ksq)
                        : generate_pawn_moves<BLACK, QUIET_CHECKS>(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<QUEEN>(pos, mlist, us, ci);
+  mlist = generate_moves<KNIGHT, true>(pos, mlist, us, empty, &ci);
+  mlist = generate_moves<BISHOP, true>(pos, mlist, us, empty, &ci);
+  mlist = generate_moves<ROOK,   true>(pos, mlist, us, empty, &ci);
+  mlist = generate_moves<QUEEN,  true>(pos, mlist, us, empty, &ci);
 
   if (pos.can_castle(us))
   {
-      mlist = generate_castle<KING_SIDE, true>(pos, mlist, us);
+      mlist = generate_castle<KING_SIDE,  true>(pos, mlist, us);
       mlist = generate_castle<QUEEN_SIDE, true>(pos, mlist, us);
   }
 
@@ -398,7 +378,7 @@ MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {
   do
   {
       checkersCnt++;
-      checksq = pop_1st_bit(&b);
+      checksq = pop_lsb(&b);
 
       assert(color_of(pos.piece_on(checksq)) == ~us);
 
@@ -439,10 +419,10 @@ MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {
   mlist = (us == WHITE ? generate_pawn_moves<WHITE, EVASIONS>(pos, mlist, target)
                        : generate_pawn_moves<BLACK, EVASIONS>(pos, mlist, target));
 
-  mlist = generate_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_moves<ROOK>(pos, mlist, us, target);
-  return  generate_moves<QUEEN>(pos, mlist, us, target);
+  mlist = generate_moves<KNIGHT, false>(pos, mlist, us, target);
+  mlist = generate_moves<BISHOP, false>(pos, mlist, us, target);
+  mlist = generate_moves<ROOK,   false>(pos, mlist, us, target);
+  return  generate_moves<QUEEN,  false>(pos, mlist, us, target);
 }