From d2e01be5c6b193013922de3f15a4d4f305ef6631 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Wed, 19 Sep 2018 08:52:02 +0200
Subject: [PATCH] working template redesign for regular and context free
grammars
---
alib2algo/src/grammar/convert/ToAutomaton.cpp | 10 +-
.../src/grammar/generate/GenerateUpToLength.h | 2 +-
.../grammar/generate/RandomGrammarFactory.cpp | 6 +-
.../src/grammar/generate/RandomizeGrammar.h | 20 +-
.../src/grammar/simplify/EpsilonRemover.h | 28 +-
.../grammar/simplify/LeftRecursionRemover.h | 66 ++---
alib2algo/src/grammar/simplify/ToCNF.cpp | 58 ++--
alib2algo/src/grammar/simplify/ToCNF.h | 12 +-
alib2algo/src/grammar/simplify/ToGNF.cpp | 12 +-
alib2algo/src/grammar/simplify/ToGNF.h | 101 +++----
.../grammar/convert/GrammarCFGtoPDATest.cpp | 24 +-
.../properties/GrammarPropertiesTest.cpp | 12 +-
.../grammar/simplify/GrammarToCNFTest.cpp | 18 +-
.../grammar/simplify/GrammarToGNFTest.cpp | 88 +++---
.../grammar/parsing/AbsorbTerminalSymbol.cpp | 14 +-
.../grammar/parsing/CornerSubstitution.cpp | 4 +-
.../grammar/parsing/ExtractRightContext.cpp | 6 +-
.../parsing/HandleFirstFollowConflict.cpp | 10 +-
.../src/grammar/parsing/LR0Parser.cpp | 50 ++--
.../src/grammar/parsing/LR0Parser.h | 4 +-
.../src/grammar/parsing/LRParser.cpp | 8 +-
.../src/grammar/parsing/LRParser.h | 2 +-
.../src/grammar/parsing/LeftFactorize.cpp | 8 +-
.../src/grammar/parsing/SLR1ParseTable.cpp | 29 +-
.../src/grammar/parsing/common/Substitute.cpp | 6 +-
.../src/grammar/parsing/common/Substitute.h | 2 +-
.../grammar/parsing/CornerSubstitution.cpp | 54 ++--
.../grammar/parsing/ExtractRightContext.cpp | 46 ++--
.../test-src/grammar/parsing/FirstTest.cpp | 250 ++++++++----------
.../test-src/grammar/parsing/FollowTest.cpp | 40 +--
.../parsing/HandleFirstFirstConflict.cpp | 88 +++---
.../parsing/HandleFirstFollowConflict.cpp | 88 +++---
.../grammar/parsing/LL1ParseTable.cpp | 81 +++---
.../test-src/grammar/parsing/LR0Parser.cpp | 59 ++---
.../test-src/grammar/parsing/LRParser.cpp | 10 +-
.../grammar/parsing/LeftFactorize.cpp | 72 ++---
.../grammar/parsing/SLR1ParseTable.cpp | 122 ++++-----
alib2data/src/PrimitiveRegistrator.cpp | 1 +
.../src/alphabet/common/SymbolNormalize.h | 23 ++
alib2data/src/grammar/AddRawRule.h | 44 ++-
alib2data/src/grammar/ContextFree/CFG.h | 174 ++++++------
alib2data/src/grammar/ContextFree/CNF.h | 212 +++++++--------
.../src/grammar/ContextFree/EpsilonFreeCFG.h | 170 ++++++------
alib2data/src/grammar/ContextFree/GNF.h | 166 ++++++------
alib2data/src/grammar/RawRules.h | 64 ++---
alib2data/src/grammar/Regular/LeftLG.h | 50 ++--
alib2data/src/grammar/xml/ContextFree/CFG.h | 42 +--
alib2data/src/grammar/xml/ContextFree/CNF.h | 46 ++--
.../grammar/xml/ContextFree/EpsilonFreeCFG.h | 42 +--
alib2data/src/grammar/xml/ContextFree/GNF.h | 46 ++--
.../grammar/xml/common/GrammarFromXMLParser.h | 30 ---
.../grammar/xml/common/GrammarToXMLComposer.h | 12 +-
alib2data/test-src/grammar/GrammarTest.cpp | 153 +++++++----
.../src/grammar/parsing/LRParserTypes.h | 6 +-
.../src/label/xml/LR0ItemsLabel.cpp | 1 +
alib2str/src/grammar/string/ContextFree/GNF.h | 22 +-
56 files changed, 1405 insertions(+), 1409 deletions(-)
diff --git a/alib2algo/src/grammar/convert/ToAutomaton.cpp b/alib2algo/src/grammar/convert/ToAutomaton.cpp
index e76d5f55e4..84a1a70abe 100644
--- a/alib2algo/src/grammar/convert/ToAutomaton.cpp
+++ b/alib2algo/src/grammar/convert/ToAutomaton.cpp
@@ -109,9 +109,13 @@ automaton::NPDA < > ToAutomaton::convert(const T& grammar) {
for(const DefaultSymbolType& symbol : grammar.getTerminalAlphabet())
automaton.addPushdownStoreSymbol(symbol);
- for(const std::pair<const DefaultSymbolType, ext::set<ext::vector<DefaultSymbolType>>>& kv : grammar.getRules())
- for(const ext::vector<DefaultSymbolType>& rhs : kv.second)
- automaton.addTransition(automaton.getInitialState(), ext::vector<DefaultSymbolType>{kv.first}, automaton.getInitialState(), rhs);
+ for(const std::pair<const DefaultSymbolType, ext::set<ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>>>& kv : grammar.getRules())
+ for(const ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>& rhs : kv.second) {
+ ext::vector < DefaultSymbolType > tmp;
+ for ( const ext::variant < DefaultSymbolType, DefaultSymbolType > & symbol : rhs )
+ tmp.push_back ( symbol.get < DefaultSymbolType > ( ) );
+ automaton.addTransition(automaton.getInitialState(), ext::vector<DefaultSymbolType>{kv.first}, automaton.getInitialState(), tmp);
+ }
for(const DefaultSymbolType& symbol : grammar.getTerminalAlphabet())
automaton.addTransition(automaton.getInitialState(), symbol, ext::vector<DefaultSymbolType>{symbol}, automaton.getInitialState(), ext::vector<DefaultSymbolType>{});
diff --git a/alib2algo/src/grammar/generate/GenerateUpToLength.h b/alib2algo/src/grammar/generate/GenerateUpToLength.h
index 45e0487520..5007490124 100644
--- a/alib2algo/src/grammar/generate/GenerateUpToLength.h
+++ b/alib2algo/src/grammar/generate/GenerateUpToLength.h
@@ -66,7 +66,7 @@ ext::set < string::LinearString < TerminalSymbolType > > GenerateUpToLength::gen
ext::vector < TerminalSymbolType > newString ( item.first );
newStack.insert ( newStack.end ( ), rhs.rbegin ( ), rhs.rend ( ) );
- while ( ! newStack.empty ( ) && grammar.getTerminalAlphabet ( ).count ( newStack.back ( ).template get < TerminalSymbolType > ( ) ) ) {
+ while ( ! newStack.empty ( ) && grammar.getTerminalAlphabet ( ).count ( newStack.back ( ) ) ) {
newString.push_back ( std::move ( newStack.back ( ).template get < TerminalSymbolType > ( ) ) );
newStack.pop_back ( );
}
diff --git a/alib2algo/src/grammar/generate/RandomGrammarFactory.cpp b/alib2algo/src/grammar/generate/RandomGrammarFactory.cpp
index 7c4a26ae6f..f612148ac4 100644
--- a/alib2algo/src/grammar/generate/RandomGrammarFactory.cpp
+++ b/alib2algo/src/grammar/generate/RandomGrammarFactory.cpp
@@ -65,14 +65,14 @@ grammar::CFG < > RandomGrammarFactory::randomCFG( const ext::deque<DefaultSymbol
const DefaultSymbolType& lhs = nonterminals[ext::random_devices::semirandom() % nonterminals.size()];
int rhsSize = ext::random_devices::semirandom() % 5;
- ext::vector<DefaultSymbolType> rhs;
+ ext::vector<ext::variant<DefaultSymbolType, DefaultSymbolType>> rhs;
int nonterminalsOnRHS = 0;
for(int i = 0; i < rhsSize; i++) {
if(ext::random_devices::semirandom() % (nonterminals.size() + terminals.size()) < nonterminals.size()) {
- rhs.push_back(nonterminals[ext::random_devices::semirandom() % nonterminals.size()]);
+ rhs.push_back(ext::variant < DefaultSymbolType, DefaultSymbolType > ( nonterminals[ext::random_devices::semirandom() % nonterminals.size()]));
nonterminalsOnRHS++;
} else {
- rhs.push_back(terminals[ext::random_devices::semirandom() % terminals.size()]);
+ rhs.push_back(ext::variant < DefaultSymbolType, DefaultSymbolType > ( terminals[ext::random_devices::semirandom() % terminals.size()]));
}
}
rules += nonterminalsOnRHS;
diff --git a/alib2algo/src/grammar/generate/RandomizeGrammar.h b/alib2algo/src/grammar/generate/RandomizeGrammar.h
index 464f65dda9..0fadf8bae5 100644
--- a/alib2algo/src/grammar/generate/RandomizeGrammar.h
+++ b/alib2algo/src/grammar/generate/RandomizeGrammar.h
@@ -30,8 +30,8 @@ public:
static grammar::RightRG < SymbolType > randomize ( const grammar::RightRG < SymbolType > & gram );
template < class SymbolType >
static grammar::RightLG < SymbolType > randomize ( const grammar::RightLG < SymbolType > & gram );
- template < class SymbolType >
- static grammar::CFG < SymbolType > randomize ( const grammar::CFG < SymbolType > & gram );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::CFG < TerminalSymbolType, NonterminalSymbolType > randomize ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & gram );
};
@@ -111,20 +111,20 @@ grammar::RightLG < SymbolType > RandomizeGrammar::randomize ( const grammar::Rig
return res;
}
-template < class SymbolType >
-grammar::CFG < SymbolType > RandomizeGrammar::randomize ( const grammar::CFG < SymbolType > & gram ) {
- ext::map < SymbolType, SymbolType > symbolPermutationMap = common::Permutation::permutationMap ( gram.getNonterminalAlphabet ( ) );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::CFG < TerminalSymbolType, NonterminalSymbolType > RandomizeGrammar::randomize ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & gram ) {
+ ext::map < NonterminalSymbolType, NonterminalSymbolType > symbolPermutationMap = common::Permutation::permutationMap ( gram.getNonterminalAlphabet ( ) );
- grammar::CFG < SymbolType > res ( symbolPermutationMap.find ( gram.getInitialSymbol ( ) )->second );
+ grammar::CFG < TerminalSymbolType, NonterminalSymbolType > res ( symbolPermutationMap.find ( gram.getInitialSymbol ( ) )->second );
res.setNonterminalAlphabet ( gram.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( gram.getTerminalAlphabet ( ) );
- for ( const std::pair < SymbolType, ext::set < ext::vector < SymbolType > > > & rule : gram.getRules ( ) )
- for ( const ext::vector < SymbolType > & rhs : rule.second )
- res.addRule ( symbolPermutationMap.find ( rule.first )->second, ext::transform < SymbolType > ( rhs, [ & ] ( const SymbolType & elem ) {
+ for ( const std::pair < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & rule : gram.getRules ( ) )
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs : rule.second )
+ res.addRule ( symbolPermutationMap.find ( rule.first )->second, ext::transform < ext::variant < TerminalSymbolType, NonterminalSymbolType > > ( rhs, [ & ] ( const ext::variant < TerminalSymbolType, NonterminalSymbolType > & elem ) {
if ( gram.getNonterminalAlphabet ( ).count ( elem ) )
- return symbolPermutationMap.find ( elem )->second;
+ return ext::variant < TerminalSymbolType, NonterminalSymbolType > ( symbolPermutationMap.find ( elem )->second );
else
return elem;
} ) );
diff --git a/alib2algo/src/grammar/simplify/EpsilonRemover.h b/alib2algo/src/grammar/simplify/EpsilonRemover.h
index b91a62ed3e..11d020ef20 100644
--- a/alib2algo/src/grammar/simplify/EpsilonRemover.h
+++ b/alib2algo/src/grammar/simplify/EpsilonRemover.h
@@ -33,13 +33,13 @@ namespace simplify {
class EpsilonRemover {
template < class TerminalSymbolType, class NonterminalSymbolType >
- static void removeNullableNonterminals(grammar::EpsilonFreeCFG < TerminalSymbolType > & grammar, const ext::set < NonterminalSymbolType >& nullableNonterminals, const NonterminalSymbolType & lhs, const ext::vector<ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs, unsigned i, ext::vector < TerminalSymbolType > clear);
+ static void removeNullableNonterminals(grammar::EpsilonFreeCFG < TerminalSymbolType > & grammar, const ext::set < NonterminalSymbolType >& nullableNonterminals, const NonterminalSymbolType & lhs, const ext::vector<ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs, unsigned i, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > clear);
- template<class T, class SymbolType = typename grammar::TerminalSymbolTypeOfGrammar < T > >
- static grammar::EpsilonFreeCFG < SymbolType > removeInternal( const T & origGrammar );
+ template<class T, class TerminalSymbolType = typename grammar::TerminalSymbolTypeOfGrammar < T >, class NonterminalSymbolType = typename grammar::NonterminalSymbolTypeOfGrammar < T > >
+ static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > removeInternal( const T & origGrammar );
public:
- template < class SymbolType >
- static grammar::EpsilonFreeCFG < SymbolType > remove( const grammar::CFG < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType >
static grammar::EpsilonFreeCFG < SymbolType > remove( const grammar::EpsilonFreeCFG < SymbolType > & grammar );
template < class SymbolType >
@@ -59,24 +59,24 @@ public:
};
template < class TerminalSymbolType, class NonterminalSymbolType >
-void EpsilonRemover::removeNullableNonterminals(grammar::EpsilonFreeCFG < TerminalSymbolType > & grammar, const ext::set < NonterminalSymbolType > & nullableNonterminals, const NonterminalSymbolType & lhs, const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs, unsigned i, ext::vector < TerminalSymbolType > clear) {
+void EpsilonRemover::removeNullableNonterminals(grammar::EpsilonFreeCFG < TerminalSymbolType > & grammar, const ext::set < NonterminalSymbolType > & nullableNonterminals, const NonterminalSymbolType & lhs, const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs, unsigned i, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > clear) {
if(rhs.size() == i) {
if(clear.size() == 0) return;
grammar.addRule(lhs, clear);
} else if(rhs[i].template is < NonterminalSymbolType > ( ) && nullableNonterminals.find ( rhs [ i ].template get < NonterminalSymbolType > ( ) ) != nullableNonterminals.end()) {
removeNullableNonterminals(grammar, nullableNonterminals, lhs, rhs, i+1, clear);
- clear.push_back(rhs[i].template get < NonterminalSymbolType > ( ) );
+ clear.push_back ( rhs [ i ] );
removeNullableNonterminals(grammar, nullableNonterminals, lhs, rhs, i+1, clear);
} else {
- clear.push_back(rhs[i].template get < TerminalSymbolType > ( ) );
+ clear.push_back ( rhs [ i ] );
removeNullableNonterminals(grammar, nullableNonterminals, lhs, rhs, i+1, clear);
}
}
-template<class T, class SymbolType >
-grammar::EpsilonFreeCFG < SymbolType > EpsilonRemover::removeInternal( const T & origGrammar ) {
- grammar::EpsilonFreeCFG < SymbolType > grammar(origGrammar.getInitialSymbol());
+template<class T, class TerminalSymbolType, class NonterminalSymbolType >
+grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > EpsilonRemover::removeInternal( const T & origGrammar ) {
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > grammar(origGrammar.getInitialSymbol());
for( const auto & symbol : origGrammar.getNonterminalAlphabet() )
grammar.addNonterminalSymbol( symbol );
@@ -84,7 +84,7 @@ grammar::EpsilonFreeCFG < SymbolType > EpsilonRemover::removeInternal( const T &
for( const auto & symbol : origGrammar.getTerminalAlphabet() )
grammar.addTerminalSymbol( symbol );
- ext::set<SymbolType> nullableNonterminals = grammar::properties::NullableNonterminals::getNullableNonterminals(origGrammar);
+ ext::set < NonterminalSymbolType > nullableNonterminals = grammar::properties::NullableNonterminals::getNullableNonterminals(origGrammar);
auto rawRules = grammar::RawRules::getRawRules ( origGrammar );
@@ -101,8 +101,8 @@ grammar::EpsilonFreeCFG < SymbolType > EpsilonRemover::removeInternal( const T &
return grammar;
}
-template < class SymbolType >
-grammar::EpsilonFreeCFG < SymbolType > EpsilonRemover::remove(const grammar::CFG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > EpsilonRemover::remove(const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return EpsilonRemover::removeInternal(origGrammar);
}
diff --git a/alib2algo/src/grammar/simplify/LeftRecursionRemover.h b/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
index a536828664..c3b4dff95a 100644
--- a/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
+++ b/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
@@ -31,14 +31,14 @@ namespace grammar {
namespace simplify {
class LeftRecursionRemover {
- template < class SymbolType >
- static grammar::EpsilonFreeCFG < SymbolType > directLeftRecursionRemoveAsOrder ( const grammar::EpsilonFreeCFG < SymbolType > & origGrammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > directLeftRecursionRemoveAsOrder ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar );
- template < class SymbolType >
- static grammar::EpsilonFreeCFG < SymbolType > assignAsOrder ( const grammar::EpsilonFreeCFG < SymbolType > & origGrammar, unsigned i, const ext::set< SymbolType >& origNonterminals );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > assignAsOrder ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar, unsigned i, const ext::set < NonterminalSymbolType > & origNonterminals );
public:
- template < class SymbolType >
- static grammar::EpsilonFreeCFG < SymbolType > remove( const grammar::EpsilonFreeCFG < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType >
static grammar::EpsilonFreeCFG < SymbolType > remove( const grammar::CNF < SymbolType > & grammar );
template < class SymbolType >
@@ -53,9 +53,9 @@ public:
static grammar::RightLG < SymbolType > remove( const grammar::LeftLG < SymbolType > & grammar );
};
-template < class SymbolType >
-grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::directLeftRecursionRemoveAsOrder(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar) {
- grammar::EpsilonFreeCFG < SymbolType > res(origGrammar.getInitialSymbol());
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > LeftRecursionRemover::directLeftRecursionRemoveAsOrder(const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > res(origGrammar.getInitialSymbol());
res.setNonterminalAlphabet(origGrammar.getNonterminalAlphabet());
res.setTerminalAlphabet(origGrammar.getTerminalAlphabet());
res.setGeneratesEpsilon(origGrammar.getGeneratesEpsilon());
@@ -63,23 +63,23 @@ grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::directLeftRecursion
for(const auto& nonterminal : origGrammar.getNonterminalAlphabet()) {
if(origGrammar.getRules().find(nonterminal) == origGrammar.getRules().end()) continue;
- if(std::any_of(origGrammar.getRules().find(nonterminal)->second.begin(), origGrammar.getRules().find(nonterminal)->second.end(), [&](const ext::vector<SymbolType>& singleRHS) {
+ if(std::any_of(origGrammar.getRules().find(nonterminal)->second.begin(), origGrammar.getRules().find(nonterminal)->second.end(), [&](const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & singleRHS ) {
return singleRHS[0] == nonterminal; // is there a direct left recursion?
- } ) && std::all_of(origGrammar.getRules().find(nonterminal)->second.begin(), origGrammar.getRules().find(nonterminal)->second.end(), [&](const ext::vector<SymbolType>& singleRHS) {
+ } ) && std::all_of(origGrammar.getRules().find(nonterminal)->second.begin(), origGrammar.getRules().find(nonterminal)->second.end(), [&](const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & singleRHS) {
return origGrammar.getTerminalAlphabet().count(singleRHS[0]) || singleRHS[0] >= nonterminal; // only remove left recursion when all nonterminals are bigger than the left hand side
})) {
- SymbolType primed = common::createUnique(nonterminal, res.getTerminalAlphabet(), res.getNonterminalAlphabet());
+ NonterminalSymbolType primed = common::createUnique(nonterminal, res.getTerminalAlphabet(), res.getNonterminalAlphabet());
res.addNonterminalSymbol(primed);
- for(const ext::vector<SymbolType>& singleRHS : origGrammar.getRules().find(nonterminal)->second) { // do the removal
+ for(const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & singleRHS : origGrammar.getRules().find(nonterminal)->second) { // do the removal
if(singleRHS[0] == nonterminal) { // A -> A alpha
- ext::vector<SymbolType> tmpRHS(singleRHS.begin() + 1, singleRHS.end());
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > tmpRHS(singleRHS.begin() + 1, singleRHS.end());
res.addRule(primed, tmpRHS); // A' -> alpha
tmpRHS.push_back(primed);
res.addRule(primed, tmpRHS); // A' -> alpha A'
} else { // a -> beta
- ext::vector<SymbolType> tmpRHS(singleRHS);
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > tmpRHS(singleRHS);
res.addRule(nonterminal, tmpRHS); // A -> beta
@@ -88,7 +88,7 @@ grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::directLeftRecursion
}
}
} else {
- for(const ext::vector<SymbolType>& singleRHS : origGrammar.getRules().find(nonterminal)->second) {
+ for(const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & singleRHS : origGrammar.getRules().find(nonterminal)->second) {
res.addRule(nonterminal, singleRHS);
}
}
@@ -96,17 +96,17 @@ grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::directLeftRecursion
return res;
}
-template < class SymbolType >
-grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::assignAsOrder(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar, unsigned i, const ext::set<SymbolType>& origNonterminals) {
- grammar::EpsilonFreeCFG < SymbolType > res(origGrammar.getInitialSymbol());
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > LeftRecursionRemover::assignAsOrder ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar, unsigned i, const ext::set < NonterminalSymbolType > & origNonterminals) {
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > res(origGrammar.getInitialSymbol());
res.setNonterminalAlphabet(origGrammar.getNonterminalAlphabet());
res.setTerminalAlphabet(origGrammar.getTerminalAlphabet());
res.setGeneratesEpsilon(origGrammar.getGeneratesEpsilon());
- for(const SymbolType& lhs : origGrammar.getNonterminalAlphabet()) {
+ for(const NonterminalSymbolType& lhs : origGrammar.getNonterminalAlphabet()) {
if(i > 0) {
if(origGrammar.getRules().find(lhs) == origGrammar.getRules().end()) continue;
- for(const ext::vector<SymbolType>& rule : origGrammar.getRules().find(lhs)->second) {
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rule : origGrammar.getRules().find(lhs)->second) {
res.addRule(lhs, rule);
}
@@ -115,20 +115,20 @@ grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::assignAsOrder(const
}
if(origGrammar.getRules().find(lhs) == origGrammar.getRules().end()) continue;
if(!origNonterminals.count(lhs)) { // do not subsitute in nonoriginal nonterminals
- for(const ext::vector<SymbolType>& rule : origGrammar.getRules().find(lhs)->second) {
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rule : origGrammar.getRules().find(lhs)->second) {
res.addRule(lhs, rule);
}
continue;
}
- const ext::set<ext::vector<SymbolType>>& rule = origGrammar.getRules().find(lhs)->second;
+ const ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > & rule = origGrammar.getRules().find(lhs)->second;
- for(const ext::vector<SymbolType>& singleRHS : rule) {
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & singleRHS : rule ) {
if(res.getTerminalAlphabet().count(singleRHS[0])) { //do not substitute terminals
res.addRule(lhs, singleRHS);
continue;
}
- const SymbolType& secondLHS = singleRHS[0];
+ const ext::variant < TerminalSymbolType, NonterminalSymbolType > & secondLHS = singleRHS[0];
if(secondLHS >= lhs) { // substitute only by 0th up to i-th nonterminals right hand sides
res.addRule(lhs, singleRHS);
continue;
@@ -138,8 +138,8 @@ grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::assignAsOrder(const
continue;
}
- for(const ext::vector<SymbolType>& secondSingleRHS : origGrammar.getRules().find(secondLHS)->second) { // do the substitution
- ext::vector<SymbolType> newRHS(secondSingleRHS);
+ for(const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & secondSingleRHS : origGrammar.getRules().find(secondLHS)->second) { // do the substitution
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > newRHS ( secondSingleRHS );
newRHS.insert(newRHS.end(), singleRHS.begin() + 1, singleRHS.end());
res.addRule(lhs, newRHS);
}
@@ -148,15 +148,15 @@ grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::assignAsOrder(const
return res;
}
-template < class SymbolType >
-grammar::EpsilonFreeCFG < SymbolType > LeftRecursionRemover::remove(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar) {
- grammar::EpsilonFreeCFG < SymbolType > step = origGrammar;
- for(const SymbolType& nonterminal : step.getNonterminalAlphabet()) { // remove identities
- step.removeRule(nonterminal, ext::vector<SymbolType>{nonterminal});
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > LeftRecursionRemover::remove(const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > step = origGrammar;
+ for(const NonterminalSymbolType& nonterminal : step.getNonterminalAlphabet()) { // remove identities
+ step.removeRule(nonterminal, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > >{nonterminal});
}
unsigned i = 0;
while(i < origGrammar.getNonterminalAlphabet().size()) {
- grammar::EpsilonFreeCFG < SymbolType > nextStep = assignAsOrder(directLeftRecursionRemoveAsOrder(step), i, origGrammar.getNonterminalAlphabet());
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > nextStep = assignAsOrder(directLeftRecursionRemoveAsOrder(step), i, origGrammar.getNonterminalAlphabet());
if(step == nextStep) break;
step = std::move(nextStep);
diff --git a/alib2algo/src/grammar/simplify/ToCNF.cpp b/alib2algo/src/grammar/simplify/ToCNF.cpp
index 903a644e95..a82015413e 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToCNF.cpp
@@ -21,14 +21,14 @@ namespace grammar {
namespace simplify {
-void splitRule ( const DefaultSymbolType & lhs, ext::vector < DefaultSymbolType > rhs, grammar::CNF < DefaultSymbolType > & result ) { //After templating the CNF make rhs const reference
+void splitRule ( const DefaultSymbolType & lhs, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhs, grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > & result ) { //After templating the CNF make rhs const reference
switch ( rhs.size ( ) ) {
case 2: {
result.addRule ( lhs, ext::make_pair ( std::move ( rhs [ 0 ] ), std::move ( rhs [ 1 ] ) ) );
break;
}
case 3: {
- ext::vector < DefaultSymbolType > right ( std::make_move_iterator ( std::next ( rhs.begin ( ) ) ), std::make_move_iterator ( rhs.end ( ) ) );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > right ( std::make_move_iterator ( std::next ( rhs.begin ( ) ) ), std::make_move_iterator ( rhs.end ( ) ) );
DefaultSymbolType second = object::ObjectFactory::make ( right );
if ( result.addNonterminalSymbol ( second ) )
splitRule ( second, std::move ( right ), result );
@@ -37,7 +37,7 @@ void splitRule ( const DefaultSymbolType & lhs, ext::vector < DefaultSymbolType
break;
}
default: {
- ext::vector < DefaultSymbolType > left;
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > left;
for ( unsigned i = 0; i < rhs.size ( ) / 2; ++ i )
left.push_back ( std::move ( rhs [ i ] ) );
@@ -45,7 +45,7 @@ void splitRule ( const DefaultSymbolType & lhs, ext::vector < DefaultSymbolType
if ( result.addNonterminalSymbol ( first ) )
splitRule ( first, std::move ( left ), result );
- ext::vector < DefaultSymbolType > right;
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > right;
for ( unsigned i = rhs.size ( ) / 2; i < rhs.size ( ); ++ i )
right.push_back ( std::move ( rhs [ i ] ) );
@@ -59,10 +59,12 @@ void splitRule ( const DefaultSymbolType & lhs, ext::vector < DefaultSymbolType
}
template<class T>
-grammar::CNF < > convertInternal( const T & origGrammar ) {
- grammar::CNF < > result ( origGrammar.getInitialSymbol ( ) );
+grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > convertInternal( const T & origGrammar ) {
+ grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > result ( origGrammar.getInitialSymbol ( ) );
+
+ for ( const DefaultSymbolType & nonterminal : origGrammar.getNonterminalAlphabet ( ) )
+ result.addNonterminalSymbol ( nonterminal );
- result.setNonterminalAlphabet ( origGrammar.getNonterminalAlphabet ( ) );
result.setTerminalAlphabet ( origGrammar.getTerminalAlphabet ( ) );
ext::map < DefaultSymbolType, DefaultSymbolType > terminalToShadowNonterminal;
@@ -74,14 +76,14 @@ grammar::CNF < > convertInternal( const T & origGrammar ) {
}
for ( const auto & rules : origGrammar.getRules ( ) ) {
- for ( const ext::vector < DefaultSymbolType > & rhs : rules.second ) {
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : rules.second ) {
if ( rhs.size ( ) == 1 ) {
- result.addRule ( rules.first, rhs [ 0 ] );
+ result.addRule ( rules.first, rhs [ 0 ].get < DefaultSymbolType > ( ) );
} else {
- ext::vector < DefaultSymbolType > rawRule;
- for ( const DefaultSymbolType & symbol : rhs ) {
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rawRule;
+ for ( const ext::variant < DefaultSymbolType, DefaultSymbolType > & symbol : rhs ) {
if ( origGrammar.getTerminalAlphabet ( ).count ( symbol ) )
- rawRule.push_back ( terminalToShadowNonterminal.at ( symbol ) );
+ rawRule.push_back ( terminalToShadowNonterminal.at ( symbol.get < DefaultSymbolType > ( ) ) );
else
rawRule.push_back ( symbol );
}
@@ -96,18 +98,20 @@ grammar::CNF < > convertInternal( const T & origGrammar ) {
return result;
}
-grammar::CNF < > ToCNF::convert(const grammar::CFG < > & origGrammar) {
+grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > ToCNF::convert(const grammar::CFG < > & origGrammar) {
return convert(grammar::simplify::EpsilonRemover::remove(origGrammar));
}
-grammar::CNF < > ToCNF::convert(const grammar::EpsilonFreeCFG < > & origGrammar) {
+grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > ToCNF::convert(const grammar::EpsilonFreeCFG < > & origGrammar) {
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(origGrammar));
}
-grammar::CNF < > ToCNF::convert ( const grammar::GNF < > & origGrammar ) {
- grammar::CNF < > result ( origGrammar.getInitialSymbol ( ) );
+grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > ToCNF::convert ( const grammar::GNF < > & origGrammar ) {
+ grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > result ( origGrammar.getInitialSymbol ( ) );
+
+ for ( const DefaultSymbolType & nonterminal : origGrammar.getNonterminalAlphabet ( ) )
+ result.addNonterminalSymbol ( nonterminal );
- result.setNonterminalAlphabet ( origGrammar.getNonterminalAlphabet ( ) );
result.setTerminalAlphabet ( origGrammar.getTerminalAlphabet ( ) );
ext::map < DefaultSymbolType, DefaultSymbolType > terminalToShadowNonterminal;
@@ -123,7 +127,7 @@ grammar::CNF < > ToCNF::convert ( const grammar::GNF < > & origGrammar ) {
if ( rhs.second.size ( ) == 0 )
result.addRule ( rules.first, rhs.first );
else {
- ext::vector < DefaultSymbolType > rawRule { terminalToShadowNonterminal.at ( rhs.first ) };
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rawRule { terminalToShadowNonterminal.at ( rhs.first ) };
rawRule.insert ( rawRule.end ( ), rhs.second.begin ( ), rhs.second.end ( ) );
splitRule ( rules.first, std::move ( rawRule ), result );
}
@@ -135,26 +139,26 @@ grammar::CNF < > ToCNF::convert ( const grammar::GNF < > & origGrammar ) {
return result;
}
-grammar::CNF < > ToCNF::convert(const grammar::LG < > & origGrammar) {
+grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > ToCNF::convert(const grammar::LG < > & origGrammar) {
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
}
-grammar::CNF < > ToCNF::convert(const grammar::LeftLG< > & origGrammar) {
+grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > ToCNF::convert(const grammar::LeftLG< > & origGrammar) {
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
}
-grammar::CNF < > ToCNF::convert(const grammar::RightLG < > & origGrammar) {
+grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > ToCNF::convert(const grammar::RightLG < > & origGrammar) {
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
}
-auto ToCNFCFG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::CFG < > & > ( ToCNF::convert );
-auto ToCNFEpsilonFreeCFG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::EpsilonFreeCFG < > & > ( ToCNF::convert );
+auto ToCNFCFG = registration::AbstractRegister < ToCNF, grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::CFG < > & > ( ToCNF::convert );
+auto ToCNFEpsilonFreeCFG = registration::AbstractRegister < ToCNF, grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::EpsilonFreeCFG < > & > ( ToCNF::convert );
auto ToCNFCNF = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::CNF < > & > ( ToCNF::convert );
-auto ToCNFGNF = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::GNF < > & > ( ToCNF::convert );
-auto ToCNFLG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::LG < > & > ( ToCNF::convert );
-auto ToCNFLeftLG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::LeftLG < > & > ( ToCNF::convert );
+auto ToCNFGNF = registration::AbstractRegister < ToCNF, grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::GNF < > & > ( ToCNF::convert );
+auto ToCNFLG = registration::AbstractRegister < ToCNF, grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::LG < > & > ( ToCNF::convert );
+auto ToCNFLeftLG = registration::AbstractRegister < ToCNF, grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::LeftLG < > & > ( ToCNF::convert );
auto ToCNFLeftRG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::LeftRG < > & > ( ToCNF::convert );
-auto ToCNFRightLG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::RightLG < > & > ( ToCNF::convert );
+auto ToCNFRightLG = registration::AbstractRegister < ToCNF, grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::RightLG < > & > ( ToCNF::convert );
auto ToCNFRightRG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::RightRG < > & > ( ToCNF::convert );
} /* namespace simplify */
diff --git a/alib2algo/src/grammar/simplify/ToCNF.h b/alib2algo/src/grammar/simplify/ToCNF.h
index 8b39636ea3..1b58eeba81 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.h
+++ b/alib2algo/src/grammar/simplify/ToCNF.h
@@ -26,23 +26,23 @@ namespace simplify {
class ToCNF {
public:
- static grammar::CNF < > convert( const grammar::CFG < > & grammar );
+ static grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > convert( const grammar::CFG < > & grammar );
- static grammar::CNF < > convert( const grammar::EpsilonFreeCFG < > & grammar );
+ static grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > convert( const grammar::EpsilonFreeCFG < > & grammar );
- static grammar::CNF < > convert( const grammar::GNF < > & grammar );
+ static grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > convert( const grammar::GNF < > & grammar );
template < class SymbolType >
static grammar::CNF < SymbolType > convert( const grammar::CNF < SymbolType > & grammar );
- static grammar::CNF < > convert( const grammar::LG < > & grammar );
+ static grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > convert( const grammar::LG < > & grammar );
- static grammar::CNF < > convert( const grammar::LeftLG < > & grammar );
+ static grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > convert( const grammar::LeftLG < > & grammar );
template < class SymbolType >
static grammar::CNF < SymbolType > convert( const grammar::LeftRG < SymbolType > & grammar );
- static grammar::CNF < > convert( const grammar::RightLG < > & grammar );
+ static grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > convert( const grammar::RightLG < > & grammar );
template < class SymbolType >
static grammar::CNF < SymbolType > convert( const grammar::RightRG < SymbolType > & grammar );
diff --git a/alib2algo/src/grammar/simplify/ToGNF.cpp b/alib2algo/src/grammar/simplify/ToGNF.cpp
index 8352b12d07..412797732b 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToGNF.cpp
@@ -12,14 +12,14 @@ namespace grammar {
namespace simplify {
-auto ToGNFCFG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::CFG < > & > ( ToGNF::convert );
-auto ToGNFEpsilonFreeCFG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::EpsilonFreeCFG < > & > ( ToGNF::convert );
-auto ToGNFCNF = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::CNF < > & > ( ToGNF::convert );
+auto ToGNFCFG = registration::AbstractRegister < ToGNF, grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::CFG < > & > ( ToGNF::convert );
+auto ToGNFEpsilonFreeCFG = registration::AbstractRegister < ToGNF, grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::EpsilonFreeCFG < > & > ( ToGNF::convert );
+auto ToGNFCNF = registration::AbstractRegister < ToGNF, grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::CNF < > & > ( ToGNF::convert );
auto ToGNFGNF = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::GNF < > & > ( ToGNF::convert );
-auto ToGNFLG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::LG < > & > ( ToGNF::convert );
-auto ToGNFLeftLG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::LeftLG < > & > ( ToGNF::convert );
+auto ToGNFLG = registration::AbstractRegister < ToGNF, grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::LG < > & > ( ToGNF::convert );
+auto ToGNFLeftLG = registration::AbstractRegister < ToGNF, grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::LeftLG < > & > ( ToGNF::convert );
auto ToGNFLeftRG = registration::AbstractRegister < ToGNF, grammar::RightRG < >, const grammar::LeftRG < > & > ( ToGNF::convert );
-auto ToGNFRightLG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::RightLG < > & > ( ToGNF::convert );
+auto ToGNFRightLG = registration::AbstractRegister < ToGNF, grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > >, const grammar::RightLG < > & > ( ToGNF::convert );
auto ToGNFRightRG = registration::AbstractRegister < ToGNF, grammar::RightRG < >, const grammar::RightRG < > & > ( ToGNF::convert );
} /* namespace simplify */
diff --git a/alib2algo/src/grammar/simplify/ToGNF.h b/alib2algo/src/grammar/simplify/ToGNF.h
index 830e879c06..c233a2d6de 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.h
+++ b/alib2algo/src/grammar/simplify/ToGNF.h
@@ -32,53 +32,53 @@ namespace grammar {
namespace simplify {
class ToGNF {
- template < class SymbolType >
- static grammar::EpsilonFreeCFG < SymbolType > assignNonterminals(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar);
- template < class SymbolType >
- static grammar::GNF < SymbolType > convertInternal( const grammar::EpsilonFreeCFG < SymbolType > & origGrammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > assignNonterminals(const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar);
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convertInternal( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar );
public:
- template < class SymbolType >
- static grammar::GNF < SymbolType > convert( const grammar::CFG < SymbolType > & grammar );
- template < class SymbolType >
- static grammar::GNF < SymbolType > convert( const grammar::EpsilonFreeCFG < SymbolType > & grammar );
- template < class SymbolType >
- static grammar::GNF < SymbolType > convert( const grammar::CNF < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType >
static grammar::GNF < SymbolType > convert( const grammar::GNF < SymbolType > & grammar );
- template < class SymbolType >
- static grammar::GNF < SymbolType > convert( const grammar::LG < SymbolType > & grammar );
- template < class SymbolType >
- static grammar::GNF < SymbolType > convert( const grammar::LeftLG < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType >
static grammar::RightRG < SymbolType > convert( const grammar::LeftRG < SymbolType > & grammar );
- template < class SymbolType >
- static grammar::GNF < SymbolType > convert( const grammar::RightLG < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType >
static grammar::RightRG < SymbolType > convert( const grammar::RightRG < SymbolType > & grammar );
};
-template < class SymbolType >
-grammar::EpsilonFreeCFG < SymbolType > ToGNF::assignNonterminals(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar) {
- grammar::EpsilonFreeCFG < SymbolType > res(origGrammar.getInitialSymbol());
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > ToGNF::assignNonterminals(const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > res(origGrammar.getInitialSymbol());
res.setNonterminalAlphabet(origGrammar.getNonterminalAlphabet());
res.setTerminalAlphabet(origGrammar.getTerminalAlphabet());
res.setGeneratesEpsilon(origGrammar.getGeneratesEpsilon());
- for(const std::pair<const SymbolType, ext::set<ext::vector<SymbolType>>>& rule : origGrammar.getRules()) {
- for(const ext::vector<SymbolType>& singleRHS : rule.second) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set<ext::vector<ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & rule : origGrammar.getRules ( ) ) {
+ for(const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & singleRHS : rule.second) {
if(res.getTerminalAlphabet().count(singleRHS[0])) { //do not substitute terminals
res.addRule(rule.first, singleRHS);
continue;
}
- const SymbolType& secondLHS = singleRHS[0];
+ const ext::variant < TerminalSymbolType, NonterminalSymbolType > & secondLHS = singleRHS[0];
if(origGrammar.getRules().find(secondLHS) == origGrammar.getRules().end()) { //is there any right hand side to substitue with?
//if not well this rule does not generate anything anyway
continue;
}
- for(const ext::vector<SymbolType>& secondSingleRHS : origGrammar.getRules().find(secondLHS)->second) { // do the substitution
- ext::vector<SymbolType> newRHS(secondSingleRHS);
+ for(const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & secondSingleRHS : origGrammar.getRules().find(secondLHS)->second) { // do the substitution
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > newRHS(secondSingleRHS);
newRHS.insert(newRHS.end(), singleRHS.begin() + 1, singleRHS.end());
res.addRule(rule.first, newRHS);
}
@@ -87,32 +87,33 @@ grammar::EpsilonFreeCFG < SymbolType > ToGNF::assignNonterminals(const grammar::
return res;
}
-template < class SymbolType >
-grammar::GNF < SymbolType > ToGNF::convertInternal( const grammar::EpsilonFreeCFG < SymbolType > & origGrammar ) {
- grammar::EpsilonFreeCFG < SymbolType > step(origGrammar);
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > ToGNF::convertInternal( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar ) {
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > step(origGrammar);
while(true) {
- grammar::EpsilonFreeCFG < SymbolType > nextStep = assignNonterminals(step);
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > nextStep = assignNonterminals(step);
if(step == nextStep) break;
step = std::move(nextStep);
}
- grammar::GNF < SymbolType > res(step.getInitialSymbol());
+ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > res(step.getInitialSymbol());
res.setTerminalAlphabet(step.getTerminalAlphabet());
- res.setNonterminalAlphabet(step.getNonterminalAlphabet());
+ for ( const NonterminalSymbolType & nonterminal : step.getNonterminalAlphabet ( ) )
+ res.addNonterminalSymbol ( ext::variant < TerminalSymbolType, NonterminalSymbolType > ( nonterminal ) );
res.setGeneratesEpsilon(step.getGeneratesEpsilon());
- ext::map<SymbolType, SymbolType> terminalToPrimed;
- for(const SymbolType& terminal : step.getTerminalAlphabet()) {
- SymbolType primed = common::createUnique(terminal, res.getTerminalAlphabet(), res.getNonterminalAlphabet());
+ ext::map < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > terminalToPrimed;
+ for ( const TerminalSymbolType & terminal : step.getTerminalAlphabet ( ) ) {
+ ext::variant < TerminalSymbolType, NonterminalSymbolType > primed = common::createUnique ( terminal, res.getTerminalAlphabet(), res.getNonterminalAlphabet());
terminalToPrimed.insert(std::make_pair(terminal, primed));
res.addNonterminalSymbol(primed);
- res.addRule(primed, ext::make_pair(terminal, ext::vector<SymbolType> {}));
+ res.addRule(primed, ext::make_pair(terminal, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > { } ) );
}
for(const auto& rule : step.getRules()) {
for(const auto& rhs : rule.second) {
- ext::vector<SymbolType> convertedNonterminals;
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > convertedNonterminals;
bool first = true;
- for(const SymbolType& rhsSymbol : rhs) {
+ for(const ext::variant < TerminalSymbolType, NonterminalSymbolType > & rhsSymbol : rhs) {
if(first) {
first = false;
continue;
@@ -123,24 +124,24 @@ grammar::GNF < SymbolType > ToGNF::convertInternal( const grammar::EpsilonFreeCF
else
convertedNonterminals.push_back(terminalToPrimed.find(rhsSymbol)->second);
}
- res.addRule(rule.first, ext::make_pair(rhs[0], std::move(convertedNonterminals)));
+ res.addRule(rule.first, ext::make_pair(rhs[0].template get < TerminalSymbolType > ( ), std::move(convertedNonterminals)));
}
}
return res;
}
-template < class SymbolType >
-grammar::GNF < SymbolType > ToGNF::convert(const grammar::CFG < SymbolType > & origGrammar) {
- return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > ToGNF::convert ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
+ return convert(grammar::simplify::EpsilonRemover::remove(origGrammar));
}
-template < class SymbolType >
-grammar::GNF < SymbolType > ToGNF::convert(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > ToGNF::convert(const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(origGrammar)));
}
-template < class SymbolType >
-grammar::GNF < SymbolType > ToGNF::convert(const grammar::CNF < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > ToGNF::convert(const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return convertInternal(grammar::simplify::LeftRecursionRemover::remove(origGrammar));
}
@@ -149,13 +150,13 @@ grammar::GNF < SymbolType > ToGNF::convert(const grammar::GNF < SymbolType > & o
return origGrammar;
}
-template < class SymbolType >
-grammar::GNF < SymbolType > ToGNF::convert(const grammar::LG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > ToGNF::convert(const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
}
-template < class SymbolType >
-grammar::GNF < SymbolType > ToGNF::convert(const grammar::LeftLG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > ToGNF::convert(const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
}
@@ -164,8 +165,8 @@ grammar::RightRG < SymbolType > ToGNF::convert(const grammar::LeftRG < SymbolTyp
return convert::ToGrammarRightRG::convert(origGrammar);
}
-template < class SymbolType >
-grammar::GNF < SymbolType > ToGNF::convert(const grammar::RightLG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > ToGNF::convert(const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
}
diff --git a/alib2algo/test-src/grammar/convert/GrammarCFGtoPDATest.cpp b/alib2algo/test-src/grammar/convert/GrammarCFGtoPDATest.cpp
index 102175c865..f2aab8b5f5 100644
--- a/alib2algo/test-src/grammar/convert/GrammarCFGtoPDATest.cpp
+++ b/alib2algo/test-src/grammar/convert/GrammarCFGtoPDATest.cpp
@@ -36,12 +36,12 @@ void GrammarCFGtoPDATest::testTopDown()
grammar::CFG < > grammar(nE);
grammar.setTerminalAlphabet(ext::set<DefaultSymbolType>{tP, tS, tL, tR, tA});
grammar.setNonterminalAlphabet(ext::set<DefaultSymbolType>{nE, nT, nF});
- grammar.addRule(nE, ext::vector<DefaultSymbolType>{nE, tP, nT});
- grammar.addRule(nE, ext::vector<DefaultSymbolType>{nT});
- grammar.addRule(nT, ext::vector<DefaultSymbolType>{nT, tS, nF});
- grammar.addRule(nT, ext::vector<DefaultSymbolType>{nF});
- grammar.addRule(nF, ext::vector<DefaultSymbolType>{tL, nE, tR});
- grammar.addRule(nF, ext::vector<DefaultSymbolType>{tA});
+ grammar.addRule(nE, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{nE, tP, nT});
+ grammar.addRule(nE, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{nT});
+ grammar.addRule(nT, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{nT, tS, nF});
+ grammar.addRule(nT, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{nF});
+ grammar.addRule(nF, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{tL, nE, tR});
+ grammar.addRule(nF, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{tA});
DefaultStateType q = label::InitialStateLabel::instance < DefaultStateType > ( );
@@ -81,12 +81,12 @@ void GrammarCFGtoPDATest::testBottomUp()
grammar::CFG < > grammar(nE);
grammar.setTerminalAlphabet(ext::set<DefaultSymbolType>{tP, tS, tL, tR, tA});
grammar.setNonterminalAlphabet(ext::set<DefaultSymbolType>{nE, nT, nF});
- grammar.addRule(nE, ext::vector<DefaultSymbolType>{nE, tP, nT});
- grammar.addRule(nE, ext::vector<DefaultSymbolType>{nT});
- grammar.addRule(nT, ext::vector<DefaultSymbolType>{nT, tS, nF});
- grammar.addRule(nT, ext::vector<DefaultSymbolType>{nF});
- grammar.addRule(nF, ext::vector<DefaultSymbolType>{tL, nE, tR});
- grammar.addRule(nF, ext::vector<DefaultSymbolType>{tA});
+ grammar.addRule(nE, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{nE, tP, nT});
+ grammar.addRule(nE, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{nT});
+ grammar.addRule(nT, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{nT, tS, nF});
+ grammar.addRule(nT, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{nF});
+ grammar.addRule(nF, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{tL, nE, tR});
+ grammar.addRule(nF, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{tA});
unsigned q = label::InitialStateLabel::instance < unsigned > ( );
diff --git a/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp b/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
index 3ff696c633..0c8478a7cd 100644
--- a/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
+++ b/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
@@ -28,12 +28,12 @@ void GrammarPropertiesTest::testNullable() {
grammar.setNonterminalAlphabet({{X, Y, Z}});
grammar.setInitialSymbol(X);
- grammar.addRule(X, ext::vector<DefaultSymbolType>{ d });
- grammar.addRule(X, ext::vector<DefaultSymbolType>{ Y });
- grammar.addRule(Y, ext::vector<DefaultSymbolType>{ d });
- grammar.addRule(Y, ext::vector<DefaultSymbolType>{ });
- grammar.addRule(Z, ext::vector<DefaultSymbolType>{ d });
- grammar.addRule(Z, ext::vector<DefaultSymbolType>{ X, Y, Z });
+ grammar.addRule(X, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{ d });
+ grammar.addRule(X, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{ Y });
+ grammar.addRule(Y, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{ d });
+ grammar.addRule(Y, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{ });
+ grammar.addRule(Z, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{ d });
+ grammar.addRule(Z, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{ X, Y, Z });
ext::set<DefaultSymbolType> res = {X, Y};
CPPUNIT_ASSERT(res == grammar::properties::NullableNonterminals::getNullableNonterminals(grammar));
diff --git a/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp b/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
index fb2951651c..fa54a8ace0 100644
--- a/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
+++ b/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
@@ -37,9 +37,9 @@ void GrammarToCNFTest::testToCNFRules1() {
grammar1.setNonterminalAlphabet({S, A, B, C, D});
grammar1.setTerminalAlphabet({a, b});
- grammar::CNF < > grammar2 = grammar::simplify::ToCNF::convert(grammar1);
+ grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar2 = grammar::simplify::ToCNF::convert(grammar1);
- grammar::CNF < > grammar3(S);
+ grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar3(S);
grammar3.setNonterminalAlphabet({S, A, B, C, D, aP, bP});
grammar3.setTerminalAlphabet({a, b});
grammar3.addRule(aP, a);
@@ -70,15 +70,15 @@ void GrammarToCNFTest::testToCNFRules2() {
grammar1.addRule({Y}, {X});
grammar1.addRule({Y}, {c});
- grammar::CNF < > grammar2 = grammar::simplify::ToCNF::convert(grammar1);
+ grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar2 = grammar::simplify::ToCNF::convert(grammar1);
DefaultSymbolType aP = DefaultSymbolType("a'");
DefaultSymbolType bP = DefaultSymbolType("b'");
DefaultSymbolType cP = DefaultSymbolType("c'");
- DefaultSymbolType Xb = object::ObjectFactory::make ( ext::vector < DefaultSymbolType > { X, bP } );
- DefaultSymbolType aX = object::ObjectFactory::make ( ext::vector < DefaultSymbolType > { aP, X } );
- DefaultSymbolType bX = object::ObjectFactory::make ( ext::vector < DefaultSymbolType > { bP, X } );
+ DefaultSymbolType Xb = object::ObjectFactory::make ( ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { X, bP } );
+ DefaultSymbolType aX = object::ObjectFactory::make ( ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { aP, X } );
+ DefaultSymbolType bX = object::ObjectFactory::make ( ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { bP, X } );
- grammar::CNF < > grammar3(S);
+ grammar::CNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar3(S);
grammar3.setNonterminalAlphabet({S, X, Y, aP, bP, cP, Xb, aX, bX});
grammar3.setTerminalAlphabet({a, b, c});
grammar3.addRule(S, ext::make_pair(aX, bX));
@@ -101,8 +101,8 @@ void GrammarToCNFTest::testToCNFRules2() {
grammar3.addRule(bP, b);
grammar3.addRule(cP, c);
- std::cout << factory::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar2)) << std::endl;
- std::cout << factory::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar3)) << std::endl;
+ std::cout << grammar2 << std::endl;
+ std::cout << grammar3 << std::endl;
CPPUNIT_ASSERT(grammar2 == grammar3);
}
diff --git a/alib2algo/test-src/grammar/simplify/GrammarToGNFTest.cpp b/alib2algo/test-src/grammar/simplify/GrammarToGNFTest.cpp
index a7548621fa..81174c8231 100644
--- a/alib2algo/test-src/grammar/simplify/GrammarToGNFTest.cpp
+++ b/alib2algo/test-src/grammar/simplify/GrammarToGNFTest.cpp
@@ -10,6 +10,8 @@
#include <factory/StringDataFactory.hpp>
#include <common/createUnique.hpp>
+#include "container/string/ObjectsVariant.h"
+
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( GrammarToGNFTest, "grammar" );
CPPUNIT_TEST_SUITE_REGISTRATION( GrammarToGNFTest );
@@ -36,16 +38,16 @@ void GrammarToGNFTest::testRemoveToGNFRules1() {
DefaultSymbolType aprimed = common::createUnique(a, grammar1.getTerminalAlphabet(), grammar1.getNonterminalAlphabet());
DefaultSymbolType bprimed = common::createUnique(b, grammar1.getTerminalAlphabet(), grammar1.getNonterminalAlphabet());
- grammar::GNF < > grammar2 = grammar::simplify::ToGNF::convert(grammar1);
+ grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar2 = grammar::simplify::ToGNF::convert(grammar1);
- grammar::GNF < > grammar3(S);
+ grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar3(S);
grammar3.setNonterminalAlphabet({S, A, B, C, D, aprimed, bprimed});
grammar3.setTerminalAlphabet({a, b});
- grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{}));
+ grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
- std::cout << factory::StringDataFactory::toString(grammar2) << std::endl;
- std::cout << factory::StringDataFactory::toString(grammar3) << std::endl;
+ std::cout << grammar2 << std::endl;
+ std::cout << grammar3 << std::endl;
CPPUNIT_ASSERT(grammar2 == grammar3);
}
@@ -74,27 +76,27 @@ void GrammarToGNFTest::testRemoveToGNFRules2() {
DefaultSymbolType bprimed = common::createUnique(b, grammar1.getTerminalAlphabet(), grammar1.getNonterminalAlphabet());
DefaultSymbolType cprimed = common::createUnique(c, grammar1.getTerminalAlphabet(), grammar1.getNonterminalAlphabet());
- std::cout << factory::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar1)) << std::endl;
+ std::cout << grammar1 << std::endl;
- grammar::GNF < > grammar2 = grammar::simplify::ToGNF::convert(grammar1);
+ grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar2 = grammar::simplify::ToGNF::convert(grammar1);
- grammar::GNF < > grammar3(S);
+ grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar3(S);
grammar3.setNonterminalAlphabet({S, A, Aprimed, B, C, D, aprimed, bprimed, cprimed});
grammar3.setTerminalAlphabet({a, b, c});
- grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{Aprimed}));
- grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{Aprimed}));
- grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(Aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{Aprimed}));
- grammar3.addRule(Aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(Aprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{Aprimed}));
- grammar3.addRule(Aprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(cprimed, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
-
- std::cout << factory::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar2)) << std::endl;
- std::cout << factory::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar3)) << std::endl;
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{Aprimed}));
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{Aprimed}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(Aprimed, ext::make_pair(a, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{Aprimed}));
+ grammar3.addRule(Aprimed, ext::make_pair(a, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(Aprimed, ext::make_pair(b, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{Aprimed}));
+ grammar3.addRule(Aprimed, ext::make_pair(b, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(cprimed, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+
+ std::cout << grammar2 << std::endl;
+ std::cout << grammar3 << std::endl;
CPPUNIT_ASSERT(grammar2 == grammar3);
}
@@ -122,29 +124,29 @@ void GrammarToGNFTest::testRemoveToGNFRules3() {
DefaultSymbolType bprimed = common::createUnique(b, grammar1.getTerminalAlphabet(), grammar1.getNonterminalAlphabet());
DefaultSymbolType cprimed = common::createUnique(c, grammar1.getTerminalAlphabet(), grammar1.getNonterminalAlphabet());
- std::cout << factory::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar1)) << std::endl;
+ std::cout << grammar1 << std::endl;
- grammar::GNF < > grammar2 = grammar::simplify::ToGNF::convert(grammar1);
+ grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar2 = grammar::simplify::ToGNF::convert(grammar1);
- grammar::GNF < > grammar3(S);
+ grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar3(S);
grammar3.setNonterminalAlphabet({S, A, B, Bprimed, C, aprimed, bprimed, cprimed});
grammar3.setTerminalAlphabet({a, b, c});
- grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed, aprimed}));
- grammar3.addRule(S, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, aprimed}));
- grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, aprimed}));
- grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed, aprimed}));
- grammar3.addRule(A, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(B, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed}));
- grammar3.addRule(B, ext::make_pair(c, ext::vector<DefaultSymbolType>{bprimed, Bprimed}));
- grammar3.addRule(Bprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{bprimed, Bprimed}));
- grammar3.addRule(Bprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{bprimed}));
- grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<DefaultSymbolType>{}));
- grammar3.addRule(cprimed, ext::make_pair(c, ext::vector<DefaultSymbolType>{}));
-
- std::cout << factory::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar2)) << std::endl;
- std::cout << factory::StringDataFactory::toString<grammar::Grammar>(grammar::Grammar(grammar3)) << std::endl;
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{bprimed, Bprimed, aprimed}));
+ grammar3.addRule(S, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{bprimed, aprimed}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{bprimed, aprimed}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{bprimed, Bprimed, aprimed}));
+ grammar3.addRule(A, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(B, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{bprimed}));
+ grammar3.addRule(B, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{bprimed, Bprimed}));
+ grammar3.addRule(Bprimed, ext::make_pair(a, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{bprimed, Bprimed}));
+ grammar3.addRule(Bprimed, ext::make_pair(a, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{bprimed}));
+ grammar3.addRule(aprimed, ext::make_pair(a, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(bprimed, ext::make_pair(b, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+ grammar3.addRule(cprimed, ext::make_pair(c, ext::vector<ext::variant<DefaultSymbolType,DefaultSymbolType>>{}));
+
+ std::cout << grammar2 << std::endl;
+ std::cout << grammar3 << std::endl;
CPPUNIT_ASSERT(grammar2 == grammar3);
}
@@ -168,7 +170,7 @@ void GrammarToGNFTest::testRemoveToGNFRules4() {
grammar1.addRule(C, {C, C});
grammar1.addRule(C, {a});
- grammar::GNF < > grammar2 = grammar::simplify::ToGNF::convert(grammar1);
+ grammar::GNF < DefaultSymbolType, ext::variant < DefaultSymbolType, DefaultSymbolType > > grammar2 = grammar::simplify::ToGNF::convert(grammar1);
CPPUNIT_ASSERT(grammar::generate::GenerateUpToLength::generate(grammar1, 7) == grammar::generate::GenerateUpToLength::generate(grammar2, 7));
}
diff --git a/alib2algo_experimental/src/grammar/parsing/AbsorbTerminalSymbol.cpp b/alib2algo_experimental/src/grammar/parsing/AbsorbTerminalSymbol.cpp
index 92f29151b5..04df2c6ecf 100644
--- a/alib2algo_experimental/src/grammar/parsing/AbsorbTerminalSymbol.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/AbsorbTerminalSymbol.cpp
@@ -17,10 +17,10 @@ namespace parsing {
void AbsorbTerminalSymbol::handleAbsobtion ( const grammar::CFG < > & orig, grammar::CFG < > & res, const DefaultSymbolType & terminal, const ext::set < DefaultSymbolType > & nonterminals, const ext::map < DefaultSymbolType, DefaultSymbolType > & nonterminalsPrimed ) {
for ( const DefaultSymbolType & nonterminal : nonterminals )
- for ( const ext::vector < DefaultSymbolType > & rhs : orig.getRules ( ).find ( nonterminal )->second ) {
- ext::vector < DefaultSymbolType > newRHS;
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : orig.getRules ( ).find ( nonterminal )->second ) {
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > newRHS;
- for ( ext::vector < DefaultSymbolType >::const_iterator iter = rhs.begin ( ); iter != rhs.end ( ); ++iter ) {
+ for ( ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >::const_iterator iter = rhs.begin ( ); iter != rhs.end ( ); ++iter ) {
if ( nonterminals.count ( * iter ) && ( ( iter + 1 == rhs.end ( ) ) || ( terminal == * ( iter + 1 ) ) ) ) {
newRHS.push_back ( nonterminalsPrimed.find ( * iter )->second );
@@ -57,13 +57,13 @@ void AbsorbTerminalSymbol::absorbTerminalSymbol ( grammar::CFG < > & grammar, co
handleAbsobtion ( grammar, res, terminal, nonterminals, nonterminalsPrimed );
- for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > & rule : grammar.getRules ( ) ) {
const DefaultSymbolType & lhs = rule.first;
- for ( const ext::vector < DefaultSymbolType > & rhs : rule.second ) {
- ext::vector < DefaultSymbolType > newRHS;
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : rule.second ) {
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > newRHS;
- for ( ext::vector < DefaultSymbolType >::const_iterator iter = rhs.begin ( ); iter != rhs.end ( ); ++iter ) {
+ for ( ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >::const_iterator iter = rhs.begin ( ); iter != rhs.end ( ); ++iter ) {
if ( ( iter + 1 != rhs.end ( ) ) && nonterminals.count ( * iter ) && ( terminal == * ( iter + 1 ) ) ) {
newRHS.push_back ( nonterminalsPrimed.find ( * iter )->second );
++iter;
diff --git a/alib2algo_experimental/src/grammar/parsing/CornerSubstitution.cpp b/alib2algo_experimental/src/grammar/parsing/CornerSubstitution.cpp
index 19c550037c..c2f23ff290 100644
--- a/alib2algo_experimental/src/grammar/parsing/CornerSubstitution.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/CornerSubstitution.cpp
@@ -22,10 +22,10 @@ void CornerSubstitution::cornerSubstitution ( grammar::CFG < > & grammar, const
res.setNonterminalAlphabet ( grammar.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( grammar.getTerminalAlphabet ( ) );
- for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > & rule : grammar.getRules ( ) ) {
const DefaultSymbolType & lhs = rule.first;
- for ( const ext::vector < DefaultSymbolType > & rhs : rule.second ) {
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : rule.second ) {
ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rawRhs ( rhs.begin ( ), rhs.end ( ) );
if ( ( lhs == nonterminal ) && ( rhs.size ( ) > 0 ) && ( grammar.getNonterminalAlphabet ( ).count ( rhs[0] ) ) && First::first ( grammar, rawRhs ).count ( ext::variant < DefaultSymbolType, DefaultEpsilonType > ( terminal ) ) )
Substitute::substitute ( grammar, res, lhs, rhs, rhs.begin ( ) );
diff --git a/alib2algo_experimental/src/grammar/parsing/ExtractRightContext.cpp b/alib2algo_experimental/src/grammar/parsing/ExtractRightContext.cpp
index 43fcdb9048..c7e39b422e 100644
--- a/alib2algo_experimental/src/grammar/parsing/ExtractRightContext.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/ExtractRightContext.cpp
@@ -21,13 +21,13 @@ void ExtractRightContext::extractRightContext ( grammar::CFG < > & grammar, cons
res.setNonterminalAlphabet ( grammar.getNonterminalAlphabet ( ) );
res.setTerminalAlphabet ( grammar.getTerminalAlphabet ( ) );
- for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > & rule : grammar.getRules ( ) ) {
const DefaultSymbolType & lhs = rule.first;
- for ( const ext::vector < DefaultSymbolType > & rhs : rule.second ) {
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : rule.second ) {
bool substitued = false;
if(rhs.size() > 0)
- for ( ext::vector < DefaultSymbolType >::const_iterator iter = rhs.begin ( ); iter + 1 != rhs.end ( ); ++iter )
+ for ( ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >::const_iterator iter = rhs.begin ( ); iter + 1 != rhs.end ( ); ++iter )
if ( nonterminals.count ( * iter ) && grammar.getNonterminalAlphabet ( ).count ( * ( iter + 1 ) ) && First::first ( grammar, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > ( iter + 1, rhs.end ( ) ) ).count ( ext::variant < DefaultSymbolType, DefaultEpsilonType > ( terminal ) ) ) {
Substitute::substitute ( grammar, res, lhs, rhs, iter + 1 );
substitued = true;
diff --git a/alib2algo_experimental/src/grammar/parsing/HandleFirstFollowConflict.cpp b/alib2algo_experimental/src/grammar/parsing/HandleFirstFollowConflict.cpp
index 58b8116cd1..57f9c82c58 100644
--- a/alib2algo_experimental/src/grammar/parsing/HandleFirstFollowConflict.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/HandleFirstFollowConflict.cpp
@@ -30,11 +30,11 @@ void HandleFirstFollowConflict::handleFirstFollowConflict ( grammar::CFG < > & g
while ( true ) {
ext::set < DefaultSymbolType > symbolsEndingWithNonterminalOld = symbolsEndingWithNonterminal;
- for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > & rule : grammar.getRules ( ) ) {
const DefaultSymbolType & lhs = rule.first;
if ( Follow::follow ( grammar, lhs ).count ( ext::variant < DefaultSymbolType, DefaultEpsilonType > ( terminal ) ) )
- for ( const ext::vector < DefaultSymbolType > & rhs : rule.second )
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : rule.second )
for ( unsigned i = rhs.size ( ); i > 0; i-- ) {
if ( symbolsEndingWithNonterminal.count ( rhs[i - 1] ) )
symbolsEndingWithNonterminal.insert ( lhs );
@@ -48,10 +48,10 @@ void HandleFirstFollowConflict::handleFirstFollowConflict ( grammar::CFG < > & g
}
// find whether all occurrences of a symbol in symbolsEndingWithNonterminal are followed by terminal symbol (the paremeter)
- for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > > & rule : grammar.getRules ( ) )
- for ( const ext::vector < DefaultSymbolType > & rhs : rule.second ) {
+ for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : rule.second ) {
if ( rhs.size ( ) > 0 )
- for ( ext::vector < DefaultSymbolType >::const_iterator iter = rhs.begin ( ); iter + 1 != rhs.end ( ); ++iter )
+ for ( ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >::const_iterator iter = rhs.begin ( ); iter + 1 != rhs.end ( ); ++iter )
if ( symbolsEndingWithNonterminal.count ( * iter ) && grammar.getNonterminalAlphabet ( ).count ( * ( iter + 1 ) ) && First::first ( grammar, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > ( iter + 1, rhs.end ( ) ) ).count ( ext::variant < DefaultSymbolType, DefaultEpsilonType > ( terminal ) ) ) {
ExtractRightContext::extractRightContext ( grammar, terminal, symbolsEndingWithNonterminal );
return;
diff --git a/alib2algo_experimental/src/grammar/parsing/LR0Parser.cpp b/alib2algo_experimental/src/grammar/parsing/LR0Parser.cpp
index 9824f028af..b3a10d6ede 100644
--- a/alib2algo_experimental/src/grammar/parsing/LR0Parser.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/LR0Parser.cpp
@@ -23,21 +23,21 @@ LR0Items LR0Parser::getClosure ( LR0Items items, grammar::CFG < > originalGramma
changed = false;
for ( const LR0Items::value_type & symbolItems : items ) {
- for ( const std::pair < unsigned, ext::vector < DefaultSymbolType > > & item : symbolItems.second ) {
+ for ( const std::pair < unsigned, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > & item : symbolItems.second ) {
unsigned position = item.first;
- ext::vector < DefaultSymbolType > rightHandSide = item.second;
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rightHandSide = item.second;
if ( position == rightHandSide.size ( ) )
continue;
- ext::map < DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > >::const_iterator rulesIterator = originalGrammar.getRules ( ) . find(rightHandSide[position]);
+ ext::map < DefaultSymbolType, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > >::const_iterator rulesIterator = originalGrammar.getRules ( ) . find(rightHandSide[position]);
if ( rulesIterator == originalGrammar.getRules ( ) . end ( ) )
continue;
- for ( const ext::vector < DefaultSymbolType > & rule : rulesIterator->second ) {
- if (items[rightHandSide[position]].find ( { 0, rule } ) == items[rightHandSide[position]].end ( ) ) {
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rule : rulesIterator->second ) {
+ if (items[rightHandSide[position].get < DefaultSymbolType > ( ) ].find ( { 0, rule } ) == items[rightHandSide[position].get < DefaultSymbolType > ( ) ].end ( ) ) {
changed = true;
- items[rightHandSide[position]].insert ( { 0, rule } );
+ items[rightHandSide[position].get < DefaultSymbolType > ( ) ].insert ( { 0, rule } );
}
}
}
@@ -47,13 +47,13 @@ LR0Items LR0Parser::getClosure ( LR0Items items, grammar::CFG < > originalGramma
return items;
}
-LR0Items LR0Parser::getNextStateItems ( LR0Items items, DefaultSymbolType symbol, grammar::CFG < > originalGrammar ) {
+LR0Items LR0Parser::getNextStateItems ( LR0Items items, ext::variant < DefaultSymbolType, DefaultSymbolType > symbol, grammar::CFG < > originalGrammar ) {
LR0Items transitionItems;
for ( const LR0Items::value_type & symbolItems : items ) {
DefaultSymbolType leftHandSide = symbolItems.first;
- for ( const std::pair < unsigned, ext::vector < DefaultSymbolType > > & item : symbolItems.second) {
+ for ( const std::pair < unsigned, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > & item : symbolItems.second) {
unsigned position = item.first;
- ext::vector < DefaultSymbolType > rightHandSide = item.second;
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rightHandSide = item.second;
if ( position == rightHandSide.size ( ) ) {
continue;
@@ -68,34 +68,34 @@ LR0Items LR0Parser::getNextStateItems ( LR0Items items, DefaultSymbolType symbol
return getClosure ( transitionItems, originalGrammar );
}
-automaton::DFA<> LR0Parser::getAutomaton ( grammar::CFG < > originalGrammar ) {
+automaton::DFA < ext::variant < DefaultSymbolType, DefaultSymbolType >, LR0Items > LR0Parser::getAutomaton ( grammar::CFG < > originalGrammar ) {
grammar::CFG < > augmentedGrammar = LRParser::getAugmentedGrammar ( originalGrammar );
DefaultSymbolType initialSymbol = augmentedGrammar.getInitialSymbol ( );
- const ext::map < DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > > & rules = augmentedGrammar.getRules ( );
+ const ext::map < DefaultSymbolType, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > & rules = augmentedGrammar.getRules ( );
LR0Items initialItems;
initialItems[initialSymbol].insert ( { 0, *rules.find ( initialSymbol ) -> second.begin ( ) } );
- DefaultStateType initialState ( label::LR0ItemsLabel ( getClosure ( initialItems, augmentedGrammar ) ) );
+ LR0Items initialState = getClosure ( initialItems, augmentedGrammar );
- automaton::DFA<> lr0Automaton ( initialState );
- lr0Automaton.addInputSymbols ( augmentedGrammar.getNonterminalAlphabet ( ) );
- lr0Automaton.addInputSymbols ( augmentedGrammar.getTerminalAlphabet ( ) );
+ automaton::DFA < ext::variant < DefaultSymbolType, DefaultSymbolType >, LR0Items > lr0Automaton ( initialState );
- std::queue < DefaultStateType > itemsToProcess;
+ for ( const DefaultSymbolType & nonterminal : augmentedGrammar.getNonterminalAlphabet ( ) )
+ lr0Automaton.addInputSymbol ( nonterminal );
+
+ for ( const DefaultSymbolType & terminal : augmentedGrammar.getTerminalAlphabet ( ) )
+ lr0Automaton.addInputSymbol ( terminal );
+
+ std::queue < LR0Items > itemsToProcess;
itemsToProcess.push ( initialState );
while ( !itemsToProcess.empty ( ) ) {
- DefaultStateType currentState = itemsToProcess.front ( );
- label::LR0ItemsLabel & currentLabel = static_cast < label::LR0ItemsLabel & > ( currentState . getData ( ) );
+ LR0Items currentState = itemsToProcess.front ( );
itemsToProcess.pop ( );
- for ( const DefaultSymbolType & symbol : lr0Automaton.getInputAlphabet ( ) ) {
- LR0Items nextStateItems = getNextStateItems ( currentLabel.getItems ( ), symbol, augmentedGrammar );
- if ( !nextStateItems.empty ( ) ) {
- label::LR0ItemsLabel nextStateLabel ( nextStateItems );
-
- DefaultStateType nextState ( nextStateLabel );
- ext::set < DefaultStateType > ::iterator stateIterator = lr0Automaton.getStates ( ) . find ( nextState );
+ for ( const ext::variant < DefaultSymbolType, DefaultSymbolType > & symbol : lr0Automaton.getInputAlphabet ( ) ) {
+ LR0Items nextState = getNextStateItems ( currentState, symbol, augmentedGrammar );
+ if ( !nextState.empty ( ) ) {
+ ext::set < LR0Items > ::iterator stateIterator = lr0Automaton.getStates ( ) . find ( nextState );
if ( stateIterator == lr0Automaton.getStates ( ) . end ( ) ) {
lr0Automaton.addState ( nextState );
lr0Automaton.addTransition ( currentState, symbol, nextState );
diff --git a/alib2algo_experimental/src/grammar/parsing/LR0Parser.h b/alib2algo_experimental/src/grammar/parsing/LR0Parser.h
index 8ab87ba3f3..6b74013a4c 100644
--- a/alib2algo_experimental/src/grammar/parsing/LR0Parser.h
+++ b/alib2algo_experimental/src/grammar/parsing/LR0Parser.h
@@ -20,9 +20,9 @@ class LR0Parser {
public:
static LR0Items getClosure ( LR0Items items, grammar::CFG < > originalGrammar );
- static LR0Items getNextStateItems ( LR0Items items, DefaultSymbolType symbol, grammar::CFG < > originalGrammar );
+ static LR0Items getNextStateItems ( LR0Items items, ext::variant < DefaultSymbolType, DefaultSymbolType > symbol, grammar::CFG < > originalGrammar );
- static automaton::DFA<> getAutomaton ( grammar::CFG < > originalGrammar );
+ static automaton::DFA < ext::variant < DefaultSymbolType, DefaultSymbolType >, LR0Items > getAutomaton ( grammar::CFG < > originalGrammar );
};
} /* namespace parsing */
diff --git a/alib2algo_experimental/src/grammar/parsing/LRParser.cpp b/alib2algo_experimental/src/grammar/parsing/LRParser.cpp
index c0a1c8a7d0..285f26744d 100644
--- a/alib2algo_experimental/src/grammar/parsing/LRParser.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/LRParser.cpp
@@ -29,8 +29,8 @@ grammar::CFG < > LRParser::getAugmentedGrammar ( grammar::CFG < > originalGramma
return originalGrammar;
}
-bool LRParser::parse ( LRActionTable actionTable, LRGotoTable gotoTable, DefaultStateType initialState, ext::vector < DefaultSymbolType > input ) {
- std::stack < DefaultStateType > states;
+bool LRParser::parse ( LRActionTable actionTable, LRGotoTable gotoTable, LR0Items initialState, ext::vector < DefaultSymbolType > input ) {
+ std::stack < LR0Items > states;
states.push ( initialState );
unsigned currentPosition = 0;
@@ -41,13 +41,13 @@ bool LRParser::parse ( LRActionTable actionTable, LRGotoTable gotoTable, Default
switch ( actionIterator->second.first ) {
case LRAction::Shift:
- states.push ( actionIterator->second.second.get < DefaultStateType > ( ) );
+ states.push ( actionIterator->second.second.get < LR0Items > ( ) );
++currentPosition;
break;
case LRAction::Reduce: {
- ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > reduceBy = actionIterator->second.second.get < ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( );
+ ext::pair < DefaultSymbolType, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > reduceBy = actionIterator->second.second.get < ext::pair < DefaultSymbolType, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > ( );
for ( unsigned i = 0; i < reduceBy.second.size ( ); ++i ) {
states.pop ( );
}
diff --git a/alib2algo_experimental/src/grammar/parsing/LRParser.h b/alib2algo_experimental/src/grammar/parsing/LRParser.h
index f759a6f7e5..e9b8573af7 100644
--- a/alib2algo_experimental/src/grammar/parsing/LRParser.h
+++ b/alib2algo_experimental/src/grammar/parsing/LRParser.h
@@ -24,7 +24,7 @@ public:
static grammar::CFG < > getAugmentedGrammar ( grammar::CFG < > originalGrammar );
- static bool parse ( LRActionTable actionTable, LRGotoTable gotoTable, DefaultStateType initialState, ext::vector < DefaultSymbolType > input );
+ static bool parse ( LRActionTable actionTable, LRGotoTable gotoTable, LR0Items initialState, ext::vector < DefaultSymbolType > input );
};
} /* namespace parsing */
diff --git a/alib2algo_experimental/src/grammar/parsing/LeftFactorize.cpp b/alib2algo_experimental/src/grammar/parsing/LeftFactorize.cpp
index 4e7d24f85a..6596086ef4 100644
--- a/alib2algo_experimental/src/grammar/parsing/LeftFactorize.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/LeftFactorize.cpp
@@ -23,13 +23,13 @@ void LeftFactorize::leftFactorize ( grammar::CFG < > & grammar, const DefaultSym
DefaultSymbolType primed = common::createUnique ( nonterminal, grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ) );
res.addNonterminalSymbol ( primed );
- for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < DefaultSymbolType > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const DefaultSymbolType, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > & rule : grammar.getRules ( ) ) {
const DefaultSymbolType & lhs = rule.first;
- for ( const ext::vector < DefaultSymbolType > & rhs : rule.second ) {
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : rule.second ) {
if ( ( lhs == nonterminal ) && ( rhs.size ( ) > 0 ) && ( rhs[0] == terminal ) ) {
- res.addRule ( lhs, ext::vector < DefaultSymbolType > { terminal, primed } );
- res.addRule ( primed, ext::vector < DefaultSymbolType > ( rhs.begin ( ) + 1, rhs.end ( ) ) );
+ res.addRule ( lhs, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { terminal, primed } );
+ res.addRule ( primed, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > ( rhs.begin ( ) + 1, rhs.end ( ) ) );
} else {
res.addRule ( lhs, rhs );
}
diff --git a/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp b/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
index 1e4676c05a..408cd90ee1 100644
--- a/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/SLR1ParseTable.cpp
@@ -28,16 +28,13 @@ void SLR1ParseTable::insertToActionTable ( LRActionTable & actionTable, LRAction
LRActionTable SLR1ParseTable::getActionTable ( grammar::CFG < > originalGrammar ) {
LRActionTable actionTable;
grammar::CFG < > augmentedGrammar = LRParser::getAugmentedGrammar ( originalGrammar );
- automaton::DFA<> parsingAutomaton = LR0Parser::getAutomaton ( originalGrammar );
- for ( const DefaultStateType & state : parsingAutomaton.getStates ( ) ) {
- LR0Items items = static_cast < const label::LR0ItemsLabel & > ( state . getData ( ) ) . getItems ( );
- ext::iterator_range < ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType >::const_iterator > transitionsFromCurrentStateRange = parsingAutomaton.getTransitionsFromState ( state );
- ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > transitionsFromCurrentState ( transitionsFromCurrentStateRange.begin ( ), transitionsFromCurrentStateRange.end ( ) );
- for ( const LR0Items::value_type & nonterminalItems : items ) {
+ automaton::DFA < ext::variant < DefaultSymbolType, DefaultSymbolType >, LR0Items > parsingAutomaton = LR0Parser::getAutomaton ( originalGrammar );
+ for ( const LR0Items & state : parsingAutomaton.getStates ( ) ) {
+ for ( const LR0Items::value_type & nonterminalItems : state ) {
DefaultSymbolType leftHandSide = nonterminalItems.first;
- for ( const std::pair < unsigned, ext::vector < DefaultSymbolType > > & item : nonterminalItems.second ) {
+ for ( const std::pair < unsigned, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > & item : nonterminalItems.second ) {
unsigned position = item.first;
- ext::vector < DefaultSymbolType > rightHandSide = item.second;
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rightHandSide = item.second;
if ( position == rightHandSide.size ( ) ) {
if ( leftHandSide == augmentedGrammar.getInitialSymbol ( ) ) {
@@ -46,7 +43,7 @@ LRActionTable SLR1ParseTable::getActionTable ( grammar::CFG < > originalGrammar
}
ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > followSet = grammar::parsing::Follow::follow ( augmentedGrammar, leftHandSide );
- ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > currentRule = { leftHandSide, rightHandSide };
+ ext::pair < DefaultSymbolType, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > currentRule = { leftHandSide, rightHandSide };
for ( const ext::variant < DefaultSymbolType, string::Epsilon < > > & followSymbol : followSet ) {
if ( followSymbol.is < DefaultSymbolType > ( ) ) {
insertToActionTable(actionTable, { state, followSymbol.get < DefaultSymbolType > ( ) }, { LRAction::Reduce, currentRule } );
@@ -57,9 +54,9 @@ LRActionTable SLR1ParseTable::getActionTable ( grammar::CFG < > originalGrammar
continue;
}
- DefaultSymbolType currentSymbol = rightHandSide[position];
+ ext::variant < DefaultSymbolType, DefaultSymbolType > currentSymbol = rightHandSide[position];
if ( originalGrammar.getTerminalAlphabet ( ) . find ( currentSymbol ) != originalGrammar.getTerminalAlphabet ( ) . end ( ) ) {
- insertToActionTable(actionTable, { state, currentSymbol }, { LRAction::Shift, transitionsFromCurrentState.find ( { state, currentSymbol } )->second } );
+ insertToActionTable(actionTable, { state, currentSymbol.get < DefaultSymbolType /* terminal */ > ( ) }, { LRAction::Shift, parsingAutomaton.getTransitions ( ).find ( { state, currentSymbol } )->second } );
}
}
}
@@ -71,13 +68,11 @@ LRActionTable SLR1ParseTable::getActionTable ( grammar::CFG < > originalGrammar
LRGotoTable SLR1ParseTable::getGotoTable ( grammar::CFG < > originalGrammar ) {
LRGotoTable gotoTable;
grammar::CFG < > augmentedGrammar = LRParser::getAugmentedGrammar ( originalGrammar );
- automaton::DFA<> parsingAutomaton = LR0Parser::getAutomaton ( originalGrammar );
- for ( const DefaultStateType & state : parsingAutomaton.getStates ( ) ) {
- ext::iterator_range < ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType >::const_iterator > transitionsFromCurrentStateRange = parsingAutomaton.getTransitionsFromState ( state );
- ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > transitionsFromCurrentState ( transitionsFromCurrentStateRange.begin ( ), transitionsFromCurrentStateRange.end ( ) );
+ automaton::DFA < ext::variant < DefaultSymbolType, DefaultSymbolType >, LR0Items > parsingAutomaton = LR0Parser::getAutomaton ( originalGrammar );
+ for ( const LR0Items & state : parsingAutomaton.getStates ( ) ) {
for ( const DefaultSymbolType & nonterminal : augmentedGrammar.getNonterminalAlphabet ( ) ) {
- ext::map < ext::pair<DefaultStateType, DefaultSymbolType >, DefaultStateType >::iterator transitionIterator = transitionsFromCurrentState.find ( { state, nonterminal } );
- if ( transitionIterator != transitionsFromCurrentState.end ( ) ) {
+ ext::map < ext::pair < LR0Items, ext::variant < DefaultSymbolType, DefaultSymbolType > >, LR0Items >::const_iterator transitionIterator = parsingAutomaton.getTransitions ( ).find ( { state, nonterminal } );
+ if ( transitionIterator != parsingAutomaton.getTransitions ( ).end ( ) ) {
gotoTable.insert ( { { state, nonterminal }, transitionIterator->second } );
}
}
diff --git a/alib2algo_experimental/src/grammar/parsing/common/Substitute.cpp b/alib2algo_experimental/src/grammar/parsing/common/Substitute.cpp
index 95f015898a..755f700b70 100644
--- a/alib2algo_experimental/src/grammar/parsing/common/Substitute.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/common/Substitute.cpp
@@ -12,13 +12,13 @@ namespace grammar {
namespace parsing {
-void Substitute::substitute ( const grammar::CFG < > & orig, grammar::CFG < > & res, const DefaultSymbolType & origLHS, const ext::vector < DefaultSymbolType > & origRHS, ext::vector < DefaultSymbolType >::const_iterator nonterminal ) {
+void Substitute::substitute ( const grammar::CFG < > & orig, grammar::CFG < > & res, const DefaultSymbolType & origLHS, const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & origRHS, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >::const_iterator nonterminal ) {
auto iter = orig.getRules ( ).find ( * nonterminal );
if ( iter == orig.getRules ( ).end ( ) ) return;
- for ( const ext::vector < DefaultSymbolType > & rhs : iter->second ) {
- ext::vector < DefaultSymbolType > newRHS ( origRHS.begin ( ), nonterminal );
+ for ( const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & rhs : iter->second ) {
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > newRHS ( origRHS.begin ( ), nonterminal );
newRHS.insert ( newRHS.end ( ), rhs.begin ( ), rhs.end ( ) );
newRHS.insert ( newRHS.end ( ), nonterminal + 1, origRHS.end ( ) );
res.addRule ( origLHS, newRHS );
diff --git a/alib2algo_experimental/src/grammar/parsing/common/Substitute.h b/alib2algo_experimental/src/grammar/parsing/common/Substitute.h
index f151b80f44..561cf7b4c0 100644
--- a/alib2algo_experimental/src/grammar/parsing/common/Substitute.h
+++ b/alib2algo_experimental/src/grammar/parsing/common/Substitute.h
@@ -18,7 +18,7 @@ namespace parsing {
class Substitute {
public:
- static void substitute ( const grammar::CFG < > & orig, grammar::CFG < > & res, const DefaultSymbolType & origLHS, const ext::vector < DefaultSymbolType > & origRHS, ext::vector < DefaultSymbolType >::const_iterator nonterminal );
+ static void substitute ( const grammar::CFG < > & orig, grammar::CFG < > & res, const DefaultSymbolType & origLHS, const ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > & origRHS, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >::const_iterator nonterminal );
};
diff --git a/alib2algo_experimental/test-src/grammar/parsing/CornerSubstitution.cpp b/alib2algo_experimental/test-src/grammar/parsing/CornerSubstitution.cpp
index 45117d1895..cc38e87bbe 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/CornerSubstitution.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/CornerSubstitution.cpp
@@ -28,12 +28,12 @@ void CornerSubstitution::testCornerSubstitution ( ) {
grammar.setNonterminalAlphabet ( { A, B, C } );
grammar.setInitialSymbol ( A );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { a, B } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { C, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { d } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { b, B } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { d } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
grammar::CFG < > res = grammar;
grammar::parsing::CornerSubstitution::cornerSubstitution ( res, a, A );
@@ -44,13 +44,13 @@ void CornerSubstitution::testCornerSubstitution ( ) {
comp.setNonterminalAlphabet ( { A, B, C } );
comp.setInitialSymbol ( A );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, C, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { b, B, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { d } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { b, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B, B } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { d } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
// std::cout << res << std::endl << comp << std::endl;
@@ -73,12 +73,12 @@ void CornerSubstitution::testCornerSubstitution2 ( ) {
grammar.setNonterminalAlphabet ( { A, B, C } );
grammar.setInitialSymbol ( A );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { a, B } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { C, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { a } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { B, b } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B, b } );
grammar::CFG < > res = grammar;
grammar::parsing::CornerSubstitution::cornerSubstitution ( res, a, A );
@@ -90,14 +90,14 @@ void CornerSubstitution::testCornerSubstitution2 ( ) {
comp.setNonterminalAlphabet ( { A, B, C } );
comp.setInitialSymbol ( A );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, C, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, b, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { c, B, b, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { a } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { B, b } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, b, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B, b, B } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B, b } );
// std::cout << res << std::endl << comp << std::endl;
diff --git a/alib2algo_experimental/test-src/grammar/parsing/ExtractRightContext.cpp b/alib2algo_experimental/test-src/grammar/parsing/ExtractRightContext.cpp
index 4ec2ba8b92..ce3d159029 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/ExtractRightContext.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/ExtractRightContext.cpp
@@ -27,10 +27,10 @@ void ExtractRightContext::testExtractRightContext ( ) {
grammar.setNonterminalAlphabet ( { S, A, C } );
grammar.setInitialSymbol ( S );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { b, c, A, C } );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { b, b } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { a, c, A, b } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, c, A, C } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, b } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, c, A, b } );
grammar.addRule ( C, { a, b } );
grammar.addRule ( C, { c, C } );
@@ -43,13 +43,13 @@ void ExtractRightContext::testExtractRightContext ( ) {
comp.setNonterminalAlphabet ( { S, A, C } );
comp.setInitialSymbol ( S );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { b, c, A, a, b } );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { b, c, A, c, C } );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { b, b } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, c, A, b } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { a, b } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { c, C } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, c, A, a, b } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, c, A, c, C } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, b } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, c, A, b } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, b } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
// std::cout << res << std::endl << comp << std::endl;
@@ -72,11 +72,11 @@ void ExtractRightContext::testExtractRightContext2 ( ) {
grammar.setNonterminalAlphabet ( { S, X, A, C } );
grammar.setInitialSymbol ( S );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { b, c, X, C } );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { b, b } );
- grammar.addRule ( X, ext::vector < DefaultSymbolType > { b, A } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { a, c, A, b } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, c, X, C } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, b } );
+ grammar.addRule ( X, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, A } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, c, A, b } );
grammar.addRule ( C, { A, a, b } );
grammar.addRule ( C, { c, C } );
@@ -89,14 +89,14 @@ void ExtractRightContext::testExtractRightContext2 ( ) {
comp.setNonterminalAlphabet ( { S, X, A, C } );
comp.setInitialSymbol ( S );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { b, c, X, A, a, b } );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { b, c, X, c, C } );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { b, b } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, c, X, A, a, b } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, c, X, c, C } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, b } );
comp.addRule ( X, { b, A } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, c, A, b } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { A, a, b } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { c, C } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, c, A, b } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { A, a, b } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
// std::cout << res << std::endl << comp << std::endl;
diff --git a/alib2algo_experimental/test-src/grammar/parsing/FirstTest.cpp b/alib2algo_experimental/test-src/grammar/parsing/FirstTest.cpp
index da5d72bbfd..64da2b9aa4 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/FirstTest.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/FirstTest.cpp
@@ -29,52 +29,41 @@ void FirstTest::testFirst ( ) {
grammar.setTerminalAlphabet ( ext::set < DefaultSymbolType > { tP, tS, tL, tR, tA } );
grammar.setNonterminalAlphabet ( ext::set < DefaultSymbolType > { nE, nT, nF } );
- {
- ext::vector < DefaultSymbolType > rhsE1 ( { nE, tP, nT } );
- ext::vector < DefaultSymbolType > rhsE2 ( { nT } );
- ext::vector < DefaultSymbolType > rhsT1 ( { nT, tS, nF } );
- ext::vector < DefaultSymbolType > rhsT2 ( { nF } );
- ext::vector < DefaultSymbolType > rhsF1 ( { tA } );
- ext::vector < DefaultSymbolType > rhsF2 ( { tL, nE, tR } );
-
- grammar.addRule ( nE, rhsE1 );
- grammar.addRule ( nE, rhsE2 );
- grammar.addRule ( nT, rhsT1 );
- grammar.addRule ( nT, rhsT2 );
- grammar.addRule ( nF, rhsF1 );
- grammar.addRule ( nF, rhsF2 );
- }
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE1 ( { nE, tP, nT } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE2 ( { nT } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsT1 ( { nT, tS, nF } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsT2 ( { nF } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF1 ( { tA } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF2 ( { tL, nE, tR } );
+
+ grammar.addRule ( nE, rhsE1 );
+ grammar.addRule ( nE, rhsE2 );
+ grammar.addRule ( nT, rhsT1 );
+ grammar.addRule ( nT, rhsT2 );
+ grammar.addRule ( nF, rhsF1 );
+ grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
ext::map < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >, ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > first;
- {
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE1 ( { nE, tP, nT } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE2 ( { nT } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsT1 ( { nT, tS, nF } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsT2 ( { nF } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF1 ( { tA } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF2 ( { tL, nE, tR } );
-
- first[rhsE1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA, tL
- };
- first[rhsE2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA, tL
- };
- first[rhsT1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA, tL
- };
- first[rhsT2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA, tL
- };
- first[rhsF1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA
- };
- first[rhsF2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tL
- };
- }
+ first[rhsE1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA, tL
+ };
+ first[rhsE2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA, tL
+ };
+ first[rhsT1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA, tL
+ };
+ first[rhsT2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA, tL
+ };
+ first[rhsF1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA
+ };
+ first[rhsF2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tL
+ };
// --------------------------------------------------
@@ -106,100 +95,81 @@ void FirstTest::testFirst ( ) {
grammar.setTerminalAlphabet ( ext::set < DefaultSymbolType > { tA, tB, tC, tD, tE } );
grammar.setNonterminalAlphabet ( ext::set < DefaultSymbolType > { nS, nA, nB, nC, nD, nE, nF } );
- {
- ext::vector < DefaultSymbolType > rhsS1 ( { nB, tD, nS } );
- ext::vector < DefaultSymbolType > rhsS2 ( { tD, tD, nC } );
- ext::vector < DefaultSymbolType > rhsS3 ( { tC, nA } );
- ext::vector < DefaultSymbolType > rhsA1 ( { tA, tE, nE } );
- ext::vector < DefaultSymbolType > rhsA2 ( { tB, tB, nE } );
- ext::vector < DefaultSymbolType > rhsB1 ( { tA, nF } );
- ext::vector < DefaultSymbolType > rhsB2 ( { tB, tB, nD } );
- ext::vector < DefaultSymbolType > rhsC1 ( { tA, nB, tD } );
- ext::vector < DefaultSymbolType > rhsC2 ( { tE, nA } );
- ext::vector < DefaultSymbolType > rhsD1 ( { tC, tA, nF } );
- ext::vector < DefaultSymbolType > rhsE1 ( { tC, tA, tE, nE } );
- ext::vector < DefaultSymbolType > rhsE2 ( { } );
- ext::vector < DefaultSymbolType > rhsF1 ( { tE, nD } );
- ext::vector < DefaultSymbolType > rhsF2 ( { } );
-
- grammar.addRule ( nS, rhsS1 );
- grammar.addRule ( nS, rhsS2 );
- grammar.addRule ( nS, rhsS3 );
- grammar.addRule ( nA, rhsA1 );
- grammar.addRule ( nA, rhsA2 );
- grammar.addRule ( nB, rhsB1 );
- grammar.addRule ( nB, rhsB2 );
- grammar.addRule ( nC, rhsC1 );
- grammar.addRule ( nC, rhsC2 );
- grammar.addRule ( nD, rhsD1 );
- grammar.addRule ( nE, rhsE1 );
- grammar.addRule ( nE, rhsE2 );
- grammar.addRule ( nF, rhsF1 );
- grammar.addRule ( nF, rhsF2 );
- }
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS1 ( { nB, tD, nS } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS2 ( { tD, tD, nC } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS3 ( { tC, nA } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsA1 ( { tA, tE, nE } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsA2 ( { tB, tB, nE } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsB1 ( { tA, nF } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsB2 ( { tB, tB, nD } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsC1 ( { tA, nB, tD } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsC2 ( { tE, nA } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsD1 ( { tC, tA, nF } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE1 ( { tC, tA, tE, nE } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE2 ( { } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF1 ( { tE, nD } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF2 ( { } );
+
+ grammar.addRule ( nS, rhsS1 );
+ grammar.addRule ( nS, rhsS2 );
+ grammar.addRule ( nS, rhsS3 );
+ grammar.addRule ( nA, rhsA1 );
+ grammar.addRule ( nA, rhsA2 );
+ grammar.addRule ( nB, rhsB1 );
+ grammar.addRule ( nB, rhsB2 );
+ grammar.addRule ( nC, rhsC1 );
+ grammar.addRule ( nC, rhsC2 );
+ grammar.addRule ( nD, rhsD1 );
+ grammar.addRule ( nE, rhsE1 );
+ grammar.addRule ( nE, rhsE2 );
+ grammar.addRule ( nF, rhsF1 );
+ grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
ext::map < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >, ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > first;
- {
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS1 ( { nB, tD, nS } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS2 ( { tD, tD, nC } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS3 ( { tC, nA } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsA1 ( { tA, tE, nE } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsA2 ( { tB, tB, nE } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsB1 ( { tA, nF } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsB2 ( { tB, tB, nD } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsC1 ( { tA, nB, tD } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsC2 ( { tE, nA } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsD1 ( { tC, tA, nF } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE1 ( { tC, tA, tE, nE } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE2 ( { } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF1 ( { tE, nD } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF2 ( { } );
-
- first[rhsS1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA, tB
- };
- first[rhsS2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tD
- };
- first[rhsS3] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tC
- };
- first[rhsA1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA
- };
- first[rhsA2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tB
- };
- first[rhsB1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA
- };
- first[rhsB2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tB
- };
- first[rhsC1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tA
- };
- first[rhsC2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tE
- };
- first[rhsD1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tC
- };
- first[rhsE1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tC
- };
- first[rhsE2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- string::Epsilon < >::EPSILON
- };
- first[rhsF1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- tE
- };
- first[rhsF2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
- string::Epsilon < >::EPSILON
- };
- }
+ first[rhsS1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA, tB
+ };
+ first[rhsS2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tD
+ };
+ first[rhsS3] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tC
+ };
+ first[rhsA1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA
+ };
+ first[rhsA2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tB
+ };
+ first[rhsB1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA
+ };
+ first[rhsB2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tB
+ };
+ first[rhsC1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tA
+ };
+ first[rhsC2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tE
+ };
+ first[rhsD1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tC
+ };
+ first[rhsE1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tC
+ };
+ first[rhsE2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ string::Epsilon < >::EPSILON
+ };
+ first[rhsF1] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ tE
+ };
+ first[rhsF2] = ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > {
+ string::Epsilon < >::EPSILON
+ };
// --------------------------------------------------
ext::map < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >, ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > firstAlgo;
@@ -223,8 +193,8 @@ void FirstTest::testFirst2 ( ) {
grammar.setNonterminalAlphabet ( { { A } } );
grammar.setInitialSymbol ( A );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { A, c } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { d } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { A, c } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { d } );
ext::map < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >, ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > res = { { { d }, { d } }, { { A, c }, { d } } };
CPPUNIT_ASSERT ( res == grammar::parsing::First::first ( grammar ) );
@@ -246,12 +216,12 @@ void FirstTest::testFirst3 ( ) {
grammar.setNonterminalAlphabet ( { { S, A, B } } );
grammar.setInitialSymbol ( S );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { A, a } );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { b, S } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { c, A, d } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { f, S } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { A, a } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, S } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, A, d } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { f, S } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
ext::map < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > >, ext::set < ext::variant < DefaultSymbolType, string::Epsilon < > > > > res =
{
diff --git a/alib2algo_experimental/test-src/grammar/parsing/FollowTest.cpp b/alib2algo_experimental/test-src/grammar/parsing/FollowTest.cpp
index 384615b4ac..b0eb04c7a2 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/FollowTest.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/FollowTest.cpp
@@ -29,12 +29,12 @@ void FollowTest::testFollow ( ) {
grammar.setTerminalAlphabet ( ext::set < DefaultSymbolType > { tP, tS, tL, tR, tA } );
grammar.setNonterminalAlphabet ( ext::set < DefaultSymbolType > { nE, nT, nF } );
- ext::vector < DefaultSymbolType > rhsE1 ( { nE, tP, nT } );
- ext::vector < DefaultSymbolType > rhsE2 ( { nT } );
- ext::vector < DefaultSymbolType > rhsT1 ( { nT, tS, nF } );
- ext::vector < DefaultSymbolType > rhsT2 ( { nF } );
- ext::vector < DefaultSymbolType > rhsF1 ( { tA } );
- ext::vector < DefaultSymbolType > rhsF2 ( { tL, nE, tR } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE1 ( { nE, tP, nT } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE2 ( { nT } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsT1 ( { nT, tS, nF } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsT2 ( { nF } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF1 ( { tA } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF2 ( { tL, nE, tR } );
grammar.addRule ( nE, rhsE1 );
grammar.addRule ( nE, rhsE2 );
@@ -87,20 +87,20 @@ void FollowTest::testFollow ( ) {
grammar.setTerminalAlphabet ( ext::set < DefaultSymbolType > { tA, tB, tC, tD, tE } );
grammar.setNonterminalAlphabet ( ext::set < DefaultSymbolType > { nS, nA, nB, nC, nD, nE, nF } );
- ext::vector < DefaultSymbolType > rhsS1 ( { nB, tD, nS } );
- ext::vector < DefaultSymbolType > rhsS2 ( { tD, tD, nC } );
- ext::vector < DefaultSymbolType > rhsS3 ( { tC, nA } );
- ext::vector < DefaultSymbolType > rhsA1 ( { tA, tE, nE } );
- ext::vector < DefaultSymbolType > rhsA2 ( { tB, tB, nE } );
- ext::vector < DefaultSymbolType > rhsB1 ( { tA, nF } );
- ext::vector < DefaultSymbolType > rhsB2 ( { tB, tB, nD } );
- ext::vector < DefaultSymbolType > rhsC1 ( { tA, nB, tD } );
- ext::vector < DefaultSymbolType > rhsC2 ( { tE, nA } );
- ext::vector < DefaultSymbolType > rhsD1 ( { tC, tA, nF } );
- ext::vector < DefaultSymbolType > rhsE1 ( { tC, tA, tE, nE } );
- ext::vector < DefaultSymbolType > rhsE2 ( { } );
- ext::vector < DefaultSymbolType > rhsF1 ( { tE, nD } );
- ext::vector < DefaultSymbolType > rhsF2 ( { } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS1 ( { nB, tD, nS } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS2 ( { tD, tD, nC } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsS3 ( { tC, nA } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsA1 ( { tA, tE, nE } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsA2 ( { tB, tB, nE } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsB1 ( { tA, nF } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsB2 ( { tB, tB, nD } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsC1 ( { tA, nB, tD } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsC2 ( { tE, nA } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsD1 ( { tC, tA, nF } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE1 ( { tC, tA, tE, nE } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE2 ( { } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF1 ( { tE, nD } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF2 ( { } );
grammar.addRule ( nS, rhsS1 );
grammar.addRule ( nS, rhsS2 );
diff --git a/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFirstConflict.cpp b/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFirstConflict.cpp
index 52eef65ed1..1f7cb3daab 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFirstConflict.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFirstConflict.cpp
@@ -29,12 +29,12 @@ void HandleFirstFirstConflict::testHandleFirstFirstConflict ( ) {
grammar.setNonterminalAlphabet ( { A, B, C } );
grammar.setInitialSymbol ( A );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { a, B } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { C, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { d } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { b, B } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { d } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
grammar::CFG < > res = grammar;
grammar::parsing::HandleFirstFirstConflict::handleFirstFirstConflict ( res, a, A, { {a, B }, {C ,B} } );
@@ -45,13 +45,13 @@ void HandleFirstFirstConflict::testHandleFirstFirstConflict ( ) {
comp.setNonterminalAlphabet ( { A, B, C } );
comp.setInitialSymbol ( A );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, C, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { b, B, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { d } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { b, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B, B } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { d } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
// std::cout << res << std::endl << comp << std::endl;
@@ -65,14 +65,14 @@ void HandleFirstFirstConflict::testHandleFirstFirstConflict ( ) {
comp2.setNonterminalAlphabet ( { A, Ap, B, C } );
comp2.setInitialSymbol ( A );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { a, Ap } );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { b, B, B } );
- comp2.addRule ( Ap, ext::vector < DefaultSymbolType > { B } );
- comp2.addRule ( Ap, ext::vector < DefaultSymbolType > { C, B } );
- comp2.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- comp2.addRule ( B, ext::vector < DefaultSymbolType > { d } );
- comp2.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp2.addRule ( C, ext::vector < DefaultSymbolType > { b, B } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Ap } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B, B } );
+ comp2.addRule ( Ap, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B } );
+ comp2.addRule ( Ap, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C, B } );
+ comp2.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ comp2.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { d } );
+ comp2.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp2.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
// std::cout << res << std::endl << comp2 << std::endl;
@@ -96,12 +96,12 @@ void HandleFirstFirstConflict::testHandleFirstFirstConflict2 ( ) {
grammar.setNonterminalAlphabet ( { A, B, C } );
grammar.setInitialSymbol ( A );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { a, B } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { C, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { a } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { B, b } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B, b } );
grammar::CFG < > res = grammar;
grammar::parsing::HandleFirstFirstConflict::handleFirstFirstConflict ( res, a, A, { {a, B}, {C, B}});
@@ -113,14 +113,14 @@ void HandleFirstFirstConflict::testHandleFirstFirstConflict2 ( ) {
comp.setNonterminalAlphabet ( { A, B, C } );
comp.setInitialSymbol ( A );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, C, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, b, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { c, B, b, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { a } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { B, b } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, b, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B, b, B } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B, b } );
// std::cout << res << std::endl << comp << std::endl;
@@ -134,15 +134,15 @@ void HandleFirstFirstConflict::testHandleFirstFirstConflict2 ( ) {
comp2.setNonterminalAlphabet ( { A, Ap, B, C } );
comp2.setInitialSymbol ( A );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { a, Ap } );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { c, B, b, B } );
- comp2.addRule ( Ap, ext::vector < DefaultSymbolType > { B } );
- comp2.addRule ( Ap, ext::vector < DefaultSymbolType > { C, B } );
- comp2.addRule ( Ap, ext::vector < DefaultSymbolType > { b, B } );
- comp2.addRule ( B, ext::vector < DefaultSymbolType > { c, B } );
- comp2.addRule ( B, ext::vector < DefaultSymbolType > { a } );
- comp2.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp2.addRule ( C, ext::vector < DefaultSymbolType > { B, b } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Ap } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B, b, B } );
+ comp2.addRule ( Ap, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B } );
+ comp2.addRule ( Ap, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C, B } );
+ comp2.addRule ( Ap, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
+ comp2.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, B } );
+ comp2.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a } );
+ comp2.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp2.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B, b } );
// std::cout << res << std::endl << comp2 << std::endl;
diff --git a/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFollowConflict.cpp b/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFollowConflict.cpp
index cd1ca80f58..17ff67d5fc 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFollowConflict.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/HandleFirstFollowConflict.cpp
@@ -32,12 +32,12 @@ void HandleFirstFollowConflict::testHandleFirstFollowConflict ( ) {
grammar.setNonterminalAlphabet ( { A, B, C } );
grammar.setInitialSymbol ( A );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { a, B, C } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { c, C } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { a, B, a, d } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { b, B } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B, C } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B, a, d } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
grammar::CFG < > res = grammar;
grammar::parsing::HandleFirstFollowConflict::handleFirstFollowConflict ( res, a, B, { { a, B, C }, { } } );
@@ -48,13 +48,13 @@ void HandleFirstFollowConflict::testHandleFirstFollowConflict ( ) {
comp.setNonterminalAlphabet ( { A, B, C } );
comp.setInitialSymbol ( A );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, B, a, C } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, B, b, B } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { c, C } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { a, B, a, d } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { b, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B, a, C } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B, b, B } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B, a, d } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
// std::cout << "res " << alib::StringDataFactory::toString ( grammar::Grammar ( res ) ) << std::endl << "comp " << alib::StringDataFactory::toString ( grammar::Grammar ( comp ) ) << std::endl;
@@ -68,15 +68,15 @@ void HandleFirstFollowConflict::testHandleFirstFollowConflict ( ) {
comp2.setNonterminalAlphabet ( { A, B, Ba, C } );
comp2.setInitialSymbol ( A );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { a, Ba, C } );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { a, B, b, B } );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { c, C } );
- comp2.addRule ( B, ext::vector < DefaultSymbolType > { a, Ba, d } );
- comp2.addRule ( B, ext::vector < DefaultSymbolType > { } );
- comp2.addRule ( Ba, ext::vector < DefaultSymbolType > { a, Ba, d, a } );
- comp2.addRule ( Ba, ext::vector < DefaultSymbolType > { a } );
- comp2.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp2.addRule ( C, ext::vector < DefaultSymbolType > { b, B } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Ba, C } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B, b, B } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
+ comp2.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Ba, d } );
+ comp2.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp2.addRule ( Ba, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Ba, d, a } );
+ comp2.addRule ( Ba, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a } );
+ comp2.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp2.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
// std::cout << "res2 " << alib::StringDataFactory::toString ( grammar::Grammar ( res ) ) << std::endl << "comp2 " << alib::StringDataFactory::toString ( grammar::Grammar ( comp2 ) ) << std::endl;
@@ -103,13 +103,13 @@ void HandleFirstFollowConflict::testHandleFirstFollowConflict2 ( ) {
grammar.setNonterminalAlphabet ( { A, B, C, X } );
grammar.setInitialSymbol ( A );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { a, X, C, a } );
- grammar.addRule ( A, ext::vector < DefaultSymbolType > { c, C } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, X, C, a } );
+ grammar.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
grammar.addRule ( X, { c, B });
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { a, B, a, d } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { b, B, c } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B, a, d } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B, c } );
grammar::CFG < > res = grammar;
grammar::parsing::HandleFirstFollowConflict::handleFirstFollowConflict ( res, a, B, { { a, B, C }, { } } );
@@ -120,14 +120,14 @@ void HandleFirstFollowConflict::testHandleFirstFollowConflict2 ( ) {
comp.setNonterminalAlphabet ( { A, B, C, X } );
comp.setInitialSymbol ( A );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, X, a, C, a } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { a, X, b, B, c, a } );
- comp.addRule ( A, ext::vector < DefaultSymbolType > { c, C } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, X, a, C, a } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, X, b, B, c, a } );
+ comp.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
comp.addRule ( X, { c, B } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { a, B, a, d } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { b, B, c } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B, a, d } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B, c } );
// std::cout << "res " << alib::StringDataFactory::toString ( grammar::Grammar ( res ) ) << std::endl << "comp " << alib::StringDataFactory::toString ( grammar::Grammar ( comp ) ) << std::endl;
@@ -141,17 +141,17 @@ void HandleFirstFollowConflict::testHandleFirstFollowConflict2 ( ) {
comp2.setNonterminalAlphabet ( { A, B, Ba, C, X, Xa } );
comp2.setInitialSymbol ( A );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { a, Xa, C, a } );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { a, X, b, B, c, a } );
- comp2.addRule ( A, ext::vector < DefaultSymbolType > { c, C } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Xa, C, a } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, X, b, B, c, a } );
+ comp2.addRule ( A, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
comp2.addRule ( X, { c, B } );
comp2.addRule ( Xa, { c, Ba } );
- comp2.addRule ( B, ext::vector < DefaultSymbolType > { a, Ba, d } );
- comp2.addRule ( B, ext::vector < DefaultSymbolType > { } );
- comp2.addRule ( Ba, ext::vector < DefaultSymbolType > { a, Ba, d, a } );
- comp2.addRule ( Ba, ext::vector < DefaultSymbolType > { a } );
- comp2.addRule ( C, ext::vector < DefaultSymbolType > { a, C } );
- comp2.addRule ( C, ext::vector < DefaultSymbolType > { b, B, c } );
+ comp2.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Ba, d } );
+ comp2.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp2.addRule ( Ba, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Ba, d, a } );
+ comp2.addRule ( Ba, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a } );
+ comp2.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ comp2.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B, c } );
// std::cout << "res2 " << alib::StringDataFactory::toString ( grammar::Grammar ( res ) ) << std::endl << "comp2 " << alib::StringDataFactory::toString ( grammar::Grammar ( comp2 ) ) << std::endl;
diff --git a/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp b/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
index 17484041bb..3242e53926 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/LL1ParseTable.cpp
@@ -31,57 +31,44 @@ void LL1ParseTable::testLL1Table ( ) {
grammar.setTerminalAlphabet ( ext::set < DefaultSymbolType > { tP, tS, tL, tR, tA } );
grammar.setNonterminalAlphabet ( ext::set < DefaultSymbolType > { nE, nEp, nT, nTp, nF } );
- {
- ext::vector < DefaultSymbolType > rhsE1 ( { nT, nEp } );
- ext::vector < DefaultSymbolType > rhsEp1 ( { tP, nT, nEp } );
- ext::vector < DefaultSymbolType > rhsEp2 ( { } );
- ext::vector < DefaultSymbolType > rhsT1 ( { nF, nTp } );
- ext::vector < DefaultSymbolType > rhsTp1 ( { tS, nF, nTp } );
- ext::vector < DefaultSymbolType > rhsTp2 ( { } );
- ext::vector < DefaultSymbolType > rhsF1 ( { tA } );
- ext::vector < DefaultSymbolType > rhsF2 ( { tL, nE, tR } );
-
- grammar.addRule ( nE, rhsE1 );
- grammar.addRule ( nEp, rhsEp1 );
- grammar.addRule ( nEp, rhsEp2 );
- grammar.addRule ( nT, rhsT1 );
- grammar.addRule ( nTp, rhsTp1 );
- grammar.addRule ( nTp, rhsTp2 );
- grammar.addRule ( nF, rhsF1 );
- grammar.addRule ( nF, rhsF2 );
- }
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE1 ( { nT, nEp } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsEp1 ( { tP, nT, nEp } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsEp2 ( { } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsT1 ( { nF, nTp } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsTp1 ( { tS, nF, nTp } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsTp2 ( { } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF1 ( { tA } );
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF2 ( { tL, nE, tR } );
+
+ grammar.addRule ( nE, rhsE1 );
+ grammar.addRule ( nEp, rhsEp1 );
+ grammar.addRule ( nEp, rhsEp2 );
+ grammar.addRule ( nT, rhsT1 );
+ grammar.addRule ( nTp, rhsTp1 );
+ grammar.addRule ( nTp, rhsTp2 );
+ grammar.addRule ( nF, rhsF1 );
+ grammar.addRule ( nF, rhsF2 );
// --------------------------------------------------
ext::map < ext::pair < ext::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > parseTable;
- {
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsE1 ( { nT, nEp } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsEp1 ( { tP, nT, nEp } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsEp2 ( { } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsT1 ( { nF, nTp } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsTp1 ( { tS, nF, nTp } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsTp2 ( { } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF1 ( { tA } );
- ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > rhsF2 ( { tL, nE, tR } );
-
- parseTable[ext::make_pair ( tA, nE )].insert ( rhsE1 );
- parseTable[ext::make_pair ( tL, nE )].insert ( rhsE1 );
-
- parseTable[ext::make_pair ( tP, nEp )].insert ( rhsEp1 );
- parseTable[ext::make_pair ( tR, nEp )].insert ( rhsEp2 );
- parseTable[ext::make_pair ( string::Epsilon < >::EPSILON, nEp )].insert ( rhsEp2 );
-
- parseTable[ext::make_pair ( tA, nT )].insert ( rhsT1 );
- parseTable[ext::make_pair ( tL, nT )].insert ( rhsT1 );
-
- parseTable[ext::make_pair ( tS, nTp )].insert ( rhsTp1 );
- parseTable[ext::make_pair ( tP, nTp )].insert ( rhsTp2 );
- parseTable[ext::make_pair ( tR, nTp )].insert ( rhsTp2 );
- parseTable[ext::make_pair ( string::Epsilon < >::EPSILON, nTp )].insert ( rhsTp2 );
-
- parseTable[ext::make_pair ( tA, nF )].insert ( rhsF1 );
- parseTable[ext::make_pair ( tL, nF )].insert ( rhsF2 );
- }
+ parseTable[ext::make_pair ( tA, nE )].insert ( rhsE1 );
+ parseTable[ext::make_pair ( tL, nE )].insert ( rhsE1 );
+
+ parseTable[ext::make_pair ( tP, nEp )].insert ( rhsEp1 );
+ parseTable[ext::make_pair ( tR, nEp )].insert ( rhsEp2 );
+ parseTable[ext::make_pair ( string::Epsilon < >::EPSILON, nEp )].insert ( rhsEp2 );
+
+ parseTable[ext::make_pair ( tA, nT )].insert ( rhsT1 );
+ parseTable[ext::make_pair ( tL, nT )].insert ( rhsT1 );
+
+ parseTable[ext::make_pair ( tS, nTp )].insert ( rhsTp1 );
+ parseTable[ext::make_pair ( tP, nTp )].insert ( rhsTp2 );
+ parseTable[ext::make_pair ( tR, nTp )].insert ( rhsTp2 );
+ parseTable[ext::make_pair ( string::Epsilon < >::EPSILON, nTp )].insert ( rhsTp2 );
+
+ parseTable[ext::make_pair ( tA, nF )].insert ( rhsF1 );
+ parseTable[ext::make_pair ( tL, nF )].insert ( rhsF2 );
// --------------------------------------------------
diff --git a/alib2algo_experimental/test-src/grammar/parsing/LR0Parser.cpp b/alib2algo_experimental/test-src/grammar/parsing/LR0Parser.cpp
index ed9f3b0e1b..457e4dda2b 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/LR0Parser.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/LR0Parser.cpp
@@ -304,48 +304,45 @@ void LR0Parser::testAutomaton ( ) {
}
};
- ext::vector < DefaultStateType > states;
- for (const grammar::parsing::LR0Items & currentItems : items) {
- states.emplace_back( DefaultStateType ( label::LR0ItemsLabel ( currentItems ) ) );
- }
-
- automaton::DFA<> parsingAutomaton ( states[0] );
- parsingAutomaton.addInputSymbols ( augmentedExpressionGrammar.getNonterminalAlphabet ( ) );
- parsingAutomaton.addInputSymbols ( augmentedExpressionGrammar.getTerminalAlphabet ( ) );
+ automaton::DFA < ext::variant < DefaultSymbolType, DefaultSymbolType >, grammar::parsing::LR0Items > parsingAutomaton ( items[0] );
+ for ( const DefaultSymbolType & nonterminal : augmentedExpressionGrammar.getNonterminalAlphabet ( ) )
+ parsingAutomaton.addInputSymbol ( nonterminal );
+ for ( const DefaultSymbolType & terminal : augmentedExpressionGrammar.getTerminalAlphabet ( ) )
+ parsingAutomaton.addInputSymbol ( terminal );
- for (const DefaultStateType & state : states) {
+ for (const grammar::parsing::LR0Items & state : items) {
parsingAutomaton.addState(state);
}
- parsingAutomaton.addTransition(states[0], E, states[1]);
- parsingAutomaton.addTransition(states[0], T, states[2]);
- parsingAutomaton.addTransition(states[0], identifier, states[5]);
- parsingAutomaton.addTransition(states[0], leftParenthesis, states[4]);
- parsingAutomaton.addTransition(states[0], F, states[3]);
+ parsingAutomaton.addTransition(items[0], E, items[1]);
+ parsingAutomaton.addTransition(items[0], T, items[2]);
+ parsingAutomaton.addTransition(items[0], identifier, items[5]);
+ parsingAutomaton.addTransition(items[0], leftParenthesis, items[4]);
+ parsingAutomaton.addTransition(items[0], F, items[3]);
- parsingAutomaton.addTransition(states[1], plus, states[6]);
+ parsingAutomaton.addTransition(items[1], plus, items[6]);
- parsingAutomaton.addTransition(states[2], times, states[7]);
+ parsingAutomaton.addTransition(items[2], times, items[7]);
- parsingAutomaton.addTransition(states[4], E, states[8]);
- parsingAutomaton.addTransition(states[4], F, states[3]);
- parsingAutomaton.addTransition(states[4], T, states[2]);
- parsingAutomaton.addTransition(states[4], leftParenthesis, states[4]);
- parsingAutomaton.addTransition(states[4], identifier, states[5]);
+ parsingAutomaton.addTransition(items[4], E, items[8]);
+ parsingAutomaton.addTransition(items[4], F, items[3]);
+ parsingAutomaton.addTransition(items[4], T, items[2]);
+ parsingAutomaton.addTransition(items[4], leftParenthesis, items[4]);
+ parsingAutomaton.addTransition(items[4], identifier, items[5]);
- parsingAutomaton.addTransition(states[6], T, states[9]);
- parsingAutomaton.addTransition(states[6], F, states[3]);
- parsingAutomaton.addTransition(states[6], leftParenthesis, states[4]);
- parsingAutomaton.addTransition(states[6], identifier, states[5]);
+ parsingAutomaton.addTransition(items[6], T, items[9]);
+ parsingAutomaton.addTransition(items[6], F, items[3]);
+ parsingAutomaton.addTransition(items[6], leftParenthesis, items[4]);
+ parsingAutomaton.addTransition(items[6], identifier, items[5]);
- parsingAutomaton.addTransition(states[7], F, states[10]);
- parsingAutomaton.addTransition(states[7], leftParenthesis, states[4]);
- parsingAutomaton.addTransition(states[7], identifier, states[5]);
+ parsingAutomaton.addTransition(items[7], F, items[10]);
+ parsingAutomaton.addTransition(items[7], leftParenthesis, items[4]);
+ parsingAutomaton.addTransition(items[7], identifier, items[5]);
- parsingAutomaton.addTransition(states[8], rightParenthesis, states[11]);
- parsingAutomaton.addTransition(states[8], plus, states[6]);
+ parsingAutomaton.addTransition(items[8], rightParenthesis, items[11]);
+ parsingAutomaton.addTransition(items[8], plus, items[6]);
- parsingAutomaton.addTransition(states[9], times, states[7]);
+ parsingAutomaton.addTransition(items[9], times, items[7]);
CPPUNIT_ASSERT ( grammar::parsing::LR0Parser::getAutomaton(getExpressionGrammar()) == parsingAutomaton );
}
diff --git a/alib2algo_experimental/test-src/grammar/parsing/LRParser.cpp b/alib2algo_experimental/test-src/grammar/parsing/LRParser.cpp
index 1921562740..1d7c11cb71 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/LRParser.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/LRParser.cpp
@@ -52,7 +52,7 @@ void LRParser::testEndOfInputSymbol ( ) {
void LRParser::testParseCorrectInput ( ) {
grammar::CFG < > augmentedExpressionGrammar = grammar::parsing::LRParser::getAugmentedGrammar ( getExpressionGrammar ( ) );
- DefaultStateType initialState ( DefaultStateType ( label::LR0ItemsLabel ( {
+ grammar::parsing::LR0Items initialState {
{
augmentedExpressionGrammar.getInitialSymbol(),
{
@@ -80,7 +80,7 @@ void LRParser::testParseCorrectInput ( ) {
{ 0 , { identifier } }
}
}
- } ) ) );
+ };
ext::vector < DefaultSymbolType > correctInput {
leftParenthesis,
@@ -107,8 +107,8 @@ void LRParser::testParseCorrectInput ( ) {
void LRParser::testParseIncorrectInput ( ) {
grammar::CFG < > augmentedExpressionGrammar = grammar::parsing::LRParser::getAugmentedGrammar ( getExpressionGrammar ( ) );
-
- DefaultStateType initialState ( DefaultStateType ( label::LR0ItemsLabel ( {
+
+ grammar::parsing::LR0Items initialState {
{
augmentedExpressionGrammar.getInitialSymbol(),
{
@@ -136,7 +136,7 @@ void LRParser::testParseIncorrectInput ( ) {
{ 0 , { identifier } }
}
}
- } ) ) );
+ };
ext::vector < DefaultSymbolType > incorrectInput {
leftParenthesis,
diff --git a/alib2algo_experimental/test-src/grammar/parsing/LeftFactorize.cpp b/alib2algo_experimental/test-src/grammar/parsing/LeftFactorize.cpp
index 0fe206323b..5f722fe6a2 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/LeftFactorize.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/LeftFactorize.cpp
@@ -30,12 +30,12 @@ void LeftFactorize::testLeftFactorize ( ) {
grammar.setNonterminalAlphabet ( { S, B, C } );
grammar.setInitialSymbol ( S );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { a, B } );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { a, C } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { b, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { b } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { c, C } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { c } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c } );
grammar::CFG < > res = grammar;
grammar::parsing::LeftFactorize::leftFactorize ( res, a, S);
@@ -48,15 +48,15 @@ void LeftFactorize::testLeftFactorize ( ) {
comp.setNonterminalAlphabet ( { S, Sp, B, Bp, C, Cp } );
comp.setInitialSymbol ( S );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { a, Sp } );
- comp.addRule ( Sp, ext::vector < DefaultSymbolType > { B } );
- comp.addRule ( Sp, ext::vector < DefaultSymbolType > { C } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { b, Bp } );
- comp.addRule ( Bp, ext::vector < DefaultSymbolType > { B } );
- comp.addRule ( Bp, ext::vector < DefaultSymbolType > { } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { c, Cp } );
- comp.addRule ( Cp, ext::vector < DefaultSymbolType > { C } );
- comp.addRule ( Cp, ext::vector < DefaultSymbolType > { } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Sp } );
+ comp.addRule ( Sp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B } );
+ comp.addRule ( Sp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, Bp } );
+ comp.addRule ( Bp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B } );
+ comp.addRule ( Bp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, Cp } );
+ comp.addRule ( Cp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C } );
+ comp.addRule ( Cp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
// std::cout << res << std::endl << comp << std::endl;
@@ -83,15 +83,15 @@ void LeftFactorize::testLeftFactorize2 ( ) {
grammar.setNonterminalAlphabet ( { S, B, C, D } );
grammar.setInitialSymbol ( S );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { a, B } );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { a, C } );
- grammar.addRule ( S, ext::vector < DefaultSymbolType > { D } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { b, B } );
- grammar.addRule ( B, ext::vector < DefaultSymbolType > { b } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { c, C } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { c } );
- grammar.addRule ( C, ext::vector < DefaultSymbolType > { b } );
- grammar.addRule ( D, ext::vector < DefaultSymbolType > { d } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, B } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, C } );
+ grammar.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { D } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, B } );
+ grammar.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, C } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c } );
+ grammar.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b } );
+ grammar.addRule ( D, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { d } );
grammar::CFG < > res = grammar;
grammar::parsing::LeftFactorize::leftFactorize ( res, a, S);
@@ -104,18 +104,18 @@ void LeftFactorize::testLeftFactorize2 ( ) {
comp.setNonterminalAlphabet ( { S, Sp, B, Bp, C, Cp, D} );
comp.setInitialSymbol ( S );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { a, Sp } );
- comp.addRule ( S, ext::vector < DefaultSymbolType > { D } );
- comp.addRule ( Sp, ext::vector < DefaultSymbolType > { B } );
- comp.addRule ( Sp, ext::vector < DefaultSymbolType > { C } );
- comp.addRule ( B, ext::vector < DefaultSymbolType > { b, Bp } );
- comp.addRule ( Bp, ext::vector < DefaultSymbolType > { B } );
- comp.addRule ( Bp, ext::vector < DefaultSymbolType > { } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { c, Cp } );
- comp.addRule ( C, ext::vector < DefaultSymbolType > { b } );
- comp.addRule ( Cp, ext::vector < DefaultSymbolType > { C } );
- comp.addRule ( Cp, ext::vector < DefaultSymbolType > { } );
- comp.addRule ( D, ext::vector < DefaultSymbolType > { d } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { a, Sp } );
+ comp.addRule ( S, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { D } );
+ comp.addRule ( Sp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B } );
+ comp.addRule ( Sp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C } );
+ comp.addRule ( B, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b, Bp } );
+ comp.addRule ( Bp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { B } );
+ comp.addRule ( Bp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { c, Cp } );
+ comp.addRule ( C, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { b } );
+ comp.addRule ( Cp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { C } );
+ comp.addRule ( Cp, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { } );
+ comp.addRule ( D, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { d } );
// std::cout << res << std::endl << comp << std::endl;
diff --git a/alib2algo_experimental/test-src/grammar/parsing/SLR1ParseTable.cpp b/alib2algo_experimental/test-src/grammar/parsing/SLR1ParseTable.cpp
index ac24ce337a..59dc916c51 100644
--- a/alib2algo_experimental/test-src/grammar/parsing/SLR1ParseTable.cpp
+++ b/alib2algo_experimental/test-src/grammar/parsing/SLR1ParseTable.cpp
@@ -229,62 +229,57 @@ void SLR1ParseTable::testActionTable ( ) {
}
};
- ext::vector < DefaultStateType > states;
- for (const grammar::parsing::LR0Items & currentItems : items) {
- states.emplace_back( DefaultStateType ( label::LR0ItemsLabel ( currentItems ) ) );
- }
-
DefaultSymbolType endOfInput = grammar::parsing::LRParser::getEndOfInputSymbol ( getExpressionGrammar ( ) );
grammar::parsing::LRActionTable correctActionTable {
- { { states[0], identifier }, { grammar::parsing::LRAction::Shift, states[5] } },
- { { states[0], leftParenthesis }, { grammar::parsing::LRAction::Shift, states[4] } },
- { { states[1], plus }, { grammar::parsing::LRAction::Shift, states[6] } },
- { { states[1], endOfInput }, { grammar::parsing::LRAction::Accept, states[0] } },
- { { states[2], times }, { grammar::parsing::LRAction::Shift, states[7] } },
- { { states[4], identifier }, { grammar::parsing::LRAction::Shift, states[5] } },
- { { states[4], leftParenthesis }, { grammar::parsing::LRAction::Shift, states[4] } },
- { { states[6], identifier }, { grammar::parsing::LRAction::Shift, states[5] } },
- { { states[6], leftParenthesis }, { grammar::parsing::LRAction::Shift, states[4] } },
- { { states[7], identifier }, { grammar::parsing::LRAction::Shift, states[5] } },
- { { states[7], leftParenthesis }, { grammar::parsing::LRAction::Shift, states[4] } },
- { { states[8], plus }, { grammar::parsing::LRAction::Shift, states[6] } },
- { { states[8], rightParenthesis }, { grammar::parsing::LRAction::Shift, states[11] } },
- { { states[9], times }, { grammar::parsing::LRAction::Shift, states[7] } }
+ { { items[0], identifier }, { grammar::parsing::LRAction::Shift, items[5] } },
+ { { items[0], leftParenthesis }, { grammar::parsing::LRAction::Shift, items[4] } },
+ { { items[1], plus }, { grammar::parsing::LRAction::Shift, items[6] } },
+ { { items[1], endOfInput }, { grammar::parsing::LRAction::Accept, items[0] } },
+ { { items[2], times }, { grammar::parsing::LRAction::Shift, items[7] } },
+ { { items[4], identifier }, { grammar::parsing::LRAction::Shift, items[5] } },
+ { { items[4], leftParenthesis }, { grammar::parsing::LRAction::Shift, items[4] } },
+ { { items[6], identifier }, { grammar::parsing::LRAction::Shift, items[5] } },
+ { { items[6], leftParenthesis }, { grammar::parsing::LRAction::Shift, items[4] } },
+ { { items[7], identifier }, { grammar::parsing::LRAction::Shift, items[5] } },
+ { { items[7], leftParenthesis }, { grammar::parsing::LRAction::Shift, items[4] } },
+ { { items[8], plus }, { grammar::parsing::LRAction::Shift, items[6] } },
+ { { items[8], rightParenthesis }, { grammar::parsing::LRAction::Shift, items[11] } },
+ { { items[9], times }, { grammar::parsing::LRAction::Shift, items[7] } }
};
- ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > reduceBy = ext::make_pair ( E, ext::vector < DefaultSymbolType > { T } );
- correctActionTable.insert ( { { states[2], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[2], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[2], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ ext::pair < DefaultSymbolType, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > reduceBy = ext::make_pair ( E, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { T } );
+ correctActionTable.insert ( { { items[2], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[2], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[2], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- reduceBy = ext::make_pair ( T, ext::vector < DefaultSymbolType > { F } );
- correctActionTable.insert ( { { states[3], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[3], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[3], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[3], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ reduceBy = ext::make_pair ( T, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { F } );
+ correctActionTable.insert ( { { items[3], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[3], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[3], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[3], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- reduceBy = ext::make_pair ( F, ext::vector < DefaultSymbolType > { identifier } );
- correctActionTable.insert ( { { states[5], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[5], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[5], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[5], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
-
- reduceBy = ext::make_pair ( E, ext::vector < DefaultSymbolType > { E, plus, T } );
- correctActionTable.insert ( { { states[9], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[9], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[9], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
-
- reduceBy = ext::make_pair ( T, ext::vector < DefaultSymbolType > { T, times, F } );
- correctActionTable.insert ( { { states[10], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[10], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[10], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[10], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
-
- reduceBy = ext::make_pair ( F, ext::vector < DefaultSymbolType > { leftParenthesis, E, rightParenthesis } );
- correctActionTable.insert ( { { states[11], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[11], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[11], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
- correctActionTable.insert ( { { states[11], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ reduceBy = ext::make_pair ( F, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { identifier } );
+ correctActionTable.insert ( { { items[5], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[5], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[5], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[5], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+
+ reduceBy = ext::make_pair ( E, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { E, plus, T } );
+ correctActionTable.insert ( { { items[9], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[9], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[9], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+
+ reduceBy = ext::make_pair ( T, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { T, times, F } );
+ correctActionTable.insert ( { { items[10], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[10], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[10], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[10], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+
+ reduceBy = ext::make_pair ( F, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > { leftParenthesis, E, rightParenthesis } );
+ correctActionTable.insert ( { { items[11], plus }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[11], times }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[11], rightParenthesis }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
+ correctActionTable.insert ( { { items[11], endOfInput }, { grammar::parsing::LRAction::Reduce, reduceBy } } );
grammar::parsing::LRActionTable actionTable = grammar::parsing::SLR1ParseTable::getActionTable ( getExpressionGrammar ( ) );
@@ -304,13 +299,13 @@ void SLR1ParseTable::testActionTable ( ) {
bool correctContent = true;
switch ( actionTablePair.second.first ) {
case grammar::parsing::LRAction::Shift:
- if ( actionTablePair.second.second.get < DefaultStateType > ( ) != value->second.second.get < DefaultStateType > ( ) ) {
+ if ( actionTablePair.second.second.get < grammar::parsing::LR0Items > ( ) != value->second.second.get < grammar::parsing::LR0Items > ( ) ) {
correctContent = false;
}
break;
case grammar::parsing::LRAction::Reduce:
- if ( actionTablePair.second.second.get < ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( ) != value->second.second.get < ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > ( ) ) {
+ if ( actionTablePair.second.second.get < ext::pair < DefaultSymbolType, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > ( ) != value->second.second.get < ext::pair < DefaultSymbolType, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > ( ) ) {
correctContent = false;
}
break;
@@ -527,21 +522,16 @@ void SLR1ParseTable::testGotoTable ( ) {
}
};
- ext::vector < DefaultStateType > states;
- for (const grammar::parsing::LR0Items & currentItems : items) {
- states.emplace_back( DefaultStateType ( label::LR0ItemsLabel ( currentItems ) ) );
- }
-
grammar::parsing::LRGotoTable gotoTable {
- { { states[0], E }, states[1] },
- { { states[0], T }, states[2] },
- { { states[0], F }, states[3] },
- { { states[4], E }, states[8] },
- { { states[4], T }, states[2] },
- { { states[4], F }, states[3] },
- { { states[6], T }, states[9] },
- { { states[6], F }, states[3] },
- { { states[7], F }, states[10] }
+ { { items[0], E }, items[1] },
+ { { items[0], T }, items[2] },
+ { { items[0], F }, items[3] },
+ { { items[4], E }, items[8] },
+ { { items[4], T }, items[2] },
+ { { items[4], F }, items[3] },
+ { { items[6], T }, items[9] },
+ { { items[6], F }, items[3] },
+ { { items[7], F }, items[10] }
};
CPPUNIT_ASSERT ( grammar::parsing::SLR1ParseTable::getGotoTable ( getExpressionGrammar ( ) ) == gotoTable );
diff --git a/alib2data/src/PrimitiveRegistrator.cpp b/alib2data/src/PrimitiveRegistrator.cpp
index e55f1c011c..0099f20b6f 100644
--- a/alib2data/src/PrimitiveRegistrator.cpp
+++ b/alib2data/src/PrimitiveRegistrator.cpp
@@ -73,6 +73,7 @@ public:
core::xmlApi < object::Object >::template registerXmlWriter < object::AnyObject < ext::pair < ext::set < ext::pair < object::Object, object::Object > >, ext::variant < string::Epsilon < object::Object >, object::Object > > > > ( );
core::xmlApi < object::Object >::template registerXmlWriter < object::AnyObject < ext::pair < object::Object, ext::variant < string::Epsilon < object::Object >, object::Object > > > > ( );
core::xmlApi < object::Object >::template registerXmlWriter < object::AnyObject < ext::vector < object::Object > > > ( );
+ core::xmlApi < object::Object >::template registerXmlWriter < object::AnyObject < ext::vector < ext::variant < object::Object, object::Object > > > > ( );
core::xmlApi < object::Object >::template registerXmlWriter < object::AnyObject < ext::set < object::Object > > > ( );
core::xmlApi < object::Object >::template registerXmlWriter < object::AnyObject < unsigned int > > ( );
core::xmlApi < object::Object >::template registerXmlWriter < container::ObjectsPair < object::Object, unsigned > > ( );
diff --git a/alib2data/src/alphabet/common/SymbolNormalize.h b/alib2data/src/alphabet/common/SymbolNormalize.h
index 42476ee358..20fe47f86b 100644
--- a/alib2data/src/alphabet/common/SymbolNormalize.h
+++ b/alib2data/src/alphabet/common/SymbolNormalize.h
@@ -31,12 +31,18 @@ public:
template < class SymbolType >
static DefaultSymbolType normalizeSymbol ( SymbolType && symbol );
+ template < class FirstSymbolType, class SecondSymbolType >
+ static ext::variant < DefaultSymbolType, DefaultSymbolType > normalizeVariantSymbol ( ext::variant < FirstSymbolType, SecondSymbolType > && symbol );
+
template < class SymbolType, class RankType >
static common::ranked_symbol < DefaultSymbolType, DefaultRankType > normalizeRankedSymbol ( common::ranked_symbol < SymbolType, RankType > && symbol );
template < class SymbolType >
static ext::vector < DefaultSymbolType > normalizeSymbols ( ext::vector < SymbolType > && symbols );
+ template < class FirstSymbolType, class SecondSymbolType >
+ static ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > normalizeVariantSymbols ( ext::vector < ext::variant < FirstSymbolType, SecondSymbolType > > && symbols );
+
template < class SymbolType, class RankType >
static ext::vector < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > normalizeRankedSymbols ( ext::vector < common::ranked_symbol < SymbolType, RankType > > && symbols );
};
@@ -64,6 +70,14 @@ DefaultSymbolType SymbolNormalize::normalizeSymbol ( SymbolType && symbol ) {
return object::ObjectFactory::make ( std::move ( symbol ) );
}
+template < class FirstSymbolType, class SecondSymbolType >
+ext::variant < DefaultSymbolType, DefaultSymbolType > SymbolNormalize::normalizeVariantSymbol ( ext::variant < FirstSymbolType, SecondSymbolType > && symbol ) {
+ if ( symbol.template is < FirstSymbolType > ( ) )
+ return ext::variant < DefaultSymbolType, DefaultSymbolType > ( object::ObjectFactory::make ( std::move ( symbol.template get < FirstSymbolType > ( ) ) ) );
+ else
+ return ext::variant < DefaultSymbolType, DefaultSymbolType > ( object::ObjectFactory::make ( std::move ( symbol.template get < SecondSymbolType > ( ) ) ) );
+}
+
template < class SymbolType, class RankType >
common::ranked_symbol < DefaultSymbolType, DefaultRankType > SymbolNormalize::normalizeRankedSymbol ( common::ranked_symbol < SymbolType, RankType > && symbol ) {
return common::ranked_symbol < DefaultSymbolType, DefaultRankType > ( normalizeSymbol ( std::move ( symbol ).getSymbol ( ) ), DefaultRankType ( std::move ( symbol ).getRank ( ) ) );
@@ -78,6 +92,15 @@ ext::vector < DefaultSymbolType > SymbolNormalize::normalizeSymbols ( ext::vecto
return res;
}
+template < class FirstSymbolType, class SecondSymbolType >
+ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > SymbolNormalize::normalizeVariantSymbols ( ext::vector < ext::variant < FirstSymbolType, SecondSymbolType > > && symbols ) {
+ ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > res;
+ for ( ext::variant < FirstSymbolType, SecondSymbolType > & symbol : symbols ) {
+ res.push_back ( normalizeVariantSymbol ( std::move ( symbol ) ) );
+ }
+ return res;
+}
+
template < class SymbolType, class RankType >
ext::vector < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > SymbolNormalize::normalizeRankedSymbols ( ext::vector < common::ranked_symbol < SymbolType, RankType > > && symbols ) {
ext::vector < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > res;
diff --git a/alib2data/src/grammar/AddRawRule.h b/alib2data/src/grammar/AddRawRule.h
index 9814d66953..c14dd6d014 100644
--- a/alib2data/src/grammar/AddRawRule.h
+++ b/alib2data/src/grammar/AddRawRule.h
@@ -45,26 +45,26 @@ public:
/**
* \override
*/
- template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
- static bool addRawRule ( GNF < SymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static bool addRawRule ( GNF < TerminalSymbolType, NonterminalSymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
/**
* \override
*/
- template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
- static bool addRawRule ( EpsilonFreeCFG < SymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static bool addRawRule ( EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
/**
* \override
*/
- template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
- static bool addRawRule ( CNF < SymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static bool addRawRule ( CNF < TerminalSymbolType, NonterminalSymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
/**
* \override
*/
- template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
- static bool addRawRule ( CFG < SymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static bool addRawRule ( CFG < TerminalSymbolType, NonterminalSymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
/**
* \override
@@ -118,8 +118,8 @@ bool AddRawRule::addRawRule ( LG < TerminalSymbolType, NonterminalSymbolType > &
}
}
-template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
-bool AddRawRule::addRawRule ( GNF < SymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool AddRawRule::addRawRule ( GNF < TerminalSymbolType, NonterminalSymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
if ( rightHandSide.size ( ) == 0 ) {
if ( leftHandSide != grammar.getInitialSymbol ( ) )
throw GrammarException ( "Illegal left hand side of epsilon rule" );
@@ -138,8 +138,8 @@ bool AddRawRule::addRawRule ( GNF < SymbolType > & grammar, NonterminalSymbolTyp
}
}
-template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
-bool AddRawRule::addRawRule ( EpsilonFreeCFG < SymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool AddRawRule::addRawRule ( EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
if ( rightHandSide.size ( ) == 0 ) {
if ( leftHandSide != grammar.getInitialSymbol ( ) )
throw GrammarException ( "Illegal left hand side of epsilon rule" );
@@ -148,16 +148,12 @@ bool AddRawRule::addRawRule ( EpsilonFreeCFG < SymbolType > & grammar, Nontermin
grammar.setGeneratesEpsilon ( true );
return ! res;
} else {
- ext::vector < SymbolType > rhs;
- for ( ext::variant < TerminalSymbolType, NonterminalSymbolType > & element : ext::make_iterator_range ( rightHandSide.begin ( ), rightHandSide.end ( ) ) )
- rhs.push_back ( std::move ( element.template get < SymbolType > ( ) ) );
-
- return grammar.addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
+ return grammar.addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
}
}
-template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
-bool AddRawRule::addRawRule ( CNF < SymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool AddRawRule::addRawRule ( CNF < TerminalSymbolType, NonterminalSymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
if ( rightHandSide.size ( ) == 0 ) {
if ( leftHandSide != grammar.getInitialSymbol ( ) )
throw GrammarException ( "Illegal left hand side of epsilon rule" );
@@ -174,13 +170,9 @@ bool AddRawRule::addRawRule ( CNF < SymbolType > & grammar, NonterminalSymbolTyp
}
}
-template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
-bool AddRawRule::addRawRule ( CFG < SymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
- ext::vector < SymbolType > rhs;
- for ( ext::variant < TerminalSymbolType, NonterminalSymbolType > & element : ext::make_iterator_range ( rightHandSide.begin ( ), rightHandSide.end ( ) ) )
- rhs.push_back ( std::move ( element.template get < SymbolType > ( ) ) );
-
- return grammar.addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool AddRawRule::addRawRule ( CFG < TerminalSymbolType, NonterminalSymbolType > & grammar, NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
+ return grammar.addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
}
template < class TerminalSymbolType, class NonterminalSymbolType >
diff --git a/alib2data/src/grammar/ContextFree/CFG.h b/alib2data/src/grammar/ContextFree/CFG.h
index 5bb00f51e2..ace9d8630d 100644
--- a/alib2data/src/grammar/ContextFree/CFG.h
+++ b/alib2data/src/grammar/ContextFree/CFG.h
@@ -62,14 +62,15 @@ class InitialSymbol;
* P = set of production rules of the form A -> B, where A \in N and B \in ( N \cup T )*,
* S (InitialSymbol) = initial nonterminal symbol,
*
- * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType = DefaultSymbolType >
-class CFG final : public GrammarBase, public core::Components < CFG < SymbolType >, ext::set < SymbolType >, component::Set, std::tuple < TerminalAlphabet, NonterminalAlphabet >, SymbolType, component::Value, InitialSymbol > {
+template < class TerminalSymbolType = DefaultSymbolType, class NonterminalSymbolType = DefaultSymbolType >
+class CFG final : public GrammarBase, public core::Components < CFG < TerminalSymbolType, NonterminalSymbolType >, ext::set < TerminalSymbolType >, component::Set, TerminalAlphabet, ext::set < NonterminalSymbolType >, component::Set, NonterminalAlphabet, NonterminalSymbolType, component::Value, InitialSymbol > {
/**
* Rules function as mapping from nonterminal symbol on the left hand side to a set of sequences of terminal and nonterminal symbols.
*/
- ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > rules;
+ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > rules;
public:
/**
@@ -77,7 +78,7 @@ public:
*
* \param initialSymbol the initial symbol of the grammar
*/
- explicit CFG ( SymbolType initialSymbol );
+ explicit CFG ( NonterminalSymbolType initialSymbol );
/**
* \brief Creates a new instance of the grammar with a concrete nonterminal alphabet, terminal alphabet and initial symbol.
@@ -86,14 +87,14 @@ public:
* \param terminalSymbols the initial terminal alphabet
* \param initialSymbol the initial symbol of the grammar
*/
- explicit CFG ( ext::set < SymbolType > nonTerminalSymbols, ext::set < SymbolType > terminalSymbols, SymbolType initialSymbol );
+ explicit CFG ( ext::set < NonterminalSymbolType > nonTerminalSymbols, ext::set < TerminalSymbolType > terminalSymbols, NonterminalSymbolType initialSymbol );
/*
* \brief Creates a new instance of the automaton based on the Epsilon free context free grammar.
*
* \param other the Epsilon free context free grammar
*/
- explicit CFG ( const EpsilonFreeCFG < SymbolType > & other );
+ explicit CFG ( const EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & other );
/**
* @copydoc grammar::GrammarBase::clone()
@@ -115,7 +116,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, ext::vector < SymbolType > rightHandSide );
+ bool addRule ( NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
/**
* \brief Add new rules of a grammar.
@@ -125,21 +126,21 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( SymbolType leftHandSide, ext::set < ext::vector < SymbolType > > rightHandSide );
+ void addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > & getRules ( ) const &;
+ const ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & getRules ( ) const &;
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > && getRules ( ) &&;
+ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > && getRules ( ) &&;
/**
* Remove a rule of a grammar in form of A -> B, where A \in N and B \in (N \cup T)*.
@@ -149,14 +150,14 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const ext::vector < SymbolType > & rightHandSide );
+ bool removeRule ( const NonterminalSymbolType & leftHandSide, const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rightHandSide );
/**
* Getter of initial symbol.
*
* \returns the initial symbol of the grammar
*/
- const SymbolType & getInitialSymbol ( ) const & {
+ const NonterminalSymbolType & getInitialSymbol ( ) const & {
return this->template accessComponent < InitialSymbol > ( ).get ( );
}
@@ -165,7 +166,7 @@ public:
*
* \returns the initial symbol of the grammar
*/
- SymbolType && getInitialSymbol ( ) && {
+ NonterminalSymbolType && getInitialSymbol ( ) && {
return std::move ( this->template accessComponent < InitialSymbol > ( ).get ( ) );
}
@@ -176,7 +177,7 @@ public:
*
* \returns true if the initial symbol was indeed changed
*/
- bool setInitialSymbol ( SymbolType symbol ) {
+ bool setInitialSymbol ( NonterminalSymbolType symbol ) {
return this->template accessComponent < InitialSymbol > ( ).set ( std::move ( symbol ) );
}
@@ -185,7 +186,7 @@ public:
*
* \returns the nonterminal alphabet of the grammar
*/
- const ext::set < SymbolType > & getNonterminalAlphabet ( ) const & {
+ const ext::set < NonterminalSymbolType > & getNonterminalAlphabet ( ) const & {
return this->template accessComponent < NonterminalAlphabet > ( ).get ( );
}
@@ -194,7 +195,7 @@ public:
*
* \returns the nonterminal alphabet of the grammar
*/
- ext::set < SymbolType > && getNonterminalAlphabet ( ) && {
+ ext::set < NonterminalSymbolType > && getNonterminalAlphabet ( ) && {
return std::move ( this->template accessComponent < NonterminalAlphabet > ( ).get ( ) );
}
@@ -205,7 +206,7 @@ public:
*
* \returns true if the symbol was indeed added
*/
- bool addNonterminalSymbol ( SymbolType symbol ) {
+ bool addNonterminalSymbol ( NonterminalSymbolType symbol ) {
return this->template accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
}
@@ -214,7 +215,7 @@ public:
*
* \param symbols completely new nonterminal alphabet
*/
- void setNonterminalAlphabet ( ext::set < SymbolType > symbols ) {
+ void setNonterminalAlphabet ( ext::set < NonterminalSymbolType > symbols ) {
this->template accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
}
@@ -223,7 +224,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- const ext::set < SymbolType > & getTerminalAlphabet ( ) const & {
+ const ext::set < TerminalSymbolType > & getTerminalAlphabet ( ) const & {
return this->template accessComponent < TerminalAlphabet > ( ).get ( );
}
@@ -232,7 +233,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- ext::set < SymbolType > && getTerminalAlphabet ( ) && {
+ ext::set < TerminalSymbolType > && getTerminalAlphabet ( ) && {
return std::move ( this->template accessComponent < TerminalAlphabet > ( ).get ( ) );
}
@@ -243,7 +244,7 @@ public:
*
* \returns true if the symbol was indeed added
*/
- bool addTerminalSymbol ( SymbolType symbol ) {
+ bool addTerminalSymbol ( TerminalSymbolType symbol ) {
return this->template accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
}
@@ -252,7 +253,7 @@ public:
*
* \param symbol completely new nontemrinal alphabet
*/
- void setTerminalAlphabet ( ext::set < SymbolType > symbols ) {
+ void setTerminalAlphabet ( ext::set < TerminalSymbolType > symbols ) {
this->template accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
}
@@ -290,76 +291,76 @@ public:
virtual object::ObjectBase * inc ( ) && override;
};
-template < class SymbolType >
-CFG < SymbolType >::CFG ( SymbolType initialSymbol ) : CFG ( ext::set < SymbolType > { initialSymbol }, ext::set < SymbolType > ( ), initialSymbol ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+CFG < TerminalSymbolType, NonterminalSymbolType >::CFG ( NonterminalSymbolType initialSymbol ) : CFG ( ext::set < NonterminalSymbolType > { initialSymbol }, ext::set < TerminalSymbolType > ( ), initialSymbol ) {
}
-template < class SymbolType >
-CFG < SymbolType >::CFG ( ext::set < SymbolType > nonterminalAlphabet, ext::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : core::Components < CFG, ext::set < SymbolType >, component::Set, std::tuple < TerminalAlphabet, NonterminalAlphabet >, SymbolType, component::Value, InitialSymbol > ( std::move ( terminalAlphabet), std::move ( nonterminalAlphabet ), std::move ( initialSymbol ) ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+CFG < TerminalSymbolType, NonterminalSymbolType >::CFG ( ext::set < NonterminalSymbolType > nonterminalAlphabet, ext::set < TerminalSymbolType > terminalAlphabet, NonterminalSymbolType initialSymbol ) : core::Components < CFG, ext::set < TerminalSymbolType >, component::Set, TerminalAlphabet, ext::set < NonterminalSymbolType >, component::Set, NonterminalAlphabet, NonterminalSymbolType, component::Value, InitialSymbol > ( std::move ( terminalAlphabet), std::move ( nonterminalAlphabet ), std::move ( initialSymbol ) ) {
}
-template < class SymbolType >
-CFG < SymbolType >::CFG ( const EpsilonFreeCFG < SymbolType > & other ) : CFG ( other.getNonterminalAlphabet ( ), other.getTerminalAlphabet ( ), other.getInitialSymbol ( ) ) {
- for ( const std::pair < const SymbolType, ext::set < ext::vector < SymbolType > > > & rule : other.getRules ( ) ) {
- const SymbolType & lhs = rule.first;
+template < class TerminalSymbolType, class NonterminalSymbolType >
+CFG < TerminalSymbolType, NonterminalSymbolType >::CFG ( const EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & other ) : CFG ( other.getNonterminalAlphabet ( ), other.getTerminalAlphabet ( ), other.getInitialSymbol ( ) ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & rule : other.getRules ( ) ) {
+ const NonterminalSymbolType & lhs = rule.first;
- for ( const ext::vector < SymbolType > & rhs : rule.second )
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs : rule.second )
addRule ( lhs, rhs );
}
}
-template < class SymbolType >
-GrammarBase * CFG < SymbolType >::clone ( ) const & {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GrammarBase * CFG < TerminalSymbolType, NonterminalSymbolType >::clone ( ) const & {
return new CFG ( * this );
}
-template < class SymbolType >
-GrammarBase * CFG < SymbolType >::clone ( ) && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GrammarBase * CFG < TerminalSymbolType, NonterminalSymbolType >::clone ( ) && {
return new CFG ( std::move ( * this ) );
}
-template < class SymbolType >
-bool CFG < SymbolType >::addRule ( SymbolType leftHandSide, ext::vector < SymbolType > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CFG < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const SymbolType & symbol : rightHandSide )
+ for ( const ext::variant < TerminalSymbolType, NonterminalSymbolType > & symbol : rightHandSide )
if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
}
-template < class SymbolType >
-void CFG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::vector < SymbolType > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void CFG < TerminalSymbolType, NonterminalSymbolType >::addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::vector < SymbolType > & rhs : rightHandSide )
- for ( const SymbolType & symbol : rhs )
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs : rightHandSide )
+ for ( const ext::variant < TerminalSymbolType, NonterminalSymbolType > & symbol : rhs )
if ( ! getTerminalAlphabet ( ).count ( symbol ) && ! getNonterminalAlphabet ( ).count ( symbol ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
rules [ std::move ( leftHandSide ) ].insert ( ext::make_mover ( rightHandSide ).begin ( ), ext::make_mover ( rightHandSide ).end ( ) );
}
-template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > & CFG < SymbolType >::getRules ( ) const & {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+const ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & CFG < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) const & {
return rules;
}
-template < class SymbolType >
-ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > && CFG < SymbolType >::getRules ( ) && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > && CFG < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) && {
return std::move ( rules );
}
-template < class SymbolType >
-bool CFG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::vector < SymbolType > & rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CFG < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
-template < class SymbolType >
-int CFG < SymbolType >::compare ( const CFG & other ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+int CFG < TerminalSymbolType, NonterminalSymbolType >::compare ( const CFG & other ) const {
auto first = ext::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
auto second = ext::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
@@ -368,8 +369,8 @@ int CFG < SymbolType >::compare ( const CFG & other ) const {
return comp ( first, second );
}
-template < class SymbolType >
-void CFG < SymbolType >::operator >>( std::ostream & out ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void CFG < TerminalSymbolType, NonterminalSymbolType >::operator >>( std::ostream & out ) const {
out << "(CFG "
<< "nonterminalAlphabet = " << getNonterminalAlphabet ( )
<< "terminalAlphabet = " << getTerminalAlphabet ( )
@@ -377,15 +378,15 @@ void CFG < SymbolType >::operator >>( std::ostream & out ) const {
<< "rules = " << rules << ")";
}
-template < class SymbolType >
-CFG < SymbolType >::operator std::string ( ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+CFG < TerminalSymbolType, NonterminalSymbolType >::operator std::string ( ) const {
std::stringstream ss;
ss << * this;
return ss.str ( );
}
-template < class SymbolType >
-object::ObjectBase* CFG < SymbolType >::inc() && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+object::ObjectBase* CFG < TerminalSymbolType, NonterminalSymbolType >::inc() && {
return new object::UniqueObject(object::Object(std::move(*this)), primitive::Integer(0));
}
@@ -396,10 +397,11 @@ namespace core {
/**
* Helper class specifying constraints for the grammar's internal terminal alphabet component.
*
- * \tparam SymbolType used for the terminal alphabet of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class SetConstraint< grammar::CFG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class SetConstraint< grammar::CFG < TerminalSymbolType, NonterminalSymbolType >, TerminalSymbolType, grammar::TerminalAlphabet > {
public:
/**
* Returns true if the terminal symbol is still used in some rule of the grammar.
@@ -409,9 +411,9 @@ public:
*
* \returns true if the symbol is used, false othervise
*/
- static bool used ( const grammar::CFG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < ext::vector < SymbolType > > > & rule : grammar.getRules ( ) )
- for ( const ext::vector < SymbolType > & rhs : rule.second )
+ static bool used ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs : rule.second )
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
@@ -426,7 +428,7 @@ public:
*
* \returns true
*/
- static bool available ( const grammar::CFG < SymbolType > &, const SymbolType & ) {
+ static bool available ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > &, const TerminalSymbolType & ) {
return true;
}
@@ -438,7 +440,7 @@ public:
*
* \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
*/
- static void valid ( const grammar::CFG < SymbolType > & grammar, const SymbolType & symbol ) {
+ static void valid ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + ext::to_string ( symbol ) + "cannot be in terminal alphabet since it is already nonterminal alphabet" );
}
@@ -447,10 +449,11 @@ public:
/**
* Helper class specifying constraints for the grammar's internal nonterminal alphabet component.
*
- * \tparam SymbolType used for the nonterminal alphabet of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class SetConstraint< grammar::CFG < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class SetConstraint< grammar::CFG < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::NonterminalAlphabet > {
public:
/**
* Returns true if the nonterminal symbol is still used in some rule of the grammar or if it is the initial symbol of the grammar.
@@ -460,12 +463,12 @@ public:
*
* \returns true if the symbol is used, false othervise
*/
- static bool used ( const grammar::CFG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < ext::vector < SymbolType > > > & rule : grammar.getRules ( ) ) {
+ static bool used ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::vector < SymbolType > & rhs : rule.second )
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs : rule.second )
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
@@ -485,7 +488,7 @@ public:
*
* \returns true
*/
- static bool available ( const grammar::CFG < SymbolType > &, const SymbolType & ) {
+ static bool available ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > &, const NonterminalSymbolType & ) {
return true;
}
@@ -497,7 +500,7 @@ public:
*
* \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
*/
- static void valid ( const grammar::CFG < SymbolType > & grammar, const SymbolType & symbol ) {
+ static void valid ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + ext::to_string ( symbol ) + "cannot be in nonterminal alphabet since it is already in terminal alphabet" );
}
@@ -506,10 +509,11 @@ public:
/**
* Helper class specifying constraints for the grammar's internal initial symbol element.
*
- * \tparam SymbolType used for the initial symbol of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class ElementConstraint< grammar::CFG < SymbolType >, SymbolType, grammar::InitialSymbol > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class ElementConstraint< grammar::CFG < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::InitialSymbol > {
public:
/**
* Returns true if the symbol requested to be initial is available in nonterminal alphabet.
@@ -519,7 +523,7 @@ public:
*
* \returns true if the tested symbol is in nonterminal alphabet
*/
- static bool available ( const grammar::CFG < SymbolType > & grammar, const SymbolType & symbol ) {
+ static bool available ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
}
@@ -529,7 +533,7 @@ public:
* \param grammar the tested grammar
* \param symbol the tested symbol
*/
- static void valid ( const grammar::CFG < SymbolType > &, const SymbolType & ) {
+ static void valid ( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > &, const NonterminalSymbolType & ) {
}
};
@@ -538,20 +542,20 @@ public:
*
* \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
*/
-template < class SymbolType >
-struct normalize < grammar::CFG < SymbolType > > {
- static grammar::CFG < > eval ( grammar::CFG < SymbolType > && value ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct normalize < grammar::CFG < TerminalSymbolType, NonterminalSymbolType > > {
+ static grammar::CFG < > eval ( grammar::CFG < TerminalSymbolType, NonterminalSymbolType > && value ) {
ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
DefaultSymbolType initialSymbol = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getInitialSymbol ( ) );
grammar::CFG < > res ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::vector < SymbolType > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
+ for ( std::pair < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
- ext::set < ext::vector < DefaultSymbolType > > rhs;
- for ( ext::vector < SymbolType > && target : ext::make_mover ( rule.second ) )
- rhs.insert ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( target ) ) );
+ ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > rhs;
+ for ( ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > && target : ext::make_mover ( rule.second ) )
+ rhs.insert ( alphabet::SymbolNormalize::normalizeVariantSymbols ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
diff --git a/alib2data/src/grammar/ContextFree/CNF.h b/alib2data/src/grammar/ContextFree/CNF.h
index 2c23c845e1..0d80692849 100644
--- a/alib2data/src/grammar/ContextFree/CNF.h
+++ b/alib2data/src/grammar/ContextFree/CNF.h
@@ -61,14 +61,15 @@ class InitialSymbol;
* P = set of production rules of the form A -> BC or A -> a, where A, B, C \in N and a \in T,
* S (InitialSymbol) = initial nonterminal symbol,
*
- * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType = DefaultSymbolType >
-class CNF final : public GrammarBase, public core::Components < CNF < SymbolType >, ext::set < SymbolType >, component::Set, std::tuple < TerminalAlphabet, NonterminalAlphabet >, SymbolType, component::Value, InitialSymbol > {
+template < class TerminalSymbolType = DefaultSymbolType, class NonterminalSymbolType = DefaultSymbolType >
+class CNF final : public GrammarBase, public core::Components < CNF < TerminalSymbolType, NonterminalSymbolType >, ext::set < TerminalSymbolType >, component::Set, TerminalAlphabet, ext::set < NonterminalSymbolType >, component::Set, NonterminalAlphabet, NonterminalSymbolType, component::Value, InitialSymbol > {
/**
* Rules function as mapping from nonterminal symbol on the left hand side to a set of sequences of terminal and nonterminal symbols.
*/
- ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > rules;
+ ext::map < NonterminalSymbolType, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > > rules;
/**
* Boolean signaling whether grammar generates empty string or don't.
@@ -81,7 +82,7 @@ public:
*
* \param initialSymbol the initial symbol of the grammar
*/
- explicit CNF ( SymbolType initialSymbol );
+ explicit CNF ( NonterminalSymbolType initialSymbol );
/**
* \brief Creates a new instance of the grammar with a concrete nonterminal alphabet, terminal alphabet and initial symbol.
@@ -90,7 +91,7 @@ public:
* \param terminalSymbols the initial terminal alphabet
* \param initialSymbol the initial symbol of the grammar
*/
- explicit CNF ( ext::set < SymbolType > nonTerminalSymbols, ext::set < SymbolType > terminalSymbols, SymbolType initialSymbol );
+ explicit CNF ( ext::set < NonterminalSymbolType > nonTerminalSymbols, ext::set < TerminalSymbolType > terminalSymbols, NonterminalSymbolType initialSymbol );
/**
* @copydoc grammar::GrammarBase::clone()
@@ -112,7 +113,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rightHandSide );
+ bool addRule ( NonterminalSymbolType leftHandSide, ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -124,7 +125,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, SymbolType rightHandSide );
+ bool addRule ( NonterminalSymbolType leftHandSide, TerminalSymbolType rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -136,7 +137,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, ext::pair < SymbolType, SymbolType > rightHandSide );
+ bool addRule ( NonterminalSymbolType leftHandSide, ext::pair < NonterminalSymbolType, NonterminalSymbolType > rightHandSide );
/**
* \brief Add new rules of a grammar.
@@ -146,21 +147,21 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > rightHandSide );
+ void addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & getRules ( ) const &;
+ const ext::map < NonterminalSymbolType, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > > & getRules ( ) const &;
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > && getRules ( ) &&;
+ ext::map < NonterminalSymbolType, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > > && getRules ( ) &&;
/**
* Remove a rule of a grammar in form of A -> BC or A -> a, where A, B, C \in N and a \in T.
@@ -170,7 +171,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rightHandSide );
+ bool removeRule ( const NonterminalSymbolType & leftHandSide, const ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T.
@@ -180,7 +181,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide );
+ bool removeRule ( const NonterminalSymbolType & leftHandSide, const TerminalSymbolType & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> BC, where A, B, C.
@@ -190,14 +191,14 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, SymbolType > & rightHandSide );
+ bool removeRule ( const NonterminalSymbolType & leftHandSide, const ext::pair < NonterminalSymbolType, NonterminalSymbolType > & rightHandSide );
/**
* Getter of initial symbol.
*
* \returns the initial symbol of the grammar
*/
- const SymbolType & getInitialSymbol ( ) const & {
+ const NonterminalSymbolType & getInitialSymbol ( ) const & {
return this->template accessComponent < InitialSymbol > ( ).get ( );
}
@@ -206,7 +207,7 @@ public:
*
* \returns the initial symbol of the grammar
*/
- SymbolType && getInitialSymbol ( ) && {
+ NonterminalSymbolType && getInitialSymbol ( ) && {
return std::move ( this->template accessComponent < InitialSymbol > ( ).get ( ) );
}
@@ -217,7 +218,7 @@ public:
*
* \returns true if the initial symbol was indeed changed
*/
- bool setInitialSymbol ( SymbolType symbol ) {
+ bool setInitialSymbol ( NonterminalSymbolType symbol ) {
return this->template accessComponent < InitialSymbol > ( ).set ( std::move ( symbol ) );
}
@@ -226,7 +227,7 @@ public:
*
* \returns the nonterminal alphabet of the grammar
*/
- const ext::set < SymbolType > & getNonterminalAlphabet ( ) const & {
+ const ext::set < NonterminalSymbolType > & getNonterminalAlphabet ( ) const & {
return this->template accessComponent < NonterminalAlphabet > ( ).get ( );
}
@@ -235,7 +236,7 @@ public:
*
* \returns the nonterminal alphabet of the grammar
*/
- ext::set < SymbolType > && getNonterminalAlphabet ( ) && {
+ ext::set < NonterminalSymbolType > && getNonterminalAlphabet ( ) && {
return std::move ( this->template accessComponent < NonterminalAlphabet > ( ).get ( ) );
}
@@ -246,7 +247,7 @@ public:
*
* \returns true if the symbol was indeed added
*/
- bool addNonterminalSymbol ( SymbolType symbol ) {
+ bool addNonterminalSymbol ( NonterminalSymbolType symbol ) {
return this->template accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
}
@@ -255,7 +256,7 @@ public:
*
* \param symbols completely new nonterminal alphabet
*/
- void setNonterminalAlphabet ( ext::set < SymbolType > symbols ) {
+ void setNonterminalAlphabet ( ext::set < NonterminalSymbolType > symbols ) {
this->template accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
}
@@ -264,7 +265,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- const ext::set < SymbolType > & getTerminalAlphabet ( ) const & {
+ const ext::set < TerminalSymbolType > & getTerminalAlphabet ( ) const & {
return this->template accessComponent < TerminalAlphabet > ( ).get ( );
}
@@ -273,7 +274,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- ext::set < SymbolType > && getTerminalAlphabet ( ) && {
+ ext::set < TerminalSymbolType > && getTerminalAlphabet ( ) && {
return std::move ( this->template accessComponent < TerminalAlphabet > ( ).get ( ) );
}
@@ -284,7 +285,7 @@ public:
*
* \returns true if the symbol was indeed added
*/
- bool addTerminalSymbol ( SymbolType symbol ) {
+ bool addTerminalSymbol ( TerminalSymbolType symbol ) {
return this->template accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
}
@@ -293,7 +294,7 @@ public:
*
* \param symbol completely new nontemrinal alphabet
*/
- void setTerminalAlphabet ( ext::set < SymbolType > symbols ) {
+ void setTerminalAlphabet ( ext::set < TerminalSymbolType > symbols ) {
this->template accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
}
@@ -345,34 +346,34 @@ public:
virtual object::ObjectBase * inc ( ) && override;
};
-template < class SymbolType >
-CNF < SymbolType >::CNF ( SymbolType initialSymbol ) : CNF ( ext::set < SymbolType > { initialSymbol }, ext::set < SymbolType > ( ), initialSymbol ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+CNF < TerminalSymbolType, NonterminalSymbolType >::CNF ( NonterminalSymbolType initialSymbol ) : CNF ( ext::set < NonterminalSymbolType > { initialSymbol }, ext::set < TerminalSymbolType > ( ), initialSymbol ) {
}
-template < class SymbolType >
-CNF < SymbolType >::CNF ( ext::set < SymbolType > nonterminalAlphabet, ext::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : core::Components < CNF, ext::set < SymbolType >, component::Set, std::tuple < TerminalAlphabet, NonterminalAlphabet >, SymbolType, component::Value, InitialSymbol > ( std::move ( terminalAlphabet), std::move ( nonterminalAlphabet ), std::move ( initialSymbol ) ), generatesEpsilon ( false ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+CNF < TerminalSymbolType, NonterminalSymbolType >::CNF ( ext::set < NonterminalSymbolType > nonterminalAlphabet, ext::set < TerminalSymbolType > terminalAlphabet, NonterminalSymbolType initialSymbol ) : core::Components < CNF, ext::set < TerminalSymbolType >, component::Set, TerminalAlphabet, ext::set < NonterminalSymbolType >, component::Set, NonterminalAlphabet, NonterminalSymbolType, component::Value, InitialSymbol > ( std::move ( terminalAlphabet), std::move ( nonterminalAlphabet ), std::move ( initialSymbol ) ), generatesEpsilon ( false ) {
}
-template < class SymbolType >
-GrammarBase * CNF < SymbolType >::clone ( ) const & {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GrammarBase * CNF < TerminalSymbolType, NonterminalSymbolType >::clone ( ) const & {
return new CNF ( * this );
}
-template < class SymbolType >
-GrammarBase * CNF < SymbolType >::clone ( ) && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GrammarBase * CNF < TerminalSymbolType, NonterminalSymbolType >::clone ( ) && {
return new CNF ( std::move ( * this ) );
}
-template < class SymbolType >
-bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CNF < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- if ( rightHandSide.template is < SymbolType > ( ) ) {
- if ( !getTerminalAlphabet ( ).count ( rightHandSide.template get < SymbolType > ( ) ) )
+ if ( rightHandSide.template is < TerminalSymbolType > ( ) ) {
+ if ( !getTerminalAlphabet ( ).count ( rightHandSide.template get < TerminalSymbolType > ( ) ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
} else {
- const ext::pair < SymbolType, SymbolType > rhs = rightHandSide.template get < ext::pair < SymbolType, SymbolType > > ( );
+ const ext::pair < NonterminalSymbolType, NonterminalSymbolType > rhs = rightHandSide.template get < ext::pair < NonterminalSymbolType, NonterminalSymbolType > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.first ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( rhs.first ) + "\" is not a nonterminal symbol" );
@@ -384,31 +385,31 @@ bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::variant < Symbo
return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
}
-template < class SymbolType >
-bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, SymbolType rightHandSide ) {
- ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CNF < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, TerminalSymbolType rightHandSide ) {
+ ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
-template < class SymbolType >
-bool CNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::pair < SymbolType, SymbolType > rightHandSide ) {
- ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( std::move ( rightHandSide ) );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CNF < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::pair < NonterminalSymbolType, NonterminalSymbolType > rightHandSide ) {
+ ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
-template < class SymbolType >
-void CNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void CNF < TerminalSymbolType, NonterminalSymbolType >::addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & element : rightHandSide ) {
- if ( element.template is < SymbolType > ( ) ) {
- if ( !getTerminalAlphabet ( ).count ( element.template get < SymbolType > ( ) ) )
+ for ( const ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > & element : rightHandSide ) {
+ if ( element.template is < TerminalSymbolType > ( ) ) {
+ if ( !getTerminalAlphabet ( ).count ( element.template get < TerminalSymbolType > ( ) ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
} else {
- const ext::pair < SymbolType, SymbolType > rhs = element.template get < ext::pair < SymbolType, SymbolType > > ( );
+ const ext::pair < NonterminalSymbolType, NonterminalSymbolType > rhs = element.template get < ext::pair < NonterminalSymbolType, NonterminalSymbolType > > ( );
if ( !getNonterminalAlphabet ( ).count ( rhs.first ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( rhs.first ) + "\" is not a nonterminal symbol" );
@@ -421,47 +422,47 @@ void CNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::var
rules[std::move ( leftHandSide )].insert ( ext::make_mover ( rightHandSide ).begin ( ), ext::make_mover ( rightHandSide ).end ( ) );
}
-template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & CNF < SymbolType >::getRules ( ) const & {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+const ext::map < NonterminalSymbolType, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > > & CNF < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) const & {
return rules;
}
-template < class SymbolType >
-ext::map < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > && CNF < SymbolType >::getRules ( ) && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+ext::map < NonterminalSymbolType, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > > && CNF < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) && {
return std::move ( rules );
}
-template < class SymbolType >
-bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CNF < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
-template < class SymbolType >
-bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const SymbolType & rightHandSide ) {
- ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CNF < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const TerminalSymbolType & rightHandSide ) {
+ ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
-template < class SymbolType >
-bool CNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, SymbolType > & rightHandSide ) {
- ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs ( rightHandSide );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CNF < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::pair < NonterminalSymbolType, NonterminalSymbolType > & rightHandSide ) {
+ ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
-template < class SymbolType >
-void CNF < SymbolType >::setGeneratesEpsilon ( bool genEps ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void CNF < TerminalSymbolType, NonterminalSymbolType >::setGeneratesEpsilon ( bool genEps ) {
generatesEpsilon = genEps;
}
-template < class SymbolType >
-bool CNF < SymbolType >::getGeneratesEpsilon ( ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool CNF < TerminalSymbolType, NonterminalSymbolType >::getGeneratesEpsilon ( ) const {
return generatesEpsilon;
}
-template < class SymbolType >
-int CNF < SymbolType >::compare ( const CNF & other ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+int CNF < TerminalSymbolType, NonterminalSymbolType >::compare ( const CNF & other ) const {
auto first = ext::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
auto second = ext::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
@@ -470,8 +471,8 @@ int CNF < SymbolType >::compare ( const CNF & other ) const {
return comp ( first, second );
}
-template < class SymbolType >
-void CNF < SymbolType >::operator >>( std::ostream & out ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void CNF < TerminalSymbolType, NonterminalSymbolType >::operator >>( std::ostream & out ) const {
out << "(CNF "
<< "nonterminalAlphabet = " << getNonterminalAlphabet ( )
<< "terminalAlphabet = " << getTerminalAlphabet ( )
@@ -480,15 +481,15 @@ void CNF < SymbolType >::operator >>( std::ostream & out ) const {
<< "generatesEpsilon = " << generatesEpsilon << ")";
}
-template < class SymbolType >
-CNF < SymbolType >::operator std::string ( ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+CNF < TerminalSymbolType, NonterminalSymbolType >::operator std::string ( ) const {
std::stringstream ss;
ss << * this;
return ss.str ( );
}
-template < class SymbolType >
-object::ObjectBase* CNF < SymbolType >::inc() && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+object::ObjectBase* CNF < TerminalSymbolType, NonterminalSymbolType >::inc() && {
return new object::UniqueObject(object::Object(std::move(*this)), primitive::Integer(0));
}
@@ -499,10 +500,11 @@ namespace core {
/**
* Helper class specifying constraints for the grammar's internal terminal alphabet component.
*
- * \tparam SymbolType used for the terminal alphabet of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class SetConstraint< grammar::CNF < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class SetConstraint< grammar::CNF < TerminalSymbolType, NonterminalSymbolType >, TerminalSymbolType, grammar::TerminalAlphabet > {
public:
/**
* Returns true if the terminal symbol is still used in some rule of the grammar.
@@ -512,10 +514,10 @@ public:
*
* \returns true if the symbol is used, false othervise
*/
- static bool used ( const grammar::CNF < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) )
- for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second )
- if ( ( rhs.template is < SymbolType > ( ) && ( rhs.template get < SymbolType > ( ) == symbol ) ) )
+ static bool used ( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > & rhs : rule.second )
+ if ( ( rhs.template is < TerminalSymbolType > ( ) && ( rhs.template get < TerminalSymbolType > ( ) == symbol ) ) )
return true;
return false;
@@ -529,7 +531,7 @@ public:
*
* \returns true
*/
- static bool available ( const grammar::CNF < SymbolType > &, const SymbolType & ) {
+ static bool available ( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > &, const TerminalSymbolType & ) {
return true;
}
@@ -541,7 +543,7 @@ public:
*
* \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
*/
- static void valid ( const grammar::CNF < SymbolType > & grammar, const SymbolType & symbol ) {
+ static void valid ( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + ext::to_string ( symbol ) + "cannot be in terminal alphabet since it is already nonterminal alphabet" );
}
@@ -550,10 +552,11 @@ public:
/**
* Helper class specifying constraints for the grammar's internal nonterminal alphabet component.
*
- * \tparam SymbolType used for the nonterminal alphabet of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class SetConstraint< grammar::CNF < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class SetConstraint< grammar::CNF < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::NonterminalAlphabet > {
public:
/**
* Returns true if the nonterminal symbol is still used in some rule of the grammar or if it is the initial symbol of the grammar.
@@ -563,16 +566,16 @@ public:
*
* \returns true if the symbol is used, false othervise
*/
- static bool used ( const grammar::CNF < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ static bool used ( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > & rhs : rule.second ) {
- if ( rhs.template is < SymbolType > ( ) )
+ for ( const ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > & rhs : rule.second ) {
+ if ( rhs.template is < TerminalSymbolType > ( ) )
continue;
- if ( rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).first == symbol || rhs.template get < ext::pair < SymbolType, SymbolType > > ( ).second == symbol )
+ if ( rhs.template get < ext::pair < NonterminalSymbolType, NonterminalSymbolType > > ( ).first == symbol || rhs.template get < ext::pair < NonterminalSymbolType, NonterminalSymbolType > > ( ).second == symbol )
return true;
}
@@ -592,7 +595,7 @@ public:
*
* \returns true
*/
- static bool available ( const grammar::CNF < SymbolType > &, const SymbolType & ) {
+ static bool available ( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > &, const NonterminalSymbolType & ) {
return true;
}
@@ -604,7 +607,7 @@ public:
*
* \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
*/
- static void valid ( const grammar::CNF < SymbolType > & grammar, const SymbolType & symbol ) {
+ static void valid ( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + ext::to_string ( symbol ) + "cannot be in nonterminal alphabet since it is already in terminal alphabet" );
}
@@ -613,10 +616,11 @@ public:
/**
* Helper class specifying constraints for the grammar's internal initial symbol element.
*
- * \tparam SymbolType used for the initial symbol of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class ElementConstraint< grammar::CNF < SymbolType >, SymbolType, grammar::InitialSymbol > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class ElementConstraint< grammar::CNF < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::InitialSymbol > {
public:
/**
* Returns true if the symbol requested to be initial is available in nonterminal alphabet.
@@ -626,7 +630,7 @@ public:
*
* \returns true if the tested symbol is in nonterminal alphabet
*/
- static bool available ( const grammar::CNF < SymbolType > & grammar, const SymbolType & symbol ) {
+ static bool available ( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
}
@@ -636,7 +640,7 @@ public:
* \param grammar the tested grammar
* \param symbol the tested symbol
*/
- static void valid ( const grammar::CNF < SymbolType > &, const SymbolType & ) {
+ static void valid ( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > &, const NonterminalSymbolType & ) {
}
};
@@ -645,19 +649,19 @@ public:
*
* \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
*/
-template < class SymbolType >
-struct normalize < grammar::CNF < SymbolType > > {
- static grammar::CNF < > eval ( grammar::CNF < SymbolType > && value ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct normalize < grammar::CNF < TerminalSymbolType, NonterminalSymbolType > > {
+ static grammar::CNF < > eval ( grammar::CNF < TerminalSymbolType, NonterminalSymbolType > && value ) {
ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
DefaultSymbolType initialSymbol = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getInitialSymbol ( ) );
grammar::CNF < > res ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
+ for ( std::pair < NonterminalSymbolType, ext::set < ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
ext::set < ext::variant < DefaultSymbolType, ext::pair < DefaultSymbolType, DefaultSymbolType > > > rhs;
- for ( ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > && target : ext::make_mover ( rule.second ) )
+ for ( ext::variant < TerminalSymbolType, ext::pair < NonterminalSymbolType, NonterminalSymbolType > > && target : ext::make_mover ( rule.second ) )
rhs.insert ( grammar::GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
diff --git a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
index 6e4e36ae9b..91a33f2bc1 100644
--- a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
+++ b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
@@ -60,14 +60,15 @@ class InitialSymbol;
* P = set of production rules of the form A -> B, where A \in N and B \in ( N \cup T )+,
* S (InitialSymbol) = initial nonterminal symbol,
*
- * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType = DefaultSymbolType >
-class EpsilonFreeCFG final : public GrammarBase, public core::Components < EpsilonFreeCFG < SymbolType >, ext::set < SymbolType >, component::Set, std::tuple < TerminalAlphabet, NonterminalAlphabet >, SymbolType, component::Value, InitialSymbol > {
+template < class TerminalSymbolType = DefaultSymbolType, class NonterminalSymbolType = DefaultSymbolType >
+class EpsilonFreeCFG final : public GrammarBase, public core::Components < EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >, ext::set < TerminalSymbolType >, component::Set, TerminalAlphabet, ext::set < NonterminalSymbolType >, component::Set, NonterminalAlphabet, NonterminalSymbolType, component::Value, InitialSymbol > {
/**
* Rules function as mapping from nonterminal symbol on the left hand side to a set of sequences of terminal and nonterminal symbols.
*/
- ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > rules;
+ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > rules;
/**
* Boolean signaling whether grammar generates empty string or don't.
@@ -80,7 +81,7 @@ public:
*
* \param initialSymbol the initial symbol of the grammar
*/
- explicit EpsilonFreeCFG ( SymbolType initialSymbol );
+ explicit EpsilonFreeCFG ( NonterminalSymbolType initialSymbol );
/**
* \brief Creates a new instance of the grammar with a concrete nonterminal alphabet, terminal alphabet and initial symbol.
@@ -89,7 +90,7 @@ public:
* \param terminalSymbols the initial terminal alphabet
* \param initialSymbol the initial symbol of the grammar
*/
- explicit EpsilonFreeCFG ( ext::set < SymbolType > nonTerminalSymbols, ext::set < SymbolType > terminalSymbols, SymbolType initialSymbol );
+ explicit EpsilonFreeCFG ( ext::set < NonterminalSymbolType > nonTerminalSymbols, ext::set < TerminalSymbolType > terminalSymbols, NonterminalSymbolType initialSymbol );
/**
* @copydoc grammar::GrammarBase::clone()
@@ -111,7 +112,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, ext::vector < SymbolType > rightHandSide );
+ bool addRule ( NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide );
/**
* \brief Add new rules of a grammar.
@@ -121,21 +122,21 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( SymbolType leftHandSide, ext::set < ext::vector < SymbolType > > rightHandSide );
+ void addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > & getRules ( ) const &;
+ const ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & getRules ( ) const &;
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > && getRules ( ) &&;
+ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > && getRules ( ) &&;
/**
* Remove a rule of a grammar in form of A -> B, where A \in N and B \in (N \cup T)+.
@@ -145,14 +146,14 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const ext::vector < SymbolType > & rightHandSide );
+ bool removeRule ( const NonterminalSymbolType & leftHandSide, const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rightHandSide );
/**
* Getter of initial symbol.
*
* \returns the initial symbol of the grammar
*/
- const SymbolType & getInitialSymbol ( ) const & {
+ const NonterminalSymbolType & getInitialSymbol ( ) const & {
return this->template accessComponent < InitialSymbol > ( ).get ( );
}
@@ -161,7 +162,7 @@ public:
*
* \returns the initial symbol of the grammar
*/
- SymbolType && getInitialSymbol ( ) && {
+ NonterminalSymbolType && getInitialSymbol ( ) && {
return std::move ( this->template accessComponent < InitialSymbol > ( ).get ( ) );
}
@@ -172,7 +173,7 @@ public:
*
* \returns true if the initial symbol was indeed changed
*/
- bool setInitialSymbol ( SymbolType symbol ) {
+ bool setInitialSymbol ( NonterminalSymbolType symbol ) {
return this->template accessComponent < InitialSymbol > ( ).set ( std::move ( symbol ) );
}
@@ -181,7 +182,7 @@ public:
*
* \returns the nonterminal alphabet of the grammar
*/
- const ext::set < SymbolType > & getNonterminalAlphabet ( ) const & {
+ const ext::set < NonterminalSymbolType > & getNonterminalAlphabet ( ) const & {
return this->template accessComponent < NonterminalAlphabet > ( ).get ( );
}
@@ -190,7 +191,7 @@ public:
*
* \returns the nonterminal alphabet of the grammar
*/
- ext::set < SymbolType > && getNonterminalAlphabet ( ) && {
+ ext::set < NonterminalSymbolType > && getNonterminalAlphabet ( ) && {
return std::move ( this->template accessComponent < NonterminalAlphabet > ( ).get ( ) );
}
@@ -201,7 +202,7 @@ public:
*
* \returns true if the symbol was indeed added
*/
- bool addNonterminalSymbol ( SymbolType symbol ) {
+ bool addNonterminalSymbol ( NonterminalSymbolType symbol ) {
return this->template accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
}
@@ -210,7 +211,7 @@ public:
*
* \param symbols completely new nonterminal alphabet
*/
- void setNonterminalAlphabet ( ext::set < SymbolType > symbols ) {
+ void setNonterminalAlphabet ( ext::set < NonterminalSymbolType > symbols ) {
this->template accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
}
@@ -219,7 +220,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- const ext::set < SymbolType > & getTerminalAlphabet ( ) const & {
+ const ext::set < TerminalSymbolType > & getTerminalAlphabet ( ) const & {
return this->template accessComponent < TerminalAlphabet > ( ).get ( );
}
@@ -228,7 +229,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- ext::set < SymbolType > && getTerminalAlphabet ( ) && {
+ ext::set < TerminalSymbolType > && getTerminalAlphabet ( ) && {
return std::move ( this->template accessComponent < TerminalAlphabet > ( ).get ( ) );
}
@@ -239,7 +240,7 @@ public:
*
* \returns true if the symbol was indeed added
*/
- bool addTerminalSymbol ( SymbolType symbol ) {
+ bool addTerminalSymbol ( TerminalSymbolType symbol ) {
return this->template accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
}
@@ -248,7 +249,7 @@ public:
*
* \param symbol completely new nontemrinal alphabet
*/
- void setTerminalAlphabet ( ext::set < SymbolType > symbols ) {
+ void setTerminalAlphabet ( ext::set < TerminalSymbolType > symbols ) {
this->template accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
}
@@ -300,49 +301,49 @@ public:
virtual object::ObjectBase * inc ( ) && override;
};
-template < class SymbolType >
-EpsilonFreeCFG < SymbolType >::EpsilonFreeCFG ( SymbolType initialSymbol ) : EpsilonFreeCFG ( ext::set < SymbolType > { initialSymbol }, ext::set < SymbolType > ( ), initialSymbol ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::EpsilonFreeCFG ( NonterminalSymbolType initialSymbol ) : EpsilonFreeCFG ( ext::set < NonterminalSymbolType > { initialSymbol }, ext::set < TerminalSymbolType > ( ), initialSymbol ) {
}
-template < class SymbolType >
-EpsilonFreeCFG < SymbolType >::EpsilonFreeCFG ( ext::set < SymbolType > nonterminalAlphabet, ext::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : core::Components < EpsilonFreeCFG, ext::set < SymbolType >, component::Set, std::tuple < TerminalAlphabet, NonterminalAlphabet >, SymbolType, component::Value, InitialSymbol > ( std::move ( terminalAlphabet), std::move ( nonterminalAlphabet ), std::move ( initialSymbol ) ), generatesEpsilon ( false ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::EpsilonFreeCFG ( ext::set < NonterminalSymbolType > nonterminalAlphabet, ext::set < TerminalSymbolType > terminalAlphabet, NonterminalSymbolType initialSymbol ) : core::Components < EpsilonFreeCFG, ext::set < TerminalSymbolType >, component::Set, TerminalAlphabet, ext::set < NonterminalSymbolType >, component::Set, NonterminalAlphabet, NonterminalSymbolType, component::Value, InitialSymbol > ( std::move ( terminalAlphabet), std::move ( nonterminalAlphabet ), std::move ( initialSymbol ) ), generatesEpsilon ( false ) {
}
-template < class SymbolType >
-GrammarBase * EpsilonFreeCFG < SymbolType >::clone ( ) const & {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GrammarBase * EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::clone ( ) const & {
return new EpsilonFreeCFG ( * this );
}
-template < class SymbolType >
-GrammarBase * EpsilonFreeCFG < SymbolType >::clone ( ) && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GrammarBase * EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::clone ( ) && {
return new EpsilonFreeCFG ( std::move ( * this ) );
}
-template < class SymbolType >
-bool EpsilonFreeCFG < SymbolType >::addRule ( SymbolType leftHandSide, ext::vector < SymbolType > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rightHandSide ) {
if ( rightHandSide.size ( ) == 0 )
throw GrammarException ( "Epsilon rule is not allowed" );
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const SymbolType & symbol : rightHandSide )
+ for ( const ext::variant < TerminalSymbolType, NonterminalSymbolType > & symbol : rightHandSide )
if ( !getTerminalAlphabet ( ).count ( symbol ) && !getNonterminalAlphabet ( ).count ( symbol ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
}
-template < class SymbolType >
-void EpsilonFreeCFG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::vector < SymbolType > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::vector < SymbolType > & rhs : rightHandSide ) {
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs : rightHandSide ) {
if ( rhs.size ( ) == 0 )
throw GrammarException ( "Epsilon rule is not allowed" );
- for ( const SymbolType & symbol : rhs )
+ for ( const ext::variant < TerminalSymbolType, NonterminalSymbolType > & symbol : rhs )
if ( ! getTerminalAlphabet ( ).count ( symbol ) && ! getNonterminalAlphabet ( ).count ( symbol ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( symbol ) + "\" is not neither terminal nor nonterminal symbol" );
}
@@ -350,33 +351,33 @@ void EpsilonFreeCFG < SymbolType >::addRules ( SymbolType leftHandSide, ext::set
rules [ std::move ( leftHandSide ) ].insert ( ext::make_mover ( rightHandSide ).begin ( ), ext::make_mover ( rightHandSide ).end ( ) );
}
-template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > & EpsilonFreeCFG < SymbolType >::getRules ( ) const & {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+const ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) const & {
return rules;
}
-template < class SymbolType >
-ext::map < SymbolType, ext::set < ext::vector < SymbolType > > > && EpsilonFreeCFG < SymbolType >::getRules ( ) && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > && EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) && {
return std::move ( rules );
}
-template < class SymbolType >
-bool EpsilonFreeCFG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::vector < SymbolType > & rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
-template < class SymbolType >
-void EpsilonFreeCFG < SymbolType >::setGeneratesEpsilon ( bool genEps ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::setGeneratesEpsilon ( bool genEps ) {
generatesEpsilon = genEps;
}
-template < class SymbolType >
-bool EpsilonFreeCFG < SymbolType >::getGeneratesEpsilon ( ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::getGeneratesEpsilon ( ) const {
return generatesEpsilon;
}
-template < class SymbolType >
-int EpsilonFreeCFG < SymbolType >::compare ( const EpsilonFreeCFG & other ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+int EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::compare ( const EpsilonFreeCFG & other ) const {
auto first = ext::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
auto second = ext::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
@@ -385,8 +386,8 @@ int EpsilonFreeCFG < SymbolType >::compare ( const EpsilonFreeCFG & other ) cons
return comp ( first, second );
}
-template < class SymbolType >
-void EpsilonFreeCFG < SymbolType >::operator >>( std::ostream & out ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::operator >>( std::ostream & out ) const {
out << "(EpsilonFreeCFG "
<< "nonterminalAlphabet = " << getNonterminalAlphabet ( )
<< "terminalAlphabet = " << getTerminalAlphabet ( )
@@ -395,15 +396,15 @@ void EpsilonFreeCFG < SymbolType >::operator >>( std::ostream & out ) const {
<< "generatesEpsilon = " << generatesEpsilon << ")";
}
-template < class SymbolType >
-EpsilonFreeCFG < SymbolType >::operator std::string ( ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::operator std::string ( ) const {
std::stringstream ss;
ss << * this;
return ss.str ( );
}
-template < class SymbolType >
-object::ObjectBase* EpsilonFreeCFG < SymbolType >::inc() && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+object::ObjectBase* EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >::inc() && {
return new object::UniqueObject(object::Object(std::move(*this)), primitive::Integer(0));
}
@@ -414,10 +415,11 @@ namespace core {
/**
* Helper class specifying constraints for the grammar's internal terminal alphabet component.
*
- * \tparam SymbolType used for the terminal alphabet of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class SetConstraint< grammar::EpsilonFreeCFG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class SetConstraint< grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >, TerminalSymbolType, grammar::TerminalAlphabet > {
public:
/**
* Returns true if the terminal symbol is still used in some rule of the grammar.
@@ -427,9 +429,9 @@ public:
*
* \returns true if the symbol is used, false othervise
*/
- static bool used ( const grammar::EpsilonFreeCFG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < ext::vector < SymbolType > > > & rule : grammar.getRules ( ) )
- for ( const ext::vector < SymbolType > & rhs : rule.second )
+ static bool used ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs : rule.second )
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
@@ -444,7 +446,7 @@ public:
*
* \returns true
*/
- static bool available ( const grammar::EpsilonFreeCFG < SymbolType > &, const SymbolType & ) {
+ static bool available ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > &, const TerminalSymbolType & ) {
return true;
}
@@ -456,7 +458,7 @@ public:
*
* \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
*/
- static void valid ( const grammar::EpsilonFreeCFG < SymbolType > & grammar, const SymbolType & symbol ) {
+ static void valid ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + ext::to_string ( symbol ) + "cannot be in terminal alphabet since it is already nonterminal alphabet" );
}
@@ -465,10 +467,11 @@ public:
/**
* Helper class specifying constraints for the grammar's internal nonterminal alphabet component.
*
- * \tparam SymbolType used for the nonterminal alphabet of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class SetConstraint< grammar::EpsilonFreeCFG < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class SetConstraint< grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::NonterminalAlphabet > {
public:
/**
* Returns true if the nonterminal symbol is still used in some rule of the grammar or if it is the initial symbol of the grammar.
@@ -478,12 +481,12 @@ public:
*
* \returns true if the symbol is used, false othervise
*/
- static bool used ( const grammar::EpsilonFreeCFG < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < ext::vector < SymbolType > > > & rule : grammar.getRules ( ) ) {
+ static bool used ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::vector < SymbolType > & rhs : rule.second )
+ for ( const ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > & rhs : rule.second )
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
@@ -503,7 +506,7 @@ public:
*
* \returns true
*/
- static bool available ( const grammar::EpsilonFreeCFG < SymbolType > &, const SymbolType & ) {
+ static bool available ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > &, const NonterminalSymbolType & ) {
return true;
}
@@ -515,7 +518,7 @@ public:
*
* \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
*/
- static void valid ( const grammar::EpsilonFreeCFG < SymbolType > & grammar, const SymbolType & symbol ) {
+ static void valid ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + ext::to_string ( symbol ) + "cannot be in nonterminal alphabet since it is already in terminal alphabet" );
}
@@ -524,10 +527,11 @@ public:
/**
* Helper class specifying constraints for the grammar's internal initial symbol element.
*
- * \tparam SymbolType used for the initial symbol of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class ElementConstraint< grammar::EpsilonFreeCFG < SymbolType >, SymbolType, grammar::InitialSymbol > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class ElementConstraint< grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::InitialSymbol > {
public:
/**
* Returns true if the symbol requested to be initial is available in nonterminal alphabet.
@@ -537,7 +541,7 @@ public:
*
* \returns true if the tested symbol is in nonterminal alphabet
*/
- static bool available ( const grammar::EpsilonFreeCFG < SymbolType > & grammar, const SymbolType & symbol ) {
+ static bool available ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
}
@@ -547,7 +551,7 @@ public:
* \param grammar the tested grammar
* \param symbol the tested symbol
*/
- static void valid ( const grammar::EpsilonFreeCFG < SymbolType > &, const SymbolType & ) {
+ static void valid ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > &, const NonterminalSymbolType & ) {
}
};
@@ -556,20 +560,20 @@ public:
*
* \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
*/
-template < class SymbolType >
-struct normalize < grammar::EpsilonFreeCFG < SymbolType > > {
- static grammar::EpsilonFreeCFG < > eval ( grammar::EpsilonFreeCFG < SymbolType > && value ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct normalize < grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > > {
+ static grammar::EpsilonFreeCFG < > eval ( grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > && value ) {
ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
DefaultSymbolType initialSymbol = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getInitialSymbol ( ) );
grammar::EpsilonFreeCFG < > res ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::vector < SymbolType > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
+ for ( std::pair < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
- ext::set < ext::vector < DefaultSymbolType > > rhs;
- for ( ext::vector < SymbolType > && target : ext::make_mover ( rule.second ) )
- rhs.insert ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( target ) ) );
+ ext::set < ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > rhs;
+ for ( ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > && target : ext::make_mover ( rule.second ) )
+ rhs.insert ( alphabet::SymbolNormalize::normalizeVariantSymbols ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
diff --git a/alib2data/src/grammar/ContextFree/GNF.h b/alib2data/src/grammar/ContextFree/GNF.h
index 0de4d45fb8..93731718fe 100644
--- a/alib2data/src/grammar/ContextFree/GNF.h
+++ b/alib2data/src/grammar/ContextFree/GNF.h
@@ -60,14 +60,15 @@ class InitialSymbol;
* P = set of production rules of the form A -> BC or A -> a, where A, B, C \in N and a \in T,
* S (InitialSymbol) = initial nonterminal symbol,
*
- * \tparam SymbolType used for the terminal alphabet, the nonterminal alphabet, and the initial symbol of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType = DefaultSymbolType >
-class GNF final : public GrammarBase, public core::Components < GNF < SymbolType >, ext::set < SymbolType >, component::Set, std::tuple < TerminalAlphabet, NonterminalAlphabet >, SymbolType, component::Value, InitialSymbol > {
+template < class TerminalSymbolType = DefaultSymbolType, class NonterminalSymbolType = DefaultSymbolType >
+class GNF final : public GrammarBase, public core::Components < GNF < TerminalSymbolType, NonterminalSymbolType >, ext::set < TerminalSymbolType >, component::Set, TerminalAlphabet, ext::set < NonterminalSymbolType >, component::Set, NonterminalAlphabet, NonterminalSymbolType, component::Value, InitialSymbol > {
/**
* Rules function as mapping from nonterminal symbol on the left hand side to a set of sequences of terminal and nonterminal symbols.
*/
- ext::map < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > rules;
+ ext::map < NonterminalSymbolType, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > > rules;
/**
* Boolean signaling whether grammar generates empty string or don't.
@@ -80,7 +81,7 @@ public:
*
* \param initialSymbol the initial symbol of the grammar
*/
- explicit GNF ( SymbolType initialSymbol );
+ explicit GNF ( NonterminalSymbolType initialSymbol );
/**
* \brief Creates a new instance of the grammar with a concrete nonterminal alphabet, terminal alphabet and initial symbol.
@@ -89,7 +90,7 @@ public:
* \param terminalSymbols the initial terminal alphabet
* \param initialSymbol the initial symbol of the grammar
*/
- explicit GNF ( ext::set < SymbolType > nonTerminalSymbols, ext::set < SymbolType > terminalSymbols, SymbolType initialSymbol );
+ explicit GNF ( ext::set < NonterminalSymbolType > nonTerminalSymbols, ext::set < TerminalSymbolType > terminalSymbols, NonterminalSymbolType initialSymbol );
/**
* @copydoc grammar::GrammarBase::clone()
@@ -111,7 +112,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( SymbolType leftHandSide, ext::pair < SymbolType, ext::vector < SymbolType > > rightHandSide );
+ bool addRule ( NonterminalSymbolType leftHandSide, ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > rightHandSide );
/**
* \brief Add new rules of a grammar.
@@ -121,21 +122,21 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( SymbolType leftHandSide, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide );
+ void addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > & getRules ( ) const &;
+ const ext::map < NonterminalSymbolType, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > > & getRules ( ) const &;
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- ext::map < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > && getRules ( ) &&;
+ ext::map < NonterminalSymbolType, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > > && getRules ( ) &&;
/**
* Remove a rule of a grammar in form of A -> aB, where A \in N, a \in T, and B \in N*.
@@ -145,14 +146,14 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide );
+ bool removeRule ( const NonterminalSymbolType & leftHandSide, const ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > & rightHandSide );
/**
* Getter of initial symbol.
*
* \returns the initial symbol of the grammar
*/
- const SymbolType & getInitialSymbol ( ) const & {
+ const NonterminalSymbolType & getInitialSymbol ( ) const & {
return this->template accessComponent < InitialSymbol > ( ).get ( );
}
@@ -161,7 +162,7 @@ public:
*
* \returns the initial symbol of the grammar
*/
- SymbolType && getInitialSymbol ( ) && {
+ NonterminalSymbolType && getInitialSymbol ( ) && {
return std::move ( this->template accessComponent < InitialSymbol > ( ).get ( ) );
}
@@ -172,7 +173,7 @@ public:
*
* \returns true if the initial symbol was indeed changed
*/
- bool setInitialSymbol ( SymbolType symbol ) {
+ bool setInitialSymbol ( NonterminalSymbolType symbol ) {
return this->template accessComponent < InitialSymbol > ( ).set ( std::move ( symbol ) );
}
@@ -181,7 +182,7 @@ public:
*
* \returns the nonterminal alphabet of the grammar
*/
- const ext::set < SymbolType > & getNonterminalAlphabet ( ) const & {
+ const ext::set < NonterminalSymbolType > & getNonterminalAlphabet ( ) const & {
return this->template accessComponent < NonterminalAlphabet > ( ).get ( );
}
@@ -190,7 +191,7 @@ public:
*
* \returns the nonterminal alphabet of the grammar
*/
- ext::set < SymbolType > && getNonterminalAlphabet ( ) && {
+ ext::set < NonterminalSymbolType > && getNonterminalAlphabet ( ) && {
return std::move ( this->template accessComponent < NonterminalAlphabet > ( ).get ( ) );
}
@@ -201,7 +202,7 @@ public:
*
* \returns true if the symbol was indeed added
*/
- bool addNonterminalSymbol ( SymbolType symbol ) {
+ bool addNonterminalSymbol ( NonterminalSymbolType symbol ) {
return this->template accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
}
@@ -210,7 +211,7 @@ public:
*
* \param symbols completely new nonterminal alphabet
*/
- void setNonterminalAlphabet ( ext::set < SymbolType > symbols ) {
+ void setNonterminalAlphabet ( ext::set < NonterminalSymbolType > symbols ) {
this->template accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
}
@@ -219,7 +220,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- const ext::set < SymbolType > & getTerminalAlphabet ( ) const & {
+ const ext::set < TerminalSymbolType > & getTerminalAlphabet ( ) const & {
return this->template accessComponent < TerminalAlphabet > ( ).get ( );
}
@@ -228,7 +229,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- ext::set < SymbolType > && getTerminalAlphabet ( ) && {
+ ext::set < TerminalSymbolType > && getTerminalAlphabet ( ) && {
return std::move ( this->template accessComponent < TerminalAlphabet > ( ).get ( ) );
}
@@ -239,7 +240,7 @@ public:
*
* \returns true if the symbol was indeed added
*/
- bool addTerminalSymbol ( SymbolType symbol ) {
+ bool addTerminalSymbol ( TerminalSymbolType symbol ) {
return this->template accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
}
@@ -248,7 +249,7 @@ public:
*
* \param symbol completely new nontemrinal alphabet
*/
- void setTerminalAlphabet ( ext::set < SymbolType > symbols ) {
+ void setTerminalAlphabet ( ext::set < TerminalSymbolType > symbols ) {
this->template accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
}
@@ -300,49 +301,49 @@ public:
virtual object::ObjectBase * inc ( ) && override;
};
-template < class SymbolType >
-GNF < SymbolType >::GNF ( SymbolType initialSymbol ) : GNF ( ext::set < SymbolType > { initialSymbol }, ext::set < SymbolType > ( ), initialSymbol ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GNF < TerminalSymbolType, NonterminalSymbolType >::GNF ( NonterminalSymbolType initialSymbol ) : GNF ( ext::set < NonterminalSymbolType > { initialSymbol }, ext::set < TerminalSymbolType > ( ), initialSymbol ) {
}
-template < class SymbolType >
-GNF < SymbolType >::GNF ( ext::set < SymbolType > nonterminalAlphabet, ext::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : core::Components < GNF, ext::set < SymbolType >, component::Set, std::tuple < TerminalAlphabet, NonterminalAlphabet >, SymbolType, component::Value, InitialSymbol > ( std::move ( terminalAlphabet), std::move ( nonterminalAlphabet ), std::move ( initialSymbol ) ), generatesEpsilon ( false ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GNF < TerminalSymbolType, NonterminalSymbolType >::GNF ( ext::set < NonterminalSymbolType > nonterminalAlphabet, ext::set < TerminalSymbolType > terminalAlphabet, NonterminalSymbolType initialSymbol ) : core::Components < GNF, ext::set < TerminalSymbolType >, component::Set, TerminalAlphabet, ext::set < NonterminalSymbolType >, component::Set, NonterminalAlphabet, NonterminalSymbolType, component::Value, InitialSymbol > ( std::move ( terminalAlphabet), std::move ( nonterminalAlphabet ), std::move ( initialSymbol ) ), generatesEpsilon ( false ) {
}
-template < class SymbolType >
-GrammarBase * GNF < SymbolType >::clone ( ) const & {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GrammarBase * GNF < TerminalSymbolType, NonterminalSymbolType >::clone ( ) const & {
return new GNF ( * this );
}
-template < class SymbolType >
-GrammarBase * GNF < SymbolType >::clone ( ) && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GrammarBase * GNF < TerminalSymbolType, NonterminalSymbolType >::clone ( ) && {
return new GNF ( std::move ( * this ) );
}
-template < class SymbolType >
-bool GNF < SymbolType >::addRule ( SymbolType leftHandSide, ext::pair < SymbolType, ext::vector < SymbolType > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool GNF < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
if ( !getTerminalAlphabet ( ).count ( rightHandSide.first ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
- for ( const SymbolType & rhsNTs : rightHandSide.second )
+ for ( const NonterminalSymbolType & rhsNTs : rightHandSide.second )
if ( !getNonterminalAlphabet ( ).count ( rhsNTs ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( rhsNTs ) + "\" is not a nonterminal symbol" );
return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
}
-template < class SymbolType >
-void GNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void GNF < TerminalSymbolType, NonterminalSymbolType >::addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const std::pair < SymbolType, ext::vector < SymbolType > > & rhs : rightHandSide ) {
+ for ( const ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > & rhs : rightHandSide ) {
if ( ! getTerminalAlphabet ( ).count ( rhs.first ) )
throw GrammarException ( "Rule must rewrite to terminal symbol" );
- for ( const SymbolType & rhsNTs : rhs.second )
+ for ( const NonterminalSymbolType & rhsNTs : rhs.second )
if ( !getNonterminalAlphabet ( ).count ( rhsNTs ) )
throw GrammarException ( "Symbol \"" + ext::to_string ( rhsNTs ) + "\" is not a nonterminal symbol" );
}
@@ -350,33 +351,33 @@ void GNF < SymbolType >::addRules ( SymbolType leftHandSide, ext::set < ext::pai
rules[std::move ( leftHandSide )].insert ( ext::make_mover ( rightHandSide ).begin ( ), ext::make_mover ( rightHandSide ).end ( ) );
}
-template < class SymbolType >
-const ext::map < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > & GNF < SymbolType >::getRules ( ) const & {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+const ext::map < NonterminalSymbolType, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > > & GNF < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) const & {
return rules;
}
-template < class SymbolType >
-ext::map < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > && GNF < SymbolType >::getRules ( ) && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+ext::map < NonterminalSymbolType, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > > && GNF < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) && {
return std::move ( rules );
}
-template < class SymbolType >
-bool GNF < SymbolType >::removeRule ( const SymbolType & leftHandSide, const ext::pair < SymbolType, ext::vector < SymbolType > > & rightHandSide ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool GNF < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
-template < class SymbolType >
-void GNF < SymbolType >::setGeneratesEpsilon ( bool genEps ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void GNF < TerminalSymbolType, NonterminalSymbolType >::setGeneratesEpsilon ( bool genEps ) {
generatesEpsilon = genEps;
}
-template < class SymbolType >
-bool GNF < SymbolType >::getGeneratesEpsilon ( ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool GNF < TerminalSymbolType, NonterminalSymbolType >::getGeneratesEpsilon ( ) const {
return generatesEpsilon;
}
-template < class SymbolType >
-int GNF < SymbolType >::compare ( const GNF & other ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+int GNF < TerminalSymbolType, NonterminalSymbolType >::compare ( const GNF & other ) const {
auto first = ext::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
auto second = ext::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
@@ -385,8 +386,8 @@ int GNF < SymbolType >::compare ( const GNF & other ) const {
return comp ( first, second );
}
-template < class SymbolType >
-void GNF < SymbolType >::operator >>( std::ostream & out ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void GNF < TerminalSymbolType, NonterminalSymbolType >::operator >>( std::ostream & out ) const {
out << "(GNF "
<< "nonterminalAlphabet = " << getNonterminalAlphabet ( )
<< "terminalAlphabet = " << getTerminalAlphabet ( )
@@ -394,15 +395,15 @@ void GNF < SymbolType >::operator >>( std::ostream & out ) const {
<< "rules = " << rules << ")";
}
-template < class SymbolType >
-GNF < SymbolType >::operator std::string ( ) const {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+GNF < TerminalSymbolType, NonterminalSymbolType >::operator std::string ( ) const {
std::stringstream ss;
ss << * this;
return ss.str ( );
}
-template < class SymbolType >
-object::ObjectBase* GNF < SymbolType >::inc() && {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+object::ObjectBase* GNF < TerminalSymbolType, NonterminalSymbolType >::inc() && {
return new object::UniqueObject(object::Object(std::move(*this)), primitive::Integer(0));
}
@@ -413,10 +414,11 @@ namespace core {
/**
* Helper class specifying constraints for the grammar's internal terminal alphabet component.
*
- * \tparam SymbolType used for the terminal alphabet of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class SetConstraint< grammar::GNF < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class SetConstraint< grammar::GNF < TerminalSymbolType, NonterminalSymbolType >, TerminalSymbolType, grammar::TerminalAlphabet > {
public:
/**
* Returns true if the terminal symbol is still used in some rule of the grammar.
@@ -426,9 +428,9 @@ public:
*
* \returns true if the symbol is used, false othervise
*/
- static bool used ( const grammar::GNF < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > & rule : grammar.getRules ( ) )
- for ( const std::pair < SymbolType, ext::vector < SymbolType > > & rhs : rule.second )
+ static bool used ( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > > & rule : grammar.getRules ( ) )
+ for ( const ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > & rhs : rule.second )
if ( rhs.first == symbol )
return true;
@@ -443,7 +445,7 @@ public:
*
* \returns true
*/
- static bool available ( const grammar::GNF < SymbolType > &, const SymbolType & ) {
+ static bool available ( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > &, const TerminalSymbolType & ) {
return true;
}
@@ -455,7 +457,7 @@ public:
*
* \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
*/
- static void valid ( const grammar::GNF < SymbolType > & grammar, const SymbolType & symbol ) {
+ static void valid ( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + ext::to_string ( symbol ) + "cannot be in terminal alphabet since it is already nonterminal alphabet" );
}
@@ -464,10 +466,11 @@ public:
/**
* Helper class specifying constraints for the grammar's internal nonterminal alphabet component.
*
- * \tparam SymbolType used for the nonterminal alphabet of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class SetConstraint< grammar::GNF < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class SetConstraint< grammar::GNF < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::NonterminalAlphabet > {
public:
/**
* Returns true if the nonterminal symbol is still used in some rule of the grammar or if it is the initial symbol of the grammar.
@@ -477,12 +480,12 @@ public:
*
* \returns true if the symbol is used, false othervise
*/
- static bool used ( const grammar::GNF < SymbolType > & grammar, const SymbolType & symbol ) {
- for ( const std::pair < const SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > & rule : grammar.getRules ( ) ) {
+ static bool used ( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const std::pair < SymbolType, ext::vector < SymbolType > > & rhs : rule.second )
+ for ( const ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > & rhs : rule.second )
if ( std::find ( rhs.second.begin ( ), rhs.second.end ( ), symbol ) != rhs.second.end ( ) )
return true;
}
@@ -501,7 +504,7 @@ public:
*
* \returns true
*/
- static bool available ( const grammar::GNF < SymbolType > &, const SymbolType & ) {
+ static bool available ( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > &, const NonterminalSymbolType & ) {
return true;
}
@@ -513,7 +516,7 @@ public:
*
* \throws grammar::GrammarException of the tested symbol is in nonterminal alphabet
*/
- static void valid ( const grammar::GNF < SymbolType > & grammar, const SymbolType & symbol ) {
+ static void valid ( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
if ( grammar.template accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
throw grammar::GrammarException ( "Symbol " + ext::to_string ( symbol ) + "cannot be in nonterminal alphabet since it is already in terminal alphabet" );
}
@@ -522,10 +525,11 @@ public:
/**
* Helper class specifying constraints for the grammar's internal initial symbol element.
*
- * \tparam SymbolType used for the initial symbol of the grammar.
+ * \tparam TerminalSymbolType used for the terminal alphabet of the grammar.
+ * \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
-template < class SymbolType >
-class ElementConstraint< grammar::GNF < SymbolType >, SymbolType, grammar::InitialSymbol > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+class ElementConstraint< grammar::GNF < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::InitialSymbol > {
public:
/**
* Returns true if the symbol requested to be initial is available in nonterminal alphabet.
@@ -535,7 +539,7 @@ public:
*
* \returns true if the tested symbol is in nonterminal alphabet
*/
- static bool available ( const grammar::GNF < SymbolType > & grammar, const SymbolType & symbol ) {
+ static bool available ( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
}
@@ -545,7 +549,7 @@ public:
* \param grammar the tested grammar
* \param symbol the tested symbol
*/
- static void valid ( const grammar::GNF < SymbolType > &, const SymbolType & ) {
+ static void valid ( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > &, const NonterminalSymbolType & ) {
}
};
@@ -554,19 +558,19 @@ public:
*
* \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
*/
-template < class SymbolType >
-struct normalize < grammar::GNF < SymbolType > > {
- static grammar::GNF < > eval ( grammar::GNF < SymbolType > && value ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct normalize < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > > {
+ static grammar::GNF < > eval ( grammar::GNF < TerminalSymbolType, NonterminalSymbolType > && value ) {
ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
DefaultSymbolType initialSymbol = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getInitialSymbol ( ) );
grammar::GNF < > res ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < SymbolType, ext::set < ext::pair < SymbolType, ext::vector < SymbolType > > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
+ for ( std::pair < NonterminalSymbolType, ext::set < ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
ext::set < ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > rhs;
- for ( ext::pair < SymbolType, ext::vector < SymbolType > > && target : ext::make_mover ( rule.second ) )
+ for ( ext::pair < TerminalSymbolType, ext::vector < NonterminalSymbolType > > && target : ext::make_mover ( rule.second ) )
rhs.insert ( grammar::GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
diff --git a/alib2data/src/grammar/RawRules.h b/alib2data/src/grammar/RawRules.h
index 170f868bca..c15159a399 100644
--- a/alib2data/src/grammar/RawRules.h
+++ b/alib2data/src/grammar/RawRules.h
@@ -45,26 +45,26 @@ public:
/**
* \override
*/
- template < class SymbolType, class TerminalSymbolType = SymbolType, class NonterminalSymbolType = SymbolType >
- static ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > getRawRules ( const GNF < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > getRawRules ( const GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* \override
*/
- template < class SymbolType, class TerminalSymbolType = SymbolType, class NonterminalSymbolType = SymbolType >
- static ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > getRawRules ( const EpsilonFreeCFG < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > getRawRules ( const EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* \override
*/
- template < class SymbolType, class TerminalSymbolType = SymbolType, class NonterminalSymbolType = SymbolType >
- static ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > getRawRules ( const CNF < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > getRawRules ( const CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* \override
*/
- template < class SymbolType, class TerminalSymbolType = SymbolType, class NonterminalSymbolType = SymbolType >
- static ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > getRawRules ( const CFG < SymbolType > & grammar );
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > getRawRules ( const CFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* \override
@@ -120,8 +120,8 @@ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < Termin
return res;
}
-template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
-ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > RawRules::getRawRules ( const GNF < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > RawRules::getRawRules ( const GNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > res;
for ( const auto & rule : grammar.getRules ( ) )
@@ -141,21 +141,9 @@ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < Termin
return res;
}
-template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
-ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > RawRules::getRawRules ( const EpsilonFreeCFG < SymbolType > & grammar ) {
- ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > res;
-
- for ( const std::pair < SymbolType, ext::set < ext::vector < SymbolType > > > & rule : grammar.getRules ( ) ) {
- ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > resRHSSet;
- for ( const ext::vector < SymbolType > & rhs : rule.second ) {
- ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > resRHS;
- for ( const SymbolType & symbol : rhs ) {
- resRHS.push_back ( ext::variant < TerminalSymbolType, NonterminalSymbolType > ( symbol ) );
- }
- resRHSSet.insert ( std::move ( resRHS ) );
- }
- res.insert ( std::make_pair ( rule.first, std::move ( resRHSSet ) ) );
- }
+template < class TerminalSymbolType, class NonterminalSymbolType >
+ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > RawRules::getRawRules ( const EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
+ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > res = grammar.getRules ( );
if ( grammar.getGeneratesEpsilon ( ) )
res [ grammar.getInitialSymbol ( ) ].insert ( ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > { } );
@@ -163,14 +151,14 @@ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < Termin
return res;
}
-template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
-ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > RawRules::getRawRules ( const CNF < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > RawRules::getRawRules ( const CNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > res;
for ( const auto & rule : grammar.getRules ( ) )
for ( const auto & rhs : rule.second ) {
if ( rhs.template is < TerminalSymbolType > ( ) ) {
- ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > tmp { ext::variant < TerminalSymbolType, NonterminalSymbolType > ( rhs.template get < SymbolType > ( ) ) };
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > tmp { ext::variant < TerminalSymbolType, NonterminalSymbolType > ( rhs.template get < TerminalSymbolType > ( ) ) };
res[rule.first].insert ( std::move ( tmp ) );
} else {
const auto & realRHS = rhs.template get < ext::pair < NonterminalSymbolType, NonterminalSymbolType > > ( );
@@ -185,23 +173,9 @@ ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < Termin
return res;
}
-template < class SymbolType, class TerminalSymbolType, class NonterminalSymbolType >
-ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > RawRules::getRawRules ( const CFG < SymbolType > & grammar ) {
- ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > res;
-
- for ( const std::pair < SymbolType, ext::set < ext::vector < SymbolType > > > & rule : grammar.getRules ( ) ) {
- ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > resRHSSet;
- for ( const ext::vector < SymbolType > & rhs : rule.second ) {
- ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > resRHS;
- for ( const SymbolType & symbol : rhs ) {
- resRHS.push_back ( ext::variant < TerminalSymbolType, NonterminalSymbolType > ( symbol ) );
- }
- resRHSSet.insert ( std::move ( resRHS ) );
- }
- res.insert ( std::make_pair ( rule.first, std::move ( resRHSSet ) ) );
- }
-
- return res;
+template < class TerminalSymbolType, class NonterminalSymbolType >
+ext::map < NonterminalSymbolType, ext::set < ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > > > RawRules::getRawRules ( const CFG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
+ return grammar.getRules ( );
}
template < class TerminalSymbolType, class NonterminalSymbolType >
diff --git a/alib2data/src/grammar/Regular/LeftLG.h b/alib2data/src/grammar/Regular/LeftLG.h
index 2cd8c427f0..605a95de88 100644
--- a/alib2data/src/grammar/Regular/LeftLG.h
+++ b/alib2data/src/grammar/Regular/LeftLG.h
@@ -69,7 +69,7 @@ class LeftLG final : public GrammarBase, public core::Components < LeftLG < Term
/**
* Rules as mapping from nonterminal symbol on the left hand side to set of either sequence of terminal symbols or doublets of sequence of terminal symbols and nonterminal symbol.
*/
- ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > rules;
+ ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > rules;
public:
/**
@@ -108,7 +108,7 @@ public:
*
* \returns true if the rule was indeed added, false othervise
*/
- bool addRule ( NonterminalSymbolType leftHandSide, ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rightHandSide );
+ bool addRule ( NonterminalSymbolType leftHandSide, ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rightHandSide );
/**
* \brief Add a new rule of a grammar.
@@ -142,21 +142,21 @@ public:
* \param leftHandSide the left hand side of the rule
* \param rightHandSide a set of right hand sides of the rule
*/
- void addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > rightHandSide );
+ void addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > rightHandSide );
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- const ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > & getRules ( ) const &;
+ const ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > & getRules ( ) const &;
/**
* Get rules of the grammar.
*
* \returns rules of the grammar
*/
- ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > && getRules ( ) &&;
+ ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > && getRules ( ) &&;
/**
* Remove a rule of a grammar in form of A -> Ba or A -> a, where A, B \in N and a \in T*.
@@ -166,7 +166,7 @@ public:
*
* \returns true if the rule was indeed removed, false othervise
*/
- bool removeRule ( const NonterminalSymbolType & leftHandSide, const ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & rightHandSide );
+ bool removeRule ( const NonterminalSymbolType & leftHandSide, const ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & rightHandSide );
/**
* Remove a rule of a grammar in form of A -> a, where A \in N and a \in T*.
@@ -260,7 +260,7 @@ public:
*
* \returns the terminal alphabet of the grammar
*/
- const ext::set < NonterminalSymbolType > & getTerminalAlphabet ( ) const & {
+ const ext::set < TerminalSymbolType > & getTerminalAlphabet ( ) const & {
return this->template accessComponent < TerminalAlphabet > ( ).get ( );
}
@@ -346,7 +346,7 @@ GrammarBase * LeftLG < TerminalSymbolType, NonterminalSymbolType >::clone ( ) &&
}
template < class TerminalSymbolType, class NonterminalSymbolType >
-bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rightHandSide ) {
+bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
@@ -370,24 +370,24 @@ bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::addRule ( Nonterminal
template < class TerminalSymbolType, class NonterminalSymbolType >
bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::vector < TerminalSymbolType > rightHandSide ) {
- ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class TerminalSymbolType, class NonterminalSymbolType >
bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::addRule ( NonterminalSymbolType leftHandSide, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > rightHandSide ) {
- ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rhs ( std::move ( rightHandSide ) );
+ ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rhs ( std::move ( rightHandSide ) );
return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
}
template < class TerminalSymbolType, class NonterminalSymbolType >
-void LeftLG < TerminalSymbolType, NonterminalSymbolType >::addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > rightHandSide ) {
+void LeftLG < TerminalSymbolType, NonterminalSymbolType >::addRules ( NonterminalSymbolType leftHandSide, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > rightHandSide ) {
if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
throw GrammarException ( "Rule must rewrite nonterminal symbol" );
- for ( const ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & element : rightHandSide ) {
+ for ( const ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & element : rightHandSide ) {
if ( element.template is < ext::vector < TerminalSymbolType > > ( ) ) {
for ( const auto & symbol : element.template get < ext::vector < TerminalSymbolType > > ( ) )
if ( !getTerminalAlphabet ( ).count ( symbol ) )
@@ -410,30 +410,30 @@ void LeftLG < TerminalSymbolType, NonterminalSymbolType >::addRules ( Nontermina
}
template < class TerminalSymbolType, class NonterminalSymbolType >
-const ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > & LeftLG < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) const & {
+const ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > & LeftLG < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) const & {
return rules;
}
template < class TerminalSymbolType, class NonterminalSymbolType >
-ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > && LeftLG < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) && {
+ext::map < NonterminalSymbolType, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > && LeftLG < TerminalSymbolType, NonterminalSymbolType >::getRules ( ) && {
return std::move ( rules );
}
template < class TerminalSymbolType, class NonterminalSymbolType >
-bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & rightHandSide ) {
+bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & rightHandSide ) {
return rules[leftHandSide].erase ( rightHandSide );
}
template < class TerminalSymbolType, class NonterminalSymbolType >
bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::vector < TerminalSymbolType > & rightHandSide ) {
- ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rhs ( rightHandSide );
+ ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
template < class TerminalSymbolType, class NonterminalSymbolType >
bool LeftLG < TerminalSymbolType, NonterminalSymbolType >::removeRule ( const NonterminalSymbolType & leftHandSide, const ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > & rightHandSide ) {
- ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rhs ( rightHandSide );
+ ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > rhs ( rightHandSide );
return removeRule ( leftHandSide, rhs );
}
@@ -491,10 +491,10 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & grammar, const TerminalSymbolType & symbol ) {
- for ( const std::pair < const NonterminalSymbolType, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > & rule : grammar.getRules ( ) ) {
- for ( const ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & rhsTmp : rule.second )
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > & rule : grammar.getRules ( ) ) {
+ for ( const ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & rhsTmp : rule.second )
if ( rhsTmp.template is < ext::vector < TerminalSymbolType > > ( ) ) {
- const ext::vector < NonterminalSymbolType > & rhs = rhsTmp.template get < ext::vector < TerminalSymbolType > > ( );
+ const ext::vector < TerminalSymbolType > & rhs = rhsTmp.template get < ext::vector < TerminalSymbolType > > ( );
if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
return true;
@@ -554,11 +554,11 @@ public:
* \returns true if the symbol is used, false othervise
*/
static bool used ( const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & grammar, const NonterminalSymbolType & symbol ) {
- for ( const std::pair < const NonterminalSymbolType, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > & rule : grammar.getRules ( ) ) {
+ for ( const std::pair < const NonterminalSymbolType, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > & rule : grammar.getRules ( ) ) {
if ( rule.first == symbol )
return true;
- for ( const ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & rhsTmp : rule.second )
+ for ( const ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > & rhsTmp : rule.second )
if ( rhsTmp.template is < ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > ( ) ) {
const ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > & rhs = rhsTmp.template get < ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > ( );
@@ -607,7 +607,7 @@ public:
* \tparam NonterminalSymbolType used for the nonterminal alphabet, and the initial symbol of the grammar.
*/
template < class TerminalSymbolType, class NonterminalSymbolType >
-class ElementConstraint< grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType >, TerminalSymbolType, grammar::InitialSymbol > {
+class ElementConstraint< grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType >, NonterminalSymbolType, grammar::InitialSymbol > {
public:
/**
* Returns true if the symbol requested to be initial is available in nonterminal alphabet.
@@ -645,10 +645,10 @@ struct normalize < grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType >
grammar::LeftLG < > res ( std::move ( nonterminals ), std::move ( terminals ), std::move ( initialSymbol ) );
- for ( std::pair < NonterminalSymbolType, ext::set < ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
+ for ( std::pair < NonterminalSymbolType, ext::set < ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > > > && rule : ext::make_mover ( std::move ( value ).getRules ( ) ) ) {
ext::set < ext::variant < ext::vector < DefaultSymbolType >, ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > > rhs;
- for ( ext::variant < ext::vector < NonterminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > && target : ext::make_mover ( rule.second ) )
+ for ( ext::variant < ext::vector < TerminalSymbolType >, ext::pair < NonterminalSymbolType, ext::vector < TerminalSymbolType > > > && target : ext::make_mover ( rule.second ) )
rhs.insert ( grammar::GrammarNormalize::normalizeRHS ( std::move ( target ) ) );
DefaultSymbolType lhs = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( rule.first ) );
diff --git a/alib2data/src/grammar/xml/ContextFree/CFG.h b/alib2data/src/grammar/xml/ContextFree/CFG.h
index e19621dfca..4c2075bae2 100644
--- a/alib2data/src/grammar/xml/ContextFree/CFG.h
+++ b/alib2data/src/grammar/xml/ContextFree/CFG.h
@@ -28,10 +28,12 @@
#include "../common/GrammarFromXMLParser.h"
#include "../common/GrammarToXMLComposer.h"
+#include <container/xml/ObjectsVariant.h>
+
namespace core {
-template < class SymbolType >
-struct xmlApi < grammar::CFG < SymbolType > > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct xmlApi < grammar::CFG < TerminalSymbolType, NonterminalSymbolType > > {
/**
* \brief The XML tag name of class.
*
@@ -63,7 +65,7 @@ struct xmlApi < grammar::CFG < SymbolType > > {
*
* \returns the new instance of the grammar
*/
- static grammar::CFG < SymbolType > parse ( ext::deque < sax::Token >::iterator & input );
+ static grammar::CFG < TerminalSymbolType, NonterminalSymbolType > parse ( ext::deque < sax::Token >::iterator & input );
/**
* Helper for parsing of individual rules of the grammar from a sequence of xml tokens.
@@ -71,7 +73,7 @@ struct xmlApi < grammar::CFG < SymbolType > > {
* \params input the iterator to sequence of xml tokens to parse from
* \params grammar the grammar to add the rule to
*/
- static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CFG < SymbolType > & grammar );
+ static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* Composing to a sequence of xml tokens helper.
@@ -79,7 +81,7 @@ struct xmlApi < grammar::CFG < SymbolType > > {
* \param out sink for new xml tokens representing the grammar
* \param grammar the grammar to compose
*/
- static void compose ( ext::deque < sax::Token > & out, const grammar::CFG < SymbolType > & grammar );
+ static void compose ( ext::deque < sax::Token > & out, const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* Helper for composing rules of the grammar to a sequence of xml tokens.
@@ -87,18 +89,18 @@ struct xmlApi < grammar::CFG < SymbolType > > {
* \param out sink for xml tokens representing the rules of the grammar
* \param grammar the grammar to compose
*/
- static void composeRules ( ext::deque < sax::Token > & out, const grammar::CFG < SymbolType > & grammar );
+ static void composeRules ( ext::deque < sax::Token > & out, const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
};
-template < class SymbolType >
-grammar::CFG < SymbolType > xmlApi < grammar::CFG < SymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::CFG < TerminalSymbolType, NonterminalSymbolType > xmlApi < grammar::CFG < TerminalSymbolType, NonterminalSymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
- ext::set < SymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
- ext::set < SymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
- SymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
+ ext::set < NonterminalSymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < NonterminalSymbolType > ( input );
+ ext::set < TerminalSymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < TerminalSymbolType > ( input );
+ NonterminalSymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < NonterminalSymbolType > ( input );
- grammar::CFG < SymbolType > grammar ( std::move ( initialSymbol ) );
+ grammar::CFG < TerminalSymbolType, NonterminalSymbolType > grammar ( std::move ( initialSymbol ) );
grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
@@ -109,16 +111,16 @@ grammar::CFG < SymbolType > xmlApi < grammar::CFG < SymbolType > >::parse ( ext:
return grammar;
}
-template < class SymbolType >
-void xmlApi < grammar::CFG < SymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CFG < SymbolType > & grammar ) {
- SymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- ext::vector < SymbolType > rhs = grammar::GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::CFG < TerminalSymbolType, NonterminalSymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
+ NonterminalSymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < NonterminalSymbolType > ( input );
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rhs = grammar::GrammarFromXMLParser::parseRuleRHS < ext::variant < TerminalSymbolType, NonterminalSymbolType > > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
-template < class SymbolType >
-void xmlApi < grammar::CFG < SymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::CFG < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::CFG < TerminalSymbolType, NonterminalSymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
grammar::GrammarToXMLComposer::composeNonterminalAlphabet ( out, grammar.getNonterminalAlphabet ( ) );
@@ -129,8 +131,8 @@ void xmlApi < grammar::CFG < SymbolType > >::compose ( ext::deque < sax::Token >
out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
}
-template < class SymbolType >
-void xmlApi < grammar::CFG < SymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::CFG < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::CFG < TerminalSymbolType, NonterminalSymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
for ( const auto & rule : grammar.getRules ( ) )
diff --git a/alib2data/src/grammar/xml/ContextFree/CNF.h b/alib2data/src/grammar/xml/ContextFree/CNF.h
index 150648aff2..4f69d392fe 100644
--- a/alib2data/src/grammar/xml/ContextFree/CNF.h
+++ b/alib2data/src/grammar/xml/ContextFree/CNF.h
@@ -28,10 +28,14 @@
#include "../common/GrammarFromXMLParser.h"
#include "../common/GrammarToXMLComposer.h"
+#include <grammar/AddRawRule.h>
+
+#include <container/xml/ObjectsVariant.h>
+
namespace core {
-template < class SymbolType >
-struct xmlApi < grammar::CNF < SymbolType > > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct xmlApi < grammar::CNF < TerminalSymbolType, NonterminalSymbolType > > {
/**
* \brief The XML tag name of class.
*
@@ -63,7 +67,7 @@ struct xmlApi < grammar::CNF < SymbolType > > {
*
* \returns the new instance of the grammar
*/
- static grammar::CNF < SymbolType > parse ( ext::deque < sax::Token >::iterator & input );
+ static grammar::CNF < TerminalSymbolType, NonterminalSymbolType > parse ( ext::deque < sax::Token >::iterator & input );
/**
* Helper for parsing of individual rules of the grammar from a sequence of xml tokens.
@@ -71,7 +75,7 @@ struct xmlApi < grammar::CNF < SymbolType > > {
* \params input the iterator to sequence of xml tokens to parse from
* \params grammar the grammar to add the rule to
*/
- static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CNF < SymbolType > & grammar );
+ static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* Composing to a sequence of xml tokens helper.
@@ -79,7 +83,7 @@ struct xmlApi < grammar::CNF < SymbolType > > {
* \param out sink for new xml tokens representing the grammar
* \param grammar the grammar to compose
*/
- static void compose ( ext::deque < sax::Token > & out, const grammar::CNF < SymbolType > & grammar );
+ static void compose ( ext::deque < sax::Token > & out, const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* Helper for composing rules of the grammar to a sequence of xml tokens.
@@ -87,18 +91,18 @@ struct xmlApi < grammar::CNF < SymbolType > > {
* \param out sink for xml tokens representing the rules of the grammar
* \param grammar the grammar to compose
*/
- static void composeRules ( ext::deque < sax::Token > & out, const grammar::CNF < SymbolType > & grammar );
+ static void composeRules ( ext::deque < sax::Token > & out, const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
};
-template < class SymbolType >
-grammar::CNF < SymbolType > xmlApi < grammar::CNF < SymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::CNF < TerminalSymbolType, NonterminalSymbolType > xmlApi < grammar::CNF < TerminalSymbolType, NonterminalSymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
- ext::set < SymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
- ext::set < SymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
- SymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
+ ext::set < NonterminalSymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < NonterminalSymbolType > ( input );
+ ext::set < TerminalSymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < TerminalSymbolType > ( input );
+ NonterminalSymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < NonterminalSymbolType > ( input );
- grammar::CNF < SymbolType > grammar ( std::move ( initialSymbol ) );
+ grammar::CNF < TerminalSymbolType, NonterminalSymbolType > grammar ( std::move ( initialSymbol ) );
grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
@@ -112,16 +116,16 @@ grammar::CNF < SymbolType > xmlApi < grammar::CNF < SymbolType > >::parse ( ext:
return grammar;
}
-template < class SymbolType >
-void xmlApi < grammar::CNF < SymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CNF < SymbolType > & grammar ) {
- SymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- ext::variant < SymbolType, ext::pair < SymbolType, SymbolType > > rhs = grammar::GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::CNF < TerminalSymbolType, NonterminalSymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
+ NonterminalSymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < NonterminalSymbolType > ( input );
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rhs = grammar::GrammarFromXMLParser::parseRuleRHS < ext::variant < TerminalSymbolType, NonterminalSymbolType > > ( input );
- grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
+ grammar::AddRawRule::addRawRule ( grammar, std::move ( lhs ), std::move ( rhs ) );
}
-template < class SymbolType >
-void xmlApi < grammar::CNF < SymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::CNF < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::CNF < TerminalSymbolType, NonterminalSymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
grammar::GrammarToXMLComposer::composeNonterminalAlphabet ( out, grammar.getNonterminalAlphabet ( ) );
@@ -133,8 +137,8 @@ void xmlApi < grammar::CNF < SymbolType > >::compose ( ext::deque < sax::Token >
out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
}
-template < class SymbolType >
-void xmlApi < grammar::CNF < SymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::CNF < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::CNF < TerminalSymbolType, NonterminalSymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
for ( const auto & rule : grammar.getRules ( ) )
diff --git a/alib2data/src/grammar/xml/ContextFree/EpsilonFreeCFG.h b/alib2data/src/grammar/xml/ContextFree/EpsilonFreeCFG.h
index e7b18aa3ab..2229d1d4cb 100644
--- a/alib2data/src/grammar/xml/ContextFree/EpsilonFreeCFG.h
+++ b/alib2data/src/grammar/xml/ContextFree/EpsilonFreeCFG.h
@@ -28,10 +28,12 @@
#include "../common/GrammarFromXMLParser.h"
#include "../common/GrammarToXMLComposer.h"
+#include <container/xml/ObjectsVariant.h>
+
namespace core {
-template < class SymbolType >
-struct xmlApi < grammar::EpsilonFreeCFG < SymbolType > > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct xmlApi < grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > > {
/**
* \brief The XML tag name of class.
*
@@ -63,7 +65,7 @@ struct xmlApi < grammar::EpsilonFreeCFG < SymbolType > > {
*
* \returns the new instance of the grammar
*/
- static grammar::EpsilonFreeCFG < SymbolType > parse ( ext::deque < sax::Token >::iterator & input );
+ static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > parse ( ext::deque < sax::Token >::iterator & input );
/**
* Helper for parsing of individual rules of the grammar from a sequence of xml tokens.
@@ -71,7 +73,7 @@ struct xmlApi < grammar::EpsilonFreeCFG < SymbolType > > {
* \params input the iterator to sequence of xml tokens to parse from
* \params grammar the grammar to add the rule to
*/
- static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::EpsilonFreeCFG < SymbolType > & grammar );
+ static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* Composing to a sequence of xml tokens helper.
@@ -79,7 +81,7 @@ struct xmlApi < grammar::EpsilonFreeCFG < SymbolType > > {
* \param out sink for new xml tokens representing the grammar
* \param grammar the grammar to compose
*/
- static void compose ( ext::deque < sax::Token > & out, const grammar::EpsilonFreeCFG < SymbolType > & grammar );
+ static void compose ( ext::deque < sax::Token > & out, const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* Helper for composing rules of the grammar to a sequence of xml tokens.
@@ -87,18 +89,18 @@ struct xmlApi < grammar::EpsilonFreeCFG < SymbolType > > {
* \param out sink for xml tokens representing the rules of the grammar
* \param grammar the grammar to compose
*/
- static void composeRules ( ext::deque < sax::Token > & out, const grammar::EpsilonFreeCFG < SymbolType > & grammar );
+ static void composeRules ( ext::deque < sax::Token > & out, const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
};
-template < class SymbolType >
-grammar::EpsilonFreeCFG < SymbolType > xmlApi < grammar::EpsilonFreeCFG < SymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > xmlApi < grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
- ext::set < SymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
- ext::set < SymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
- SymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
+ ext::set < NonterminalSymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < NonterminalSymbolType > ( input );
+ ext::set < TerminalSymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < TerminalSymbolType > ( input );
+ NonterminalSymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < NonterminalSymbolType > ( input );
- grammar::EpsilonFreeCFG < SymbolType > grammar ( std::move ( initialSymbol ) );
+ grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > grammar ( std::move ( initialSymbol ) );
grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
@@ -112,16 +114,16 @@ grammar::EpsilonFreeCFG < SymbolType > xmlApi < grammar::EpsilonFreeCFG < Symbol
return grammar;
}
-template < class SymbolType >
-void xmlApi < grammar::EpsilonFreeCFG < SymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::EpsilonFreeCFG < SymbolType > & grammar ) {
- SymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- ext::vector < SymbolType > rhs = grammar::GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
+ NonterminalSymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < NonterminalSymbolType > ( input );
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rhs = grammar::GrammarFromXMLParser::parseRuleRHS < ext::variant < TerminalSymbolType, NonterminalSymbolType > > ( input );
grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
}
-template < class SymbolType >
-void xmlApi < grammar::EpsilonFreeCFG < SymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::EpsilonFreeCFG < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
grammar::GrammarToXMLComposer::composeNonterminalAlphabet ( out, grammar.getNonterminalAlphabet ( ) );
@@ -133,8 +135,8 @@ void xmlApi < grammar::EpsilonFreeCFG < SymbolType > >::compose ( ext::deque < s
out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
}
-template < class SymbolType >
-void xmlApi < grammar::EpsilonFreeCFG < SymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::EpsilonFreeCFG < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
for ( const auto & rule : grammar.getRules ( ) )
diff --git a/alib2data/src/grammar/xml/ContextFree/GNF.h b/alib2data/src/grammar/xml/ContextFree/GNF.h
index 89016d7617..4abc398689 100644
--- a/alib2data/src/grammar/xml/ContextFree/GNF.h
+++ b/alib2data/src/grammar/xml/ContextFree/GNF.h
@@ -28,10 +28,14 @@
#include "../common/GrammarFromXMLParser.h"
#include "../common/GrammarToXMLComposer.h"
+#include <grammar/AddRawRule.h>
+
+#include <container/xml/ObjectsVariant.h>
+
namespace core {
-template < class SymbolType >
-struct xmlApi < grammar::GNF < SymbolType > > {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct xmlApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > > {
/**
* \brief The XML tag name of class.
*
@@ -63,7 +67,7 @@ struct xmlApi < grammar::GNF < SymbolType > > {
*
* \returns the new instance of the grammar
*/
- static grammar::GNF < SymbolType > parse ( ext::deque < sax::Token >::iterator & input );
+ static grammar::GNF < TerminalSymbolType, NonterminalSymbolType > parse ( ext::deque < sax::Token >::iterator & input );
/**
* Helper for parsing of individual rules of the grammar from a sequence of xml tokens.
@@ -71,7 +75,7 @@ struct xmlApi < grammar::GNF < SymbolType > > {
* \params input the iterator to sequence of xml tokens to parse from
* \params grammar the grammar to add the rule to
*/
- static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::GNF < SymbolType > & grammar );
+ static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* Composing to a sequence of xml tokens helper.
@@ -79,7 +83,7 @@ struct xmlApi < grammar::GNF < SymbolType > > {
* \param out sink for new xml tokens representing the grammar
* \param grammar the grammar to compose
*/
- static void compose ( ext::deque < sax::Token > & out, const grammar::GNF < SymbolType > & grammar );
+ static void compose ( ext::deque < sax::Token > & out, const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
/**
* Helper for composing rules of the grammar to a sequence of xml tokens.
@@ -87,18 +91,18 @@ struct xmlApi < grammar::GNF < SymbolType > > {
* \param out sink for xml tokens representing the rules of the grammar
* \param grammar the grammar to compose
*/
- static void composeRules ( ext::deque < sax::Token > & out, const grammar::GNF < SymbolType > & grammar );
+ static void composeRules ( ext::deque < sax::Token > & out, const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
};
-template < class SymbolType >
-grammar::GNF < SymbolType > xmlApi < grammar::GNF < SymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, NonterminalSymbolType > xmlApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
- ext::set < SymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
- ext::set < SymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
- SymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
+ ext::set < NonterminalSymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < NonterminalSymbolType > ( input );
+ ext::set < TerminalSymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < TerminalSymbolType > ( input );
+ NonterminalSymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < NonterminalSymbolType > ( input );
- grammar::GNF < SymbolType > grammar ( std::move ( initialSymbol ) );
+ grammar::GNF < TerminalSymbolType, NonterminalSymbolType > grammar ( std::move ( initialSymbol ) );
grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
@@ -112,16 +116,16 @@ grammar::GNF < SymbolType > xmlApi < grammar::GNF < SymbolType > >::parse ( ext:
return grammar;
}
-template < class SymbolType >
-void xmlApi < grammar::GNF < SymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::GNF < SymbolType > & grammar ) {
- SymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
- ext::pair < SymbolType, ext::vector < SymbolType > > rhs = grammar::GrammarFromXMLParser::parseRuleGNFRHS < SymbolType > ( input );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
+ NonterminalSymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < NonterminalSymbolType > ( input );
+ ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rhs = grammar::GrammarFromXMLParser::parseRuleRHS < ext::variant < TerminalSymbolType, NonterminalSymbolType > > ( input );
- grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
+ grammar::AddRawRule::addRawRule ( grammar, std::move ( lhs ), std::move ( rhs ) );
}
-template < class SymbolType >
-void xmlApi < grammar::GNF < SymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::GNF < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
grammar::GrammarToXMLComposer::composeNonterminalAlphabet ( out, grammar.getNonterminalAlphabet ( ) );
@@ -133,8 +137,8 @@ void xmlApi < grammar::GNF < SymbolType > >::compose ( ext::deque < sax::Token >
out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
}
-template < class SymbolType >
-void xmlApi < grammar::GNF < SymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::GNF < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void xmlApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
for ( const auto & rule : grammar.getRules ( ) )
diff --git a/alib2data/src/grammar/xml/common/GrammarFromXMLParser.h b/alib2data/src/grammar/xml/common/GrammarFromXMLParser.h
index 9ee6d7dbe9..4b8787dd46 100644
--- a/alib2data/src/grammar/xml/common/GrammarFromXMLParser.h
+++ b/alib2data/src/grammar/xml/common/GrammarFromXMLParser.h
@@ -56,11 +56,7 @@ public:
template < class SymbolType >
static SymbolType parseRuleSingleSymbolLHS(ext::deque<sax::Token>::iterator& input);
template < class SymbolType >
- static ext::pair<SymbolType, ext::vector<SymbolType>> parseRuleGNFRHS(ext::deque<sax::Token>::iterator& input);
- template < class SymbolType >
static ext::vector<SymbolType> parseRuleRHS(ext::deque<sax::Token>::iterator& input);
- template < class SymbolType >
- static ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>> parseRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>::iterator& input);
template<class T>
static void parseRules(ext::deque<sax::Token>::iterator& input, T& grammar);
@@ -146,18 +142,6 @@ ext::vector<SymbolType> GrammarFromXMLParser::parseRuleRContext(ext::deque<sax::
return rContext;
}
-template < class SymbolType >
-ext::pair<SymbolType, ext::vector<SymbolType>> GrammarFromXMLParser::parseRuleGNFRHS(ext::deque<sax::Token>::iterator& input) {
- sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
- SymbolType first = core::xmlApi<SymbolType>::parse(input);
- ext::vector<SymbolType> second;
- while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
- second.push_back(core::xmlApi<SymbolType>::parse(input));
- }
- sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
- return ext::make_pair(std::move(first), std::move(second));
-}
-
template < class SymbolType >
ext::vector<SymbolType> GrammarFromXMLParser::parseRuleRHS(ext::deque<sax::Token>::iterator& input) {
ext::vector<SymbolType> rhs;
@@ -172,20 +156,6 @@ ext::vector<SymbolType> GrammarFromXMLParser::parseRuleRHS(ext::deque<sax::Token
return rhs;
}
-template < class SymbolType >
-ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(ext::deque<sax::Token>::iterator& input) {
- sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
- SymbolType first = core::xmlApi<SymbolType>::parse(input);
- if(sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
- SymbolType second = core::xmlApi<SymbolType>::parse(input);
- sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
- return ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>>(ext::make_pair(std::move(first), std::move(second)));
- } else {
- sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
- return ext::variant<SymbolType, ext::pair<SymbolType, SymbolType>>(std::move(first));
- }
-}
-
template<class T>
void GrammarFromXMLParser::parseRules(ext::deque<sax::Token>::iterator& input, T& grammar) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rules");
diff --git a/alib2data/src/grammar/xml/common/GrammarToXMLComposer.h b/alib2data/src/grammar/xml/common/GrammarToXMLComposer.h
index 988d36be7a..51308bbce7 100644
--- a/alib2data/src/grammar/xml/common/GrammarToXMLComposer.h
+++ b/alib2data/src/grammar/xml/common/GrammarToXMLComposer.h
@@ -55,8 +55,8 @@ public:
static void composeRuleRHS(ext::deque<sax::Token>& out, const ext::vector<SymbolType>& symbols);
template < class T, class R, class S >
static void composeRuleOneOrTwoSymbolsRHS ( ext::deque < sax::Token > & out, const ext::variant < T, ext::pair < R, S > > & symbols );
- template < class SymbolType >
- static void composeRuleGNFRHS(ext::deque<sax::Token>& out, const ext::pair<SymbolType, ext::vector<SymbolType>>& symbols);
+ template < class TerminalSymbolType, class NonterminalSymbolType >
+ static void composeRuleGNFRHS(ext::deque<sax::Token>& out, const ext::pair<TerminalSymbolType, ext::vector<NonterminalSymbolType>>& symbols);
template < class TerminalSymbolType, class NonterminalSymbolType >
static void composeRuleLeftLGRHS(ext::deque<sax::Token>& out, const ext::variant<ext::vector<TerminalSymbolType>, ext::pair<NonterminalSymbolType, ext::vector<TerminalSymbolType>>>& symbols);
template < class TerminalSymbolType, class NonterminalSymbolType >
@@ -158,14 +158,14 @@ void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS ( ext::deque < sax::Tok
out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
}
-template < class SymbolType >
-void GrammarToXMLComposer::composeRuleGNFRHS(ext::deque<sax::Token>& out, const ext::pair<SymbolType, ext::vector<SymbolType>>& symbols) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void GrammarToXMLComposer::composeRuleGNFRHS(ext::deque<sax::Token>& out, const ext::pair<TerminalSymbolType, ext::vector<NonterminalSymbolType>>& symbols) {
out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
- core::xmlApi<SymbolType>::compose(out, symbols.first);
+ core::xmlApi<TerminalSymbolType>::compose(out, symbols.first);
for (const auto& symbol : symbols.second) {
- core::xmlApi<SymbolType>::compose(out, symbol);
+ core::xmlApi<NonterminalSymbolType>::compose(out, symbol);
}
out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
diff --git a/alib2data/test-src/grammar/GrammarTest.cpp b/alib2data/test-src/grammar/GrammarTest.cpp
index daac785bb2..40bd53c1d0 100644
--- a/alib2data/test-src/grammar/GrammarTest.cpp
+++ b/alib2data/test-src/grammar/GrammarTest.cpp
@@ -14,6 +14,11 @@
#include "grammar/Regular/RightLG.h"
#include "grammar/xml/Regular/RightLG.h"
+#include "grammar/Regular/LeftRG.h"
+#include "grammar/xml/Regular/LeftRG.h"
+#include "grammar/Regular/LeftLG.h"
+#include "grammar/xml/Regular/LeftLG.h"
+
#include "grammar/ContextFree/LG.h"
#include "grammar/xml/ContextFree/LG.h"
#include "grammar/ContextFree/EpsilonFreeCFG.h"
@@ -151,6 +156,58 @@ void GrammarTest::testRegularParser() {
CPPUNIT_ASSERT( grammar == grammar2 );
}
}
+
+ {
+ grammar::LeftRG < std::string, int > grammar ( 1 );
+
+ grammar.addNonterminalSymbol ( 1 );
+ grammar.addNonterminalSymbol ( 2 );
+ grammar.addNonterminalSymbol ( 3 );
+ grammar.addTerminalSymbol ( "a" );
+ grammar.addTerminalSymbol ( "b" );
+
+ grammar.addRule ( 1, ext::make_pair ( 2, "a" ) );
+ grammar.addRule ( 2, ext::make_pair ( 3, "b" ) );
+
+ CPPUNIT_ASSERT( grammar == grammar );
+ {
+ ext::deque<sax::Token> tokens = factory::XmlDataFactory::toTokens(grammar);
+ std::string tmp = sax::SaxComposeInterface::composeMemory ( tokens );
+
+ ext::deque<sax::Token> tokens2 = sax::SaxParseInterface::parseMemory ( tmp );
+ grammar::LeftRG < std::string, int > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
+
+ CPPUNIT_ASSERT( grammar == grammar2 );
+ }
+ }
+
+ {
+ grammar::LeftLG < std::string, int > grammar ( 1 );
+
+ grammar.addNonterminalSymbol ( 1 );
+ grammar.addNonterminalSymbol ( 2 );
+ grammar.addNonterminalSymbol ( 3 );
+ grammar.addTerminalSymbol ( "a" );
+ grammar.addTerminalSymbol ( "b" );
+
+ grammar.addRule ( 1, ext::make_pair ( 2, ext::vector < std::string > { "a" } ) );
+ grammar.addRule ( 2, ext::make_pair ( 3, ext::vector < std::string > { "b" } ) );
+ grammar.addRule ( 1, ext::make_pair ( 3, ext::vector < std::string > {} ) );
+ grammar.addRule ( 1, ext::make_pair ( 2, ext::vector < std::string > { "a", "a", "a" } ) );
+
+ CPPUNIT_ASSERT( grammar == grammar );
+ {
+ ext::deque<sax::Token> tokens = factory::XmlDataFactory::toTokens(grammar);
+ std::string tmp = sax::SaxComposeInterface::composeMemory ( tokens );
+
+ std::cout << tmp << std::endl;
+
+ ext::deque<sax::Token> tokens2 = sax::SaxParseInterface::parseMemory ( tmp );
+ grammar::LeftLG < std::string, int > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
+
+ CPPUNIT_ASSERT( grammar == grammar2 );
+ }
+ }
}
void GrammarTest::testContextFreeParser() {
@@ -180,19 +237,19 @@ void GrammarTest::testContextFreeParser() {
}
}
{
- grammar::EpsilonFreeCFG < > grammar(DefaultSymbolType(1));
+ grammar::EpsilonFreeCFG < std::string, int > grammar ( 1 );
- grammar.addNonterminalSymbol(DefaultSymbolType(1));
- grammar.addNonterminalSymbol(DefaultSymbolType(2));
- grammar.addNonterminalSymbol(DefaultSymbolType(3));
- grammar.addTerminalSymbol(DefaultSymbolType("a"));
- grammar.addTerminalSymbol(DefaultSymbolType("b"));
- grammar.setGeneratesEpsilon(true);
+ grammar.addNonterminalSymbol ( 1 );
+ grammar.addNonterminalSymbol ( 2 );
+ grammar.addNonterminalSymbol ( 3 );
+ grammar.addTerminalSymbol ( "a" );
+ grammar.addTerminalSymbol ( "b" );
+ grammar.setGeneratesEpsilon ( true );
- grammar.addRule(DefaultSymbolType(1), ext::vector<DefaultSymbolType> {DefaultSymbolType("a"), DefaultSymbolType(2)});
- grammar.addRule(DefaultSymbolType(2), ext::vector<DefaultSymbolType> {DefaultSymbolType("b"), DefaultSymbolType(3)});
- grammar.addRule(DefaultSymbolType(1), ext::vector<DefaultSymbolType> {DefaultSymbolType(3)});
- grammar.addRule(DefaultSymbolType(1), ext::vector<DefaultSymbolType> {DefaultSymbolType("a"), DefaultSymbolType("a"), DefaultSymbolType("a"), DefaultSymbolType(2)});
+ grammar.addRule ( 1, ext::vector < ext::variant < std::string, int > > { { "a" }, { 2 } } );
+ grammar.addRule ( 2, ext::vector < ext::variant < std::string, int > > { { "b" }, { 3 } } );
+ grammar.addRule ( 1, ext::vector < ext::variant < std::string, int > > { { 3 } } );
+ grammar.addRule ( 1, ext::vector < ext::variant < std::string, int > > { { "a" }, { "a" }, { "a" }, { 2 } } );
CPPUNIT_ASSERT( grammar == grammar );
{
@@ -200,25 +257,25 @@ void GrammarTest::testContextFreeParser() {
std::string tmp = sax::SaxComposeInterface::composeMemory ( tokens );
ext::deque<sax::Token> tokens2 = sax::SaxParseInterface::parseMemory ( tmp );
- grammar::EpsilonFreeCFG < > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
+ grammar::EpsilonFreeCFG < std::string, int > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
CPPUNIT_ASSERT( grammar == grammar2 );
}
}
{
- grammar::CFG < > grammar(DefaultSymbolType(1));
+ grammar::CFG < std::string, int > grammar ( 1 );
- grammar.addNonterminalSymbol(DefaultSymbolType(1));
- grammar.addNonterminalSymbol(DefaultSymbolType(2));
- grammar.addNonterminalSymbol(DefaultSymbolType(3));
- grammar.addTerminalSymbol(DefaultSymbolType("a"));
- grammar.addTerminalSymbol(DefaultSymbolType("b"));
+ grammar.addNonterminalSymbol ( 1 );
+ grammar.addNonterminalSymbol ( 2 );
+ grammar.addNonterminalSymbol ( 3 );
+ grammar.addTerminalSymbol ( "a" );
+ grammar.addTerminalSymbol ( "b" );
- grammar.addRule(DefaultSymbolType(1), ext::vector<DefaultSymbolType> {DefaultSymbolType("a"), DefaultSymbolType(2)});
- grammar.addRule(DefaultSymbolType(2), ext::vector<DefaultSymbolType> {DefaultSymbolType("b"), DefaultSymbolType(3)});
- grammar.addRule(DefaultSymbolType(1), ext::vector<DefaultSymbolType> {DefaultSymbolType(3)});
- grammar.addRule(DefaultSymbolType(1), ext::vector<DefaultSymbolType> {DefaultSymbolType("a"), DefaultSymbolType("a"), DefaultSymbolType("a"), DefaultSymbolType(2)});
- grammar.addRule(DefaultSymbolType(2), ext::vector<DefaultSymbolType> {});
+ grammar.addRule ( 1, ext::vector < ext::variant < std::string, int > > { { "a" }, { 2 } } );
+ grammar.addRule ( 2, ext::vector < ext::variant < std::string, int > > { { "b" }, { 3 } } );
+ grammar.addRule ( 1, ext::vector < ext::variant < std::string, int > > { { 3 } } );
+ grammar.addRule ( 1, ext::vector < ext::variant < std::string, int > > { { "a" }, { "a" }, { "a" }, { 2 } } );
+ grammar.addRule ( 2, ext::vector < ext::variant < std::string, int > > { } );
CPPUNIT_ASSERT( grammar == grammar );
{
@@ -226,25 +283,25 @@ void GrammarTest::testContextFreeParser() {
std::string tmp = sax::SaxComposeInterface::composeMemory ( tokens );
ext::deque<sax::Token> tokens2 = sax::SaxParseInterface::parseMemory ( tmp );
- grammar::CFG < > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
+ grammar::CFG < std::string, int > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
CPPUNIT_ASSERT( grammar == grammar2 );
}
}
{
- grammar::CNF < > grammar(DefaultSymbolType(1));
+ grammar::CNF < std::string, int > grammar ( 1 );
- grammar.addNonterminalSymbol(DefaultSymbolType(1));
- grammar.addNonterminalSymbol(DefaultSymbolType(2));
- grammar.addNonterminalSymbol(DefaultSymbolType(3));
- grammar.addTerminalSymbol(DefaultSymbolType("a"));
- grammar.addTerminalSymbol(DefaultSymbolType("b"));
- grammar.setGeneratesEpsilon(true);
+ grammar.addNonterminalSymbol ( 1 );
+ grammar.addNonterminalSymbol ( 2 );
+ grammar.addNonterminalSymbol ( 3 );
+ grammar.addTerminalSymbol ( "a" );
+ grammar.addTerminalSymbol ( "b" );
+ grammar.setGeneratesEpsilon ( true );
- grammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType(3), DefaultSymbolType(2)));
- grammar.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType(3), DefaultSymbolType(3)));
- grammar.addRule(DefaultSymbolType(3), DefaultSymbolType("a"));
- grammar.addRule(DefaultSymbolType(1), DefaultSymbolType("a"));
+ grammar.addRule ( 1, ext::make_pair ( 3, 2 ) );
+ grammar.addRule ( 2, ext::make_pair ( 3, 3 ) );
+ grammar.addRule ( 3, "a" );
+ grammar.addRule ( 1, "a" );
CPPUNIT_ASSERT( grammar == grammar );
{
@@ -252,25 +309,25 @@ void GrammarTest::testContextFreeParser() {
std::string tmp = sax::SaxComposeInterface::composeMemory ( tokens );
ext::deque<sax::Token> tokens2 = sax::SaxParseInterface::parseMemory ( tmp );
- grammar::CNF < > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
+ grammar::CNF < std::string, int > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
CPPUNIT_ASSERT( grammar == grammar2 );
}
}
{
- grammar::GNF < > grammar(DefaultSymbolType(1));
+ grammar::GNF < std::string, int > grammar ( 1 );
- grammar.addNonterminalSymbol(DefaultSymbolType(1));
- grammar.addNonterminalSymbol(DefaultSymbolType(2));
- grammar.addNonterminalSymbol(DefaultSymbolType(3));
- grammar.addTerminalSymbol(DefaultSymbolType("a"));
- grammar.addTerminalSymbol(DefaultSymbolType("b"));
- grammar.setGeneratesEpsilon(true);
+ grammar.addNonterminalSymbol ( 1 );
+ grammar.addNonterminalSymbol ( 2 );
+ grammar.addNonterminalSymbol ( 3 );
+ grammar.addTerminalSymbol ( "a" );
+ grammar.addTerminalSymbol ( "b" );
+ grammar.setGeneratesEpsilon ( true );
- grammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {DefaultSymbolType(2)}));
- grammar.addRule(DefaultSymbolType(2), ext::make_pair(DefaultSymbolType("b"), ext::vector<DefaultSymbolType> {DefaultSymbolType(3)}));
- grammar.addRule(DefaultSymbolType(3), ext::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {}));
- grammar.addRule(DefaultSymbolType(1), ext::make_pair(DefaultSymbolType("a"), ext::vector<DefaultSymbolType> {}));
+ grammar.addRule ( 1, ext::make_pair ( "a", ext::vector < int > { 2 } ) );
+ grammar.addRule ( 2, ext::make_pair ( "b", ext::vector < int > { 3 } ) );
+ grammar.addRule ( 3, ext::make_pair ( "a", ext::vector < int > { } ) );
+ grammar.addRule ( 1, ext::make_pair ( "a", ext::vector < int > { } ) );
CPPUNIT_ASSERT( grammar == grammar );
{
@@ -278,7 +335,7 @@ void GrammarTest::testContextFreeParser() {
std::string tmp = sax::SaxComposeInterface::composeMemory ( tokens );
ext::deque<sax::Token> tokens2 = sax::SaxParseInterface::parseMemory ( tmp );
- grammar::GNF < > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
+ grammar::GNF < std::string, int > grammar2 = factory::XmlDataFactory::fromTokens (std::move(tokens2));
CPPUNIT_ASSERT( grammar == grammar2 );
}
diff --git a/alib2data_experimental/src/grammar/parsing/LRParserTypes.h b/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
index 15a0088f2d..4d46764ce2 100644
--- a/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
+++ b/alib2data_experimental/src/grammar/parsing/LRParserTypes.h
@@ -26,9 +26,9 @@ enum class LRAction {
Accept
};
-typedef ext::map < DefaultSymbolType, ext::set < ext::pair < unsigned, ext::vector < DefaultSymbolType > > > > LR0Items;
-typedef ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, ext::pair < LRAction, ext::variant < DefaultStateType, ext::pair < DefaultSymbolType, ext::vector < DefaultSymbolType > > > > > LRActionTable;
-typedef ext::map < ext::pair < DefaultStateType, DefaultSymbolType >, DefaultStateType > LRGotoTable;
+typedef ext::map < DefaultSymbolType, ext::set < ext::pair < unsigned, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > > LR0Items;
+typedef ext::map < ext::pair < LR0Items, DefaultSymbolType >, ext::pair < LRAction, ext::variant < LR0Items, ext::pair < DefaultSymbolType, ext::vector < ext::variant < DefaultSymbolType, DefaultSymbolType > > > > > > LRActionTable;
+typedef ext::map < ext::pair < LR0Items, DefaultSymbolType >, LR0Items > LRGotoTable;
} /* namespace parsing */
diff --git a/alib2data_experimental/src/label/xml/LR0ItemsLabel.cpp b/alib2data_experimental/src/label/xml/LR0ItemsLabel.cpp
index 403cabcb4c..d038fa53e5 100644
--- a/alib2data_experimental/src/label/xml/LR0ItemsLabel.cpp
+++ b/alib2data_experimental/src/label/xml/LR0ItemsLabel.cpp
@@ -17,6 +17,7 @@
#include <container/xml/ObjectsMap.h>
#include <container/xml/ObjectsSet.h>
#include <container/xml/ObjectsVector.h>
+#include <container/xml/ObjectsVariant.h>
#include <primitive/xml/Unsigned.h>
#include <registration/XmlRegistration.hpp>
diff --git a/alib2str/src/grammar/string/ContextFree/GNF.h b/alib2str/src/grammar/string/ContextFree/GNF.h
index eff82bc294..0edae27f6d 100644
--- a/alib2str/src/grammar/string/ContextFree/GNF.h
+++ b/alib2str/src/grammar/string/ContextFree/GNF.h
@@ -18,32 +18,32 @@
namespace core {
-template<class SymbolType >
-struct stringApi < grammar::GNF < SymbolType > > {
- static grammar::GNF < SymbolType > parse ( std::istream & input );
+template < class TerminalSymbolType, class NonterminalSymbolType >
+struct stringApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > > {
+ static grammar::GNF < TerminalSymbolType, NonterminalSymbolType > parse ( std::istream & input );
static bool first ( std::istream & input );
- static void compose ( std::ostream & output, const grammar::GNF < SymbolType > & grammar );
+ static void compose ( std::ostream & output, const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
};
-template<class SymbolType >
-grammar::GNF < SymbolType > stringApi < grammar::GNF < SymbolType > >::parse ( std::istream & input ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, NonterminalSymbolType > stringApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > >::parse ( std::istream & input ) {
grammar::GrammarFromStringLexer::Token token = grammar::GrammarFromStringLexer::next(input);
if(token.type != grammar::GrammarFromStringLexer::TokenType::GNF)
throw exception::CommonException("Unrecognised GNF token.");
- return grammar::GrammarFromStringParserCommon::parseCFLikeGrammar < grammar::GNF < SymbolType > > ( input );
+ return grammar::GrammarFromStringParserCommon::parseCFLikeGrammar < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > > ( input );
}
-template<class SymbolType >
-bool stringApi < grammar::GNF < SymbolType > >::first ( std::istream & input ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+bool stringApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > >::first ( std::istream & input ) {
grammar::GrammarFromStringLexer::Token token = grammar::GrammarFromStringLexer::next ( input );
bool res = token.type == grammar::GrammarFromStringLexer::TokenType::GNF;
grammar::GrammarFromStringLexer::putback ( input, token );
return res;
}
-template<class SymbolType >
-void stringApi < grammar::GNF < SymbolType > >::compose ( std::ostream & output, const grammar::GNF < SymbolType > & grammar ) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+void stringApi < grammar::GNF < TerminalSymbolType, NonterminalSymbolType > >::compose ( std::ostream & output, const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
output << "GNF";
grammar::GrammarToStringComposerCommon::composeCFLikeGrammar ( output, grammar );
}
--
GitLab