make interpreter's Conjunction a Compound node

src/interpreter/Engine.cpp

@@ -979,7 +979,12 @@ RamDomain Engine::execute(const Node* node, Context& ctxt) {
         ESAC(False)
 
         CASE(Conjunction)
-            return execute(shadow.getLhs(), ctxt) && execute(shadow.getRhs(), ctxt);
+            for (const auto& child : shadow.getChildren()) {
+                if (!execute(child.get(), ctxt)) {
+                    return false;
+                }
+            }
+            return true;
         ESAC(Conjunction)
 
         CASE(Negation)

src/interpreter/Generator.cpp

@@ -200,7 +200,21 @@ NodePtr NodeGenerator::visit_(type_identity<ram::False>, const ram::False& lfals
 }
 
 NodePtr NodeGenerator::visit_(type_identity<ram::Conjunction>, const ram::Conjunction& conj) {
-    return mk<Conjunction>(I_Conjunction, &conj, dispatch(conj.getLHS()), dispatch(conj.getRHS()));
+    NodePtrVec children;
+    std::stack<const ram::Node*> dfs;
+    dfs.push(&conj.getRHS());
+    dfs.push(&conj.getLHS());
+    while (!dfs.empty()) {
+        const ram::Node* term = dfs.top();
+        dfs.pop();
+        if (const ram::Conjunction* subconj = as<ram::Conjunction>(term)) {
+            dfs.push(&subconj->getRHS());
+            dfs.push(&subconj->getLHS());
+        } else {
+            children.emplace_back(std::move(dispatch(*term)));
+        }
+    }
+    return mk<Conjunction>(I_Conjunction, &conj, std::move(children));
 }
 
 NodePtr NodeGenerator::visit_(type_identity<ram::Negation>, const ram::Negation& neg) {

src/interpreter/Node.h

@@ -578,9 +578,12 @@ class False : public Node {
 
 /**
  * @class Conjunction
+ *
+ * It's a compound node so that conjunctions with hundreds of terms
+ * do not overflow the engine stack with left/right recursion.
  */
-class Conjunction : public BinaryNode {
-    using BinaryNode::BinaryNode;
+class Conjunction : public CompoundNode {
+    using CompoundNode::CompoundNode;
 };
 
 /**