Reformat UCI option code

Make a better use of C++ operators overloading to
streamline the APIs.

Also sync polyglot.ini file while there.

No functional change.

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

polyglot.ini

@@ -15,13 +15,10 @@ ResignScore = 600
 
 [Engine]
 
-Hash = 128
-Threads = 1
-OwnBook = false
-Book File = book.bin
-Best Book Move = false
 Use Search Log = false
 Search Log Filename = SearchLog.txt
+Book File = book.bin
+Best Book Move = false
 Mobility (Middle Game) = 100
 Mobility (Endgame) = 100
 Passed Pawns (Middle Game) = 100
@@ -29,11 +26,18 @@ Passed Pawns (Endgame) = 100
 Space = 100
 Aggressiveness = 100
 Cowardice = 100
-Minimum Split Depth = 4
+Min Split Depth = 4
-Maximum Number of Threads per Split Point = 5
+Max Threads per Split Point = 5
-Use Sleeping Threads = false
+Threads = 1
+Use Sleeping Threads = true
+Hash = 128
+Ponder = true
+OwnBook = false
+MultiPV = 1
 Skill Level = 20
 Emergency Move Horizon = 40
 Emergency Base Time = 200
 Emergency Move Time = 70
 Minimum Thinking Time = 20
+UCI_Chess960 = false
+UCI_AnalyseMode = false

src/benchmark.cpp

@@ -71,9 +71,9 @@ void benchmark(int argc, char* argv[]) {
   string fenFile = argc > 5 ? argv[5] : "default";
   string valType = argc > 6 ? argv[6] : "depth";
 
-  Options["Hash"].set_value(ttSize);
+  Options["Hash"] = ttSize;
-  Options["Threads"].set_value(threads);
+  Options["Threads"] = threads;
-  Options["OwnBook"].set_value("false");
+  Options["OwnBook"] = false;
 
   // Search should be limited by nodes, time or depth ?
   if (valType == "nodes")

src/search.cpp

@@ -318,7 +318,7 @@ void Search::think() {
   TT.set_size(Options["Hash"].value<int>());
   if (Options["Clear Hash"].value<bool>())
   {
-      Options["Clear Hash"].set_value("false");
+      Options["Clear Hash"] = false;
       TT.clear();
   }
 

src/thread.cpp

@@ -112,8 +112,8 @@ bool Thread::is_available_to(int master) const {
 
 void ThreadsManager::read_uci_options() {
 
-  maxThreadsPerSplitPoint = Options["Maximum Number of Threads per Split Point"].value<int>();
+  maxThreadsPerSplitPoint = Options["Max Threads per Split Point"].value<int>();
-  minimumSplitDepth       = Options["Minimum Split Depth"].value<int>() * ONE_PLY;
+  minimumSplitDepth       = Options["Min Split Depth"].value<int>() * ONE_PLY;
   useSleepingThreads      = Options["Use Sleeping Threads"].value<bool>();
 
   set_size(Options["Threads"].value<int>());

src/uci.cpp

@@ -124,7 +124,7 @@ void uci_loop() {
       else if (token == "uci")
           cout << "id name "     << engine_name()
                << "\nid author " << engine_authors()
-               << "\n"           << Options.print_all()
+               << "\n"           << Options
                << "\nuciok"      << endl;
       else
           cout << "Unknown command: " << cmd << endl;
@@ -188,8 +188,8 @@ namespace {
     while (is >> token)
         value += string(" ", !value.empty()) + token;
 
-    if (Options.find(name) != Options.end())
+    if (Options.count(name))
-        Options[name].set_value(value.empty() ? "true" : value); // UCI buttons don't have "value"
+        Options[name] = (value.empty() ? "true" : value); // UCI buttons don't have "value"
     else
         cout << "No such option: " << name << endl;
   }

src/ucioption.cpp

@@ -29,7 +29,7 @@ using std::string;
 OptionsMap Options; // Global object
 
 
-// Our case insensitive less() function as required by UCI protocol
+/// Our case insensitive less() function as required by UCI protocol
 static bool ci_less(char c1, char c2) { return tolower(c1) < tolower(c2); }
 
 bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
@@ -37,120 +37,91 @@ bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const
 }
 
 
-// An helper to convert an integer value to a std::string
-static string int_to_string(int v) {
-
-  std::ostringstream ss;
-  ss << v;
-  return ss.str();
-}
-
-
 /// OptionsMap c'tor initializes the UCI options to their hard coded default
 /// values and initializes the default value of "Threads" and "Minimum Split Depth"
-/// parameters according to the number of CPU cores.
+/// parameters according to the number of CPU cores detected.
 
 OptionsMap::OptionsMap() {
 
+  int cpus = std::min(cpu_count(), MAX_THREADS);
+  int msd = cpus < 8 ? 4 : 7;
   OptionsMap& o = *this;
 
-  o["Use Search Log"] = UCIOption(false);
+  o["Use Search Log"]              = UCIOption(false);
-  o["Search Log Filename"] = UCIOption("SearchLog.txt");
+  o["Search Log Filename"]         = UCIOption("SearchLog.txt");
-  o["Book File"] = UCIOption("book.bin");
+  o["Book File"]                   = UCIOption("book.bin");
-  o["Best Book Move"] = UCIOption(false);
+  o["Best Book Move"]              = UCIOption(false);
-  o["Mobility (Middle Game)"] = UCIOption(100, 0, 200);
+  o["Mobility (Middle Game)"]      = UCIOption(100, 0, 200);
-  o["Mobility (Endgame)"] = UCIOption(100, 0, 200);
+  o["Mobility (Endgame)"]          = UCIOption(100, 0, 200);
-  o["Passed Pawns (Middle Game)"] = UCIOption(100, 0, 200);
+  o["Passed Pawns (Middle Game)"]  = UCIOption(100, 0, 200);
-  o["Passed Pawns (Endgame)"] = UCIOption(100, 0, 200);
+  o["Passed Pawns (Endgame)"]      = UCIOption(100, 0, 200);
-  o["Space"] = UCIOption(100, 0, 200);
+  o["Space"]                       = UCIOption(100, 0, 200);
-  o["Aggressiveness"] = UCIOption(100, 0, 200);
+  o["Aggressiveness"]              = UCIOption(100, 0, 200);
-  o["Cowardice"] = UCIOption(100, 0, 200);
+  o["Cowardice"]                   = UCIOption(100, 0, 200);
-  o["Minimum Split Depth"] = UCIOption(4, 4, 7);
+  o["Min Split Depth"]             = UCIOption(msd, 4, 7);
-  o["Maximum Number of Threads per Split Point"] = UCIOption(5, 4, 8);
+  o["Max Threads per Split Point"] = UCIOption(5, 4, 8);
-  o["Threads"] = UCIOption(1, 1, MAX_THREADS);
+  o["Threads"]                     = UCIOption(cpus, 1, MAX_THREADS);
-  o["Use Sleeping Threads"] = UCIOption(true);
+  o["Use Sleeping Threads"]        = UCIOption(true);
-  o["Hash"] = UCIOption(32, 4, 8192);
+  o["Hash"]                        = UCIOption(32, 4, 8192);
-  o["Clear Hash"] = UCIOption(false, "button");
+  o["Clear Hash"]                  = UCIOption(false, "button");
-  o["Ponder"] = UCIOption(true);
+  o["Ponder"]                      = UCIOption(true);
-  o["OwnBook"] = UCIOption(true);
+  o["OwnBook"]                     = UCIOption(true);
-  o["MultiPV"] = UCIOption(1, 1, 500);
+  o["MultiPV"]                     = UCIOption(1, 1, 500);
-  o["Skill Level"] = UCIOption(20, 0, 20);
+  o["Skill Level"]                 = UCIOption(20, 0, 20);
-  o["Emergency Move Horizon"] = UCIOption(40, 0, 50);
+  o["Emergency Move Horizon"]      = UCIOption(40, 0, 50);
-  o["Emergency Base Time"] = UCIOption(200, 0, 30000);
+  o["Emergency Base Time"]         = UCIOption(200, 0, 30000);
-  o["Emergency Move Time"] = UCIOption(70, 0, 5000);
+  o["Emergency Move Time"]         = UCIOption(70, 0, 5000);
-  o["Minimum Thinking Time"] = UCIOption(20, 0, 5000);
+  o["Minimum Thinking Time"]       = UCIOption(20, 0, 5000);
-  o["UCI_Chess960"] = UCIOption(false);
+  o["UCI_Chess960"]                = UCIOption(false);
-  o["UCI_AnalyseMode"] = UCIOption(false);
+  o["UCI_AnalyseMode"]             = UCIOption(false);
-
-  // Set some SMP parameters accordingly to the detected CPU count
-  UCIOption& thr = o["Threads"];
-  UCIOption& msd = o["Minimum Split Depth"];
-
-  thr.defaultValue = thr.currentValue = int_to_string(cpu_count());
-
-  if (cpu_count() >= 8)
-      msd.defaultValue = msd.currentValue = int_to_string(7);
 }
 
 
-/// OptionsMap::print_all() returns a string with all the UCI options in chronological
+/// operator<<() is used to output all the UCI options in chronological insertion
-/// insertion order (the idx field) and in the format defined by the UCI protocol.
+/// order (the idx field) and in the format defined by the UCI protocol.
+std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
 
-string OptionsMap::print_all() const {
+  for (size_t i = 0; i <= om.size(); i++)
-
+      for (OptionsMap::const_iterator it = om.begin(); it != om.end(); ++it)
-  std::stringstream s;
-
-  for (size_t i = 0; i <= size(); i++)
-      for (OptionsMap::const_iterator it = begin(); it != end(); ++it)
           if (it->second.idx == i)
           {
               const UCIOption& o = it->second;
-              s << "\noption name " << it->first << " type " << o.type;
+              os << "\noption name " << it->first << " type " << o.type;
 
               if (o.type != "button")
-                  s << " default " << o.defaultValue;
+                  os << " default " << o.defaultValue;
 
               if (o.type == "spin")
-                  s << " min " << o.minValue << " max " << o.maxValue;
+                  os << " min " << o.min << " max " << o.max;
 
               break;
           }
-  return s.str();
+  return os;
 }
 
 
-/// Option class c'tors
+/// UCIOption class c'tors
 
-UCIOption::UCIOption(const char* def) : type("string"), minValue(0), maxValue(0), idx(Options.size())
+UCIOption::UCIOption(const char* v) : type("string"), min(0), max(0), idx(Options.size())
-{ defaultValue = currentValue = def; }
+{ defaultValue = currentValue = v; }
 
-UCIOption::UCIOption(bool def, string t) : type(t), minValue(0), maxValue(0), idx(Options.size())
+UCIOption::UCIOption(bool v, string t) : type(t), min(0), max(0), idx(Options.size())
-{ defaultValue = currentValue = (def ? "true" : "false"); }
+{ defaultValue = currentValue = (v ? "true" : "false"); }
 
-UCIOption::UCIOption(int def, int minv, int maxv) : type("spin"), minValue(minv), maxValue(maxv), idx(Options.size())
+UCIOption::UCIOption(int v, int minv, int maxv) : type("spin"), min(minv), max(maxv), idx(Options.size())
-{ defaultValue = currentValue = int_to_string(def); }
+{ std::ostringstream ss; ss << v; defaultValue = currentValue = ss.str(); }
 
 
-/// set_value() updates currentValue of the Option object. Normally it's up to
+/// UCIOption::operator=() updates currentValue. Normally it's up to the GUI to
-/// the GUI to check for option's limits, but we could receive the new value
+/// check for option's limits, but we could receive the new value directly from
-/// directly from the user by teminal window. So let's check the bounds anyway.
+/// the user by teminal window, so let's check the bounds anyway.
 
-void UCIOption::set_value(const string& v) {
+void UCIOption::operator=(const string& v) {
 
   assert(!type.empty());
 
-  if (v.empty())
+  if (   !v.empty()
-      return;
+      && (type == "check" || type == "button") == (v == "true" || v == "false")
-
+      && (type != "spin" || (atoi(v.c_str()) >= min && atoi(v.c_str()) <= max)))
-  if ((type == "check" || type == "button") != (v == "true" || v == "false"))
+      currentValue = v;
-      return;
-
-  if (type == "spin")
-  {
-      int val = atoi(v.c_str());
-      if (val < minValue || val > maxValue)
-          return;
-  }
-
-  currentValue = v;
 }

src/ucioption.h

@@ -25,41 +25,30 @@
 #include <map>
 #include <string>
 
+struct OptionsMap;
+
+/// UCIOption class implements an option as defined by UCI protocol
 class UCIOption {
 public:
-  UCIOption() {} // To be used in a std::map
+  UCIOption() {} // Required by std::map::operator[]
-  UCIOption(const char* defaultValue);
+  UCIOption(const char* v);
-  UCIOption(bool defaultValue, std::string type = "check");
+  UCIOption(bool v, std::string type = "check");
-  UCIOption(int defaultValue, int minValue, int maxValue);
+  UCIOption(int v, int min, int max);
 
-  void set_value(const std::string& v);
   template<typename T> T value() const;
+  void operator=(const std::string& v);
+  void operator=(bool v) { *this = std::string(v ? "true" : "false"); }
 
 private:
-  friend struct OptionsMap;
+  friend std::ostream& operator<<(std::ostream&, const OptionsMap&);
 
   std::string defaultValue, currentValue, type;
-  int minValue, maxValue;
+  int min, max;
   size_t idx;
 };
 
 
-/// Custom comparator because UCI options should be case insensitive
+/// UCIOption::value() definition and specializations
-struct CaseInsensitiveLess {
-  bool operator() (const std::string&, const std::string&) const;
-};
-
-
-/// Our options container is actually a map with a customized c'tor
-struct OptionsMap : public std::map<std::string, UCIOption, CaseInsensitiveLess> {
-  OptionsMap();
-  std::string print_all() const;
-};
-
-extern OptionsMap Options;
-
-
-/// Option::value() definition and specializations
 template<typename T>
 T UCIOption::value() const {
 
@@ -81,4 +70,19 @@ inline bool UCIOption::value<bool>() const {
   return currentValue == "true";
 }
 
+
+/// Custom comparator because UCI options should be case insensitive
+struct CaseInsensitiveLess {
+  bool operator() (const std::string&, const std::string&) const;
+};
+
+
+/// Our options container is actually a map with a customized c'tor
+struct OptionsMap : public std::map<std::string, UCIOption, CaseInsensitiveLess> {
+  OptionsMap();
+};
+
+extern std::ostream& operator<<(std::ostream&, const OptionsMap&);
+extern OptionsMap Options;
+
 #endif // !defined(UCIOPTION_H_INCLUDED)