Big trailing whitespace cleanup part 1
[stockfish] / src / uci.cpp
1 /*
2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4   Copyright (C) 2008 Marco Costalba
5
6   Stockfish is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   Stockfish is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20
21 ////
22 //// Includes
23 ////
24
25 #include <iostream>
26 #include <sstream>
27 #include <string>
28
29 #include "book.h"
30 #include "evaluate.h"
31 #include "misc.h"
32 #include "move.h"
33 #include "movegen.h"
34 #include "position.h"
35 #include "san.h"
36 #include "search.h"
37 #include "uci.h"
38 #include "ucioption.h"
39
40
41 ////
42 //// Local definitions:
43 ////
44
45 namespace {
46
47   // UCIInputParser is a class for parsing UCI input.  The class
48   // is actually a string stream built on a given input string.
49
50   typedef std::istringstream UCIInputParser;
51
52   // The root position.  This is set up when the user (or in practice, the GUI)
53   // sends the "position" UCI command.  The root position is sent to the think()
54   // function when the program receives the "go" command.
55   Position RootPosition;
56
57   // Local functions
58   void get_command();
59   void handle_command(const std::string &command);
60   void set_option(UCIInputParser &uip);
61   void set_position(UCIInputParser &uip);
62   void go(UCIInputParser &uip);
63 }
64
65
66 ////
67 //// Functions
68 ////
69
70 /// uci_main_loop() is the only global function in this file.  It is
71 /// called immediately after the program has finished initializing.
72 /// The program remains in this loop until it receives the "quit" UCI
73 /// command.
74
75 void uci_main_loop() {
76
77   RootPosition.from_fen(StartPosition);
78
79   while (1)
80       get_command();
81 }
82
83
84 ////
85 //// Local functions
86 ////
87
88 namespace {
89
90   // get_command() waits for a command from the user, and passes
91   // this command to handle_command.  get_command also intercepts
92   // EOF from stdin, by translating EOF to the "quit" command.  This
93   // ensures that Stockfish exits gracefully if the GUI dies
94   // unexpectedly.
95
96   void get_command() {
97
98     std::string command;
99
100     if (!std::getline(std::cin, command))
101         command = "quit";
102
103     handle_command(command);
104   }
105
106
107   // handle_command() takes a text string as input, uses a
108   // UCIInputParser object to parse this text string as a UCI command,
109   // and calls the appropriate functions.  In addition to the UCI
110   // commands, the function also supports a few debug commands.
111
112   void handle_command(const std::string &command) {
113
114     UCIInputParser uip(command);
115     std::string token;
116
117     uip >> token; // operator >> skips any whitespace
118
119     if (token == "quit")
120     {
121         OpeningBook.close();
122         stop_threads();
123         quit_eval();
124         exit(0);
125     }
126     else if (token == "uci")
127     {
128         std::cout << "id name " << engine_name() << std::endl
129                   << "id author Tord Romstad, Marco Costalba"
130                   << std::endl;
131         print_uci_options();
132         std::cout << "uciok" << std::endl;
133     }
134     else if (token == "ucinewgame")
135     {
136         TT.clear();
137         Position::init_piece_square_tables();
138         RootPosition.from_fen(StartPosition);
139     }
140     else if (token == "isready")
141         std::cout << "readyok" << std::endl;
142     else if (token == "position")
143         set_position(uip);
144     else if (token == "setoption")
145         set_option(uip);
146     else if (token == "go")
147         go(uip);
148
149     // The remaining commands are for debugging purposes only.
150     // Perhaps they should be removed later in order to reduce the
151     // size of the program binary.
152     else if (token == "d")
153         RootPosition.print();
154     else if (token == "flip")
155     {
156         Position p(RootPosition);
157         RootPosition.flipped_copy(p);
158     }
159     else if (token == "eval")
160     {
161         EvalInfo ei;
162         std::cout << "Incremental mg: " << RootPosition.mg_value()
163                   << std::endl;
164         std::cout << "Incremental eg: " << RootPosition.eg_value()
165                   << std::endl;
166         std::cout << "Full eval: "
167                   << evaluate(RootPosition, ei, 0)
168                   << std::endl;
169     }
170     else if (token == "key")
171     {
172         std::cout << "key: " << RootPosition.get_key()
173                   << " material key: " << RootPosition.get_material_key()
174                   << " pawn key: " << RootPosition.get_pawn_key()
175                   << std::endl;
176     }
177     else
178     {
179         std::cout << "Unknown command: " << command << std::endl;
180         while (!uip.eof())
181         {
182             uip >> token;
183             std::cout << token << std::endl;
184         }
185     }
186   }
187
188
189   // set_position() is called when Stockfish receives the "position" UCI
190   // command.  The input parameter is a UCIInputParser.  It is assumed
191   // that this parser has consumed the first token of the UCI command
192   // ("position"), and is ready to read the second token ("startpos"
193   // or "fen", if the input is well-formed).
194
195   void set_position(UCIInputParser &uip) {
196
197     std::string token;
198
199     uip >> token; // operator >> skips any whitespace
200
201     if (token == "startpos")
202         RootPosition.from_fen(StartPosition);
203     else if (token == "fen")
204     {
205         std::string fen;
206         while (token != "moves" && !uip.eof())
207         {
208           uip >> token;
209           fen += token;
210           fen += ' ';
211         }
212         RootPosition.from_fen(fen);
213     }
214
215     if (!uip.eof())
216     {
217         if (token != "moves")
218           uip >> token;
219         if (token == "moves")
220         {
221             Move move;
222             UndoInfo u;
223             while (!uip.eof())
224             {
225                 uip >> token;
226                 move = move_from_string(RootPosition, token);
227                 RootPosition.do_move(move, u);
228                 if (RootPosition.rule_50_counter() == 0)
229                     RootPosition.reset_game_ply();
230             }
231         }
232     }
233   }
234
235
236   // set_option() is called when Stockfish receives the "setoption" UCI
237   // command.  The input parameter is a UCIInputParser.  It is assumed
238   // that this parser has consumed the first token of the UCI command
239   // ("setoption"), and is ready to read the second token ("name", if
240   // the input is well-formed).
241
242   void set_option(UCIInputParser &uip) {
243
244     std::string token, name;
245
246     uip >> token;
247     if (token == "name")
248     {
249         uip >> name;
250         uip >> token;
251         while (!uip.eof() && token != "value")
252         {
253           name += (" " + token);
254           uip >> token;
255         }
256         if (token == "value")
257         {
258             std::getline(uip, token); // reads until end of line
259             set_option_value(name, token);
260         } else
261             push_button(name);
262     }
263   }
264
265
266   // go() is called when Stockfish receives the "go" UCI command.  The
267   // input parameter is a UCIInputParser.  It is assumed that this
268   // parser has consumed the first token of the UCI command ("go"),
269   // and is ready to read the second token.  The function sets the
270   // thinking time and other parameters from the input string, and
271   // calls think() (defined in search.cpp) with the appropriate
272   // parameters.
273
274   void go(UCIInputParser &uip) {
275
276     std::string token;
277
278     int time[2] = {0, 0}, inc[2] = {0, 0};
279     int movesToGo = 0, depth = 0, nodes = 0, moveTime = 0;
280     bool infinite = false, ponder = false;
281     Move searchMoves[500];
282
283     searchMoves[0] = MOVE_NONE;
284
285     while (!uip.eof())
286     {
287         uip >> token;
288
289         if (token == "infinite")
290             infinite = true;
291         else if (token == "ponder")
292             ponder = true;
293         else if (token == "wtime")
294             uip >> time[0];
295         else if (token == "btime")
296             uip >> time[1];
297         else if (token == "winc")
298             uip >> inc[0];
299         else if (token == "binc")
300             uip >> inc[1];
301         else if (token == "movestogo")
302             uip >> movesToGo;
303         else if (token == "depth")
304             uip >> depth;
305         else if (token == "nodes")
306             uip >> nodes;
307         else if (token == "movetime")
308             uip >> moveTime;
309         else if (token == "searchmoves")
310         {
311             int numOfMoves = 0;
312             while (!uip.eof())
313             {
314                 uip >> token;
315                 searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
316             }
317             searchMoves[numOfMoves] = MOVE_NONE;
318         }
319     }
320
321     if (moveTime)
322         infinite = true;  // HACK
323
324     think(RootPosition, infinite, ponder, RootPosition.side_to_move(), time,
325           inc, movesToGo, depth, nodes, moveTime, searchMoves);
326   }
327 }