Renaming some variables in code

Implements renaming suggestions by Marco Costalba, Günther Demetz,
Gontran Lemaire, Ronald de Man, Stéphane Nicolet, Alain Savard,
Joost VandeVondele, Jerry Donald Watson, Mike Whiteley, xoto10,
and I hope that I haven't forgotten anybody.

Perpetual renaming thread for suggestions:
https://github.com/official-stockfish/Stockfish/issues/1426

No functional change.

src/evaluate.cpp

@@ -163,24 +163,24 @@ namespace {
   const Score KingProtector[] = { S(3, 5), S(4, 3), S(3, 0), S(1, -1) };
 
   // Assorted bonuses and penalties
-  const Score BishopPawns       = S(  8, 12);
+  const Score BishopPawns        = S(  8, 12);
-  const Score CloseEnemies      = S(  7,  0);
+  const Score CloseEnemies       = S(  7,  0);
-  const Score Connectivity      = S(  3,  1);
+  const Score Connectivity       = S(  3,  1);
-  const Score Hanging           = S( 52, 30);
+  const Score CorneredBishop     = S( 50, 50);
-  const Score HinderPassedPawn  = S(  8,  1);
+  const Score Hanging            = S( 52, 30);
-  const Score KnightOnQueen     = S( 21, 11);
+  const Score HinderPassedPawn   = S(  8,  1);
-  const Score LongRangedBishop  = S( 22,  0);
+  const Score KnightOnQueen      = S( 21, 11);
-  const Score MinorBehindPawn   = S( 16,  0);
+  const Score LongDiagonalBishop = S( 22,  0);
-  const Score PawnlessFlank     = S( 20, 80);
+  const Score MinorBehindPawn    = S( 16,  0);
-  const Score RookOnPawn        = S(  8, 24);
+  const Score PawnlessFlank      = S( 20, 80);
-  const Score SliderOnQueen     = S( 42, 21);
+  const Score RookOnPawn         = S(  8, 24);
-  const Score ThreatByPawnPush  = S( 47, 26);
+  const Score SliderOnQueen      = S( 42, 21);
-  const Score ThreatByRank      = S( 16,  3);
+  const Score ThreatByPawnPush   = S( 47, 26);
-  const Score ThreatBySafePawn  = S(175,168);
+  const Score ThreatByRank       = S( 16,  3);
-  const Score TrappedBishopA1H1 = S( 50, 50);
+  const Score ThreatBySafePawn   = S(175,168);
-  const Score TrappedRook       = S( 92,  0);
+  const Score TrappedRook        = S( 92,  0);
-  const Score WeakQueen         = S( 50, 10);
+  const Score WeakQueen          = S( 50, 10);
-  const Score WeakUnopposedPawn = S(  5, 25);
+  const Score WeakUnopposedPawn  = S(  5, 25);
 
 #undef S
 
@@ -230,18 +230,18 @@ namespace {
     // which attack a square in the kingRing of the enemy king.
     int kingAttackersCount[COLOR_NB];
 
-    // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
+    // kingAttackersWeight[color] is the sum of the "weights" of the pieces of
-    // given color which attack a square in the kingRing of the enemy king. The
+    // the given color which attack a square in the kingRing of the enemy king.
-    // weights of the individual piece types are given by the elements in the
+    // The weights of the individual piece types are given by the elements in
-    // KingAttackWeights array.
+    // the KingAttackWeights array.
     int kingAttackersWeight[COLOR_NB];
 
-    // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
+    // kingAttacksCount[color] is the number of attacks by the given color to
-    // color to squares directly adjacent to the enemy king. Pieces which attack
+    // squares directly adjacent to the enemy king. Pieces which attack more
-    // more than one square are counted multiple times. For instance, if there is
+    // than one square are counted multiple times. For instance, if there is
     // a white knight on g5 and black's king is on g8, this white knight adds 2
-    // to kingAdjacentZoneAttacksCount[WHITE].
+    // to kingAttacksCount[WHITE].
-    int kingAdjacentZoneAttacksCount[COLOR_NB];
+    int kingAttacksCount[COLOR_NB];
   };
 
 
@@ -276,7 +276,7 @@ namespace {
             kingRing[Us] |= shift<Up>(kingRing[Us]);
 
         kingAttackersCount[Them] = popcount(attackedBy[Us][KING] & pe->pawn_attacks(Them));
-        kingAdjacentZoneAttacksCount[Them] = kingAttackersWeight[Them] = 0;
+        kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
     }
     else
         kingRing[Us] = kingAttackersCount[Them] = 0;
@@ -316,7 +316,7 @@ namespace {
         {
             kingAttackersCount[Us]++;
             kingAttackersWeight[Us] += KingAttackWeights[Pt];
-            kingAdjacentZoneAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
+            kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
         }
 
         int mob = popcount(b & mobilityArea[Us]);
@@ -348,7 +348,7 @@ namespace {
 
                 // Bonus for bishop on a long diagonal which can "see" both center squares
                 if (more_than_one(Center & (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) | s)))
-                    score += LongRangedBishop;
+                    score += LongDiagonalBishop;
             }
 
             // An important Chess960 pattern: A cornered bishop blocked by a friendly
@@ -360,9 +360,9 @@ namespace {
             {
                 Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
-                    score -= !pos.empty(s + d + pawn_push(Us))                ? TrappedBishopA1H1 * 4
+                    score -= !pos.empty(s + d + pawn_push(Us))                ? CorneredBishop * 4
-                            : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
+                            : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
-                                                                              : TrappedBishopA1H1;
+                                                                              : CorneredBishop;
             }
         }
 
@@ -463,7 +463,7 @@ namespace {
         pinned = pos.blockers_for_king(Us) & pos.pieces(Us);
 
         kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]
-                     + 102 * kingAdjacentZoneAttacksCount[Them]
+                     + 102 * kingAttacksCount[Them]
                      + 191 * popcount(kingRing[Us] & weak)
                      + 143 * popcount(pinned | unsafeChecks)
                      - 848 * !pos.count<QUEEN>(Them)

src/material.cpp

@@ -68,7 +68,7 @@ namespace {
           && pos.non_pawn_material(us) >= RookValueMg;
   }
 
-  bool is_KBPsKs(const Position& pos, Color us) {
+  bool is_KBPsK(const Position& pos, Color us) {
     return   pos.non_pawn_material(us) == BishopValueMg
           && pos.count<BISHOP>(us) == 1
           && pos.count<PAWN  >(us) >= 1;
@@ -165,7 +165,7 @@ Entry* probe(const Position& pos) {
   // case we don't return after setting the function.
   for (Color c = WHITE; c <= BLACK; ++c)
   {
-    if (is_KBPsKs(pos, c))
+    if (is_KBPsK(pos, c))
         e->scalingFunction[c] = &ScaleKBPsK[c];
 
     else if (is_KQKRPs(pos, c))

src/position.cpp

@@ -322,8 +322,8 @@ void Position::set_castling_right(Color c, Square rfrom) {
 
 void Position::set_check_info(StateInfo* si) const {
 
-  si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinnersForKing[WHITE]);
+  si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinners[BLACK]);
-  si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinnersForKing[BLACK]);
+  si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinners[WHITE]);
 
   Square ksq = square<KING>(~sideToMove);
 
@@ -1037,7 +1037,7 @@ bool Position::see_ge(Move m, Value threshold) const {
 
       // Don't allow pinned pieces to attack (except the king) as long as
       // all pinners are on their original square.
-      if (!(st->pinnersForKing[stm] & ~occupied))
+      if (!(st->pinners[~stm] & ~occupied))
           stmAttackers &= ~st->blockersForKing[stm];
 
       // If stm has no more attackers then give up: stm loses

src/position.h

@@ -52,7 +52,7 @@ struct StateInfo {
   Piece      capturedPiece;
   StateInfo* previous;
   Bitboard   blockersForKing[COLOR_NB];
-  Bitboard   pinnersForKing[COLOR_NB];
+  Bitboard   pinners[COLOR_NB];
   Bitboard   checkSquares[PIECE_TYPE_NB];
 };
 

src/psqt.cpp

@@ -112,12 +112,12 @@ void init() {
       PieceValue[MG][~pc] = PieceValue[MG][pc];
       PieceValue[EG][~pc] = PieceValue[EG][pc];
 
-      Score v = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);
+      Score score = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);
 
       for (Square s = SQ_A1; s <= SQ_H8; ++s)
       {
           File f = std::min(file_of(s), ~file_of(s));
-          psq[ pc][ s] = v + Bonus[pc][rank_of(s)][f];
+          psq[ pc][ s] = score + Bonus[pc][rank_of(s)][f];
           psq[~pc][~s] = -psq[pc][s];
       }
   }

src/search.cpp

@@ -455,12 +455,12 @@ void Thread::search() {
                      timeReduction *= 1.25;
 
               // Use part of the gained time from a previous stable move for the current move
-              double unstablePvFactor = 1.0 + mainThread->bestMoveChanges;
+              double bestMoveInstability = 1.0 + mainThread->bestMoveChanges;
-              unstablePvFactor *= std::pow(mainThread->previousTimeReduction, 0.528) / timeReduction;
+              bestMoveInstability *= std::pow(mainThread->previousTimeReduction, 0.528) / timeReduction;
 
               // Stop the search if we have only one legal move, or if available time elapsed
               if (   rootMoves.size() == 1
-                  || Time.elapsed() > Time.optimum() * unstablePvFactor * improvingFactor / 581)
+                  || Time.elapsed() > Time.optimum() * bestMoveInstability * improvingFactor / 581)
               {
                   // If we are allowed to ponder do not stop the search now but
                   // keep pondering until the GUI sends "ponderhit" or "stop".
@@ -495,7 +495,7 @@ namespace {
     if (depth < ONE_PLY)
         return qsearch<NT>(pos, ss, alpha, beta);
 
-    const bool PvNode = NT == PV;
+    constexpr bool PvNode = NT == PV;
     const bool rootNode = PvNode && ss->ply == 0;
 
     assert(-VALUE_INFINITE <= alpha && alpha < beta && beta <= VALUE_INFINITE);
@@ -1156,7 +1156,7 @@ moves_loop: // When in check, search starts from here
   template <NodeType NT>
   Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth) {
 
-    const bool PvNode = NT == PV;
+    constexpr bool PvNode = NT == PV;
     const bool inCheck = bool(pos.checkers());
 
     assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);