diff --git a/alib2data/src/XmlApi.cpp b/alib2data/src/XmlApi.cpp
index 493e2b9d6e7188de17096d787031ce3eb2fdcb20..ce3dccd050f6d8776c0eac35a32cc18ff2d8fa3d 100644
--- a/alib2data/src/XmlApi.cpp
+++ b/alib2data/src/XmlApi.cpp
@@ -33,13 +33,11 @@
 namespace alib {
 
 const regexp::RegExpFromXMLParser FromXMLParsers::regexpParser;
-const grammar::GrammarFromXMLParser FromXMLParsers::grammarParser;
 const graph::GraphFromXMLParser FromXMLParsers::graphParser;
 const alib::ObjectFromXMLParser FromXMLParsers::objectParser;
 const container::ContainerFromXMLParser FromXMLParsers::containerParser;
 
 const regexp::RegExpToXMLComposer ToXMLComposers::regexpComposer;
-const grammar::GrammarToXMLComposer ToXMLComposers::grammarComposer;
 const graph::GraphToXMLComposer ToXMLComposers::graphComposer;
 const alib::ObjectToXMLComposer ToXMLComposers::objectComposer;
 const container::ContainerToXMLComposer ToXMLComposers::containerComposer;
@@ -119,175 +117,6 @@ void xmlApi<alib::Object>::compose(std::deque<sax::Token>& output, const alib::O
 }
 
 
-grammar::Grammar xmlApi<grammar::Grammar>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseGrammar(input);
-}
-
-bool xmlApi<grammar::Grammar>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return FromXMLParsers::grammarParser.first(input);
-}
-
-void xmlApi<grammar::Grammar>::compose(std::deque<sax::Token>& output, const grammar::Grammar& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::LeftLG xmlApi<grammar::LeftLG>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseLeftLG(input);
-}
-
-bool xmlApi<grammar::LeftLG>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LEFT_LG);
-}
-
-void xmlApi<grammar::LeftLG>::compose(std::deque<sax::Token>& output, const grammar::LeftLG& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::LeftRG xmlApi<grammar::LeftRG>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseLeftRG(input);
-}
-
-bool xmlApi<grammar::LeftRG>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LEFT_RG);
-}
-
-void xmlApi<grammar::LeftRG>::compose(std::deque<sax::Token>& output, const grammar::LeftRG& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::RightLG xmlApi<grammar::RightLG>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseRightLG(input);
-}
-
-bool xmlApi<grammar::RightLG>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_RIGHT_LG);
-}
-
-void xmlApi<grammar::RightLG>::compose(std::deque<sax::Token>& output, const grammar::RightLG& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::RightRG xmlApi<grammar::RightRG>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseRightRG(input);
-}
-
-bool xmlApi<grammar::RightRG>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_RIGHT_RG);
-}
-
-void xmlApi<grammar::RightRG>::compose(std::deque<sax::Token>& output, const grammar::RightRG& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::LG xmlApi<grammar::LG>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseLG(input);
-}
-
-bool xmlApi<grammar::LG>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_LG);
-}
-
-void xmlApi<grammar::LG>::compose(std::deque<sax::Token>& output, const grammar::LG& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::CFG xmlApi<grammar::CFG>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseCFG(input);
-}
-
-bool xmlApi<grammar::CFG>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CFG);
-}
-
-void xmlApi<grammar::CFG>::compose(std::deque<sax::Token>& output, const grammar::CFG& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::EpsilonFreeCFG xmlApi<grammar::EpsilonFreeCFG>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseEpsilonFreeCFG(input);
-}
-
-bool xmlApi<grammar::EpsilonFreeCFG>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_EPSILON_FREE_CFG);
-}
-
-void xmlApi<grammar::EpsilonFreeCFG>::compose(std::deque<sax::Token>& output, const grammar::EpsilonFreeCFG& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::CNF xmlApi<grammar::CNF>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseCNF(input);
-}
-
-bool xmlApi<grammar::CNF>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CNF);
-}
-
-void xmlApi<grammar::CNF>::compose(std::deque<sax::Token>& output, const grammar::CNF& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::GNF xmlApi<grammar::GNF>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseGNF(input);
-}
-
-bool xmlApi<grammar::GNF>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_GNF);
-}
-
-void xmlApi<grammar::GNF>::compose(std::deque<sax::Token>& output, const grammar::GNF& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::CSG xmlApi<grammar::CSG>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseCSG(input);
-}
-
-bool xmlApi<grammar::CSG>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CSG);
-}
-
-void xmlApi<grammar::CSG>::compose(std::deque<sax::Token>& output, const grammar::CSG& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::NonContractingGrammar xmlApi<grammar::NonContractingGrammar>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseNonContractingGrammar(input);
-}
-
-bool xmlApi<grammar::NonContractingGrammar>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
-}
-
-void xmlApi<grammar::NonContractingGrammar>::compose(std::deque<sax::Token>& output, const grammar::NonContractingGrammar& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::ContextPreservingUnrestrictedGrammar xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseContextPreservingUnrestrictedGrammar(input);
-}
-
-bool xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
-}
-
-void xmlApi<grammar::ContextPreservingUnrestrictedGrammar>::compose(std::deque<sax::Token>& output, const grammar::ContextPreservingUnrestrictedGrammar& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-grammar::UnrestrictedGrammar xmlApi<grammar::UnrestrictedGrammar>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::grammarParser.parseUnrestrictedGrammar(input);
-}
-
-bool xmlApi<grammar::UnrestrictedGrammar>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
-}
-
-void xmlApi<grammar::UnrestrictedGrammar>::compose(std::deque<sax::Token>& output, const grammar::UnrestrictedGrammar& data) {
-	ToXMLComposers::grammarComposer.compose(output, data);
-}
-
-
 graph::Graph xmlApi<graph::Graph>::parse(std::deque<sax::Token>::iterator& input) {
 	return FromXMLParsers::graphParser.parseGraph(input);
 }
diff --git a/alib2data/src/XmlApi.hpp b/alib2data/src/XmlApi.hpp
index e2cfe61d774c637e266ebdcd455fa21e84e94d87..e52f7a394378144a76c4e909e29d9d24f95076b1 100644
--- a/alib2data/src/XmlApi.hpp
+++ b/alib2data/src/XmlApi.hpp
@@ -20,13 +20,11 @@
 #include "XmlTagNames.h"
 
 #include "regexp/RegExpFromXMLParser.h"
-#include "grammar/GrammarFromXMLParser.h"
 #include "graph/GraphFromXMLParser.h"
 #include "object/ObjectFromXMLParser.h"
 #include "container/ContainerFromXMLParser.hpp"
 
 #include "regexp/RegExpToXMLComposer.h"
-#include "grammar/GrammarToXMLComposer.h"
 #include "graph/GraphToXMLComposer.h"
 #include "object/ObjectToXMLComposer.h"
 #include "container/ContainerToXMLComposer.hpp"
@@ -179,105 +177,6 @@ struct xmlApi<Object> {
 };
 
 
-template<>
-struct xmlApi<grammar::Grammar> {
-	static grammar::Grammar parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::Grammar& data);
-};
-
-template<>
-struct xmlApi<grammar::LeftLG> {
-	static grammar::LeftLG parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::LeftLG& data);
-};
-
-template<>
-struct xmlApi<grammar::LeftRG> {
-	static grammar::LeftRG parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::LeftRG& data);
-};
-
-template<>
-struct xmlApi<grammar::RightLG> {
-	static grammar::RightLG parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::RightLG& data);
-};
-
-template<>
-struct xmlApi<grammar::RightRG> {
-	static grammar::RightRG parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::RightRG& data);
-};
-
-template<>
-struct xmlApi<grammar::LG> {
-	static grammar::LG parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::LG& data);
-};
-
-template<>
-struct xmlApi<grammar::CFG> {
-	static grammar::CFG parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::CFG& data);
-};
-
-template<>
-struct xmlApi<grammar::EpsilonFreeCFG> {
-	static grammar::EpsilonFreeCFG parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::EpsilonFreeCFG& data);
-};
-
-template<>
-struct xmlApi<grammar::CNF> {
-	static grammar::CNF parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::CNF& data);
-};
-
-template<>
-struct xmlApi<grammar::GNF> {
-	static grammar::GNF parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::GNF& data);
-};
-
-template<>
-struct xmlApi<grammar::CSG> {
-	static grammar::CSG parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::CSG& data);
-};
-
-template<>
-struct xmlApi<grammar::NonContractingGrammar> {
-	static grammar::NonContractingGrammar parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::NonContractingGrammar& data);
-};
-
-template<>
-struct xmlApi<grammar::ContextPreservingUnrestrictedGrammar> {
-	static grammar::ContextPreservingUnrestrictedGrammar parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::ContextPreservingUnrestrictedGrammar& data);
-};
-
-template<>
-struct xmlApi<grammar::UnrestrictedGrammar> {
-	static grammar::UnrestrictedGrammar parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const grammar::UnrestrictedGrammar& data);
-};
-
-
 template<>
 struct xmlApi<graph::Graph> {
 	static graph::Graph parse(std::deque<sax::Token>::iterator& input);
@@ -332,7 +231,6 @@ struct xmlApi<container::Container> {
 class FromXMLParsers {
 public:
 	static const regexp::RegExpFromXMLParser regexpParser;
-	static const grammar::GrammarFromXMLParser grammarParser;
 	static const graph::GraphFromXMLParser graphParser;
 	static const ObjectFromXMLParser objectParser;
 	static const container::ContainerFromXMLParser containerParser;
@@ -434,7 +332,6 @@ private:
 
 public:
 	static const regexp::RegExpToXMLComposer regexpComposer;
-	static const grammar::GrammarToXMLComposer grammarComposer;
 	static const graph::GraphToXMLComposer graphComposer;
 	static const ObjectToXMLComposer objectComposer;
 	static const container::ContainerToXMLComposer containerComposer;
diff --git a/alib2data/src/grammar/ContextFree/CFG.cpp b/alib2data/src/grammar/ContextFree/CFG.cpp
index 7162f89776a340e9c6bdc6a8a0ffb9ef0aaaefdd..2e593895dd3b36feacf4bb642c66fb7ba94bfa4f 100644
--- a/alib2data/src/grammar/ContextFree/CFG.cpp
+++ b/alib2data/src/grammar/ContextFree/CFG.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 CFG::CFG(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)) {
@@ -112,4 +118,63 @@ CFG::operator std::string () const {
 	return ss.str();
 }
 
+const std::string CFG::XML_TAG_NAME = "CFG";
+
+CFG CFG::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, CFG::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	CFG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, CFG::XML_TAG_NAME);
+	return grammar;
+}
+
+void CFG::parseRule(std::deque<sax::Token>::iterator& input, CFG& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRule(std::move(lhs), std::move(rhs));
+}
+
+void CFG::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(CFG::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+
+	out.emplace_back(CFG::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void CFG::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::CFG> CFGParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::CFG>(grammar::CFG::XML_TAG_NAME, grammar::CFG::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/ContextFree/CFG.h b/alib2data/src/grammar/ContextFree/CFG.h
index 64ab1f5710c10cfcbbfa66bedd2295c25ec59ffe..1bee09055877229f9e1d8d087824318a1cd1bb25 100644
--- a/alib2data/src/grammar/ContextFree/CFG.h
+++ b/alib2data/src/grammar/ContextFree/CFG.h
@@ -59,6 +59,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static CFG parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, CFG& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/ContextFree/CNF.cpp b/alib2data/src/grammar/ContextFree/CNF.cpp
index 875c4b960ca83958821f10ee261003f335495a1e..f47dd534de2b5933760529adf1e1be759229b50a 100644
--- a/alib2data/src/grammar/ContextFree/CNF.cpp
+++ b/alib2data/src/grammar/ContextFree/CNF.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 CNF::CNF(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)), generatesEpsilon(false) {
@@ -195,4 +201,67 @@ CNF::operator std::string () const {
 	return ss.str();
 }
 
+const std::string CNF::XML_TAG_NAME = "CNF";
+
+CNF CNF::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, CNF::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	CNF grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	bool generatesEpsilon = GrammarFromXMLParser::parseGeneratesEpsilon(input);
+	grammar.setGeneratesEpsilon(generatesEpsilon);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, CNF::XML_TAG_NAME);
+	return grammar;
+}
+
+void CNF::parseRule(std::deque<sax::Token>::iterator& input, CNF& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(input);
+	grammar.addRule(std::move(lhs), std::move(rhs));
+}
+
+void CNF::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(CNF::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+	GrammarToXMLComposer::composeGeneratesEpsilon(out, this->getGeneratesEpsilon());
+
+	out.emplace_back(CNF::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void CNF::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::CNF> CNFParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::CNF>(grammar::CNF::XML_TAG_NAME, grammar::CNF::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/ContextFree/CNF.h b/alib2data/src/grammar/ContextFree/CNF.h
index 0ed6f66d04c7f03f4c13b790bf86a8e472fd7f8a..5097cf5554cfa500cda0e67b9c7bb320c3443b4d 100644
--- a/alib2data/src/grammar/ContextFree/CNF.h
+++ b/alib2data/src/grammar/ContextFree/CNF.h
@@ -68,6 +68,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static CNF parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, CNF& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.cpp b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.cpp
index 0df67d4f80d82fa55442b2a347a2f75961abe190..a84fd6af840260d51c2fe6b92615ea5462b75271 100644
--- a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.cpp
+++ b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 EpsilonFreeCFG::EpsilonFreeCFG(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(initialSymbol), generatesEpsilon(false) {
@@ -146,4 +152,67 @@ EpsilonFreeCFG::operator std::string () const {
 	return ss.str();
 }
 
+const std::string EpsilonFreeCFG::XML_TAG_NAME = "EpsilonFreeCFG";
+
+EpsilonFreeCFG EpsilonFreeCFG::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, EpsilonFreeCFG::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	EpsilonFreeCFG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	bool generatesEpsilon = GrammarFromXMLParser::parseGeneratesEpsilon(input);
+	grammar.setGeneratesEpsilon(generatesEpsilon);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, EpsilonFreeCFG::XML_TAG_NAME);
+	return grammar;
+}
+
+void EpsilonFreeCFG::parseRule(std::deque<sax::Token>::iterator& input, EpsilonFreeCFG& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRule(std::move(lhs), std::move(rhs));
+}
+
+void EpsilonFreeCFG::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(EpsilonFreeCFG::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+	GrammarToXMLComposer::composeGeneratesEpsilon(out, this->getGeneratesEpsilon());
+
+	out.emplace_back(EpsilonFreeCFG::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void EpsilonFreeCFG::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::EpsilonFreeCFG> EpsilonFreeCFGParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::EpsilonFreeCFG>(grammar::EpsilonFreeCFG::XML_TAG_NAME, grammar::EpsilonFreeCFG::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
index dd49d377dbb35518e4471e95ecc1f0b167ec7ed4..3c2b24dcbe8aa9f0892b785212cd826cb21b3e62 100644
--- a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
+++ b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
@@ -63,6 +63,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static EpsilonFreeCFG parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, EpsilonFreeCFG& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/ContextFree/GNF.cpp b/alib2data/src/grammar/ContextFree/GNF.cpp
index ce821d8e23ab2e02b15014a544ed0afa0c7871f7..f003d0df9290f51afc3b0dfd5398dcfd958c128c 100644
--- a/alib2data/src/grammar/ContextFree/GNF.cpp
+++ b/alib2data/src/grammar/ContextFree/GNF.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 GNF::GNF(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(initialSymbol), generatesEpsilon(false) {
@@ -153,4 +159,67 @@ GNF::operator std::string () const {
 	return ss.str();
 }
 
+const std::string GNF::XML_TAG_NAME = "GNF";
+
+GNF GNF::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, GNF::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	GNF grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	bool generatesEpsilon = GrammarFromXMLParser::parseGeneratesEpsilon(input);
+	grammar.setGeneratesEpsilon(generatesEpsilon);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, GNF::XML_TAG_NAME);
+	return grammar;
+}
+
+void GNF::parseRule(std::deque<sax::Token>::iterator& input, GNF& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> rhs = GrammarFromXMLParser::parseRuleGNFRHS(input);
+	grammar.addRule(std::move(lhs), std::move(rhs));
+}
+
+void GNF::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(GNF::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+	GrammarToXMLComposer::composeGeneratesEpsilon(out, this->getGeneratesEpsilon());
+
+	out.emplace_back(GNF::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void GNF::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleGNFRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::GNF> GNFParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::GNF>(grammar::GNF::XML_TAG_NAME, grammar::GNF::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/ContextFree/GNF.h b/alib2data/src/grammar/ContextFree/GNF.h
index ceaa05d681dccfc9709cc1b01caa725bba44ff23..7d31a66b6a2edaed445bc3c2a93f19565e3e8e1b 100644
--- a/alib2data/src/grammar/ContextFree/GNF.h
+++ b/alib2data/src/grammar/ContextFree/GNF.h
@@ -63,6 +63,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static GNF parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, GNF& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/ContextFree/LG.cpp b/alib2data/src/grammar/ContextFree/LG.cpp
index e5ed22a382cc498ff04ea2b7056968a950866056..9824423ce244b283f63514d4364a8d9a992aaef2 100644
--- a/alib2data/src/grammar/ContextFree/LG.cpp
+++ b/alib2data/src/grammar/ContextFree/LG.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 LG::LG(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)) {
@@ -203,4 +209,63 @@ LG::operator std::string () const {
 	return ss.str();
 }
 
+const std::string LG::XML_TAG_NAME = "LG";
+
+LG LG::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, LG::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	LG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, LG::XML_TAG_NAME);
+	return grammar;
+}
+
+void LG::parseRule(std::deque<sax::Token>::iterator& input, LG& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRawRule(std::move(lhs), std::move(rhs));
+}
+
+void LG::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(LG::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+
+	out.emplace_back(LG::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void LG::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleLGRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::LG> LGParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::LG>(grammar::LG::XML_TAG_NAME, grammar::LG::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/ContextFree/LG.h b/alib2data/src/grammar/ContextFree/LG.h
index d99df0845b6626f03690a189987e6028ab346680..dac536aa5b0c9d496046a5d80180eb62630eea9d 100644
--- a/alib2data/src/grammar/ContextFree/LG.h
+++ b/alib2data/src/grammar/ContextFree/LG.h
@@ -64,6 +64,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static LG parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, LG& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/ContextSensitive/CSG.cpp b/alib2data/src/grammar/ContextSensitive/CSG.cpp
index 99cb1f35be2c97fdf10309465156440372443aef..0f79d9fc5fff6de115da9005da1f9dd1554ae2a1 100644
--- a/alib2data/src/grammar/ContextSensitive/CSG.cpp
+++ b/alib2data/src/grammar/ContextSensitive/CSG.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 CSG::CSG(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)), generatesEpsilon(false) {
@@ -142,4 +148,71 @@ CSG::operator std::string () const {
 	return ss.str();
 }
 
+const std::string CSG::XML_TAG_NAME = "CSG";
+
+CSG CSG::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, CSG::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	CSG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	bool generatesEpsilon = GrammarFromXMLParser::parseGeneratesEpsilon(input);
+	grammar.setGeneratesEpsilon(generatesEpsilon);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, CSG::XML_TAG_NAME);
+	return grammar;
+}
+
+void CSG::parseRule(std::deque<sax::Token>::iterator& input, CSG& grammar) {
+	std::vector<alphabet::Symbol> lContext = GrammarFromXMLParser::parseRuleLContext(input);
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rContext = GrammarFromXMLParser::parseRuleRContext(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
+}
+
+void CSG::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(CSG::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+	GrammarToXMLComposer::composeGeneratesEpsilon(out, this->getGeneratesEpsilon());
+
+	out.emplace_back(CSG::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void CSG::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleLContext(out, std::get<0>(rule.first));
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, std::get<1>(rule.first));
+			GrammarToXMLComposer::composeRuleRContext(out, std::get<2>(rule.first));
+			GrammarToXMLComposer::composeRuleRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::CSG> CSGParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::CSG>(grammar::CSG::XML_TAG_NAME, grammar::CSG::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/ContextSensitive/CSG.h b/alib2data/src/grammar/ContextSensitive/CSG.h
index a2c020a78bde6f503b7995ea9a60556c71039ef3..f0bdee5d2700ac0132e2886dd474a8be92e86fea 100644
--- a/alib2data/src/grammar/ContextSensitive/CSG.h
+++ b/alib2data/src/grammar/ContextSensitive/CSG.h
@@ -57,6 +57,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static CSG parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, CSG& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.cpp b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.cpp
index d153d4f79d2a90622fd0fe81ae74f8276ca6865a..4c717a730c5a38d6025e0ac4f9c61c1b3064e826 100644
--- a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.cpp
+++ b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 NonContractingGrammar::NonContractingGrammar(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(initialSymbol), generatesEpsilon(false) {
@@ -123,4 +129,67 @@ NonContractingGrammar::operator std::string () const {
 	return ss.str();
 }
 
+const std::string NonContractingGrammar::XML_TAG_NAME = "NonContractingGrammar";
+
+NonContractingGrammar NonContractingGrammar::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, NonContractingGrammar::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	NonContractingGrammar grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	bool generatesEpsilon = GrammarFromXMLParser::parseGeneratesEpsilon(input);
+	grammar.setGeneratesEpsilon(generatesEpsilon);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, NonContractingGrammar::XML_TAG_NAME);
+	return grammar;
+}
+
+void NonContractingGrammar::parseRule(std::deque<sax::Token>::iterator& input, NonContractingGrammar& grammar) {
+	std::vector<alphabet::Symbol> lhs = GrammarFromXMLParser::parseRuleLHS(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRule(std::move(lhs), std::move(rhs));
+}
+
+void NonContractingGrammar::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(NonContractingGrammar::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+	GrammarToXMLComposer::composeGeneratesEpsilon(out, this->getGeneratesEpsilon());
+
+	out.emplace_back(NonContractingGrammar::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void NonContractingGrammar::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::NonContractingGrammar> NonContractingGrammarParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::NonContractingGrammar>(grammar::NonContractingGrammar::XML_TAG_NAME, grammar::NonContractingGrammar::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
index c1240a74154782c948592e254fdede680946a6f7..7d7547ad0579035f01772ae8adcf7a4805a6394a 100644
--- a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
+++ b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
@@ -57,6 +57,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static NonContractingGrammar parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, NonContractingGrammar& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/GrammarBase.h b/alib2data/src/grammar/GrammarBase.h
index 4f6727ade343ba11a1e8fcf7d608226d4a27aeaa..e1ba1a3c361fae1f752ea604fe4942463df13e2a 100644
--- a/alib2data/src/grammar/GrammarBase.h
+++ b/alib2data/src/grammar/GrammarBase.h
@@ -43,6 +43,7 @@ public:
 	virtual GrammarBase* clone() const = 0;
 	virtual GrammarBase* plunder() && = 0;
 
+	virtual void compose(std::deque<sax::Token>& out) const = 0;
 };
 
 class VisitableConstRGBase : public VisitableGrammarBase::const_visitor_type {
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.cpp b/alib2data/src/grammar/GrammarFromXMLParser.cpp
deleted file mode 100644
index 54214f11d3183aa3132e68f08be5cb687e4e0879..0000000000000000000000000000000000000000
--- a/alib2data/src/grammar/GrammarFromXMLParser.cpp
+++ /dev/null
@@ -1,537 +0,0 @@
-/*
- * GrammarFromXMLParser.cpp
- *
- *  Created on: Oct 12, 2013
- *      Author: Jan Travnicek
- */
-
-#include "GrammarFromXMLParser.h"
-#include "../sax/ParserException.h"
-#include "../XmlApi.hpp"
-
-#include "Grammar.h"
-#include "GrammarClasses.h"
-
-namespace grammar {
-
-Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token>::iterator& input) const {
-	return parseGrammar(input, std::set<FEATURES>({FEATURES::LEFT_LG, FEATURES::LEFT_RG, FEATURES::RIGHT_LG, FEATURES::RIGHT_RG, FEATURES::LG, FEATURES::CFG, FEATURES::EPSILON_FREE_CFG, FEATURES::CNF, FEATURES::GNF, FEATURES::CSG, FEATURES::NON_CONTRACTING_GRAMMAR, FEATURES::CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, FEATURES::UNRESTRICTED_GRAMMAR}));
-}
-
-Grammar GrammarFromXMLParser::parseGrammar(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
-	if(alib::xmlApi<UnrestrictedGrammar>::first(input)) {
-		if(!features.count(FEATURES::UNRESTRICTED_GRAMMAR)) throw exception::AlibException();
-		return Grammar(parseUnrestrictedGrammar(input));
-	} else if(alib::xmlApi<ContextPreservingUnrestrictedGrammar>::first(input)) {
-		if(!features.count(FEATURES::CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR)) throw exception::AlibException();
-		return Grammar(parseContextPreservingUnrestrictedGrammar(input));
-	} else if(alib::xmlApi<NonContractingGrammar>::first(input)) {
-		if(!features.count(FEATURES::NON_CONTRACTING_GRAMMAR)) throw exception::AlibException();
-		return Grammar(parseNonContractingGrammar(input));
-	} else if(alib::xmlApi<CSG>::first(input)) {
-		if(!features.count(FEATURES::CSG)) throw exception::AlibException();
-		return Grammar(parseCSG(input));
-	} else if(alib::xmlApi<GNF>::first(input)) {
-		if(!features.count(FEATURES::GNF)) throw exception::AlibException();
-		return Grammar(parseGNF(input));
-	} else if(alib::xmlApi<CNF>::first(input)) {
-		if(!features.count(FEATURES::CNF)) throw exception::AlibException();
-		return Grammar(parseCNF(input));
-	} else if(alib::xmlApi<EpsilonFreeCFG>::first(input)) {
-		if(!features.count(FEATURES::EPSILON_FREE_CFG)) throw exception::AlibException();
-		return Grammar(parseEpsilonFreeCFG(input));
-	} else if(alib::xmlApi<CFG>::first(input)) {
-		if(!features.count(FEATURES::CFG)) throw exception::AlibException();
-		return Grammar(parseCFG(input));
-	} else if(alib::xmlApi<LG>::first(input)) {
-		if(!features.count(FEATURES::LG)) throw exception::AlibException();
-		return Grammar(parseLG(input));
-	} else if(alib::xmlApi<RightRG>::first(input)) {
-		if(!features.count(FEATURES::RIGHT_RG)) throw exception::AlibException();
-		return Grammar(parseRightRG(input));
-	} else if(alib::xmlApi<RightLG>::first(input)) {
-		if(!features.count(FEATURES::RIGHT_LG)) throw exception::AlibException();
-		return Grammar(parseRightLG(input));
-	} else if(alib::xmlApi<LeftRG>::first(input)) {
-		if(!features.count(FEATURES::LEFT_RG)) throw exception::AlibException();
-		return Grammar(parseLeftRG(input));
-	} else if(alib::xmlApi<LeftLG>::first(input)) {
-		if(!features.count(FEATURES::LEFT_LG)) throw exception::AlibException();
-		return Grammar(parseLeftLG(input));
-	} else
-		throw sax::ParserException(sax::Token("Grammar / UnrestrictedGrammar", sax::Token::TokenType::START_ELEMENT), *input);
-}
-
-bool GrammarFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
-	if(alib::xmlApi<UnrestrictedGrammar>::first(input) || alib::xmlApi<ContextPreservingUnrestrictedGrammar>::first(input) || alib::xmlApi<NonContractingGrammar>::first(input) || alib::xmlApi<CSG>::first(input) || alib::xmlApi<GNF>::first(input) || alib::xmlApi<CNF>::first(input) || alib::xmlApi<EpsilonFreeCFG>::first(input) || alib::xmlApi<CFG>::first(input) || alib::xmlApi<LG>::first(input) || alib::xmlApi<RightRG>::first(input) || alib::xmlApi<RightLG>::first(input) || alib::xmlApi<LeftLG>::first(input) || alib::xmlApi<LeftRG>::first(input)) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	UnrestrictedGrammar grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR);
-	return grammar;
-}
-
-ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservingUnrestrictedGrammar(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	ContextPreservingUnrestrictedGrammar grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR);
-	return grammar;
-}
-
-NonContractingGrammar GrammarFromXMLParser::parseNonContractingGrammar(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	NonContractingGrammar grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	bool generatesEpsilon = parseGeneratesEpsilon(input);
-	grammar.setGeneratesEpsilon(generatesEpsilon);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR);
-	return grammar;
-}
-
-CSG GrammarFromXMLParser::parseCSG(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CSG);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	CSG grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	bool generatesEpsilon = parseGeneratesEpsilon(input);
-	grammar.setGeneratesEpsilon(generatesEpsilon);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_CSG);
-	return grammar;
-}
-
-GNF GrammarFromXMLParser::parseGNF(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_GNF);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	GNF grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	bool generatesEpsilon = parseGeneratesEpsilon(input);
-	grammar.setGeneratesEpsilon(generatesEpsilon);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_GNF);
-	return grammar;
-}
-
-CNF GrammarFromXMLParser::parseCNF(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CNF);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	CNF grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	bool generatesEpsilon = parseGeneratesEpsilon(input);
-	grammar.setGeneratesEpsilon(generatesEpsilon);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_CNF);
-	return grammar;
-}
-
-EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_EPSILON_FREE_CFG);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	EpsilonFreeCFG grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	bool generatesEpsilon = parseGeneratesEpsilon(input);
-	grammar.setGeneratesEpsilon(generatesEpsilon);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_EPSILON_FREE_CFG);
-	return grammar;
-}
-
-CFG GrammarFromXMLParser::parseCFG(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_CFG);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	CFG grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_CFG);
-	return grammar;
-}
-
-LG GrammarFromXMLParser::parseLG(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LG);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	LG grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_LG);
-	return grammar;
-}
-
-RightRG GrammarFromXMLParser::parseRightRG(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_RIGHT_RG);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	RightRG grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	bool generatesEpsilon = parseGeneratesEpsilon(input);
-	grammar.setGeneratesEpsilon(generatesEpsilon);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_RIGHT_RG);
-	return grammar;
-}
-
-RightLG GrammarFromXMLParser::parseRightLG(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_RIGHT_LG);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	RightLG grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_RIGHT_LG);
-	return grammar;
-}
-
-LeftRG GrammarFromXMLParser::parseLeftRG(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LEFT_RG);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	LeftRG grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	bool generatesEpsilon = parseGeneratesEpsilon(input);
-	grammar.setGeneratesEpsilon(generatesEpsilon);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_LEFT_RG);
-	return grammar;
-}
-
-LeftLG GrammarFromXMLParser::parseLeftLG(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAMMAR_LEFT_LG);
-
-	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
-	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
-	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
-
-	LeftLG grammar(std::move(initialSymbol));
-	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
-	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
-
-	parseRules(input, grammar);
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAMMAR_LEFT_LG);
-	return grammar;
-}
-
-
-std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input) const {
-	std::set<alphabet::Symbol> inputSymbols;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "nonterminalAlphabet");
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		inputSymbols.insert(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "nonterminalAlphabet");
-	return inputSymbols;
-}
-
-std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::deque<sax::Token>::iterator& input) const {
-	std::set<alphabet::Symbol> inputSymbols;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "terminalAlphabet");
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		inputSymbols.insert(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "terminalAlphabet");
-	return inputSymbols;
-}
-
-alphabet::Symbol GrammarFromXMLParser::parseInitialSymbol(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialSymbol");
-	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialSymbol");
-	return blank;
-}
-
-bool GrammarFromXMLParser::parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input) const {
-	bool generatesEpsilon;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "generatesEpsilon");
-	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "true")) {
-		++input;
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "true");
-		generatesEpsilon = true;
-	} else {
-		popToken(input, sax::Token::TokenType::START_ELEMENT, "false");
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "false");
-		generatesEpsilon = false;
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "generatesEpsilon");
-	return generatesEpsilon;
-}
-
-template<class T>
-void GrammarFromXMLParser::parseRules(std::deque<sax::Token>::iterator& input, T& grammar) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "rules");
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		popToken(input, sax::Token::TokenType::START_ELEMENT, "rule");
-		parseRule(input, grammar);
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "rule");
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "rules");
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, UnrestrictedGrammar& grammar) const {
-	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, ContextPreservingUnrestrictedGrammar& grammar) const {
-	std::vector<alphabet::Symbol> lContext = parseRuleLContext(input);
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, NonContractingGrammar& grammar) const {
-	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, CSG& grammar) const {
-	std::vector<alphabet::Symbol> lContext = parseRuleLContext(input);
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::vector<alphabet::Symbol> rContext = parseRuleRContext(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, GNF& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> rhs = parseRuleGNFRHS(input);
-	grammar.addRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, CNF& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
-	grammar.addRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, EpsilonFreeCFG& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, CFG& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, LG& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRawRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, RightRG& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
-	grammar.addRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, RightLG& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRawRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, LeftRG& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = parseRuleOneOrTwoSymbolsRHS(input);
-	grammar.addRule(std::move(lhs), std::move(rhs));
-}
-
-void GrammarFromXMLParser::parseRule(std::deque<sax::Token>::iterator& input, LeftLG& grammar) const {
-	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRawRule(std::move(lhs), std::move(rhs));
-}
-
-
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::deque<sax::Token>::iterator& input) const {
-	std::vector<alphabet::Symbol> lContext;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "lContext");
-	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		++input;
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
-	} else while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		lContext.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "lContext");
-	return lContext;
-}
-
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::deque<sax::Token>::iterator& input) const {
-	std::vector<alphabet::Symbol> lhs;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
-	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		++input;
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
-	} else while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		lhs.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
-	return lhs;
-}
-
-alphabet::Symbol GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
-	alphabet::Symbol lhs = alib::xmlApi<alphabet::Symbol>::parse(input);
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
-	return lhs;
-}
-
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::deque<sax::Token>::iterator& input) const {
-	std::vector<alphabet::Symbol> rContext;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "rContext");
-	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		++input;
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
-	} else while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		rContext.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "rContext");
-	return rContext;
-}
-
-std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser::parseRuleGNFRHS(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
-	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
-	std::vector<alphabet::Symbol> second;
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		second.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-	return std::make_pair(std::move(first), std::move(second));
-}
-
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::deque<sax::Token>::iterator& input) const {
-	std::vector<alphabet::Symbol> rhs;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
-	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		++input;
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
-	} else while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		rhs.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-	return rhs;
-}
-
-std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
-	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
-	if(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		alphabet::Symbol second = alib::xmlApi<alphabet::Symbol>::parse(input);
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::make_pair(std::move(first), std::move(second)));
-	} else {
-		popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::move(first));
-	}
-}
-
-} /* namespace grammar */
-
diff --git a/alib2data/src/grammar/GrammarFromXMLParser.h b/alib2data/src/grammar/GrammarFromXMLParser.h
deleted file mode 100644
index c4262d2b1c035f183333648505c6da1c70be6d53..0000000000000000000000000000000000000000
--- a/alib2data/src/grammar/GrammarFromXMLParser.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * GrammarFromXMLParser.h
- *
- *  Created on: Oct 12, 2013
- *      Author: Martin Zak
- */
-
-#ifndef GRAMMAR_FROM_XML_PARSER_H_
-#define GRAMMAR_FROM_XML_PARSER_H_
-
-#include "../sax/FromXMLParserHelper.h"
-#include <deque>
-#include <set>
-#include <variant>
-#include <vector>
-#include "GrammarFeatures.h"
-#include "../alphabet/SymbolFeatures.h"
-#include "../XmlApiBase.h"
-
-namespace grammar {
-
-/**
- * Parser used to get general FSM or EpsilonNFA, NFA, DFA from XML parsed into list of Tokens.
- */
-class GrammarFromXMLParser : public sax::FromXMLParserHelper {
-public:
-	GrammarFromXMLParser() {}
-
-private:
-	std::set<alphabet::Symbol> parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input) const;
-	std::set<alphabet::Symbol> parseTerminalAlphabet(std::deque<sax::Token>::iterator& input) const;
-	alphabet::Symbol parseInitialSymbol(std::deque<sax::Token>::iterator& input) const;
-	bool parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input) const;
-
-	std::vector<alphabet::Symbol> parseRuleLContext(std::deque<sax::Token>::iterator& input) const;
-	std::vector<alphabet::Symbol> parseRuleLHS(std::deque<sax::Token>::iterator& input) const;
-	std::vector<alphabet::Symbol> parseRuleRContext(std::deque<sax::Token>::iterator& input) const;
-	alphabet::Symbol parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input) const;
-	std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> parseRuleGNFRHS(std::deque<sax::Token>::iterator& input) const;
-	std::vector<alphabet::Symbol> parseRuleRHS(std::deque<sax::Token>::iterator& input) const;
-	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) const;
-
-	template<class T>
-	void parseRules(std::deque<sax::Token>::iterator& input, T& grammar) const;
-
-	void parseRule(std::deque<sax::Token>::iterator& input, UnrestrictedGrammar& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, ContextPreservingUnrestrictedGrammar& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, NonContractingGrammar& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, CSG& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, GNF& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, CNF& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, EpsilonFreeCFG& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, CFG& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, LG& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, RightRG& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, RightLG& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, LeftRG& grammar) const;
-	void parseRule(std::deque<sax::Token>::iterator& input, LeftLG& grammar) const;
-
-	Grammar parseGrammar(std::deque<sax::Token>::iterator& input) const;
-	Grammar parseGrammar(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
-
-	UnrestrictedGrammar parseUnrestrictedGrammar(std::deque<sax::Token>::iterator& input) const;
-	ContextPreservingUnrestrictedGrammar parseContextPreservingUnrestrictedGrammar(std::deque<sax::Token>::iterator& input) const;
-	NonContractingGrammar parseNonContractingGrammar(std::deque<sax::Token>::iterator& input) const;
-	CSG parseCSG(std::deque<sax::Token>::iterator& input) const;
-	GNF parseGNF(std::deque<sax::Token>::iterator& input) const;
-	CNF parseCNF(std::deque<sax::Token>::iterator& input) const;
-	EpsilonFreeCFG parseEpsilonFreeCFG(std::deque<sax::Token>::iterator& input) const;
-	CFG parseCFG(std::deque<sax::Token>::iterator& input) const;
-	LG parseLG(std::deque<sax::Token>::iterator& input) const;
-	RightRG parseRightRG(std::deque<sax::Token>::iterator& input) const;
-	RightLG parseRightLG(std::deque<sax::Token>::iterator& input) const;
-	LeftRG parseLeftRG(std::deque<sax::Token>::iterator& input) const;
-	LeftLG parseLeftLG(std::deque<sax::Token>::iterator& input) const;
-
-	template<typename T, typename Enable> friend struct alib::xmlApi;
-public:
-	bool first(const std::deque<sax::Token>::const_iterator& input) const;
-};
-
-} /* namespace grammar */
-
-#endif /* GRAMMAR_FROM_XML_PARSER_H_ */
-
diff --git a/alib2data/src/grammar/GrammarToXMLComposer.cpp b/alib2data/src/grammar/GrammarToXMLComposer.cpp
deleted file mode 100644
index 38df7374cef142993830b4f53ce9211a60997291..0000000000000000000000000000000000000000
--- a/alib2data/src/grammar/GrammarToXMLComposer.cpp
+++ /dev/null
@@ -1,575 +0,0 @@
-/*
- * GrammarToXMLComposer.cpp
- *
- *  Created on: Nov 11, 2013
- *      Author: Jan Travnicek
- */
-
-#include "GrammarToXMLComposer.h"
-
-#include "../XmlApi.hpp"
-
-#include "Grammar.h"
-#include "GrammarClasses.h"
-
-namespace grammar {
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const GrammarBase& grammar) const {
-	grammar.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const Grammar& grammar) const {
-	grammar.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LeftLG& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-
-	out.emplace_back(alib::Names::GRAMMAR_LEFT_LG, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LeftRG& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
-
-	out.emplace_back(alib::Names::GRAMMAR_LEFT_RG, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const RightLG& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-
-	out.emplace_back(alib::Names::GRAMMAR_RIGHT_LG, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const RightRG& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
-
-	out.emplace_back(alib::Names::GRAMMAR_RIGHT_RG, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const LG& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_LG, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-
-	out.emplace_back(alib::Names::GRAMMAR_LG, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CFG& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-
-	out.emplace_back(alib::Names::GRAMMAR_CFG, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
-
-	out.emplace_back(alib::Names::GRAMMAR_EPSILON_FREE_CFG, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CNF& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
-
-	out.emplace_back(alib::Names::GRAMMAR_CNF, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const GNF& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
-
-	out.emplace_back(alib::Names::GRAMMAR_GNF, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const CSG& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
-
-	out.emplace_back(alib::Names::GRAMMAR_CSG, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-	composeGeneratesEpsilon(out, grammar.getGeneratesEpsilon());
-
-	out.emplace_back(alib::Names::GRAMMAR_NON_CONTRACTING_GRAMMAR, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-
-	out.emplace_back(alib::Names::GRAMMAR_CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::compose(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const {
-	out.emplace_back(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::START_ELEMENT);
-
-	composeNonterminalAlphabet(out, grammar.getNonterminalAlphabet());
-	composeTerminalAlphabet(out, grammar.getTerminalAlphabet());
-	composeInitialSymbol(out, grammar.getInitialSymbol());
-	composeRules(out, grammar);
-
-	out.emplace_back(alib::Names::GRAMMAR_UNRESTRICTED_GRAMMAR, sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.emplace_back("terminalAlphabet", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("terminalAlphabet", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.emplace_back("initialSymbol", sax::Token::TokenType::START_ELEMENT);
-	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.emplace_back("initialSymbol", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon) const {
-	out.emplace_back("generatesEpsilon", sax::Token::TokenType::START_ELEMENT);
-	if(generatesEpsilon) {
-		out.emplace_back("true", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("true", sax::Token::TokenType::END_ELEMENT);
-	} else {
-		out.emplace_back("false", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("false", sax::Token::TokenType::END_ELEMENT);
-	}
-	out.emplace_back("generatesEpsilon", sax::Token::TokenType::END_ELEMENT);
-}
-
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleLHS(out, rule.first);
-			composeRuleRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleLContext(out, std::get<0>(rule.first));
-			composeRuleSingleSymbolLHS(out, std::get<1>(rule.first));
-			composeRuleRContext(out, std::get<2>(rule.first));
-			composeRuleRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleLHS(out, rule.first);
-			composeRuleRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CSG& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleLContext(out, std::get<0>(rule.first));
-			composeRuleSingleSymbolLHS(out, std::get<1>(rule.first));
-			composeRuleRContext(out, std::get<2>(rule.first));
-			composeRuleRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const GNF& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleGNFRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CNF& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleOneOrTwoSymbolsRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const CFG& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LG& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleLGRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const RightLG& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleRightLGRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const RightRG& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleOneOrTwoSymbolsRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LeftLG& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleLeftLGRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRules(std::deque<sax::Token>& out, const LeftRG& grammar) const {
-	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& rule : grammar.getRules()) {
-
-		for(const auto& rhs : rule.second) {
-			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
-
-			composeRuleSingleSymbolLHS(out, rule.first);
-			composeRuleOneOrTwoSymbolsRHS(out, rhs);
-
-			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
-		}
-	}
-
-	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.emplace_back("lContext", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.size() == 0) {
-		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-	} else for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("lContext", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.size() == 0) {
-		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-	} else for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.emplace_back("rContext", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.size() == 0) {
-		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-	} else for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("rContext", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
-	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.size() == 0) {
-		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-	} else for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) const {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.is<alphabet::Symbol>()) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbols.get<alphabet::Symbol>());
-	} else {
-		const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = symbols.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
-		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.first);
-		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.second);
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) const {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-
-	alib::xmlApi<alphabet::Symbol>::compose(out, symbols.first);
-
-	for (const auto& symbol : symbols.second) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.is<std::vector<alphabet::Symbol>>()) {
-		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
-		if(rhs.size() == 0) {
-			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-		} else for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-	} else {
-		const std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>& rhs = symbols.get<std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>();
-		for (const auto& symbol : std::get<0>(rhs)) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-		alib::xmlApi<alphabet::Symbol>::compose(out, std::get<1>(rhs));
-		for (const auto& symbol : std::get<2>(rhs)) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.is<std::vector<alphabet::Symbol>>()) {
-		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
-		if(rhs.size() == 0) {
-			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-		} else for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-	} else {
-		const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& rhs = symbols.get<std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>();
-		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.first);
-		for (const auto& symbol : rhs.second) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) const {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.is<std::vector<alphabet::Symbol>>()) {
-		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
-		if(rhs.size() == 0) {
-			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-		} else {
-			for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
-				alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-			}
-		}
-	} else {
-		const std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>& rhs = symbols.get<std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>();
-		for (const auto& symbol : rhs.first) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.second);
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-} /* namespace grammar */
-
diff --git a/alib2data/src/grammar/GrammarToXMLComposer.h b/alib2data/src/grammar/GrammarToXMLComposer.h
deleted file mode 100644
index 9533726342e5b2f46d57682652daca71abe8637a..0000000000000000000000000000000000000000
--- a/alib2data/src/grammar/GrammarToXMLComposer.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * GrammarToXMLComposer.h
- *
- *  Created on: Nov 11, 2013
- *      Author: Jan Travnicek
- */
-
-#ifndef GRAMMAR_TO_XML_COMPOSER_H_
-#define GRAMMAR_TO_XML_COMPOSER_H_
-
-#include <string>
-#include <deque>
-#include <vector>
-#include <tuple>
-#include <map>
-#include <set>
-#include <variant>
-#include "GrammarFeatures.h"
-#include "../alphabet/SymbolFeatures.h"
-#include "../sax/Token.h"
-#include "../XmlApiBase.h"
-
-namespace grammar {
-
-/**
- * This class contains methods to print XML representation of automata to the output stream.
- */
-class GrammarToXMLComposer {
-public:
-	GrammarToXMLComposer() {}
-
-private:
-	void composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const;
-	void composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const;
-	void composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const;
-	void composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon) const;
-	
-	void composeRules(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const CSG& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const GNF& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const CNF& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const CFG& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const LG& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const LeftLG& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const LeftRG& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const RightLG& grammar) const;
-	void composeRules(std::deque<sax::Token>& out, const RightRG& grammar) const;
-
-	void composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const;
-	void composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) const;
-	void composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) const;
-	void composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) const;
-	void composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const;
-	void composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) const;
-	void composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) const;
-	
-	/**
-	 * Prints XML representation of Grammar to the output stream.
-	 * @param grammar grammar to print
-	 * @return list of xml tokens representing the grammar
-	 */
-	void compose(std::deque<sax::Token>& out, const GrammarBase& grammar) const;
-
-	void compose(std::deque<sax::Token>& out, const Grammar& grammar) const;
-
-	void compose(std::deque<sax::Token>& out, const LeftLG& grammar) const;
-	void compose(std::deque<sax::Token>& out, const LeftRG& grammar) const;
-	void compose(std::deque<sax::Token>& out, const RightLG& grammar) const;
-	void compose(std::deque<sax::Token>& out, const RightRG& grammar) const;
-	void compose(std::deque<sax::Token>& out, const LG& grammar) const;
-	void compose(std::deque<sax::Token>& out, const CFG& grammar) const;
-	void compose(std::deque<sax::Token>& out, const EpsilonFreeCFG& grammar) const;
-	void compose(std::deque<sax::Token>& out, const CNF& grammar) const;
-	void compose(std::deque<sax::Token>& out, const GNF& grammar) const;
-	void compose(std::deque<sax::Token>& out, const CSG& grammar) const;
-	void compose(std::deque<sax::Token>& out, const NonContractingGrammar& grammar) const;
-	void compose(std::deque<sax::Token>& out, const ContextPreservingUnrestrictedGrammar& grammar) const;
-	void compose(std::deque<sax::Token>& out, const UnrestrictedGrammar& grammar) const;
-
-	template<typename T, typename Enable> friend struct alib::xmlApi;
-};
-
-} /* namespace grammar */
-
-#endif /* GRAMMAR_TO_XML_COMPOSER_H_ */
-
diff --git a/alib2data/src/grammar/Regular/LeftLG.cpp b/alib2data/src/grammar/Regular/LeftLG.cpp
index e8ae9f5998f6066cc6eba29eabac1dcba253484c..0be86983c80bf26d4f6155a24367c80a7e691108 100644
--- a/alib2data/src/grammar/Regular/LeftLG.cpp
+++ b/alib2data/src/grammar/Regular/LeftLG.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 LeftLG::LeftLG(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)) {
@@ -187,4 +193,63 @@ LeftLG::operator std::string () const {
 	return ss.str();
 }
 
+const std::string LeftLG::XML_TAG_NAME = "LeftLG";
+
+LeftLG LeftLG::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, LeftLG::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	LeftLG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, LeftLG::XML_TAG_NAME);
+	return grammar;
+}
+
+void LeftLG::parseRule(std::deque<sax::Token>::iterator& input, LeftLG& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRawRule(std::move(lhs), std::move(rhs));
+}
+
+void LeftLG::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(LeftLG::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+
+	out.emplace_back(LeftLG::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void LeftLG::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleLeftLGRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::LeftLG> LeftLGParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::LeftLG>(grammar::LeftLG::XML_TAG_NAME, grammar::LeftLG::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/Regular/LeftLG.h b/alib2data/src/grammar/Regular/LeftLG.h
index b12b4592a7aed8d369168c4c281fbfdf2f51c936..603f9914175ea9ac1daac3d83814bb01e1f4292e 100644
--- a/alib2data/src/grammar/Regular/LeftLG.h
+++ b/alib2data/src/grammar/Regular/LeftLG.h
@@ -64,6 +64,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static LeftLG parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, LeftLG& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/Regular/LeftRG.cpp b/alib2data/src/grammar/Regular/LeftRG.cpp
index 1299f241d9364592446fb2bbe453d3835f274188..5e24e2f4ee0ab410b25b4754c1655cde6e07dc96 100644
--- a/alib2data/src/grammar/Regular/LeftRG.cpp
+++ b/alib2data/src/grammar/Regular/LeftRG.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 LeftRG::LeftRG(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)), generatesEpsilon(false) {
@@ -192,4 +198,67 @@ LeftRG::operator std::string () const {
 	return ss.str();
 }
 
+const std::string LeftRG::XML_TAG_NAME = "LeftRG";
+
+LeftRG LeftRG::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, LeftRG::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	LeftRG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	bool generatesEpsilon = GrammarFromXMLParser::parseGeneratesEpsilon(input);
+	grammar.setGeneratesEpsilon(generatesEpsilon);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, LeftRG::XML_TAG_NAME);
+	return grammar;
+}
+
+void LeftRG::parseRule(std::deque<sax::Token>::iterator& input, LeftRG& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(input);
+	grammar.addRule(std::move(lhs), std::move(rhs));
+}
+
+void LeftRG::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(LeftRG::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+	GrammarToXMLComposer::composeGeneratesEpsilon(out, this->getGeneratesEpsilon());
+
+	out.emplace_back(LeftRG::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void LeftRG::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::LeftRG> LeftRGParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::LeftRG>(grammar::LeftRG::XML_TAG_NAME, grammar::LeftRG::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/Regular/LeftRG.h b/alib2data/src/grammar/Regular/LeftRG.h
index 13e9e2aa450b5b442f1b684602b96f1866c3a683..56a6a6fa30d4ce92a55286855abe445819763905 100644
--- a/alib2data/src/grammar/Regular/LeftRG.h
+++ b/alib2data/src/grammar/Regular/LeftRG.h
@@ -151,6 +151,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static LeftRG parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, LeftRG& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/Regular/RightLG.cpp b/alib2data/src/grammar/Regular/RightLG.cpp
index f15aaddbf10a3708a297444b74a9215010775d2c..e4410d3dbab373aa3579d574271a26176c60f20c 100644
--- a/alib2data/src/grammar/Regular/RightLG.cpp
+++ b/alib2data/src/grammar/Regular/RightLG.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 RightLG::RightLG(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)) {
@@ -187,4 +193,63 @@ RightLG::operator std::string () const {
 	return ss.str();
 }
 
+const std::string RightLG::XML_TAG_NAME = "RightLG";
+
+RightLG RightLG::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, RightLG::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	RightLG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, RightLG::XML_TAG_NAME);
+	return grammar;
+}
+
+void RightLG::parseRule(std::deque<sax::Token>::iterator& input, RightLG& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRawRule(std::move(lhs), std::move(rhs));
+}
+
+void RightLG::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(RightLG::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+
+	out.emplace_back(RightLG::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void RightLG::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleRightLGRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::RightLG> RightLGParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::RightLG>(grammar::RightLG::XML_TAG_NAME, grammar::RightLG::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/Regular/RightLG.h b/alib2data/src/grammar/Regular/RightLG.h
index 2565037307630fe0259b803b2616fa4360b40791..1fc53bcd2b275359176154c5d345e2c44271ceab 100644
--- a/alib2data/src/grammar/Regular/RightLG.h
+++ b/alib2data/src/grammar/Regular/RightLG.h
@@ -64,6 +64,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static RightLG parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, RightLG& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/Regular/RightRG.cpp b/alib2data/src/grammar/Regular/RightRG.cpp
index 0fb6ad414e5ad7dc5653e1c234eda3907419e7b4..f324300b6776c4d4c393daf605a59296e7944942 100644
--- a/alib2data/src/grammar/Regular/RightRG.cpp
+++ b/alib2data/src/grammar/Regular/RightRG.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 RightRG::RightRG(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)), generatesEpsilon(false) {
@@ -192,4 +198,67 @@ RightRG::operator std::string () const {
 	return ss.str();
 }
 
+const std::string RightRG::XML_TAG_NAME = "RightRG";
+
+RightRG RightRG::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, RightRG::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	RightRG grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	bool generatesEpsilon = GrammarFromXMLParser::parseGeneratesEpsilon(input);
+	grammar.setGeneratesEpsilon(generatesEpsilon);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, RightRG::XML_TAG_NAME);
+	return grammar;
+}
+
+void RightRG::parseRule(std::deque<sax::Token>::iterator& input, RightRG& grammar) {
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(input);
+	grammar.addRule(std::move(lhs), std::move(rhs));
+}
+
+void RightRG::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(RightRG::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+	GrammarToXMLComposer::composeGeneratesEpsilon(out, this->getGeneratesEpsilon());
+
+	out.emplace_back(RightRG::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void RightRG::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::RightRG> RightRGParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::RightRG>(grammar::RightRG::XML_TAG_NAME, grammar::RightRG::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/Regular/RightRG.h b/alib2data/src/grammar/Regular/RightRG.h
index 5adeba57e3a06ca46ce9db8ad1495c1a08c55978..fb23086d084af628886bb20faf2bb9e4862cdd89 100644
--- a/alib2data/src/grammar/Regular/RightRG.h
+++ b/alib2data/src/grammar/Regular/RightRG.h
@@ -84,6 +84,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static RightRG parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, RightRG& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.cpp b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.cpp
index 699f874d0a431dcec34475b5d8b89bc3f401cea4..9384f837c3fee5e8bc70fee21b5da1ac3fde9d15 100644
--- a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.cpp
+++ b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 ContextPreservingUnrestrictedGrammar::ContextPreservingUnrestrictedGrammar(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)) {
@@ -127,4 +133,67 @@ ContextPreservingUnrestrictedGrammar::operator std::string () const {
 	return ss.str();
 }
 
+const std::string ContextPreservingUnrestrictedGrammar::XML_TAG_NAME = "ContextPreservingUnrestrictedGrammar";
+
+ContextPreservingUnrestrictedGrammar ContextPreservingUnrestrictedGrammar::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, ContextPreservingUnrestrictedGrammar::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	ContextPreservingUnrestrictedGrammar grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, ContextPreservingUnrestrictedGrammar::XML_TAG_NAME);
+	return grammar;
+}
+
+void ContextPreservingUnrestrictedGrammar::parseRule(std::deque<sax::Token>::iterator& input, ContextPreservingUnrestrictedGrammar& grammar) {
+	std::vector<alphabet::Symbol> lContext = GrammarFromXMLParser::parseRuleLContext(input);
+	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rContext = GrammarFromXMLParser::parseRuleRContext(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRule(std::move(lContext), std::move(lhs), std::move(rContext), std::move(rhs));
+}
+
+void ContextPreservingUnrestrictedGrammar::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(ContextPreservingUnrestrictedGrammar::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+
+	out.emplace_back(ContextPreservingUnrestrictedGrammar::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void ContextPreservingUnrestrictedGrammar::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleLContext(out, std::get<0>(rule.first));
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS(out, std::get<1>(rule.first));
+			GrammarToXMLComposer::composeRuleRContext(out, std::get<2>(rule.first));
+			GrammarToXMLComposer::composeRuleRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::ContextPreservingUnrestrictedGrammar> ContextPreservingUnrestrictedGrammarParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::ContextPreservingUnrestrictedGrammar>(grammar::ContextPreservingUnrestrictedGrammar::XML_TAG_NAME, grammar::ContextPreservingUnrestrictedGrammar::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
index 3d102e79a80aca033ac4ad98dff24a3cdded2f9d..937f6ec7f414c8bd29b5bb75366c307f78e4847f 100644
--- a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
@@ -53,6 +53,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static ContextPreservingUnrestrictedGrammar parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, ContextPreservingUnrestrictedGrammar& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.cpp b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.cpp
index 50702a8e80b25cec91073323d8b9bfdd5b99f8e7..fb66eebe36ab024abb36f3b30ff306baec7a2392 100644
--- a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.cpp
+++ b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.cpp
@@ -12,6 +12,12 @@
 
 #include "../../alphabet/Symbol.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
+#include "../Grammar.h"
+#include "../../XmlApi.hpp"
+
 namespace grammar {
 
 UnrestrictedGrammar::UnrestrictedGrammar(alphabet::Symbol initialSymbol) : TerminalNonterminalAlphabetInitialSymbol(std::move(initialSymbol)) {
@@ -108,4 +114,63 @@ UnrestrictedGrammar::operator std::string () const {
 	return ss.str();
 }
 
+const std::string UnrestrictedGrammar::XML_TAG_NAME = "UnrestrictedGrammar";
+
+UnrestrictedGrammar UnrestrictedGrammar::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, UnrestrictedGrammar::XML_TAG_NAME);
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol(input);
+
+	UnrestrictedGrammar grammar(std::move(initialSymbol));
+	grammar.setNonterminalAlphabet(std::move(nonterminalAlphabet));
+	grammar.setTerminalAlphabet(std::move(terminalAlphabet));
+
+	GrammarFromXMLParser::parseRules(input, grammar);
+
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, UnrestrictedGrammar::XML_TAG_NAME);
+	return grammar;
+}
+
+void UnrestrictedGrammar::parseRule(std::deque<sax::Token>::iterator& input, UnrestrictedGrammar& grammar) {
+	std::vector<alphabet::Symbol> lhs = GrammarFromXMLParser::parseRuleLHS(input);
+	std::vector<alphabet::Symbol> rhs = GrammarFromXMLParser::parseRuleRHS(input);
+	grammar.addRule(std::move(lhs), std::move(rhs));
+}
+
+void UnrestrictedGrammar::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(UnrestrictedGrammar::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+
+	GrammarToXMLComposer::composeNonterminalAlphabet(out, this->getNonterminalAlphabet());
+	GrammarToXMLComposer::composeTerminalAlphabet(out, this->getTerminalAlphabet());
+	GrammarToXMLComposer::composeInitialSymbol(out, this->getInitialSymbol());
+	composeRules(out);
+
+	out.emplace_back(UnrestrictedGrammar::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
+void UnrestrictedGrammar::composeRules(std::deque<sax::Token>& out) const {
+	out.emplace_back("rules", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& rule : this->getRules()) {
+
+		for(const auto& rhs : rule.second) {
+			out.emplace_back("rule", sax::Token::TokenType::START_ELEMENT);
+
+			GrammarToXMLComposer::composeRuleLHS(out, rule.first);
+			GrammarToXMLComposer::composeRuleRHS(out, rhs);
+
+			out.emplace_back("rule", sax::Token::TokenType::END_ELEMENT);
+		}
+	}
+
+	out.emplace_back("rules", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
+
+namespace alib {
+
+xmlApi<grammar::Grammar>::ParserRegister<grammar::UnrestrictedGrammar> UnrestrictedGrammarParserRegister = xmlApi<grammar::Grammar>::ParserRegister<grammar::UnrestrictedGrammar>(grammar::UnrestrictedGrammar::XML_TAG_NAME, grammar::UnrestrictedGrammar::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
index 6ec9f9fbe144e30a0d8a01e067fe4ea7c3e74d13..1d99ee2d7e302ec34d49e27c78340ba97f6e8127 100644
--- a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
@@ -53,6 +53,14 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static UnrestrictedGrammar parse(std::deque<sax::Token>::iterator& input);
+	static void parseRule(std::deque<sax::Token>::iterator& input, UnrestrictedGrammar& grammar);
+
+	void compose(std::deque<sax::Token>& out) const;
+	void composeRules(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace grammar */
diff --git a/alib2data/src/grammar/common/GrammarFromXMLParser.cpp b/alib2data/src/grammar/common/GrammarFromXMLParser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77fa4c67be676e14d4d085b1246efea69bb083f4
--- /dev/null
+++ b/alib2data/src/grammar/common/GrammarFromXMLParser.cpp
@@ -0,0 +1,141 @@
+/*
+ * GrammarFromXMLParser.cpp
+ *
+ *  Created on: Oct 12, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "GrammarFromXMLParser.h"
+#include "../../sax/ParserException.h"
+#include "../../XmlApi.hpp"
+
+namespace grammar {
+
+std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input) {
+	std::set<alphabet::Symbol> inputSymbols;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "nonterminalAlphabet");
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		inputSymbols.insert(alib::xmlApi<alphabet::Symbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "nonterminalAlphabet");
+	return inputSymbols;
+}
+
+std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::deque<sax::Token>::iterator& input) {
+	std::set<alphabet::Symbol> inputSymbols;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "terminalAlphabet");
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		inputSymbols.insert(alib::xmlApi<alphabet::Symbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "terminalAlphabet");
+	return inputSymbols;
+}
+
+alphabet::Symbol GrammarFromXMLParser::parseInitialSymbol(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "initialSymbol");
+	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "initialSymbol");
+	return blank;
+}
+
+bool GrammarFromXMLParser::parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input) {
+	bool generatesEpsilon;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "generatesEpsilon");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "true")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "true");
+		generatesEpsilon = true;
+	} else {
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "false");
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "false");
+		generatesEpsilon = false;
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "generatesEpsilon");
+	return generatesEpsilon;
+}
+
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::deque<sax::Token>::iterator& input) {
+	std::vector<alphabet::Symbol> lContext;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lContext");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		lContext.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lContext");
+	return lContext;
+}
+
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::deque<sax::Token>::iterator& input) {
+	std::vector<alphabet::Symbol> lhs;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		lhs.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
+	return lhs;
+}
+
+alphabet::Symbol GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
+	alphabet::Symbol lhs = alib::xmlApi<alphabet::Symbol>::parse(input);
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
+	return lhs;
+}
+
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::deque<sax::Token>::iterator& input) {
+	std::vector<alphabet::Symbol> rContext;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rContext");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		rContext.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rContext");
+	return rContext;
+}
+
+std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser::parseRuleGNFRHS(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
+	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
+	std::vector<alphabet::Symbol> second;
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		second.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
+	return std::make_pair(std::move(first), std::move(second));
+}
+
+std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::deque<sax::Token>::iterator& input) {
+	std::vector<alphabet::Symbol> rhs;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		rhs.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
+	return rhs;
+}
+
+std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
+	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
+	if(sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		alphabet::Symbol second = alib::xmlApi<alphabet::Symbol>::parse(input);
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
+		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::make_pair(std::move(first), std::move(second)));
+	} else {
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
+		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::move(first));
+	}
+}
+
+} /* namespace grammar */
+
diff --git a/alib2data/src/grammar/common/GrammarFromXMLParser.h b/alib2data/src/grammar/common/GrammarFromXMLParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..936bf28e9829de2bb592a56528953f135b88ccdc
--- /dev/null
+++ b/alib2data/src/grammar/common/GrammarFromXMLParser.h
@@ -0,0 +1,58 @@
+/*
+ * GrammarFromXMLParser.h
+ *
+ *  Created on: Oct 12, 2013
+ *      Author: Martin Zak
+ */
+
+#ifndef GRAMMAR_FROM_XML_PARSER_H_
+#define GRAMMAR_FROM_XML_PARSER_H_
+
+#include <deque>
+#include <set>
+#include <variant>
+#include <vector>
+#include "../../alphabet/SymbolFeatures.h"
+#include "../../XmlApiBase.h"
+#include "../../sax/Token.h"
+#include "../../sax/FromXMLParserHelper.h"
+
+namespace grammar {
+
+/**
+ * Parser used to get general FSM or EpsilonNFA, NFA, DFA from XML parsed into list of Tokens.
+ */
+class GrammarFromXMLParser {
+public:
+	static std::set<alphabet::Symbol> parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input);
+	static std::set<alphabet::Symbol> parseTerminalAlphabet(std::deque<sax::Token>::iterator& input);
+	static alphabet::Symbol parseInitialSymbol(std::deque<sax::Token>::iterator& input);
+	static bool parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input);
+
+	static std::vector<alphabet::Symbol> parseRuleLContext(std::deque<sax::Token>::iterator& input);
+	static std::vector<alphabet::Symbol> parseRuleLHS(std::deque<sax::Token>::iterator& input);
+	static std::vector<alphabet::Symbol> parseRuleRContext(std::deque<sax::Token>::iterator& input);
+	static alphabet::Symbol parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input);
+	static std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> parseRuleGNFRHS(std::deque<sax::Token>::iterator& input);
+	static std::vector<alphabet::Symbol> parseRuleRHS(std::deque<sax::Token>::iterator& input);
+	static std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input);
+
+	template<class T>
+	static void parseRules(std::deque<sax::Token>::iterator& input, T& grammar);
+};
+
+template<class T>
+void GrammarFromXMLParser::parseRules(std::deque<sax::Token>::iterator& input, T& grammar) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rules");
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rule");
+		T::parseRule(input, grammar);
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rule");
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rules");
+}
+
+} /* namespace grammar */
+
+#endif /* GRAMMAR_FROM_XML_PARSER_H_ */
+
diff --git a/alib2data/src/grammar/common/GrammarToXMLComposer.cpp b/alib2data/src/grammar/common/GrammarToXMLComposer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5f54c702e8d19095000d0bce0c5de95bc1bb267f
--- /dev/null
+++ b/alib2data/src/grammar/common/GrammarToXMLComposer.cpp
@@ -0,0 +1,189 @@
+/*
+ * GrammarToXMLComposer.cpp
+ *
+ *  Created on: Nov 11, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "GrammarToXMLComposer.h"
+
+#include "../../XmlApi.hpp"
+
+namespace grammar {
+
+void GrammarToXMLComposer::composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) {
+	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& symbol : symbols) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) {
+	out.emplace_back("terminalAlphabet", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& symbol : symbols) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+	out.emplace_back("terminalAlphabet", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) {
+	out.emplace_back("initialSymbol", sax::Token::TokenType::START_ELEMENT);
+	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	out.emplace_back("initialSymbol", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon) {
+	out.emplace_back("generatesEpsilon", sax::Token::TokenType::START_ELEMENT);
+	if(generatesEpsilon) {
+		out.emplace_back("true", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("true", sax::Token::TokenType::END_ELEMENT);
+	} else {
+		out.emplace_back("false", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("false", sax::Token::TokenType::END_ELEMENT);
+	}
+	out.emplace_back("generatesEpsilon", sax::Token::TokenType::END_ELEMENT);
+}
+
+
+void GrammarToXMLComposer::composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) {
+	out.emplace_back("lContext", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.size() == 0) {
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+	} else for (const auto& symbol : symbols) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+	out.emplace_back("lContext", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) {
+	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.size() == 0) {
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+	} else for (const auto& symbol : symbols) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) {
+	out.emplace_back("rContext", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.size() == 0) {
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+	} else for (const auto& symbol : symbols) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+	out.emplace_back("rContext", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) {
+	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
+	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.size() == 0) {
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+	} else for (const auto& symbol : symbols) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.is<alphabet::Symbol>()) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbols.get<alphabet::Symbol>());
+	} else {
+		const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = symbols.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
+		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.first);
+		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.second);
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+
+	alib::xmlApi<alphabet::Symbol>::compose(out, symbols.first);
+
+	for (const auto& symbol : symbols.second) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.is<std::vector<alphabet::Symbol>>()) {
+		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
+		if(rhs.size() == 0) {
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+		} else for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
+			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+		}
+	} else {
+		const std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>& rhs = symbols.get<std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>();
+		for (const auto& symbol : std::get<0>(rhs)) {
+			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+		}
+		alib::xmlApi<alphabet::Symbol>::compose(out, std::get<1>(rhs));
+		for (const auto& symbol : std::get<2>(rhs)) {
+			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+		}
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.is<std::vector<alphabet::Symbol>>()) {
+		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
+		if(rhs.size() == 0) {
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+		} else for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
+			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+		}
+	} else {
+		const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& rhs = symbols.get<std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>();
+		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.first);
+		for (const auto& symbol : rhs.second) {
+			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+		}
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.is<std::vector<alphabet::Symbol>>()) {
+		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
+		if(rhs.size() == 0) {
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+		} else {
+			for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
+				alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+			}
+		}
+	} else {
+		const std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>& rhs = symbols.get<std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>();
+		for (const auto& symbol : rhs.first) {
+			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+		}
+		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.second);
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+} /* namespace grammar */
+
diff --git a/alib2data/src/grammar/common/GrammarToXMLComposer.h b/alib2data/src/grammar/common/GrammarToXMLComposer.h
new file mode 100644
index 0000000000000000000000000000000000000000..9267c1ec562f026a394e20ca8db4c75f35792409
--- /dev/null
+++ b/alib2data/src/grammar/common/GrammarToXMLComposer.h
@@ -0,0 +1,47 @@
+/*
+ * GrammarToXMLComposer.h
+ *
+ *  Created on: Nov 11, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef GRAMMAR_TO_XML_COMPOSER_H_
+#define GRAMMAR_TO_XML_COMPOSER_H_
+
+#include <deque>
+#include <vector>
+#include <tuple>
+#include <set>
+#include <variant>
+#include "../../alphabet/SymbolFeatures.h"
+#include "../../sax/Token.h"
+#include "../../XmlApiBase.h"
+
+namespace grammar {
+
+/**
+ * This class contains methods to print XML representation of automata to the output stream.
+ */
+class GrammarToXMLComposer {
+public:
+	static void composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols);
+	static void composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols);
+	static void composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol);
+	static void composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon);
+
+	static void composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols);
+	static void composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols);
+	static void composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols);
+	static void composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol);
+	static void composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols);
+	static void composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols);
+	static void composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols);
+	static void composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols);
+	static void composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols);
+	static void composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols);
+};
+
+} /* namespace grammar */
+
+#endif /* GRAMMAR_TO_XML_COMPOSER_H_ */
+