X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fucioption.cpp;h=a478a0cb21fcd69578109a661a69b2af8b8d87b4;hp=49e8f228ee36ab039b73cc514b69533556a93685;hb=27619830d428693b4871ce58770705b30ba84c99;hpb=ebb0f31928621115037779ba14311d1ec8b90542

diff --git a/src/ucioption.cpp b/src/ucioption.cpp
index 49e8f228..a478a0cb 100644
--- a/src/ucioption.cpp
+++ b/src/ucioption.cpp
@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -33,13 +33,7 @@
 #include "thread.h"
 #include "ucioption.h"
 
-
-////
-//// Variables
-////
-
-bool Chess960 = false;
-
+using std::string;
 
 ////
 //// Local definitions
@@ -53,25 +47,25 @@ namespace {
 
   enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON };
 
-  typedef std::vector<std::string> ComboValues;
+  typedef std::vector<string> ComboValues;
 
   struct Option {
 
-    std::string name, defaultValue, currentValue;
+    string name, defaultValue, currentValue;
     OptionType type;
+    size_t idx;
     int minValue, maxValue;
     ComboValues comboValues;
-    size_t idx;
 
     Option();
-    Option(const std::string& defaultValue, OptionType = STRING);
+    Option(const char* defaultValue, OptionType = STRING);
     Option(bool defaultValue, OptionType = CHECK);
     Option(int defaultValue, int minValue, int maxValue);
 
-    bool operator<(const Option& o) { return this->idx < o.idx; }
+    bool operator<(const Option& o) const { return this->idx < o.idx; }
   };
 
-  typedef std::map<std::string, Option> Options;
+  typedef std::map<string, Option> Options;
 
   ///
   /// Constants
@@ -125,13 +119,8 @@ namespace {
     o["Full Depth Moves (PV nodes)"] = Option(14, 1, 100);
     o["Full Depth Moves (non-PV nodes)"] = Option(3, 1, 100);
     o["Threat Depth"] = Option(5, 0, 100);
-    o["Selective Plies"] = Option(7, 0, 10);
     o["Futility Pruning (Main Search)"] = Option(true);
     o["Futility Pruning (Quiescence Search)"] = Option(true);
-    o["Futility Margin (Quiescence Search)"] = Option(50, 0, 1000);
-    o["Futility Margin Scale Factor (Main Search)"] = Option(100, 0, 1000);
-    o["Maximum Razoring Depth"] = Option(3, 0, 4);
-    o["Razoring Margin"] = Option(300, 150, 600);
     o["LSN filtering"] = Option(true);
     o["LSN Time Margin (sec)"] = Option(4, 1, 10);
     o["LSN Value Margin"] = Option(200, 100, 600);
@@ -160,27 +149,20 @@ namespace {
 
   // stringify converts a value of type T to a std::string
   template<typename T>
-  std::string stringify(const T& v) {
+  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 get_option_value(const string& optionName) {
 
       T ret = T();
       if (options.find(optionName) == options.end())
@@ -191,19 +173,6 @@ namespace {
       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) {
-
-      if (options.find(optionName) == options.end())
-          return false;
-
-      return options[optionName].currentValue == "true";
-  }
 }
 
 ////
@@ -258,31 +227,32 @@ void print_uci_options() {
 
   for (std::vector<Option>::const_iterator it = vec.begin(); it != vec.end(); ++it)
   {
-      std::cout << "option name " << it->name
-                << " type "       << optionTypeName[it->type];
+      std::cout << "\noption name " << it->name
+                << " type "         << optionTypeName[it->type];
 
-      if (it->type != BUTTON)
-      {
-          std::cout << " default " << it->defaultValue;
+      if (it->type == BUTTON)
+          continue;
 
-          if (it->type == SPIN)
-              std::cout << " min " << it->minValue
-                        << " max " << it->maxValue;
+      if (it->type == CHECK)
+          std::cout << " default " << (it->defaultValue == "1" ? "true" : "false");
+      else
+          std::cout << " default " << it->defaultValue;
 
-          else if (it->type == COMBO)
-              for (ComboValues::const_iterator itc = it->comboValues.begin();
-                  itc != it->comboValues.end(); ++itc)
-                      std::cout << " var " << *itc;
-      }
-      std::cout << std::endl;
+      if (it->type == SPIN)
+          std::cout << " min " << it->minValue << " max " << it->maxValue;
+      else if (it->type == COMBO)
+          for (ComboValues::const_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 string& optionName) {
 
   return get_option_value<bool>(optionName);
 }
@@ -293,7 +263,7 @@ 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 string& optionName) {
 
   return get_option_value<int>(optionName);
 }
@@ -302,9 +272,9 @@ int get_option_value_int(const std::string& 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) {
+string get_option_value_string(const string& optionName) {
 
-   return get_option_value<std::string>(optionName);
+   return get_option_value<string>(optionName);
 }
 
 
@@ -312,20 +282,27 @@ const std::string get_option_value_string(const std::string& optionName) {
 /// 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,
-                      const std::string& newValue) {
+void set_option_value(const string& name, const string& value) {
+
+  // UCI protocol uses "true" and "false" instead of "1" and "0", so convert
+  // value according to standard C++ convention before to store it.
+  string v(value);
+  if (v == "true")
+      v = "1";
+  else if (v == "false")
+      v = "0";
 
-  if (options.find(optionName) != options.end())
-      options[optionName].currentValue = newValue;
+  if (options.find(name) != options.end())
+      options[name].currentValue = v;
   else
-      std::cout << "No such option: " << optionName << std::endl;
+      std::cout << "No such option: " << name << 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 string& buttonName) {
 
   set_option_value(buttonName, "true");
 }
@@ -335,7 +312,7 @@ void push_button(const std::string& buttonName) {
 /// been selected since the last time the function was called, in this case
 /// it also resets the button.
 
-bool button_was_pressed(const std::string& buttonName) {
+bool button_was_pressed(const string& buttonName) {
 
   if (!get_option_value<bool>(buttonName))
 	  return false;
@@ -351,7 +328,7 @@ namespace {
 
   Option::Option() {} // To allow insertion in a std::map
 
-  Option::Option(const std::string& def, OptionType t)
+  Option::Option(const char* def, OptionType t)
   : defaultValue(def), currentValue(def), type(t), idx(options.size()), minValue(0), maxValue(0) {}
 
   Option::Option(bool def, OptionType t)