Proper indenting of multiple conditions

Triviality due to a boring saturday morning.

No functional change.

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

diff --git a/src/endgame.cpp b/src/endgame.cpp
index fdc48cb49553f7c0add882369b4c5c695ec71324..f1f29d61249371f9302d51d4c93ae3049489991d 100644 (file)
--- a/src/endgame.cpp
+++ b/src/endgame.cpp
@@ -410,7 +410,7 @@ ScaleFactor Endgame<KBPsK>::operator()(const Position& pos) const {
   File pawnFile = file_of(pos.piece_list(strongerSide, PAWN)[0]);
 
   // All pawns are on a single rook file ?
-  if (   (pawnFile == FILE_A || pawnFile == FILE_H)
+  if (    (pawnFile == FILE_A || pawnFile == FILE_H)
       && !(pawns & ~file_bb(pawnFile)))
   {
       Square bishopSq = pos.piece_list(strongerSide, BISHOP)[0];
@@ -650,7 +650,7 @@ ScaleFactor Endgame<KPsK>::operator()(const Position& pos) const {
   {
       // Does the defending king block the pawns?
       if (   square_distance(ksq, relative_square(strongerSide, SQ_A8)) <= 1
-          || (   file_of(ksq) == FILE_A
+          || (    file_of(ksq) == FILE_A
               && !in_front_bb(strongerSide, ksq) & pawns))
           return SCALE_FACTOR_DRAW;
   }
@@ -659,7 +659,7 @@ ScaleFactor Endgame<KPsK>::operator()(const Position& pos) const {
   {
     // Does the defending king block the pawns?
     if (   square_distance(ksq, relative_square(strongerSide, SQ_H8)) <= 1
-        || (   file_of(ksq) == FILE_H
+        || (    file_of(ksq) == FILE_H
             && !in_front_bb(strongerSide, ksq) & pawns))
         return SCALE_FACTOR_DRAW;
   }

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 0be426ab659b969b8073b0bb5c8c528f911a2451..a86a1702f19d1df5ee61868a78cc93052f38b8dc 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -304,9 +304,9 @@ Move MovePicker::next_move() {
 
       case KILLERS_S1:
           move = (curMove++)->move;
-          if (   move != MOVE_NONE
-              && pos.is_pseudo_legal(move)
-              && move != ttMove
+          if (    move != MOVE_NONE
+              &&  pos.is_pseudo_legal(move)
+              &&  move != ttMove
               && !pos.is_capture(move))
               return move;
           break;

diff --git a/src/position.cpp b/src/position.cpp
index f055b04c9a6563a6f243464e2cd90c1ea9a6a5d7..7f997bb776376874a36c882c206c8a57b4ce1147 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -641,7 +641,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
   if (ci.dcCandidates && (ci.dcCandidates & from))
   {
       // For pawn and king moves we need to verify also direction
-      if (  (pt != PAWN && pt != KING)
+      if (   (pt != PAWN && pt != KING)
           || !squares_aligned(from, to, king_square(~sideToMove)))
           return true;
   }

diff --git a/src/search.cpp b/src/search.cpp
index bab8f398cc8f0ebc684c94df9d2e24a29f145a17..0087cdc029d0f307f11eaf0f74076c29b8638fcd 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -176,11 +176,11 @@ namespace {
     }
 
     // Test for a capture that triggers a pawn endgame
-    if (   captureOrPromotion
-        && type_of(pos.piece_on(to_sq(m))) != PAWN
+    if (    captureOrPromotion
+        &&  type_of(pos.piece_on(to_sq(m))) != PAWN
+        && !is_special(m)
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
-            - PieceValueMidgame[pos.piece_on(to_sq(m))] == VALUE_ZERO)
-        && !is_special(m))
+            - PieceValueMidgame[pos.piece_on(to_sq(m))] == VALUE_ZERO))
         return true;
 
     return false;
@@ -622,10 +622,10 @@ namespace {
         TT.refresh(tte);
         ss->currentMove = ttMove; // Can be MOVE_NONE
 
-        if (   ttValue >= beta
-            && ttMove
+        if (    ttValue >= beta
+            &&  ttMove
             && !pos.is_capture_or_promotion(ttMove)
-            && ttMove != ss->killers[0])
+            &&  ttMove != ss->killers[0])
         {
             ss->killers[1] = ss->killers[0];
             ss->killers[0] = ttMove;
@@ -652,9 +652,9 @@ namespace {
 
     // Update gain for the parent non-capture move given the static position
     // evaluation before and after the move.
-    if (   (move = (ss-1)->currentMove) != MOVE_NULL
-        && (ss-1)->eval != VALUE_NONE
-        && ss->eval != VALUE_NONE
+    if (    (move = (ss-1)->currentMove) != MOVE_NULL
+        &&  (ss-1)->eval != VALUE_NONE
+        &&  ss->eval != VALUE_NONE
         && !pos.captured_piece_type()
         && !is_special(move))
     {
@@ -806,15 +806,15 @@ split_point_start: // At split points actual search starts from here
     futilityBase = ss->eval + ss->evalMargin;
     singularExtensionNode =   !RootNode
                            && !SpNode
-                           && depth >= SingularExtensionDepth[PvNode]
-                           && ttMove != MOVE_NONE
+                           &&  depth >= SingularExtensionDepth[PvNode]
+                           &&  ttMove != MOVE_NONE
                            && !excludedMove // Recursive singular search is not allowed
                            && (tte->type() & BOUND_LOWER)
-                           && tte->depth() >= depth - 3 * ONE_PLY;
+                           &&  tte->depth() >= depth - 3 * ONE_PLY;
 
     // Step 11. Loop through moves
     // Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
-    while (   bestValue < beta
+    while (    bestValue < beta
            && (move = mp.next_move()) != MOVE_NONE
            && !thisThread->cutoff_occurred()
            && !Signals.stop)
@@ -870,10 +870,10 @@ split_point_start: // At split points actual search starts from here
       // is singular and should be extended. To verify this we do a reduced search
       // on all the other moves but the ttMove, if result is lower than ttValue minus
       // a margin then we extend ttMove.
-      if (   singularExtensionNode
+      if (    singularExtensionNode
           && !ext
-          && move == ttMove
-          && pos.pl_move_is_legal(move, ci.pinned))
+          &&  move == ttMove
+          &&  pos.pl_move_is_legal(move, ci.pinned))
       {
           if (abs(ttValue) < VALUE_KNOWN_WIN)
           {
@@ -952,7 +952,7 @@ split_point_start: // At split points actual search starts from here
 
       // Step 15. Reduced depth search (LMR). If the move fails high will be
       // re-searched at full depth.
-      if (   depth > 3 * ONE_PLY
+      if (    depth > 3 * ONE_PLY
           && !isPvMove
           && !captureOrPromotion
           && !dangerous
@@ -1051,9 +1051,9 @@ split_point_start: // At split points actual search starts from here
 
       // Step 19. Check for split
       if (   !SpNode
-          && depth >= Threads.min_split_depth()
-          && bestValue < beta
-          && Threads.available_slave_exists(thisThread)
+          &&  depth >= Threads.min_split_depth()
+          &&  bestValue < beta
+          &&  Threads.available_slave_exists(thisThread)
           && !Signals.stop
           && !thisThread->cutoff_occurred())
           bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, &bestMove,
@@ -1245,8 +1245,8 @@ split_point_start: // At split points actual search starts from here
 
       // Detect non-capture evasions that are candidate to be pruned
       evasionPrunable =   !PvNode
-                       && inCheck
-                       && bestValue > VALUE_MATED_IN_MAX_PLY
+                       &&  inCheck
+                       &&  bestValue > VALUE_MATED_IN_MAX_PLY
                        && !pos.is_capture(move)
                        && !pos.can_castle(pos.side_to_move());
 
@@ -1849,8 +1849,8 @@ void Thread::idle_loop(SplitPoint* sp_master) {
 
           // Wake up master thread so to allow it to return from the idle loop in
           // case we are the last slave of the split point.
-          if (   Threads.use_sleeping_threads()
-              && this != sp->master
+          if (    Threads.use_sleeping_threads()
+              &&  this != sp->master
               && !sp->master->is_searching)
               sp->master->wake_up();