diff --git a/alib2/src/grammar/GrammarFeatures.h b/alib2/src/grammar/GrammarFeatures.h
index 4587fc98b493ec1ea7438e649ee30715b9bc5a8b..10a4932df12596a689723ae28d6ec2e8e9fc5186 100644
--- a/alib2/src/grammar/GrammarFeatures.h
+++ b/alib2/src/grammar/GrammarFeatures.h
@@ -23,6 +23,7 @@ enum class FEATURES {
 	GNF,
 	CSG,
 	NON_CONTRACTING_GRAMMAR,
+	CONTEXT_PRESERVING_UNRESTRICTED_GRAMMAR,
 	UNRESTRICTED_GRAMMAR
 };
 
diff --git a/alib2/src/grammar/GrammarFromXMLParser.cpp b/alib2/src/grammar/GrammarFromXMLParser.cpp
index 574418beb31201cd3841d8d04ddb693c8f657620..5ac2fc0ad565f65762fc5b7676d7a2d835beeb46 100644
--- a/alib2/src/grammar/GrammarFromXMLParser.cpp
+++ b/alib2/src/grammar/GrammarFromXMLParser.cpp
@@ -15,7 +15,7 @@
 namespace grammar {
 
 Grammar GrammarFromXMLParser::parse(std::list<sax::Token> &input) const {
-	return parse(input, std::set<FEATURES>({FEATURES::GRAMMAR, 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::UNRESTRICTED_GRAMMAR}));
+	return parse(input, std::set<FEATURES>({FEATURES::GRAMMAR, 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::parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
@@ -71,12 +71,217 @@ UnrestrictedGrammar GrammarFromXMLParser::parseUnrestrictedGrammar(std::list<sax
 	grammar.setNonterminalAlphabet(nonterminalAlphabet);
 	grammar.setTerminalAlphabet(terminalAlphabet);
 
-	parseRules<UnrestrictedGrammar>(input, grammar);
+	parseRules(input, grammar);
 
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "UnrestrictedGrammar");
 	return grammar;
 }
 
+ContextPreservingUnrestrictedGrammar GrammarFromXMLParser::parseContextPreservingUnrestrictedGrammar(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "ContextPreservingUnrestrictedGrammar");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	ContextPreservingUnrestrictedGrammar grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "ContextPreservingUnrestrictedGrammar");
+	return grammar;
+}
+
+NonContractingGrammar GrammarFromXMLParser::parseNoncontractingGrammar(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "NonContractingGrammar");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	NonContractingGrammar grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "NonContractingGrammar");
+	return grammar;
+}
+
+CSG GrammarFromXMLParser::parseCSG(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "CSG");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	CSG grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "CSG");
+	return grammar;
+}
+
+GNF GrammarFromXMLParser::parseGNF(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "GNF");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	GNF grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "GNF");
+	return grammar;
+}
+
+CNF GrammarFromXMLParser::parseCNF(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "CNF");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	CNF grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "CNF");
+	return grammar;
+}
+
+EpsilonFreeCFG GrammarFromXMLParser::parseEpsilonFreeCFG(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonFreeCFG");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	EpsilonFreeCFG grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "EpsilonFreeCFG");
+	return grammar;
+}
+
+CFG GrammarFromXMLParser::parseCFG(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "CFG");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	CFG grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "CFG");
+	return grammar;
+}
+
+LG GrammarFromXMLParser::parseLG(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "LG");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	LG grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "LG");
+	return grammar;
+}
+
+RightRG GrammarFromXMLParser::parseRightRG(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "RightRG");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	RightRG grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "RightRG");
+	return grammar;
+}
+
+RightLG GrammarFromXMLParser::parseRightLG(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "LeftLG");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	RightLG grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "RightLG");
+	return grammar;
+}
+
+LeftRG GrammarFromXMLParser::parseLeftRG(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "LeftRG");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	LeftRG grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "LeftRG");
+	return grammar;
+}
+
+LeftLG GrammarFromXMLParser::parseLeftLG(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "LeftLG");
+
+	std::set<alphabet::Symbol> nonterminalAlphabet = parseNonterminalAlphabet(input);
+	std::set<alphabet::Symbol> terminalAlphabet = parseTerminalAlphabet(input);
+	alphabet::Symbol initialSymbol = parseInitialSymbol(input);
+
+	LeftLG grammar(initialSymbol);
+	grammar.setNonterminalAlphabet(nonterminalAlphabet);
+	grammar.setTerminalAlphabet(terminalAlphabet);
+
+	parseRules(input, grammar);
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "LeftLG");
+	return grammar;
+}
+
+
 std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::list<sax::Token> &input) const {
 	std::set<alphabet::Symbol> inputSymbols;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "nonterminalAlphabet");
@@ -115,12 +320,6 @@ void GrammarFromXMLParser::parseRules(std::list<sax::Token> &input, T& grammar)
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "rules");
 }
 
-void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, UnrestrictedGrammar& grammar) const {
-	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
-	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
-	grammar.addRule(lhs, rhs);
-}
-
 void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, UnknownGrammar& grammar) const {
 	UnknownRule rule;
 
@@ -137,6 +336,85 @@ void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, UnknownGramma
 	grammar.addRule(rule);
 }
 
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, UnrestrictedGrammar& grammar) const {
+	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const {
+	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, NonContractingGrammar& grammar) const {
+	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CSG& grammar) const {
+	std::vector<alphabet::Symbol> lhs = parseRuleLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, GNF& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CNF& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, EpsilonFreeCFG& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, CFG& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LG& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightRG& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, RightLG& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftRG& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+void GrammarFromXMLParser::parseRule(std::list<sax::Token>& input, LeftLG& grammar) const {
+	alphabet::Symbol lhs = parseRuleSingleSymbolLHS(input);
+	std::vector<alphabet::Symbol> rhs = parseRuleRHS(input);
+	grammar.addRule(lhs, rhs);
+}
+
+
 std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::list<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> lhs;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
@@ -147,6 +425,13 @@ std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::list<sax::
 	return lhs;
 }
 
+alphabet::Symbol GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::list<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
+	alphabet::Symbol lhs = alib::FromXMLParsers::symbolParser.parse(input);
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
+	return lhs;
+}
+
 std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::list<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> rhs;
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
diff --git a/alib2/src/grammar/GrammarFromXMLParser.h b/alib2/src/grammar/GrammarFromXMLParser.h
index f97c74c20f2d78398051846e4a06babf9901e434..e4ba86d70956f32f6667acd7dd486d44c10d9319 100644
--- a/alib2/src/grammar/GrammarFromXMLParser.h
+++ b/alib2/src/grammar/GrammarFromXMLParser.h
@@ -12,6 +12,18 @@
 #include "Grammar.h"
 #include "GrammarFeatures.h"
 #include "UnknownGrammar.h"
+#include "Regular/LeftLG.h"
+#include "Regular/LeftRG.h"
+#include "Regular/RightLG.h"
+#include "Regular/RightRG.h"
+#include "ContextFree/LG.h"
+#include "ContextFree/CFG.h"
+#include "ContextFree/EpsilonFreeCFG.h"
+#include "ContextFree/CNF.h"
+#include "ContextFree/GNF.h"
+#include "ContextSensitive/CSG.h"
+#include "ContextSensitive/NonContractingGrammar.h"
+#include "Unrestricted/ContextPreservingUnrestrictedGrammar.h"
 #include "Unrestricted/UnrestrictedGrammar.h"
 
 #include <list>
@@ -31,12 +43,26 @@ protected:
 	alphabet::Symbol parseInitialSymbol(std::list<sax::Token> &input) const;
 
 	std::vector<alphabet::Symbol> parseRuleLHS(std::list<sax::Token>& input) const;
+	alphabet::Symbol parseRuleSingleSymbolLHS(std::list<sax::Token>& input) const;
 	std::vector<alphabet::Symbol> parseRuleRHS(std::list<sax::Token>& input) const;
 
 	template<class T>
 	void parseRules(std::list<sax::Token> &input, T& grammar) const;
+
 	void parseRule(std::list<sax::Token>& input, UnknownGrammar& grammar) const;
 	void parseRule(std::list<sax::Token>& input, UnrestrictedGrammar& grammar) const;
+	void parseRule(std::list<sax::Token>& input, ContextPreservingUnrestrictedGrammar& grammar) const;
+	void parseRule(std::list<sax::Token>& input, NonContractingGrammar& grammar) const;
+	void parseRule(std::list<sax::Token>& input, CSG& grammar) const;
+	void parseRule(std::list<sax::Token>& input, GNF& grammar) const;
+	void parseRule(std::list<sax::Token>& input, CNF& grammar) const;
+	void parseRule(std::list<sax::Token>& input, EpsilonFreeCFG& grammar) const;
+	void parseRule(std::list<sax::Token>& input, CFG& grammar) const;
+	void parseRule(std::list<sax::Token>& input, LG& grammar) const;
+	void parseRule(std::list<sax::Token>& input, RightRG& grammar) const;
+	void parseRule(std::list<sax::Token>& input, RightLG& grammar) const;
+	void parseRule(std::list<sax::Token>& input, LeftRG& grammar) const;
+	void parseRule(std::list<sax::Token>& input, LeftLG& grammar) const;
 
 	virtual Grammar parse(std::list<sax::Token>& input) const;
 	virtual Grammar parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
@@ -45,6 +71,18 @@ public:
 
 	UnknownGrammar parseUnknownGrammar(std::list<sax::Token>& input) const;
 	UnrestrictedGrammar parseUnrestrictedGrammar(std::list<sax::Token>& input) const;
+	ContextPreservingUnrestrictedGrammar parseContextPreservingUnrestrictedGrammar(std::list<sax::Token>& input) const;
+	NonContractingGrammar parseNoncontractingGrammar(std::list<sax::Token>& input) const;
+	CSG parseCSG(std::list<sax::Token>& input) const;
+	GNF parseGNF(std::list<sax::Token>& input) const;
+	CNF parseCNF(std::list<sax::Token>& input) const;
+	EpsilonFreeCFG parseEpsilonFreeCFG(std::list<sax::Token>& input) const;
+	CFG parseCFG(std::list<sax::Token>& input) const;
+	LG parseLG(std::list<sax::Token>& input) const;
+	RightRG parseRightRG(std::list<sax::Token>& input) const;
+	RightLG parseRightLG(std::list<sax::Token>& input) const;
+	LeftRG parseLeftRG(std::list<sax::Token>& input) const;
+	LeftLG parseLeftLG(std::list<sax::Token>& input) const;
 };
 
 } /* namespace grammar */