From 89968a59e26a9883c6696c83d8cf775a1d2b9774 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Mon, 11 Sep 2017 19:58:49 +0200
Subject: [PATCH] use cli in normalize binary

---
 .../src/automaton/simplify/Normalize.cpp      |  13 +-
 alib2algo/src/automaton/simplify/Normalize.h  |   6 +-
 .../automaton/simplify/SingleInitialState.cpp |  23 +--
 .../automaton/simplify/SingleInitialState.h   |   8 +-
 .../src/grammar/convert/ToGrammarLeftRG.cpp   |   6 +-
 .../src/grammar/convert/ToGrammarLeftRG.h     |   7 +-
 .../src/grammar/convert/ToGrammarRightRG.cpp  |   6 +-
 .../src/grammar/convert/ToGrammarRightRG.h    |   7 +-
 alib2algo/src/grammar/simplify/ToCNF.cpp      |  30 ++--
 alib2algo/src/grammar/simplify/ToCNF.h        |   7 +-
 alib2algo/src/grammar/simplify/ToGNF.cpp      |  22 ++-
 alib2algo/src/grammar/simplify/ToGNF.h        |   7 +-
 .../src/string/simplify/NormalizeAlphabet.cpp |   6 +-
 .../src/string/simplify/NormalizeAlphabet.h   |   7 +-
 .../grammar/simplify/GrammarToCNFTest.cpp     |   2 +
 .../parsing/DeterministicLL1Grammar.cpp       |   6 +-
 .../grammar/parsing/DeterministicLL1Grammar.h |   6 +-
 anormalize2/makefile.conf                     |   6 +-
 anormalize2/src/anormalize.cpp                | 141 ++++--------------
 19 files changed, 72 insertions(+), 244 deletions(-)

diff --git a/alib2algo/src/automaton/simplify/Normalize.cpp b/alib2algo/src/automaton/simplify/Normalize.cpp
index edfed9fb05..43b529f6c4 100644
--- a/alib2algo/src/automaton/simplify/Normalize.cpp
+++ b/alib2algo/src/automaton/simplify/Normalize.cpp
@@ -12,17 +12,8 @@ namespace automaton {
 
 namespace simplify {
 
-automaton::Automaton Normalize::normalize(const automaton::Automaton& automaton) {
-	automaton::Automaton res = dispatch(automaton.getData());
-	res.normalize ( );
-	return res;
-}
-
-auto NormalizeDFA = registration::OverloadRegister < Normalize, automaton::DFA < DefaultSymbolType, unsigned >, automaton::DFA < > > ( Normalize::normalize );
-auto NormalizeDPDA = registration::OverloadRegister < Normalize, automaton::DPDA < DefaultSymbolType, DefaultEpsilonType, unsigned, unsigned >, automaton::DPDA < > > ( Normalize::normalize );
-
-auto NormalizeDFA2 = registration::AbstractRegister < Normalize, automaton::DFA < DefaultSymbolType, unsigned >, const automaton::DFA < > & > ( Normalize::normalize );
-auto NormalizeDPDA2 = registration::AbstractRegister < Normalize, automaton::DPDA < DefaultSymbolType, DefaultEpsilonType, unsigned, unsigned >, const automaton::DPDA < > & > ( Normalize::normalize );
+auto NormalizeDFA = registration::AbstractRegister < Normalize, automaton::DFA < DefaultSymbolType, unsigned >, const automaton::DFA < > & > ( Normalize::normalize );
+auto NormalizeDPDA = registration::AbstractRegister < Normalize, automaton::DPDA < DefaultSymbolType, DefaultEpsilonType, unsigned, unsigned >, const automaton::DPDA < > & > ( Normalize::normalize );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/automaton/simplify/Normalize.h b/alib2algo/src/automaton/simplify/Normalize.h
index e6cfc984ef..d5473d7901 100644
--- a/alib2algo/src/automaton/simplify/Normalize.h
+++ b/alib2algo/src/automaton/simplify/Normalize.h
@@ -8,22 +8,18 @@
 #ifndef NORMALIZE_H_
 #define NORMALIZE_H_
 
-#include <core/multipleDispatch.hpp>
 #include <automaton/FSM/DFA.h>
 #include <automaton/PDA/DPDA.h>
-#include <automaton/Automaton.h>
 
 namespace automaton {
 
 namespace simplify {
 
-class Normalize : public alib::SingleDispatch<Normalize, automaton::Automaton, const automaton::AutomatonBase &> {
+class Normalize {
 public:
 	/**
 	 * @param dfa automaton to normalize
 	 */
-	static automaton::Automaton normalize(const automaton::Automaton& dfa);
-
 	template < class SymbolType, class StateType >
 	static automaton::DFA < SymbolType, unsigned > normalize(const automaton::DFA < SymbolType, StateType > & dfa);
 	template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
diff --git a/alib2algo/src/automaton/simplify/SingleInitialState.cpp b/alib2algo/src/automaton/simplify/SingleInitialState.cpp
index 5e62c59f97..5cb4ef02e9 100644
--- a/alib2algo/src/automaton/simplify/SingleInitialState.cpp
+++ b/alib2algo/src/automaton/simplify/SingleInitialState.cpp
@@ -12,23 +12,12 @@ namespace automaton {
 
 namespace simplify {
 
-automaton::Automaton SingleInitialState::convert(const Automaton& automaton) {
-	return dispatch(automaton.getData());
-}
-
-auto SingleInitialStateMultiInitialStateNFA = registration::OverloadRegister < SingleInitialState, automaton::NFA < >, automaton::MultiInitialStateNFA < > > ( SingleInitialState::convert );
-auto SingleInitialStateDFA = registration::OverloadRegister < SingleInitialState, automaton::DFA < >, automaton::DFA < > > ( SingleInitialState::convert );
-auto SingleInitialStateEpsilonNFA = registration::OverloadRegister < SingleInitialState, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( SingleInitialState::convert );
-auto SingleInitialStateNFA = registration::OverloadRegister < SingleInitialState, automaton::NFA < > , automaton::NFA < > > ( SingleInitialState::convert );
-auto SingleInitialStateCompactNFA = registration::OverloadRegister < SingleInitialState, automaton::CompactNFA < >, automaton::CompactNFA < > > ( SingleInitialState::convert );
-auto SingleInitialStateExtendedNFA = registration::OverloadRegister < SingleInitialState, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( SingleInitialState::convert );
-
-auto SingleInitialStateMultiInitialStateNFA2 = registration::AbstractRegister < SingleInitialState, automaton::NFA < >, const automaton::MultiInitialStateNFA < > & > ( SingleInitialState::convert );
-auto SingleInitialStateDFA2 = registration::AbstractRegister < SingleInitialState, automaton::DFA < >, const automaton::DFA < > & > ( SingleInitialState::convert );
-auto SingleInitialStateEpsilonNFA2 = registration::AbstractRegister < SingleInitialState, automaton::EpsilonNFA < >, const automaton::EpsilonNFA < > & > ( SingleInitialState::convert );
-auto SingleInitialStateNFA2 = registration::AbstractRegister < SingleInitialState, automaton::NFA < >, const automaton::NFA < > & > ( SingleInitialState::convert );
-auto SingleInitialStateCompactNFA2 = registration::AbstractRegister < SingleInitialState, automaton::CompactNFA < >, const automaton::CompactNFA < > & > ( SingleInitialState::convert );
-auto SingleInitialStateExtendedNFA2 = registration::AbstractRegister < SingleInitialState, automaton::ExtendedNFA < >, const automaton::ExtendedNFA < > & > ( SingleInitialState::convert );
+auto SingleInitialStateMultiInitialStateNFA = registration::AbstractRegister < SingleInitialState, automaton::NFA < >, const automaton::MultiInitialStateNFA < > & > ( SingleInitialState::convert );
+auto SingleInitialStateDFA = registration::AbstractRegister < SingleInitialState, automaton::DFA < >, const automaton::DFA < > & > ( SingleInitialState::convert );
+auto SingleInitialStateEpsilonNFA = registration::AbstractRegister < SingleInitialState, automaton::EpsilonNFA < >, const automaton::EpsilonNFA < > & > ( SingleInitialState::convert );
+auto SingleInitialStateNFA = registration::AbstractRegister < SingleInitialState, automaton::NFA < >, const automaton::NFA < > & > ( SingleInitialState::convert );
+auto SingleInitialStateCompactNFA = registration::AbstractRegister < SingleInitialState, automaton::CompactNFA < >, const automaton::CompactNFA < > & > ( SingleInitialState::convert );
+auto SingleInitialStateExtendedNFA = registration::AbstractRegister < SingleInitialState, automaton::ExtendedNFA < >, const automaton::ExtendedNFA < > & > ( SingleInitialState::convert );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/automaton/simplify/SingleInitialState.h b/alib2algo/src/automaton/simplify/SingleInitialState.h
index f42a746647..9d6a8cc4e4 100644
--- a/alib2algo/src/automaton/simplify/SingleInitialState.h
+++ b/alib2algo/src/automaton/simplify/SingleInitialState.h
@@ -8,10 +8,6 @@
 #ifndef _SINGLE_INITIAL_STATE_H_
 #define _SINGLE_INITIAL_STATE_H_
 
-#include <core/multipleDispatch.hpp>
-#include <automaton/Automaton.h>
-#include <automaton/AutomatonFeatures.h>
-
 #include <algorithm>
 #include <set>
 
@@ -33,13 +29,11 @@ namespace simplify {
  * Makes finite automaton's transition function convert.
  * Source: Melichar: Algorithm 2.22
  */
-class SingleInitialState : public alib::SingleDispatch<SingleInitialState, automaton::Automaton, const automaton::AutomatonBase &> {
+class SingleInitialState {
 public:
 	/**
 	 * Computes epsilon closure of a state in epsilon nonfree automaton
 	 */
-	static automaton::Automaton convert(const automaton::Automaton& automaton);
-
 	template < class SymbolType, class StateType >
 	static automaton::NFA < SymbolType, StateType > convert(const automaton::MultiInitialStateNFA < SymbolType, StateType > & automaton);
 	template < class SymbolType, class StateType >
diff --git a/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp b/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
index 33ae387e1d..f91cb42a56 100644
--- a/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
+++ b/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
@@ -12,11 +12,7 @@ namespace grammar {
 
 namespace convert {
 
-grammar::Grammar ToGrammarLeftRG::convert(const grammar::Grammar& grammar) {
-	return dispatch(grammar.getData());
-}
-
-auto ToGrammarLeftRGRightRG = registration::OverloadRegister < ToGrammarLeftRG, grammar::LeftRG < >, grammar::RightRG < > > ( ToGrammarLeftRG::convert );
+auto ToGrammarLeftRGRightRG = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const grammar::RightRG < > & > ( ToGrammarLeftRG::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/grammar/convert/ToGrammarLeftRG.h b/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
index ba052c78f5..fea91f6220 100644
--- a/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
+++ b/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
@@ -8,9 +8,6 @@
 #ifndef TO_GRAMMAR_LEFT_RG_H_
 #define TO_GRAMMAR_LEFT_RG_H_
 
-#include <core/multipleDispatch.hpp>
-
-#include <grammar/Grammar.h>
 #include <grammar/Regular/LeftRG.h>
 #include <grammar/Regular/RightRG.h>
 
@@ -23,15 +20,13 @@ namespace convert {
 /**
  * Converts right regular grammar to left regular grammar.
  */
-class ToGrammarLeftRG : public alib::SingleDispatch<ToGrammarLeftRG, grammar::Grammar, const grammar::GrammarBase &> {
+class ToGrammarLeftRG {
 public:
 	/**
 	 * Performs conversion.
 	 * @param grammar Right regular grammar to convert
 	 * @return left regular grammar which is equivalent to source right regular grammar.
 	 */
-	static grammar::Grammar convert(const grammar::Grammar& grammar);
-
 	template < class SymbolType >
 	static grammar::LeftRG < SymbolType > convert(const grammar::RightRG < SymbolType > & grammar);
 };
diff --git a/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp b/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
index 4a549e9293..a906b00f7a 100644
--- a/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
+++ b/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
@@ -12,11 +12,7 @@ namespace grammar {
 
 namespace convert {
 
-grammar::Grammar ToGrammarRightRG::convert(const grammar::Grammar& grammar) {
-	return dispatch(grammar.getData());
-}
-
-auto ToGrammarRightRGLeftRG = registration::OverloadRegister < ToGrammarRightRG, grammar::RightRG < >, grammar::LeftRG < > > ( ToGrammarRightRG::convert );
+auto ToGrammarRightRGLeftRG = registration::AbstractRegister < ToGrammarRightRG, grammar::RightRG < >, const grammar::LeftRG < > & > ( ToGrammarRightRG::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/grammar/convert/ToGrammarRightRG.h b/alib2algo/src/grammar/convert/ToGrammarRightRG.h
index c6882bb8bd..a0af3bdc5f 100644
--- a/alib2algo/src/grammar/convert/ToGrammarRightRG.h
+++ b/alib2algo/src/grammar/convert/ToGrammarRightRG.h
@@ -8,9 +8,6 @@
 #ifndef TO_GRAMMAR_RIGHT_RG_H_
 #define TO_GRAMMAR_RIGHT_RG_H_
 
-#include <core/multipleDispatch.hpp>
-
-#include <grammar/Grammar.h>
 #include <grammar/Regular/LeftRG.h>
 #include <grammar/Regular/RightRG.h>
 
@@ -23,15 +20,13 @@ namespace convert {
 /**
  * Converts left regular grammar to right regular grammar.
  */
-class ToGrammarRightRG : public alib::SingleDispatch<ToGrammarRightRG, grammar::Grammar, const grammar::GrammarBase &> {
+class ToGrammarRightRG {
 public:
 	/**
 	 * Performs conversion.
 	 * @param grammar Left regular grammar to convert
 	 * @return right regular grammar which is equivalent to source left regular grammar.
 	 */
-	static grammar::Grammar convert(const grammar::Grammar& grammar);
-
 	template < class SymbolType >
 	static grammar::RightRG < SymbolType > convert(const grammar::LeftRG < SymbolType > & grammar);
 };
diff --git a/alib2algo/src/grammar/simplify/ToCNF.cpp b/alib2algo/src/grammar/simplify/ToCNF.cpp
index 35f4d123dd..6120caac84 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToCNF.cpp
@@ -122,59 +122,47 @@ grammar::CNF < > ToCNF::convert(const grammar::CFG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFCFG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::CFG < > > ( ToCNF::convert );
-
 grammar::CNF < > ToCNF::convert(const grammar::EpsilonFreeCFG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(origGrammar));
 }
 
-auto ToCNFEpsilonFreeCFG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::EpsilonFreeCFG < > > ( ToCNF::convert );
-
 grammar::CNF < > ToCNF::convert(const grammar::CNF < > & origGrammar) {
 	return origGrammar;
 }
 
-auto ToCNFCNF = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::CNF < > > ( ToCNF::convert );
-
 grammar::CNF < > ToCNF::convert(const grammar::GNF < > & origGrammar) {
 	return convertInternal(origGrammar);
 }
 
-auto ToCNFGNF = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::GNF < > > ( ToCNF::convert );
-
 grammar::CNF < > ToCNF::convert(const grammar::LG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFLG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::LG < > > ( ToCNF::convert );
-
 grammar::CNF < > ToCNF::convert(const grammar::LeftLG< > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFLeftLG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::LeftLG < > > ( ToCNF::convert );
-
 grammar::CNF < > ToCNF::convert(const grammar::LeftRG < > & origGrammar) {
 	return convertInternal(origGrammar);
 }
 
-auto ToCNFLeftRG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::LeftRG < > > ( ToCNF::convert );
-
 grammar::CNF < > ToCNF::convert(const grammar::RightLG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFRightLG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::RightLG < > > ( ToCNF::convert );
-
 grammar::CNF < > ToCNF::convert(const grammar::RightRG < > & origGrammar) {
 	return convertInternal(origGrammar);
 }
 
-auto ToCNFRightRG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::RightRG < > > ( ToCNF::convert );
-
-grammar::Grammar ToCNF::convert(const grammar::Grammar& grammar) {
-	return dispatch(grammar.getData());
-}
+auto ToCNFCFG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::CFG < > & > ( ToCNF::convert );
+auto ToCNFEpsilonFreeCFG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::EpsilonFreeCFG < > & > ( ToCNF::convert );
+auto ToCNFCNF = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::CNF < > & > ( ToCNF::convert );
+auto ToCNFGNF = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::GNF < > & > ( ToCNF::convert );
+auto ToCNFLG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::LG < > & > ( ToCNF::convert );
+auto ToCNFLeftLG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::LeftLG < > & > ( ToCNF::convert );
+auto ToCNFLeftRG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::LeftRG < > & > ( ToCNF::convert );
+auto ToCNFRightLG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::RightLG < > & > ( ToCNF::convert );
+auto ToCNFRightRG = registration::AbstractRegister < ToCNF, grammar::CNF < >, const grammar::RightRG < > & > ( ToCNF::convert );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/grammar/simplify/ToCNF.h b/alib2algo/src/grammar/simplify/ToCNF.h
index 5ab1a06336..e6b9cc588c 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.h
+++ b/alib2algo/src/grammar/simplify/ToCNF.h
@@ -8,12 +8,9 @@
 #ifndef TO_CNF_H_
 #define TO_CNF_H_
 
-#include <core/multipleDispatch.hpp>
 #include <map>
 #include <algorithm>
 
-#include <grammar/Grammar.h>
-
 #include <grammar/ContextFree/CFG.h>
 #include <grammar/ContextFree/EpsilonFreeCFG.h>
 #include <grammar/ContextFree/CNF.h>
@@ -28,10 +25,8 @@ namespace grammar {
 
 namespace simplify {
 
-class ToCNF : public alib::SingleDispatch<ToCNF, grammar::Grammar, const grammar::GrammarBase &> {
+class ToCNF {
 public:
-	static grammar::Grammar convert( const grammar::Grammar & grammar );
-
 	static grammar::CNF < > convert( const grammar::CFG < > & grammar );
 	static grammar::CNF < > convert( const grammar::EpsilonFreeCFG < > & grammar );
 	static grammar::CNF < > convert( const grammar::GNF < > & grammar );
diff --git a/alib2algo/src/grammar/simplify/ToGNF.cpp b/alib2algo/src/grammar/simplify/ToGNF.cpp
index 557bc9ca1a..8352b12d07 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToGNF.cpp
@@ -12,19 +12,15 @@ namespace grammar {
 
 namespace simplify {
 
-auto ToGNFCFG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::CFG < > > ( ToGNF::convert );
-auto ToGNFEpsilonFreeCFG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::EpsilonFreeCFG < > > ( ToGNF::convert );
-auto ToGNFCNF = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::CNF < > > ( ToGNF::convert );
-auto ToGNFGNF = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::GNF < > > ( ToGNF::convert );
-auto ToGNFLG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::LG < > > ( ToGNF::convert );
-auto ToGNFLeftLG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::LeftLG < > > ( ToGNF::convert );
-auto ToGNFLeftRG = registration::OverloadRegister < ToGNF, grammar::RightRG < >, grammar::LeftRG < > > ( ToGNF::convert );
-auto ToGNFRightLG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::RightLG < > > ( ToGNF::convert );
-auto ToGNFRightRG = registration::OverloadRegister < ToGNF, grammar::RightRG < >, grammar::RightRG < > > ( ToGNF::convert );
-
-grammar::Grammar ToGNF::convert(const grammar::Grammar& grammar) {
-	return dispatch(grammar.getData());
-}
+auto ToGNFCFG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::CFG < > & > ( ToGNF::convert );
+auto ToGNFEpsilonFreeCFG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::EpsilonFreeCFG < > & > ( ToGNF::convert );
+auto ToGNFCNF = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::CNF < > & > ( ToGNF::convert );
+auto ToGNFGNF = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::GNF < > & > ( ToGNF::convert );
+auto ToGNFLG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::LG < > & > ( ToGNF::convert );
+auto ToGNFLeftLG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::LeftLG < > & > ( ToGNF::convert );
+auto ToGNFLeftRG = registration::AbstractRegister < ToGNF, grammar::RightRG < >, const grammar::LeftRG < > & > ( ToGNF::convert );
+auto ToGNFRightLG = registration::AbstractRegister < ToGNF, grammar::GNF < >, const grammar::RightLG < > & > ( ToGNF::convert );
+auto ToGNFRightRG = registration::AbstractRegister < ToGNF, grammar::RightRG < >, const grammar::RightRG < > & > ( ToGNF::convert );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/grammar/simplify/ToGNF.h b/alib2algo/src/grammar/simplify/ToGNF.h
index 17159b3239..da220e6438 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.h
+++ b/alib2algo/src/grammar/simplify/ToGNF.h
@@ -8,12 +8,9 @@
 #ifndef TO_GNF_H_
 #define TO_GNF_H_
 
-#include <core/multipleDispatch.hpp>
 #include <map>
 #include <algorithm>
 
-#include <grammar/Grammar.h>
-
 #include <grammar/ContextFree/CFG.h>
 #include <grammar/ContextFree/EpsilonFreeCFG.h>
 #include <grammar/ContextFree/CNF.h>
@@ -34,15 +31,13 @@ namespace grammar {
 
 namespace simplify {
 
-class ToGNF : public alib::SingleDispatch<ToGNF, grammar::Grammar, const grammar::GrammarBase &> {
+class ToGNF {
 	template < class SymbolType >
 	static grammar::EpsilonFreeCFG < SymbolType > assignNonterminals(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar);
 	template < class SymbolType >
 	static grammar::GNF < SymbolType > convertInternal( const grammar::EpsilonFreeCFG < SymbolType > & origGrammar );
 
 public:
-	static grammar::Grammar convert( const grammar::Grammar & grammar );
-
 	template < class SymbolType >
 	static grammar::GNF < SymbolType > convert( const grammar::CFG < SymbolType > & grammar );
 	template < class SymbolType >
diff --git a/alib2algo/src/string/simplify/NormalizeAlphabet.cpp b/alib2algo/src/string/simplify/NormalizeAlphabet.cpp
index 595a4cafc9..62ed204c56 100644
--- a/alib2algo/src/string/simplify/NormalizeAlphabet.cpp
+++ b/alib2algo/src/string/simplify/NormalizeAlphabet.cpp
@@ -12,11 +12,7 @@ namespace string {
 
 namespace simplify {
 
-string::String NormalizeAlphabet::normalize(const string::String& string) {
-	return dispatch(string.getData());
-}
-
-auto NormalizeAlphabetLinearString = registration::OverloadRegister < NormalizeAlphabet, string::LinearString < >, string::LinearString < > > ( NormalizeAlphabet::normalize );
+auto NormalizeAlphabetLinearString = registration::AbstractRegister < NormalizeAlphabet, string::LinearString < >, const string::LinearString < > & > ( NormalizeAlphabet::normalize );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/string/simplify/NormalizeAlphabet.h b/alib2algo/src/string/simplify/NormalizeAlphabet.h
index 3705ad7fa2..458d7c99f1 100644
--- a/alib2algo/src/string/simplify/NormalizeAlphabet.h
+++ b/alib2algo/src/string/simplify/NormalizeAlphabet.h
@@ -8,22 +8,17 @@
 #ifndef NORMALIZE_ALPHABET_H_
 #define NORMALIZE_ALPHABET_H_
 
-#include <core/multipleDispatch.hpp>
-
 #include <string/LinearString.h>
-#include <string/String.h>
 
 namespace string {
 
 namespace simplify {
 
-class NormalizeAlphabet : public alib::SingleDispatch<NormalizeAlphabet, string::String, const string::StringBase &> {
+class NormalizeAlphabet {
 public:
 	/**
 	 * @param dfa automaton to normalize
 	 */
-	static string::String normalize(const string::String& str);
-
 	template < class SymbolType >
 	static string::LinearString < SymbolType > normalize(const string::LinearString < SymbolType > & str);
 };
diff --git a/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp b/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
index 1b7b509f53..e66a952cc8 100644
--- a/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
+++ b/alib2algo/test-src/grammar/simplify/GrammarToCNFTest.cpp
@@ -9,6 +9,8 @@
 
 #include <common/DefaultSymbolsPairType.h>
 
+#include <grammar/Grammar.h>
+
 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( GrammarToCNFTest, "grammar" );
 CPPUNIT_TEST_SUITE_REGISTRATION( GrammarToCNFTest );
 
diff --git a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
index 349679092c..7cf3d9faeb 100644
--- a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
@@ -80,11 +80,7 @@ grammar::CFG < > DeterministicLL1Grammar::convert ( const grammar::CFG < > & par
 	}
 }
 
-auto DeterministicLL1GrammarCFG = registration::OverloadRegister < DeterministicLL1Grammar, grammar::CFG < >, grammar::CFG < > > ( DeterministicLL1Grammar::convert );
-
-grammar::Grammar DeterministicLL1Grammar::convert ( const grammar::Grammar & grammar ) {
-	return dispatch ( grammar.getData ( ) );
-}
+auto DeterministicLL1GrammarCFG = registration::AbstractRegister < DeterministicLL1Grammar, grammar::CFG < >, const grammar::CFG < > & > ( DeterministicLL1Grammar::convert );
 
 } /* namespace parsing */
 
diff --git a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.h b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.h
index 434721fd59..caf6d91685 100644
--- a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.h
+++ b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.h
@@ -8,20 +8,16 @@
 #ifndef DETERMINISTIC_LL_1_GRAMMAR_H_
 #define DETERMINISTIC_LL_1_GRAMMAR_H_
 
-#include <core/multipleDispatch.hpp>
-#include <grammar/Grammar.h>
 #include <grammar/GrammarFeatures.h>
 
 namespace grammar {
 
 namespace parsing {
 
-class DeterministicLL1Grammar : public alib::SingleDispatch < DeterministicLL1Grammar, grammar::Grammar, const grammar::GrammarBase & > {
+class DeterministicLL1Grammar {
 public:
 	static grammar::CFG < > convert ( const grammar::CFG < > & grammar );
 
-	static grammar::Grammar convert ( const grammar::Grammar & grammar );
-
 };
 
 } /* namespace parsing */
diff --git a/anormalize2/makefile.conf b/anormalize2/makefile.conf
index 83077b7cfa..f5f02c777b 100644
--- a/anormalize2/makefile.conf
+++ b/anormalize2/makefile.conf
@@ -1,4 +1,4 @@
 EXECUTABLE:=anormalize2
-LINK_PATHS=../alib2elgo/ ../alib2algo_experimental/ ../alib2algo/ ../alib2data_experimental/ ../alib2data/ ../alib2common/ ../alib2std/
-LINK_LIBRARIES=alib2elgo alib2algo_experimental alib2algo alib2data_experimental alib2data alib2common alib2std xml2
-INCLUDE_PATHS=\$$(SOURCES_BASE_DIR)/../../alib2elgo/src/ \$$(SOURCES_BASE_DIR)/../../alib2algo_experimental/src/ \$$(SOURCES_BASE_DIR)/../../alib2algo/src/ \$$(SOURCES_BASE_DIR)/../../alib2data_experimental/src/  \$$(SOURCES_BASE_DIR)/../../alib2data/src/ \$$(SOURCES_BASE_DIR)/../../alib2common/src/ \$$(SOURCES_BASE_DIR)/../../alib2std/src/ /usr/include/libxml2/
+LINK_PATHS=../alib2cli/ ../alib2elgo/ ../alib2algo/ ../alib2data/ ../alib2common/ ../alib2std/
+LINK_LIBRARIES=alib2cli alib2elgo alib2algo alib2data alib2common alib2std xml2
+INCLUDE_PATHS=\$$(SOURCES_BASE_DIR)/../../alib2cli/src/ \$$(SOURCES_BASE_DIR)/../../alib2common/src/ \$$(SOURCES_BASE_DIR)/../../alib2std/src/ /usr/include/libxml2/
diff --git a/anormalize2/src/anormalize.cpp b/anormalize2/src/anormalize.cpp
index e93abbc04d..d9d269f644 100644
--- a/anormalize2/src/anormalize.cpp
+++ b/anormalize2/src/anormalize.cpp
@@ -8,18 +8,10 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
-#include <sax/FromXMLParserHelper.h>
-
-#include "exception/CommonException.h"
-#include "factory/XmlDataFactory.hpp"
-#include "string/simplify/NormalizeAlphabet.h"
-#include "automaton/simplify/Normalize.h"
-#include "automaton/simplify/SingleInitialState.h"
-#include "grammar/convert/ToGrammarLeftRG.h"
-#include "grammar/convert/ToGrammarRightRG.h"
-#include "grammar/simplify/ToCNF.h"
-#include "grammar/simplify/ToGNF.h"
-#include "grammar/parsing/DeterministicLL1Grammar.h"
+
+#include <exception/CommonException.h>
+#include <lexer/Lexer.h>
+#include <parser/Parser.h>
 
 int main ( int argc, char * * argv ) {
 	try {
@@ -69,123 +61,48 @@ int main ( int argc, char * * argv ) {
 		if ( measure.isSet ( ) )
 			common::GlobalData::measure = true;
 
+		cli::Environment environment;
+		environment.setBinding ( "stdin", input.getValue ( ) );
+		environment.setBinding ( "stdout", "-" );
+
 		measurements::start ( "Overal", measurements::Type::OVERALL );
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
-		ext::deque < sax::Token > tokens = sax::FromXMLParserHelper::parseInput(input);
+		cli::Parser parser ( cli::Lexer ( "execute <#stdin > $input" ) );
+		parser.parse ( )->run ( environment );
 
+		std::string cliCommand;
 		if ( labels.getValue ( ) == "automaton" ) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			automaton::Automaton res = automaton::simplify::Normalize::normalize ( automaton );
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			alib::XmlDataFactory::toStdout ( res );
+			cliCommand = "execute automaton::simplify::Normalize $input > $output";
 		} else if ( labels.getValue ( ) == "grammar" ) {
-			// grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			// grammar::Grammar res = grammar::simplify::Normalize::normalize(grammar);
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			// alib::XmlDataFactory::toStdout(res);
+			cliCommand = "execute grammar::simplify::Normalize $input > $output";
 		} else if ( alphabet.getValue ( ) == "string" ) {
-			string::String string = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			string::String res = string::simplify::NormalizeAlphabet::normalize ( string );
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			alib::XmlDataFactory::toStdout ( res );
+			cliCommand = "execute string::simplify::NormalizeAlphabet $input > $output";
 		} else if ( form.getValue ( ) == "leftRG" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			grammar::Grammar res = grammar::convert::ToGrammarLeftRG::convert ( grammar );
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			alib::XmlDataFactory::toStdout ( res );
+			cliCommand = "execute grammar::convert::ToGrammarLeftRG $input > $output";
 		} else if ( form.getValue ( ) == "rightRG" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			grammar::Grammar res = grammar::convert::ToGrammarRightRG::convert ( grammar );
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			alib::XmlDataFactory::toStdout ( res );
+			cliCommand = "execute grammar::convert::ToGrammarRightRG $input > $output";
 		} else if ( form.getValue ( ) == "singleInitialState" ) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			automaton::Automaton res = automaton::simplify::SingleInitialState::convert ( automaton );
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			alib::XmlDataFactory::toStdout ( res );
+			cliCommand = "execute automaton::simplify::SingleInitialState $input > $output";
 		} else if ( form.getValue ( ) == "CNF" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			grammar::Grammar res = grammar::simplify::ToCNF::convert ( grammar );
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			alib::XmlDataFactory::toStdout ( res );
+			cliCommand = "execute grammar::simplify::ToCNF $input > $output";
 		} else if ( form.getValue ( ) == "GNF" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			grammar::Grammar res = grammar::simplify::ToGNF::convert ( grammar );
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			alib::XmlDataFactory::toStdout ( res );
+			cliCommand = "execute grammar::simplify::ToGNF $input > $output";
 		} else if ( form.getValue ( ) == "LL1" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( tokens ) );
-
-			measurements::end ( );
-			measurements::start ( "Algorithm", measurements::Type::MAIN );
-
-			grammar::Grammar res = grammar::parsing::DeterministicLL1Grammar::convert ( grammar );
-
-			measurements::end ( );
-			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
-			alib::XmlDataFactory::toStdout ( res );
+			cliCommand = "execute grammar::parsing::DeterministicLL1Grammar $input > $output";
 		} else {
 			throw exception::CommonException ( "Invalid normalize command" );
 		}
 
+		parser = cli::Parser ( cli::Lexer ( cliCommand ) );
+		parser.parse ( )->run ( environment );
+
+		measurements::end();
+		measurements::start("Output write", measurements::Type::AUXILIARY);
+
+		parser = cli::Parser ( cli::Lexer ( "execute $output >#stdout" ) );
+		parser.parse ( )->run ( environment );
+
 		measurements::end ( );
 		measurements::end ( );
 
-- 
GitLab