First part of generic LR generator implementation

Done: First and follow sets

src/CMakeLists.txt

@@ -1,6 +1,10 @@
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h @ONLY)
 include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
 
+add_library(Parsodus-tables
+    lrtables/generator.cpp
+    )
+
 add_library(Parsodus-backends
     backends/cpp.cpp
     )

src/lrtables/generator.cpp

@@ -0,0 +1,109 @@
+#include "Parsodus/lrtables/generator.h"
+
+namespace pds {
+namespace lr
+{
+   
+template <typename Item>
+Generator<Item>::Generator(const Grammar& g) : m_gram(g), m_first(), m_follow() {
+    if (needsFollowSet()) {
+        buildFirst();
+        buildFollow();
+    }
+}
+
+template <typename Item>
+LRTable Generator<Item>::generate() {
+    //TODO
+}
+
+template <typename Item>
+void Generator<Item>::buildFirst() {
+    for (std::string term : m_gram.terminals) {
+        m_first[term].insert(term);
+    }
+
+
+    bool changes = true;
+
+    auto update = [&changes, this](std::string head, auto& s) {
+        for (std::string elem : s) {
+            if (!m_first[head].count(elem)) {
+                changes = true;
+                m_first[head].insert(s.begin(), s.end());
+                return;
+            }
+        }
+    };
+
+    while (changes) {
+        changes = false;
+
+        for (const auto& p : m_gram.rules) {
+            const std::string& head = p.first;
+            const std::set<Rule>& rules = p.second;
+            for (const Rule& rule : rules) {
+                if (rule.tail.size() == 0) {
+                    update(head, {""});
+                }
+
+                bool ended = false;
+                for (const std::string& replacement : rule.tail) {
+                    if (m_first[replacement].count("")) {
+                        std::set<std::string> tmp = m_first[replacement];
+                        tmp.erase("");
+                        update(head, tmp);
+                    } else {
+                        update(head, m_first[replacement]);
+                        ended = true;
+                        break;
+                    }
+                }
+                if (!ended) {
+                    update(head, {""});
+                }
+            }
+        }
+    }
+}
+
+template <typename Item>
+void Generator<Item>::buildFollow() {
+    //EOF follow the added start rule.
+    m_follow["^"].insert("$");
+
+    bool changes = true;
+
+    auto update = [&changes, this](std::string head, auto s) {
+        s.erase("");
+        for (std::string elem : s) {
+            if (!m_follow[head].count(elem)) {
+                changes = true;
+                m_follow[head].insert(s.begin(), s.end());
+                return;
+            }
+        }
+    };
+
+    while (changes) {
+        changes = false;
+        for (const auto& p : m_gram.rules) {
+            std::string& head = p.first;
+            for (const auto& rule : p.second) {
+                for (std::size_t i = 0; i < rule.tail.size(); i++) {
+                    if (!m_gram.terminals.count(rule.tail[i])) {
+                        if (i == rule.tail.size() - 1 || m_first[rule.tail[i + 1]].count("")) {
+                            update(rule.tail[i], m_follow[head]);
+                        }
+                        if (i < rule.tail.size() - 1) {
+                            update(rule.tail[i], m_first[rule.tail[i + 1]]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+} /* lr */  
+} /* pds  */