Merge remote-tracking branch 'upstream/master'

[stockfish] / src / ucioption.cpp

diff --git a/src/ucioption.cpp b/src/ucioption.cpp
index b822ccf936f66d659b5be679ccd031aa4447efb4..455803cfe1b049b8c6d538eb7718caf9bf9b1c21 100644 (file)
--- a/src/ucioption.cpp
+++ b/src/ucioption.cpp
@@ -1,6 +1,6 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1

-  Copyright (C) 2004-2023 The Stockfish developers (see AUTHORS file)
+  Copyright (C) 2004-2024 The Stockfish developers (see AUTHORS file)

 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by


@@ -16,184 +16,196 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 

+#include "ucioption.h"
+

 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <algorithm>
 #include <cassert>
 #include <cctype>

-#include <cstddef>
-#include <iosfwd>
-#include <istream>
-#include <map>
-#include <ostream>
+#include <iostream>

 #include <sstream>
 #include <sstream>

-#include <string>
+#include <utility>

 
 

-#include "evaluate.h"

 #include "misc.h"
 #include "misc.h"

-#include "search.h"
-#include "syzygy/tbprobe.h"
-#include "thread.h"
-#include "tt.h"
-#include "types.h"
-#include "uci.h"
-
-using std::string;

 
 namespace Stockfish {
 
 
 namespace Stockfish {
 

-UCI::OptionsMap Options; // Global object
-
-namespace UCI {
-
-// 'On change' actions, triggered by an option's value change
-static void on_clear_hash(const Option&) { Search::clear(); }
-static void on_hash_size(const Option& o) { TT.resize(size_t(o)); }
-static void on_logger(const Option& o) { start_logger(o); }
-static void on_threads(const Option& o) { Threads.set(size_t(o)); }
-static void on_tb_path(const Option& o) { Tablebases::init(o); }
-static void on_eval_file(const Option&) { Eval::NNUE::init(); }
+bool CaseInsensitiveLess::operator()(const std::string& s1, const std::string& s2) const {

 
 

-// Our case insensitive less() function as required by UCI protocol
-bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
-
-  return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
-         [](char c1, char c2) { return tolower(c1) < tolower(c2); });
+    return std::lexicographical_compare(
+      s1.begin(), s1.end(), s2.begin(), s2.end(),
+      [](char c1, char c2) { return std::tolower(c1) < std::tolower(c2); });

 }
 
 }
 

+void OptionsMap::add_info_listener(InfoListener&& message_func) { info = std::move(message_func); }

 
 

-// UCI::init() initializes the UCI options to their hard-coded default values
-
-void init(OptionsMap& o) {
-
-  constexpr int MaxHashMB = Is64Bit ? 33554432 : 2048;
-
-  o["Debug Log File"]        << Option("", on_logger);
-  o["Threads"]               << Option(1, 1, 1024, on_threads);
-  o["Hash"]                  << Option(16, 1, MaxHashMB, on_hash_size);
-  o["Clear Hash"]            << Option(on_clear_hash);
-  o["Ponder"]                << Option(false);
-  o["MultiPV"]               << Option(1, 1, 500);
-  o["Skill Level"]           << Option(20, 0, 20);
-  o["Move Overhead"]         << Option(10, 0, 5000);
-  o["Slow Mover"]            << Option(100, 10, 1000);
-  o["nodestime"]             << Option(0, 0, 10000);
-  o["UCI_Chess960"]          << Option(false);
-  o["UCI_AnalyseMode"]       << Option(false);
-  o["UCI_LimitStrength"]     << Option(false);
-  o["UCI_Elo"]               << Option(1320, 1320, 3190);
-  o["UCI_ShowWDL"]           << Option(false);
-  o["SyzygyPath"]            << Option("<empty>", on_tb_path);
-  o["SyzygyProbeDepth"]      << Option(1, 1, 100);
-  o["Syzygy50MoveRule"]      << Option(true);
-  o["SyzygyProbeLimit"]      << Option(7, 0, 7);
-  o["EvalFile"]              << Option(EvalFileDefaultName, on_eval_file);
-}
-
+void OptionsMap::setoption(std::istringstream& is) {
+    std::string token, name, value;

 
 

-// operator<<() is used to print all the options default values in chronological
-// insertion order (the idx field) and in the format defined by the UCI protocol.
+    is >> token;  // Consume the "name" token

 
 

-std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
+    // Read the option name (can contain spaces)
+    while (is >> token && token != "value")
+        name += (name.empty() ? "" : " ") + token;

 
 

-  for (size_t idx = 0; idx < om.size(); ++idx)
-      for (const auto& it : om)
-          if (it.second.idx == idx)
-          {
-              const Option& o = it.second;
-              os << "\noption name " << it.first << " type " << o.type;
+    // Read the option value (can contain spaces)
+    while (is >> token)
+        value += (value.empty() ? "" : " ") + token;

 
 

-              if (o.type == "string" || o.type == "check" || o.type == "combo")
-                  os << " default " << o.defaultValue;
-
-              if (o.type == "spin")
-                  os << " default " << int(stof(o.defaultValue))
-                     << " min "     << o.min
-                     << " max "     << o.max;
-
-              break;
-          }
+    if (options_map.count(name))
+        options_map[name] = value;
+    else
+        sync_cout << "No such option: " << name << sync_endl;
+}

 
 

-  return os;
+Option OptionsMap::operator[](const std::string& name) const {
+    auto it = options_map.find(name);
+    return it != options_map.end() ? it->second : Option(this);

 }
 
 }
 

+Option& OptionsMap::operator[](const std::string& name) {
+    if (!options_map.count(name))
+        options_map[name] = Option(this);
+    return options_map[name];
+}

 
 

-// Option class constructors and conversion operators
+std::size_t OptionsMap::count(const std::string& name) const { return options_map.count(name); }

 
 

-Option::Option(const char* v, OnChange f) : type("string"), min(0), max(0), on_change(f)
-{ defaultValue = currentValue = v; }
+Option::Option(const OptionsMap* map) :
+    parent(map) {}

 
 

-Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f)
-{ defaultValue = currentValue = (v ? "true" : "false"); }
+Option::Option(const char* v, OnChange f) :
+    type("string"),
+    min(0),
+    max(0),
+    on_change(std::move(f)) {
+    defaultValue = currentValue = v;
+}

 
 

-Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f)
-{}
+Option::Option(bool v, OnChange f) :
+    type("check"),
+    min(0),
+    max(0),
+    on_change(std::move(f)) {
+    defaultValue = currentValue = (v ? "true" : "false");
+}

 
 

-Option::Option(double v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f)
-{ defaultValue = currentValue = std::to_string(v); }
+Option::Option(OnChange f) :
+    type("button"),
+    min(0),
+    max(0),
+    on_change(std::move(f)) {}
+
+Option::Option(double v, int minv, int maxv, OnChange f) :
+    type("spin"),
+    min(minv),
+    max(maxv),
+    on_change(std::move(f)) {
+    defaultValue = currentValue = std::to_string(v);
+}

 
 

-Option::Option(const char* v, const char* cur, OnChange f) : type("combo"), min(0), max(0), on_change(f)
-{ defaultValue = v; currentValue = cur; }
+Option::Option(const char* v, const char* cur, OnChange f) :
+    type("combo"),
+    min(0),
+    max(0),
+    on_change(std::move(f)) {
+    defaultValue = v;
+    currentValue = cur;
+}

 
 Option::operator int() const {
 
 Option::operator int() const {

-  assert(type == "check" || type == "spin");
-  return (type == "spin" ? std::stoi(currentValue) : currentValue == "true");
+    assert(type == "check" || type == "spin");
+    return (type == "spin" ? std::stoi(currentValue) : currentValue == "true");

 }
 
 Option::operator std::string() const {
 }
 
 Option::operator std::string() const {

-  assert(type == "string");
-  return currentValue;
+    assert(type == "string");
+    return currentValue;

 }
 
 bool Option::operator==(const char* s) const {
 }
 
 bool Option::operator==(const char* s) const {

-  assert(type == "combo");
-  return   !CaseInsensitiveLess()(currentValue, s)
-        && !CaseInsensitiveLess()(s, currentValue);
+    assert(type == "combo");
+    return !CaseInsensitiveLess()(currentValue, s) && !CaseInsensitiveLess()(s, currentValue);

 }
 
 }
 

+bool Option::operator!=(const char* s) const { return !(*this == s); }
+

 
 

-// operator<<() inits options and assigns idx in the correct printing order
+// Inits options and assigns idx in the correct printing order

 
 void Option::operator<<(const Option& o) {
 
 
 void Option::operator<<(const Option& o) {
 

-  static size_t insert_order = 0;
+    static size_t insert_order = 0;

 
 

-  *this = o;
-  idx = insert_order++;
-}
+    auto p = this->parent;
+    *this  = o;

 
 

+    this->parent = p;
+    idx          = insert_order++;
+}

 
 

-// operator=() updates currentValue and triggers on_change() action. It's up to
+// Updates currentValue and triggers on_change() action. It's up to

 // the GUI to check for option's limits, but we could receive the new value
 // from the user by console window, so let's check the bounds anyway.
 // the GUI to check for option's limits, but we could receive the new value
 // from the user by console window, so let's check the bounds anyway.

-
-Option& Option::operator=(const string& v) {
-
-  assert(!type.empty());
-
-  if (   (type != "button" && type != "string" && v.empty())
-      || (type == "check" && v != "true" && v != "false")
-      || (type == "spin" && (stof(v) < min || stof(v) > max)))
-      return *this;
-
-  if (type == "combo")
-  {
-      OptionsMap comboMap; // To have case insensitive compare
-      string token;
-      std::istringstream ss(defaultValue);
-      while (ss >> token)
-          comboMap[token] << Option();
-      if (!comboMap.count(v) || v == "var")
-          return *this;
-  }
-
-  if (type != "button")
-      currentValue = v;
-
-  if (on_change)
-      on_change(*this);
-
-  return *this;
+Option& Option::operator=(const std::string& v) {
+
+    assert(!type.empty());
+
+    if ((type != "button" && type != "string" && v.empty())
+        || (type == "check" && v != "true" && v != "false")
+        || (type == "spin" && (std::stof(v) < min || std::stof(v) > max)))
+        return *this;
+
+    if (type == "combo")
+    {
+        OptionsMap         comboMap;  // To have case insensitive compare
+        std::string        token;
+        std::istringstream ss(defaultValue);
+        while (ss >> token)
+            comboMap[token] << Option();
+        if (!comboMap.count(v) || v == "var")
+            return *this;
+    }
+
+    if (type == "string")
+        currentValue = v == "<empty>" ? "" : v;
+    else if (type != "button")
+        currentValue = v;
+
+    if (on_change)
+    {
+        const auto ret = on_change(*this);
+
+        if (ret && parent != nullptr && parent->info != nullptr)
+            parent->info(ret);
+    }
+
+    return *this;

 }
 
 }
 

-} // namespace UCI
-
-} // namespace Stockfish
+std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
+    for (size_t idx = 0; idx < om.options_map.size(); ++idx)
+        for (const auto& it : om.options_map)
+            if (it.second.idx == idx)
+            {
+                const Option& o = it.second;
+                os << "\noption name " << it.first << " type " << o.type;
+
+                if (o.type == "check" || o.type == "combo")
+                    os << " default " << o.defaultValue;
+
+                else if (o.type == "string")
+                {
+                    std::string defaultValue = o.defaultValue.empty() ? "<empty>" : o.defaultValue;
+                    os << " default " << defaultValue;
+                }
+
+                else if (o.type == "spin")
+                    os << " default " << int(stof(o.defaultValue)) << " min " << o.min << " max "
+                       << o.max;
+
+                break;
+            }
+
+    return os;
+}
+}