diff --git a/TODO b/TODO index d043b22..286342b 100644 --- a/TODO +++ b/TODO @@ -18,28 +18,28 @@ K> Parsodus Parsodus parser #R 1 enkel LR(1) #K 1 LR(1) + LALR(1) #T 1 LR(0) - -> Table generator (independent of specific tables)??? +-> JSON/example tests + -> presentation --> Error reporting -> publication / LICENSE --> --- logging - -> write configuration sets, table - -> Generator: logging - -> driver/main: debug flag - ----------------------------------------------------------------------- - MOSTLY DONE - ----------------------------------------------------------------------- -R> README +R> README: bash completion + precedence R> JSON port -> rewrite once named rules exist ----------------------------------------------------------------------- - DONE - ----------------------------------------------------------------------- +-> logging + -> write configuration sets, table + -> Generator: logging + -> driver/main: debug flag +-> Error reporting -> bool specialization in backend? T> Parsodus regex parser in Lexesis -> Vrijgeven in libraryformaat: mogelijkheid verschillende tokens opvragen diff --git a/include/Parsodus/lrtables/LR0ItemsetBase.h b/include/Parsodus/lrtables/LR0ItemsetBase.h index 5888fa6..3bc54e7 100644 --- a/include/Parsodus/lrtables/LR0ItemsetBase.h +++ b/include/Parsodus/lrtables/LR0ItemsetBase.h @@ -4,6 +4,9 @@ #include "Parsodus/lrtables/LR0Item.h" +#include +#include + namespace pds { namespace lr { @@ -24,6 +27,21 @@ public: bool merge(const Itemset& rhs); bool empty() const; + friend std::ostream& operator<<(std::ostream& os, const LR0ItemsetBase& its) { + for (const auto& it : its.m_items) { + os << it.rule->head << " ->"; + for (std::size_t i = 0; i < it.rule->tail.size(); i++) { + if (i == it.dotIdx) + os << " ·"; + os << " " << it.rule->tail[i]; + } + if (it.dotIdx == it.rule->tail.size()) + os << " ·"; + os << std::endl; + } + return os; + } + protected: std::set m_items; }; diff --git a/include/Parsodus/lrtables/LR1ItemsetBase.h b/include/Parsodus/lrtables/LR1ItemsetBase.h index 108bfa5..e9f7b28 100644 --- a/include/Parsodus/lrtables/LR1ItemsetBase.h +++ b/include/Parsodus/lrtables/LR1ItemsetBase.h @@ -6,6 +6,8 @@ #include "Parsodus/util/symbols.h" #include +#include +#include namespace pds { namespace lr { @@ -24,6 +26,28 @@ public: bool empty() const; std::set getReduces(const Grammar& g, std::string lookahead) const; + friend std::ostream& operator<<(std::ostream& os, const LR1ItemsetBase& its) { + for (const auto& it : its.m_items) { + os << it.rule->head << " ->"; + for (std::size_t i = 0; i < it.rule->tail.size(); i++) { + if (i == it.dotIdx) + os << " ·"; + os << " " << it.rule->tail[i]; + } + if (it.dotIdx == it.rule->tail.size()) + os << " ·"; + + os << " ["; + for (auto la = it.lookaheads.cbegin(); la != it.lookaheads.cend(); la++) { + if (la != it.lookaheads.cbegin()) + os << ", "; + os << *la; + } + os << "]" << std::endl; + } + return os; + } + protected: std::vector m_items; }; diff --git a/include/Parsodus/lrtables/generator.h b/include/Parsodus/lrtables/generator.h index 576e03f..07f2f28 100644 --- a/include/Parsodus/lrtables/generator.h +++ b/include/Parsodus/lrtables/generator.h @@ -6,6 +6,8 @@ #include "Parsodus/util/symbols.h" #include "Parsodus/lrtables/table.h" +#include "g3log/g3log.hpp" + #include #include #include @@ -80,6 +82,9 @@ LRTable Generator::generate() { m_gram.variables.begin(), m_gram.variables.end(), std::inserter(symbols, symbols.end())); + std::map>> errors; + bool reduceReduce = false; + std::queue> q; q.emplace(0, itemsets[0]); while (!q.empty()) { @@ -131,7 +136,6 @@ LRTable Generator::generate() { table.act[curIdx][term] = std::make_pair(Action::ACCEPT, 0); } else if (table.act[curIdx].count(term)) { if (table.act[curIdx][term].first == Action::SHIFT) { - //Shift-Reduce conflict, rapport and resolve it (TODO) bool handled = false; auto rightTokenIt = m_gram.precedence.find(term); @@ -151,15 +155,21 @@ LRTable Generator::generate() { } else if (leftPrec.second == PrecedenceType::RIGHT) { // Keep the shift handled = true; - } //Nonassoc falls through + } else { + //make it an error + table.act[curIdx][term] = {Action::ERROR, 0}; + handled = true; + } + } + if (!handled) { + LOG(WARNING) << "Shift/reduce conflict in state " << curIdx << ", favouring shift" << std::endl; + errors[curIdx][term] = {Action::REDUCE, rule_applied}; } - - if (!handled) - throw std::runtime_error("shift-reduce"); } else if (table.act[curIdx][term].first == Action::REDUCE && table.act[curIdx][term].second != rule_applied) { - //Reduce-Reduce conflict, rapport it (TODO) - throw std::runtime_error("reduce-reduce"); + LOG(WARNING) << "Reduce/reduce conflict in state " << curIdx << std::endl; + errors[curIdx][term] = {Action::REDUCE, rule_applied}; + reduceReduce = true; } else { //Reduce using the same rule, no problem, NO-OP } @@ -171,10 +181,59 @@ LRTable Generator::generate() { } } + auto reporter = [&table](std::size_t idx, std::string sym, const std::pair& p) -> std::string { + switch (p.first) { + case Action::ERROR: + return "on " + sym + " fail\n"; + case Action::SHIFT: + return "on " + sym + " shift and go to " + std::to_string(table.act[idx][sym].second) + "\n"; + case Action::REDUCE: + return "on " + sym + " reduce with rule " + std::to_string(table.act[idx][sym].second) + "\n"; + case Action::ACCEPT: + return "on " + sym + " accept\n"; + default: + return ""; + } + }; + + for (std::size_t idx = 0; idx < itemsets.size(); idx++) { + LOG(INFO) << "State " << idx << std::endl + << itemsets[idx] << std::endl; + for (std::string terminal : m_gram.terminals) { + auto pIt = table.act[idx].find(terminal); + if (pIt != table.act[idx].end()) { + LOG(INFO) << reporter(idx, terminal, pIt->second); + } else { + LOG(INFO) << reporter(idx, terminal, {Action::ERROR, 0}); + } + } + LOG(INFO) << std::endl; + bool doneGoto = false, doneError = false; + for (std::string var : m_gram.variables) { + if (table.goto_[idx].count(var)) { + LOG(INFO) << "after " << var << " go to state " << table.goto_[idx][var] << std::endl; + doneGoto = true; + } + } + if (doneGoto) + LOG(INFO) << std::endl; + for (auto& p : errors[idx]) { + doneError = true; + LOG(INFO) << "! " << reporter(idx, p.first, p.second); + } + if (doneError) + LOG(INFO) << std::endl; + LOG(INFO) << std::string(50, '=') << std::endl << std::endl; + } + + if (reduceReduce) { + throw std::runtime_error("Stopped generating because of errors in the file"); + } + return table; } } /* lr */ -} /* pdf */ +} /* pds */ #endif /* PARSODUS_LRTABLES_GENERATOR_H_YW3GIUNH */ diff --git a/templates/c++/lr.h b/templates/c++/lr.h index 26be0c4..c8814d0 100644 --- a/templates/c++/lr.h +++ b/templates/c++/lr.h @@ -119,9 +119,6 @@ inline std::string to_string({{name}}_Symbol s) { case {{name}}_Symbol::{{symbol}}: return "{{symbol}}"; {{/symbols}} - default: - //should not happen - return "?"; } } diff --git a/tests/lr0_shift-red.cpp b/tests/lr0_shift-red.cpp index 08a2423..aa90c8c 100644 --- a/tests/lr0_shift-red.cpp +++ b/tests/lr0_shift-red.cpp @@ -45,15 +45,6 @@ TEST(lr0, test0) { grammar.rules.push_back(std::make_shared(*rule)); - { - pds::lr::Generator g(grammar); - ASSERT_THROW(g.generate(), std::runtime_error); - try { - g.generate(); - } catch (std::runtime_error& e) { - ASSERT_EQ(std::string("shift-reduce"), e.what()); - } - } { pds::lr::Generator g(grammar); ASSERT_NO_THROW(g.generate()); diff --git a/tests/lr1_only.cpp b/tests/lr1_only.cpp index ed08e99..ba0319e 100644 --- a/tests/lr1_only.cpp +++ b/tests/lr1_only.cpp @@ -86,11 +86,6 @@ TEST(lr1, only) { { pds::lr::Generator g(grammar); ASSERT_THROW(g.generate(), std::runtime_error); - try { - g.generate(); - } catch (std::runtime_error& e) { - ASSERT_EQ(std::string("reduce-reduce"), e.what()); - } } }