san.cpp pass position as constant reference

Make a copy of the position when needed instead
of passing as a reference. It is cleaner and
let us to simplify also Position::print()

A small space inflate while there.

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

src/position.cpp

@@ -275,9 +275,8 @@ void Position::print(Move m) const {
   std::cout << std::endl;
   if (m != MOVE_NONE)
   {
-      Position p(*this);
       std::string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : "");
-      std::cout << "Move is: " << col << move_to_san(p, m) << std::endl;
+      std::cout << "Move is: " << col << move_to_san(*this, m) << std::endl;
   }
   for (Rank rank = RANK_8; rank >= RANK_1; rank--)
   {

src/san.cpp

@@ -51,7 +51,7 @@ namespace {
 
   /// Functions
 
-  Ambiguity move_ambiguity(Position &pos, Move m);
+  Ambiguity move_ambiguity(const Position& pos, Move m);
   const std::string time_string(int milliseconds);
   const std::string score_string(Value v);
 }
@@ -65,57 +65,51 @@ namespace {
 /// that the move is a legal move from the position.  The return value is
 /// a string containing the move in short algebraic notation.
 
-const std::string move_to_san(Position &pos, Move m) {
+const std::string move_to_san(const Position& pos, Move m) {
-  std::string str;
 
   assert(pos.is_ok());
   assert(move_is_ok(m));
 
-  if(m == MOVE_NONE) {
+  std::string san = "";
-    str = "(none)";
+
-    return str;
+  if (m == MOVE_NONE)
-  }
+      return "(none)";
-  else if(m == MOVE_NULL) {
+  else if (m == MOVE_NULL)
-    str = "(null)";
+      return "(null)";
-    return str;
-  }
   else if (move_is_long_castle(m))
-    str = "O-O-O";
+      san = "O-O-O";
   else if (move_is_short_castle(m))
-    str = "O-O";
+      san = "O-O";
-  else {
+  else
-    Square from, to;
+  {
-    Piece pc;
+      Square from = move_from(m);
+      Square to = move_to(m);
+      Piece pc = pos.piece_on(move_from(m));
 
-    from = move_from(m);
+      if (type_of_piece(pc) == PAWN)
-    to = move_to(m);
+      {
-    pc = pos.piece_on(move_from(m));
-
-    str = "";
-
-    if(type_of_piece(pc) == PAWN) {
           if (pos.move_is_capture(m))
-        str += file_to_char(square_file(move_from(m)));
+              san += file_to_char(square_file(move_from(m)));
       }
-    else {
+      else
-      str += piece_type_to_char(type_of_piece(pc), true);
+      {
+          san += piece_type_to_char(type_of_piece(pc), true);
 
-      Ambiguity amb = move_ambiguity(pos, m);
+          switch (move_ambiguity(pos, m)) {
-      switch(amb) {
 
           case AMBIGUITY_NONE:
             break;
 
           case AMBIGUITY_FILE:
-        str += file_to_char(square_file(from));
+            san += file_to_char(square_file(from));
             break;
 
           case AMBIGUITY_RANK:
-        str += rank_to_char(square_rank(from));
+            san += rank_to_char(square_rank(from));
             break;
 
           case AMBIGUITY_BOTH:
-        str += square_to_string(from);
+            san += square_to_string(from);
             break;
 
           default:
@@ -124,13 +118,14 @@ const std::string move_to_san(Position &pos, Move m) {
       }
 
       if (pos.move_is_capture(m))
-      str += "x";
+          san += "x";
 
-    str += square_to_string(move_to(m));
+      san += square_to_string(move_to(m));
 
-    if(move_promotion(m)) {
+      if (move_promotion(m))
-      str += "=";
+      {
-      str += piece_type_to_char(move_promotion(m), true);
+          san += '=';
+          san += piece_type_to_char(move_promotion(m), true);
       }
   }
 
@@ -138,12 +133,12 @@ const std::string move_to_san(Position &pos, Move m) {
   // Position::move_is_check doesn't detect all checks (not castling moves,
   // promotions and en passant captures).
   UndoInfo u;
-  pos.do_move(m, u);
+  Position p(pos);
-  if(pos.is_check())
+  p.do_move(m, u);
-    str += pos.is_mate()? "#" : "+";
+  if (p.is_check())
-  pos.undo_move(m, u);
+      san += p.is_mate()? "#" : "+";
 
-  return str;
+  return san;
 }
 
 
@@ -152,24 +147,29 @@ const std::string move_to_san(Position &pos, Move m) {
 /// the move is returned.  On failure (i.e. if the string is unparsable, or
 /// if the move is illegal or ambiguous), MOVE_NONE is returned.
 
-Move move_from_san(Position &pos, const std::string &movestr) {
+Move move_from_san(const Position& pos, const std::string& movestr) {
+
   assert(pos.is_ok());
 
   MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
 
   // Castling moves
-  if(movestr == "O-O-O") {
+  if (movestr == "O-O-O")
+  {
       Move m;
       while ((m = mp.get_next_move()) != MOVE_NONE)
           if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
               return m;
+
       return MOVE_NONE;
   }
-  else if(movestr == "O-O") {
+  else if (movestr == "O-O")
+  {
       Move m;
       while ((m = mp.get_next_move()) != MOVE_NONE)
           if(move_is_short_castle(m) && pos.pl_move_is_legal(m))
               return m;
+
     return MOVE_NONE;
   }
 
@@ -271,8 +271,8 @@ Move move_from_san(Position &pos, const std::string &movestr) {
 /// length of 80 characters.  After a line break, 'startColumn' spaces are
 /// inserted at the beginning of the new line.
 
-const std::string line_to_san(const Position &pos, Move line[], int startColumn,
+const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
-                              bool breakLines) {
+
   Position p = Position(pos);
   UndoInfo u;
   std::stringstream s;
@@ -337,13 +337,11 @@ const std::string pretty_pv(const Position &pos, int time, int depth,
 
 namespace {
 
-  Ambiguity move_ambiguity(Position &pos, Move m) {
+  Ambiguity move_ambiguity(const Position& pos, Move m) {
-    Square from, to;
-    Piece pc;
 
-    from = move_from(m);
+    Square from = move_from(m);
-    to = move_to(m);
+    Square to = move_to(m);
-    pc = pos.piece_on(from);
+    Piece pc = pos.piece_on(from);
 
     // King moves are never ambiguous, because there is never two kings of
     // the same color.
@@ -352,28 +350,28 @@ namespace {
 
     MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
     Move mv, moveList[8];
-    int i, j, n;
 
-    n = 0;
+    int n = 0;
     while ((mv = mp.get_next_move()) != MOVE_NONE)
-      if(move_to(mv) == to && pos.piece_on(move_from(mv)) == pc
+        if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv))
-         && pos.pl_move_is_legal(mv))
             moveList[n++] = mv;
+
     if (n == 1)
         return AMBIGUITY_NONE;
 
-    j = 0;
+    int f = 0, r = 0;
-    for(i = 0; i < n; i++)
+    for (int i = 0; i < n; i++)
+    {
         if (square_file(move_from(moveList[i])) == square_file(from))
-        j++;
+            f++;
-    if(j == 1)
+
+        if (square_rank(move_from(moveList[i])) == square_rank(from))
+            r++;
+    }
+    if (f == 1)
         return AMBIGUITY_FILE;
 
-    j = 0;
+    if (r == 1)
-    for(i = 0; i < n; i++)
-      if(square_rank(move_from(moveList[i])) == square_rank(from))
-        j++;
-    if(j == 1)
         return AMBIGUITY_RANK;
 
     return AMBIGUITY_BOTH;

src/san.h

@@ -36,12 +36,9 @@
 //// Prototypes
 ////
 
-extern const std::string move_to_san(Position &pos, Move m);
+extern const std::string move_to_san(const Position& pos, Move m);
-extern Move move_from_san(Position &pos, const std::string &str);
+extern Move move_from_san(const Position& pos, const std::string& str);
-extern const std::string line_to_san(const Position &pos, Move line[],
+extern const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines);
-                                     int startColumn, bool breakLines);
+extern const std::string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes, Value score, Move pv[]);
-extern const std::string pretty_pv(const Position &pos, int time, int depth,
-                                   uint64_t nodes, Value score, Move pv[]);
-
 
 #endif // !defined(SAN_H_INCLUDED)