Stockfish 1.1a

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

Readme.txt

@@ -1,21 +1,14 @@
 1. Introduction
 ---------------
 
-Glaurung is a free UCI chess engine.  It is not a complete chess
+Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
-program, but requires some UCI compatible GUI (like XBoard with
+not a complete chess program, but requires some UCI compatible GUI
-PolyGlot, eboard, José, Arena, Sigma Chess, Shredder, Chess Partner,
+(like XBoard with PolyGlot, eboard, Jos�, Arena, Sigma Chess, Shredder,
-or Fritz) in order to be used comfortably.  Read the documentation for
+Chess Partner, or Fritz) in order to be used comfortably.  Read the
-your GUI of choice for information about how to use Glaurung with your
+documentation for your GUI of choice for information about how to use
-GUI.
+Stockfish with your GUI.
 
-Glaurung 2 is a completely rewritten version of Glaurung.  Apart from
+This version of Stockfish supports up to 8 CPUs, but has not been
-the parallel search code, almost no code is shared with Glaurung
-1.2.1, the previous stable version.  The new program is clearly
-stronger than the old, but has a less attractive style of play,
-because there are still a few major holes in its evaluation function
-(most notably space and development).
-
-This version of Glaurung supports up to 8 CPUs, but has not been
 tested thoroughly with more than 2.  The program tries to detect the
 number of CPUs on your computer and set the number of search threads
 accordingly, but please be aware that the detection is not always
@@ -27,7 +20,7 @@ cores on your computer.
 2. Files
 --------
 
-This distribution of Glaurung consists of the following files:
+This distribution of Stockfish consists of the following files:
 
   * Readme.txt, the file you are currently reading.
 
@@ -35,284 +28,63 @@ This distribution of Glaurung consists of the following files:
     License.
 
   * src/, a subdirectory containing the full source code, including a
-    Makefile that can be used to compile Glaurung on Unix-like
+    Makefile that can be used to compile Stockfish on Unix-like
-    systems.  For further information about how to compile Glaurung
+    systems.  For further information about how to compile Stockfish
     yourself, read section 4 below.
 
-  * MacOSX/, a subdirectory containing excutables for Apple Macintosh
+  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
-    computers running Mac OS X 10.4 (Tiger) and newer.  There are two
-    executables, one for OS X 10.4, and one for OS X 10.5.  The
-    executable for OS X 10.4 will work in 10.5 as well, but the one
-    for 10.5 is faster.
-
-  * LinuxX86/, a subdirectory containing 32-bit and 64-bit x86 GNU/Linux
-    executables.
-
-  * Windows/, a subdirectory containing 32-bit and 64-bit Windows
-    executables.
-
-  * polyglot.ini, for using Glaurung with Fabien Letouzey's PolyGlot
     adapter.
 
 
 3. Opening books
 ----------------
 
-This version of Glaurung has experimental support for PolyGlot opening
+This version of Stockfish has experimental support for PolyGlot opening
-books.  For information about how to create such books, consult the
+books. For information about how to create such books, consult the
 PolyGlot documentation.  The book file can be selected by setting the
 UCI parameter "Book File".
 
-A book file contributed by Salvo Spitaleri can be found on the
-Glaurung web page.
 
 
 4. Compiling it yourself
 ------------------------
 
 On Unix-like systems, it should usually be possible to compile
-Glaurung directly from the source code with the included Makefile.
+Stockfish directly from the source code with the included Makefile.
 The exception is computer with big-endian CPUs, like PowerPC
-Macintoshes.  Some of the bitboard routines in the current version of
+Macintoshes. Some of the bitboard routines in the current version of
-Glaurung are endianness-sensitive, and won't work on a big-endian CPU.
+Stockfish are endianness-sensitive, and won't work on a big-endian CPU.
 Ensuring that the line with #define USE_32BIT_ATTACKS" near the top
 of bitboard.h is commented out should solve this problem.
 Commenting out the line with "#define USE_32BIT_ATTACKS" near the
 
-There is also a problem with compiling Glaurung on certain 64-bit 
+There is also a problem with compiling Stockfish on certain 64-bit
-systems, regardless of the endianness.  If Glaurung segfaults 
+systems, regardless of the endianness.  If Stockfish segfaults
-immediately after startup, try to comment out the line with 
+immediately after startup, try to comment out the line with
 "#define USE_FOLDED_BITSCAN" near the beginning of bitboard.h and
 recompile.
 
-Finally, even if Glaurung does work without any changes on your
+Finally, even if Stockfish does work without any changes on your
 computer, it might be possible to improve the performance by changing
 some of the #define directives in bitboard.h.  The default settings
 are optimized for 64-bit CPUs.  On 32-bit CPUs, it is probably better
 to switch on USE_32BIT_ATTACKS, and to use BITCOUNT_SWAR_32 instead of
 BITCOUNT_SWAR_64.  For computers with very little memory (like
 handheld devices), it is possible to conserve memory by defining
-USE_COMPACT_ROOK_ATTACKS. 
+USE_COMPACT_ROOK_ATTACKS.
-
-
-
-5. History
-----------
-
-2007-05-06: Glaurung 2 - epsilon
---------------------------------
-
-The first public release, and the first version of my new program
-which is able to match the old Glaurung 1.2.1 on a single CPU.  Lots
-of features and chess knowledge is still missing.
-
-2007-05-10: Glaurung 2 - epsilon/2
-----------------------------------
-
-This version is very close to 2 - epsilon.  The major changes are:
-
-  * A number of compatibility problems which appeared when trying to
-    compile Glaurung 2 - epsilon on various operating systems and CPUs
-    have been solved.
-
-  * Fixed a major bug in the detection of rooks trapped inside a
-    friendly king.
-
-  * Added knowledge about several types of drawn endgames.
-
-  * Fixed a few FRC related bugs.  FRC now works, but because of
-    serious holes in the evaluation function the program plays very
-    badly.
-
-  * A slightly more sophisticated king safety evaluation.
-
-2007-06-07: Glaurung 2 - epsilon/3
-----------------------------------
-
-The first public version with support for multiple CPUs.  Unless you
-have a dual-core (or better) computer, use Glaurung with a PolyGlot
-book, or runs games with ponder on, you may want to skip this version,
-which is almost certainly no stronger than 2 - epsilon/2 when running
-on a single CPU.  The main changes compared to the previous version
-are:
-
-  * Parallel search, with support for 1-4 CPUs.  The program currently
-    always allocates a separate pawn hash table and material hash
-    table for four threads, which is a pure waste of RAM if your
-    computer has just a single CPU.  This will be fixed in a future
-    version.
-
-  * Fixed a bug in book randomization.  When using Polyglot books, the
-    previous version would always select exactly the same move in the
-    same position after a restart of the program.  Thanks to Pavel
-    Háse for pointing this out.
-
-  * Fixed a UCI pondering bug: Glaurung no longer instantly prints its
-    best move when the maximum depth is reached during a ponder
-    search, as the previous version did.  According to the UCI
-    protocol, it is not allowed to print the best move before the
-    engine has received the "stop" or "quit" command.
-
-  * Additional search information:  The new version displays hash
-    saturation and the current line(s) of search.
-
-  * Several minor bug fixes and optimizations in the search and
-    evaluation. 
-
-2007-06-08: Glaurung 2 - epsilon/4
-----------------------------------
-
-A bugfix release, with only a single important change:
-
-   * Fixed a very serious pondering bug.  As pointed out by Marc
-     Lacrosse, the previous version would lose on time in almost every
-     single game with pondering enabled.  The new version handles
-     pondering correctly (or so I hope).  When playing with ponder
-     off, the new version is identical to version 2 - epsilon/3.
-
-2007-06-25: Glaurung 2 - epsilon/5
-----------------------------------
-
-Another minor update, including the following improvements and bug
-fixes:
-
-   * As Werner Schüle discovered, the previous version would sometimes
-     stop thinking and lose on time right before delivering checkmate
-     (which is of course a very unfortunate moment to lose on time).
-     I haven't been able to reproduce Werner's problem on my computer
-     (probably because I run a different OS), but I have fixed the bug
-     which I suspect caused the time losses.  I hope the time losses
-     will no longer occur with 2 - epsilon/5.
-
-   * The program is now slightly less resource-hungry on computers
-     with less than 4 CPU cores: The previous version would always
-     allocated separate pawn and material hash tables for four
-     threads, even when running on a single-core CPU.  The new version
-     only allocates pawn and material hash tables for the threads
-     which are actually used.
-
-   * A minor reorganization of the memory layout has made the parallel
-     search about 10% more efficient (at least on my computer, but the
-     results are likely to vary considerably on different systems).
-
-   * The Intel Mac OS X binary is much faster than before, thanks to
-     the Intel C++ compiler (previous versions were compiled with
-     GCC).
-
-   * A few other very minor bug fixes and enhancements.
-
-2007-11-21: Glaurung 2.0
-------------------------
-
-The first stable (or so I hope) and feature-complete version of
-Glaurung 2.  The following are the main changes compared to the
-previous version:
-
-   * The license has been changed from GPL version 2 to GPL version 3.
-
-   * MultiPV mode.
-
-   * Support for the "searchmoves" option in the UCI "go" command.
-     This means that it is possible to ask Glaurung to exclude some
-     moves from its analysis, or to restrict its analysis to just a
-     handful of moves selected by the user.  This feature must also be
-     supported by the GUI under which Glaurung is run.  Glaurung's own
-     GUI does currently not support this feature.
-
-   * Chess960 support now works.  The program still plays this game 
-     very badly, because of lack of opening knowledge.
-
-   * Much more aggressive pruning in the last few plies of the main
-     search.
-
-   * Somewhat better scaling on multi-CPU systems, and support for up
-     to 8 CPUs.
-
-   * Lots of new UCI parameters.
-
-   * Improved time managment, especially in games with pondering on 
-     (i.e. when the engine is allowed to think when it's the
-     opponent's turn to move).
-
-   * Some evaluation improvements, and some new basic endgame
-     patterns.
-
-   * The program should no longer crash if the game lasts longer than
-     1000 plies.
- 
-   * Many minor bug fixes and other tiny improvements throughout the
-     code.  
- 
-   * More generously commented code, and numerous cosmetic changes in
-     coding style.
-
-2007-11-22: Glaurung 2.0.1
---------------------------
-
-   * Fixed (or so I hope) a bug which would occasionally cause one of
-     the search threads to get stuck forever in its idle loop.
-
-2008-05-14: Glaurung 2.1
-------------------------
-
-This version contains far too many changes to list them all, but most
-of them are minor and cosmetic.  The most important and noticable
-changes are a lot of new UCI parameters, and many improvements in the
-evaluation function.  The highlights are:
-
-   * Extensive changes in the evaluation function.  The addition of
-     king safety is the most important improvement, but there are also
-     numerous little improvements elsewhere in the evaluation.  There
-     is still much work left to do in the evaluation function, though.
-     Space and development are still missing, and the tuning is likely
-     to be very poor.  Currently, the program is optimized for an
-     entertaining style rather than maximum strength.
-
-   * More accurate forward pruning.  The previous version used the
-     null move refutation move to improve the pruning accuracy by
-     means of a very simple trick: It did not allow pruning of any
-     moves with the piece captured by the null move refutation move.
-     In Glaurung 2.1, this has been enhanced: It does not allow
-     pruning of moves which defend the destination square of the null
-     move refutation move, nor of moves which block the ray of the
-     piece in the case that the moving piece in the null move
-     refutation move is a slider.
-
-   * More conservative use of LMR at PV nodes.  The previous version
-     searched the first 6 moves with full depth, 2.1 by default
-     searches the first 14 moves with full depth (but there is a new
-     UCI parameter for configuring this).  I am not at all sure
-     whether this is an improvement.  More thorough testing is
-     required. 
-
-   * Feedback from the evaluation to the search.  The search passes an
-     object of type 'EvalInfo' to the eval, and the eval fills this
-     struct with various potentially useful information (like the sets
-     of squares attacked by each piece type, the middle game and
-     endgame components of the eval, etc.).  At the moment, almost
-     none of this information is actually used by the search.  The
-     only exception is that the evaluation function is now used to
-     adjust the futility pruning margin in the quiescence search.
-
-   * Less extensions.  This hurts the programs performance a lot in most
-     test suites, but I hope it improves the branching factor in deep
-     searches.
-
-   * A very long list of new UCI parameters, especially for tuning the
-     evaluation. 
 
 
 6. Terms of use
 ---------------
 
-Glaurung is free, and distributed under the GNU General Public License
+Stockfish is free, and distributed under the GNU General Public License
 (GPL).  Essentially, this means that you are free to do almost exactly
 what you want with the program, including distributing it among your
 friends, making it available for download from your web site, selling
 it (either by itself or as part of some bigger software package), or
 using it as the starting point for a software project of your own.
 
-The only real limitation is that whenever you distribute Glaurung in
+The only real limitation is that whenever you distribute Stockfish in
 some way, you must always include the full source code, or a pointer
 to where the source code can be found.  If you make any changes to the
 source code, these changes must also be made available under the GPL.
@@ -324,5 +96,4 @@ Copying.txt.
 7. Feedback
 -----------
 
-The author's e-mail address is tord@glaurungchess.com
+The author's e-mail address is mcostalba@gmail.com
-

src/Makefile

@@ -1,14 +1,15 @@
-# Glaurung, a UCI chess playing engine.
+# Stockfish, a UCI chess playing engine derived from Glaurung 2.1
 # Copyright (C) 2004-2007 Tord Romstad
+# Copyright (C) 2008 Marco Costalba
 
-# This file is part of Glaurung.
+# This file is part of Stockfish.
 #
-# Glaurung is free software: you can redistribute it and/or modify
+# 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.
 #
-# Glaurung is distributed in the hope that it will be useful,
+# 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.
@@ -21,7 +22,7 @@
 ### Files
 ###
 
-EXE = glaurung
+EXE = stockfish
 
 OBJS = bitboard.o color.o pawns.o material.o endgame.o evaluate.o main.o \
 	misc.o move.o movegen.o history.o movepick.o search.o piece.o \
@@ -35,7 +36,7 @@ OBJS = bitboard.o color.o pawns.o material.o endgame.o evaluate.o main.o \
 
 all: $(EXE) .depend
 
-clean: 
+clean:
 	$(RM) *.o .depend glaurung
 
 
@@ -43,9 +44,9 @@ clean:
 ### Compiler:
 ###
 
-CXX = g++
+# CXX = g++
 # CXX = g++-4.2
-# CXX = icpc
+CXX = icpc
 
 
 ###
@@ -78,7 +79,11 @@ CXXFLAGS += -Wall -g
 # General optimization flags.  Note that -O2 might be faster than -O3 on some
 # systems; this requires testing.
 
-CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fstrict-aliasing
+CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fno-strict-aliasing
+
+# Disable most annoying warnings for the Intel C++ compiler
+
+CXXFLAGS += -wd383,869,981
 
 
 # Compiler optimization flags for the Intel C++ compiler in Mac OS X:
@@ -88,16 +93,16 @@ CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fstrict-aliasing
 
 # Profiler guided optimization with the Intel C++ compiler.  To use it, first
 # create the directory ./profdata if it does not already exist, and delete its
-# contents if it does exist.  Then compile with -prof_gen, and run the 
+# contents if it does exist.  Then compile with -prof_gen, and run the
 # resulting binary for a while (for instance, do ./glaurung bench 128 1, and
-# wait 15 minutes for the benchmark to complete).  Then do a 'make clean', and 
+# wait 15 minutes for the benchmark to complete).  Then do a 'make clean', and
 # recompile with -prof_use.
 
-# CXXFLAGS += -prof_gen -prof_dir ./profdata
+# CXXFLAGS += -prof_gen -prof_dir profdata
 # CXXFLAGS += -prof_use -prof_dir ./profdata
 
 
-# Profiler guided optimization with GCC.  I've never been able to make this 
+# Profiler guided optimization with GCC.  I've never been able to make this
 # work.
 
 # CXXFLAGS += -fprofile-generate
@@ -125,7 +130,7 @@ LDFLAGS += -lm -lpthread
 # LDFLAGS += -arch x86_64
 
 
-# Backwards compatibility with Mac OS X 10.4 when compiling under 10.5 with 
+# Backwards compatibility with Mac OS X 10.4 when compiling under 10.5 with
 # GCC 4.0.  I haven't found a way to make it work with GCC 4.2.
 
 # CXXFLAGS += -isysroot /Developer/SDKs/MacOSX10.4u.sdk

src/benchmark.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -20,6 +21,9 @@
 ////
 //// Includes
 ////
+#include <fstream>
+#include <sstream>
+#include <vector>
 
 #include "benchmark.h"
 #include "search.h"
@@ -31,7 +35,8 @@
 //// Variables
 ////
 
-const std::string BenchmarkPositions[15] = {
+const std::string BenchmarkPositions[] = {
+  "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
   "r4rk1/1b2qppp/p1n1p3/1p6/1b1PN3/3BRN2/PP3PPP/R2Q2K1 b - - 7 16",
   "4r1k1/ppq3pp/3b4/2pP4/2Q1p3/4B1P1/PP5P/R5K1 b - - 0 20",
   "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
@@ -54,38 +59,93 @@ const std::string BenchmarkPositions[15] = {
 //// Functions
 ////
 
-/// benchmark() runs a simple benchmark by letting Glaurung analyze 15
+/// benchmark() runs a simple benchmark by letting Stockfish analyze a set
-/// positions for 60 seconds each.  There are two parameters; the
+/// of positions for a given time each.  There are four parameters; the
-/// transposition table size and the number of search threads that should
+/// transposition table size, the number of search threads that should
-/// be used.  The analysis is written to a file named bench.txt.
+/// be used, the time in seconds spent for each position (optional, default
+/// is 60) and an optional file name where to look for positions in fen
+/// format (default are the BenchmarkPositions defined above).
+/// The analysis is written to a file named bench.txt.
 
-void benchmark(const std::string &ttSize, const std::string &threads) {
+void benchmark(const std::string& commandLine) {
-  Position pos;
-  Move moves[1] = {MOVE_NONE};
-  int i;
 
-  i = atoi(ttSize.c_str());
+  std::istringstream csVal(commandLine);
-  if(i < 4 || i > 1024) {
+  std::istringstream csStr(commandLine);
-    std::cerr << "The hash table size must be between 4 and 1024" << std::endl;
+  std::string ttSize, threads, fileName, limitType;
-    exit(EXIT_FAILURE);
+  int val, secsPerPos, maxDepth, maxNodes;
+
+  csStr >> ttSize;
+  csVal >> val;
+  if (val < 4 || val > 1024)
+  {
+      std::cerr << "The hash table size must be between 4 and 1024" << std::endl;
+      exit(EXIT_FAILURE);
   }
-
+  csStr >> threads;
-  i = atoi(threads.c_str());
+  csVal >> val;
-  if(i < 1 || i > THREAD_MAX) {
+  if (val < 1 || val > THREAD_MAX)
-    std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
+  {
-              << std::endl;
+      std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
-    exit(EXIT_FAILURE);
+                << std::endl;
-  }
+      exit(EXIT_FAILURE);
-  
+  }  
   set_option_value("Hash", ttSize);
   set_option_value("Threads", threads);
   set_option_value("OwnBook", "false");
   set_option_value("Use Search Log", "true");
   set_option_value("Search Log Filename", "bench.txt");
 
-  for(i = 0; i < 15; i++) {
+  csVal >> val;
-    pos.from_fen(BenchmarkPositions[i]);
+  csVal >> fileName;
-    think(pos, true, false, 0, 0, 0, 0, 0, 60000, moves);
+  csVal >> limitType;
+
+  secsPerPos = maxDepth = maxNodes = 0;
+
+  if (limitType == "time")
+      secsPerPos = val * 1000;
+  else if (limitType == "depth")
+      maxDepth = val;
+  else
+      maxNodes = val;
+
+  std::vector<std::string> positions;
+  
+  if (fileName != "default")
+  {
+      std::ifstream fenFile(fileName.c_str());
+      if (!fenFile.is_open())
+      {
+          std::cerr << "Unable to open positions file " << fileName
+                    << std::endl;
+          exit(EXIT_FAILURE);
+      }        
+      std::string pos;
+      while (fenFile.good())
+      {
+          std::getline(fenFile, pos);
+          if (!pos.empty())
+              positions.push_back(pos);
+      }
+      fenFile.close();
+  } else
+      for (int i = 0; i < 16; i++)
+          positions.push_back(std::string(BenchmarkPositions[i]));
+
+  int startTime = get_system_time();
+  std::vector<std::string>::iterator it;
+  int cnt = 1;
+  int64_t totalNodes = 0;
+  for (it = positions.begin(); it != positions.end(); ++it, ++cnt)
+  {
+      Move moves[1] = {MOVE_NONE};
+      int dummy[2] = {0, 0};
+      Position pos(*it);
+      std::cout << "\nProcessing position " << cnt << '/' << positions.size() << std::endl << std::endl;
+      think(pos, true, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves);
+      totalNodes += nodes_searched();
   }
-    
+  std::cout << "\nProcessing time (ms) " << get_system_time() - startTime << std::endl
+            << "Nodes searched " << totalNodes << std::endl
+            << "Press any key to exit" << std::endl;
+  std::cin >> fileName;
 }

src/benchmark.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -31,7 +32,6 @@
 //// Prototypes
 ////
 
-extern void benchmark(const std::string &ttSize, const std::string &threads);
+extern void benchmark(const std::string& commandLine);
-
 
 #endif // !defined(BENCHMARK_H_INCLUDED)

src/bitbase.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/bitbase.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/bitboard.cpp

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -21,6 +22,16 @@
 //// Includes
 ////
 
+#ifdef _MSC_VER
+    #include <intrin.h>
+    #ifdef _WIN64
+        #pragma intrinsic(_BitScanForward64)
+    #else
+        #pragma intrinsic(_BitScanForward)
+    #endif
+    #define USING_INTRINSICS
+#endif
+
 #include <iostream>
 
 #include "bitboard.h"
@@ -38,7 +49,7 @@ const Bitboard FileBB[8] = {
 };
 
 const Bitboard NeighboringFilesBB[8] = {
-  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB, 
+  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
   FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
 };
 
@@ -47,7 +58,7 @@ const Bitboard ThisAndNeighboringFilesBB[8] = {
   FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
   FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
   FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
-};  
+};
 
 const Bitboard RankBB[8] = {
   Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
@@ -126,27 +137,27 @@ const int RShift[64] = {
 #else // if defined(USE_32BIT_ATTACKS)
 
 const uint64_t RMult[64] = {
-  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL, 
+  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
-  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL, 
+  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL,
-  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL, 
+  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL,
-  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL, 
+  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL,
-  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL, 
+  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL,
-  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL, 
+  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL,
-  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL, 
+  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL,
-  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL, 
+  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL,
-  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL, 
+  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL,
-  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL, 
+  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL,
-  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL, 
+  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL,
-  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL, 
+  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL,
-  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL, 
+  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL,
-  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL, 
+  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
-  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL, 
+  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL,
-  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL, 
+  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL,
-  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL, 
+  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
-  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL, 
+  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL,
-  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL, 
+  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL,
-  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL, 
+  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL,
-  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL, 
+  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL,
   0x410201ce5c030092ULL
 };
 
@@ -190,7 +201,7 @@ const uint64_t BMult[64] = {
   0x881c7c67fcbfc4f6ULL, 0x47ca41e7e440d423ULL, 0xeb0c88112048d004ULL,
   0x51c60e04359aef1aULL, 0x1aa1fe0e957a5554ULL, 0xdd9448db4f5e3104ULL,
   0xdc01f6dca4bebbdcULL,
-}; 
+};
 
 const int BShift[64] = {
   26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
@@ -202,27 +213,27 @@ const int BShift[64] = {
 #else // if defined(USE_32BIT_ATTACKS)
 
 const uint64_t BMult[64] = {
-  0x440049104032280ULL, 0x1021023c82008040ULL, 0x404040082000048ULL, 
+  0x440049104032280ULL, 0x1021023c82008040ULL, 0x404040082000048ULL,
-  0x48c4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL, 
+  0x48c4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL,
-  0x181011002e06040ULL, 0x9101004104200e00ULL, 0x1240848848310401ULL, 
+  0x181011002e06040ULL, 0x9101004104200e00ULL, 0x1240848848310401ULL,
-  0x2000142828050024ULL, 0x1004024d5000ULL, 0x102044400800200ULL, 
+  0x2000142828050024ULL, 0x1004024d5000ULL, 0x102044400800200ULL,
-  0x8108108820112000ULL, 0xa880818210c00046ULL, 0x4008008801082000ULL, 
+  0x8108108820112000ULL, 0xa880818210c00046ULL, 0x4008008801082000ULL,
-  0x60882404049400ULL, 0x104402004240810ULL, 0xa002084250200ULL, 
+  0x60882404049400ULL, 0x104402004240810ULL, 0xa002084250200ULL,
-  0x100b0880801100ULL, 0x4080201220101ULL, 0x44008080a00000ULL, 
+  0x100b0880801100ULL, 0x4080201220101ULL, 0x44008080a00000ULL,
-  0x202200842000ULL, 0x5006004882d00808ULL, 0x200045080802ULL, 
+  0x202200842000ULL, 0x5006004882d00808ULL, 0x200045080802ULL,
-  0x86100020200601ULL, 0xa802080a20112c02ULL, 0x80411218080900ULL, 
+  0x86100020200601ULL, 0xa802080a20112c02ULL, 0x80411218080900ULL,
-  0x200a0880080a0ULL, 0x9a01010000104000ULL, 0x28008003100080ULL, 
+  0x200a0880080a0ULL, 0x9a01010000104000ULL, 0x28008003100080ULL,
-  0x211021004480417ULL, 0x401004188220806ULL, 0x825051400c2006ULL, 
+  0x211021004480417ULL, 0x401004188220806ULL, 0x825051400c2006ULL,
-  0x140c0210943000ULL, 0x242800300080ULL, 0xc2208120080200ULL, 
+  0x140c0210943000ULL, 0x242800300080ULL, 0xc2208120080200ULL,
-  0x2430008200002200ULL, 0x1010100112008040ULL, 0x8141050100020842ULL, 
+  0x2430008200002200ULL, 0x1010100112008040ULL, 0x8141050100020842ULL,
-  0x822081014405ULL, 0x800c049e40400804ULL, 0x4a0404028a000820ULL, 
+  0x822081014405ULL, 0x800c049e40400804ULL, 0x4a0404028a000820ULL,
-  0x22060201041200ULL, 0x360904200840801ULL, 0x881a08208800400ULL, 
+  0x22060201041200ULL, 0x360904200840801ULL, 0x881a08208800400ULL,
-  0x60202c00400420ULL, 0x1204440086061400ULL, 0x8184042804040ULL, 
+  0x60202c00400420ULL, 0x1204440086061400ULL, 0x8184042804040ULL,
-  0x64040315300400ULL, 0xc01008801090a00ULL, 0x808010401140c00ULL, 
+  0x64040315300400ULL, 0xc01008801090a00ULL, 0x808010401140c00ULL,
-  0x4004830c2020040ULL, 0x80005002020054ULL, 0x40000c14481a0490ULL, 
+  0x4004830c2020040ULL, 0x80005002020054ULL, 0x40000c14481a0490ULL,
-  0x10500101042048ULL, 0x1010100200424000ULL, 0x640901901040ULL, 
+  0x10500101042048ULL, 0x1010100200424000ULL, 0x640901901040ULL,
-  0xa0201014840ULL, 0x840082aa011002ULL, 0x10010840084240aULL, 
+  0xa0201014840ULL, 0x840082aa011002ULL, 0x10010840084240aULL,
-  0x420400810420608ULL, 0x8d40230408102100ULL, 0x4a00200612222409ULL, 
+  0x420400810420608ULL, 0x8d40230408102100ULL, 0x4a00200612222409ULL,
   0xa08520292120600ULL
 };
 
@@ -274,7 +285,7 @@ namespace {
 #if defined(USE_COMPACT_ROOK_ATTACKS)
   void init_file_and_rank_attacks();
 #endif
-};
+}
 
 
 ////
@@ -320,9 +331,9 @@ void init_bitboards() {
 #if defined(USE_FOLDED_BITSCAN)
 
 static const int BitTable[64] = {
-  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2, 
+  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2,
-  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52, 
+  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52,
-  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28, 
+  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28,
   58, 20, 37, 17, 36, 8
 };
 
@@ -339,6 +350,43 @@ Square first_1(Bitboard b) {
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.
 
+#if defined(USE_32BIT_ATTACKS)
+
+// Use type-punning
+union b_union {
+
+    Bitboard b;
+    struct {
+        uint32_t l;
+        uint32_t h;
+    };
+};
+
+// WARNING: Needs -fno-strict-aliasing compiler option
+Square pop_1st_bit(Bitboard *bb) {
+
+  b_union u;
+  uint32_t b;
+
+  u.b = *bb;
+
+  if (u.l)
+  {
+      b = u.l;
+      *((uint32_t*)bb) = b & (b - 1);
+      b ^= (b - 1);
+  }
+  else
+  {
+      b = u.h;
+      *((uint32_t*)bb+1) = b & (b - 1); // Little endian only?
+      b = ~(b ^ (b - 1));
+  }
+  return Square(BitTable[(b * 0x783a9b23) >> 26]);
+}
+
+#else
+
 Square pop_1st_bit(Bitboard *b) {
   Bitboard bb = *b ^ (*b - 1);
   uint32_t fold = int(bb) ^ int(bb >> 32);
@@ -346,6 +394,8 @@ Square pop_1st_bit(Bitboard *b) {
   return Square(BitTable[(fold * 0x783a9b23) >> 26]);
 }
 
+#endif
+
 #else
 
 static const int BitTable[64] = {
@@ -369,7 +419,7 @@ Square first_1(Bitboard b) {
 Square pop_1st_bit(Bitboard *b) {
   Bitboard bb = *b;
   *b &= (*b - 1);
-  return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]); 
+  return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]);
 }
 
 #endif // defined(USE_FOLDED_BITSCAN)
@@ -417,7 +467,7 @@ namespace {
       {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
       {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}
     };
-    
+
     for(i = 0; i < 64; i++) {
       for(j = 0; j <= int(BK); j++) {
         StepAttackBB[j][i] = EmptyBoardBB;
@@ -483,14 +533,14 @@ namespace {
     Bitboard b;
     for(i = 0; i < 64; i++) {
       attackIndex[i] = index;
-      mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);      
+      mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);
       j = (1 << (64 - shift[i]));
       for(k = 0; k < j; k++) {
 #if defined(USE_32BIT_ATTACKS)
         b = index_to_bitboard(k, mask[i]);
-        attacks[index + 
+        attacks[index +
-                 (unsigned(int(b) * int(mult[i]) ^ 
+                 (unsigned(int(b) * int(mult[i]) ^
-                           int(b >> 32) * int(mult[i] >> 32)) 
+                           int(b >> 32) * int(mult[i] >> 32))
                   >> shift[i])] =
           sliding_attacks(i, b, 4, deltas);
 #else
@@ -502,7 +552,7 @@ namespace {
       index += j;
     }
   }
-  
+
 
   void init_pseudo_attacks() {
     Square s;
@@ -537,5 +587,5 @@ namespace {
     }
   }
 #endif // defined(USE_COMPACT_ROOK_ATTACKS)
-    
+
 }

src/bitboard.h

@@ -1,17 +1,19 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+
+  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/>.
 */
@@ -25,15 +27,37 @@
 //// Defines
 ////
 
+// Comment following define if you prefer manually adjust
+// platform macros defined below
+#define AUTO_CONFIGURATION
+
+// Quiet a warning on Intel compiler
+#if !defined(__SIZEOF_INT__ )
+#define __SIZEOF_INT__ 0
+#endif
+
+// Check for 64 bits for different compilers: Intel, MSVC and gcc
+#if defined(__x86_64) || defined(_WIN64) || (__SIZEOF_INT__ > 4)
+#define IS_64BIT
+#endif
+
+#if !defined(AUTO_CONFIGURATION) || defined(IS_64BIT)
+
 //#define USE_COMPACT_ROOK_ATTACKS
-//#define USE_32BIT_ATTACKS 
+//#define USE_32BIT_ATTACKS
 #define USE_FOLDED_BITSCAN
 
 #define BITCOUNT_SWAR_64
 //#define BITCOUNT_SWAR_32
 //#define BITCOUNT_LOOP
 
+#else
 
+#define USE_32BIT_ATTACKS
+#define USE_FOLDED_BITSCAN
+#define BITCOUNT_SWAR_32
+
+#endif
 
 ////
 //// Includes
@@ -74,7 +98,7 @@ const Bitboard FileHBB = 0x8080808080808080ULL;
 
 extern const Bitboard FileBB[8];
 extern const Bitboard NeighboringFilesBB[8];
-extern const Bitboard ThisAndNeighboringFilesBB[8];  
+extern const Bitboard ThisAndNeighboringFilesBB[8];
 
 const Bitboard Rank1BB = 0xFFULL;
 const Bitboard Rank2BB = 0xFF00ULL;
@@ -109,7 +133,7 @@ extern int RAttackIndex[64];
 extern Bitboard RAttacks[0x19000];
 #endif // defined(USE_COMPACT_ROOK_ATTACKS)
 
-extern const uint64_t BMult[64]; 
+extern const uint64_t BMult[64];
 extern const int BShift[64];
 extern Bitboard BMask[64];
 extern int BAttackIndex[64];
@@ -124,29 +148,19 @@ extern Bitboard QueenPseudoAttacks[64];
 //// Inline functions
 ////
 
-/// Functions for testing whether a given bit is set in a bitboard, and for 
+/// Functions for testing whether a given bit is set in a bitboard, and for
 /// setting and clearing bits.
 
-inline Bitboard set_mask_bb(Square s) {
-  //  return 1ULL << s;
-  return SetMaskBB[s];
-}
-
-inline Bitboard clear_mask_bb(Square s) {
-  //  return ~set_mask_bb(s);
-  return ClearMaskBB[s];
-}
-
 inline Bitboard bit_is_set(Bitboard b, Square s) {
-  return b & set_mask_bb(s);
+  return b & SetMaskBB[s];
 }
 
 inline void set_bit(Bitboard *b, Square s) {
-  *b |= set_mask_bb(s);
+  *b |= SetMaskBB[s];
 }
 
 inline void clear_bit(Bitboard *b, Square s) {
-  *b &= clear_mask_bb(s);
+  *b &= ClearMaskBB[s];
 }
 
 
@@ -181,7 +195,7 @@ inline Bitboard neighboring_files_bb(File f) {
 inline Bitboard neighboring_files_bb(Square s) {
   return neighboring_files_bb(square_file(s));
 }
-  
+
 
 /// this_and_neighboring_files_bb takes a file or a square as input, and
 /// returns a bitboard representing all squares on the given and neighboring
@@ -256,9 +270,9 @@ inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
 
 inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & RMask[s];
-  return RAttacks[RAttackIndex[s] + 
+  return RAttacks[RAttackIndex[s] +
                   (unsigned(int(b) * int(RMult[s]) ^
-                            int(b >> 32) * int(RMult[s] >> 32)) 
+                            int(b >> 32) * int(RMult[s] >> 32))
                    >> RShift[s])];
 }
 
@@ -275,9 +289,9 @@ inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
 
 inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & BMask[s];
-  return BAttacks[BAttackIndex[s] + 
+  return BAttacks[BAttackIndex[s] +
                   (unsigned(int(b) * int(BMult[s]) ^
-                            int(b >> 32) * int(BMult[s] >> 32)) 
+                            int(b >> 32) * int(BMult[s] >> 32))
                    >> BShift[s])];
 }
 
@@ -305,9 +319,9 @@ inline Bitboard squares_between(Square s1, Square s2) {
 }
 
 
-/// squares_in_front_of takes a color and a square as input, and returns a 
+/// squares_in_front_of takes a color and a square as input, and returns a
 /// bitboard representing all squares along the line in front of the square,
-/// from the point of view of the given color.  For instance, 
+/// from the point of view of the given color.  For instance,
 /// squares_in_front_of(BLACK, SQ_E4) returns a bitboard with the squares
 /// e3, e2 and e1 set.
 
@@ -324,8 +338,8 @@ inline Bitboard squares_behind(Color c, Square s) {
 }
 
 
-/// passed_pawn_mask takes a color and a square as input, and returns a 
+/// passed_pawn_mask takes a color and a square as input, and returns a
-/// bitboard mask which can be used to test if a pawn of the given color on 
+/// bitboard mask which can be used to test if a pawn of the given color on
 /// the given square is a passed pawn.
 
 inline Bitboard passed_pawn_mask(Color c, Square s) {
@@ -342,7 +356,7 @@ inline Bitboard outpost_mask(Color c, Square s) {
 }
 
 
-/// isolated_pawn_mask takes a square as input, and returns a bitboard mask 
+/// isolated_pawn_mask takes a square as input, and returns a bitboard mask
 /// which can be used to test whether a pawn on the given square is isolated.
 
 inline Bitboard isolated_pawn_mask(Square s) {

src/book.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -29,7 +30,6 @@
 ////
 
 #include <cassert>
-#include <cstdio>
 
 #include "book.h"
 #include "mersenne.h"
@@ -339,8 +339,9 @@ namespace {
   uint64_t book_ep_key(const Position &pos);
   uint64_t book_color_key(const Position &pos);
 
-  uint64_t read_integer(FILE *file, int size);
+  uint16_t read_integer16(std::ifstream& file);
-
+  uint64_t read_integer64(std::ifstream& file);
+  uint64_t read_integer(std::ifstream& file, int size);
 }
 
 
@@ -351,27 +352,26 @@ namespace {
 
 /// Constructor
 
-Book::Book() {
+Book::Book() : bookSize(0) {}
-  bookFile = NULL;
-  bookSize = 0;
-}
 
 
 /// Book::open() opens a book file with a given file name.
 
 void Book::open(const std::string &fName) {
+
   fileName = fName;
-  bookFile = fopen(fileName.c_str(), "rb");
+  bookFile.open(fileName.c_str(), std::ifstream::in | std::ifstream::binary);
-  if(bookFile != NULL) {
+  if (!bookFile.is_open())
-    if(fseek(bookFile, 0, SEEK_END) == -1) {
+      return;
+
+  bookFile.seekg(0, std::ios::end);
+  bookSize = bookFile.tellg() / 16;
+  bookFile.seekg(0, std::ios::beg);
+
+  if (!bookFile.good())
+  {
       std::cerr << "Failed to open book file " << fileName << std::endl;
       exit(EXIT_FAILURE);
-    }
-    bookSize = ftell(bookFile) / 16;
-    if(bookSize == -1) {
-      std::cerr << "Failed to open book file " << fileName << std::endl;
-      exit(EXIT_FAILURE);
-    }
   }
 }
 
@@ -379,17 +379,17 @@ void Book::open(const std::string &fName) {
 /// Book::close() closes the currently open book file.
 
 void Book::close() {
-  if(bookFile != NULL && fclose(bookFile) == EOF) {
+
-    std::cerr << "Failed to close book file" << std::endl;
+  if (bookFile.is_open())
-    exit(EXIT_FAILURE);
+      bookFile.close();
-  }
 }
 
 
 /// Book::is_open() tests whether a book file has been opened.
 
 bool Book::is_open() const {
-  return bookFile != NULL && bookSize != 0;
+  
+  return bookFile.is_open() && bookSize != 0;
 }
 
 
@@ -397,7 +397,8 @@ bool Book::is_open() const {
 /// or the empty string if no book is open.
 
 const std::string Book::file_name() const {
-  return this->is_open()? fileName : "";
+
+  return bookFile.is_open() ? fileName : "";
 }
   
 
@@ -476,19 +477,21 @@ int Book::find_key(uint64_t key) const {
 /// file.  The book entry is copied to the first input parameter.
 
 void Book::read_entry(BookEntry& entry, int n) const {
-  assert(n >= 0 && n < bookSize);
-  assert(bookFile != NULL);
 
-  if(fseek(bookFile, n*16, SEEK_SET) == -1) {
+  assert(n >= 0 && n < bookSize);
+  assert(bookFile.is_open());
+
+  bookFile.seekg(n*16, std::ios_base::beg);
+  if (!bookFile.good())
+  {
     std::cerr << "Failed to read book entry at index " << n << std::endl;
     exit(EXIT_FAILURE);
   }
-
+  entry.key = read_integer64(bookFile);
-  entry.key = read_integer(bookFile, 8);
+  entry.move = read_integer16(bookFile);
-  entry.move = read_integer(bookFile, 2);
+  entry.count = read_integer16(bookFile);
-  entry.count = read_integer(bookFile, 2);
+  entry.n = read_integer16(bookFile);
-  entry.n = read_integer(bookFile, 2);
+  entry.sum = read_integer16(bookFile);
-  entry.sum = read_integer(bookFile, 2);
 }
 
 
@@ -554,25 +557,36 @@ namespace {
   }
   
 
-  uint64_t read_integer(FILE *file, int size) {
+  uint16_t read_integer16(std::ifstream& file) {
-    uint64_t n = 0ULL;;
+    
-    int i;
+    uint64_t n = read_integer(file, 2);
-    int b;
+    assert(n == (uint16_t)n);
+    return (uint16_t)n;      
+  }
 
-    assert(file != NULL);
-    assert(size > 0 && size <= 8);
 
-    for(i = 0; i < size; i++) {
+  uint64_t read_integer64(std::ifstream& file) {
-      b = fgetc(file);
+    
-      if(b == EOF) {
+    return read_integer(file, 8);      
+  }
+
+
+  uint64_t read_integer(std::ifstream& file, int size) {
+
+    char buf[8];
+    file.read(buf, size);
+
+    if (!file.good())
+    {
         std::cerr << "Failed to read " << size << " bytes from book file"
                   << std::endl;
         exit(EXIT_FAILURE);
-      }
-      assert(b >= 0 && b < 256);
-      n = (n << 8) | b;
     }
+    // Numbers are stored in little endian format
+    uint64_t n = 0ULL;
+    for (int i = 0; i < size; i++)
+        n = (n << 8) + (unsigned char)buf[i];
+
     return n;
   }
-
 }

src/book.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -32,6 +33,7 @@
 //// Includes
 ////
 
+#include <fstream>
 #include <string>
 
 #include "move.h"
@@ -74,7 +76,7 @@ private:
   void read_entry(BookEntry &entry, int n) const;
 
   std::string fileName;
-  FILE *bookFile;
+  mutable std::ifstream bookFile;
   int bookSize;
 };
 

src/color.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/color.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/depth.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/direction.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/direction.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/endgame.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -212,19 +213,19 @@ KPKPScalingFunction::KPKPScalingFunction(Color c) : ScalingFunction(c) { }
 Value KXKEvaluationFunction::apply(const Position &pos) {
 
   assert(pos.non_pawn_material(weakerSide) == Value(0));
-  assert(pos.pawn_count(weakerSide) == Value(0));
+  assert(pos.piece_count(weakerSide, PAWN) == Value(0));
 
   Square winnerKSq = pos.king_square(strongerSide);
   Square loserKSq = pos.king_square(weakerSide);
 
   Value result =
     pos.non_pawn_material(strongerSide) +
-    pos.pawn_count(strongerSide) * PawnValueEndgame +
+    pos.piece_count(strongerSide, PAWN) * PawnValueEndgame +
     mate_table(loserKSq) +
     distance_bonus(square_distance(winnerKSq, loserKSq));
 
-  if(pos.queen_count(strongerSide) > 0 || pos.rook_count(strongerSide) > 0 ||
+  if(pos.piece_count(strongerSide, QUEEN) > 0 || pos.piece_count(strongerSide, ROOK) > 0 ||
-     pos.bishop_count(strongerSide) > 1)
+     pos.piece_count(strongerSide, BISHOP) > 1)
     // TODO: check for two equal-colored bishops!
     result += VALUE_KNOWN_WIN;
 
@@ -238,16 +239,16 @@ Value KXKEvaluationFunction::apply(const Position &pos) {
 Value KBNKEvaluationFunction::apply(const Position &pos) {
 
   assert(pos.non_pawn_material(weakerSide) == Value(0));
-  assert(pos.pawn_count(weakerSide) == Value(0));
+  assert(pos.piece_count(weakerSide, PAWN) == Value(0));
   assert(pos.non_pawn_material(strongerSide) ==
          KnightValueMidgame + BishopValueMidgame);
-  assert(pos.bishop_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.knight_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, KNIGHT) == 1);
-  assert(pos.pawn_count(strongerSide) == 0);
+  assert(pos.piece_count(strongerSide, PAWN) == 0);
 
   Square winnerKSq = pos.king_square(strongerSide);
   Square loserKSq = pos.king_square(weakerSide);
-  Square bishopSquare = pos.bishop_list(strongerSide, 0);
+  Square bishopSquare = pos.piece_list(strongerSide, BISHOP, 0);
 
   if(square_color(bishopSquare) == BLACK) {
     winnerKSq = flop_square(winnerKSq);
@@ -268,8 +269,8 @@ Value KPKEvaluationFunction::apply(const Position &pos) {
 
   assert(pos.non_pawn_material(strongerSide) == Value(0));
   assert(pos.non_pawn_material(weakerSide) == Value(0));
-  assert(pos.pawn_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, PAWN) == 1);
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
   
   Square wksq, bksq, wpsq;
   Color stm;
@@ -277,13 +278,13 @@ Value KPKEvaluationFunction::apply(const Position &pos) {
   if(strongerSide == WHITE) {
     wksq = pos.king_square(WHITE);
     bksq = pos.king_square(BLACK);
-    wpsq = pos.pawn_list(WHITE, 0);
+    wpsq = pos.piece_list(WHITE, PAWN, 0);
     stm = pos.side_to_move();
   }
   else {
     wksq = flip_square(pos.king_square(BLACK));
     bksq = flip_square(pos.king_square(WHITE));
-    wpsq = flip_square(pos.pawn_list(BLACK, 0));
+    wpsq = flip_square(pos.piece_list(BLACK, PAWN, 0));
     stm = opposite_color(pos.side_to_move());
   }
 
@@ -311,17 +312,17 @@ Value KPKEvaluationFunction::apply(const Position &pos) {
 Value KRKPEvaluationFunction::apply(const Position &pos) {
 
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
-  assert(pos.pawn_count(strongerSide) == 0);
+  assert(pos.piece_count(strongerSide, PAWN) == 0);
   assert(pos.non_pawn_material(weakerSide) == 0);
-  assert(pos.pawn_count(weakerSide) == 1);
+  assert(pos.piece_count(weakerSide, PAWN) == 1);
 
   Square wksq, wrsq, bksq, bpsq;
   int tempo = (pos.side_to_move() == strongerSide);
 
   wksq = pos.king_square(strongerSide);
-  wrsq = pos.rook_list(strongerSide, 0);
+  wrsq = pos.piece_list(strongerSide, ROOK, 0);
   bksq = pos.king_square(weakerSide);
-  bpsq = pos.pawn_list(weakerSide, 0);
+  bpsq = pos.piece_list(weakerSide, PAWN, 0);
 
   if(strongerSide == BLACK) {
     wksq = flip_square(wksq);
@@ -366,10 +367,10 @@ Value KRKPEvaluationFunction::apply(const Position &pos) {
 Value KRKBEvaluationFunction::apply(const Position &pos) {
 
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
-  assert(pos.pawn_count(strongerSide) == 0);
+  assert(pos.piece_count(strongerSide, PAWN) == 0);
   assert(pos.non_pawn_material(weakerSide) == BishopValueMidgame);
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
-  assert(pos.bishop_count(weakerSide) == 1);
+  assert(pos.piece_count(weakerSide, BISHOP) == 1);
 
   Value result = mate_table(pos.king_square(weakerSide));
   return (pos.side_to_move() == strongerSide)? result : -result;
@@ -382,13 +383,13 @@ Value KRKBEvaluationFunction::apply(const Position &pos) {
 Value KRKNEvaluationFunction::apply(const Position &pos) {
 
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
-  assert(pos.pawn_count(strongerSide) == 0);
+  assert(pos.piece_count(strongerSide, PAWN) == 0);
   assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame);
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
-  assert(pos.knight_count(weakerSide) == 1);
+  assert(pos.piece_count(weakerSide, KNIGHT) == 1);
 
   Square defendingKSq = pos.king_square(weakerSide);
-  Square nSq = pos.knight_list(weakerSide, 0);
+  Square nSq = pos.piece_list(weakerSide, KNIGHT, 0);
 
   Value result = Value(10) + mate_table(defendingKSq) +
     krkn_king_knight_distance_penalty(square_distance(defendingKSq, nSq));
@@ -405,9 +406,9 @@ Value KRKNEvaluationFunction::apply(const Position &pos) {
 
 Value KQKREvaluationFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
-  assert(pos.pawn_count(strongerSide) == 0);
+  assert(pos.piece_count(strongerSide, PAWN) == 0);
   assert(pos.non_pawn_material(weakerSide) == RookValueMidgame);
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
 
   Square winnerKSq = pos.king_square(strongerSide);
   Square loserKSq = pos.king_square(weakerSide);
@@ -427,20 +428,20 @@ Value KQKREvaluationFunction::apply(const Position &pos) {
 
 ScaleFactor KBPKScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
-  assert(pos.bishop_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.pawn_count(strongerSide) >= 1);
+  assert(pos.piece_count(strongerSide, PAWN) >= 1);
 
   // No assertions about the material of weakerSide, because we want draws to
   // be detected even when the weaker side has some pawns.
 
   Bitboard pawns = pos.pawns(strongerSide);
-  File pawnFile = square_file(pos.pawn_list(strongerSide, 0));
+  File pawnFile = square_file(pos.piece_list(strongerSide, PAWN, 0));
 
   if((pawnFile == FILE_A || pawnFile == FILE_H) &&
      (pawns & ~file_bb(pawnFile)) == EmptyBoardBB) {
     // All pawns are on a single rook file.
 
-    Square bishopSq = pos.bishop_list(strongerSide, 0);
+    Square bishopSq = pos.piece_list(strongerSide, BISHOP, 0);
     Square queeningSq =
       relative_square(strongerSide, make_square(pawnFile, RANK_8));
     Square kingSq = pos.king_square(weakerSide);
@@ -464,7 +465,7 @@ ScaleFactor KBPKScalingFunction::apply(const Position &pos) {
       // If the defending king has distance 1 to the promotion square or
       // is placed somewhere in front of the pawn, it's a draw.
       if(square_distance(kingSq, queeningSq) <= 1 ||
-         pawn_rank(strongerSide, kingSq) >= rank)
+         relative_rank(strongerSide, kingSq) >= rank)
         return ScaleFactor(0);
     }
   }
@@ -479,18 +480,18 @@ ScaleFactor KBPKScalingFunction::apply(const Position &pos) {
 
 ScaleFactor KQKRPScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
-  assert(pos.queen_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, QUEEN) == 1);
-  assert(pos.pawn_count(strongerSide) == 0);
+  assert(pos.piece_count(strongerSide, PAWN) == 0);
-  assert(pos.rook_count(weakerSide) == 1);
+  assert(pos.piece_count(weakerSide, ROOK) == 1);
-  assert(pos.pawn_count(weakerSide) >= 1);
+  assert(pos.piece_count(weakerSide, PAWN) >= 1);
 
   Square kingSq = pos.king_square(weakerSide);
-  if(pawn_rank(weakerSide, kingSq) <= RANK_2 &&
+  if(relative_rank(weakerSide, kingSq) <= RANK_2 &&
-     pawn_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4 &&
+     relative_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4 &&
      (pos.rooks(weakerSide) & relative_rank_bb(weakerSide, RANK_3)) &&
      (pos.pawns(weakerSide) & relative_rank_bb(weakerSide, RANK_2)) &&
-     (pos.king_attacks(kingSq) & pos.pawns(weakerSide))) {
+     (pos.piece_attacks<KING>(kingSq) & pos.pawns(weakerSide))) {
-    Square rsq = pos.rook_list(weakerSide, 0);
+    Square rsq = pos.piece_list(weakerSide, ROOK, 0);
     if(pos.pawn_attacks(strongerSide, rsq) & pos.pawns(weakerSide))
       return ScaleFactor(0);
   }
@@ -508,15 +509,15 @@ ScaleFactor KQKRPScalingFunction::apply(const Position &pos) {
 
 ScaleFactor KRPKRScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
-  assert(pos.pawn_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, PAWN) == 1);
   assert(pos.non_pawn_material(weakerSide) == RookValueMidgame);
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
 
   Square wksq = pos.king_square(strongerSide);
-  Square wrsq = pos.rook_list(strongerSide, 0);
+  Square wrsq = pos.piece_list(strongerSide, ROOK, 0);
-  Square wpsq = pos.pawn_list(strongerSide, 0);
+  Square wpsq = pos.piece_list(strongerSide, PAWN, 0);
   Square bksq = pos.king_square(weakerSide);
-  Square brsq = pos.rook_list(weakerSide, 0);
+  Square brsq = pos.piece_list(weakerSide, ROOK, 0);
 
   // Orient the board in such a way that the stronger side is white, and the
   // pawn is on the left half of the board:
@@ -613,12 +614,12 @@ ScaleFactor KRPKRScalingFunction::apply(const Position &pos) {
 
 ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
-  assert(pos.pawn_count(strongerSide) == 2);
+  assert(pos.piece_count(strongerSide, PAWN) == 2);
   assert(pos.non_pawn_material(weakerSide) == RookValueMidgame);
-  assert(pos.pawn_count(weakerSide) == 1);
+  assert(pos.piece_count(weakerSide, PAWN) == 1);
 
-  Square wpsq1 = pos.pawn_list(strongerSide, 0);
+  Square wpsq1 = pos.piece_list(strongerSide, PAWN, 0);
-  Square wpsq2 = pos.pawn_list(strongerSide, 1);
+  Square wpsq2 = pos.piece_list(strongerSide, PAWN, 1);
   Square bksq = pos.king_square(weakerSide);
 
   // Does the stronger side have a passed pawn?
@@ -626,10 +627,10 @@ ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) {
      pos.pawn_is_passed(strongerSide, wpsq2))
     return SCALE_FACTOR_NONE;
 
-  Rank r = Max(pawn_rank(strongerSide, wpsq1), pawn_rank(strongerSide, wpsq2));
+  Rank r = Max(relative_rank(strongerSide, wpsq1), relative_rank(strongerSide, wpsq2));
 
   if(file_distance(bksq, wpsq1) <= 1 && file_distance(bksq, wpsq2) <= 1
-     && pawn_rank(strongerSide, bksq) > r) {
+     && relative_rank(strongerSide, bksq) > r) {
     switch(r) {
 
     case RANK_2: return ScaleFactor(10);
@@ -651,9 +652,9 @@ ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) {
 
 ScaleFactor KPsKScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == Value(0));
-  assert(pos.pawn_count(strongerSide) >= 2);
+  assert(pos.piece_count(strongerSide, PAWN) >= 2);
   assert(pos.non_pawn_material(weakerSide) == Value(0));
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
 
   Bitboard pawns = pos.pawns(strongerSide);
 
@@ -694,22 +695,22 @@ ScaleFactor KPsKScalingFunction::apply(const Position &pos) {
 
 ScaleFactor KBPKBScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
-  assert(pos.bishop_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.pawn_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, PAWN) == 1);
   assert(pos.non_pawn_material(weakerSide) == BishopValueMidgame);
-  assert(pos.bishop_count(weakerSide) == 1);
+  assert(pos.piece_count(weakerSide, BISHOP) == 1);
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
 
-  Square pawnSq = pos.pawn_list(strongerSide, 0);
+  Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
-  Square strongerBishopSq = pos.bishop_list(strongerSide, 0);
+  Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0);
-  Square weakerBishopSq = pos.bishop_list(weakerSide, 0);
+  Square weakerBishopSq = pos.piece_list(weakerSide, BISHOP, 0);
   Square weakerKingSq = pos.king_square(weakerSide);
 
   // Case 1: Defending king blocks the pawn, and cannot be driven away.
   if(square_file(weakerKingSq) == square_file(pawnSq)
-     && pawn_rank(strongerSide, pawnSq) < pawn_rank(strongerSide, weakerKingSq)
+     && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
      && (square_color(weakerKingSq) != square_color(strongerBishopSq)
-         || pawn_rank(strongerSide, weakerKingSq) <= RANK_6))
+         || relative_rank(strongerSide, weakerKingSq) <= RANK_6))
     return ScaleFactor(0);
 
   // Case 2: Opposite colored bishops.
@@ -725,14 +726,14 @@ ScaleFactor KBPKBScalingFunction::apply(const Position &pos) {
     // These rules are probably not perfect, but in practice they work
     // reasonably well.
     
-    if(pawn_rank(strongerSide, pawnSq) <= RANK_5)
+    if(relative_rank(strongerSide, pawnSq) <= RANK_5)
       return ScaleFactor(0);
     else {
       Bitboard ray =
         ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S);
       if(ray & pos.kings(weakerSide))
         return ScaleFactor(0);
-      if((pos.bishop_attacks(weakerBishopSq) & ray)
+      if((pos.piece_attacks<BISHOP>(weakerBishopSq) & ray)
          && square_distance(weakerBishopSq, pawnSq) >= 3)
         return ScaleFactor(0);
     }
@@ -748,20 +749,20 @@ ScaleFactor KBPKBScalingFunction::apply(const Position &pos) {
 
 ScaleFactor KBPKNScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
-  assert(pos.bishop_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.pawn_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, PAWN) == 1);
   assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame);
-  assert(pos.knight_count(weakerSide) == 1);
+  assert(pos.piece_count(weakerSide, KNIGHT) == 1);
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
 
-  Square pawnSq = pos.pawn_list(strongerSide, 0);
+  Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
-  Square strongerBishopSq = pos.bishop_list(strongerSide, 0);
+  Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0);
   Square weakerKingSq = pos.king_square(weakerSide);
       
   if(square_file(weakerKingSq) == square_file(pawnSq)
-     && pawn_rank(strongerSide, pawnSq) < pawn_rank(strongerSide, weakerKingSq)
+     && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
      && (square_color(weakerKingSq) != square_color(strongerBishopSq)
-         || pawn_rank(strongerSide, weakerKingSq) <= RANK_6))
+         || relative_rank(strongerSide, weakerKingSq) <= RANK_6))
     return ScaleFactor(0);
 
   return SCALE_FACTOR_NONE;
@@ -774,12 +775,12 @@ ScaleFactor KBPKNScalingFunction::apply(const Position &pos) {
 
 ScaleFactor KNPKScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame);
-  assert(pos.knight_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, KNIGHT) == 1);
-  assert(pos.pawn_count(strongerSide) == 1);
+  assert(pos.piece_count(strongerSide, PAWN) == 1);
   assert(pos.non_pawn_material(weakerSide) == Value(0));
-  assert(pos.pawn_count(weakerSide) == 0);
+  assert(pos.piece_count(weakerSide, PAWN) == 0);
 
-  Square pawnSq = pos.pawn_list(strongerSide, 0);
+  Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
   Square weakerKingSq = pos.king_square(weakerSide);
 
   if(pawnSq == relative_square(strongerSide, SQ_A7) &&
@@ -804,8 +805,8 @@ ScaleFactor KNPKScalingFunction::apply(const Position &pos) {
 ScaleFactor KPKPScalingFunction::apply(const Position &pos) {
   assert(pos.non_pawn_material(strongerSide) == Value(0));
   assert(pos.non_pawn_material(weakerSide) == Value(0));
-  assert(pos.pawn_count(WHITE) == 1);
+  assert(pos.piece_count(WHITE, PAWN) == 1);
-  assert(pos.pawn_count(BLACK) == 1);
+  assert(pos.piece_count(BLACK, PAWN) == 1);
 
   Square wksq, bksq, wpsq;
   Color stm;
@@ -813,13 +814,13 @@ ScaleFactor KPKPScalingFunction::apply(const Position &pos) {
   if(strongerSide == WHITE) {
     wksq = pos.king_square(WHITE);
     bksq = pos.king_square(BLACK);
-    wpsq = pos.pawn_list(WHITE, 0);
+    wpsq = pos.piece_list(WHITE, PAWN, 0);
     stm = pos.side_to_move();
   }
   else {
     wksq = flip_square(pos.king_square(BLACK));
     bksq = flip_square(pos.king_square(WHITE));
-    wpsq = flip_square(pos.pawn_list(BLACK, 0));
+    wpsq = flip_square(pos.piece_list(BLACK, PAWN, 0));
     stm = opposite_color(pos.side_to_move());
   }
 

src/endgame.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/evaluate.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -56,31 +57,32 @@ struct EvalInfo {
   Bitboard attackedBy[2][8];
   Bitboard attacked_by(Color c) const { return attackedBy[c][0]; }
   Bitboard attacked_by(Color c, PieceType pt) const { return attackedBy[c][pt]; }
-  // attackZone[color] is the zone around the enemy king which is considered
+
+  // kingZone[color] is the zone around the enemy king which is considered
   // by the king safety evaluation.  This consists of the squares directly
   // adjacent to the king, and the three (or two, for a king on an edge file)
   // squares two ranks in front of the king.  For instance, if black's king
-  // is on g8, attackZone[WHITE] is a bitboard containing the squares f8, h8,
+  // is on g8, kingZone[WHITE] is a bitboard containing the squares f8, h8,
   // f7, g7, h7, f6, g6 and h6.
-  Bitboard attackZone[2];
+  Bitboard kingZone[2];
 
-  // attackCount[color] is the number of pieces of the given color which
+  // kingAttackersCount[color] is the number of pieces of the given color
-  // attack a square adjacent to the enemy king.
+  // which attack a square in the kingZone of the enemy king.
-  int attackCount[2];
+  int kingAttackersCount[2];
 
-  // attackWeight[color] is the sum of the "weight" of the pieces of the given
+  // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
-  // color which attack a square adjacent to the enemy king.  The weights of
+  // given color which attack a square in the kingZone of the enemy king. The
-  // the individual piece types are given by the variables QueenAttackWeight,
+  // weights of the individual piece types are given by the variables
-  // RookAttackWeight, BishopAttackWeight and KnightAttackWeight in
+  // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
-  // evaluate.cpp.
+  // KnightAttackWeight in evaluate.cpp
-  int attackWeight[2];
+  int kingAttackersWeight[2];
 
-  // attacked[color] is the number of enemy piece attacks to squares directly
+  // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
-  // adjacent to the king of the given color.  Pieces which attack more
+  // directly adjacent to the king of the given color. Pieces which attack
-  // than one square are counted multiple times.  For instance, if black's
+  // more than one square are counted multiple times. For instance, if black's
   // king is on g8 and there's a white knight on g5, this knight adds
-  // 2 to attacked[BLACK].
+  // 2 to kingAdjacentZoneAttacksCount[BLACK].
-  int attacked[2];
+  int kingAdjacentZoneAttacksCount[2];
 
   // mateThreat[color] is a move for the given side which gives a direct mate.
   Move mateThreat[2];

src/history.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -22,6 +23,7 @@
 ////
 
 #include <cassert>
+#include <cstring>
 
 #include "history.h"
 

src/history.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/lock.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/main.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -21,7 +22,6 @@
 //// Includes
 ////
 
-#include <cstdlib>
 #include <iostream>
 
 #include "benchmark.h"
@@ -39,6 +39,7 @@
 #include "uci.h"
 #include "ucioption.h"
 
+using std::string;
 
 //// 
 //// Functions
@@ -47,8 +48,6 @@
 int main(int argc, char *argv[]) {
 
   // Disable IO buffering
-  setbuf(stdin, NULL);
-  setbuf(stdout, NULL);
   std::cout.rdbuf()->pubsetbuf(NULL, 0);
   std::cin.rdbuf()->pubsetbuf(NULL, 0);
 
@@ -60,32 +59,36 @@ int main(int argc, char *argv[]) {
   init_uci_options();
   Position::init_zobrist();
   Position::init_piece_square_tables();
-  MaterialInfo::init();
   MovePicker::init_phase_table();
   init_eval(1);
   init_bitbases();
   init_threads();
 
   // Make random number generation less deterministic, for book moves
-  int i = abs(get_system_time() % 10000);
+  for (int i = abs(get_system_time() % 10000); i > 0; i--)
-  for(int j = 0; j < i; j++)
+      genrand_int32();
-    genrand_int32();
 
   // Process command line arguments
-  if(argc >= 2) {
+  if (argc >= 2 && string(argv[1]) == "bench")
-    if(std::string(argv[1]) == "bench") {
+  {
-      if(argc != 4) {
+      if (argc < 4 || argc > 7)
-        std::cout << "Usage: glaurung bench <hash> <threads>" << std::endl;
+      {
+        std::cout << "Usage: glaurung bench <hash size> <threads> "
+                  << "[time = 60s] [fen positions file = default] "
+                  << "[time, depth or node limited = time]"
+                  << std::endl;
         exit(0);
       }
-      benchmark(std::string(argv[2]), std::string(argv[3]));
+      string time = argc > 4 ? argv[4] : "60";
+      string fen = argc > 5 ? argv[5] : "default";
+      string lim = argc > 6 ? argv[6] : "time";
+      benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen + " " + lim);
       return 0;
-    }
   }
 
   // Print copyright notice
-  std::cout << engine_name() << ".  "
+  std::cout << engine_name() << ".  Copyright (C) "
-            << "Copyright (C) 2004-2008 Tord Romstad."
+            << "2004-2008 Tord Romstad, Marco Costalba. "
             << std::endl;
 
   // Enter UCI mode

src/material.cpp

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -22,6 +23,8 @@
 ////
 
 #include <cassert>
+#include <cstring>
+#include <map>
 
 #include "material.h"
 
@@ -35,20 +38,37 @@ namespace {
   const Value BishopPairMidgameBonus = Value(100);
   const Value BishopPairEndgameBonus = Value(100);
 
-  Key KPKMaterialKey, KKPMaterialKey;
-  Key KBNKMaterialKey, KKBNMaterialKey;
-  Key KRKPMaterialKey, KPKRMaterialKey;
-  Key KRKBMaterialKey, KBKRMaterialKey;
-  Key KRKNMaterialKey, KNKRMaterialKey;
-  Key KQKRMaterialKey, KRKQMaterialKey;
-  Key KRPKRMaterialKey, KRKRPMaterialKey;
-  Key KRPPKRPMaterialKey, KRPKRPPMaterialKey;
   Key KNNKMaterialKey, KKNNMaterialKey;
-  Key KBPKBMaterialKey, KBKBPMaterialKey;
-  Key KBPKNMaterialKey, KNKBPMaterialKey;
-  Key KNPKMaterialKey, KKNPMaterialKey;
-  Key KPKPMaterialKey;
 
+}
+
+////
+//// Classes
+////
+
+
+/// See header for a class description. It is declared here to avoid
+/// to include <map> in the header file.
+
+class EndgameFunctions {
+
+public:
+  EndgameFunctions();
+  EndgameEvaluationFunction* getEEF(Key key) const;
+  ScalingFunction* getESF(Key key, Color* c) const;
+
+private:
+  void add(Key k, EndgameEvaluationFunction* f);
+  void add(Key k, Color c, ScalingFunction* f);
+
+  struct ScalingInfo
+  {
+      Color col;
+      ScalingFunction* fun;
+  };
+
+  std::map<Key, EndgameEvaluationFunction*> EEFmap;
+  std::map<Key, ScalingInfo> ESFmap;
 };
 
 
@@ -56,115 +76,30 @@ namespace {
 //// Functions
 ////
 
-/// MaterialInfo::init() is called during program initialization.  It 
-/// precomputes material hash keys for a few basic endgames, in order
-/// to make it easy to recognize such endgames when they occur.
 
-void MaterialInfo::init() {
+/// Constructor for the MaterialInfoTable class
-  KPKMaterialKey = Position::zobMaterial[WHITE][PAWN][1];
-  KKPMaterialKey = Position::zobMaterial[BLACK][PAWN][1];
-  KBNKMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][KNIGHT][1];
-  KKBNMaterialKey =
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KRKPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KPKRMaterialKey =
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKBMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1];
-  KBKRMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKNMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KNKRMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KQKRMaterialKey =
-    Position::zobMaterial[WHITE][QUEEN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKQMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][QUEEN][1];
-  KRPKRMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKRPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KRPPKRPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[WHITE][PAWN][2] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KRPKRPPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1] ^
-    Position::zobMaterial[BLACK][PAWN][2];
-  KNNKMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[WHITE][KNIGHT][2];
-  KKNNMaterialKey =
-    Position::zobMaterial[BLACK][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][2];
-  KBPKBMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1];
-  KBKBPMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KBPKNMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KNKBPMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KNPKMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[WHITE][PAWN][1];
-  KKNPMaterialKey =
-    Position::zobMaterial[BLACK][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KPKPMaterialKey =
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-}
 
+MaterialInfoTable::MaterialInfoTable(unsigned int numOfEntries) {
 
-/// Constructor for the MaterialInfoTable class.
-
-MaterialInfoTable::MaterialInfoTable(unsigned numOfEntries) {
   size = numOfEntries;
   entries = new MaterialInfo[size];
-  if(entries == NULL) {
+  funcs = new EndgameFunctions();
-    std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo))
+  if (!entries || !funcs)
-              << " bytes for material hash table." << std::endl;
+  {
-    exit(EXIT_FAILURE);
+      std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo))
+                << " bytes for material hash table." << std::endl;
+      exit(EXIT_FAILURE);
   }
-  this->clear();
+  clear();
 }
 
 
-/// Destructor for the MaterialInfoTable class.
+/// Destructor for the MaterialInfoTable class
 
 MaterialInfoTable::~MaterialInfoTable() {
+
   delete [] entries;
+  delete funcs;
 }
 
 
@@ -172,6 +107,7 @@ MaterialInfoTable::~MaterialInfoTable() {
 /// all entries to 0.
 
 void MaterialInfoTable::clear() {
+
   memset(entries, 0, size * sizeof(MaterialInfo));
 }
 
@@ -179,228 +115,238 @@ void MaterialInfoTable::clear() {
 /// MaterialInfoTable::get_material_info() takes a position object as input,
 /// computes or looks up a MaterialInfo object, and returns a pointer to it.
 /// If the material configuration is not already present in the table, it
-/// is stored there, so we don't have to recompute everything when the 
+/// is stored there, so we don't have to recompute everything when the
 /// same material configuration occurs again.
 
-MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
+MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
+
   Key key = pos.get_material_key();
   int index = key & (size - 1);
-  MaterialInfo *mi = entries + index;
+  MaterialInfo* mi = entries + index;
 
-  // If mi->key matches the position's material hash key, it means that we 
+  // If mi->key matches the position's material hash key, it means that we
   // have analysed this material configuration before, and we can simply
-  // return the information we found the last time instead of recomputing it:
+  // return the information we found the last time instead of recomputing it.
-  if(mi->key == key)
+  if (mi->key == key)
-    return mi;
+      return mi;
 
-  // Clear the MaterialInfo object, and set its key:
+  // Clear the MaterialInfo object, and set its key
   mi->clear();
   mi->key = key;
 
-  // A special case before looking for a specialized evaluation function:
+  // A special case before looking for a specialized evaluation function
-  // KNN vs K is a draw:
+  // KNN vs K is a draw.
-  if(key == KNNKMaterialKey || key == KKNNMaterialKey) {
+  if (key == KNNKMaterialKey || key == KKNNMaterialKey)
-    mi->factor[WHITE] = mi->factor[BLACK] = 0;
+  {
-    return mi;
+      mi->factor[WHITE] = mi->factor[BLACK] = 0;
+      return mi;
   }
 
   // Let's look if we have a specialized evaluation function for this
-  // particular material configuration:
+  // particular material configuration.
-  if(key == KPKMaterialKey) {
+  if ((mi->evaluationFunction = funcs->getEEF(key)) != NULL)
-    mi->evaluationFunction = &EvaluateKPK;
+      return mi;
-    return mi;
+
+  else if (   pos.non_pawn_material(BLACK) == Value(0)
+           && pos.piece_count(BLACK, PAWN) == 0
+           && pos.non_pawn_material(WHITE) >= RookValueEndgame)
+  {
+      mi->evaluationFunction = &EvaluateKXK;
+      return mi;
   }
-  else if(key == KKPMaterialKey) {
+  else if (   pos.non_pawn_material(WHITE) == Value(0)
-    mi->evaluationFunction = &EvaluateKKP;
+           && pos.piece_count(WHITE, PAWN) == 0
-    return mi;
+           && pos.non_pawn_material(BLACK) >= RookValueEndgame)
-  }
+  {
-  else if(key == KBNKMaterialKey) {
+      mi->evaluationFunction = &EvaluateKKX;
-    mi->evaluationFunction = &EvaluateKBNK;
+      return mi;
-    return mi;
-  }
-  else if(key == KKBNMaterialKey) {
-    mi->evaluationFunction = &EvaluateKKBN;
-    return mi;
-  }
-  else if(key == KRKPMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKP;
-    return mi;
-  }
-  else if(key == KPKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKPKR;
-    return mi;
-  }
-  else if(key == KRKBMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKB;
-    return mi;
-  }
-  else if(key == KBKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKBKR;
-    return mi;
-  }
-  else if(key == KRKNMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKN;
-    return mi;
-  }
-  else if(key == KNKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKNKR;
-    return mi;
-  }
-  else if(key == KQKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKQKR;
-    return mi;
-  }
-  else if(key == KRKQMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKQ;
-    return mi;
-  }
-  else if(pos.non_pawn_material(BLACK) == Value(0) &&
-          pos.pawn_count(BLACK) == 0 &&
-          pos.non_pawn_material(WHITE) >= RookValueEndgame) {
-    mi->evaluationFunction = &EvaluateKXK;
-    return mi;
-  }
-  else if(pos.non_pawn_material(WHITE) == Value(0) &&
-          pos.pawn_count(WHITE) == 0 &&
-          pos.non_pawn_material(BLACK) >= RookValueEndgame) {
-    mi->evaluationFunction = &EvaluateKKX;
-    return mi;
   }
 
   // OK, we didn't find any special evaluation function for the current
-  // material configuration.  Is there a suitable scaling function?
+  // material configuration. Is there a suitable scaling function?
   //
   // The code below is rather messy, and it could easily get worse later,
   // if we decide to add more special cases.  We face problems when there
   // are several conflicting applicable scaling functions and we need to
   // decide which one to use.
-
-  if(key == KRPKRMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKRPKR;
-    return mi;
-  }
-  if(key == KRKRPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKRKRP;
-    return mi;
-  }
-  if(key == KRPPKRPMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKRPPKRP;
-    return mi;
-  }
-  else if(key == KRPKRPPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKRPKRPP;
-    return mi;
-  }
-  if(key == KBPKBMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKBPKB;
-    return mi;
-  }
-  if(key == KBKBPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKBKBP;
-    return mi;
-  }
-  if(key == KBPKNMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKBPKN;
-    return mi;
-  }
-  if(key == KNKBPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKNKBP;
-    return mi;
-  }
-  if(key == KNPKMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKNPK;
-    return mi;
-  }
-  if(key == KKNPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKKNP;
-    return mi;
-  }
-
-  if(pos.non_pawn_material(WHITE) == BishopValueMidgame &&
-     pos.bishop_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
-    mi->scalingFunction[WHITE] = &ScaleKBPK;
-  if(pos.non_pawn_material(BLACK) == BishopValueMidgame &&
-     pos.bishop_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
-    mi->scalingFunction[BLACK] = &ScaleKKBP;
-
-  if(pos.pawn_count(WHITE) == 0 &&
-     pos.non_pawn_material(WHITE) == QueenValueMidgame &&
-     pos.queen_count(WHITE) == 1 &&
-     pos.rook_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
-    mi->scalingFunction[WHITE] = &ScaleKQKRP;
-  else if(pos.pawn_count(BLACK) == 0 &&
-          pos.non_pawn_material(BLACK) == QueenValueMidgame &&
-          pos.queen_count(BLACK) == 1 &&
-          pos.rook_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
-    mi->scalingFunction[BLACK] = &ScaleKRPKQ;
-
-  if(pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0)) {
-    if(pos.pawn_count(BLACK) == 0) {
-      assert(pos.pawn_count(WHITE) >= 2);
-      mi->scalingFunction[WHITE] = &ScaleKPsK;
-    }
-    else if(pos.pawn_count(WHITE) == 0) {
-      assert(pos.pawn_count(BLACK) >= 2);
-      mi->scalingFunction[BLACK] = &ScaleKKPs;
-    }
-    else if(pos.pawn_count(WHITE) == 1 && pos.pawn_count(BLACK) == 1) {
-      mi->scalingFunction[WHITE] = &ScaleKPKPw;
-      mi->scalingFunction[BLACK] = &ScaleKPKPb;
-    }
-  }
-
-  // Evaluate the material balance.
-  
   Color c;
-  int sign;
+  ScalingFunction* sf;
-  Value egValue = Value(0), mgValue = Value(0);
-  
-  for(c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign) {
 
-    // No pawns makes it difficult to win, even with a material advantage:
+  if ((sf = funcs->getESF(key, &c)) != NULL)
-    if(pos.pawn_count(c) == 0 &&
+  {
-       pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c))
+      mi->scalingFunction[c] = sf;
-       <= BishopValueMidgame) {
+      return mi;
-      if(pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c)))
+  }
-        mi->factor[c] = 0;
+
-      else if(pos.non_pawn_material(c) < RookValueMidgame)
+  if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
-        mi->factor[c] = 0;
+      && pos.piece_count(WHITE, BISHOP) == 1
-      else {
+      && pos.piece_count(WHITE, PAWN) >= 1)
-        switch(pos.bishop_count(c)) {
+      mi->scalingFunction[WHITE] = &ScaleKBPK;
-        case 2:
+
-          mi->factor[c] = 32; break;
+  if (   pos.non_pawn_material(BLACK) == BishopValueMidgame
-        case 1:
+      && pos.piece_count(BLACK, BISHOP) == 1
-          mi->factor[c] = 12; break;
+      && pos.piece_count(BLACK, PAWN) >= 1)
-        case 0:
+      mi->scalingFunction[BLACK] = &ScaleKKBP;
-          mi->factor[c] = 6; break;
+
-        }
+  if (   pos.piece_count(WHITE, PAWN) == 0
+      && pos.non_pawn_material(WHITE) == QueenValueMidgame
+      && pos.piece_count(WHITE, QUEEN) == 1
+      && pos.piece_count(BLACK, ROOK) == 1
+      && pos.piece_count(BLACK, PAWN) >= 1)
+      mi->scalingFunction[WHITE] = &ScaleKQKRP;
+
+  else if (   pos.piece_count(BLACK, PAWN) == 0
+           && pos.non_pawn_material(BLACK) == QueenValueMidgame
+           && pos.piece_count(BLACK, QUEEN) == 1
+           && pos.piece_count(WHITE, ROOK) == 1
+           && pos.piece_count(WHITE, PAWN) >= 1)
+      mi->scalingFunction[BLACK] = &ScaleKRPKQ;
+
+  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0))
+  {
+      if (pos.piece_count(BLACK, PAWN) == 0)
+      {
+          assert(pos.piece_count(WHITE, PAWN) >= 2);
+          mi->scalingFunction[WHITE] = &ScaleKPsK;
       }
-    }
+      else if (pos.piece_count(WHITE, PAWN) == 0)
-    
+      {
-    // Bishop pair:
+          assert(pos.piece_count(BLACK, PAWN) >= 2);
-    if(pos.bishop_count(c) >= 2) {
+          mi->scalingFunction[BLACK] = &ScaleKKPs;
-      mgValue += sign * BishopPairMidgameBonus;
+      }
-      egValue += sign * BishopPairEndgameBonus;
+      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+      {
+          mi->scalingFunction[WHITE] = &ScaleKPKPw;
+          mi->scalingFunction[BLACK] = &ScaleKPKPb;
+      }
+  }
+
+  // Evaluate the material balance
+
+  int sign;
+  Value egValue = Value(0);
+  Value mgValue = Value(0);
+
+  for (c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign)
+  {
+    // No pawns makes it difficult to win, even with a material advantage
+    if (   pos.piece_count(c, PAWN) == 0
+        && pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c)) <= BishopValueMidgame)
+    {
+        if (   pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c))
+            || pos.non_pawn_material(c) < RookValueMidgame)
+            mi->factor[c] = 0;
+        else
+        {
+            switch (pos.piece_count(c, BISHOP)) {
+            case 2:
+                mi->factor[c] = 32;
+                break;
+            case 1:
+                mi->factor[c] = 12;
+                break;
+            case 0:
+                mi->factor[c] = 6;
+                break;
+            }
+        }
     }
 
-    // Knights are stronger when there are many pawns on the board.  The 
+    // Bishop pair
+    if (pos.piece_count(c, BISHOP) >= 2)
+    {
+        mgValue += sign * BishopPairMidgameBonus;
+        egValue += sign * BishopPairEndgameBonus;
+    }
+
+    // Knights are stronger when there are many pawns on the board.  The
     // formula is taken from Larry Kaufman's paper "The Evaluation of Material
-    // Imbalances in Chess": 
+    // Imbalances in Chess":
     // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
-    mgValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
+    mgValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
-    egValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
+    egValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
 
     // Redundancy of major pieces, again based on Kaufman's paper:
-    if(pos.rook_count(c) >= 1) {
+    if (pos.piece_count(c, ROOK) >= 1)
-      Value v = Value((pos.rook_count(c) - 1) * 32 + pos.queen_count(c) * 16);
+    {
-      mgValue -= sign * v;
+        Value v = Value((pos.piece_count(c, ROOK) - 1) * 32 + pos.piece_count(c, QUEEN) * 16);
-      egValue -= sign * v;
+        mgValue -= sign * v;
+        egValue -= sign * v;
     }
-      
   }
-
   mi->mgValue = int16_t(mgValue);
   mi->egValue = int16_t(egValue);
-
   return mi;
 }
+
+
+/// EndgameFunctions member definitions. This class is used to store the maps
+/// of end game and scaling functions that MaterialInfoTable will query for 
+/// each key. The maps are constant and are populated only at construction,
+/// but are per-thread instead of globals to avoid expensive locks.
+
+EndgameFunctions::EndgameFunctions() {
+
+  typedef Key ZM[2][8][16];
+  const ZM& z = Position::zobMaterial;
+
+  static const Color W = WHITE;
+  static const Color B = BLACK;
+
+  KNNKMaterialKey = z[W][KNIGHT][1] ^ z[W][KNIGHT][2];
+  KKNNMaterialKey = z[B][KNIGHT][1] ^ z[B][KNIGHT][2];
+
+  add(z[W][PAWN][1], &EvaluateKPK);
+  add(z[B][PAWN][1], &EvaluateKKP);
+
+  add(z[W][BISHOP][1] ^ z[W][KNIGHT][1], &EvaluateKBNK);
+  add(z[B][BISHOP][1] ^ z[B][KNIGHT][1], &EvaluateKKBN);
+  add(z[W][ROOK][1]   ^ z[B][PAWN][1],   &EvaluateKRKP);
+  add(z[W][PAWN][1]   ^ z[B][ROOK][1],   &EvaluateKPKR);
+  add(z[W][ROOK][1]   ^ z[B][BISHOP][1], &EvaluateKRKB);
+  add(z[W][BISHOP][1] ^ z[B][ROOK][1],   &EvaluateKBKR);
+  add(z[W][ROOK][1]   ^ z[B][KNIGHT][1], &EvaluateKRKN);
+  add(z[W][KNIGHT][1] ^ z[B][ROOK][1],   &EvaluateKNKR);
+  add(z[W][QUEEN][1]  ^ z[B][ROOK][1],   &EvaluateKQKR);
+  add(z[W][ROOK][1]   ^ z[B][QUEEN][1],  &EvaluateKRKQ);
+
+  add(z[W][KNIGHT][1] ^ z[W][PAWN][1], W, &ScaleKNPK);
+  add(z[B][KNIGHT][1] ^ z[B][PAWN][1], B, &ScaleKKNP);
+
+  add(z[W][ROOK][1]   ^ z[W][PAWN][1]   ^ z[B][ROOK][1]  , W, &ScaleKRPKR);
+  add(z[W][ROOK][1]   ^ z[B][ROOK][1]   ^ z[B][PAWN][1]  , B, &ScaleKRKRP);
+  add(z[W][BISHOP][1] ^ z[W][PAWN][1]   ^ z[B][BISHOP][1], W, &ScaleKBPKB);
+  add(z[W][BISHOP][1] ^ z[B][BISHOP][1] ^ z[B][PAWN][1]  , B, &ScaleKBKBP);
+  add(z[W][BISHOP][1] ^ z[W][PAWN][1]   ^ z[B][KNIGHT][1], W, &ScaleKBPKN);
+  add(z[W][KNIGHT][1] ^ z[B][BISHOP][1] ^ z[B][PAWN][1]  , B, &ScaleKNKBP);
+
+  add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[W][PAWN][2] ^ z[B][ROOK][1] ^ z[B][PAWN][1], W, &ScaleKRPPKRP);
+  add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[B][ROOK][1] ^ z[B][PAWN][1] ^ z[B][PAWN][2], B, &ScaleKRPKRPP);
+}
+
+void EndgameFunctions::add(Key k, EndgameEvaluationFunction* f) {
+
+  EEFmap.insert(std::pair<Key, EndgameEvaluationFunction*>(k, f));
+}
+
+void EndgameFunctions::add(Key k, Color c, ScalingFunction* f) {
+
+  ScalingInfo s = {c, f};
+  ESFmap.insert(std::pair<Key, ScalingInfo>(k, s));
+}
+
+EndgameEvaluationFunction* EndgameFunctions::getEEF(Key key) const {
+
+  std::map<Key, EndgameEvaluationFunction*>::const_iterator it(EEFmap.find(key));
+  return (it != EEFmap.end() ? it->second : NULL);
+}
+
+ScalingFunction* EndgameFunctions::getESF(Key key, Color* c) const {
+
+  std::map<Key, ScalingInfo>::const_iterator it(ESFmap.find(key));
+  if (it == ESFmap.end())
+      return NULL;
+
+  *c = it->second.col;
+  return it->second.fun;
+}

src/material.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -34,7 +35,7 @@
 ////
 
 /// MaterialInfo is a class which contains various information about a
-/// material configuration.  It contains a material balance evaluation,
+/// material configuration. It contains a material balance evaluation,
 /// a function pointer to a special endgame evaluation function (which in
 /// most cases is NULL, meaning that the standard evaluation function will
 /// be used), and "scale factors" for black and white.
@@ -50,11 +51,9 @@ class MaterialInfo {
 public:
   Value mg_value() const;
   Value eg_value() const;
-  ScaleFactor scale_factor(const Position &pos, Color c) const;
+  ScaleFactor scale_factor(const Position& pos, Color c) const;
   bool specialized_eval_exists() const;
-  Value evaluate(const Position &pos) const;
+  Value evaluate(const Position& pos) const;
-
-  static void init();
 
 private:
   void clear();
@@ -63,14 +62,22 @@ private:
   int16_t mgValue;
   int16_t egValue;
   uint8_t factor[2];
-  EndgameEvaluationFunction *evaluationFunction;
+  EndgameEvaluationFunction* evaluationFunction;
-  ScalingFunction *scalingFunction[2];
+  ScalingFunction* scalingFunction[2];
 };
 
 
-/// The MaterialInfoTable class represents a pawn hash table.  It is basically
+/// EndgameFunctions class stores the endgame evaluation functions std::map.
+/// Because STL library is not thread safe even for read access, the maps,
+/// although with identical content, are replicated for each thread. This
+/// is faster then using locks with an unique set of global maps.
+
+class EndgameFunctions;
+
+
+/// The MaterialInfoTable class represents a pawn hash table. It is basically
 /// just an array of MaterialInfo objects and a few methods for accessing these
-/// objects.  The most important method is get_material_info, which looks up a
+/// objects. The most important method is get_material_info, which looks up a
 /// position in the table and returns a pointer to a MaterialInfo object.
 
 class MaterialInfoTable {
@@ -79,11 +86,12 @@ public:
   MaterialInfoTable(unsigned numOfEntries);
   ~MaterialInfoTable();
   void clear();
-  MaterialInfo *get_material_info(const Position &pos);
+  MaterialInfo* get_material_info(const Position& pos);
 
 private:
   unsigned size;
-  MaterialInfo *entries;
+  MaterialInfo* entries;
+  EndgameFunctions* funcs;
 };
 
 
@@ -95,10 +103,12 @@ private:
 /// material balance evaluation for the middle game and the endgame.
 
 inline Value MaterialInfo::mg_value() const {
+
   return Value(mgValue);
 }
 
 inline Value MaterialInfo::eg_value() const {
+
   return Value(egValue);
 }
 
@@ -107,6 +117,7 @@ inline Value MaterialInfo::eg_value() const {
 /// with all slots at their default values.
 
 inline void MaterialInfo::clear() {
+
   mgValue = egValue = 0;
   factor[WHITE] = factor[BLACK] = uint8_t(SCALE_FACTOR_NORMAL);
   evaluationFunction = NULL;
@@ -117,16 +128,17 @@ inline void MaterialInfo::clear() {
 /// MaterialInfo::scale_factor takes a position and a color as input, and
 /// returns a scale factor for the given color.  We have to provide the
 /// position in addition to the color, because the scale factor need not
-/// be a constant:  It can also be a function which should be applied to
+/// to be a constant: It can also be a function which should be applied to
-/// the position.  For instance, in KBP vs K endgames, a scaling function
+/// the position. For instance, in KBP vs K endgames, a scaling function
 /// which checks for draws with rook pawns and wrong-colored bishops.
 
-inline ScaleFactor MaterialInfo::scale_factor(const Position &pos, Color c)
+inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) const {
-  const {
+
-  if(scalingFunction[c] != NULL) {
+  if (scalingFunction[c] != NULL)
-    ScaleFactor sf = scalingFunction[c]->apply(pos);
+  {
-    if(sf != SCALE_FACTOR_NONE)
+      ScaleFactor sf = scalingFunction[c]->apply(pos);
-      return sf;
+      if (sf != SCALE_FACTOR_NONE)
+          return sf;
   }
   return ScaleFactor(factor[c]);
 }
@@ -137,15 +149,17 @@ inline ScaleFactor MaterialInfo::scale_factor(const Position &pos, Color c)
 /// or if the normal evaluation function should be used.
 
 inline bool MaterialInfo::specialized_eval_exists() const {
+
   return evaluationFunction != NULL;
 }
 
 
-/// MaterialInfo::evaluate applies a specialized evaluation function to a
+/// MaterialInfo::evaluate applies a specialized evaluation function
-/// given position object.  It should only be called when
+/// to a given position object.  It should only be called when
-/// this->specialized_eval_exists() returns 'true'.
+/// specialized_eval_exists() returns 'true'.
+
+inline Value MaterialInfo::evaluate(const Position& pos) const {
 
-inline Value MaterialInfo::evaluate(const Position &pos) const {
   return evaluationFunction->apply(pos);
 }
 

src/mersenne.cpp

@@ -1,12 +1,12 @@
-/* 
+/*
    A C-program for MT19937, with initialization improved 2002/1/26.
    Coded by Takuji Nishimura and Makoto Matsumoto.
 
-   Before using, initialize the state by using init_genrand(seed)  
+   Before using, initialize the state by using init_genrand(seed)
    or init_by_array(init_key, key_length).
 
    Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
-   All rights reserved.                          
+   All rights reserved.
 
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
@@ -19,8 +19,8 @@
         notice, this list of conditions and the following disclaimer in the
         documentation and/or other materials provided with the distribution.
 
-     3. The names of its contributors may not be used to endorse or promote 
+     3. The names of its contributors may not be used to endorse or promote
-        products derived from this software without specific prior written 
+        products derived from this software without specific prior written
         permission.
 
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
@@ -42,8 +42,9 @@
 */
 
 #include "types.h"
+#include "mersenne.h"
 
-/* Period parameters */  
+/* Period parameters */
 #define N 624
 #define M 397
 #define MATRIX_A 0x9908b0dfUL   /* constant vector a */
@@ -54,12 +55,12 @@ static unsigned long mt[N]; /* the array for the state vector  */
 static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
 
 /* initializes mt[N] with a seed */
-void init_genrand(unsigned long s)
+static void init_genrand(unsigned long s)
 {
     mt[0]= s & 0xffffffffUL;
     for (mti=1; mti<N; mti++) {
-        mt[mti] = 
+        mt[mti] =
-            (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti); 
+            (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
         /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
         /* In the previous versions, MSBs of the seed affect   */
         /* only MSBs of the array mt[].                        */
@@ -73,7 +74,7 @@ void init_genrand(unsigned long s)
 /* init_key is the array for initializing keys */
 /* key_length is its length */
 /* slight change for C++, 2004/2/26 */
-void init_by_array(unsigned long init_key[], int key_length)
+static void init_by_array(unsigned long init_key[], int key_length)
 {
     int i, j, k;
     init_genrand(19650218UL);
@@ -95,7 +96,7 @@ void init_by_array(unsigned long init_key[], int key_length)
         if (i>=N) { mt[0] = mt[N-1]; i=1; }
     }
 
-    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */ 
+    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
 }
 
 /* generates a random number on [0,0xffffffff]-interval */
@@ -123,7 +124,7 @@ uint32_t genrand_int32(void) {
 
     mti = 0;
   }
-  
+
   y = mt[mti++];
 
   /* Tempering */

src/mersenne.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/misc.cpp

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -38,41 +39,63 @@ int gettimeofday(struct timeval * tp, struct timezone * tzp);
 
 #include <cstdio>
 #include <iomanip>
+#include <iostream>
 #include <sstream>
 
 #include "misc.h"
 
 
-//// 
+////
+//// Variables
+////
+
+long dbg_cnt0 = 0;
+long dbg_cnt1 = 0;
+
+bool dbg_show_mean = false;
+bool dbg_show_hit_rate = false;
+
+
+////
 //// Functions
 ////
 
-/// engine_name() returns the full name of the current Glaurung version.
+void dbg_print_hit_rate() {
-/// This will be either "Glaurung YYMMDD" (where YYMMDD is the date when the
+
-/// program was compiled) or "Glaurung <version number>", depending on whether
+  std::cout << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
+            << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1)
+            << std::endl;
+}
+
+void dbg_print_mean() {
+
+  std::cout << "Total " << dbg_cnt0 << " Mean "
+            << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << std::endl;
+}
+
+/// engine_name() returns the full name of the current Stockfish version.
+/// This will be either "Stockfish YYMMDD" (where YYMMDD is the date when the
+/// program was compiled) or "Stockfish <version number>", depending on whether
 /// the constant EngineVersion (defined in misc.h) is empty.
 
 const std::string engine_name() {
-  if(EngineVersion == "") {
+
-    static const char monthNames[12][4] = {
+  if (EngineVersion.empty())
-      "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
+  {
-    };
+      std::string date(__DATE__); // From compiler, format is "Sep 21 2008"
-    const char *dateString = __DATE__;
+      std::string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
-    std::stringstream s;
+
-    int month = 0, day = 0;
+      size_t mon = 1 + months.find(date.substr(0, 3)) / 4;
-    
+
-    for(int i = 0; i < 12; i++)
+      std::stringstream s;
-      if(strncmp(dateString, monthNames[i], 3) == 0)
+      std::string day = (date[4] == ' ' ? date.substr(5, 1) : date.substr(4, 2));
-        month = i + 1;
+
-    day = atoi(dateString+4);
+      s << "Stockfish " << date.substr(date.length() - 2) << std::setfill('0')
-    
+        << std::setw(2) << mon << std::setw(2) << day;
-    s << "Glaurung " << (dateString+9) << std::setfill('0') << std::setw(2)
+
-      << month << std::setfill('0') << std::setw(2) << day;
+      return s.str();
-    
+  } else
-    return s.str();
+      return "Stockfish " + EngineVersion;
-  }
-  else
-    return "Glaurung " + EngineVersion;
 }
 
 
@@ -82,7 +105,7 @@ const std::string engine_name() {
 int get_system_time() {
   struct timeval t;
   gettimeofday(&t, NULL);
-  return t.tv_sec*1000 + t.tv_usec/1000; 
+  return t.tv_sec*1000 + t.tv_usec/1000;
 }
 
 
@@ -120,14 +143,14 @@ int Bioskey()
 {
   fd_set          readfds;
   struct timeval  timeout;
-  
+
   FD_ZERO(&readfds);
   FD_SET(fileno(stdin), &readfds);
   /* Set to timeout immediately */
   timeout.tv_sec = 0;
   timeout.tv_usec = 0;
   select(16, &readfds, 0, 0, &timeout);
-  
+
   return (FD_ISSET(fileno(stdin), &readfds));
 }
 
@@ -162,8 +185,24 @@ int Bioskey()
             return 1;
         return dw;
     } else {
+        // Count the number of unread input records, including keyboard,
+        // mouse, and window-resizing input records.
         GetNumberOfConsoleInputEvents(inh, &dw);
-        return dw <= 1 ? 0 : dw;
+        if (dw <= 0)
+            return 0;
+
+        // Read data from console without removing it from the buffer
+        INPUT_RECORD rec[256];
+        DWORD recCnt;
+        if (!PeekConsoleInput(inh, rec, Min(dw, 256), &recCnt))
+            return 0;
+
+        // Search for at least one keyboard event
+        for (DWORD i = 0; i < recCnt; i++)
+            if (rec[i].EventType == KEY_EVENT)
+                return 1;
+
+        return 0;
     }
 }
 #endif

src/misc.h

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -36,7 +37,7 @@
 /// Version number.  If this is left empty, the current date (in the format
 /// YYMMDD) is used as a version number.
 
-const std::string EngineVersion = "2.1";
+const std::string EngineVersion = "1.1a";
 
 
 ////
@@ -56,5 +57,24 @@ extern int get_system_time();
 extern int cpu_count();
 extern int Bioskey();
 
+////
+//// Debug
+////
+extern bool dbg_show_mean;
+extern bool dbg_show_hit_rate;
+
+extern long dbg_cnt0;
+extern long dbg_cnt1;
+
+inline void dbg_hit_on(bool b) { dbg_show_hit_rate = true; dbg_cnt0++; if (b) dbg_cnt1++; }
+inline void dbg_hit_on_c(bool c, bool b) { if (c) dbg_hit_on(b); }
+
+inline void dbg_before() { dbg_show_hit_rate = true; dbg_cnt0++; }
+inline void dbg_after() { dbg_show_hit_rate = true; dbg_cnt1++; }
+
+inline void dbg_mean_of(int v) { dbg_cnt0++; dbg_cnt1 += v; }
+
+extern void dbg_print_hit_rate();
+extern void dbg_print_mean();
 
 #endif // !defined(MISC_H_INCLUDED)

src/move.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -35,65 +36,70 @@
 
 /// move_from_string() takes a position and a string as input, and attempts to
 /// convert the string to a move, using simple coordinate notation (g1f3,
-/// a7a8q, etc.).  In order to correctly parse en passant captures and castling
+/// a7a8q, etc.). In order to correctly parse en passant captures and castling
-/// moves, we need the position.  This function is not robust, and expects that
+/// moves, we need the position. This function is not robust, and expects that
 /// the input move is legal and correctly formatted.
 
-Move move_from_string(const Position &pos, const std::string &str) {
+Move move_from_string(const Position& pos, const std::string& str) {
+
   Square from, to;
   Piece piece;
   Color us = pos.side_to_move();
 
-  if(str.length() < 4) return MOVE_NONE;
+  if (str.length() < 4)
+      return MOVE_NONE;
 
-  // Read the from and to squares:
+  // Read the from and to squares
   from = square_from_string(str.substr(0, 2));
   to = square_from_string(str.substr(2, 4));
 
-  // Find the moving piece:
+  // Find the moving piece
   piece = pos.piece_on(from);
 
   // If the string has more than 4 characters, try to interpret the 5th
-  // character as a promotion:
+  // character as a promotion
-  if(type_of_piece(piece) == PAWN && str.length() >= 5) {
+  if (type_of_piece(piece) == PAWN && str.length() > 4)
-    switch(str[4]) {
+  {
-    case 'n': case 'N': 
+      switch (tolower(str[4])) {
-      return make_promotion_move(from, to, KNIGHT);
+      case 'n':
-    case 'b': case 'B':
+          return make_promotion_move(from, to, KNIGHT);
-      return make_promotion_move(from, to, BISHOP);
+      case 'b':
-    case 'r': case 'R':
+          return make_promotion_move(from, to, BISHOP);
-      return make_promotion_move(from, to, ROOK);
+      case 'r':
-    case 'q': case 'Q':
+          return make_promotion_move(from, to, ROOK);
-      return make_promotion_move(from, to, QUEEN);
+      case 'q':
+          return make_promotion_move(from, to, QUEEN);
     }
   }
 
-  if(piece == king_of_color(us)) {
+  if (piece == king_of_color(us))
-    // Is this a castling move?  A king move is assumed to be a castling
+  {
-    // move if the destination square is occupied by a friendly rook, or
+      // Is this a castling move? A king move is assumed to be a castling
-    // if the distance between the source and destination squares is more
+      // move if the destination square is occupied by a friendly rook, or
-    // than 1.
+      // if the distance between the source and destination squares is more
-    if(pos.piece_on(to) == rook_of_color(us))
+      // than 1.
-      return make_castle_move(from, to);
+      if (pos.piece_on(to) == rook_of_color(us))
-    else if(square_distance(from, to) > 1) {
+          return make_castle_move(from, to);
-      // This is a castling move, but we have to translate it to the
-      // internal "king captures rook" representation.
-      SquareDelta delta = (to > from)? DELTA_E : DELTA_W;
-      Square s;
-      for(s = from + delta;
-          pawn_rank(us, s) == RANK_1 && pos.piece_on(s) != rook_of_color(us);
-          s += delta);
-      if(pawn_rank(us, s) == RANK_1 && pos.piece_on(s) == rook_of_color(us))
-        return make_castle_move(from, s);
-    }
-  }
-  else if(piece == pawn_of_color(us)) {
-    // En passant move?  We assume that a pawn move is an en passant move
-    // without further testing if the destination square is epSquare.
-    if(to == pos.ep_square())
-      return make_ep_move(from, to);
-  }
 
+      else if (square_distance(from, to) > 1)
+      {
+          // This is a castling move, but we have to translate it to the
+          // internal "king captures rook" representation.
+          SquareDelta delta = (to > from ? DELTA_E : DELTA_W);
+          Square s = from + delta;
+          while (relative_rank(us, s) == RANK_1 && pos.piece_on(s) != rook_of_color(us))
+              s += delta;
+
+          return (relative_rank(us, s) == RANK_1 ? make_castle_move(from, s) : MOVE_NONE);
+      }
+  }
+  else if (piece == pawn_of_color(us))
+  {
+      // En passant move? We assume that a pawn move is an en passant move
+      // without further testing if the destination square is epSquare.
+      if (to == pos.ep_square())
+          return make_ep_move(from, to);
+  }
   return make_move(from, to);
 }
 
@@ -104,30 +110,28 @@ Move move_from_string(const Position &pos, const std::string &str) {
 /// Chess960 mode.
 
 const std::string move_to_string(Move move) {
-  std::string str;
 
-  if(move == MOVE_NONE)
+  std::string str;
-    str = "(none)";
+  Square from = move_from(move);
-  else if(move == MOVE_NULL)
+  Square to = move_to(move);
-    str = "0000";
+
-  else {
+  if (move == MOVE_NONE)
-    if(!Chess960) {
+      str = "(none)";
-      if(move_from(move) == SQ_E1 && move_is_short_castle(move)) {
+  else if (move == MOVE_NULL)
-        str = "e1g1"; return str;
+      str = "0000";
+  else
+  {
+      if (!Chess960)
+      {
+          if (move_is_short_castle(move))
+              return (from == SQ_E1 ? "e1g1" : "e8g8");
+
+          if (move_is_long_castle(move))
+              return (from == SQ_E1 ? "e1c1" : "e8c8");
       }
-      else if(move_from(move) == SQ_E1 && move_is_long_castle(move)) {
+      str = square_to_string(from) + square_to_string(to);
-        str = "e1c1"; return str;
+      if (move_promotion(move))
-      }
+          str += piece_type_to_char(move_promotion(move), false);
-      if(move_from(move) == SQ_E8 && move_is_short_castle(move)) {
-        str = "e8g8"; return str;
-      }
-      else if(move_from(move) == SQ_E8 && move_is_long_castle(move)) {
-        str = "e8c8"; return str;
-      }
-    }
-    str = square_to_string(move_from(move)) + square_to_string(move_to(move));
-    if(move_promotion(move))
-      str += piece_type_to_char(move_promotion(move), false);
   }
   return str;
 }
@@ -136,6 +140,7 @@ const std::string move_to_string(Move move) {
 /// Overload the << operator, to make it easier to print moves.
 
 std::ostream &operator << (std::ostream &os, Move m) {
+
   return os << move_to_string(m);
 }
 
@@ -143,5 +148,6 @@ std::ostream &operator << (std::ostream &os, Move m) {
 /// move_is_ok(), for debugging.
 
 bool move_is_ok(Move m) {
+
   return square_is_ok(move_from(m)) && square_is_ok(move_to(m));
 }

src/move.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/movegen.h

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -36,7 +37,7 @@ extern int generate_noncaptures(const Position &pos, MoveStack *mlist);
 extern int generate_checks(const Position &pos, MoveStack *mlist, Bitboard dc);
 extern int generate_evasions(const Position &pos, MoveStack *mlist);
 extern int generate_legal_moves(const Position &pos, MoveStack *mlist);
-extern Move generate_move_if_legal(const Position &pos, Move m,
+extern bool move_is_legal(const Position &pos, const Move m, Bitboard pinned);
-                                   Bitboard pinned);
+
 
 #endif // !defined(MOVEGEN_H_INCLUDED)

src/movepick.cpp

@@ -1,17 +1,19 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+
+  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/>.
 */
@@ -24,6 +26,7 @@
 #include <cassert>
 
 #include "history.h"
+#include "evaluate.h"
 #include "movegen.h"
 #include "movepick.h"
 #include "search.h"
@@ -36,34 +39,20 @@
 
 namespace {
 
-  /// Types
-
-  enum MovegenPhase {
-    PH_TT_MOVE,        // Transposition table move
-    PH_MATE_KILLER,    // Mate killer from the current ply
-    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
-    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE valuse <= 0
-    PH_KILLER_1,       // Killer move 1 from the current ply (not used yet).
-    PH_KILLER_2,       // Killer move 2 from the current ply (not used yet).
-    PH_NONCAPTURES,    // Non-captures and underpromotions
-    PH_EVASIONS,       // Check evasions
-    PH_QCAPTURES,      // Captures in quiescence search
-    PH_QCHECKS,        // Checks in quiescence search
-    PH_STOP
-  };
-
-
   /// Variables
 
-  MovegenPhase PhaseTable[32];
+  MovePicker::MovegenPhase PhaseTable[32];
   int MainSearchPhaseIndex;
   int EvasionsPhaseIndex;
   int QsearchWithChecksPhaseIndex;
+  int QsearchNoCapturesPhaseIndex;
   int QsearchWithoutChecksPhaseIndex;
+  int NoMovesPhaseIndex;
 
 }
 
 
+
 ////
 //// Functions
 ////
@@ -76,29 +65,38 @@ namespace {
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.
 
-MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
+MovePicker::MovePicker(const Position& p, bool pv, Move ttm,
-                       Move k1, Move k2, Depth dpth) {
+                       const SearchStack& ss, Depth d, EvalInfo* ei) : pos(p) {
-  pos = &p;
+  pvNode = pv;
-  pvNode = pvnode;
   ttMove = ttm;
-  mateKiller = (mk == ttm)? MOVE_NONE : mk;
+  mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller;
-  killer1 = k1;
+  killer1 = ss.killers[0];
-  killer2 = k2;
+  killer2 = ss.killers[1];
-  depth = dpth;
+  depth = d;
   movesPicked = 0;
   numOfMoves = 0;
   numOfBadCaptures = 0;
-  dc = p.discovered_check_candidates(p.side_to_move());
 
-  if(p.is_check())
+  // With EvalInfo we are able to know how many captures are possible before
-    phaseIndex = EvasionsPhaseIndex;
+  // generating them. So avoid generating in case we know are zero.
-  else if(depth > Depth(0))
+  Color us = pos.side_to_move();
-    phaseIndex = MainSearchPhaseIndex;
+  Color them = opposite_color(us);
-  else if(depth == Depth(0))
+  bool noCaptures =    ei
-    phaseIndex = QsearchWithChecksPhaseIndex;
+                   && (ei->attackedBy[us][0] & pos.pieces_of_color(them)) == 0
+                   && !ei->mi->specialized_eval_exists()
+                   && (pos.ep_square() == SQ_NONE)
+                   && !pos.has_pawn_on_7th(us);
+
+  if (p.is_check())
+      phaseIndex = EvasionsPhaseIndex;
+  else if (depth > Depth(0))
+      phaseIndex = MainSearchPhaseIndex;
+  else if (depth == Depth(0))
+      phaseIndex = (noCaptures ? QsearchNoCapturesPhaseIndex : QsearchWithChecksPhaseIndex);
   else
-    phaseIndex = QsearchWithoutChecksPhaseIndex;
+      phaseIndex = (noCaptures ? NoMovesPhaseIndex : QsearchWithoutChecksPhaseIndex);
 
+  dc = p.discovered_check_candidates(us);
   pinned = p.pinned_pieces(p.side_to_move());
 
   finished = false;
@@ -110,92 +108,84 @@ MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
 /// are no more moves left of the types we are interested in.
 
 Move MovePicker::get_next_move() {
+
   Move move;
 
-  while(true) {
+  while (true)
+  {
     // If we already have a list of generated moves, pick the best move from
-    // the list, and return it:
+    // the list, and return it.
-    move = this->pick_move_from_list();
+    move = pick_move_from_list();
-    if(move != MOVE_NONE) {
+    if (move != MOVE_NONE)
-      assert(move_is_ok(move));
+    {
-      return move;
+        assert(move_is_ok(move));
+        return move;
     }
 
-    // Next phase:
+    // Next phase
     phaseIndex++;
-    switch(PhaseTable[phaseIndex]) {
+    switch (PhaseTable[phaseIndex]) {
 
     case PH_TT_MOVE:
-      if(ttMove != MOVE_NONE) {
+        if (ttMove != MOVE_NONE)
-        assert(move_is_ok(ttMove));
+        {
-        Move m = generate_move_if_legal(*pos, ttMove, pinned);
+            assert(move_is_ok(ttMove));
-        if(m != MOVE_NONE) {
+            if (move_is_legal(pos, ttMove, pinned))
-          assert(m == ttMove);
+                return ttMove;
-          return m;
         }
-      }
+        break;
-      break;
 
     case PH_MATE_KILLER:
-      if(mateKiller != MOVE_NONE) {
+        if (mateKiller != MOVE_NONE)
-        assert(move_is_ok(mateKiller));
+        {
-        Move m = generate_move_if_legal(*pos, mateKiller, pinned);
+            assert(move_is_ok(mateKiller));
-        if(m != MOVE_NONE) {
+            if (move_is_legal(pos, mateKiller, pinned))
-          assert(m == mateKiller);
+                return mateKiller;
-          return m;
+       }
-        }
+       break;
-      }
-      break;
 
     case PH_GOOD_CAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
+        numOfMoves = generate_captures(pos, moves);
-      numOfMoves = generate_captures(*pos, moves);
+        score_captures();
-      this->score_captures();
+        movesPicked = 0;
-      movesPicked = 0;
+        break;
-      break;
 
     case PH_BAD_CAPTURES:
-      badCapturesPicked = 0;
+        badCapturesPicked = 0;
-      break;
+        break;
 
     case PH_NONCAPTURES:
-      numOfMoves = generate_noncaptures(*pos, moves);
+        numOfMoves = generate_noncaptures(pos, moves);
-      this->score_noncaptures();
+        score_noncaptures();
-      movesPicked = 0;
+        movesPicked = 0;
-      break;
+        break;
 
     case PH_EVASIONS:
-      assert(pos->is_check());
+        assert(pos.is_check());
-      // pinned = pos->pinned_pieces(pos->side_to_move());
+        numOfMoves = generate_evasions(pos, moves);
-      numOfMoves = generate_evasions(*pos, moves);
+        score_evasions();
-      this->score_evasions();
+        movesPicked = 0;
-      movesPicked = 0;
+        break;
-      break;
 
     case PH_QCAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
+        numOfMoves = generate_captures(pos, moves);
-      numOfMoves = generate_captures(*pos, moves);
+        score_qcaptures();
-      this->score_qcaptures();
+        movesPicked = 0;
-      movesPicked = 0;
+        break;
-      break;
 
     case PH_QCHECKS:
-      numOfMoves = generate_checks(*pos, moves, dc);
+        numOfMoves = generate_checks(pos, moves, dc);
-      movesPicked = 0;
+        movesPicked = 0;
-      break;
+        break;
 
     case PH_STOP:
-      return MOVE_NONE;
+        return MOVE_NONE;
 
     default:
-      assert(false);
+        assert(false);
-      return MOVE_NONE;
+        return MOVE_NONE;
     }
   }
-
-  assert(false);
-
-  return MOVE_NONE;
 }
 
 
@@ -203,37 +193,26 @@ Move MovePicker::get_next_move() {
 /// prevent multiple threads from picking the same move at a split point.
 
 Move MovePicker::get_next_move(Lock &lock) {
-   Move m;
 
    lock_grab(&lock);
-   if(finished) {
+   if (finished)
-     lock_release(&lock);
+   {
-     return MOVE_NONE;
+       lock_release(&lock);
+       return MOVE_NONE;
    }
-   m = this->get_next_move();
+   Move m = get_next_move();
-   if(m == MOVE_NONE)
+   if (m == MOVE_NONE)
-     finished = true;
+       finished = true;
+
    lock_release(&lock);
-   
    return m;
 }
 
- 
-/// MovePicker::number_of_moves() simply returns the numOfMoves member
-/// variable.  It is intended to be used in positions where the side to move
-/// is in check, for detecting checkmates or situations where there is only
-/// a single reply to check.
-
-int MovePicker::number_of_moves() const {
-  return numOfMoves;
-}
-
 
 /// MovePicker::score_captures(), MovePicker::score_noncaptures(),
 /// MovePicker::score_evasions() and MovePicker::score_qcaptures() assign a
 /// numerical move ordering score to each move in a move list.  The moves
-/// with highest scores will be picked first by
+/// with highest scores will be picked first by pick_move_from_list().
-/// MovePicker::pick_move_from_list().
 
 void MovePicker::score_captures() {
   // Winning and equal captures in the main search are ordered by MVV/LVA.
@@ -242,235 +221,296 @@ void MovePicker::score_captures() {
   // capture, capturing a more valuable (but sufficiently defended) piece
   // first usually doesn't hurt.  The opponent will have to recapture, and
   // the hanging piece will still be hanging (except in the unusual cases
-  // where it is possible to recapture with the hanging piece).  Exchanging
+  // where it is possible to recapture with the hanging piece). Exchanging
   // big pieces before capturing a hanging piece probably helps to reduce
   // the subtree size.
-  for(int i = 0; i < numOfMoves; i++) {
+  // While scoring captures it moves all captures with negative SEE values
-    int seeValue = pos->see(moves[i].move);
+  // to the badCaptures[] array.
-    if(seeValue >= 0) {
+  Move m;
-      if(move_promotion(moves[i].move))
+  int seeValue;
-        moves[i].score = QueenValueMidgame;
+
-      else 
+  for (int i = 0; i < numOfMoves; i++)
-        moves[i].score =
+  {
-          int(pos->midgame_value_of_piece_on(move_to(moves[i].move))) -
+      m = moves[i].move;
-          int(pos->type_of_piece_on(move_from(moves[i].move)));
+      seeValue = pos.see(m);
-    }
+      if (seeValue >= 0)
-    else
+      {
-      moves[i].score = seeValue;
+          if (move_promotion(m))
-        
+              moves[i].score = QueenValueMidgame;
+          else
+              moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
+                              -int(pos.type_of_piece_on(move_from(m)));
+      }
+      else
+      {
+          // Losing capture, move it to the badCaptures[] array
+          assert(numOfBadCaptures < 63);
+          moves[i].score = seeValue;
+          badCaptures[numOfBadCaptures++] = moves[i];
+          moves[i--] = moves[--numOfMoves];
+      }
   }
 }
 
 void MovePicker::score_noncaptures() {
-  for(int i = 0; i < numOfMoves; i++) {
+  // First score by history, when no history is available then use
-    Move m = moves[i].move;
+  // piece/square tables values. This seems to be better then a
-    if(m == killer1)
+  // random choice when we don't have an history for any move.
-      moves[i].score = HistoryMax + 2;
+  Move m;
-    else if(m == killer2)
+  int hs;
-      moves[i].score = HistoryMax + 1;
+
-    else
+  for (int i = 0; i < numOfMoves; i++)
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+  {
+      m = moves[i].move;
+
+      if (m == killer1)
+          hs = HistoryMax + 2;
+      else if (m == killer2)
+          hs = HistoryMax + 1;
+      else
+          hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);
+
+      // Ensure history is always preferred to pst
+      if (hs > 0)
+          hs += 1000;
+
+      // pst based scoring
+      moves[i].score = hs + pos.mg_pst_delta(m);
   }
 }
 
 void MovePicker::score_evasions() {
-  for(int i = 0; i < numOfMoves; i++) {
+
-    Move m = moves[i].move;
+  for (int i = 0; i < numOfMoves; i++)
-    if(m == ttMove)
+  {
-      moves[i].score = 2*HistoryMax;
+      Move m = moves[i].move;
-    else if(!pos->square_is_empty(move_to(m))) {
+      if (m == ttMove)
-      int seeScore = pos->see(m);
+          moves[i].score = 2*HistoryMax;
-      moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
+      else if (!pos.square_is_empty(move_to(m)))
-    }
+      {
-    else
+          int seeScore = pos.see(m);
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+          moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
+      } else
+          moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m);
   }
 }
 
 void MovePicker::score_qcaptures() {
-  // Use MVV/LVA ordering.
+
-  for(int i = 0; i < numOfMoves; i++) {
+  // Use MVV/LVA ordering
-    Move m = moves[i].move;
+  for (int i = 0; i < numOfMoves; i++)
-    if(move_promotion(m))
+  {
-      moves[i].score = QueenValueMidgame;
+      Move m = moves[i].move;
-    else
+      if (move_promotion(m))
-      moves[i].score =
+          moves[i].score = QueenValueMidgame;
-        int(pos->midgame_value_of_piece_on(move_to(m))) -
+      else
-        int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
+          moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
+                          -int(pos.type_of_piece_on(move_from(m)));
   }
 }
 
 
+/// find_best_index() loops across the moves and returns index of
+/// the highest scored one. There is also a second version that
+/// lowers the priority of moves that attack the same square,
+/// so that if the best move that attack a square fails the next
+/// move picked attacks a different square if any, not the same one.
+
+int MovePicker::find_best_index() {
+
+  int bestScore = -10000000, bestIndex = -1;
+
+  for (int i = movesPicked; i < numOfMoves; i++)
+      if (moves[i].score > bestScore)
+      {
+          bestIndex = i;
+          bestScore = moves[i].score;
+      }
+  return bestIndex;
+}
+
+int MovePicker::find_best_index(Bitboard* squares, int values[]) {
+
+  int hs;
+  Move m;
+  Square to;
+  int bestScore = -10000000, bestIndex = -1;
+
+  for (int i = movesPicked; i < numOfMoves; i++)
+  {
+      m = moves[i].move;
+      to = move_to(m);
+      
+      if (!bit_is_set(*squares, to))
+      {
+          // Init at first use
+          set_bit(squares, to);
+          values[to] = 0;
+      }
+
+      hs = moves[i].score - values[to];
+      if (hs > bestScore)
+      {
+          bestIndex = i;
+          bestScore = hs;
+      }
+  }
+
+  if (bestIndex != -1)
+  {
+      // Raise value of the picked square, so next attack
+      // to the same square will get low priority.
+      to = move_to(moves[bestIndex].move);
+      values[to] += 0xB00;
+  }
+  return bestIndex;
+}
+
+
 /// MovePicker::pick_move_from_list() picks the move with the biggest score
 /// from a list of generated moves (moves[] or badCaptures[], depending on
 /// the current move generation phase).  It takes care not to return the
 /// transposition table move if that has already been serched previously.
-/// While picking captures in the PH_GOOD_CAPTURES phase (i.e. while picking
-/// non-losing captures in the main search), it moves all captures with
-/// negative SEE values to the badCaptures[] array.
 
 Move MovePicker::pick_move_from_list() {
-  int bestScore = -10000000;
+
   int bestIndex;
   Move move;
 
-  switch(PhaseTable[phaseIndex]) {
+  switch (PhaseTable[phaseIndex]) {
-
   case PH_GOOD_CAPTURES:
-    assert(!pos->is_check());
+      assert(!pos.is_check());
-    assert(movesPicked >= 0);
+      assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++) {
-        if(moves[i].score < 0) {
-          // Losing capture, move it to the badCaptures[] array
-          assert(numOfBadCaptures < 63);
-          badCaptures[numOfBadCaptures++] = moves[i];
-          moves[i--] = moves[--numOfMoves];
-        }
-        else if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
-      }
-      if(bestIndex != -1) { // Found a good capture
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
 
-  case PH_NONCAPTURES:
+      while (movesPicked < numOfMoves)
-    assert(!pos->is_check());
+      {
-    assert(movesPicked >= 0);
+          bestIndex = find_best_index();
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
 
-      // If this is a PV node or we have only picked a few moves, scan
+          if (bestIndex != -1) // Found a good capture
-      // the entire move list for the best move.  If many moves have already
+          {
-      // been searched and it is not a PV node, we are probably failing low
+              move = moves[bestIndex].move;
-      // anyway, so we just pick the first move from the list.
+              moves[bestIndex] = moves[movesPicked++];
-      if(pvNode || movesPicked < 12) {
+              if (   move != ttMove
-        bestIndex = -1;
+                  && move != mateKiller
-        for(int i = movesPicked; i < numOfMoves; i++)
+                  && pos.pl_move_is_legal(move, pinned))
-          if(moves[i].score > bestScore) {
+                  return move;
-            bestIndex = i;
-            bestScore = moves[i].score;
           }
       }
-      else
+      break;
-        bestIndex = movesPicked;
 
-      if(bestIndex != -1) {
+  case PH_NONCAPTURES:
-        MoveStack tmp = moves[movesPicked];
+      assert(!pos.is_check());
-        moves[movesPicked] = moves[bestIndex];
+      assert(movesPicked >= 0);
-        moves[bestIndex] = tmp;
+
-        move = moves[movesPicked++].move;
+      while (movesPicked < numOfMoves)
-        if(move != ttMove && move != mateKiller &&
+      {
-           pos->move_is_legal(move, pinned))
+          // If this is a PV node or we have only picked a few moves, scan
-          return move;
+          // the entire move list for the best move.  If many moves have already
+          // been searched and it is not a PV node, we are probably failing low
+          // anyway, so we just pick the first move from the list.
+          bestIndex = (pvNode || movesPicked < 12) ? find_best_index() : movesPicked;
+
+          if (bestIndex != -1)
+          {
+              move = moves[bestIndex].move;
+              moves[bestIndex] = moves[movesPicked++];
+              if (   move != ttMove
+                  && move != mateKiller
+                  && pos.pl_move_is_legal(move, pinned))
+                  return move;
+          }
       }
-    }
+      break;
-    break;
 
   case PH_EVASIONS:
-    assert(pos->is_check());
+      assert(pos.is_check());
-    assert(movesPicked >= 0);
+      assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++)
-        if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
 
-      if(bestIndex != -1) {
+      while (movesPicked < numOfMoves)
-        MoveStack tmp = moves[movesPicked];
+      {
-        moves[movesPicked] = moves[bestIndex];
+          bestIndex = find_best_index();
-        moves[bestIndex] = tmp;
+
-        move = moves[movesPicked++].move;
+          if (bestIndex != -1)
-        return move;
+          {
-      }
+              move = moves[bestIndex].move;
+              moves[bestIndex] = moves[movesPicked++];
+              return move;
+          }
     }
     break;
 
   case PH_BAD_CAPTURES:
-    assert(!pos->is_check());
+      assert(!pos.is_check());
-    assert(badCapturesPicked >= 0);
+      assert(badCapturesPicked >= 0);
-    // It's probably a good idea to use SEE move ordering here, instead
+      // It's probably a good idea to use SEE move ordering here, instead
-    // of just picking the first move.  FIXME
+      // of just picking the first move.  FIXME
-    while(badCapturesPicked < numOfBadCaptures) {
+      while (badCapturesPicked < numOfBadCaptures)
-      move = badCaptures[badCapturesPicked++].move;
+      {
-      if(move != ttMove && move != mateKiller && 
+          move = badCaptures[badCapturesPicked++].move;
-         pos->move_is_legal(move, pinned))
+          if (   move != ttMove
-        return move;
+              && move != mateKiller
-    }
+              && pos.pl_move_is_legal(move, pinned))
-    break;
+              return move;
+      }
+      break;
 
   case PH_QCAPTURES:
-    assert(!pos->is_check());
+      assert(!pos.is_check());
-    assert(movesPicked >= 0);
+      assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
+      while (movesPicked < numOfMoves)
-      bestScore = -10000000;
+      {
-      if(movesPicked < 4) {
+          bestIndex = (movesPicked < 4 ? find_best_index() : movesPicked);
-        bestIndex = -1;
+
-        for(int i = movesPicked; i < numOfMoves; i++)
+          if (bestIndex != -1)
-          if(moves[i].score > bestScore) {
+          {
-            bestIndex = i;
+              move = moves[bestIndex].move;
-            bestScore = moves[i].score;
+              moves[bestIndex] = moves[movesPicked++];
+              // Remember to change the line below if we decide to hash the qsearch!
+              // Maybe also postpone the legality check until after futility pruning?
+              if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned))
+                  return move;
           }
       }
-      else
+      break;
-        bestIndex = movesPicked;
-
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-
-        move = moves[movesPicked++].move;
-        // Remember to change the line below if we decide to hash the qsearch!
-        // Maybe also postpone the legality check until after futility pruning?
-        if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
 
   case PH_QCHECKS:
-    assert(!pos->is_check());
+      assert(!pos.is_check());
-    assert(movesPicked >= 0);
+      assert(movesPicked >= 0);
-    // Perhaps we should do something better than just picking the first
+      // Perhaps we should do something better than just picking the first
-    // move here?  FIXME
+      // move here?  FIXME
-    while(movesPicked < numOfMoves) {
+      while (movesPicked < numOfMoves)
-      move = moves[movesPicked++].move;
+      {
-      // Remember to change the line below if we decide to hash the qsearch!
+          move = moves[movesPicked++].move;
-      if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
+          // Remember to change the line below if we decide to hash the qsearch!
-        return move;
+          if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned))
-    }
+              return move;
-    break;
+      }
+      break;
 
   default:
-    break;
+      break;
   }
-
   return MOVE_NONE;
 }
 
 
+/// MovePicker::current_move_type() returns the type of the just
+/// picked next move. It can be used in search to further differentiate
+/// according to the current move type: capture, non capture, escape, etc.
+MovePicker::MovegenPhase MovePicker::current_move_type() const {
+
+  return PhaseTable[phaseIndex];
+}
+
+
 /// MovePicker::init_phase_table() initializes the PhaseTable[],
 /// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex
-/// and QsearchWithoutChecksPhaseIndex variables.  It is only called once
+/// QsearchNoCapturesPhaseIndex, QsearchWithoutChecksPhaseIndex and
-/// during program startup, and never again while the program is running.
+/// NoMovesPhaseIndex variables. It is only called once during program
+/// startup, and never again while the program is running.
 
 void MovePicker::init_phase_table() {
+
   int i = 0;
 
   // Main search
@@ -496,8 +536,17 @@ void MovePicker::init_phase_table() {
   PhaseTable[i++] = PH_QCHECKS;
   PhaseTable[i++] = PH_STOP;
 
+  // Quiescence search with checks only and no captures
+  QsearchNoCapturesPhaseIndex = i - 1;
+  PhaseTable[i++] = PH_QCHECKS;
+  PhaseTable[i++] = PH_STOP;
+
   // Quiescence search without checks
   QsearchWithoutChecksPhaseIndex = i - 1;
   PhaseTable[i++] = PH_QCAPTURES;
   PhaseTable[i++] = PH_STOP;
+
+  // Do not generate any move
+  NoMovesPhaseIndex = i - 1;
+  PhaseTable[i++] = PH_STOP;
 }

src/movepick.h

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -33,6 +34,9 @@
 //// Types
 ////
 
+struct EvalInfo;
+struct SearchStack;
+
 /// MovePicker is a class which is used to pick one legal move at a time from
 /// the current position.  It is initialized with a Position object and a few
 /// moves we have reason to believe are good.  The most important method is
@@ -44,13 +48,28 @@
 class MovePicker {
 
 public:
-  MovePicker(Position &p, bool pvnode, Move ttm, Move mk, Move k1, Move k2,
+
-             Depth dpth);
+  enum MovegenPhase {
+    PH_TT_MOVE,        // Transposition table move
+    PH_MATE_KILLER,    // Mate killer from the current ply
+    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
+    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE values < 0
+    PH_KILLER_1,       // Killer move 1 from the current ply (not used yet).
+    PH_KILLER_2,       // Killer move 2 from the current ply (not used yet).
+    PH_NONCAPTURES,    // Non-captures and underpromotions
+    PH_EVASIONS,       // Check evasions
+    PH_QCAPTURES,      // Captures in quiescence search
+    PH_QCHECKS,        // Checks in quiescence search
+    PH_STOP
+  };
+
+  MovePicker(const Position& p, bool pvnode, Move ttm, const SearchStack& ss, Depth d, EvalInfo* ei = NULL);
   Move get_next_move();
   Move get_next_move(Lock &lock);
   int number_of_moves() const;
   int current_move_score() const;
-  Bitboard discovered_check_candidates();
+  MovegenPhase current_move_type() const;
+  Bitboard discovered_check_candidates() const;
 
   static void init_phase_table();
 
@@ -60,8 +79,10 @@ private:
   void score_evasions();
   void score_qcaptures();
   Move pick_move_from_list();
-  
+  int find_best_index();
-  Position *pos;
+  int find_best_index(Bitboard* squares, int values[]);
+
+  const Position& pos;
   Move ttMove, mateKiller, killer1, killer2;
   Bitboard pinned, dc;
   MoveStack moves[256], badCaptures[64];
@@ -78,11 +99,21 @@ private:
 //// Inline functions
 ////
 
+/// MovePicker::number_of_moves() simply returns the numOfMoves member
+/// variable. It is intended to be used in positions where the side to move
+/// is in check, for detecting checkmates or situations where there is only
+/// a single reply to check.
+
+inline int MovePicker::number_of_moves() const {
+
+  return numOfMoves;
+}
+
 /// MovePicker::discovered_check_candidates() returns a bitboard containing
 /// all pieces which can possibly give discovered check.  This bitboard is
 /// computed by the constructor function.
 
-inline Bitboard MovePicker::discovered_check_candidates() {
+inline Bitboard MovePicker::discovered_check_candidates() const {
   return dc;
 }
 

src/pawns.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -22,6 +23,7 @@
 ////
 
 #include <cassert>
+#include <cstring>
 
 #include "pawns.h"
 
@@ -364,8 +366,8 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
         ev += ChainEndgameBonus[f];
       }
       if(candidate) {
-        mv += CandidateMidgameBonus[pawn_rank(us, s)];
+        mv += CandidateMidgameBonus[relative_rank(us, s)];
-        ev += CandidateEndgameBonus[pawn_rank(us, s)];
+        ev += CandidateEndgameBonus[relative_rank(us, s)];
       }
 
       mgValue[us] += mv;

src/pawns.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/phase.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/piece.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -71,7 +72,7 @@ const SquareDelta PawnPush[2] = {
 
 static const char PieceChars[] = " pnbrqk";
 
-char piece_type_to_char(PieceType pt, bool upcase = false) {
+char piece_type_to_char(PieceType pt, bool upcase) {
   return upcase? toupper(PieceChars[pt]) : PieceChars[pt];
 }
 

src/piece.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -123,7 +124,7 @@ inline SquareDelta pawn_push(Color c) {
 //// Prototypes
 ////
 
-extern char piece_type_to_char(PieceType pt, bool upcase);
+extern char piece_type_to_char(PieceType pt, bool upcase = false);
 extern PieceType piece_type_from_char(char c);
 extern bool piece_is_ok(Piece pc);
 extern bool piece_type_is_ok(PieceType pt);

src/position.h

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -20,6 +21,14 @@
 #if !defined(POSITION_H_INCLUDED)
 #define POSITION_H_INCLUDED
 
+// Disable a silly and noisy warning from MSVC compiler
+#if defined(_MSC_VER)
+
+// Forcing value to bool 'true' or 'false' (performance warning)
+#pragma warning(disable: 4800)
+
+#endif
+
 ////
 //// Includes
 ////
@@ -39,7 +48,7 @@
 ////
 
 /// FEN string for the initial position:
-const std::string StartPosition = 
+const std::string StartPosition =
   "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
 /// Maximum number of plies per game (220 should be enough, because the
@@ -55,9 +64,11 @@ const int MaxGameLength = 220;
 /// Castle rights, encoded as bit fields:
 
 enum CastleRights {
-  NO_CASTLES = 0, 
+  NO_CASTLES = 0,
-  WHITE_OO = 1, BLACK_OO = 2, 
+  WHITE_OO = 1,
-  WHITE_OOO = 4, BLACK_OOO = 8,
+  BLACK_OO = 2,
+  WHITE_OOO = 4,
+  BLACK_OOO = 8,
   ALL_CASTLES = 15
 };
 
@@ -81,7 +92,7 @@ struct UndoInfo {
 
 
 /// The position data structure.  A position consists of the following data:
-///    
+///
 ///    * For each piece type, a bitboard representing the squares occupied
 ///      by pieces of that type.
 ///    * For each color, a bitboard representing the squares occupiecd by
@@ -106,17 +117,18 @@ struct UndoInfo {
 class Position {
 
   friend class MaterialInfo;
+  friend class EndgameFunctions;
 
 public:
   // Constructors
-  Position();
+  Position() {};
   Position(const Position &pos);
   Position(const std::string &fen);
 
   // Text input/output
   void from_fen(const std::string &fen);
   const std::string to_fen() const;
-  void print() const;
+  void print(Move m = MOVE_NONE) const;
 
   // Copying
   void copy(const Position &pos);
@@ -161,19 +173,14 @@ public:
 
   // Number of pieces of each color and type
   int piece_count(Color c, PieceType pt) const;
-  int pawn_count(Color c) const;
-  int knight_count(Color c) const;
-  int bishop_count(Color c) const;
-  int rook_count(Color c) const;
-  int queen_count(Color c) const;
 
-  // The en passant square:
+  // The en passant square
   Square ep_square() const;
 
   // Current king position for each color
   Square king_square(Color c) const;
 
-  // Castling rights.
+  // Castling rights
   bool can_castle_kingside(Color c) const;
   bool can_castle_queenside(Color c) const;
   bool can_castle(Color c) const;
@@ -184,13 +191,9 @@ public:
   Bitboard sliding_attacks(Square s, Direction d) const;
   Bitboard ray_attacks(Square s, SignedDirection d) const;
   Bitboard pawn_attacks(Color c, Square s) const;
-  Bitboard white_pawn_attacks(Square s) const;
+
-  Bitboard black_pawn_attacks(Square s) const;
+  template<PieceType>
-  Bitboard knight_attacks(Square s) const;
+  Bitboard piece_attacks(Square s) const;
-  Bitboard bishop_attacks(Square s) const;
-  Bitboard rook_attacks(Square s) const;
-  Bitboard queen_attacks(Square s) const;
-  Bitboard king_attacks(Square s) const;
 
   // Bitboards for pinned pieces and discovered check candidates
   Bitboard discovered_check_candidates(Color c) const;
@@ -199,34 +202,28 @@ public:
   // Checking pieces
   Bitboard checkers() const;
 
-  // Piece lists:
+  // Piece lists
   Square piece_list(Color c, PieceType pt, int index) const;
-  Square pawn_list(Color c, int index) const;
-  Square knight_list(Color c, int index) const;
-  Square bishop_list(Color c, int index) const;
-  Square rook_list(Color c, int index) const;
-  Square queen_list(Color c, int index) const;
 
   // Attack information for a given square
   bool square_is_attacked(Square s, Color c) const;
   Bitboard attacks_to(Square s) const;
   Bitboard attacks_to(Square s, Color c) const;
   bool is_check() const;
-  bool piece_attacks_square(Square f, Square t) const;
+  bool pawn_attacks_square(Color c, Square f, Square t) const;
-  bool white_pawn_attacks_square(Square f, Square t) const;
+
-  bool black_pawn_attacks_square(Square f, Square t) const;
+  template<PieceType>
-  bool knight_attacks_square(Square f, Square t) const;
+  Bitboard piece_attacks_square(Square f, Square t) const; // Dispatch at compile-time
-  bool bishop_attacks_square(Square f, Square t) const;
+
-  bool rook_attacks_square(Square f, Square t) const;
+  bool piece_attacks_square(Square f, Square t) const; // Dispatch at run-time
-  bool queen_attacks_square(Square f, Square t) const;
-  bool king_attacks_square(Square f, Square t) const;
 
   // Properties of moves
-  bool move_is_legal(Move m) const;
+  bool pl_move_is_legal(Move m) const;
-  bool move_is_legal(Move m, Bitboard pinned) const;
+  bool pl_move_is_legal(Move m, Bitboard pinned) const;
   bool move_is_check(Move m) const;
   bool move_is_check(Move m, Bitboard dcCandidates) const;
   bool move_is_capture(Move m) const;
+  bool move_is_deep_pawn_push(Move m) const;
   bool move_is_pawn_push_to_7th(Move m) const;
   bool move_is_passed_pawn_push(Move m) const;
   bool move_was_passed_pawn_push(Move m) const;
@@ -267,6 +264,7 @@ public:
   Value eg_value() const;
   Value non_pawn_material(Color c) const;
   Phase game_phase() const;
+  Value mg_pst_delta(Move m) const;
 
   // Game termination checks
   bool is_mate();
@@ -284,9 +282,9 @@ public:
 
   // Reset the gamePly variable to 0
   void reset_game_ply();
-  
+
   // Position consistency check, for debugging
-  bool is_ok() const;
+  bool is_ok(int* failedStep = NULL) const;
 
   // Static member functions:
   static void init_zobrist();
@@ -300,6 +298,7 @@ private:
   void allow_ooo(Color c);
 
   // Helper functions for doing and undoing moves
+  void do_capture_move(Move m, PieceType capture, Color them, Square to);
   void do_castle_move(Move m);
   void do_promotion_move(Move m, UndoInfo &u);
   void do_ep_move(Move m);
@@ -308,6 +307,9 @@ private:
   void undo_ep_move(Move m);
   void find_checkers();
 
+  template<PieceType Piece, bool FindPinned>
+  Bitboard hidden_checks(Color c, Square ksq) const;
+
   // Computing hash keys from scratch (for initialization and debugging)
   Key compute_key() const;
   Key compute_pawn_key() const;
@@ -329,7 +331,7 @@ private:
 
   // Piece counts
   int pieceCount[2][8]; // [color][pieceType]
-  
+
   // Piece lists
   Square pieceList[2][8][16]; // [color][pieceType][index]
   int index[64];
@@ -367,27 +369,27 @@ inline Piece Position::piece_on(Square s) const {
 }
 
 inline Color Position::color_of_piece_on(Square s) const {
-  return color_of_piece(this->piece_on(s));
+  return color_of_piece(piece_on(s));
 }
 
 inline PieceType Position::type_of_piece_on(Square s) const {
-  return type_of_piece(this->piece_on(s));
+  return type_of_piece(piece_on(s));
 }
 
 inline bool Position::square_is_empty(Square s) const {
-  return this->piece_on(s) == EMPTY;
+  return piece_on(s) == EMPTY;
 }
 
 inline bool Position::square_is_occupied(Square s) const {
-  return !this->square_is_empty(s);
+  return !square_is_empty(s);
 }
 
 inline Value Position::midgame_value_of_piece_on(Square s) const {
-  return piece_value_midgame(this->piece_on(s));
+  return piece_value_midgame(piece_on(s));
 }
 
 inline Value Position::endgame_value_of_piece_on(Square s) const {
-  return piece_value_endgame(this->piece_on(s));
+  return piece_value_endgame(piece_on(s));
 }
 
 inline Color Position::side_to_move() const {
@@ -399,7 +401,7 @@ inline Bitboard Position::occupied_squares() const {
 }
 
 inline Bitboard Position::empty_squares() const {
-  return ~(this->occupied_squares());
+  return ~(occupied_squares());
 }
 
 inline Bitboard Position::pieces_of_color(Color c) const {
@@ -410,131 +412,90 @@ inline Bitboard Position::pieces_of_type(PieceType pt) const {
   return byTypeBB[pt];
 }
 
-inline Bitboard Position::pieces_of_color_and_type(Color c, PieceType pt)
+inline Bitboard Position::pieces_of_color_and_type(Color c, PieceType pt) const {
-  const {
+  return pieces_of_color(c) & pieces_of_type(pt);
-  return this->pieces_of_color(c) & this->pieces_of_type(pt);
 }
 
 inline Bitboard Position::pawns() const {
-  return this->pieces_of_type(PAWN);
+  return pieces_of_type(PAWN);
 }
 
 inline Bitboard Position::knights() const {
-  return this->pieces_of_type(KNIGHT);
+  return pieces_of_type(KNIGHT);
 }
 
 inline Bitboard Position::bishops() const {
-  return this->pieces_of_type(BISHOP);
+  return pieces_of_type(BISHOP);
 }
 
 inline Bitboard Position::rooks() const {
-  return this->pieces_of_type(ROOK);
+  return pieces_of_type(ROOK);
 }
 
 inline Bitboard Position::queens() const {
-  return this->pieces_of_type(QUEEN);
+  return pieces_of_type(QUEEN);
 }
 
 inline Bitboard Position::kings() const {
-  return this->pieces_of_type(KING);
+  return pieces_of_type(KING);
 }
 
 inline Bitboard Position::rooks_and_queens() const {
-  return this->rooks() | this->queens();
+  return rooks() | queens();
 }
 
 inline Bitboard Position::bishops_and_queens() const {
-  return this->bishops() | this->queens();
+  return bishops() | queens();
 }
 
 inline Bitboard Position::sliders() const {
-  return this->bishops() | this->queens() | this->rooks();
+  return bishops() | queens() | rooks();
 }
 
 inline Bitboard Position::pawns(Color c) const {
-  return this->pieces_of_color_and_type(c, PAWN);
+  return pieces_of_color_and_type(c, PAWN);
 }
 
 inline Bitboard Position::knights(Color c) const {
-  return this->pieces_of_color_and_type(c, KNIGHT);
+  return pieces_of_color_and_type(c, KNIGHT);
 }
 
 inline Bitboard Position::bishops(Color c) const {
-  return this->pieces_of_color_and_type(c, BISHOP);
+  return pieces_of_color_and_type(c, BISHOP);
 }
 
 inline Bitboard Position::rooks(Color c) const {
-  return this->pieces_of_color_and_type(c, ROOK);
+  return pieces_of_color_and_type(c, ROOK);
 }
 
 inline Bitboard Position::queens(Color c) const {
-  return this->pieces_of_color_and_type(c, QUEEN);
+  return pieces_of_color_and_type(c, QUEEN);
 }
 
 inline Bitboard Position::kings(Color c) const {
-  return this->pieces_of_color_and_type(c, KING);
+  return pieces_of_color_and_type(c, KING);
 }
 
 inline Bitboard Position::rooks_and_queens(Color c) const {
-  return this->rooks_and_queens() & this->pieces_of_color(c);
+  return rooks_and_queens() & pieces_of_color(c);
 }
 
 inline Bitboard Position::bishops_and_queens(Color c) const {
-  return this->bishops_and_queens() & this->pieces_of_color(c);
+  return bishops_and_queens() & pieces_of_color(c);
 }
 
 inline Bitboard Position::sliders_of_color(Color c) const {
-  return this->sliders() & this->pieces_of_color(c);
+  return sliders() & pieces_of_color(c);
 }
 
 inline int Position::piece_count(Color c, PieceType pt) const {
   return pieceCount[c][pt];
 }
 
-inline int Position::pawn_count(Color c) const {
-  return this->piece_count(c, PAWN);
-}
-
-inline int Position::knight_count(Color c) const {
-  return this->piece_count(c, KNIGHT);
-}
-
-inline int Position::bishop_count(Color c) const {
-  return this->piece_count(c, BISHOP);
-}
-
-inline int Position::rook_count(Color c) const {
-  return this->piece_count(c, ROOK);
-}
-
-inline int Position::queen_count(Color c) const {
-  return this->piece_count(c, QUEEN);
-}
-
 inline Square Position::piece_list(Color c, PieceType pt, int index) const {
   return pieceList[c][pt][index];
 }
 
-inline Square Position::pawn_list(Color c, int index) const {
-  return this->piece_list(c, PAWN, index);
-}
-
-inline Square Position::knight_list(Color c, int index) const {
-  return this->piece_list(c, KNIGHT, index);
-}
-
-inline Square Position::bishop_list(Color c, int index) const {
-  return this->piece_list(c, BISHOP, index);
-}
-
-inline Square Position::rook_list(Color c, int index) const {
-  return this->piece_list(c, ROOK, index);
-}
-
-inline Square Position::queen_list(Color c, int index) const {
-  return this->piece_list(c, QUEEN, index);
-}
-
 inline Square Position::ep_square() const {
   return epSquare;
 }
@@ -567,31 +528,28 @@ inline Bitboard Position::pawn_attacks(Color c, Square s) const {
   return StepAttackBB[pawn_of_color(c)][s];
 }
 
-inline Bitboard Position::white_pawn_attacks(Square s) const {
+template<>
-  return this->pawn_attacks(WHITE, s);
+inline Bitboard Position::piece_attacks<KNIGHT>(Square s) const {
-}
-
-inline Bitboard Position::black_pawn_attacks(Square s) const {
-  return this->pawn_attacks(BLACK, s);
-}
-
-inline Bitboard Position::knight_attacks(Square s) const {
   return StepAttackBB[KNIGHT][s];
 }
 
-inline Bitboard Position::rook_attacks(Square s) const {
+template<>
-  return rook_attacks_bb(s, this->occupied_squares());
+inline Bitboard Position::piece_attacks<BISHOP>(Square s) const {
+  return bishop_attacks_bb(s, occupied_squares());
 }
 
-inline Bitboard Position::bishop_attacks(Square s) const {
+template<>
-  return bishop_attacks_bb(s, this->occupied_squares());
+inline Bitboard Position::piece_attacks<ROOK>(Square s) const {
+  return rook_attacks_bb(s, occupied_squares());
 }
 
-inline Bitboard Position::queen_attacks(Square s) const {
+template<>
-  return this->rook_attacks(s) | this->bishop_attacks(s);
+inline Bitboard Position::piece_attacks<QUEEN>(Square s) const {
+  return piece_attacks<ROOK>(s) | piece_attacks<BISHOP>(s);
 }
 
-inline Bitboard Position::king_attacks(Square s) const {
+template<>
+inline Bitboard Position::piece_attacks<KING>(Square s) const {
   return StepAttackBB[KING][s];
 }
 
@@ -600,61 +558,42 @@ inline Bitboard Position::checkers() const {
 }
 
 inline bool Position::is_check() const {
-  return this->checkers() != EmptyBoardBB;
+  return checkersBB != EmptyBoardBB;
 }
 
-inline bool Position::white_pawn_attacks_square(Square f, Square t) const {
+inline bool Position::pawn_attacks_square(Color c, Square f, Square t) const {
-  return bit_is_set(this->white_pawn_attacks(f), t);
+  return bit_is_set(pawn_attacks(c, f), t);
 }
 
-inline bool Position::black_pawn_attacks_square(Square f, Square t) const {
+template<PieceType Piece>
-  return bit_is_set(this->black_pawn_attacks(f), t);
+Bitboard Position::piece_attacks_square(Square f, Square t) const {
-}
+  return bit_is_set(piece_attacks<Piece>(f), t);
-
-inline bool Position::knight_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->knight_attacks(f), t);
-}
-
-inline bool Position::bishop_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->bishop_attacks(f), t);
-}
-
-inline bool Position::rook_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->rook_attacks(f), t);
-}
-
-inline bool Position::queen_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->queen_attacks(f), t);
-}
-
-inline bool Position::king_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->king_attacks(f), t);
 }
 
 inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(this->pawns(opposite_color(c)) & passed_pawn_mask(c, s));
+  return !(pawns(opposite_color(c)) & passed_pawn_mask(c, s));
 }
 
 inline bool Position::pawn_is_isolated(Color c, Square s) const {
-  return !(this->pawns(c) & neighboring_files_bb(s));
+  return !(pawns(c) & neighboring_files_bb(s));
 }
 
 inline bool Position::pawn_is_doubled(Color c, Square s) const {
-  return this->pawns(c) & squares_behind(c, s);
+  return pawns(c) & squares_behind(c, s);
 }
 
 inline bool Position::file_is_open(File f) const {
-  return !(this->pawns() & file_bb(f));
+  return !(pawns() & file_bb(f));
 }
 
 inline bool Position::file_is_half_open(Color c, File f) const {
-  return !(this->pawns(c) & file_bb(f));
+  return !(pawns(c) & file_bb(f));
 }
 
 inline bool Position::square_is_weak(Square s, Color c) const {
-  return !(this->pawns(c) & outpost_mask(opposite_color(c), s));
+  return !(pawns(c) & outpost_mask(opposite_color(c), s));
 }
-                                
+
 inline Key Position::get_key() const {
   return key;
 }
@@ -671,6 +610,11 @@ inline Value Position::mg_pst(Color c, PieceType pt, Square s) const {
   return MgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
 }
 
+inline Value Position::mg_pst_delta(Move m) const {
+  return MgPieceSquareTable[piece_on(move_from(m))][move_to(m)]
+        -MgPieceSquareTable[piece_on(move_from(m))][move_from(m)];
+}
+
 inline Value Position::eg_pst(Color c, PieceType pt, Square s) const {
   return EgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
 }
@@ -692,55 +636,67 @@ inline Phase Position::game_phase() const {
   // The purpose of the Value(325) terms below is to make sure the difference
   // between MidgameLimit and EndgameLimit is a power of 2, which should make
   // the division at the end of the function a bit faster.
+  static const Value MidgameLimit =  2 * QueenValueMidgame
+                                   + 2 * RookValueMidgame
+                                   + 6 * BishopValueMidgame
+                                   + Value(325);
 
-  static const Value MidgameLimit =
+  static const Value EndgameLimit = 4 * RookValueMidgame - Value(325);
-    2*QueenValueMidgame+2*RookValueMidgame+6*BishopValueMidgame+Value(325);
+
-  static const Value EndgameLimit = 4*RookValueMidgame-Value(325);
+  Value npm = non_pawn_material(WHITE) + non_pawn_material(BLACK);
-  Value npm = this->non_pawn_material(WHITE) + this->non_pawn_material(BLACK);
+
-  
+  if (npm >= MidgameLimit)
-  if(npm >= MidgameLimit)
+      return PHASE_MIDGAME;
-    return PHASE_MIDGAME;
   else if(npm <= EndgameLimit)
-    return PHASE_ENDGAME;
+      return PHASE_ENDGAME;
   else
-    return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
+      return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
+}
+
+inline bool Position::move_is_deep_pawn_push(Move m) const {
+
+  Color c = side_to_move();
+  return   piece_on(move_from(m)) == pawn_of_color(c)
+        && relative_rank(c, move_to(m)) > RANK_4;
 }
 
 inline bool Position::move_is_pawn_push_to_7th(Move m) const {
-  Color c = this->side_to_move();
+
-  return 
+  Color c = side_to_move();
-    this->piece_on(move_from(m)) == pawn_of_color(c) &&
+  return   piece_on(move_from(m)) == pawn_of_color(c)
-    pawn_rank(c, move_to(m)) == RANK_7;
+        && relative_rank(c, move_to(m)) == RANK_7;
 }
 
 inline bool Position::move_is_passed_pawn_push(Move m) const {
-  Color c = this->side_to_move();
+
-  return 
+  Color c = side_to_move();
-    this->piece_on(move_from(m)) == pawn_of_color(c) &&
+  return   piece_on(move_from(m)) == pawn_of_color(c)
-    this->pawn_is_passed(c, move_to(m));
+        && pawn_is_passed(c, move_to(m));
 }
- 
+
 inline bool Position::move_was_passed_pawn_push(Move m) const {
-  Color c = opposite_color(this->side_to_move());
+
-  return 
+  Color c = opposite_color(side_to_move());
-    this->piece_on(move_to(m)) == pawn_of_color(c) &&
+  return   piece_on(move_to(m)) == pawn_of_color(c)
-    this->pawn_is_passed(c, move_to(m));
+        && pawn_is_passed(c, move_to(m));
 }
 
 inline int Position::rule_50_counter() const {
+
   return rule50;
 }
 
 inline bool Position::opposite_colored_bishops() const {
-  return
+
-    this->bishop_count(WHITE) == 1 && this->bishop_count(BLACK) == 1 &&
+  return   piece_count(WHITE, BISHOP) == 1
-    square_color(this->bishop_list(WHITE, 0)) !=
+        && piece_count(BLACK, BISHOP) == 1
-    square_color(this->bishop_list(BLACK, 0));
+        && square_color(piece_list(WHITE, BISHOP, 0)) != square_color(piece_list(BLACK, BISHOP, 0));
 }
 
 inline bool Position::has_pawn_on_7th(Color c) const {
-  return this->pawns(c) & relative_rank_bb(c, RANK_7);
+
+  return pawns(c) & relative_rank_bb(c, RANK_7);
 }
-                        
+
 
 #endif // !defined(POSITION_H_INCLUDED)

src/psqtab.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -25,138 +26,162 @@
 ////
 
 #include "position.h"
+#include "value.h"
 
 
 ////
 //// Variables
 ////
 
+static const Value MP = PawnValueMidgame;
+static const Value MK = KnightValueMidgame;
+static const Value MB = BishopValueMidgame;
+static const Value MR = RookValueMidgame;
+static const Value MQ = QueenValueMidgame;
+
 static const int MgPST[][64] = {
   { },
-  { // Pawn
+  {// Pawn
-    0, 0, 0, 0, 0, 0, 0, 0,
+   // A      B      C      D      E      F      G      H
-    166, 192, 204, 216, 216, 204, 192, 166,
+        0,     0,     0,     0,     0,     0,     0,     0,
-    166, 192, 210, 242, 242, 210, 192, 166, 
+    MP-38, MP-12, MP- 0, MP+12, MP+12, MP- 0, MP-12, MP-38,
-    166, 192, 220, 268, 268, 220, 192, 166, 
+    MP-38, MP-12, MP+ 6, MP+38, MP+38, MP+ 6, MP-12, MP-38,
-    166, 192, 220, 242, 242, 220, 192, 166, 
+    MP-38, MP-12, MP+16, MP+64, MP+64, MP+16, MP-12, MP-38,
-    166, 192, 210, 216, 216, 210, 192, 166, 
+    MP-38, MP-12, MP+16, MP+38, MP+38, MP+16, MP-12, MP-38,
-    166, 192, 204, 216, 216, 204, 192, 166, 
+    MP-38, MP-12, MP+ 6, MP+12, MP+12, MP+ 6, MP-12, MP-38,
-    0, 0, 0, 0, 0, 0, 0, 0
+    MP-38, MP-12, MP- 0, MP+12, MP+12, MP- 0, MP-12, MP-38,
-  }, 
+        0,     0,     0,     0,     0,     0,     0,     0
-  { // Knight
+  },
-    704, 730, 756, 768, 768, 756, 730, 704, 
+  {// Knight
-    743, 768, 794, 807, 807, 794, 768, 743, 
+   //  A      B       C      D      E      F      G       H
-    781, 807, 832, 844, 844, 832, 807, 781, 
+    MK-128, MK-102, MK-76, MK-64, MK-64, MK-76, MK-102, MK-128,
-    807, 832, 857, 870, 870, 857, 832, 807, 
+    MK- 89, MK- 64, MK-38, MK-25, MK-25, MK-38, MK- 64, MK- 89,
-    820, 844, 870, 883, 883, 870, 844, 820, 
+    MK- 51, MK- 25, MK- 0, MK+12, MK+12, MK- 0, MK- 25, MK- 51,
-    820, 844, 870, 883, 883, 870, 844, 820, 
+    MK- 25, MK-  0, MK+25, MK+38, MK+38, MK+25, MK-  0, MK- 25,
-    781, 807, 832, 844, 844, 832, 807, 781, 
+    MK- 12, MK+ 12, MK+38, MK+51, MK+51, MK+38, MK+ 12, MK- 12,
-    650, 768, 794, 807, 807, 794, 768, 650
+    MK- 12, MK+ 12, MK+38, MK+51, MK+51, MK+38, MK+ 12, MK- 12,
-  }, 
+    MK- 51, MK- 25, MK- 0, MK+12, MK+12, MK- 0, MK- 25, MK- 51,
-  { // Bishop
+    MK-182, MK- 64, MK-38, MK-25, MK-25, MK-38, MK- 64, MK-182
-    786, 786, 792, 797, 797, 792, 786, 786, 
+  },
-    812, 832, 827, 832, 832, 827, 832, 812, 
+  {// Bishop
-    817, 827, 842, 837, 837, 842, 827, 817, 
+   // A      B      C      D      E      F      G      H
-    822, 832, 837, 852, 852, 837, 832, 822, 
+    MB-46, MB-46, MB-40, MB-35, MB-35, MB-40, MB-46, MB-46,
-    822, 832, 837, 852, 852, 837, 832, 822, 
+    MB-20, MB- 0, MB- 5, MB- 0, MB- 0, MB- 5, MB- 0, MB-20,
-    817, 827, 842, 837, 837, 842, 827, 817, 
+    MB-15, MB- 5, MB+10, MB+ 5, MB+ 5, MB+10, MB- 5, MB-15,
-    812, 832, 827, 832, 832, 827, 832, 812, 
+    MB-10, MB- 0, MB+ 5, MB+20, MB+20, MB+ 5, MB- 0, MB-10,
-    812, 812, 817, 822, 822, 817, 812, 812
+    MB-10, MB- 0, MB+ 5, MB+20, MB+20, MB+ 5, MB- 0, MB-10,
-  }, 
+    MB-15, MB- 5, MB+10, MB+ 5, MB+ 5, MB+10, MB- 5, MB-15,
-  { // Rook
+    MB-20, MB- 0, MB- 5, MB- 0, MB- 0, MB- 5, MB- 0, MB-20,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MB-20, MB-20, MB-15, MB-10, MB-10, MB-15, MB-20, MB-20
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+  },
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+  {// Rook
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+   // A      B      C     D     E     F     G      H
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-  }, 
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-  { // Queen
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+  },
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+  {// Queen
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+   //A   B   C   D   E   F   G   H
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-  }, 
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-  { // King
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    302, 328, 276, 225, 225, 276, 328, 302, 
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    276, 302, 251, 200, 200, 251, 302, 276, 
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    225, 251, 200, 149, 149, 200, 251, 225, 
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ
-    200, 225, 175, 124, 124, 175, 225, 200, 
+  },
-    175, 200, 149, 98, 98, 149, 200, 175, 
+  {// King
-    149, 175, 124, 72, 72, 124, 175, 149, 
+   //A    B    C    D    E    F    G    H
-    124, 149, 98, 47, 47, 98, 149, 124, 
+    302, 328, 276, 225, 225, 276, 328, 302,
-    98, 124, 72, 21, 21, 72, 124, 98, 
+    276, 302, 251, 200, 200, 251, 302, 276,
+    225, 251, 200, 149, 149, 200, 251, 225,
+    200, 225, 175, 124, 124, 175, 225, 200,
+    175, 200, 149,  98,  98, 149, 200, 175,
+    149, 175, 124,  72,  72, 124, 175, 149,
+    124, 149,  98,  47,  47,  98, 149, 124,
+     98, 124,  72,  21,  21,  72, 124,  98
   }
 };
 
+static const Value EP = PawnValueEndgame;
+static const Value EK = KnightValueEndgame;
+static const Value EB = BishopValueEndgame;
+static const Value ER = RookValueEndgame;
+static const Value EQ = QueenValueEndgame;
 
 static const int EgPST[][64] = {
   { },
-  { // Pawn
+  {// Pawn
-    0, 0, 0, 0, 0, 0, 0, 0, 
+   //A   B   C   D   E   F   G   H
-    256, 256, 256, 256, 256, 256, 256, 256, 
+     0,  0,  0,  0,  0,  0,  0,  0,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP, EP, EP, EP, EP, EP, EP, EP,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP, EP, EP, EP, EP, EP, EP, EP,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP, EP, EP, EP, EP, EP, EP, EP,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP, EP, EP, EP, EP, EP, EP, EP,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP, EP, EP, EP, EP, EP, EP, EP,
-    0, 0, 0, 0, 0, 0, 0, 0
+    EP, EP, EP, EP, EP, EP, EP, EP,
+     0,  0,  0,  0,  0,  0,  0,  0
   },
-  { // Knight
+  {// Knight
-    730, 756, 781, 794, 794, 781, 756, 730, 
+   // A       B      C      D      E      F      G      H
-    756, 781, 807, 820, 820, 807, 781, 756, 
+    EK-102, EK-76, EK-51, EK-38, EK-38, EK-51, EK-76, EK-102,
-    781, 807, 832, 844, 844, 832, 807, 781, 
+    EK- 76, EK-51, EK-25, EK-12, EK-12, EK-25, EK-51, EK-76,
-    794, 820, 844, 857, 857, 844, 820, 794, 
+    EK- 51, EK-25, EK- 0, EK+12, EK+12, EK- 0, EK-25, EK-51,
-    794, 820, 844, 857, 857, 844, 820, 794, 
+    EK- 38, EK-12, EK+12, EK+25, EK+25, EK+12, EK-12, EK-38,
-    781, 807, 832, 844, 844, 832, 807, 781, 
+    EK- 38, EK-12, EK+12, EK+25, EK+25, EK+12, EK-12, EK-38,
-    756, 781, 807, 820, 820, 807, 781, 756, 
+    EK- 51, EK-25, EK- 0, EK+12, EK+12, EK- 0, EK-25, EK-51,
-    730, 756, 781, 794, 794, 781, 756, 730
+    EK- 76, EK-51, EK-25, EK-12, EK-12, EK-25, EK-51, EK-76,
+    EK-102, EK-76, EK-51, EK-38, EK-38, EK-51, EK-76, EK-102
   },
-  { // Bishop
+  {// Bishop
-    786, 802, 809, 817, 817, 809, 802, 786, 
+   // A      B      C      D      E      F      G      H
-    802, 817, 825, 832, 832, 825, 817, 802, 
+    EB-46, EB-30, EB-23, EB-15, EB-15, EB-23, EB-30, EB-46,
-    809, 825, 832, 839, 839, 832, 825, 809, 
+    EB-30, EB-15, EB- 7, EB- 0, EB- 0, EB- 7, EB-15, EB-30,
-    817, 832, 839, 847, 847, 839, 832, 817, 
+    EB-23, EB- 7, EB- 0, EB+ 7, EB+ 7, EB- 0, EB- 7, EB-23,
-    817, 832, 839, 847, 847, 839, 832, 817, 
+    EB-15, EB- 0, EB+ 7, EB+15, EB+15, EB+ 7, EB- 0, EB-15,
-    809, 825, 832, 839, 839, 832, 825, 809, 
+    EB-15, EB- 0, EB+ 7, EB+15, EB+15, EB+ 7, EB- 0, EB-15,
-    802, 817, 825, 832, 832, 825, 817, 802, 
+    EB-23, EB- 7, EB- 0, EB+ 7, EB+ 7, EB- 0, EB- 7, EB-23,
-    786, 802, 809, 817, 817, 809, 802, 786
+    EB-30, EB-15, EB- 7, EB- 0, EB- 0, EB- 7, EB-15, EB-30,
+    EB-46, EB-30, EB-23, EB-15, EB-15, EB-23, EB-30, EB-46
   },
-  { // Rook
+  {// Rook
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+   // A     B     C     D     E     F     G     H
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3
   },
-  { // Queen
+  {// Queen
-    2499, 2520, 2530, 2540, 2540, 2530, 2520, 2499, 
+   // A      B      C      D      E      F      G      H
-    2520, 2540, 2550, 2560, 2560, 2550, 2540, 2520, 
+    EQ-61, EQ-40, EQ-30, EQ-20, EQ-20, EQ-30, EQ-40, EQ-61,
-    2530, 2550, 2560, 2570, 2570, 2560, 2550, 2530, 
+    EQ-40, EQ-20, EQ-10, EQ- 0, EQ- 0, EQ-10, EQ-20, EQ-40,
-    2540, 2560, 2570, 2580, 2580, 2570, 2560, 2540, 
+    EQ-30, EQ-10, EQ- 0, EQ+10, EQ+10, EQ- 0, EQ-10, EQ-30,
-    2540, 2560, 2570, 2580, 2580, 2570, 2560, 2540, 
+    EQ-20, EQ- 0, EQ+10, EQ+20, EQ+20, EQ+10, EQ- 0, EQ-20,
-    2530, 2550, 2560, 2570, 2570, 2560, 2550, 2530, 
+    EQ-20, EQ- 0, EQ+10, EQ+20, EQ+20, EQ+10, EQ- 0, EQ-20,
-    2520, 2540, 2550, 2560, 2560, 2550, 2540, 2520, 
+    EQ-30, EQ-10, EQ- 0, EQ+10, EQ+10, EQ- 0, EQ-10, EQ-30,
-    2499, 2520, 2530, 2540, 2540, 2530, 2520, 2499
+    EQ-40, EQ-20, EQ-10, EQ- 0, EQ- 0, EQ-10, EQ-20, EQ-40,
+    EQ-61, EQ-40, EQ-30, EQ-20, EQ-20, EQ-30, EQ-40, EQ-61
   },
-  { // King
+  {// King
-    16, 78, 108, 139, 139, 108, 78, 16, 
+   //A    B    C    D    E    F    G    H
-    78, 139, 170, 200, 200, 170, 139, 78, 
+     16,  78, 108, 139, 139, 108,  78,  16,
-    108, 170, 200, 230, 230, 200, 170, 108, 
+     78, 139, 170, 200, 200, 170, 139,  78,
-    139, 200, 230, 261, 261, 230, 200, 139, 
+    108, 170, 200, 230, 230, 200, 170, 108,
-    139, 200, 230, 261, 261, 230, 200, 139, 
+    139, 200, 230, 261, 261, 230, 200, 139,
-    108, 170, 200, 230, 230, 200, 170, 108, 
+    139, 200, 230, 261, 261, 230, 200, 139,
-    78, 139, 170, 200, 200, 170, 139, 78, 
+    108, 170, 200, 230, 230, 200, 170, 108,
-    16, 78, 108, 139, 139, 108, 78, 16
+     78, 139, 170, 200, 200, 170, 139,  78,
+     16,  78, 108, 139, 139, 108,  78,  16
   }
 };
 

src/san.cpp

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -30,6 +31,7 @@
 #include "movepick.h"
 #include "san.h"
 
+extern SearchStack EmptySearchStack;
 
 ////
 //// Local definitions
@@ -48,8 +50,8 @@ 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);
 }
@@ -60,206 +62,222 @@ namespace {
 ////
 
 /// move_to_san() takes a position and a move as input, where it is assumed
-/// that the move is a legal move from the position.  The return value is
+/// 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;
-  }
-  else if(m == MOVE_NULL) {
-    str = "(null)";
-    return str;
-  }
-  else if(move_is_long_castle(m))
-    str = "O-O-O";
-  else if(move_is_short_castle(m))
-    str = "O-O";
-  else {
-    Square from, to;
-    Piece pc;
 
-    from = move_from(m);
+  if (m == MOVE_NONE)
-    to = move_to(m);
+      return "(none)";
-    pc = pos.piece_on(move_from(m));
+  else if (m == MOVE_NULL)
-
+      return "(null)";
-    str = "";
+  else if (move_is_long_castle(m))
-
+      san = "O-O-O";
-    if(type_of_piece(pc) == PAWN) {
+  else if (move_is_short_castle(m))
-      if(pos.move_is_capture(m))
+      san = "O-O";
-        str += file_to_char(square_file(move_from(m)));
+  else
-    }
+  {
-    else {
+      Piece pc = pos.piece_on(move_from(m));
-      str += piece_type_to_char(type_of_piece(pc), true);
+      if (type_of_piece(pc) != PAWN)
-
+      {
-      Ambiguity amb = move_ambiguity(pos, m);
+          san += piece_type_to_char(type_of_piece(pc), true);
-      switch(amb) {
+          Square from = move_from(m);
-
+          switch (move_ambiguity(pos, m)) {
-      case AMBIGUITY_NONE:
+          case AMBIGUITY_NONE:
-        break;
+            break;
-
+          case AMBIGUITY_FILE:
-      case AMBIGUITY_FILE:
+            san += file_to_char(square_file(from));
-        str += file_to_char(square_file(from));
+            break;
-        break;
+          case AMBIGUITY_RANK:
-
+            san += rank_to_char(square_rank(from));
-      case AMBIGUITY_RANK:
+            break;
-        str += rank_to_char(square_rank(from));
+          case AMBIGUITY_BOTH:
-        break;
+            san += square_to_string(from);
-
+            break;
-      case AMBIGUITY_BOTH:
+          default:
-        str += square_to_string(from);
+            assert(false);
-        break;
+          }
-
+      }
-      default:
+      if (pos.move_is_capture(m))
-        assert(false);
+      {
+          if (type_of_piece(pc) == PAWN)
+              san += file_to_char(square_file(move_from(m)));
+          san += "x";
+      }
+      san += square_to_string(move_to(m));
+      if (move_promotion(m))
+      {
+          san += '=';
+          san += piece_type_to_char(move_promotion(m), true);
       }
-    }
-
-    if(pos.move_is_capture(m))
-      str += "x";
-
-    str += square_to_string(move_to(m));
-
-    if(move_promotion(m)) {
-      str += "=";
-      str += piece_type_to_char(move_promotion(m), true);
-    }
   }
-
   // Is the move check?  We don't use pos.move_is_check(m) here, because
   // 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;
 }
 
 
 /// move_from_san() takes a position and a string as input, and tries to
-/// interpret the string as a move in short algebraic notation.  On success,
+/// interpret the string as a move in short algebraic notation. On success,
 /// 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, MOVE_NONE, MOVE_NONE,
+  MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
-                             MOVE_NONE, OnePly);
 
   // Castling moves
-  if(movestr == "O-O-O") {
+  if (movestr == "O-O-O" || movestr == "O-O-O+")
-    Move m;
+  {
-    while((m = mp.get_next_move()) != MOVE_NONE)
+      Move m;
-      if(move_is_long_castle(m) && pos.move_is_legal(m))
+      while ((m = mp.get_next_move()) != MOVE_NONE)
-        return m;
+          if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
-    return MOVE_NONE;
+              return m;
-  }
-  else if(movestr == "O-O") {
-    Move m;
-    while((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_short_castle(m) && pos.move_is_legal(m))
-        return m;
-    return MOVE_NONE;
-  }
 
-  // Normal moves
-  const char *cstr = movestr.c_str();
-  const char *c;
-  char *cc;
-  char str[10];
-  int i;
-
-  // Initialize str[] by making a copy of movestr with the characters
-  // 'x', '=', '+' and '#' removed.  
-  cc = str;
-  for(i=0, c=cstr; i<10 && *c!='\0' && *c!='\n' && *c!=' '; i++, c++)
-    if(!strchr("x=+#", *c)) {
-      *cc = strchr("nrq", *c)? toupper(*c) : *c;
-      cc++;
-    }
-  *cc = '\0';
-
-  int left = 0, right = strlen(str) - 1;
-  PieceType pt = NO_PIECE_TYPE, promotion;
-  Square to;
-  File fromFile = FILE_NONE;
-  Rank fromRank = RANK_NONE;
-
-  // Promotion?
-  if(strchr("BNRQ", str[right])) {
-    promotion = piece_type_from_char(str[right]);
-    right--;
-  }
-  else
-    promotion = NO_PIECE_TYPE;
-
-  // Find the moving piece:
-  if(left < right) {
-    if(strchr("BNRQK", str[left])) {
-      pt = piece_type_from_char(str[left]);
-      left++;
-    }
-    else
-      pt = PAWN;
-  }
-
-  // Find the to square:
-  if(left < right) {
-    if(str[right] < '1' || str[right] > '8' ||
-       str[right-1] < 'a' || str[right-1] > 'h')
       return MOVE_NONE;
-    to = make_square(file_from_char(str[right-1]), rank_from_char(str[right]));
-    right -= 2;
   }
-  else
+  else if (movestr == "O-O" || 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;
-
-  // Find the file and/or rank of the from square:
-  if(left <= right) {
-    if(strchr("abcdefgh", str[left])) {
-      fromFile = file_from_char(str[left]);
-      left++;
-    }
-    if(strchr("12345678", str[left]))
-      fromRank = rank_from_char(str[left]);
   }
 
-  // Look for a matching move:
+  // Normal moves. We use a simple FSM to parse the san string.
+  enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
+  static const std::string pieceLetters = "KQRBN";
+  PieceType pt = NO_PIECE_TYPE, promotion = NO_PIECE_TYPE;
+  File fromFile = FILE_NONE, toFile = FILE_NONE;
+  Rank fromRank = RANK_NONE, toRank = RANK_NONE;
+  Square to;
+  int state = START;
+
+  for (size_t i = 0; i < movestr.length(); i++)
+  {
+      char type, c = movestr[i];
+      if (pieceLetters.find(c) != std::string::npos)
+          type = 'P';
+      else if (c >= 'a' && c <= 'h')
+          type = 'F';
+      else if (c >= '1' && c <= '8')
+          type = 'R';
+      else
+          type = c;
+
+      switch (type) {
+      case 'P':
+          if (state == START)
+          {
+              pt = piece_type_from_char(c);
+              state = TO_FILE;
+          }
+          else if (state == PROMOTION)
+          {
+              promotion = piece_type_from_char(c);
+              state = (i < movestr.length() - 1) ? CHECK : END;
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'F':
+          if (state == START)
+          {
+              pt = PAWN;
+              fromFile = toFile = file_from_char(c);
+              state = TO_RANK;
+          }
+          else if (state == TO_FILE)
+          {
+              toFile = file_from_char(c);
+              state = TO_RANK;
+          }
+          else if (state == TO_RANK && toFile != FILE_NONE)
+          {
+              // Previous file was for disambiguation
+              fromFile = toFile;
+              toFile = file_from_char(c);
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'R':
+          if (state == TO_RANK)
+          {
+              toRank = rank_from_char(c);
+              state = (i < movestr.length() - 1) ? PROMOTION_OR_CHECK : END;
+          }
+          else if (state == TO_FILE && fromRank == RANK_NONE)
+          {
+              // It's a disambiguation rank instead of a file
+              fromRank = rank_from_char(c);
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'x': case 'X':
+          if (state == TO_RANK)
+          {
+              // Previous file was for disambiguation, or it's a pawn capture
+              fromFile = toFile;
+              state = TO_FILE;
+          }
+          else if (state != TO_FILE)
+              return MOVE_NONE;
+          break;
+      case '=':
+          if (state == PROMOTION_OR_CHECK)
+              state = PROMOTION;
+          else
+              return MOVE_NONE;
+          break;
+      case '+': case '#':
+          if (state == PROMOTION_OR_CHECK || state == CHECK)
+              state = END;
+          else
+              return MOVE_NONE;
+          break;
+      default:
+          return MOVE_NONE;
+          break;
+      }
+  }
+
+  if (state != END)
+      return MOVE_NONE;
+
+  // Look for a matching move
   Move m, move = MOVE_NONE;
+  to = make_square(toFile, toRank);
   int matches = 0;
-  
+
-  while((m = mp.get_next_move()) != MOVE_NONE) {
+  while ((m = mp.get_next_move()) != MOVE_NONE)
-    bool match = true;
+      if (   pos.type_of_piece_on(move_from(m)) == pt
-    if(pos.type_of_piece_on(move_from(m)) != pt)
+          && move_to(m) == to
-      match = false;
+          && move_promotion(m) == promotion
-    else if(move_to(m) != to)
+          && (fromFile == FILE_NONE || fromFile == square_file(move_from(m)))
-      match = false;
+          && (fromRank == RANK_NONE || fromRank == square_rank(move_from(m))))
-    else if(move_promotion(m) != promotion)
+      {
-      match = false;
+          move = m;
-    else if(fromFile != FILE_NONE && fromFile != square_file(move_from(m)))
+          matches++;
-      match = false;
+      }
-    else if(fromRank != RANK_NONE && fromRank != square_rank(move_from(m)))
+  return (matches == 1 ? move : MOVE_NONE);
-      match = false;
-    if(match) {
-      move = m;
-      matches++;
-    }
-  }
-  
-  if(matches == 1)
-    return move;
-  else
-    return MOVE_NONE;
 }
 
 
@@ -270,34 +288,31 @@ 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;
   std::string moveStr;
-  int length, maxLength;
+  size_t length = 0;
+  size_t maxLength = 80 - startColumn;
+  Position p(pos);
 
-  length = 0;
+  for (int i = 0; line[i] != MOVE_NONE; i++)
-  maxLength = 80 - startColumn;
+  {
+      moveStr = move_to_san(p, line[i]);
+      length += moveStr.length() + 1;
+      if (breakLines && length > maxLength)
+      {
+          s << '\n' << std::setw(startColumn) << ' ';
+          length = moveStr.length() + 1;
+      }
+      s << moveStr << ' ';
 
-  for(int i = 0; line[i] != MOVE_NONE; i++) {
+      if (line[i] == MOVE_NULL)
-    moveStr = move_to_san(p, line[i]);
+          p.do_null_move(u);
-    length += moveStr.length() + 1;
+      else
-    if(breakLines && length > maxLength) {
+          p.do_move(line[i], u);
-      s << "\n";
-      for(int j = 0; j < startColumn; j++)
-        s << " ";
-      length = moveStr.length() + 1;
-    }
-    s << moveStr << " ";
-
-    if(line[i] == MOVE_NULL)
-      p.do_null_move(u);
-    else
-      p.do_move(line[i], u);
   }
-
   return s.str();
 }
 
@@ -306,26 +321,26 @@ const std::string line_to_san(const Position &pos, Move line[], int startColumn,
 /// It is used to write search information to the log file (which is created
 /// when the UCI parameter "Use Search Log" is "true").
 
-const std::string pretty_pv(const Position &pos, int time, int depth,
+const std::string pretty_pv(const Position& pos, int time, int depth,
                             uint64_t nodes, Value score, Move pv[]) {
   std::stringstream s;
 
   // Depth
-  s << std::setw(2) << std::setfill(' ') << depth << "  ";
+  s << std::setw(2) << depth << "  ";
 
   // Score
   s << std::setw(8) << score_string(score);
 
   // Time
-  s << std::setw(8) << std::setfill(' ') << time_string(time) << " ";
+  s << std::setw(8) << time_string(time) << " ";
 
   // Nodes
-  if(nodes < 1000000ULL)
+  if (nodes < 1000000ULL)
-    s << std::setw(8) << std::setfill(' ') << nodes << " ";
+    s << std::setw(8) << nodes << " ";
-  else if(nodes < 1000000000ULL)
+  else if (nodes < 1000000000ULL)
-    s << std::setw(7) << std::setfill(' ') << nodes/1000ULL << 'k' << " ";
+    s << std::setw(7) << nodes/1000ULL << 'k' << " ";
   else
-    s << std::setw(7) << std::setfill(' ') << nodes/1000000ULL << 'M' << " ";
+    s << std::setw(7) << nodes/1000000ULL << 'M' << " ";
 
   // PV
   s << line_to_san(pos, pv, 30, true);
@@ -336,82 +351,80 @@ 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.
-    if(type_of_piece(pc) == KING)
+    if (type_of_piece(pc) == KING)
-      return AMBIGUITY_NONE;
+        return AMBIGUITY_NONE;
 
-    MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
+    MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
-                               MOVE_NONE, OnePly);
     Move mv, moveList[8];
-    int i, j, n;
 
-    n = 0;
+    int n = 0;
-    while((mv = mp.get_next_move()) != MOVE_NONE)
+    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.move_is_legal(mv))
+            moveList[n++] = mv;
-        moveList[n++] = mv;
-    if(n == 1)
-      return AMBIGUITY_NONE;
 
-    j = 0;
+    if (n == 1)
-    for(i = 0; i < n; i++)
+        return AMBIGUITY_NONE;
-      if(square_file(move_from(moveList[i])) == square_file(from))
-        j++;
-    if(j == 1)
-      return AMBIGUITY_FILE;
 
-    j = 0;
+    int f = 0, r = 0;
-    for(i = 0; i < n; i++)
+    for (int i = 0; i < n; i++)
-      if(square_rank(move_from(moveList[i])) == square_rank(from))
+    {
-        j++;
+        if (square_file(move_from(moveList[i])) == square_file(from))
-    if(j == 1)
+            f++;
-      return AMBIGUITY_RANK;
+
+        if (square_rank(move_from(moveList[i])) == square_rank(from))
+            r++;
+    }
+    if (f == 1)
+        return AMBIGUITY_FILE;
+
+    if (r == 1)
+        return AMBIGUITY_RANK;
 
     return AMBIGUITY_BOTH;
   }
 
 
   const std::string time_string(int milliseconds) {
+
     std::stringstream s;
+    s << std::setfill('0');
 
-    int hours = milliseconds / (1000 * 60 * 60);
+    int hours = milliseconds / (1000*60*60);
-    int minutes = (milliseconds - hours*1000*60*60) / (60*1000);
+    int minutes = (milliseconds - hours*1000*60*60) / (1000*60);
-    int seconds = (milliseconds - hours*1000*60*60 - minutes*60*1000) / 1000;
+    int seconds = (milliseconds - hours*1000*60*60 - minutes*1000*60) / 1000;
 
-    if(hours)
+    if (hours)
-      s << hours << ':';
+        s << hours << ':';
-    s << std::setw(2) << std::setfill('0') << minutes << ':';
+
-    s << std::setw(2) << std::setfill('0') << seconds;
+    s << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
-    
     return s.str();
   }
 
 
   const std::string score_string(Value v) {
+
     std::stringstream s;
 
-    if(abs(v) >= VALUE_MATE - 200) {
+    if (v >= VALUE_MATE - 200)
-      if(v < 0)
-        s << "-#" << (VALUE_MATE + v) / 2;
-      else
         s << "#" << (VALUE_MATE - v + 1) / 2;
-    }
+    else if(v <= -VALUE_MATE + 200)
-    else {
+        s << "-#" << (VALUE_MATE + v) / 2;
-      float floatScore = float(v) / float(PawnValueMidgame);
+    else
-      if(v >= 0)
+    {
-        s << '+';
+        float floatScore = float(v) / float(PawnValueMidgame);
-      s << std::setprecision(2) << std::fixed << floatScore;
+        if (v >= 0)
+            s << '+';
+
+        s << std::setprecision(2) << std::fixed << floatScore;
     }
     return s.str();
   }
-  
 }

src/san.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -35,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)

src/scale.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/search.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -40,6 +41,7 @@
 
 const int PLY_MAX = 100;
 const int PLY_MAX_PLUS_2 = 102;
+const int KILLER_MAX = 2;
 
 
 ////
@@ -55,8 +57,9 @@ struct SearchStack {
   Move pv[PLY_MAX];
   Move currentMove;
   Value currentMoveCaptureValue;
-  Move mateKiller, killer1, killer2;
+  Move mateKiller;
   Move threatMove;
+  Move killers[KILLER_MAX];
   Depth reduction;
 };
 
@@ -65,10 +68,9 @@ struct SearchStack {
 //// Global variables
 ////
 
+extern SearchStack EmptySearchStack;
 extern TranspositionTable TT;
-
 extern int ActiveThreads;
-
 extern Lock SMPLock;
 
 // Perhaps better to make H local, and pass as parameter to MovePicker?
@@ -81,9 +83,9 @@ extern History H;
 
 extern void init_threads();
 extern void stop_threads();
-extern void think(const Position &pos, bool infinite, bool ponder, int time,
+extern void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
-                  int increment, int movesToGo, int maxDepth, int maxNodes,
+                  int time[], int increment[], int movesToGo, int maxDepth, 
-                  int maxTime, Move searchMoves[]);
+                  int maxNodes, int maxTime, Move searchMoves[]);
 extern int64_t nodes_searched();
 
 

src/square.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -22,7 +23,6 @@
 ////
 
 #include <cassert>
-#include <cstdio>
 #include <string>
 
 #include "square.h"

src/square.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -24,6 +25,7 @@
 //// Includes
 ////
 
+#include <cstdlib> // for abs()
 #include <string>
 
 #include "color.h"
@@ -129,7 +131,7 @@ inline Square relative_square(Color c, Square s) {
   return Square(int(s) ^ (int(c) * FlipMask));
 }
 
-inline Rank pawn_rank(Color c, Square s) {
+inline Rank relative_rank(Color c, Square s) {
   return square_rank(relative_square(c, s));
 }
 

src/thread.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/tt.cpp

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -23,6 +24,7 @@
 
 #include <cassert>
 #include <cmath>
+#include <cstring>
 
 #include "tt.h"
 
@@ -34,17 +36,19 @@
 /// Constructor
 
 TranspositionTable::TranspositionTable(unsigned mbSize) {
+
   size = 0;
   generation = 0;
   writes = 0;
   entries = 0;
-  this->set_size(mbSize);
+  set_size(mbSize);
 }
 
 
 /// Destructor
 
 TranspositionTable::~TranspositionTable() {
+
   delete [] entries;
 }
 
@@ -53,25 +57,28 @@ TranspositionTable::~TranspositionTable() {
 /// measured in megabytes.
 
 void TranspositionTable::set_size(unsigned mbSize) {
-  unsigned newSize;
 
   assert(mbSize >= 4 && mbSize <= 1024);
 
-  for(newSize = 1024; newSize * 4 * (sizeof(TTEntry)) <= (mbSize << 20);
+  unsigned newSize = 1024;
-      newSize *= 2);
-  newSize /= 2;
 
-  if(newSize != size) {
+  // We store a cluster of 4 TTEntry for each position and newSize is
+  // the maximum number of storable positions
+  for ( ; newSize * 4 * (sizeof(TTEntry)) <= (mbSize << 20); newSize *= 2);
+  newSize /= 2;
+  if (newSize != size)
+  {
     size = newSize;
     delete [] entries;
     entries = new TTEntry[size * 4];
-    if(entries == NULL) {
+    if (!entries)
+    {
       std::cerr << "Failed to allocate " << mbSize
                 << " MB for transposition table."
                 << std::endl;
       exit(EXIT_FAILURE);
     }
-    this->clear();
+    clear();
   }
 }
 
@@ -82,6 +89,7 @@ void TranspositionTable::set_size(unsigned mbSize) {
 /// Perhaps we should also clear it when the "ucinewgame" command is recieved?
 
 void TranspositionTable::clear() {
+
   memset(entries, 0, size * 4 * sizeof(TTEntry));
 }
 
@@ -99,22 +107,26 @@ void TranspositionTable::store(const Position &pos, Value v, Depth d,
                                Move m, ValueType type) {
   TTEntry *tte, *replace;
 
-  tte = replace = entries + int(pos.get_key() & (size - 1)) * 4;
+  tte = replace = first_entry(pos);
-  for(int i = 0; i < 4; i++) {
+  for (int i = 0; i < 4; i++, tte++)
-    if((tte+i)->key() == pos.get_key()) {
+  {
-      if(m == MOVE_NONE)
+    if (!tte->key() || tte->key() == pos.get_key()) // empty or overwrite old
-        m = (tte+i)->move();
+    {
-      *(tte+i) = TTEntry(pos.get_key(), v, type, d, m, generation);
+        if (m == MOVE_NONE)
-      return;
+            m = tte->move();
+
+        *tte = TTEntry(pos.get_key(), v, type, d, m, generation);
+        return;
     }
-    if(replace->generation() == generation) {
+    else if (i == 0)  // replace would be a no-op in this common case
-      if((tte+i)->generation() != generation ||
+        continue;
-         (tte+i)->depth() < replace->depth())
+
-        replace = tte+i;
+    int c1 = (replace->generation() == generation ?  2 : 0);
-    }
+    int c2 = (tte->generation() == generation ? -2 : 0);
-    else if((tte+i)->generation() != generation &&
+    int c3 = (tte->depth() < replace->depth() ?  1 : 0);
-            (tte+i)->depth() < replace->depth())
+
-      replace = tte+i;
+    if (c1 + c2 + c3 > 0)
+        replace = tte;
   }
   *replace = TTEntry(pos.get_key(), v, type, d, m, generation);
   writes++;
@@ -122,58 +134,55 @@ void TranspositionTable::store(const Position &pos, Value v, Depth d,
 
 
 /// TranspositionTable::retrieve looks up the current position in the
-/// transposition table, and extracts the value, value type, depth and
+/// transposition table. Returns a pointer to the TTEntry or NULL
-/// best move if the position is found.  The return value is true if
+/// if position is not found.
-/// the position is found, and false if it isn't.
 
-bool TranspositionTable::retrieve(const Position &pos, Value *value,
+const TTEntry* TranspositionTable::retrieve(const Position &pos) const {
-                                  Depth *d, Move *move,
-                                  ValueType *type) const {
-  TTEntry *tte;
-  bool found = false;
 
-  tte = entries + int(pos.get_key() & (size - 1)) * 4;
+  TTEntry *tte = first_entry(pos);
-  for(int i = 0; i < 4 && !found ; i++)
+
-    if((tte+i)->key() == pos.get_key()) {
+  for (int i = 0; i < 4; i++, tte++)
-      tte = tte + i;
+  {
-      found = true;
+      if (tte->key() == pos.get_key())
-    }
+          return tte;
-  if(!found) {
-    *move = MOVE_NONE;
-    return false;
   }
-
+  return NULL;
-  *value = tte->value();
-  *type = tte->type();
-  *d = tte->depth();
-  *move = tte->move();
-
-  return true;
 }
 
 
+/// TranspositionTable::first_entry returns a pointer to the first
+/// entry of a cluster given a position.
+
+inline TTEntry* TranspositionTable::first_entry(const Position &pos) const {
+
+  return entries + (int(pos.get_key() & (size - 1)) << 2);
+}
+
 /// TranspositionTable::new_search() is called at the beginning of every new
 /// search.  It increments the "generation" variable, which is used to
 /// distinguish transposition table entries from previous searches from
 /// entries from the current search.
 
 void TranspositionTable::new_search() {
+
   generation++;
   writes = 0;
 }
 
 
-/// TranspositionTable::insert_pv() is called at the end of a search 
+/// TranspositionTable::insert_pv() is called at the end of a search
 /// iteration, and inserts the PV back into the PV.  This makes sure the
 /// old PV moves are searched first, even if the old TT entries have been
 /// overwritten.
 
 void TranspositionTable::insert_pv(const Position &pos, Move pv[]) {
+
   UndoInfo u;
   Position p(pos);
 
-  for(int i = 0; pv[i] != MOVE_NONE; i++) {
+  for (int i = 0; pv[i] != MOVE_NONE; i++)
-    this->store(p, VALUE_NONE, Depth(0), pv[i], VALUE_TYPE_NONE);
+  {
+    store(p, VALUE_NONE, Depth(0), pv[i], VALUE_TYPE_NONE);
     p.do_move(pv[i], u);
   }
 }
@@ -184,6 +193,7 @@ void TranspositionTable::insert_pv(const Position &pos, Move pv[]) {
 /// It is used to display the "info hashfull ..." information in UCI.
 
 int TranspositionTable::full() {
+
   double N = double(size) * 4.0;
   return int(1000 * (1 - exp(writes * log(1.0 - 1.0/N))));
 }
@@ -195,36 +205,9 @@ TTEntry::TTEntry() {
 }
 
 TTEntry::TTEntry(Key k, Value v, ValueType t, Depth d, Move m,
-                 int generation) {
+                 int generation) :
-  key_ = k;
+  key_ (k), data((m & 0x7FFFF) | (t << 20) | (generation << 23)),
-  data = (m & 0x7FFFF) | (t << 20) | (generation << 23);
+  value_(v), depth_(int16_t(d)) {}
-  value_ = v;
-  depth_ = int16_t(d);
-}
 
 
-/// Functions for extracting data from TTEntry objects.
 
-Key TTEntry::key() const {
-  return key_;
-}
-
-Depth TTEntry::depth() const {
-  return Depth(depth_);
-}
-
-Move TTEntry::move() const {
-  return Move(data & 0x7FFFF);
-}
-
-Value TTEntry::value() const {
-  return Value(value_);
-}
-
-ValueType TTEntry::type() const {
-  return ValueType((data >> 20) & 3);
-}
-
-int TTEntry::generation() const {
-  return (data >> 23);
-}

src/tt.h

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -40,21 +41,20 @@ class TTEntry {
 public:
   TTEntry();
   TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation);
-  Key key() const;
+  Key key() const { return key_; }
-  Depth depth() const;
+  Depth depth() const { return Depth(depth_); }
-  Move move() const;
+  Move move() const { return Move(data & 0x7FFFF); }
-  Value value() const;
+  Value value() const { return Value(value_); }
-  ValueType type() const;
+  ValueType type() const { return ValueType((data >> 20) & 3); }
-  int generation() const;
+  int generation() const { return (data >> 23); }
 
-private:  
+private:
   Key key_;
   uint32_t data;
   int16_t value_;
   int16_t depth_;
 };
 
-
 /// The transposition table class.  This is basically just a huge array
 /// containing TTEntry objects, and a few methods for writing new entries
 /// and reading new ones.
@@ -67,13 +67,14 @@ public:
   void set_size(unsigned mbSize);
   void clear();
   void store(const Position &pos, Value v, Depth d, Move m, ValueType type);
-  bool retrieve(const Position &pos, Value *value, Depth *d, Move *move,
+  const TTEntry* retrieve(const Position &pos) const;
-                ValueType *type) const;
   void new_search();
   void insert_pv(const Position &pos, Move pv[]);
   int full();
 
 private:
+  inline TTEntry* first_entry(const Position &pos) const;
+
   unsigned size;
   int writes;
   TTEntry* entries;

src/types.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/uci.cpp

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -22,6 +23,7 @@
 ////
 
 #include <iostream>
+#include <sstream>
 #include <string>
 
 #include "book.h"
@@ -42,30 +44,10 @@
 
 namespace {
 
-  // UCIInputParser is a class for parsing UCI input.  The class is
+  // UCIInputParser is a class for parsing UCI input.  The class
-  // very simple, and basically just consist of a constant input
+  // is actually a string stream built on a given input string.
-  // string and a current location in the string.  There are methods
-  // for checking if we are at the end of the line, for getting the
-  // next token (defined as any whitespace-delimited sequence of
-  // characters), and for getting the rest of the line as a single
-  // string.
-
-  class UCIInputParser {
-
-  public:
-    UCIInputParser(const std::string &line);
-    std::string get_next_token();
-    std::string get_rest_of_line();
-    bool at_end_of_line();
-
-  private:
-    const std::string &inputLine;
-    int length, currentIndex;
-
-    void skip_whitespace();
-
-  };
 
+  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()
@@ -73,7 +55,7 @@ namespace {
   Position RootPosition;
 
   // Local functions
-  void wait_for_command();
+  void get_command();
   void handle_command(const std::string &command);
   void set_option(UCIInputParser &uip);
   void set_position(UCIInputParser &uip);
@@ -91,8 +73,11 @@ namespace {
 /// command.
 
 void uci_main_loop() {
+
   RootPosition.from_fen(StartPosition);
-  while(1) wait_for_command();
+
+  while (1)
+      get_command();
 }
 
 
@@ -102,80 +87,19 @@ void uci_main_loop() {
 
 namespace {
 
-  ///
+  // get_command() waits for a command from the user, and passes
-  /// Implementation of the UCIInputParser class.
+  // this command to handle_command.  get_command also intercepts
-  ///
-
-  // Constructor for the UCIInputParser class.  The constructor takes a 
-  // text string containing a single UCI command as input.
-
-  UCIInputParser::UCIInputParser(const std::string &line) : inputLine(line) {
-    this->currentIndex = 0;
-    this->length = line.length();
-  }
-
-
-  // UCIInputParser::skip_whitspace() skips any number of whitespace
-  // characters from the current location in an input string.
-
-  void UCIInputParser::skip_whitespace() {
-    while(isspace((int)(unsigned char)this->inputLine[this->currentIndex]))
-      this->currentIndex++;
-  }
-
-
-  // UCIInputParser::get_next_token() gets the next token in an UCI
-  // command.  A 'token' in an UCI command is simply any
-  // whitespace-delimited sequence of characters.
-
-  std::string UCIInputParser::get_next_token() {
-    int i, j;
-
-    this->skip_whitespace();
-    for(i = j = this->currentIndex; 
-        j < this->length && !isspace(this->inputLine[j]); 
-        j++);
-    this->currentIndex = j;
-    this->skip_whitespace();
-
-    std::string str = this->inputLine.substr(i, j - i);
-
-    return str;
-  }
-
-
-  // UCIInputParser::get_rest_of_line() returns the rest of the input
-  // line (from the current location) as a single string.
-
-  std::string UCIInputParser::get_rest_of_line() {
-    this->skip_whitespace();
-    return this->inputLine.substr(this->currentIndex, this->length);
-  }
-
-
-  // UCIInputParser::at_end_of_line() tests whether we have reached the
-  // end of the input string, i.e. if any more input remains to be
-  // parsed.
-
-  bool UCIInputParser::at_end_of_line() {
-    return this->currentIndex == this->length;
-  }
-
-
-  /// 
-  /// Other functions
-  ///
-
-
-  // wait_for_command() waits for a command from the user, and passes
-  // this command to handle_command.  wait_for_command also intercepts
   // EOF from stdin, by translating EOF to the "quit" command.  This
-  // ensures that Glaurung exits gracefully if the GUI dies
+  // ensures that Stockfish exits gracefully if the GUI dies
   // unexpectedly.
 
-  void wait_for_command() {
+  void get_command() {
+
     std::string command;
-    if(!std::getline(std::cin, command)) command = "quit";
+
+    if (!std::getline(std::cin, command))
+        command = "quit";
+
     handle_command(command);
   }
 
@@ -184,137 +108,162 @@ namespace {
   // 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 s = uip.get_next_token();
 
-    if(s == "quit") {
+  void handle_command(const std::string &command) {
-      OpeningBook.close();
+
-      stop_threads();
+    UCIInputParser uip(command);
-      quit_eval();
+    std::string token;
-      exit(0);
+
+    uip >> token; // operator >> skips any whitespace
+
+    if (token == "quit")
+    {
+        OpeningBook.close();
+        stop_threads();
+        quit_eval();
+        exit(0);
     }
-    else if(s == "uci") {
+    else if (token == "uci")
-      std::cout << "id name " << engine_name() << std::endl;
+    {
-      std::cout << "id author Tord Romstad" << std::endl;
+        std::cout << "id name " << engine_name() << std::endl
-      print_uci_options();
+                  << "id author Tord Romstad, Marco Costalba"
-      std::cout << "uciok" << std::endl;
+                  << std::endl;
+        print_uci_options();
+        std::cout << "uciok" << std::endl;
     }
-    else if(s == "ucinewgame") {
+    else if (token == "ucinewgame")
-      TT.clear();
+    {
-      Position::init_piece_square_tables();
+        TT.clear();
-      RootPosition.from_fen(StartPosition);
+        Position::init_piece_square_tables();
+        RootPosition.from_fen(StartPosition);
     }
-    else if(s == "isready")
+    else if (token == "isready")
-      std::cout << "readyok" << std::endl;
+        std::cout << "readyok" << std::endl;
-    else if(s == "position")
+    else if (token == "position")
-      set_position(uip);
+        set_position(uip);
-    else if(s == "setoption")
+    else if (token == "setoption")
-      set_option(uip);
+        set_option(uip);
-    else if(s == "go")
+    else if (token == "go")
-      go(uip);
+        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(s == "d")
+    else if (token == "d")
-      RootPosition.print();
+        RootPosition.print();
-    else if(s == "flip") {
+    else if (token == "flip")
-      Position p(RootPosition);
+    {
-      RootPosition.flipped_copy(p);
+        Position p(RootPosition);
+        RootPosition.flipped_copy(p);
     }
-    else if(s == "eval") {
+    else if (token == "eval")
-      EvalInfo ei;
+    {
-      std::cout << "Incremental mg: " << RootPosition.mg_value()
+        EvalInfo ei;
-                << std::endl;
+        std::cout << "Incremental mg: " << RootPosition.mg_value()
-      std::cout << "Incremental eg: " << RootPosition.eg_value()
+                  << std::endl;
-                << std::endl;
+        std::cout << "Incremental eg: " << RootPosition.eg_value()
-      std::cout << "Full eval: "
+                  << std::endl;
-                << evaluate(RootPosition, ei, 0)
+        std::cout << "Full eval: "
-                << std::endl;
+                  << evaluate(RootPosition, ei, 0)
+                  << std::endl;
     }
-    else if(s == "key") {
+    else if (token == "key")
-      std::cout << "key: " << RootPosition.get_key()
+    {
-                << " material key: " << RootPosition.get_material_key()
+        std::cout << "key: " << RootPosition.get_key()
-                << " pawn key: " << RootPosition.get_pawn_key()
+                  << " material key: " << RootPosition.get_material_key()
-                << std::endl;
+                  << " pawn key: " << RootPosition.get_pawn_key()
+                  << std::endl;
     }
-    else {
+    else
-      std::cout << "Unknown command: " << command << std::endl;
+    {
-      while(!uip.at_end_of_line()) {
+        std::cout << "Unknown command: " << command << std::endl;
-        std::cout << uip.get_next_token() << std::endl;
+        while (!uip.eof())
-      }
+        {
+            uip >> token;
+            std::cout << token << std::endl;
+        }
     }
   }
 
 
-  // set_position() is called when Glaurung receives the "position" UCI
+  // 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;
 
-    token = uip.get_next_token();
+    uip >> token; // operator >> skips any whitespace
-    if(token == "startpos")
+
-      RootPosition.from_fen(StartPosition);
+    if (token == "startpos")
-    else if(token == "fen") {
+        RootPosition.from_fen(StartPosition);
-      std::string fen;
+    else if (token == "fen")
-      while(token != "moves" && !uip.at_end_of_line()) {
+    {
-        token = uip.get_next_token();
+        std::string fen;
-        fen += token;
+        while (token != "moves" && !uip.eof())
-        fen += ' ';
+        {
-      }
+          uip >> token;
-      RootPosition.from_fen(fen);
+          fen += token;
+          fen += ' ';
+        }
+        RootPosition.from_fen(fen);
     }
 
-    if(!uip.at_end_of_line()) {
+    if (!uip.eof())
-      if(token != "moves")
+    {
-        token = uip.get_next_token();
+        if (token != "moves")
-      if(token == "moves") {
+          uip >> token;
-        Move move;
+        if (token == "moves")
-        UndoInfo u;
+        {
-        while(!uip.at_end_of_line()) {
+            Move move;
-          token = uip.get_next_token();
+            UndoInfo u;
-          move = move_from_string(RootPosition, token);
+            while (!uip.eof())
-          RootPosition.do_move(move, u);
+            {
-          if(RootPosition.rule_50_counter() == 0)
+                uip >> token;
-            RootPosition.reset_game_ply();
+                move = move_from_string(RootPosition, token);
+                RootPosition.do_move(move, u);
+                if (RootPosition.rule_50_counter() == 0)
+                    RootPosition.reset_game_ply();
+            }
         }
-      }
     }
   }
 
 
-  // set_option() is called when Glaurung receives the "setoption" UCI
+  // 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;
+
-    if(!uip.at_end_of_line()) {
+    std::string token, name;
-      token = uip.get_next_token();
+
-      if(token == "name" && !uip.at_end_of_line()) {
+    uip >> token;
-        std::string name = uip.get_next_token();
+    if (token == "name")
-        std::string nextToken;
+    {
-        while(!uip.at_end_of_line()
+        uip >> name;
-              && (nextToken = uip.get_next_token()) != "value")
+        uip >> token;
-          name += (" " + nextToken);
+        while (!uip.eof() && token != "value")
-        if(nextToken == "value")
+        {
-          set_option_value(name, uip.get_rest_of_line());
+          name += (" " + token);
-        else
+          uip >> token;
-          push_button(name);
+        }
-      }
+        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 Glaurung receives the "go" UCI command.  The
+  // 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
@@ -323,69 +272,56 @@ namespace {
   // parameters.
 
   void go(UCIInputParser &uip) {
+
     std::string token;
-    int time[2] = {0, 0}, inc[2] = {0, 0}, movesToGo = 0, depth = 0, nodes = 0;
+
-    int moveTime = 0;
+    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.at_end_of_line()) {
+    while (!uip.eof())
-      token = uip.get_next_token();
+    {
+        uip >> token;
 
-      if(token == "infinite")
+        if (token == "infinite")
-        infinite = true;
+            infinite = true;
-      else if(token == "ponder")
+        else if (token == "ponder")
-        ponder = true;
+            ponder = true;
-      else if(token == "wtime") {
+        else if (token == "wtime")
-        if(!uip.at_end_of_line())
+            uip >> time[0];
-          time[0] = atoi(uip.get_next_token().c_str());
+        else if (token == "btime")
-      }
+            uip >> time[1];
-      else if(token == "btime") {
+        else if (token == "winc")
-        if(!uip.at_end_of_line())
+            uip >> inc[0];
-          time[1] = atoi(uip.get_next_token().c_str());
+        else if (token == "binc")
-      }
+            uip >> inc[1];
-      else if(token == "winc") {
+        else if (token == "movestogo")
-        if(!uip.at_end_of_line())
+            uip >> movesToGo;
-          inc[0] = atoi(uip.get_next_token().c_str());
+        else if (token == "depth")
-      }
+            uip >> depth;
-      else if(token == "binc") {
+        else if (token == "nodes")
-        if(!uip.at_end_of_line())
+            uip >> nodes;
-          inc[1] = atoi(uip.get_next_token().c_str());
+        else if (token == "movetime")
-      }
+            uip >> moveTime;
-      else if(token == "movestogo") {
+        else if (token == "searchmoves")
-        if(!uip.at_end_of_line())
+        {
-          movesToGo = atoi(uip.get_next_token().c_str());
+            int numOfMoves = 0;
-      }
+            while (!uip.eof())
-      else if(token == "depth") {
+            {
-        if(!uip.at_end_of_line())
+                uip >> token;
-          depth = atoi(uip.get_next_token().c_str());
+                searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
-      }
+            }
-      else if(token == "nodes") {
+            searchMoves[numOfMoves] = MOVE_NONE;
-        if(!uip.at_end_of_line())
-          nodes = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "movetime") {
-        if(!uip.at_end_of_line())
-          moveTime = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "searchmoves" && !uip.at_end_of_line()) {
-        int numOfMoves = 0;
-        while(!uip.at_end_of_line()) {
-          token = uip.get_next_token();
-          searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
         }
-        searchMoves[numOfMoves] = MOVE_NONE;
-      }
     }
 
-    if(moveTime)
+    if (moveTime)
-      infinite = true;  // HACK
+        infinite = true;  // HACK
 
-    think(RootPosition, infinite, ponder, time[RootPosition.side_to_move()],
+    think(RootPosition, infinite, ponder, RootPosition.side_to_move(), time,
-          inc[RootPosition.side_to_move()], movesToGo, depth, nodes, moveTime,
+          inc, movesToGo, depth, nodes, moveTime, searchMoves);
-          searchMoves);
   }
-  
 }

src/uci.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/ucioption.cpp

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
-  
+
-  Glaurung is distributed in the hope that it will be useful,
+  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/>.
 */
@@ -22,8 +23,9 @@
 ////
 
 #include <cassert>
-#include <cstdarg>
+#include <string>
-#include <cstdio>
+#include <sstream>
+#include <vector>
 
 #include "misc.h"
 #include "thread.h"
@@ -47,93 +49,159 @@ namespace {
   /// Types
   ///
 
-  enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON, OPTION_TYPE_NONE};
+  enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON };
+
+  typedef std::vector<std::string> ComboValues;
 
   struct Option {
-    char name[50], defaultValue[300], currentValue[300];
+
+    std::string name, defaultValue, currentValue;
     OptionType type;
     int minValue, maxValue;
-    char comboValues[8][64];
+    ComboValues comboValues;
+
+    Option(const char* name, const char* defaultValue, OptionType = STRING);
+    Option(const char* name, bool defaultValue, OptionType = CHECK);
+    Option(const char* name, int defaultValue, int minValue, int maxValue);
   };
-    
+
+  typedef std::vector<Option> Options;
+
+  ///
+  /// Constants
+  ///
+
+  // load_defaults populates the options vector with the hard
+  // coded names and default values.
+
+  void load_defaults(Options& o) {
+
+    o.push_back(Option("Use Search Log", false));
+    o.push_back(Option("Search Log Filename", "SearchLog.txt"));
+    o.push_back(Option("Book File", "book.bin"));
+    o.push_back(Option("Mobility (Middle Game)", 100, 0, 200));
+    o.push_back(Option("Mobility (Endgame)", 100, 0, 200));
+    o.push_back(Option("Pawn Structure (Middle Game)", 100, 0, 200));
+    o.push_back(Option("Pawn Structure (Endgame)", 100, 0, 200));
+    o.push_back(Option("Passed Pawns (Middle Game)", 100, 0, 200));
+    o.push_back(Option("Passed Pawns (Endgame)", 100, 0, 200));
+    o.push_back(Option("Aggressiveness", 100, 0, 200));
+    o.push_back(Option("Cowardice", 100, 0, 200));
+    o.push_back(Option("King Safety Curve", "Quadratic", COMBO));
+
+       o.back().comboValues.push_back("Quadratic");
+       o.back().comboValues.push_back("Linear");  /*, "From File"*/
+
+    o.push_back(Option("King Safety Coefficient", 40, 1, 100));
+    o.push_back(Option("King Safety X Intercept", 0, 0, 20));
+    o.push_back(Option("King Safety Max Slope", 30, 10, 100));
+    o.push_back(Option("King Safety Max Value", 500, 100, 1000));
+    o.push_back(Option("Queen Contact Check Bonus", 4, 0, 8));
+    o.push_back(Option("Rook Contact Check Bonus", 2, 0, 4));
+    o.push_back(Option("Queen Check Bonus", 2, 0, 4));
+    o.push_back(Option("Rook Check Bonus", 1, 0, 4));
+    o.push_back(Option("Bishop Check Bonus", 1, 0, 4));
+    o.push_back(Option("Knight Check Bonus", 1, 0, 4));
+    o.push_back(Option("Discovered Check Bonus", 3, 0, 8));
+    o.push_back(Option("Mate Threat Bonus", 3, 0, 8));
+    o.push_back(Option("Check Extension (PV nodes)", 2, 0, 2));
+    o.push_back(Option("Check Extension (non-PV nodes)", 1, 0, 2));
+    o.push_back(Option("Single Reply Extension (PV nodes)", 2, 0, 2));
+    o.push_back(Option("Single Reply Extension (non-PV nodes)", 2, 0, 2));
+    o.push_back(Option("Mate Threat Extension (PV nodes)", 0, 0, 2));
+    o.push_back(Option("Mate Threat Extension (non-PV nodes)", 0, 0, 2));
+    o.push_back(Option("Pawn Push to 7th Extension (PV nodes)", 1, 0, 2));
+    o.push_back(Option("Pawn Push to 7th Extension (non-PV nodes)", 1, 0, 2));
+    o.push_back(Option("Passed Pawn Extension (PV nodes)", 1, 0, 2));
+    o.push_back(Option("Passed Pawn Extension (non-PV nodes)", 0, 0, 2));
+    o.push_back(Option("Pawn Endgame Extension (PV nodes)", 2, 0, 2));
+    o.push_back(Option("Pawn Endgame Extension (non-PV nodes)", 2, 0, 2));
+    o.push_back(Option("Full Depth Moves (PV nodes)", 14, 1, 100));
+    o.push_back(Option("Full Depth Moves (non-PV nodes)", 3, 1, 100));
+    o.push_back(Option("Threat Depth", 5, 0, 100));
+    o.push_back(Option("Selective Plies", 7, 0, 10));
+    o.push_back(Option("Null driven IID", true));
+    o.push_back(Option("Futility Pruning (Main Search)", true));
+    o.push_back(Option("Futility Pruning (Quiescence Search)", true));
+    o.push_back(Option("Futility Margin 0", 50, 0, 1000));
+    o.push_back(Option("Futility Margin 1", 100, 0, 1000));
+    o.push_back(Option("Futility Margin 2", 300, 0, 1000));
+    o.push_back(Option("Maximum Razoring Depth", 3, 0, 4));
+    o.push_back(Option("Razoring Margin", 300, 150, 600));
+    o.push_back(Option("LSN filtering", false));
+    o.push_back(Option("LSN Time Margin (sec)", 4, 1, 10));
+    o.push_back(Option("LSN Value Margin", 200, 100, 600));
+    o.push_back(Option("Randomness", 0, 0, 10));
+    o.push_back(Option("Minimum Split Depth", 4, 4, 7));
+    o.push_back(Option("Maximum Number of Threads per Split Point", 5, 4, 8));
+    o.push_back(Option("Threads", 1, 1, 8));
+    o.push_back(Option("Hash", 32, 4, 4096));
+    o.push_back(Option("Clear Hash", false, BUTTON));
+    o.push_back(Option("Ponder", true));
+    o.push_back(Option("OwnBook", true));
+    o.push_back(Option("MultiPV", 1, 1, 500));
+    o.push_back(Option("UCI_ShowCurrLine", false));
+    o.push_back(Option("UCI_Chess960", false));
+  }
 
   ///
   /// Variables
   ///
 
-  Option Options[] = {
+  Options options;
-    { "Use Search Log", "false", "false", CHECK, 0, 0, {""} },
-    { "Search Log Filename", "SearchLog.txt", "SearchLog.txt", STRING, 0, 0, {""} },
-    { "Book File", "book.bin", "book.bin", STRING, 0, 0, {""} },
-    { "Mobility (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Mobility (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Pawn Structure (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Pawn Structure (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Passed Pawns (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Passed Pawns (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Aggressiveness", "100", "100", SPIN, 0, 200, {""} },
-    { "Cowardice", "100", "100", SPIN, 0, 200, {""} },
-    { "King Safety Curve", "Quadratic", "Quadratic", COMBO, 0, 0,
-      { "Quadratic", "Linear" /*, "From File"*/ } },
-    { "King Safety Coefficient", "40", "40", SPIN, 1, 100 , {""} },
-    { "King Safety X Intercept", "0", "0", SPIN, 0, 20, {""} },
-    { "King Safety Max Slope", "30", "30", SPIN, 10, 100, {""} },
-    { "King Safety Max Value", "500", "500", SPIN, 100, 1000, {""} },
-    { "Queen Contact Check Bonus", "4", "4", SPIN, 0, 8, {""} },
-    { "Rook Contact Check Bonus", "2", "2", SPIN, 0, 4, {""} },
-    { "Queen Check Bonus", "2", "2", SPIN, 0, 4, {""} },
-    { "Rook Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Bishop Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Knight Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Discovered Check Bonus", "3", "3", SPIN, 0, 8, {""} },
-    { "Mate Threat Bonus", "3", "3", SPIN, 0, 8, {""} },
-    { "Check Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Check Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Single Reply Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Single Reply Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Mate Threat Extension (PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Mate Threat Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Pawn Push to 7th Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Pawn Push to 7th Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Passed Pawn Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Passed Pawn Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Pawn Endgame Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Pawn Endgame Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Full Depth Moves (PV nodes)", "14", "14", SPIN, 1, 100, {""} },
-    { "Full Depth Moves (non-PV nodes)", "3", "3", SPIN, 1, 100, {""} },
-    { "Threat Depth", "5", "5", SPIN, 0, 100, {""} },
-    { "Selective Plies", "7", "7", SPIN, 0, 10, {""} },
-    { "Futility Pruning (Main Search)", "true", "true", CHECK, 0, 0, {""} },
-    { "Futility Pruning (Quiescence Search)", "true", "true", CHECK, 0, 0, {""} },
-    { "Futility Margin 0", "50", "50", SPIN, 0, 1000, {""} },
-    { "Futility Margin 1", "100", "100", SPIN, 0, 1000, {""} },
-    { "Futility Margin 2", "300", "300", SPIN, 0, 1000, {""} },
-    { "Maximum Razoring Depth", "3", "3", SPIN, 0, 4, {""} },
-    { "Razoring Margin", "300", "300", SPIN, 150, 600, {""} },
-    { "Randomness", "0", "0", SPIN, 0, 10, {""} },
-    { "Minimum Split Depth", "4", "4", SPIN, 4, 7, {""} },
-    { "Maximum Number of Threads per Split Point", "5", "5", SPIN, 4, 8, {""} },
-    { "Threads", "1", "1", SPIN, 1, 8, {""} },
-    { "Hash", "32", "32", SPIN, 4, 4096, {""} },
-    { "Clear Hash", "false", "false", BUTTON, 0, 0, {""} },
-    { "Ponder", "true", "true", CHECK, 0, 0, {""} },
-    { "OwnBook", "true", "true", CHECK, 0, 0, {""} },
-    { "MultiPV", "1", "1", SPIN, 1, 500, {""} },
-    { "UCI_ShowCurrLine", "false", "false", CHECK, 0, 0, {""} },
-    { "UCI_Chess960", "false", "false", CHECK, 0, 0, {""} },
-    { "", "", "", OPTION_TYPE_NONE, 0, 0, {""}}
-  };
-    
 
-  ///
+  // Local functions
-  /// Functions
+  Options::iterator option_with_name(const std::string& optionName);
-  ///
 
-  Option *option_with_name(const char *optionName);
+  // stringify converts a value of type T to a std::string
+  template<typename T>
+  std::string stringify(const T& v) {
 
+     std::ostringstream ss;
+     ss << v;
+     return ss.str();
+  }
+
+  // We want conversion from a bool value to be "true" or "false",
+  // not "1" or "0", so add a specialization for bool type.
+  template<>
+  std::string stringify<bool>(const bool& v) {
+
+    return v ? "true" : "false";
+  }
+
+  // get_option_value implements the various get_option_value_<type>
+  // functions defined later, because only the option value
+  // type changes a template seems a proper solution.
+
+  template<typename T>
+  T get_option_value(const std::string& optionName) {
+
+      T ret = T();
+      Options::iterator it = option_with_name(optionName);
+
+      if (it != options.end())
+      {
+          std::istringstream ss(it->currentValue);
+          ss >> ret;
+      }
+      return ret;
+  }
+
+  // Unfortunatly we need a specialization to convert "false" and "true"
+  // to proper bool values. The culprit is that we use a non standard way
+  // to store a bool value in a string, in particular we use "false" and
+  // "true" instead of "0" and "1" due to how UCI protocol works.
+
+  template<>
+  bool get_option_value<bool>(const std::string& optionName) {
+
+      Options::iterator it = option_with_name(optionName);
+
+      return it != options.end() && it->currentValue == "true";
+  }
 }
 
-
 ////
 //// Functions
 ////
@@ -143,26 +211,31 @@ namespace {
 /// "Threads" parameter to the number of available CPU cores.
 
 void init_uci_options() {
-  Option *o;
 
-  o = option_with_name("Threads");
+  load_defaults(options);
-  assert(o != NULL);
 
   // Limit the default value of "Threads" to 7 even if we have 8 CPU cores.
   // According to Ken Dail's tests, Glaurung plays much better with 7 than
   // with 8 threads.  This is weird, but it is probably difficult to find out
   // why before I have a 8-core computer to experiment with myself.
-  sprintf(o->defaultValue, "%d", Min(cpu_count(), 7));
+  Options::iterator it = option_with_name("Threads");
-  sprintf(o->currentValue, "%d", Min(cpu_count(), 7));
+
+  assert(it != options.end());
+
+  it->defaultValue = stringify(Min(cpu_count(), 7));
+  it->currentValue = stringify(Min(cpu_count(), 7));
 
   // Increase the minimum split depth when the number of CPUs is big.
   // It would probably be better to let this depend on the number of threads
   // instead.
-  o = option_with_name("Minimum Split Depth");
+  if(cpu_count() > 4)
-  assert(o != NULL);
+  {
-  if(cpu_count() > 4) {
+      it = option_with_name("Minimum Split Depth");
-    sprintf(o->defaultValue, "%d", 6);
+
-    sprintf(o->defaultValue, "%d", 6);
+      assert(it != options.end());
+
+      it->defaultValue = "6";
+      it->currentValue = "6";
   }
 }
 
@@ -171,30 +244,39 @@ void init_uci_options() {
 /// in the format defined by the UCI protocol.
 
 void print_uci_options() {
+
   static const char optionTypeName[][16] = {
     "spin", "combo", "check", "string", "button"
   };
-  for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++) {
+
-    printf("option name %s type %s", o->name, optionTypeName[o->type]);
+  for (Options::iterator it = options.begin(); it != options.end(); ++it)
-    if(o->type != BUTTON) {
+  {
-      printf(" default %s", o->defaultValue);
+      std::cout << "option name " << it->name
-      if(o->type == SPIN)
+                << " type "       << optionTypeName[it->type];
-        printf(" min %d max %d", o->minValue, o->maxValue);
+
-      else if(o->type == COMBO)
+      if (it->type != BUTTON)
-        for(int i = 0; strlen(o->comboValues[i]) > 0; i++)
+      {
-          printf(" var %s", o->comboValues[i]);
+          std::cout << " default " << it->defaultValue;
-    }
+
-    printf("\n");
+          if (it->type == SPIN)
+              std::cout << " min " << it->minValue
+                        << " max " << it->maxValue;
+
+          else if (it->type == COMBO)
+              for(ComboValues::iterator itc = it->comboValues.begin();
+                  itc != it->comboValues.end(); ++itc)
+                      std::cout << " var " << *itc;
+      }
+      std::cout << std::endl;
   }
 }
 
-
 /// get_option_value_bool() returns the current value of a UCI parameter of
 /// type "check".
 
-bool get_option_value_bool(const std::string &optionName) {
+bool get_option_value_bool(const std::string& optionName) {
-  Option *o = option_with_name(optionName.c_str());
+
-  return o != NULL && strcmp(o->currentValue, "true") == 0;
+  return get_option_value<bool>(optionName);
 }
 
 
@@ -203,31 +285,33 @@ bool get_option_value_bool(const std::string &optionName) {
 /// it could also be used with a "combo" parameter, where all the available
 /// values are integers.
 
-int get_option_value_int(const std::string &optionName) {
+int get_option_value_int(const std::string& optionName) {
-  Option *o = option_with_name(optionName.c_str());
+
-  return atoi(o->currentValue);
+  return get_option_value<int>(optionName);
 }
 
 
 /// get_option_value_string() returns the current value of a UCI parameter as
 /// a string.  It is used with parameters of type "combo" and "string".
 
-const std::string get_option_value_string(const std::string &optionName) {
+const std::string get_option_value_string(const std::string& optionName) {
-  Option *o = option_with_name(optionName.c_str());
+
-  return o->currentValue;
+   return get_option_value<std::string>(optionName);
 }
 
 
 /// button_was_pressed() tests whether a UCI parameter of type "button" has
 /// been selected since the last time the function was called.
 
-bool button_was_pressed(const std::string &buttonName) {
+bool button_was_pressed(const std::string& buttonName) {
-  if(get_option_value_bool(buttonName)) {
+
+  if (get_option_value<bool>(buttonName))
+  {
     set_option_value(buttonName, "false");
     return true;
   }
-  else
+
-    return false;
+  return false;
 }
 
 
@@ -235,36 +319,50 @@ bool button_was_pressed(const std::string &buttonName) {
 /// the function does not check that the new value is legal for the given
 /// parameter:  This is assumed to be the responsibility of the GUI.
 
-void set_option_value(const std::string &optionName,
+void set_option_value(const std::string& optionName,
-                      const std::string &newValue) {
+                      const std::string& newValue) {
-  Option *o = option_with_name(optionName.c_str());
 
-  if(o != NULL)
+  Options::iterator it = option_with_name(optionName);
-    strcpy(o->currentValue, newValue.c_str());
+
+  if (it != options.end())
+      it->currentValue = newValue;
   else
-    std::cout << "No such option: " << optionName << std::endl;
+      std::cout << "No such option: " << optionName << std::endl;
 }
 
 
 /// push_button() is used to tell the engine that a UCI parameter of type
 /// "button" has been selected:
 
-void push_button(const std::string &buttonName) {
+void push_button(const std::string& buttonName) {
+
   set_option_value(buttonName, "true");
 }
 
 
 namespace {
 
-  // option_with_name() tries to find a UCI option with a given
+    // Define constructors of Option class.
-  // name.  It returns a pointer to the UCI option or the null pointer,
-  // depending on whether an option with the given name exists.
-  
-  Option *option_with_name(const char *optionName) {
-    for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++)
-      if(strcmp(o->name, optionName) == 0)
-        return o;
-    return NULL;
-  }
 
+    Option::Option(const char* nm, const char* def, OptionType t)
+    : name(nm), defaultValue(def), currentValue(def), type(t), minValue(0), maxValue(0) {}
+
+    Option::Option(const char* nm, bool def, OptionType t)
+    : name(nm), defaultValue(stringify(def)), currentValue(stringify(def)), type(t), minValue(0), maxValue(0) {}
+
+    Option::Option(const char* nm, int def, int minv, int maxv)
+    : name(nm), defaultValue(stringify(def)), currentValue(stringify(def)), type(SPIN), minValue(minv), maxValue(maxv) {}
+
+    // option_with_name() tries to find a UCI option with a given
+    // name.  It returns an iterator to the UCI option or to options.end(),
+    // depending on whether an option with the given name exists.
+
+    Options::iterator option_with_name(const std::string& optionName) {
+
+        for (Options::iterator it = options.begin(); it != options.end(); ++it)
+            if (it->name == optionName)
+                return it;
+
+        return options.end();
+    }
 }

src/ucioption.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/value.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -59,7 +60,7 @@ Value value_from_tt(Value v, int ply) {
 }
 
 
-/// value_to_centipawns() converts a value from Glaurung's somewhat unusual
+/// value_to_centipawns() converts a value from Stockfish's somewhat unusual
 /// scale of pawn = 256 to the more conventional pawn = 100.
 
 int value_to_centipawns(Value v) {
@@ -67,7 +68,7 @@ int value_to_centipawns(Value v) {
 }
 
 
-/// value_from_centipawns() converts a centipawn value to Glaurung's internal
+/// value_from_centipawns() converts a centipawn value to Stockfish's internal
 /// evaluation scale.  It's used when reading the values of UCI options
 /// containing material values (e.g. futility pruning margins).
 

src/value.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
   
-  Glaurung is distributed in the hope that it will be useful,
+  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.