[poincare] Update the rulegen

poincare/src/simplification/Makefile

@@ -1,4 +1,4 @@
-#include poincare/src/simplify/rules_generation/Makefile
+include poincare/src/simplification/rules_generation/Makefile
 
 dir=poincare/src/simplification
 

poincare/src/simplification/rules_generation/Makefile

@@ -1,4 +1,4 @@
-dir=poincare/src/simplify/rules_generation
+dir=poincare/src/simplification/rules_generation
 
 rulegen_objs := $(addprefix $(dir)/,\
   rules_parser.o\
@@ -9,7 +9,7 @@ rulegen_objs := $(addprefix $(dir)/,\
 
 $(dir)/rules_parser.cpp: $(dir)/rules_parser.y
 	@echo "BISON   $@"
-	@bison --defines=poincare/src/simplify/rules_generation/rules_tokens.h $< -o $@
+	@bison --defines=poincare/src/simplification/rules_generation/rules_tokens.h $< -o $@
 
 $(dir)/rules_lexer.cpp: $(dir)/rules_lexer.l $(dir)/rules_parser.cpp
 	@echo "FLEX    $@"

poincare/src/simplification/rules_generation/node.cpp

@@ -4,34 +4,7 @@
 #include <sstream>
 #include <cassert>
 
-Node::Node(Type type, std::string * typeName) :
-  m_type(type),
-  m_typeName(typeName),
-  m_referenceMode(ReferenceMode::None),
-  m_referenceName(nullptr),
-  m_value(nullptr),
-  m_parent(nullptr)
-{
-  m_children = new std::vector<Node *>();
-}
-
-Node::~Node() {
-  delete m_children;
-}
-
-void Node::setReference(ReferenceMode mode, std::string * referenceName) {
-  assert(m_referenceName == nullptr);
-  m_referenceName = referenceName;
-  m_referenceMode = mode;
-}
-
-void Node::setValue(std::string * value) {
-  assert(m_value == nullptr);
-  m_value = value;
-}
-
 void Node::setChildren(std::vector<Node *> * children) {
-  assert(m_children->size() == 0);
   delete m_children;
   m_children = children;
   for (Node * child : *m_children) {
@@ -39,8 +12,65 @@ void Node::setChildren(std::vector<Node *> * children) {
   }
 }
 
+void Node::identifyAnonymousChildren(int * index) {
+  if (m_identifier == nullptr) {
+    m_identifier = new std::string("s" + std::to_string(*index));
+    (*index)++;
+  }
+  for (Node * child : *m_children) {
+    child->identifyAnonymousChildren(index);
+  }
+}
+
 // Generation
 
+void Node::generateSelector(Rule * rule) {
+  int i = 0;
+
+  for (Node * child : *m_children) {
+    child->generateSelector(rule);
+  }
+
+  if (m_children->size() > 0) {
+    std::cout
+      << "constexpr const Selector * "
+      << identifier() << "Children[] = {";
+    for (Node * child : *m_children) {
+      std::cout  << "&" << child->identifier();
+      if (child != m_children->back()) {
+        std::cout << ", ";
+      }
+    }
+    std::cout << "};" << std::endl;
+  }
+  std::cout << "constexpr TypeSelector " << identifier() << "(Expression::Type::" << *m_name << ", " << rule->indexOfIdentifierInTransform(*m_identifier) << ");" << std::endl;
+}
+
+void Node::generateTransform() {
+  std::cout << "constexpr " << *m_name  << " t;" << std::endl;
+}
+
+int Node::indexOfChildrenWithIdentifier(std::string identifier) {
+  for (int i=0; i<m_children->size(); i++) {
+    if (*(m_children->at(i)->m_identifier) == identifier) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+
+std::string Node::identifier() {
+  if (m_identifier) {
+    return *m_identifier;
+  }
+  return "NOIDEA";
+}
+
+
+
+#if 0
+
 std::string Node::generateSelectorConstructor(Rule * context) {
   std::ostringstream result;
   switch (m_type) {
@@ -191,3 +221,4 @@ int Node::generateTree(bool selector, Rule * context, int index, int indentation
   }
   return generatedCount;
 }
+#endif

poincare/src/simplification/rules_generation/node.h

@@ -8,39 +8,31 @@ class Rule;
 
 class Node {
 public:
-  enum class Type {
-    Expression,
-    Generator,
-    Any
-  };
-  enum class ReferenceMode {
-    None,
-    SingleNode,
-    Wildcard
-  };
-
-  // Creating Nodes
-  Node(Type type, std::string * typeName = nullptr);
-  ~Node();
-  void setReference(ReferenceMode mode, std::string * referenceName);
-  void setValue(std::string * value);
+  Node(std::string * name, std::string * identifier, std::string * value) :
+    m_name(name),
+    m_identifier(identifier),
+    m_value(value),
+    m_children(new std::vector<Node *>()),
+    m_parent(nullptr) { }
   void setChildren(std::vector<Node *> * children);
+  void identifyAnonymousChildren(int * index);
 
-  int totalDescendantCountIncludingSelf();
-  int flatIndexOfChildNamed(std::string name);
-  int flatIndexOfChildRef(Node * node);
-
-  void generateSelectorTree(Rule * context);
-  void generateBuilderTree(Rule * context);
+  void generateSelector(Rule * rule);
+  void generateTransform();
+  int indexOfChildrenWithIdentifier(std::string identifier);
+  std::string identifier();
 private:
+  int selectorCaptureIndexInRule(Rule * rule);
+  int selectorIndexInRule(Rule * rule);
+
+  /*
   int generateTree(bool selector, Rule * context, int index, int indentationLevel);
   std::string generateSelectorConstructor(Rule * context);
   std::string generateBuilderConstructor(Rule * context);
+  */
 
-  Type m_type;
-  std::string * m_typeName;
-  ReferenceMode m_referenceMode;
-  std::string * m_referenceName;
+  std::string * m_name;
+  std::string * m_identifier;
   std::string * m_value;
   std::vector<Node *> * m_children;
   Node * m_parent;

poincare/src/simplification/rules_generation/rule.cpp

@@ -1,19 +1,22 @@
 #include "rule.h"
 #include <iostream>
 
-Rule::Rule(Node * selector, Node * builder) :
-  m_selector(selector), m_builder(builder) {
+void Rule::generate(int index) {
+  std::cout << "namespace Rule" << index << " {" << std::endl;
+  int selectorIndex = 0;
+  m_selector->identifyAnonymousChildren(&selectorIndex);
+  m_selector->generateSelector(this);
+  m_transform->generateTransform();
+  std::cout << "constexpr Rule r(&"
+    << m_selector->identifier()
+    << ", &t);" << std::endl;
+  std::cout << "}" << std::endl;
 }
 
-Rule::~Rule() {
-  delete m_builder;
-  delete m_selector;
+int Rule::indexOfIdentifierInTransform(std::string identifier) {
+  return m_transform->indexOfChildrenWithIdentifier(identifier);
 }
-
-Node * Rule::selector() {
-  return m_selector;
-}
-
+#if 0
 void Rule::generate(std::string rule_name) {
   std::cout << "constexpr ExpressionSelector " << rule_name << "Selector[" << m_selector->totalDescendantCountIncludingSelf() << "] = {" << std::endl;
   m_selector->generateSelectorTree(this);
@@ -23,3 +26,4 @@ void Rule::generate(std::string rule_name) {
   m_builder->generateBuilderTree(this);
   std::cout << "};" << std::endl;
 }
+#endif

poincare/src/simplification/rules_generation/rule.h

@@ -5,13 +5,14 @@
 
 class Rule {
 public:
-  Rule(Node * selector, Node * builder);
-  ~Rule();
-  void generate(std::string rule_name);
-  Node * selector();
+  Rule(Node * selector, Node * transform) :
+    m_selector(selector), m_transform(transform) {}
+  void generate(int index);
+  void identifyAnonymousSelectors();
+  int indexOfIdentifierInTransform(std::string identifier);
 private:
   Node * m_selector;
-  Node * m_builder;
+  Node * m_transform;
 };
 
 #endif

poincare/src/simplification/rules_generation/rules_parser.y

@@ -66,26 +66,16 @@ rule:
 
 node:
   CAPITALIZED_IDENTIFIER {
-      $$ = new Node(Node::Type::Expression, $1);
+      $$ = new Node($1, nullptr, nullptr);
     }
-  | DOLLAR CAPITALIZED_IDENTIFIER {
-      $$ = new Node(Node::Type::Generator, $2);
+  | CAPITALIZED_IDENTIFIER PERIOD IDENTIFIER {
+      $$ = new Node($1, $3, nullptr);
+    }
+  | CAPITALIZED_IDENTIFIER LEFT_BRACKET VALUE RIGHT_BRACKET {
+      $$ = new Node($1, nullptr, $3);
     }
   | IDENTIFIER {
-      $$ = new Node(Node::Type::Any);
-      $$->setReference(Node::ReferenceMode::SingleNode, $1);
-    }
-  | IDENTIFIER ASTERISK {
-      $$ = new Node(Node::Type::Any);
-      $$->setReference(Node::ReferenceMode::Wildcard, $1);
-    }
-  | node PERIOD IDENTIFIER {
-      $$ = $1;
-      $$->setReference(Node::ReferenceMode::SingleNode, $3);
-    }
-  | node LEFT_BRACKET VALUE RIGHT_BRACKET {
-      $$ = $1;
-      $$->setValue($3);
+      $$ = new Node(nullptr, $1, nullptr);
     }
   | node LEFT_PARENTHESIS node_list RIGHT_PARENTHESIS {
       $$ = $1;
@@ -111,6 +101,11 @@ int main(void) {
 
   yyparse(&rules);
 
+  for (int i=0; i<rules->size(); i++) {
+    rules->at(i)->generate(i);
+  }
+#if 0
+
   std::cout << "#include \"rules.h\"" << std::endl;
   std::cout << "#include \"simplification_generator.h\"" << std::endl;
   std::cout << std::endl;
@@ -135,6 +130,7 @@ std::cout << "  Simplification((ExpressionSelector *)" << name.str() << "Selecto
   std::cout << std::endl;
   std::cout << "constexpr int Poincare::knumberOfSimplifications = " << rules->size() << ";" << std::endl;
 
+#endif
   delete rules;
   return 0;
 }