Another round of bitboard.cpp cleanups

Also renamed StepAttackBB[] in NonSlidingAttacksBB[]

No functional change.

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

src/bitbase.cpp

@@ -47,9 +47,9 @@ namespace {
     bool is_legal() const;
     bool is_immediate_draw() const;
     bool is_immediate_win() const;
-    Bitboard wk_attacks()   const { return StepAttackBB[WK][whiteKingSquare]; }
+    Bitboard wk_attacks()   const { return NonSlidingAttacksBB[WK][whiteKingSquare]; }
-    Bitboard bk_attacks()   const { return StepAttackBB[BK][blackKingSquare]; }
+    Bitboard bk_attacks()   const { return NonSlidingAttacksBB[BK][blackKingSquare]; }
-    Bitboard pawn_attacks() const { return StepAttackBB[WP][pawnSquare]; }
+    Bitboard pawn_attacks() const { return NonSlidingAttacksBB[WP][pawnSquare]; }
 
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;

src/bitboard.cpp

@@ -213,6 +213,8 @@ const Bitboard InFrontBB[2][8] = {
   }
 };
 
+// Global bitboards definitions with static storage duration are
+// automatically set to zero before enter main().
 Bitboard RMask[64];
 int RAttackIndex[64];
 Bitboard RAttacks[0x19000];
@@ -224,7 +226,7 @@ Bitboard BAttacks[0x1480];
 Bitboard SetMaskBB[65];
 Bitboard ClearMaskBB[65];
 
-Bitboard StepAttackBB[16][64];
+Bitboard NonSlidingAttacksBB[16][64];
 Bitboard BetweenBB[64][64];
 
 Bitboard SquaresInFrontMask[2][64];
@@ -238,16 +240,12 @@ Bitboard QueenPseudoAttacks[64];
 uint8_t BitCount8Bit[256];
 
 
-////
-//// Local definitions
-////
-
 namespace {
 
   void init_masks();
-  void init_attacks();
+  void init_non_sliding_attacks();
-  void init_between_bitboards();
   void init_pseudo_attacks();
+  void init_between_bitboards();
   Bitboard index_to_bitboard(int index, Bitboard mask);
   Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
                            int fmin, int fmax, int rmin, int rmax);
@@ -256,44 +254,23 @@ namespace {
 }
 
 
-////
-//// Functions
-////
-
 /// print_bitboard() prints a bitboard in an easily readable format to the
-/// standard output.  This is sometimes useful for debugging.
+/// standard output. This is sometimes useful for debugging.
 
 void print_bitboard(Bitboard b) {
 
   for (Rank r = RANK_8; r >= RANK_1; r--)
   {
-      std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
+      std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
       for (File f = FILE_A; f <= FILE_H; f++)
           std::cout << "| " << (bit_is_set(b, make_square(f, r))? 'X' : ' ') << ' ';
 
-      std::cout << "|" << std::endl;
+      std::cout << "|\n";
   }
   std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
 }
 
 
-/// init_bitboards() initializes various bitboard arrays.  It is called during
-/// program initialization.
-
-void init_bitboards() {
-
-  int rookDeltas[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
-  int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
-
-  init_masks();
-  init_attacks();
-  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
-  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
-  init_pseudo_attacks();
-  init_between_bitboards();
-}
-
-
 /// first_1() finds the least significant nonzero bit in a nonzero bitboard.
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.
@@ -373,6 +350,22 @@ Square pop_1st_bit(Bitboard* bb) {
 #endif
 
 
+/// init_bitboards() initializes various bitboard arrays. It is called during
+/// program initialization.
+
+void init_bitboards() {
+
+  int rookDeltas[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
+  int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
+
+  init_masks();
+  init_non_sliding_attacks();
+  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
+  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
+  init_pseudo_attacks();
+  init_between_bitboards();
+}
+
 namespace {
 
   // All functions below are used to precompute various bitboards during
@@ -382,7 +375,7 @@ namespace {
 
   void init_masks() {
 
-    SetMaskBB[SQ_NONE] = 0ULL;
+    SetMaskBB[SQ_NONE] = EmptyBoardBB;
     ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
 
     for (Square s = SQ_A1; s <= SQ_H8; s++)
@@ -403,32 +396,30 @@ namespace {
         BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
   }
 
-  void init_attacks() {
+  void init_non_sliding_attacks() {
 
-    const int step[16][8] =  {
+    const int step[][9] =  {
       {0},
-      {7,9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
+      {7,9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
-      {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}, {0}, {0},
+      {9,7,-7,-9,8,1,-1,-8,0}, {0}, {0},
-      {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
+      {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
-      {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}
+      {9,7,-7,-9,8,1,-1,-8,0}
     };
 
-    for (int i = 0; i < 64; i++)
+    for (Square s = SQ_A1; s <= SQ_H8; s++)
-        for (int j = 0; j <= int(BK); j++)
+        for (Piece pc = WP; pc <= BK; pc++)
-        {
+            for (int k = 0; step[pc][k] != 0; k++)
-            StepAttackBB[j][i] = EmptyBoardBB;
-            for (int k = 0; k < 8 && step[j][k] != 0; k++)
             {
-                int l = i + step[j][k];
+                Square to = s + Square(step[pc][k]);
-                if (l >= 0 && l < 64 && abs((i & 7) - (l & 7)) < 3)
+
-                    StepAttackBB[j][i] |= (1ULL << l);
+                if (square_is_ok(to) && square_distance(s, to) < 3)
+                    set_bit(&NonSlidingAttacksBB[pc][s], to);
            }
-        }
   }
 
   Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
                            int fmin=0, int fmax=7, int rmin=0, int rmax=7) {
-    Bitboard result = 0ULL;
+    Bitboard result = 0;
     int rk = sq / 8;
     int fl = sq % 8;
 
@@ -453,40 +444,17 @@ namespace {
     return result;
   }
 
-  void init_between_bitboards() {
-
-    Square s1, s2, s3;
-    SquareDelta d;
-    int f, r;
-
-    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
-        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
-        {
-            BetweenBB[s1][s2] = EmptyBoardBB;
-
-            if (bit_is_set(QueenPseudoAttacks[s1], s2))
-            {
-                f = file_distance(s1, s2);
-                r = rank_distance(s1, s2);
-
-                d = SquareDelta(s2 - s1) / Max(f, r);
-
-                for (s3 = s1 + d; s3 != s2; s3 += d)
-                    set_bit(&(BetweenBB[s1][s2]), s3);
-            }
-      }
-  }
-
   Bitboard index_to_bitboard(int index, Bitboard mask) {
 
-    Bitboard result = 0ULL;
+    Bitboard result = EmptyBoardBB;
-    int bits = count_1s<CNT32>(mask);
+    int sq, cnt = 0;
 
-    for (int i = 0; i < bits; i++)
+    while (mask)
     {
-        int j = pop_1st_bit(&mask);
+        sq = pop_1st_bit(&mask);
-        if (index & (1 << i))
+
-            result |= (1ULL << j);
+        if (index & (1 << cnt++))
+            result |= (1ULL << sq);
     }
     return result;
   }
@@ -530,4 +498,24 @@ namespace {
     }
   }
 
+  void init_between_bitboards() {
+
+    Square s1, s2, s3;
+    SquareDelta d;
+    int f, r;
+
+    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
+        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
+            if (bit_is_set(QueenPseudoAttacks[s1], s2))
+            {
+                f = file_distance(s1, s2);
+                r = rank_distance(s1, s2);
+
+                d = SquareDelta(s2 - s1) / Max(f, r);
+
+                for (s3 = s1 + d; s3 != s2; s3 += d)
+                    set_bit(&(BetweenBB[s1][s2]), s3);
+            }
+  }
+
 }

src/bitboard.h

@@ -66,7 +66,7 @@ extern const Bitboard InFrontBB[2][8];
 extern Bitboard SetMaskBB[65];
 extern Bitboard ClearMaskBB[65];
 
-extern Bitboard StepAttackBB[16][64];
+extern Bitboard NonSlidingAttacksBB[16][64];
 extern Bitboard BetweenBB[64][64];
 
 extern Bitboard SquaresInFrontMask[2][64];

src/position.cpp

@@ -524,7 +524,7 @@ Bitboard Position::attacks_from(Piece p, Square s) const {
   case WB: case BB: return attacks_from<BISHOP>(s);
   case WR: case BR: return attacks_from<ROOK>(s);
   case WQ: case BQ: return attacks_from<QUEEN>(s);
-  default: return StepAttackBB[p][s];
+  default: return NonSlidingAttacksBB[p][s];
   }
 }
 
@@ -537,7 +537,7 @@ Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {
   case WB: case BB: return bishop_attacks_bb(s, occ);
   case WR: case BR: return rook_attacks_bb(s, occ);
   case WQ: case BQ: return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);
-  default: return StepAttackBB[p][s];
+  default: return NonSlidingAttacksBB[p][s];
   }
 }
 

src/position.h

@@ -456,12 +456,12 @@ inline Square Position::initial_qr_square(Color c) const {
 
 template<>
 inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
-  return StepAttackBB[piece_of_color_and_type(c, PAWN)][s];
+  return NonSlidingAttacksBB[piece_of_color_and_type(c, PAWN)][s];
 }
 
 template<PieceType Piece> // Knight and King and white pawns
 inline Bitboard Position::attacks_from(Square s) const {
-  return StepAttackBB[Piece][s];
+  return NonSlidingAttacksBB[Piece][s];
 }
 
 template<>