Restore variant parsing for JS/python bindings

Author: Belzedar94

src/ffishjs.cpp

@@ -480,9 +480,11 @@ namespace ffish {
   }
 
   void load_variant_config(std::string variantInitContent) {
-    (void)variantInitContent;
+    std::stringstream ss(variantInitContent);
     if (!Board::sfInitialized)
       initialize_stockfish();
+    variants.parse_istream<false>(ss);
+    Options["UCI_Variant"].set_combo(variants.get_keys());
     Board::sfInitialized = true;
   }
 

src/pyffish.cpp

@@ -100,7 +100,9 @@ extern "C" PyObject* pyffish_loadVariantConfig(PyObject* self, PyObject *args) {
     const char *config;
     if (!PyArg_ParseTuple(args, "s", &config))
         return NULL;
-    (void)config;
+    std::stringstream ss(config);
+    variants.parse_istream<false>(ss);
+    Options["UCI_Variant"].set_combo(variants.get_keys());
     Py_RETURN_NONE;
 }
 

src/variant.cpp

@@ -22,6 +22,7 @@
 #include <sstream>
 
 #include "piece.h"
+#include "parser.h"
 #include "variant.h"
 
 using std::string;
@@ -86,6 +87,83 @@ void VariantMap::init() {
     add("spell-chess", spell_chess_variant());
 }
 
+/// VariantMap::parse_istream reads variants from an INI-style configuration input stream.
+
+template <bool DoCheck>
+void VariantMap::parse_istream(std::istream& file) {
+    std::string variant, variant_template, key, value, input;
+    while (file.peek() != '[' && std::getline(file, input)) {}
+
+    std::vector<std::string> varsToErase = {};
+    while (file.get() && std::getline(std::getline(file, variant, ']'), input))
+    {
+        // Extract variant template, if specified
+        if (!std::getline(std::getline(std::stringstream(variant), variant, ':'), variant_template))
+            variant_template = "";
+
+        // Read variant rules
+        Config attribs = {};
+        while (file.peek() != '[' && std::getline(file, input))
+        {
+            if (!input.empty() && input.back() == '\r')
+                input.pop_back();
+            std::stringstream ss(input);
+            if (ss.peek() != ';' && ss.peek() != '#')
+            {
+                if (DoCheck && !input.empty() && input.find('=') == std::string::npos)
+                    std::cerr << "Invalid syntax: '" << input << "'." << std::endl;
+                if (std::getline(std::getline(ss, key, '=') >> std::ws, value) && !key.empty())
+                    attribs[key.erase(key.find_last_not_of(" ") + 1)] = value;
+            }
+        }
+
+        // Create variant
+        if (variants.find(variant) != variants.end())
+            std::cerr << "Variant '" << variant << "' already exists." << std::endl;
+        else if (!variant_template.empty() && variants.find(variant_template) == variants.end())
+            std::cerr << "Variant template '" << variant_template << "' does not exist." << std::endl;
+        else
+        {
+            if (DoCheck)
+                std::cerr << "Parsing variant: " << variant << std::endl;
+            Variant* v = !variant_template.empty() ? VariantParser<DoCheck>(attribs).parse((new Variant(*variants.find(variant_template)->second))->init())
+                                                   : VariantParser<DoCheck>(attribs).parse();
+            if (v->maxFile <= FILE_MAX && v->maxRank <= RANK_MAX)
+            {
+                add(variant, v);
+                // In order to allow inheritance, we need to temporarily add configured variants
+                // even when only checking them, but we remove them later after parsing is finished.
+                if (DoCheck)
+                    varsToErase.push_back(variant);
+            }
+            else
+                delete v;
+        }
+    }
+    // Clean up temporary variants
+    for (std::string tempVar : varsToErase)
+    {
+        delete variants[tempVar];
+        variants.erase(tempVar);
+    }
+}
+
+/// VariantMap::parse reads variants from an INI-style configuration file.
+
+template <bool DoCheck>
+void VariantMap::parse(std::string path) {
+    if (path.empty() || path == "<empty>")
+        return;
+    std::ifstream file(path);
+    if (!file.is_open())
+    {
+        std::cerr << "Unable to open file " << path << std::endl;
+        return;
+    }
+    parse_istream<DoCheck>(file);
+    file.close();
+}
+
 // Pre-calculate derived properties
 Variant* Variant::conclude() {
     // Enforce consistency to allow runtime optimizations
@@ -300,7 +378,7 @@ std::vector<std::string> VariantMap::get_keys() {
 // VariantPath parsing entry points.
 template void VariantMap::parse_istream<true>(std::istream&);
 template void VariantMap::parse_istream<false>(std::istream&);
-template void VariantMap::parse<true>(const std::string&);
-template void VariantMap::parse<false>(const std::string&);
+template void VariantMap::parse<true>(std::string);
+template void VariantMap::parse<false>(std::string);
 
 } // namespace Stockfish

src/variant.h

@@ -249,32 +249,15 @@ struct Variant {
 class VariantMap : public std::map<std::string, const Variant*> {
 public:
   void init();
-  // Spell-only build: keep parsing entry points as no-ops for link compatibility
-  // with UCI VariantPath handling in other build configurations.
-  template <bool DoCheck>
-  void parse_istream(std::istream& file);
-  template <bool DoCheck>
-  void parse(const std::string& data);
+  template <bool DoCheck> void parse(std::string path);
+  template <bool DoCheck> void parse_istream(std::istream& file);
   void clear_all();
   std::vector<std::string> get_keys();
 
 private:
   void add(std::string s, Variant* v);
 };
 
-template <bool DoCheck>
-inline void VariantMap::parse_istream(std::istream& file) {
-  (void)file;
-  // No-op: variants are hardcoded in this build.
-  // If DoCheck is true, callers expect validation side effects; none apply here.
-}
-
-template <bool DoCheck>
-inline void VariantMap::parse(const std::string& data) {
-  std::istringstream ss(data);
-  parse_istream<DoCheck>(ss);
-}
-
 extern VariantMap variants;
 
 } // namespace Stockfish