mirror of
https://github.com/HChaZZY/Stockfish.git
synced 2025-12-24 02:57:11 +08:00
55f9afee2a
There was one occurence when the StateInfo variable went out of scope before the corresponding Position object. This yelds to a crash. Bug was not hit before because occurs only when using an UCI interface and not the usual benchmark. The fix consists in copying internally the content of the about to stale StateInfo. Signed-off-by: Marco Costalba <mcostalba@gmail.com>
334 lines
9.0 KiB
C++
334 lines
9.0 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
Copyright (C) 2008 Marco Costalba
|
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
////
|
|
//// Includes
|
|
////
|
|
|
|
#include <cassert>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
#include "book.h"
|
|
#include "evaluate.h"
|
|
#include "misc.h"
|
|
#include "move.h"
|
|
#include "movegen.h"
|
|
#include "position.h"
|
|
#include "san.h"
|
|
#include "search.h"
|
|
#include "uci.h"
|
|
#include "ucioption.h"
|
|
|
|
|
|
////
|
|
//// Local definitions:
|
|
////
|
|
|
|
namespace {
|
|
|
|
// UCIInputParser is a class for parsing UCI input. The class
|
|
// is actually a string stream built on a given input string.
|
|
|
|
typedef std::istringstream UCIInputParser;
|
|
|
|
// The root position. This is set up when the user (or in practice, the GUI)
|
|
// sends the "position" UCI command. The root position is sent to the think()
|
|
// function when the program receives the "go" command.
|
|
Position RootPosition;
|
|
|
|
// Local functions
|
|
void get_command();
|
|
void handle_command(const std::string &command);
|
|
void set_option(UCIInputParser &uip);
|
|
void set_position(UCIInputParser &uip);
|
|
void go(UCIInputParser &uip);
|
|
}
|
|
|
|
|
|
////
|
|
//// Functions
|
|
////
|
|
|
|
/// uci_main_loop() is the only global function in this file. It is
|
|
/// called immediately after the program has finished initializing.
|
|
/// The program remains in this loop until it receives the "quit" UCI
|
|
/// command.
|
|
|
|
void uci_main_loop() {
|
|
|
|
RootPosition.from_fen(StartPosition);
|
|
|
|
while (1)
|
|
get_command();
|
|
}
|
|
|
|
|
|
////
|
|
//// Local functions
|
|
////
|
|
|
|
namespace {
|
|
|
|
// get_command() waits for a command from the user, and passes
|
|
// this command to handle_command. get_command also intercepts
|
|
// EOF from stdin, by translating EOF to the "quit" command. This
|
|
// ensures that Stockfish exits gracefully if the GUI dies
|
|
// unexpectedly.
|
|
|
|
void get_command() {
|
|
|
|
std::string command;
|
|
|
|
if (!std::getline(std::cin, command))
|
|
command = "quit";
|
|
|
|
handle_command(command);
|
|
}
|
|
|
|
|
|
// handle_command() takes a text string as input, uses a
|
|
// UCIInputParser object to parse this text string as a UCI command,
|
|
// and calls the appropriate functions. In addition to the UCI
|
|
// commands, the function also supports a few debug commands.
|
|
|
|
void handle_command(const std::string &command) {
|
|
|
|
UCIInputParser uip(command);
|
|
std::string token;
|
|
|
|
uip >> token; // operator >> skips any whitespace
|
|
|
|
if (token == "quit")
|
|
{
|
|
OpeningBook.close();
|
|
stop_threads();
|
|
quit_eval();
|
|
exit(0);
|
|
}
|
|
else if (token == "uci")
|
|
{
|
|
std::cout << "id name " << engine_name() << std::endl
|
|
<< "id author Tord Romstad, Marco Costalba"
|
|
<< std::endl;
|
|
print_uci_options();
|
|
std::cout << "uciok" << std::endl;
|
|
}
|
|
else if (token == "ucinewgame")
|
|
{
|
|
TT.clear();
|
|
Position::init_piece_square_tables();
|
|
RootPosition.from_fen(StartPosition);
|
|
}
|
|
else if (token == "isready")
|
|
std::cout << "readyok" << std::endl;
|
|
else if (token == "position")
|
|
set_position(uip);
|
|
else if (token == "setoption")
|
|
set_option(uip);
|
|
else if (token == "go")
|
|
go(uip);
|
|
|
|
// The remaining commands are for debugging purposes only.
|
|
// Perhaps they should be removed later in order to reduce the
|
|
// size of the program binary.
|
|
else if (token == "d")
|
|
RootPosition.print();
|
|
else if (token == "flip")
|
|
{
|
|
Position p(RootPosition);
|
|
RootPosition.flipped_copy(p);
|
|
}
|
|
else if (token == "eval")
|
|
{
|
|
EvalInfo ei;
|
|
std::cout << "Incremental mg: " << RootPosition.mg_value()
|
|
<< std::endl;
|
|
std::cout << "Incremental eg: " << RootPosition.eg_value()
|
|
<< std::endl;
|
|
std::cout << "Full eval: "
|
|
<< evaluate(RootPosition, ei, 0)
|
|
<< std::endl;
|
|
}
|
|
else if (token == "key")
|
|
{
|
|
std::cout << "key: " << RootPosition.get_key()
|
|
<< " material key: " << RootPosition.get_material_key()
|
|
<< " pawn key: " << RootPosition.get_pawn_key()
|
|
<< std::endl;
|
|
}
|
|
else
|
|
{
|
|
std::cout << "Unknown command: " << command << std::endl;
|
|
while (!uip.eof())
|
|
{
|
|
uip >> token;
|
|
std::cout << token << std::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// set_position() is called when Stockfish receives the "position" UCI
|
|
// command. The input parameter is a UCIInputParser. It is assumed
|
|
// that this parser has consumed the first token of the UCI command
|
|
// ("position"), and is ready to read the second token ("startpos"
|
|
// or "fen", if the input is well-formed).
|
|
|
|
void set_position(UCIInputParser &uip) {
|
|
|
|
std::string token;
|
|
|
|
uip >> token; // operator >> skips any whitespace
|
|
|
|
if (token == "startpos")
|
|
RootPosition.from_fen(StartPosition);
|
|
else if (token == "fen")
|
|
{
|
|
std::string fen;
|
|
while (token != "moves" && !uip.eof())
|
|
{
|
|
uip >> token;
|
|
fen += token;
|
|
fen += ' ';
|
|
}
|
|
RootPosition.from_fen(fen);
|
|
}
|
|
|
|
if (!uip.eof())
|
|
{
|
|
if (token != "moves")
|
|
uip >> token;
|
|
if (token == "moves")
|
|
{
|
|
Move move;
|
|
StateInfo st;
|
|
while (!uip.eof())
|
|
{
|
|
uip >> token;
|
|
move = move_from_string(RootPosition, token);
|
|
RootPosition.do_move(move, st);
|
|
if (RootPosition.rule_50_counter() == 0)
|
|
RootPosition.reset_game_ply();
|
|
}
|
|
// Our StateInfo st is about going out of scope,
|
|
// so save its content before they disappear.
|
|
RootPosition.setStartState(st);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// set_option() is called when Stockfish receives the "setoption" UCI
|
|
// command. The input parameter is a UCIInputParser. It is assumed
|
|
// that this parser has consumed the first token of the UCI command
|
|
// ("setoption"), and is ready to read the second token ("name", if
|
|
// the input is well-formed).
|
|
|
|
void set_option(UCIInputParser &uip) {
|
|
|
|
std::string token, name;
|
|
|
|
uip >> token;
|
|
if (token == "name")
|
|
{
|
|
uip >> name;
|
|
uip >> token;
|
|
while (!uip.eof() && token != "value")
|
|
{
|
|
name += (" " + token);
|
|
uip >> token;
|
|
}
|
|
if (token == "value")
|
|
{
|
|
std::getline(uip, token); // reads until end of line
|
|
set_option_value(name, token);
|
|
} else
|
|
push_button(name);
|
|
}
|
|
}
|
|
|
|
|
|
// go() is called when Stockfish receives the "go" UCI command. The
|
|
// input parameter is a UCIInputParser. It is assumed that this
|
|
// parser has consumed the first token of the UCI command ("go"),
|
|
// and is ready to read the second token. The function sets the
|
|
// thinking time and other parameters from the input string, and
|
|
// calls think() (defined in search.cpp) with the appropriate
|
|
// parameters.
|
|
|
|
void go(UCIInputParser &uip) {
|
|
|
|
std::string token;
|
|
|
|
int time[2] = {0, 0}, inc[2] = {0, 0};
|
|
int movesToGo = 0, depth = 0, nodes = 0, moveTime = 0;
|
|
bool infinite = false, ponder = false;
|
|
Move searchMoves[500];
|
|
|
|
searchMoves[0] = MOVE_NONE;
|
|
|
|
while (!uip.eof())
|
|
{
|
|
uip >> token;
|
|
|
|
if (token == "infinite")
|
|
infinite = true;
|
|
else if (token == "ponder")
|
|
ponder = true;
|
|
else if (token == "wtime")
|
|
uip >> time[0];
|
|
else if (token == "btime")
|
|
uip >> time[1];
|
|
else if (token == "winc")
|
|
uip >> inc[0];
|
|
else if (token == "binc")
|
|
uip >> inc[1];
|
|
else if (token == "movestogo")
|
|
uip >> movesToGo;
|
|
else if (token == "depth")
|
|
uip >> depth;
|
|
else if (token == "nodes")
|
|
uip >> nodes;
|
|
else if (token == "movetime")
|
|
uip >> moveTime;
|
|
else if (token == "searchmoves")
|
|
{
|
|
int numOfMoves = 0;
|
|
while (!uip.eof())
|
|
{
|
|
uip >> token;
|
|
searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
|
|
}
|
|
searchMoves[numOfMoves] = MOVE_NONE;
|
|
}
|
|
}
|
|
|
|
if (moveTime)
|
|
infinite = true; // HACK
|
|
|
|
assert(RootPosition.is_ok());
|
|
|
|
think(RootPosition, infinite, ponder, RootPosition.side_to_move(), time,
|
|
inc, movesToGo, depth, nodes, moveTime, searchMoves);
|
|
}
|
|
}
|