146 lines
4.2 KiB
C++
146 lines
4.2 KiB
C++
/*
|
|
Copyright (c) 2015, Matthias Schiffer <mschiffer@universe-factory.net>
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
#include "generator.hpp"
|
|
|
|
#include <queue>
|
|
|
|
|
|
namespace solar {
|
|
|
|
std::set<item_t> generator_t::get_set(const std::string &nonterm) {
|
|
std::set<item_t> set;
|
|
|
|
auto entries = nonterms.equal_range(nonterm);
|
|
for (auto entry = entries.first; entry != entries.second; ++entry)
|
|
set.insert(std::get<0>(rules[entry->second]));
|
|
|
|
return set;
|
|
}
|
|
|
|
void generator_t::close_set(std::set<item_t> *set) {
|
|
std::queue<item_t> queue;
|
|
for (const item_t &item : *set)
|
|
queue.emplace(item);
|
|
|
|
for (; !queue.empty(); queue.pop()) {
|
|
const item_t &cur = queue.front();
|
|
if (!cur.has_next())
|
|
continue;
|
|
|
|
const symbol_t &sym = cur.get_next_symbol();
|
|
if (sym.get_type() != SYMBOL_TYPE_NONTERM)
|
|
continue;
|
|
|
|
for (const item_t &item : get_set(sym.get_value())) {
|
|
if (set->insert(item).second)
|
|
queue.push(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
void generator_t::generate_itemsets() {
|
|
std::queue<std::pair<std::set<item_t>, size_t>> queue;
|
|
|
|
{
|
|
std::set<item_t> set0 = get_set("");
|
|
close_set(&set0);
|
|
|
|
queue.push(*add_set(set0).first);
|
|
}
|
|
|
|
for (; !queue.empty(); queue.pop()) {
|
|
const auto &cur = queue.front();
|
|
|
|
const std::set<item_t> empty_set;
|
|
std::map<symbol_t, std::set<item_t>> new_sets;
|
|
|
|
for (const item_t &item : cur.first) {
|
|
if (!item.has_next())
|
|
continue;
|
|
|
|
const symbol_t &sym = item.get_next_symbol();
|
|
|
|
item_t shifted = item;
|
|
shifted.shift();
|
|
|
|
std::set<item_t> &set = new_sets.insert(std::make_pair(sym, empty_set)).first->second;
|
|
set.insert(std::move(shifted));
|
|
}
|
|
|
|
for (auto &entry : new_sets) {
|
|
close_set(&entry.second);
|
|
|
|
auto added = add_set(entry.second);
|
|
|
|
if (entry.first.get_type() == SYMBOL_TYPE_NONTERM)
|
|
add_goto(cur.second, entry.first.get_value(), added.first->second);
|
|
else
|
|
add_shift(cur.second, entry.first, added.first->second);
|
|
|
|
if (added.second)
|
|
queue.push(*added.first);
|
|
}
|
|
|
|
for (const item_t &item : cur.first) {
|
|
auto it = rule_ids.find(item);
|
|
if (it != rule_ids.end()) {
|
|
if (it->second)
|
|
add_reduction(cur.second, it->second);
|
|
else
|
|
add_shift(cur.second, symbol_t::make_nonterm(""), 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
generator_t::generator_t(const std::vector<std::tuple<item_t, std::vector<std::string>, std::string>> &rules0,
|
|
const std::map<std::string, std::string> &nonterm_types0,
|
|
const std::map<symbol_t, std::pair<std::string, std::string>> &term_types0)
|
|
: rules(rules0), nonterm_types(nonterm_types0), term_types(term_types0) {
|
|
for (size_t i = 0; i < rules.size(); i++) {
|
|
item_t rule = std::get<0>(rules[i]);
|
|
|
|
nonterminals.insert(rule.get_lhs());
|
|
nonterms.insert(std::make_pair(rule.get_lhs(), i));
|
|
|
|
while (rule.has_next()) {
|
|
const symbol_t &sym = rule.get_next_symbol();
|
|
items.insert(std::make_pair(sym, rule));
|
|
|
|
if (sym.get_type() != SYMBOL_TYPE_NONTERM)
|
|
terminals.insert(sym);
|
|
|
|
rule.shift();
|
|
}
|
|
|
|
rule_ids.insert(std::make_pair(rule, i));
|
|
}
|
|
|
|
generate_itemsets();
|
|
}
|
|
|
|
}
|