Shadow variables fix, missing headers and APIs

moves_io.cpp

@@ -27,6 +27,7 @@
 #include "position.h"
 #include "types.h"
 #include <algorithm>
+#include <cctype>
 #include <string_view>
 #if defined(_CHESSLIB_ERROR_MODE_THROW)
 #define INVALID_ARG_IF(c, exception)                                                                                           \
@@ -174,10 +175,10 @@ template <typename T, typename V> Move uciToMove(const _Position<T, V> &pos, std
 /// @tparam T Piece enum type.
 /// @tparam P Position tag.
 /// @param pos The position.
-/// @param san SAN string (e.g. "Nf3", "O-O").
+/// @param raw_san SAN string (e.g. "Nf3", "O-O").
 /// @param remove_illegals If true, return Move::NO_MOVE instead of throwing.
 /// @return The parsed Move.
-template <typename T, typename P> Move parseSan(const _Position<T, P> &pos, std::string_view san, bool remove_illegals) {
+template <typename T, typename P> Move parseSan(const _Position<T, P> &pos, std::string_view raw_san, bool remove_illegals) {
     auto do_parse = [&](std::string_view input_san) -> Move {
         if (input_san.empty())
             return Move::none();
@@ -404,17 +405,17 @@ template <typename T, typename P> Move parseSan(const _Position<T, P> &pos, std:
     };
 
     if (remove_illegals) {
-        std::string trimmed_san(san);
+        std::string trimmed_san(raw_san);
         while (!trimmed_san.empty()) {
             Move attempt = do_parse(trimmed_san);
             if (attempt.is_ok())
                 return attempt;
             trimmed_san.pop_back();
         }
-        INVALID_ARG_IF(trimmed_san.empty(), IllegalMoveException("illegal san: '" + std::string(san) + "' in " + pos.fen()));
+        INVALID_ARG_IF(trimmed_san.empty(), IllegalMoveException("illegal san: '" + std::string(raw_san) + "' in " + pos.fen()));
         return Move::none();
     } else
-        return do_parse(san);
+        return do_parse(raw_san);
 }
 /// @brief Convert a Move to SAN or LAN (Long Algebraic Notation) string.
 template <typename T, typename P> std::string moveToSan(const _Position<T, P> &pos, Move move, bool long_, bool suffix) {

moves_io.h

@@ -83,16 +83,16 @@ template <typename T, typename P = void> Move uciToMove(const _Position<T, P> &p
 /// @tparam T Piece enum type.
 /// @tparam P Position tag.
 /// @param pos The position.
-/// @param san SAN string (e.g. "Nf3", "O-O").
+/// @param raw_san SAN string (e.g. "Nf3", "O-O").
 /// @param remove_illegals If true, return Move::NO_MOVE instead of throwing.
 /// @return The parsed Move.
 template <typename T, typename P = void>
-Move parseSan(const _Position<T, P> &pos, std::string_view san, bool remove_illegals = false);
+Move parseSan(const _Position<T, P> &pos, std::string_view raw_san, bool remove_illegals = false);
 
-/// @brief Alias for parseSan.
+/// @copydoc parseSan
 template <typename T, typename P = void>
-Move parse_san(const _Position<T, P> &pos, std::string_view san, bool remove_illegals = false) {
-    return parseSan(pos, san, remove_illegals);
+inline Move parse_san(const _Position<T, P> &pos, std::string_view raw_san, bool remove_illegals = false) {
+    return parseSan(pos, raw_san, remove_illegals);
 }
 
 /// @brief Convert a Move to SAN string for the given position.
@@ -106,9 +106,9 @@ Move parse_san(const _Position<T, P> &pos, std::string_view san, bool remove_ill
 template <typename T, typename P = void>
 std::string moveToSan(const _Position<T, P> &pos, Move move, bool long_ = false, bool suffix = true);
 
-/// @brief Alias for moveToSan.
+/// @copydoc moveToSan
 template <typename T, typename P = void>
-std::string move_to_san(const _Position<T, P> &pos, Move move, bool long_ = false, bool suffix = true) {
+inline std::string move_to_san(const _Position<T, P> &pos, Move move, bool long_ = false, bool suffix = true) {
     return moveToSan(pos, move, long_, suffix);
 }
 } // namespace chess::uci

position.h

@@ -314,7 +314,8 @@ template <typename PieceC = EnginePiece, typename = std::enable_if_t<is_piece_en
         }
     }
     /// @brief Undo the last move (snake_case). Returns saved HistoryEntry when RetAll=true.
-    template <bool RetAll = false> inline auto undo_move() -> std::conditional_t<RetAll, HistoryEntry<PieceC>, void> {
+    template <bool RetAll = false> 
+    inline auto undo_move() -> std::conditional_t<RetAll, HistoryEntry<PieceC>, void> {
         return undoMove<RetAll>();
     }
 
@@ -343,7 +344,7 @@ template <typename PieceC = EnginePiece, typename = std::enable_if_t<is_piece_en
         refresh_attacks();
     }
     /// @brief Perform a null move (pass the turn).
-    inline void do_null_move() { doNullMove(); }
+    [[deprecated("Pending to remove")]] inline void do_null_move() { doNullMove(); }
 
     /// @name Occupancy queries
     /// @{
@@ -994,6 +995,9 @@ template <typename PieceC = EnginePiece, typename = std::enable_if_t<is_piece_en
         _check_mask = other._check_mask;
         _pin_mask = other._pin_mask;
     }
+    // @brief Get the amount of moves played since position construction
+    // @return size of history
+    inline size_t history_count() const { return history.size(); }
 };
 
 namespace attacks {

types.h

@@ -23,10 +23,10 @@
 #pragma once
 
 #include "fwd_decl.h"
+#include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <string>
-
 /// @file types.h
 /// @brief Core chess type definitions: squares, pieces, colours, move encoding, and ValueList.
 #if defined(__clang__) || defined(__GNUC__)