Merge branch 'lalr-debug'

include/Parsodus/backendmanager.h

@@ -11,6 +11,7 @@
 #include "Parsodus/lrtables/LR0Itemset.h"
 #include "Parsodus/lrtables/SLR1Itemset.h"
 #include "Parsodus/lrtables/LR1Itemset.h"
+#include "Parsodus/lrtables/LALR1Itemset.h"
 #include "Parsodus/util/parserType.h"
 
 namespace pds {
@@ -32,6 +33,7 @@ namespace pds {
                 registerBackend(std::make_unique<T<lr::Generator<lr::LR0Itemset>>>(util::ParserType::LR_0)); 
                 registerBackend(std::make_unique<T<lr::Generator<lr::SLR1Itemset>>>(util::ParserType::SLR_1)); 
                 registerBackend(std::make_unique<T<lr::Generator<lr::LR1Itemset>>>(util::ParserType::LR_1));
+                registerBackend(std::make_unique<T<lr::Generator<lr::LALR1Itemset>>>(util::ParserType::LALR_1));
             }
             
             /**

include/Parsodus/lrtables/LALR1Itemset.h

@@ -0,0 +1,24 @@
+#pragma once
+#ifndef PARSODUS_LRTABLES_LALR1ITEMSET_H_TJ1FUOEG
+#define PARSODUS_LRTABLES_LALR1ITEMSET_H_TJ1FUOEG
+
+#include "Parsodus/lrtables/LR1ItemsetBase.h"
+
+namespace pds {
+namespace lr {
+
+class LALR1Itemset : public LR1ItemsetBase<LALR1Itemset> {
+public:
+    LALR1Itemset();
+    LALR1Itemset(std::shared_ptr<Rule> start);
+
+    bool canMerge(const LALR1Itemset& rhs) const;
+    bool merge(const LALR1Itemset& rhs);
+
+private:
+};
+
+} /* lr  */ 
+} /* pds */
+
+#endif /* PARSODUS_LRTABLES_LALR1ITEMSET_H_TJ1FUOEG */

include/Parsodus/lrtables/LR0ItemsetBase.h

@@ -21,7 +21,7 @@ public:
     Itemset succ(std::string sym) const;
     bool operator==(const Itemset& rhs) const;
     bool canMerge(const Itemset& rhs) const;
-    void merge(const Itemset& rhs);
+    bool merge(const Itemset& rhs);
     bool empty() const;
 
 protected:
@@ -89,8 +89,9 @@ bool LR0ItemsetBase<Itemset>::canMerge(const Itemset&) const {
 }
 
 template <typename Itemset>
-void LR0ItemsetBase<Itemset>::merge(const Itemset&) {
+bool LR0ItemsetBase<Itemset>::merge(const Itemset&) {
     //NO-OP
+    return false;
 }
 
 template <typename Itemset>

include/Parsodus/lrtables/LR1Itemset.h

@@ -13,7 +13,7 @@ public:
     LR1Itemset(std::shared_ptr<Rule> start);
 
     bool canMerge(const LR1Itemset& rhs) const;
-    void merge(const LR1Itemset& rhs);
+    bool merge(const LR1Itemset& rhs);
 
 private:
 };

include/Parsodus/lrtables/LR1ItemsetBase.h

@@ -24,8 +24,8 @@ public:
     bool empty() const;
     std::set<std::size_t> getReduces(const Grammar& g, std::string lookahead) const;
 
-private:
+protected:
-    std::set<LR1Item> m_items;
+    std::vector<LR1Item> m_items;
 };
 
 template <typename Itemset>
@@ -34,7 +34,7 @@ LR1ItemsetBase<Itemset>::LR1ItemsetBase()
 
 template <typename Itemset>
 LR1ItemsetBase<Itemset>::LR1ItemsetBase(std::shared_ptr<Rule> start) {
-    m_items.emplace(LR1Item{start, 0, {util::EOF_PLACEHOLDER}});
+    m_items.emplace_back(LR1Item{start, 0, {util::EOF_PLACEHOLDER}});
 }
 
 template <typename Itemset>
@@ -78,13 +78,9 @@ void LR1ItemsetBase<Itemset>::close(const Grammar& g) {
             }
         }
 
-        std::vector<LR1Item> newItems;
-        for (auto& it : m_items) {
-            newItems.emplace_back(std::move(it));
-        }
         for (const auto& newItem : toAdd) {
             bool found = false;
-            for (auto& oldItem : newItems) {
+            for (auto& oldItem : m_items) {
                 if (newItem.dotIdx == oldItem.dotIdx && newItem.rule == oldItem.rule) {
                     found = true;
                     oldItem.lookaheads.insert(newItem.lookaheads.begin(), newItem.lookaheads.end());
@@ -92,13 +88,9 @@ void LR1ItemsetBase<Itemset>::close(const Grammar& g) {
                 }
             }
             if (!found) {
-                newItems.push_back(newItem);
+                m_items.push_back(newItem);
             }
         }
-        m_items.clear();
-        for (auto& it : newItems) {
-            m_items.emplace(std::move(it));
-        }
     }
 }
 
@@ -108,7 +100,7 @@ Itemset LR1ItemsetBase<Itemset>::succ(std::string sym) const {
     for (auto& item : m_items) {
         if (item.dotIdx < item.rule->tail.size()) {
             if (item.rule->tail[item.dotIdx] == sym) {
-                sc.m_items.insert(LR1Item{item.rule, item.dotIdx + 1, item.lookaheads});
+                sc.m_items.push_back(LR1Item{item.rule, item.dotIdx + 1, item.lookaheads});
             }
         }
     }

include/Parsodus/lrtables/generator.h

@@ -24,7 +24,7 @@ namespace lr {
  * - Itemset succ(std::string) const; compute the successor of this set, over the given symbol
  * - bool operator==(const Itemset&); are these two Itemsets equal
  * - bool canMerge(const Itemset&) const; Can the given Itemset be merged into this one
- * - void merge(const Itemset&); Merge the given Itemset into this one
+ * - bool merge(const Itemset&); Merge the given Itemset into this one, return whether there was a change
  * - bool empty() const; is this Itemset empty (== not useful)
  * - std::set<std::size_t> getReduces(const Grammar&, std::string) const; get all Rule indices where a reduce should happen with given lookahead (not necessarily a set, but iterable)
  * - static bool needsFollow() const; does this type of Itemset need Follow sets to work, if so the first and follow unique_ptr's of the grammar passed will be initialized
@@ -99,8 +99,9 @@ LRTable Generator<Itemset>::generate() {
                 if (itemsets[idx] == s) {
                     break;
                 } else if (itemsets[idx].canMerge(s)) {
-                    itemsets[idx].merge(s);
+                    if (itemsets[idx].merge(s)) {
-                    q.emplace(idx, std::move(s));
+                        q.emplace(idx, std::move(s));
+                    }
                     break;
                 }
             }

src/CMakeLists.txt

@@ -25,6 +25,7 @@ add_library(Parsodus-tables
     lrtables/SLR1Itemset.cpp
     lrtables/LR1Item.cpp
     lrtables/LR1Itemset.cpp
+    lrtables/LALR1Itemset.cpp
     )
 
 # add_library(Parsodus-backends

src/lrtables/LALR1Itemset.cpp

@@ -0,0 +1,56 @@
+#include "Parsodus/lrtables/LALR1Itemset.h"
+
+#include <cassert>
+
+namespace pds {
+namespace lr {
+
+LALR1Itemset::LALR1Itemset() : LR1ItemsetBase<LALR1Itemset>()
+{}
+
+LALR1Itemset::LALR1Itemset(std::shared_ptr<Rule> start) : LR1ItemsetBase<LALR1Itemset>(start)
+{}
+
+bool LALR1Itemset::canMerge(const LALR1Itemset& rhs) const {
+    if (rhs.m_items.size() != m_items.size()) {
+        return false;
+    }
+
+    for (auto& rhsIt : rhs.m_items) {
+        bool ok = false;
+        for (auto& it : m_items) {
+            if (it.rule == rhsIt.rule && it.dotIdx == rhsIt.dotIdx) {
+                ok = true;
+                break;
+            }
+        }
+        if (!ok)
+            return false;
+    }
+
+    return true;
+}
+
+bool LALR1Itemset::merge(const LALR1Itemset& rhs) {
+    bool change = false;
+    for (auto& toMerge : rhs.m_items) {
+        bool found = false;
+        for (auto& it : m_items) {
+            if (it.rule == toMerge.rule && it.dotIdx == toMerge.dotIdx) {
+                found = true;
+                for (auto& la : toMerge.lookaheads) {
+                    if (!it.lookaheads.count(la)) {
+                        change = true;
+                        it.lookaheads.insert(la);
+                    }
+                }
+                break;
+            }
+        }
+        assert(found);
+    }
+    return change;
+}
+
+} /* lr  */ 
+} /* pds  */ 

src/lrtables/LR1Itemset.cpp

@@ -13,8 +13,9 @@ bool LR1Itemset::canMerge(const LR1Itemset&) const {
     return false;
 }
 
-void LR1Itemset::merge(const LR1Itemset&) {
+bool LR1Itemset::merge(const LR1Itemset&) {
     //NO-OP
+    return false;
 }
 
 } /* lr */