Micro-optimize move_to_san()

[stockfish] / src / notation.cpp

diff --git a/src/notation.cpp b/src/notation.cpp
index 8ea6ad52aea0694ee5cf87808f444221e33837f1..69a44d95bf8b8de90186fd423547bb4b577e750c 100644 (file)
--- a/src/notation.cpp
+++ b/src/notation.cpp
@@ -25,6 +25,8 @@
 
 using std::string;
 
+static const char* PieceToChar = " PNBRQK pnbrqk";
+
 /// move_to_uci() converts a move to a string in coordinate notation
 /// (g1f3, a7a8q, etc.). The only special case is castling moves, where we print
 /// in the e1g1 notation in normal chess mode, and in e1h1 notation in chess960
@@ -34,7 +36,6 @@ const string move_to_uci(Move m, bool chess960) {
 
   Square from = from_sq(m);
   Square to = to_sq(m);
-  string promotion;
 
   if (m == MOVE_NONE)
       return "(none)";
@@ -42,13 +43,15 @@ const string move_to_uci(Move m, bool chess960) {
   if (m == MOVE_NULL)
       return "0000";
 
-  if (is_castle(m) && !chess960)
+  if (type_of(m) == CASTLE && !chess960)
       to = (to > from ? FILE_G : FILE_C) | rank_of(from);
 
-  if (is_promotion(m))
-      promotion = char(tolower(piece_type_to_char(promotion_type(m))));
+  string move = square_to_string(from) + square_to_string(to);
+
+  if (type_of(m) == PROMOTION)
+      move += PieceToChar[promotion_type(m) + 7]; // Lower case
 
-  return square_to_string(from) + square_to_string(to) + promotion;
+  return move;
 }
 
 
@@ -60,7 +63,7 @@ Move move_from_uci(const Position& pos, string& str) {
   if (str.length() == 5) // Junior could send promotion piece in uppercase
       str[4] = char(tolower(str[4]));
 
-  for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
+  for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)
       if (str == move_to_uci(ml.move(), pos.is_chess960()))
           return ml.move();
 
@@ -84,24 +87,25 @@ const string move_to_san(Position& pos, Move m) {
   Bitboard attackers;
   bool ambiguousMove, ambiguousFile, ambiguousRank;
   string san;
+  Color us = pos.side_to_move();
   Square from = from_sq(m);
   Square to = to_sq(m);
-  PieceType pt = type_of(pos.piece_on(from));
+  Piece pc = pos.piece_on(from);
 
-  if (is_castle(m))
+  if (type_of(m) == CASTLE)
       san = to > from ? "O-O" : "O-O-O";
   else
   {
-      if (pt != PAWN)
+      if (type_of(pc) != PAWN)
       {
-          san = piece_type_to_char(pt);
+          san = PieceToChar[pc];
 
           // Disambiguation if we have more then one piece with destination 'to'
           // note that for pawns is not needed because starting file is explicit.
-          attackers = pos.attackers_to(to) & pos.pieces(pos.side_to_move(), pt);
-          attackers ^= from;
           ambiguousMove = ambiguousFile = ambiguousRank = false;
 
+          attackers = (pos.attacks_from(pc, to) & pos.pieces(us)) ^ from;
+
           while (attackers)
           {
               Square sq = pop_1st_bit(&attackers);
@@ -127,26 +131,23 @@ const string move_to_san(Position& pos, Move m) {
                   san += square_to_string(from);
           }
       }
+      else if (pos.is_capture(m))
+          san = file_to_char(file_of(from));
 
       if (pos.is_capture(m))
-      {
-          if (pt == PAWN)
-              san += file_to_char(file_of(from));
-
           san += 'x';
-      }
 
       san += square_to_string(to);
 
-      if (is_promotion(m))
-          san += string("=") + piece_type_to_char(promotion_type(m));
+      if (type_of(m) == PROMOTION)
+          san += string("=") + PieceToChar[promotion_type(m)];
   }
 
   if (pos.move_gives_check(m, CheckInfo(pos)))
   {
       StateInfo st;
       pos.do_move(m, st);
-      san += MoveList<MV_LEGAL>(pos).size() ? "+" : "#";
+      san += MoveList<LEGAL>(pos).size() ? "+" : "#";
       pos.undo_move(m);
   }