From 475037e7ed3d142460523782e4ff2ae6c67d1018 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Thu, 3 Mar 2016 12:11:06 +0100
Subject: [PATCH] simplify binaries

---
 aarbology2/src/aarbology.cpp                  |  91 ++++-----------
 acast2/src/acast.cpp                          |  17 +--
 acompaction2/src/acompaction.cpp              |  15 +--
 acompare2/src/acompare.cpp                    |  36 ++----
 aconversions2/src/ConversionHandler.cpp       |  18 +--
 aconversions2/src/ConversionHandler.h         |   4 +-
 aconversions2/src/aconversion.cpp             |  16 +--
 aderivation2/src/aderivation.cpp              |  27 +----
 adeterminize2/src/adeterminize.cpp            |  14 +--
 aecho2/src/aecho.cpp                          |  16 +--
 aepsilon2/src/aepsilon.cpp                    |  20 +---
 agenerate2/src/agenerate.cpp                  |  35 ++----
 aintegral2/src/aintegral.cpp                  |  27 +----
 alangop2/src/alangop.cpp                      |  34 ++----
 alib2common/src/sax/FromXMLParserHelper.cpp   |  32 ++++++
 alib2common/src/sax/FromXMLParserHelper.h     |   8 ++
 alib2data/src/factory/XmlDataFactory.hpp      |  12 +-
 alib2data/test-src/alphabet/SymbolTest.cpp    |   2 +-
 .../test-src/automaton/AutomatonTest.cpp      |   4 +-
 alib2data/test-src/grammar/GrammarTest.cpp    |  22 ++--
 alib2data/test-src/label/LabelTest.cpp        |   2 +-
 .../test-src/primitive/PrimitiveTest.cpp      |   2 +-
 alib2data/test-src/regexp/RegExpTest.cpp      |   2 +-
 alib2data/test-src/string/StringTest.cpp      |   2 +-
 alib2data/test-src/tree/PatternTest.cpp       |   8 +-
 alib2data/test-src/tree/TreeTest.cpp          |   6 +-
 alphabetManip2/src/alphabetManip.cpp          |  37 ++----
 aminimize2/src/aminimize.cpp                  |  14 +--
 anormalize2/src/anormalize.cpp                |  30 ++---
 araw2/src/araw.cpp                            |  38 +------
 arename2/src/arename.cpp                      |  14 +--
 areverse2/src/areverse.cpp                    |  15 +--
 arun2/src/arun.cpp                            |  27 +----
 astat2/src/astat.cpp                          |  28 ++---
 astringology2/src/astringology.cpp            | 105 ++++--------------
 atrim2/src/atrim.cpp                          |  18 +--
 tniceprint/src/tniceprint.cpp                 |  22 ++--
 37 files changed, 229 insertions(+), 591 deletions(-)

diff --git a/aarbology2/src/aarbology.cpp b/aarbology2/src/aarbology.cpp
index c9aed55f1c..e307d08558 100644
--- a/aarbology2/src/aarbology.cpp
+++ b/aarbology2/src/aarbology.cpp
@@ -9,6 +9,7 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <vector>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -48,11 +49,11 @@ int main ( int argc, char * argv[] ) {
 		TCLAP::ValueArg < std::string > algorithm ( "a", "algorithm", "Execute algorithm", false, "exactSubtreeMatch", & allowedVals );
 		cmd.add ( algorithm );
 
-		TCLAP::MultiArg < std::string > subject ( "s", "subject", "Subject tree from file", false, "file" );
-		cmd.add ( subject );
+		TCLAP::MultiArg < std::string > subjectInput ( "s", "subject", "Subject tree from file", false, "file" );
+		cmd.add ( subjectInput );
 
-		TCLAP::MultiArg < std::string > pattern ( "p", "pattern", "Pattern tree from file", false, "file" );
-		cmd.add ( pattern );
+		TCLAP::MultiArg < std::string > patternInput ( "p", "pattern", "Pattern tree from file", false, "file" );
+		cmd.add ( patternInput );
 
 		TCLAP::SwitchArg ends ( "e", "ends", "Return occurrences as end indexes when applicable", false );
 		cmd.add ( ends );
@@ -70,62 +71,12 @@ int main ( int argc, char * argv[] ) {
 		if(measure.isSet())
 			common::GlobalData::measure = true;
 
-		int needPattern = 0;
-		int needSubject = 0;
-
-		if ( algorithm.getValue ( ) == "exactSubtreeMatch" ) {
-			needPattern = needSubject = 1;
-		} else if ( algorithm.getValue ( ) == "exactSubtreeMatchingAutomaton" ) {
-			needPattern = 1;
-		} else if ( algorithm.getValue ( ) == "deadZoneUsingBadCharacterShiftAndBorderArray" ) {
-			needPattern = needSubject = 1;
-		} else {
-		}
-
 		measurements::start ( "Overal", measurements::Type::OVERALL );
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
-		std::deque < std::deque < sax::Token > > subjectTokens;
-
-		if ( subject.isSet ( ) ) {
-			for ( const std::string & fileName : subject.getValue ( ) ) {
-				std::deque < sax::Token > tmp;
-
-				if ( fileName == "-" )
-					sax::SaxParseInterface::parseStdin ( tmp );
-				else
-					sax::SaxParseInterface::parseFile ( fileName, tmp );
-
-				subjectTokens.emplace_back ( std::move ( tmp ) );
-			}
-		} else if ( needSubject ) {
-			std::deque < sax::Token > tmp;
-			sax::SaxParseInterface::parseStdin ( tmp );
-			subjectTokens.emplace_back ( std::move ( tmp ) );
-		}
-
-		std::deque < std::deque < sax::Token > > patternTokens;
-
-		if ( pattern.isSet ( ) ) {
-			for ( const std::string & fileName : pattern.getValue ( ) ) {
-				std::deque < sax::Token > tmp;
-
-				if ( fileName == "-" )
-					sax::SaxParseInterface::parseStdin ( tmp );
-				else
-					sax::SaxParseInterface::parseFile ( fileName, tmp );
-
-				patternTokens.emplace_back ( std::move ( tmp ) );
-			}
-		} else if ( needPattern ) {
-			std::deque < sax::Token > tmp;
-			sax::SaxParseInterface::parseStdin ( tmp );
-			patternTokens.emplace_back ( std::move ( tmp ) );
-		}
-
 		if ( algorithm.getValue ( ) == "exactSubtreeMatch" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( subjectTokens.front ( ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( patternTokens.front ( ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -139,8 +90,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactPatternMatch" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( subjectTokens.front ( ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( patternTokens.front ( ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -154,8 +105,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "boyerMooreHorspool" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( subjectTokens.front ( ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( patternTokens.front ( ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -169,8 +120,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "reversedBoyerMooreHorspool" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( subjectTokens.front ( ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( patternTokens.front ( ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -184,8 +135,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "knuthMorrisPratt" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( subjectTokens.front ( ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( patternTokens.front ( ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -199,8 +150,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "deadZoneUsingBadCharacterShiftAndBorderArray" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( subjectTokens.front ( ) );
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( patternTokens.front ( ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -214,7 +165,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactSubtreeMatchingAutomaton" ) {
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( patternTokens.front ( ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -226,7 +177,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactPatternMatchingAutomaton" ) {
-			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( patternTokens.front ( ) );
+			tree::Tree pattern = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -238,7 +189,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactSubtreeAutomaton" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( subjectTokens.front ( ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -250,7 +201,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactTreePatternAutomaton" ) {
-			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( subjectTokens.front ( ) );
+			tree::Tree subject = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/acast2/src/acast.cpp b/acast2/src/acast.cpp
index 42ecf835c2..5198ff81fb 100644
--- a/acast2/src/acast.cpp
+++ b/acast2/src/acast.cpp
@@ -9,10 +9,9 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <string>
+#include <sax/FromXMLParserHelper.h>
 #include <exception/AlibException.h>
 #include <factory/XmlDataFactory.hpp>
-#include <sax/SaxParseInterface.h>
-#include <sax/ParserException.h>
 #include <object/Object.h>
 #include <cast/CastApi.hpp>
 
@@ -43,18 +42,8 @@ int main(int argc, char** argv) {
 
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
-
-		alib::Object in = alib::XmlDataFactory::fromTokens<alib::Object>(tokens);
+
+		alib::Object in = alib::XmlDataFactory::fromTokens<alib::Object>(sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Cast", measurements::Type::MAIN);
diff --git a/acompaction2/src/acompaction.cpp b/acompaction2/src/acompaction.cpp
index 2d5b4d38bc..7b9e8d7990 100644
--- a/acompaction2/src/acompaction.cpp
+++ b/acompaction2/src/acompaction.cpp
@@ -8,7 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
-#include <iostream>
+#include <sax/FromXMLParserHelper.h>
 
 #include "exception/AlibException.h"
 #include "factory/XmlDataFactory.hpp"
@@ -38,18 +38,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
-
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/acompare2/src/acompare.cpp b/acompare2/src/acompare.cpp
index 774a7558c0..d038237aee 100644
--- a/acompare2/src/acompare.cpp
+++ b/acompare2/src/acompare.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include "factory/XmlDataFactory.hpp"
 #include "exception/AlibException.h"
@@ -43,49 +44,30 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens1;
-		if(input1.isSet()) {
-			if(input1.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens1);
-			} else {
-				sax::SaxParseInterface::parseFile(input1.getValue(), tokens1);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens1);
-		}
-
-		std::deque<sax::Token> tokens2;
-		if(input2.isSet()) {
-			if(input2.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens2);
-			} else {
-				sax::SaxParseInterface::parseFile(input2.getValue(), tokens2);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens2);
-		}
+		std::deque<sax::Token> tokens1 = sax::FromXMLParserHelper::parseInput(input1);
+		std::deque<sax::Token> tokens2 = sax::FromXMLParserHelper::parseInput(input2);
 
 		if (tokens1.empty() && tokens2.empty()) throw exception::AlibException("Invalid arguments tokens streams 1 and 2 are empty.");
 		if (tokens1.empty()) throw exception::AlibException("Invalid arguments tokens stream 1 is empty.");
 		if (tokens2.empty()) throw exception::AlibException("Invalid arguments tokens stream 2 is empty.");
 
-		if(alib::XmlDataFactory::first<exception::AlibException>(tokens1)) std::cerr << alib::XmlDataFactory::fromTokens<exception::AlibException>(tokens1).getCause() << std::endl;
-		if(alib::XmlDataFactory::first<exception::AlibException>(tokens2)) std::cerr << alib::XmlDataFactory::fromTokens<exception::AlibException>(tokens2).getCause() << std::endl;
+		if(alib::XmlDataFactory::first<exception::AlibException>(tokens1)) std::cerr << alib::XmlDataFactory::fromTokens<exception::AlibException>(std::move(tokens1)).getCause() << std::endl; //TODO is this realy needed?
+		if(alib::XmlDataFactory::first<exception::AlibException>(tokens2)) std::cerr << alib::XmlDataFactory::fromTokens<exception::AlibException>(std::move(tokens2)).getCause() << std::endl;
 		if(alib::XmlDataFactory::first<exception::AlibException>(tokens1) || alib::XmlDataFactory::first<exception::AlibException>(tokens2)) return 0;
 
 		int res;
 
 		if(alib::XmlDataFactory::first<automaton::Automaton>(tokens1) && alib::XmlDataFactory::first<automaton::Automaton>(tokens2)) {
-			automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens1);
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens2);
+			automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens1));
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens2));
 
 			measurements::end();
 			measurements::start("Compare", measurements::Type::MAIN);
 
 			res = AutomatonCompare::compare(automaton1, automaton2);
 		} else if(alib::XmlDataFactory::first<grammar::Grammar>(tokens1) && alib::XmlDataFactory::first<grammar::Grammar>(tokens2)) {
-			grammar::Grammar grammar1 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens1);
-			grammar::Grammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens2);
+			grammar::Grammar grammar1 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(tokens1));
+			grammar::Grammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(tokens2));
 
 			measurements::end();
 			measurements::start("Compare", measurements::Type::MAIN);
diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index cb0bd615b5..76200868d3 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -26,8 +26,8 @@
 
 #include <factory/XmlDataFactory.hpp>
 
-ConversionHandler::ConversionHandler( std::deque<sax::Token> & tokens, const std::string & target, const std::string & algorithm ) :
-	m_tokens( tokens ),
+ConversionHandler::ConversionHandler( std::deque<sax::Token> && tokens, const std::string & target, const std::string & algorithm ) :
+	m_tokens( std::move( tokens ) ),
 	m_source( parseFormalismFromTokens( ) ),
 	m_target( parseFormalismFromString( target ) ),
 	m_algorithm( parseAlgorithmFromString( algorithm ) )
@@ -100,7 +100,7 @@ void ConversionHandler::convertCFG( void )
 
 void ConversionHandler::convertFAtoRE( void )
 {
-	const automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(m_tokens);
+	const automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(m_tokens));
 
 	measurements::end();
 	measurements::start("Algorithm", measurements::Type::MAIN);
@@ -132,7 +132,7 @@ void ConversionHandler::convertFAtoRE( void )
 
 void ConversionHandler::convertFAtoRG( void )
 {
-	const automaton::Automaton fsm = alib::XmlDataFactory::fromTokens<automaton::Automaton>( m_tokens );
+	const automaton::Automaton fsm = alib::XmlDataFactory::fromTokens<automaton::Automaton>( std::move(m_tokens ));
 
 	measurements::end();
 	measurements::start("Algorithm", measurements::Type::MAIN);
@@ -166,7 +166,7 @@ void ConversionHandler::convertFAtoRG( void )
 
 void ConversionHandler::convertREtoFA( void )
 {
-	const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(m_tokens);
+	const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(std::move(m_tokens));
 
 	measurements::end();
 	measurements::start("Algorithm", measurements::Type::MAIN);
@@ -207,7 +207,7 @@ void ConversionHandler::convertREtoFA( void )
 
 void ConversionHandler::convertREtoRG( void )
 {
-	const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(m_tokens);
+	const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(std::move(m_tokens));
 
 	measurements::end();
 	measurements::start("Algorithm", measurements::Type::MAIN);
@@ -240,7 +240,7 @@ void ConversionHandler::convertREtoRG( void )
 // ----------------------------------------------------------------------------
 
 void ConversionHandler::convertRGtoFA( void ) {
-	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(m_tokens);
+	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(m_tokens));
 
 	measurements::end();
 	measurements::start("Algorithm", measurements::Type::MAIN);
@@ -261,7 +261,7 @@ void ConversionHandler::convertRGtoFA( void ) {
 }
 
 void ConversionHandler::convertRGtoRE( void ) {
-	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(m_tokens);
+	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(m_tokens));
 
 	measurements::end();
 	measurements::start("Algorithm", measurements::Type::MAIN);
@@ -284,7 +284,7 @@ void ConversionHandler::convertRGtoRE( void ) {
 
 void ConversionHandler::convertCFGtoPDA( void )
 {
-	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(m_tokens);
+	const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(m_tokens));
 
 	measurements::end();
 	measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/aconversions2/src/ConversionHandler.h b/aconversions2/src/ConversionHandler.h
index d4452d0553..cb42dd4eee 100644
--- a/aconversions2/src/ConversionHandler.h
+++ b/aconversions2/src/ConversionHandler.h
@@ -56,7 +56,7 @@ public:
         CONTEXTFREE_GRAMMAR,
     };
 
-    ConversionHandler( std::deque<sax::Token> & tokens, const std::string & target, const std::string & algorithm );
+    ConversionHandler( std::deque<sax::Token> && tokens, const std::string & target, const std::string & algorithm );
     void convert( void );
 
 private:
@@ -81,7 +81,7 @@ private:
     void convertCFG( void );
     void convertCFGtoPDA( void );
 
-    std::deque<sax::Token> & m_tokens;
+    std::deque<sax::Token> m_tokens;
     TFormalism m_source, m_target;
     TAlgorithm m_algorithm;
 };
diff --git a/aconversions2/src/aconversion.cpp b/aconversions2/src/aconversion.cpp
index e129996a98..83dc9c60a4 100644
--- a/aconversions2/src/aconversion.cpp
+++ b/aconversions2/src/aconversion.cpp
@@ -8,9 +8,8 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
-#include <sax/SaxParseInterface.h>
-#include <sax/ParserException.h>
 #include <factory/XmlDataFactory.hpp>
 
 #include "ConversionHandler.h"
@@ -49,18 +48,7 @@ int main(int argc, char* argv[])
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> inputTokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(inputTokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), inputTokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(inputTokens);
-		}
-
-		ConversionHandler conv( inputTokens, target.getValue(), algorithm.getValue() );
+		ConversionHandler conv( sax::FromXMLParserHelper::parseInput(input), target.getValue(), algorithm.getValue() );
 		conv.convert( );
 
 		measurements::end();
diff --git a/aderivation2/src/aderivation.cpp b/aderivation2/src/aderivation.cpp
index 9fa812a48c..eb59fefea7 100644
--- a/aderivation2/src/aderivation.cpp
+++ b/aderivation2/src/aderivation.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -39,30 +40,8 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> stringTokens;
-		if(string.isSet()) {
-			if(string.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(stringTokens);
-			} else {
-				sax::SaxParseInterface::parseFile(string.getValue(), stringTokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(stringTokens);
-		}
-
-		std::deque<sax::Token> regexpTokens;
-		if(regexp.isSet()) {
-			if(regexp.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(regexpTokens);
-			} else {
-				sax::SaxParseInterface::parseFile(regexp.getValue(), regexpTokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(regexpTokens);
-		}
-
-		string::LinearString stringData = alib::XmlDataFactory::fromTokens<string::LinearString>(stringTokens);
-		regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens<regexp::RegExp>(regexpTokens);
+		string::LinearString stringData = alib::XmlDataFactory::fromTokens<string::LinearString>(sax::FromXMLParserHelper::parseInput(string));
+		regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens<regexp::RegExp>(sax::FromXMLParserHelper::parseInput(regexp));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/adeterminize2/src/adeterminize.cpp b/adeterminize2/src/adeterminize.cpp
index 3b56a1e5e5..74e8a0c7bf 100644
--- a/adeterminize2/src/adeterminize.cpp
+++ b/adeterminize2/src/adeterminize.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include "automaton/Automaton.h"
 #include "factory/XmlDataFactory.hpp"
@@ -37,18 +38,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
-
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/aecho2/src/aecho.cpp b/aecho2/src/aecho.cpp
index b9de770253..3593540aae 100644
--- a/aecho2/src/aecho.cpp
+++ b/aecho2/src/aecho.cpp
@@ -9,10 +9,9 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <string>
+#include <sax/FromXMLParserHelper.h>
 #include <exception/AlibException.h>
 #include <factory/XmlDataFactory.hpp>
-#include <sax/SaxParseInterface.h>
-#include <sax/ParserException.h>
 #include <object/Object.h>
 
 int main(int argc, char** argv) {
@@ -38,18 +37,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
-
-		alib::Object object = alib::XmlDataFactory::fromTokens<alib::Object>(tokens);
+		alib::Object object = alib::XmlDataFactory::fromTokens<alib::Object>(sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Output write", measurements::Type::AUXILIARY);
diff --git a/aepsilon2/src/aepsilon.cpp b/aepsilon2/src/aepsilon.cpp
index 7b7033b54c..e23fd53d89 100644
--- a/aepsilon2/src/aepsilon.cpp
+++ b/aepsilon2/src/aepsilon.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -50,19 +51,10 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
+		std::deque<sax::Token> tokens = sax::FromXMLParserHelper::parseInput(input);
 
 		if(algorithm.getValue() == "outgoing") {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -83,7 +75,7 @@ int main(int argc, char** argv) {
 				alib::XmlDataFactory::toStdout(res);
 			}
 		} else if(algorithm.getValue() == "incoming") {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -105,7 +97,7 @@ int main(int argc, char** argv) {
 			}
 		} else if(algorithm.getValue() == "default") {
 			if(alib::XmlDataFactory::first<automaton::Automaton>(tokens)) {
-				automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+				automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens));
 
 				measurements::end();
 				measurements::start("Algorithm", measurements::Type::MAIN);
@@ -126,7 +118,7 @@ int main(int argc, char** argv) {
 					alib::XmlDataFactory::toStdout(res);
 				}
 			} else if(alib::XmlDataFactory::first<grammar::Grammar>(tokens)) {
-				grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens);
+				grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(tokens));
 
 				measurements::end();
 				measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/agenerate2/src/agenerate.cpp b/agenerate2/src/agenerate.cpp
index 7d117f9b12..ad320ebfda 100644
--- a/agenerate2/src/agenerate.cpp
+++ b/agenerate2/src/agenerate.cpp
@@ -9,6 +9,7 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <vector>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -34,11 +35,11 @@ int main ( int argc, char * argv[] ) {
 		TCLAP::ValueArg < unsigned > upto ( "", "upto", "Generate all strings up to length", false, 5, "unsigned" );
 		cmd.add ( upto );
 
-		TCLAP::ValueArg < std::string > string ( "s", "string", "String from file", false, "-", "file" );
-		cmd.add ( string );
+		TCLAP::ValueArg < std::string > stringInput ( "s", "string", "String from file", false, "-", "file" );
+		cmd.add ( stringInput );
 
-		TCLAP::ValueArg < std::string > grammar ( "g", "grammar", "Grammar to use", false, "-", "file" );
-		cmd.add ( grammar );
+		TCLAP::ValueArg < std::string > grammarInput ( "g", "grammar", "Grammar to use", false, "-", "file" );
+		cmd.add ( grammarInput );
 
 		TCLAP::SwitchArg measure ( "m", "measure", "Measure times", false );
 		cmd.add ( measure );
@@ -57,28 +58,8 @@ int main ( int argc, char * argv[] ) {
 		measurements::start ( "Overal", measurements::Type::OVERALL );
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
-		std::deque < sax::Token > stringTokens;
-
-		if ( string.isSet ( ) ) {
-			if ( string.getValue ( ) == "-" )
-				sax::SaxParseInterface::parseStdin ( stringTokens );
-			else
-				sax::SaxParseInterface::parseFile ( string.getValue ( ), stringTokens );
-		}
-
-		std::deque < sax::Token > grammarTokens;
-
-		if ( grammar.isSet ( ) ) {
-			if ( grammar.getValue ( ) == "-" )
-				sax::SaxParseInterface::parseStdin ( grammarTokens );
-			else
-				sax::SaxParseInterface::parseFile ( grammar.getValue ( ), grammarTokens );
-		} else {
-			sax::SaxParseInterface::parseStdin ( grammarTokens );
-		}
-
 		if ( ( type.getValue ( ) == "upTo" ) && upto.isSet ( ) ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( grammarTokens );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( sax::FromXMLParserHelper::parseInput(grammarInput) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -90,8 +71,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( type.getValue ( ) == "CYK" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( grammarTokens );
-			string::LinearString string = alib::XmlDataFactory::fromTokens < string::LinearString > ( stringTokens );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( sax::FromXMLParserHelper::parseInput(grammarInput) );
+			string::LinearString string = alib::XmlDataFactory::fromTokens < string::LinearString > ( sax::FromXMLParserHelper::parseInput(stringInput) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/aintegral2/src/aintegral.cpp b/aintegral2/src/aintegral.cpp
index 9fdf5d4216..68950e964b 100644
--- a/aintegral2/src/aintegral.cpp
+++ b/aintegral2/src/aintegral.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -39,30 +40,8 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> stringTokens;
-		if(string.isSet()) {
-			if(string.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(stringTokens);
-			} else {
-				sax::SaxParseInterface::parseFile(string.getValue(), stringTokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(stringTokens);
-		}
-
-		std::deque<sax::Token> regexpTokens;
-		if(regexp.isSet()) {
-			if(regexp.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(regexpTokens);
-			} else {
-				sax::SaxParseInterface::parseFile(regexp.getValue(), regexpTokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(regexpTokens);
-		}
-
-		string::LinearString stringData = alib::XmlDataFactory::fromTokens<string::LinearString>(stringTokens);
-		regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens<regexp::RegExp>(regexpTokens);
+		string::LinearString stringData = alib::XmlDataFactory::fromTokens<string::LinearString>(sax::FromXMLParserHelper::parseInput(string));
+		regexp::RegExp regexpData = alib::XmlDataFactory::fromTokens<regexp::RegExp>(sax::FromXMLParserHelper::parseInput(regexp));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/alangop2/src/alangop.cpp b/alangop2/src/alangop.cpp
index 9594c64cff..9e8cc5e876 100644
--- a/alangop2/src/alangop.cpp
+++ b/alangop2/src/alangop.cpp
@@ -9,6 +9,7 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <vector>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -61,31 +62,10 @@ int main(int argc, char* argv[]) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> a1Tokens, a2Tokens;
-		if(a1.isSet()) {
-			if(a1.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(a1Tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(a1.getValue(), a1Tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(a1Tokens);
-		}
-
-		if(a2.isSet()) {
-			if(a2.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(a2Tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(a2.getValue(), a2Tokens);
-			}
-		} else if(algorithm.getValue() != "iteration" && algorithm.getValue() != "iterationEpsilon") {
-			sax::SaxParseInterface::parseStdin(a2Tokens);
-		}
-
-		automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a1Tokens);
+		automaton::Automaton automaton1 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
 
 		if( algorithm.getValue() == "unionEpsilon") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -98,7 +78,7 @@ int main(int argc, char* argv[]) {
 			alib::XmlDataFactory::toStdout( res );
 
 		} else if( algorithm.getValue() == "unionCartesian") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -110,7 +90,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( algorithm.getValue() == "concatenationEpsilon") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -122,7 +102,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( algorithm.getValue() == "concatenation") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -134,7 +114,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( algorithm.getValue() == "intersectionCartesian") {
-			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(a2Tokens);
+			automaton::Automaton automaton2 = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(a1));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/alib2common/src/sax/FromXMLParserHelper.cpp b/alib2common/src/sax/FromXMLParserHelper.cpp
index 26b4c59599..8203680872 100644
--- a/alib2common/src/sax/FromXMLParserHelper.cpp
+++ b/alib2common/src/sax/FromXMLParserHelper.cpp
@@ -7,6 +7,8 @@
 
 #include "FromXMLParserHelper.h"
 #include "ParserException.h"
+#include "../exception/AlibException.h"
+#include "SaxParseInterface.h"
 
 namespace sax {
 
@@ -44,4 +46,34 @@ std::string FromXMLParserHelper::getTokenData(const std::deque<Token>::const_ite
 	}
 }
 
+std::deque< sax::Token > FromXMLParserHelper::parseSingle(const std::string& input) {
+	std::deque < sax::Token > res;
+	sax::SaxParseInterface::parseFile ( input, res );
+	return res;
+}
+
+std::deque < std::deque < sax::Token > > FromXMLParserHelper::parseInput(bool needSingle, /*const*/ TCLAP::MultiArg < std::string >& input) {
+	std::deque < std::deque < sax::Token > > inputTokens;
+
+	if ( input.isSet ( ) ) {
+		if(needSingle && input.getValue().size() > 1)
+			throw exception::AlibException("Multiple parameters when single required.");
+
+		for ( const std::string & fileName : input.getValue() ) {
+			inputTokens.emplace_back ( parseSingle ( fileName ) );
+		}
+	} else {
+		inputTokens.emplace_back ( parseSingle ( "-" ) );
+	}
+
+	return inputTokens;
+}
+
+std::deque < sax::Token > FromXMLParserHelper::parseInput(/*const*/ TCLAP::ValueArg < std::string >& input) {
+	if ( input.isSet ( ) ) {
+		return parseSingle ( input.getValue() );
+	} else {
+		return parseSingle ( "-" );
+	}
+}
 } /* namespace sax */
diff --git a/alib2common/src/sax/FromXMLParserHelper.h b/alib2common/src/sax/FromXMLParserHelper.h
index 7492b2ff8f..3b5526935c 100644
--- a/alib2common/src/sax/FromXMLParserHelper.h
+++ b/alib2common/src/sax/FromXMLParserHelper.h
@@ -8,6 +8,9 @@
 #ifndef FROM_XML_PARSER_HELPER_H_
 #define FROM_XML_PARSER_HELPER_H_
 
+#include <tclap/MultiArg.h>
+#include <tclap/ValueArg.h>
+#include <string>
 #include <deque>
 #include "Token.h"
 
@@ -24,6 +27,11 @@ public:
 	static std::string popTokenData(std::deque<Token>::iterator& input, Token::TokenType type);
 	static std::string getTokenData(const std::deque<Token>::const_iterator& input, Token::TokenType type);
 
+	static std::deque < std::deque < sax::Token > > parseInput(bool needSingle, /*const*/ TCLAP::MultiArg < std::string >& input);
+	static std::deque < sax::Token > parseInput(/*const*/ TCLAP::ValueArg < std::string >& input);
+
+private:
+	static std::deque< sax::Token > parseSingle(const std::string& input);
 };
 
 } /* namespace sax */
diff --git a/alib2data/src/factory/XmlDataFactory.hpp b/alib2data/src/factory/XmlDataFactory.hpp
index 9ec05921ae..9d86e98fa6 100644
--- a/alib2data/src/factory/XmlDataFactory.hpp
+++ b/alib2data/src/factory/XmlDataFactory.hpp
@@ -35,7 +35,7 @@ public:
 		std::deque < sax::Token > tokens;
 		sax::SaxParseInterface::parseFile ( filename, tokens );
 
-		return fromTokens < T > ( tokens );
+		return fromTokens < T > ( std::move( tokens ) );
 	}
 
 	/**
@@ -48,7 +48,7 @@ public:
 		std::deque < sax::Token > tokens;
 		sax::SaxParseInterface::parseMemory ( str, tokens );
 
-		return fromTokens < T > ( tokens );
+		return fromTokens < T > ( std::move ( tokens ) );
 	}
 
 	/**
@@ -60,7 +60,7 @@ public:
 		std::deque < sax::Token > tokens;
 		sax::SaxParseInterface::parseStdin ( tokens );
 
-		return fromTokens < T > ( tokens );
+		return fromTokens < T > ( std::move ( tokens ) );
 	}
 
 	/**
@@ -72,7 +72,7 @@ public:
 		std::deque < sax::Token > tokens;
 		sax::SaxParseInterface::parseStream ( in, tokens );
 
-		return fromTokens < T > ( tokens );
+		return fromTokens < T > ( std::move ( tokens ) );
 	}
 
 	/**
@@ -81,7 +81,7 @@ public:
 	 * @return parsed String
 	 */
 	template < class T >
-	static T fromTokens ( std::deque < sax::Token > & tokens ) {
+	static T fromTokens ( std::deque < sax::Token > && tokens ) {
 		xmlApiInputContext context ( tokens.begin ( ) );
 
 		if ( context == tokens.end ( ) ) throw exception::AlibException ( "Empty tokens list" );
@@ -176,7 +176,7 @@ inline bool XmlDataFactory::first < exception::AlibException > ( const std::dequ
 }
 
 template < >
-inline exception::AlibException XmlDataFactory::fromTokens < exception::AlibException > ( std::deque < sax::Token > & tokens ) {
+inline exception::AlibException XmlDataFactory::fromTokens < exception::AlibException > ( std::deque < sax::Token > && tokens ) {
 	std::deque < sax::Token >::iterator iter = tokens.begin ( );
 
 	if ( iter == tokens.end ( ) ) throw exception::AlibException ( "Empty tokens list" );
diff --git a/alib2data/test-src/alphabet/SymbolTest.cpp b/alib2data/test-src/alphabet/SymbolTest.cpp
index c946cb5ce3..da3eb446f8 100644
--- a/alib2data/test-src/alphabet/SymbolTest.cpp
+++ b/alib2data/test-src/alphabet/SymbolTest.cpp
@@ -49,7 +49,7 @@ void SymbolTest::testXMLParser ( ) {
 
 		std::deque < sax::Token > tokens2;
 		sax::SaxParseInterface::parseMemory ( tmp, tokens2 );
-		alphabet::Symbol symbol2 = alib::XmlDataFactory::fromTokens < alphabet::Symbol > ( tokens2 );
+		alphabet::Symbol symbol2 = alib::XmlDataFactory::fromTokens < alphabet::Symbol > ( std::move( tokens2 ) );
 
 		CPPUNIT_ASSERT ( symbol == symbol2 );
 	}
diff --git a/alib2data/test-src/automaton/AutomatonTest.cpp b/alib2data/test-src/automaton/AutomatonTest.cpp
index da072c1708..0fc461c90b 100644
--- a/alib2data/test-src/automaton/AutomatonTest.cpp
+++ b/alib2data/test-src/automaton/AutomatonTest.cpp
@@ -55,7 +55,7 @@ void AutomatonTest::testDFAParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		automaton::DFA automaton2 = alib::XmlDataFactory::fromTokens<automaton::DFA>(tokens2);
+		automaton::DFA automaton2 = alib::XmlDataFactory::fromTokens<automaton::DFA>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( automaton == automaton2 );
 	}
@@ -273,7 +273,7 @@ void AutomatonTest::testNFTAParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		automaton::NFTA automaton2 = alib::XmlDataFactory::fromTokens<automaton::NFTA>(tokens2);
+		automaton::NFTA automaton2 = alib::XmlDataFactory::fromTokens<automaton::NFTA>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( automaton == automaton2 );
 	}
diff --git a/alib2data/test-src/grammar/GrammarTest.cpp b/alib2data/test-src/grammar/GrammarTest.cpp
index d9b400c9b0..b9f7674f50 100644
--- a/alib2data/test-src/grammar/GrammarTest.cpp
+++ b/alib2data/test-src/grammar/GrammarTest.cpp
@@ -59,7 +59,7 @@ void GrammarTest::testUnrestrictedParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		grammar::UnrestrictedGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::UnrestrictedGrammar>(tokens2);
+		grammar::UnrestrictedGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::UnrestrictedGrammar>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( grammar == grammar2 );
 	}
@@ -85,7 +85,7 @@ void GrammarTest::testUnrestrictedParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::ContextPreservingUnrestrictedGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::ContextPreservingUnrestrictedGrammar>(tokens2);
+			grammar::ContextPreservingUnrestrictedGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::ContextPreservingUnrestrictedGrammar>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -113,7 +113,7 @@ void GrammarTest::testRegularParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::RightRG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightRG>(tokens2);
+			grammar::RightRG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightRG>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -143,7 +143,7 @@ void GrammarTest::testRegularParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::RightLG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightLG>(tokens2);
+			grammar::RightLG grammar2 = alib::XmlDataFactory::fromTokens<grammar::RightLG>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -173,7 +173,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::LG grammar2 = alib::XmlDataFactory::fromTokens<grammar::LG>(tokens2);
+			grammar::LG grammar2 = alib::XmlDataFactory::fromTokens<grammar::LG>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -201,7 +201,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::EpsilonFreeCFG grammar2 = alib::XmlDataFactory::fromTokens<grammar::EpsilonFreeCFG>(tokens2);
+			grammar::EpsilonFreeCFG grammar2 = alib::XmlDataFactory::fromTokens<grammar::EpsilonFreeCFG>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -229,7 +229,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::CFG grammar2 = alib::XmlDataFactory::fromTokens<grammar::CFG>(tokens2);
+			grammar::CFG grammar2 = alib::XmlDataFactory::fromTokens<grammar::CFG>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -257,7 +257,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::CNF grammar2 = alib::XmlDataFactory::fromTokens<grammar::CNF>(tokens2);
+			grammar::CNF grammar2 = alib::XmlDataFactory::fromTokens<grammar::CNF>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -285,7 +285,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::GNF grammar2 = alib::XmlDataFactory::fromTokens<grammar::GNF>(tokens2);
+			grammar::GNF grammar2 = alib::XmlDataFactory::fromTokens<grammar::GNF>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -315,7 +315,7 @@ void GrammarTest::testContextSensitiveParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::CSG grammar2 = alib::XmlDataFactory::fromTokens<grammar::CSG>(tokens2);
+			grammar::CSG grammar2 = alib::XmlDataFactory::fromTokens<grammar::CSG>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
@@ -342,7 +342,7 @@ void GrammarTest::testContextSensitiveParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::NonContractingGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::NonContractingGrammar>(tokens2);
+			grammar::NonContractingGrammar grammar2 = alib::XmlDataFactory::fromTokens<grammar::NonContractingGrammar>(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
diff --git a/alib2data/test-src/label/LabelTest.cpp b/alib2data/test-src/label/LabelTest.cpp
index 5c3516a91d..a5f8a371f6 100644
--- a/alib2data/test-src/label/LabelTest.cpp
+++ b/alib2data/test-src/label/LabelTest.cpp
@@ -48,7 +48,7 @@ void LabelTest::testXMLParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		label::Label label2 = alib::XmlDataFactory::fromTokens<label::Label>(tokens2);
+		label::Label label2 = alib::XmlDataFactory::fromTokens<label::Label>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( label == label2 );
 	}
diff --git a/alib2data/test-src/primitive/PrimitiveTest.cpp b/alib2data/test-src/primitive/PrimitiveTest.cpp
index 5e5fe0a9e6..cc5250b6f8 100644
--- a/alib2data/test-src/primitive/PrimitiveTest.cpp
+++ b/alib2data/test-src/primitive/PrimitiveTest.cpp
@@ -33,7 +33,7 @@ void PrimitiveTest::testXMLParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		primitive::Primitive primitive2 = alib::XmlDataFactory::fromTokens<primitive::Primitive>(tokens2);
+		primitive::Primitive primitive2 = alib::XmlDataFactory::fromTokens<primitive::Primitive>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( primitive == primitive2 );
 	}
diff --git a/alib2data/test-src/regexp/RegExpTest.cpp b/alib2data/test-src/regexp/RegExpTest.cpp
index 534d07b24c..381b929251 100644
--- a/alib2data/test-src/regexp/RegExpTest.cpp
+++ b/alib2data/test-src/regexp/RegExpTest.cpp
@@ -105,7 +105,7 @@ void RegExpTest::testXMLParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		regexp::RegExp regexp2 = alib::XmlDataFactory::fromTokens<regexp::RegExp>(tokens2);
+		regexp::RegExp regexp2 = alib::XmlDataFactory::fromTokens<regexp::RegExp>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( regexp == regexp2 );
 	}
diff --git a/alib2data/test-src/string/StringTest.cpp b/alib2data/test-src/string/StringTest.cpp
index a4bc23fa0a..9680669d53 100644
--- a/alib2data/test-src/string/StringTest.cpp
+++ b/alib2data/test-src/string/StringTest.cpp
@@ -59,7 +59,7 @@ void StringTest::testXMLParser ( ) {
 
 		std::deque < sax::Token > tokens2;
 		sax::SaxParseInterface::parseMemory ( tmp, tokens2 );
-		string::String string2 = alib::XmlDataFactory::fromTokens < string::String > ( tokens2 );
+		string::String string2 = alib::XmlDataFactory::fromTokens < string::String > ( std::move( tokens2 ) );
 
 		CPPUNIT_ASSERT ( string == string2 );
 	}
diff --git a/alib2data/test-src/tree/PatternTest.cpp b/alib2data/test-src/tree/PatternTest.cpp
index 9ade84aab4..c4a62de7ef 100644
--- a/alib2data/test-src/tree/PatternTest.cpp
+++ b/alib2data/test-src/tree/PatternTest.cpp
@@ -55,7 +55,7 @@ void PatternTest::testRankedPatternParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::RankedPattern tree2 = alib::XmlDataFactory::fromTokens<tree::RankedPattern>(tokens2);
+		tree::RankedPattern tree2 = alib::XmlDataFactory::fromTokens<tree::RankedPattern>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree == tree2 );
 		std::cout << std::endl;
@@ -105,7 +105,7 @@ void PatternTest::testUnrankedPatternParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::UnrankedPattern tree2 = alib::XmlDataFactory::fromTokens<tree::UnrankedPattern>(tokens2);
+		tree::UnrankedPattern tree2 = alib::XmlDataFactory::fromTokens<tree::UnrankedPattern>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree == tree2 );
 		std::cout << std::endl;
@@ -155,7 +155,7 @@ void PatternTest::testPrefixRankedPatternParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::PrefixRankedPattern pattern3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedPattern>(tokens2);
+		tree::PrefixRankedPattern pattern3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedPattern>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( pattern2 == pattern3 );
 		std::cout << std::endl;
@@ -191,7 +191,7 @@ void PatternTest::testPrefixRankedBarPatternParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::PrefixRankedBarPattern pattern3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedBarPattern>(tokens2);
+		tree::PrefixRankedBarPattern pattern3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedBarPattern>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( pattern2 == pattern3 );
 		std::cout << std::endl;
diff --git a/alib2data/test-src/tree/TreeTest.cpp b/alib2data/test-src/tree/TreeTest.cpp
index 7d1ad8136d..0ad6a928a4 100644
--- a/alib2data/test-src/tree/TreeTest.cpp
+++ b/alib2data/test-src/tree/TreeTest.cpp
@@ -76,7 +76,7 @@ void TreeTest::testRankedTreeParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::RankedTree tree2 = alib::XmlDataFactory::fromTokens<tree::RankedTree>(tokens2);
+		tree::RankedTree tree2 = alib::XmlDataFactory::fromTokens<tree::RankedTree>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree == tree2 );
 		std::cout << std::endl;
@@ -252,7 +252,7 @@ void TreeTest::testUnrankedTreeParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::UnrankedTree tree2 = alib::XmlDataFactory::fromTokens<tree::UnrankedTree>(tokens2);
+		tree::UnrankedTree tree2 = alib::XmlDataFactory::fromTokens<tree::UnrankedTree>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree == tree2 );
 		std::cout << std::endl;
@@ -410,7 +410,7 @@ void TreeTest::testPrefixRankedBarParser() {
 
 		std::deque<sax::Token> tokens2;
 		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::PrefixRankedBarTree tree3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedBarTree>(tokens2);
+		tree::PrefixRankedBarTree tree3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedBarTree>(std::move(tokens2));
 
 		CPPUNIT_ASSERT( tree2 == tree3 );
 		std::cout << std::endl;
diff --git a/alphabetManip2/src/alphabetManip.cpp b/alphabetManip2/src/alphabetManip.cpp
index 9688496d39..843935ce92 100644
--- a/alphabetManip2/src/alphabetManip.cpp
+++ b/alphabetManip2/src/alphabetManip.cpp
@@ -9,6 +9,7 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <vector>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -20,7 +21,7 @@
 #include <iostream>
 
 template < class T >
-void process ( T & data, TCLAP::ValueArg < std::string > & operation, std::deque < sax::Token > & argumentTokens ) {
+void process ( T & data, TCLAP::ValueArg < std::string > & operation, std::deque < sax::Token > && argumentTokens ) {
 	typedef typename std::remove_const < typename std::remove_reference < decltype ( data.getAlphabet ( ) ) >::type >::type alphabetType;
 
 	if ( operation.getValue ( ) == "get" ) {
@@ -34,7 +35,7 @@ void process ( T & data, TCLAP::ValueArg < std::string > & operation, std::deque
 
 		alib::XmlDataFactory::toStdout ( res );
 	} else if ( operation.getValue ( ) == "add" ) {
-		alphabetType symbols = alib::XmlDataFactory::fromTokens < alphabetType > ( argumentTokens );
+		alphabetType symbols = alib::XmlDataFactory::fromTokens < alphabetType > ( std::move ( argumentTokens ) );
 
 		measurements::end ( );
 		measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -88,35 +89,21 @@ int main ( int argc, char * argv[] ) {
 		measurements::start ( "Overal", measurements::Type::OVERALL );
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
-		std::deque < sax::Token > inputTokens;
-
-		if ( input.isSet ( ) ) {
-			if ( input.getValue ( ) == "-" )
-				sax::SaxParseInterface::parseStdin ( inputTokens );
-			else
-				sax::SaxParseInterface::parseFile ( input.getValue ( ), inputTokens );
-		} else {
-			sax::SaxParseInterface::parseStdin ( inputTokens );
-		}
+		std::deque < sax::Token > inputTokens = sax::FromXMLParserHelper::parseInput(input);
 
 		std::deque < sax::Token > argumentTokens;
-
-		if ( argument.isSet ( ) ) {
-			if ( argument.getValue ( ) == "-" )
-				sax::SaxParseInterface::parseStdin ( argumentTokens );
-			else
-				sax::SaxParseInterface::parseFile ( argument.getValue ( ), argumentTokens );
-		}
+		if ( argument.isSet ( ) )
+			argumentTokens = sax::FromXMLParserHelper::parseInput( argument );
 
 		if ( alib::XmlDataFactory::first < tree::RankedTreeWrapper > ( inputTokens ) ) {
-			tree::RankedTreeWrapper data = alib::XmlDataFactory::fromTokens < tree::RankedTreeWrapper > ( inputTokens );
-			process ( data, operation, argumentTokens );
+			tree::RankedTreeWrapper data = alib::XmlDataFactory::fromTokens < tree::RankedTreeWrapper > ( std::move ( inputTokens ) );
+			process ( data, operation, std::move ( argumentTokens ) );
 		} else if ( alib::XmlDataFactory::first < tree::UnrankedTreeWrapper > ( inputTokens ) ) {
-			tree::UnrankedTreeWrapper data = alib::XmlDataFactory::fromTokens < tree::UnrankedTreeWrapper > ( inputTokens );
-			process ( data, operation, argumentTokens );
+			tree::UnrankedTreeWrapper data = alib::XmlDataFactory::fromTokens < tree::UnrankedTreeWrapper > ( std::move ( inputTokens ) );
+			process ( data, operation, std::move ( argumentTokens ) );
 		} else if ( alib::XmlDataFactory::first < string::String > ( inputTokens ) ) {
-			string::String data = alib::XmlDataFactory::fromTokens < string::String > ( inputTokens );
-			process ( data, operation, argumentTokens );
+			string::String data = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( inputTokens ) );
+			process ( data, operation, std::move ( argumentTokens ) );
 		} else {
 			throw exception::AlibException ( "Invalid data type" );
 		}
diff --git a/aminimize2/src/aminimize.cpp b/aminimize2/src/aminimize.cpp
index 3176084f69..8c05c2959d 100644
--- a/aminimize2/src/aminimize.cpp
+++ b/aminimize2/src/aminimize.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include <exception/AlibException.h>
 #include <factory/XmlDataFactory.hpp>
@@ -44,18 +45,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
-
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/anormalize2/src/anormalize.cpp b/anormalize2/src/anormalize.cpp
index 8c26180775..51e594a26e 100644
--- a/anormalize2/src/anormalize.cpp
+++ b/anormalize2/src/anormalize.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include "exception/AlibException.h"
 #include "factory/XmlDataFactory.hpp"
@@ -69,19 +70,10 @@ int main ( int argc, char * * argv ) {
 		measurements::start ( "Overal", measurements::Type::OVERALL );
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
-		std::deque < sax::Token > tokens;
-
-		if ( input.isSet ( ) ) {
-			if ( input.getValue ( ) == "-" )
-				sax::SaxParseInterface::parseStdin ( tokens );
-			else
-				sax::SaxParseInterface::parseFile ( input.getValue ( ), tokens );
-		} else {
-			sax::SaxParseInterface::parseStdin ( tokens );
-		}
+		std::deque < sax::Token > tokens = sax::FromXMLParserHelper::parseInput(input);
 
 		if ( labels.getValue ( ) == "automaton" ) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( tokens );
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -93,7 +85,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( labels.getValue ( ) == "grammar" ) {
-			// grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>( tokens );
+			// grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -105,7 +97,7 @@ int main ( int argc, char * * argv ) {
 
 			// alib::XmlDataFactory::toStdout(res);
 		} else if ( alphabet.getValue ( ) == "string" ) {
-			string::String string = alib::XmlDataFactory::fromTokens < string::String > ( tokens );
+			string::String string = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -117,7 +109,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "leftRG" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( tokens );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -129,7 +121,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "rightRG" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( tokens );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -141,7 +133,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "singleInitialState" ) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( tokens );
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -153,7 +145,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "CNF" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( tokens );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -165,7 +157,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "GNF" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( tokens );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -177,7 +169,7 @@ int main ( int argc, char * * argv ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( form.getValue ( ) == "LL1" ) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( tokens );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/araw2/src/araw.cpp b/araw2/src/araw.cpp
index 2c7d1fc13d..b8640350b2 100644
--- a/araw2/src/araw.cpp
+++ b/araw2/src/araw.cpp
@@ -9,6 +9,7 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <string>
+#include <sax/FromXMLParserHelper.h>
 #include <fstream>
 #include <exception/AlibException.h>
 #include <RawApi.hpp>
@@ -62,16 +63,7 @@ int main(int argc, char** argv) {
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
 		if(tree_from_raw.getValue()) {
-			std::deque<sax::Token> tokens;
-			if(input.isSet()) {
-				if(input.getValue() == "-") {
-					sax::SaxParseInterface::parseStdin(tokens);
-				} else {
-					sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-				}
-			} else {
-				sax::SaxParseInterface::parseStdin(tokens);
-			}
+			std::deque<sax::Token> tokens = sax::FromXMLParserHelper::parseInput(input);
 
 			std::deque<sax::Token>::iterator iter = tokens.begin();
 			tree::Tree tree = alib::FromRawParsers::treeParser.parseTree(iter);
@@ -81,18 +73,7 @@ int main(int argc, char** argv) {
 
 			alib::XmlDataFactory::toStdout(tree);
 		} else if(tree_to_raw.getValue()) {
-			std::deque<sax::Token> tokens;
-			if(input.isSet()) {
-				if(input.getValue() == "-") {
-					sax::SaxParseInterface::parseStdin(tokens);
-				} else {
-					sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-				}
-			} else {
-				sax::SaxParseInterface::parseStdin(tokens);
-			}
-
-			tree::Tree tree = alib::XmlDataFactory::fromTokens<tree::Tree>(tokens);
+			tree::Tree tree = alib::XmlDataFactory::fromTokens<tree::Tree>(sax::FromXMLParserHelper::parseInput(input));
 
 			measurements::end();
 			measurements::start("Output write", measurements::Type::AUXILIARY);
@@ -121,18 +102,7 @@ int main(int argc, char** argv) {
 
 			alib::XmlDataFactory::toStdout(string);
 		} else if(string_to_raw.getValue()) {
-			std::deque<sax::Token> tokens;
-			if(input.isSet()) {
-				if(input.getValue() == "-") {
-					sax::SaxParseInterface::parseStdin(tokens);
-				} else {
-					sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-				}
-			} else {
-				sax::SaxParseInterface::parseStdin(tokens);
-			}
-
-			string::String string = alib::XmlDataFactory::fromTokens<string::String>(tokens);
+			string::String string = alib::XmlDataFactory::fromTokens<string::String>(sax::FromXMLParserHelper::parseInput(input));
 
 			measurements::end();
 			measurements::start("Output write", measurements::Type::AUXILIARY);
diff --git a/arename2/src/arename.cpp b/arename2/src/arename.cpp
index dc2fb7cdac..137966326d 100644
--- a/arename2/src/arename.cpp
+++ b/arename2/src/arename.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include "exception/AlibException.h"
 #include "factory/XmlDataFactory.hpp"
@@ -37,18 +38,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
-
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/areverse2/src/areverse.cpp b/areverse2/src/areverse.cpp
index 19f2210798..7138907ec8 100644
--- a/areverse2/src/areverse.cpp
+++ b/areverse2/src/areverse.cpp
@@ -8,7 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
-#include <iostream>
+#include <sax/FromXMLParserHelper.h>
 
 #include "exception/AlibException.h"
 #include "factory/XmlDataFactory.hpp"
@@ -38,18 +38,7 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
-
-		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+		automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(input));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/arun2/src/arun.cpp b/arun2/src/arun.cpp
index 67af24994e..38f03b9587 100644
--- a/arun2/src/arun.cpp
+++ b/arun2/src/arun.cpp
@@ -9,6 +9,7 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <vector>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -59,30 +60,8 @@ int main(int argc, char* argv[]) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> inputTokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(inputTokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), inputTokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(inputTokens);
-		}
-
-		std::deque<sax::Token> automatonTokens;
-		if(automaton.isSet()) {
-			if(automaton.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(automatonTokens);
-			} else {
-				sax::SaxParseInterface::parseFile(automaton.getValue(), automatonTokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(automatonTokens);
-		}
-
-		alib::Object inputData = alib::XmlDataFactory::fromTokens<alib::Object>(inputTokens);
-		automaton::Automaton automatonData = alib::XmlDataFactory::fromTokens<automaton::Automaton>(automatonTokens);
+		alib::Object inputData = alib::XmlDataFactory::fromTokens<alib::Object>(sax::FromXMLParserHelper::parseInput(input));
+		automaton::Automaton automatonData = alib::XmlDataFactory::fromTokens<automaton::Automaton>(sax::FromXMLParserHelper::parseInput(automaton));
 
 		measurements::end();
 		measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/astat2/src/astat.cpp b/astat2/src/astat.cpp
index 04aa9c0858..fc07fd6368 100644
--- a/astat2/src/astat.cpp
+++ b/astat2/src/astat.cpp
@@ -9,6 +9,7 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <vector>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -129,16 +130,7 @@ int main ( int argc, char * argv[] ) {
 
 		PrintingOptions printingOption = translatePrintingOptions ( presentation.getValue ( ) );
 
-		std::deque < sax::Token > tokens;
-
-		if ( file.isSet ( ) ) {
-			if ( file.getValue ( ) == "-" )
-				sax::SaxParseInterface::parseStdin ( tokens );
-			else
-				sax::SaxParseInterface::parseFile ( file.getValue ( ), tokens );
-		} else {
-			sax::SaxParseInterface::parseStdin ( tokens );
-		}
+		std::deque < sax::Token > tokens = sax::FromXMLParserHelper::parseInput(file);
 
 		if ( alib::XmlDataFactory::first < automaton::Automaton > ( tokens ) && automaton.isSet ( ) ) {
 			AutomataSettings settings = { PrintingOptions::NOOP, PrintingOptions::NOOP, PrintingOptions::NOOP, PrintingOptions::NOOP, PrintingOptions::NOOP };
@@ -161,7 +153,7 @@ int main ( int argc, char * argv[] ) {
 			if ( values.count ( "transitions" ) )
 				settings.transitions = printingOption;
 
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( tokens );
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens < automaton::Automaton > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
@@ -185,7 +177,7 @@ int main ( int argc, char * argv[] ) {
 			if ( values.count ( "rules" ) )
 				settings.rules = printingOption;
 
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( tokens );
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens < grammar::Grammar > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
@@ -203,7 +195,7 @@ int main ( int argc, char * argv[] ) {
 			if ( values.count ( "nodes" ) )
 				settings.nodes = printingOption;
 
-			regexp::RegExp regexp = alib::XmlDataFactory::fromTokens < regexp::RegExp > ( tokens );
+			regexp::RegExp regexp = alib::XmlDataFactory::fromTokens < regexp::RegExp > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
@@ -221,7 +213,7 @@ int main ( int argc, char * argv[] ) {
 			if ( values.count ( "content" ) )
 				settings.content = printingOption;
 
-			string::String string = alib::XmlDataFactory::fromTokens < string::String > ( tokens );
+			string::String string = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
@@ -239,7 +231,7 @@ int main ( int argc, char * argv[] ) {
 			if ( values.count ( "nodes" ) )
 				settings.nodes = printingOption;
 
-			tree::Tree tree = alib::XmlDataFactory::fromTokens < tree::Tree > ( tokens );
+			tree::Tree tree = alib::XmlDataFactory::fromTokens < tree::Tree > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
@@ -249,7 +241,7 @@ int main ( int argc, char * argv[] ) {
 			SetSettings settings = { PrintingOptions::NOOP };
 			settings.general = printingOption;
 
-			container::ObjectsSet data = alib::XmlDataFactory::fromTokens < container::ObjectsSet > ( tokens );
+			container::ObjectsSet data = alib::XmlDataFactory::fromTokens < container::ObjectsSet > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
@@ -259,7 +251,7 @@ int main ( int argc, char * argv[] ) {
 			SetSettings settings = { PrintingOptions::NOOP };
 			settings.general = printingOption;
 
-			label::LabelSetLabel data = alib::XmlDataFactory::fromTokens < label::LabelSetLabel > ( tokens );
+			label::LabelSetLabel data = alib::XmlDataFactory::fromTokens < label::LabelSetLabel > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
@@ -269,7 +261,7 @@ int main ( int argc, char * argv[] ) {
 			SetSettings settings = { PrintingOptions::NOOP };
 			settings.general = printingOption;
 
-			alphabet::SymbolSetSymbol data = alib::XmlDataFactory::fromTokens < alphabet::SymbolSetSymbol > ( tokens );
+			alphabet::SymbolSetSymbol data = alib::XmlDataFactory::fromTokens < alphabet::SymbolSetSymbol > ( std::move ( tokens ) );
 
 			measurements::end ( );
 			measurements::start ( "Stats print", measurements::Type::MAIN );
diff --git a/astringology2/src/astringology.cpp b/astringology2/src/astringology.cpp
index b6df3b30c8..42e9daa01c 100644
--- a/astringology2/src/astringology.cpp
+++ b/astringology2/src/astringology.cpp
@@ -9,6 +9,7 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <vector>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -51,11 +52,11 @@ int main ( int argc, char * argv[] ) {
 		TCLAP::ValueArg < std::string > algorithm ( "a", "algorithm", "Execute algorithm", false, "exactFactorMatch", & allowedVals );
 		cmd.add ( algorithm );
 
-		TCLAP::MultiArg < std::string > subject ( "s", "subject", "Subject string from file", false, "file" );
-		cmd.add ( subject );
+		TCLAP::MultiArg < std::string > subjectInput ( "s", "subject", "Subject string from file", false, "file" );
+		cmd.add ( subjectInput );
 
-		TCLAP::MultiArg < std::string > pattern ( "p", "pattern", "Pattern string from file", false, "file" );
-		cmd.add ( pattern );
+		TCLAP::MultiArg < std::string > patternInput ( "p", "pattern", "Pattern string from file", false, "file" );
+		cmd.add ( patternInput );
 
 		TCLAP::SwitchArg measure ( "m", "measure", "Measure times", false );
 		cmd.add ( measure );
@@ -70,76 +71,12 @@ int main ( int argc, char * argv[] ) {
 		if(measure.isSet())
 			common::GlobalData::measure = true;
 
-		int needPattern = 0;
-		int needSubject = 0;
-
-		if ( algorithm.getValue ( ) == "exactFactorMatch" ) {
-			needPattern = needSubject = 1;
-		} else if ( algorithm.getValue ( ) == "boyerMooreHorspool" ) {
-			needPattern = needSubject = 1;
-		} else if ( algorithm.getValue ( ) == "reversedBoyerMooreHorspool" ) {
-			needPattern = needSubject = 1;
-		} else if ( algorithm.getValue ( ) == "deadZoneUsingBadCharacterShift" ) {
-			needPattern = needSubject = 1;
-		} else if ( algorithm.getValue ( ) == "exactMatchingAutomaton" ) {
-			needPattern = 1;
-		} else if ( algorithm.getValue ( ) == "exactFactorAutomaton" ) {
-			needSubject = 1;
-		} else if ( algorithm.getValue ( ) == "exactSubsequenceAutomaton" ) {
-			needSubject = 1;
-		} else if ( algorithm.getValue ( ) == "exactNondeterministicSubsequenceAutomaton" ) {
-			needSubject = 1;
-		} else if ( algorithm.getValue ( ) == "exactMultiNondeterministicSubsequenceAutomaton" ) {
-			needSubject = 2;
-		} else if ( algorithm.getValue ( ) == "borderArray" ) {
-			needSubject = 1;
-		} else {
-		}
-
 		measurements::start ( "Overal", measurements::Type::OVERALL );
 		measurements::start ( "Input read", measurements::Type::AUXILIARY );
 
-		std::deque < std::deque < sax::Token > > subjectTokens;
-
-		if ( subject.isSet ( ) ) {
-			for ( const std::string & fileName : subject.getValue ( ) ) {
-				std::deque < sax::Token > tmp;
-
-				if ( fileName == "-" )
-					sax::SaxParseInterface::parseStdin ( tmp );
-				else
-					sax::SaxParseInterface::parseFile ( fileName, tmp );
-
-				subjectTokens.emplace_back ( std::move ( tmp ) );
-			}
-		} else if ( needSubject ) {
-			std::deque < sax::Token > tmp;
-			sax::SaxParseInterface::parseStdin ( tmp );
-			subjectTokens.emplace_back ( std::move ( tmp ) );
-		}
-
-		std::deque < std::deque < sax::Token > > patternTokens;
-
-		if ( pattern.isSet ( ) ) {
-			for ( const std::string & fileName : pattern.getValue ( ) ) {
-				std::deque < sax::Token > tmp;
-
-				if ( fileName == "-" )
-					sax::SaxParseInterface::parseStdin ( tmp );
-				else
-					sax::SaxParseInterface::parseFile ( fileName, tmp );
-
-				patternTokens.emplace_back ( std::move ( tmp ) );
-			}
-		} else if ( needPattern ) {
-			std::deque < sax::Token > tmp;
-			sax::SaxParseInterface::parseStdin ( tmp );
-			patternTokens.emplace_back ( std::move ( tmp ) );
-		}
-
 		if ( algorithm.getValue ( ) == "exactFactorMatch" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( patternTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -151,8 +88,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "boyerMooreHorspool" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( patternTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -164,8 +101,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "reversedBoyerMooreHorspool" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( patternTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -177,8 +114,8 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "deadZoneUsingBadCharacterShift" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( patternTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -190,7 +127,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( res );
 		} else if ( algorithm.getValue ( ) == "exactMatchingAutomaton" ) {
-			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( patternTokens.front ( ) );
+			string::String pattern = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, patternInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -202,7 +139,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "exactFactorAutomaton" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -214,7 +151,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "exactSubsequenceAutomaton" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -226,7 +163,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "exactNondeterministicSubsequenceAutomaton" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -240,8 +177,8 @@ int main ( int argc, char * argv[] ) {
 		} else if ( algorithm.getValue ( ) == "exactMultiNondeterministicSubsequenceAutomaton" ) {
 			std::set < string::String > subjects;
 
-			for ( std::deque < sax::Token > & tokens : subjectTokens )
-				subjects.insert ( alib::XmlDataFactory::fromTokens < string::String > ( tokens ) );
+			for ( std::deque < sax::Token > & tokens : sax::FromXMLParserHelper::parseInput(false, subjectInput) )
+				subjects.insert ( alib::XmlDataFactory::fromTokens < string::String > ( std::move ( tokens ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -253,7 +190,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( automaton );
 		} else if ( algorithm.getValue ( ) == "borderArray" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
@@ -265,7 +202,7 @@ int main ( int argc, char * argv[] ) {
 
 			alib::XmlDataFactory::toStdout ( borderArray );
 		} else if ( algorithm.getValue ( ) == "suffixTrie" ) {
-			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( subjectTokens.front ( ) );
+			string::String subject = alib::XmlDataFactory::fromTokens < string::String > ( std::move ( sax::FromXMLParserHelper::parseInput(true, subjectInput).front ( ) ) );
 
 			measurements::end ( );
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
diff --git a/atrim2/src/atrim.cpp b/atrim2/src/atrim.cpp
index 7887c8e059..7dc35ed7e9 100644
--- a/atrim2/src/atrim.cpp
+++ b/atrim2/src/atrim.cpp
@@ -8,6 +8,7 @@
 #include <tclap/CmdLine.h>
 #include <global/GlobalData.h>
 #include <measure>
+#include <sax/FromXMLParserHelper.h>
 
 #include <factory/XmlDataFactory.hpp>
 #include <exception/AlibException.h>
@@ -92,19 +93,10 @@ int main(int argc, char* argv[]) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
+		std::deque<sax::Token> tokens = sax::FromXMLParserHelper::parseInput(input);
 
 		if( alib::XmlDataFactory::first<automaton::Automaton>(tokens)) {
-			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
+			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -125,7 +117,7 @@ int main(int argc, char* argv[]) {
 				alib::XmlDataFactory::toStdout( res );
 			}
 		} else if( alib::XmlDataFactory::first<grammar::Grammar>(tokens)) {
-			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(tokens);
+			grammar::Grammar grammar = alib::XmlDataFactory::fromTokens<grammar::Grammar>(std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
@@ -137,7 +129,7 @@ int main(int argc, char* argv[]) {
 
 			alib::XmlDataFactory::toStdout( res );
 		} else if( alib::XmlDataFactory::first<regexp::RegExp>(tokens)) {
-			regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(tokens);
+			regexp::RegExp regexp = alib::XmlDataFactory::fromTokens<regexp::RegExp>(std::move(tokens));
 
 			measurements::end();
 			measurements::start("Algorithm", measurements::Type::MAIN);
diff --git a/tniceprint/src/tniceprint.cpp b/tniceprint/src/tniceprint.cpp
index 49684253f9..e3344113f8 100644
--- a/tniceprint/src/tniceprint.cpp
+++ b/tniceprint/src/tniceprint.cpp
@@ -9,10 +9,9 @@
 #include <global/GlobalData.h>
 #include <measure>
 #include <string>
+#include <sax/FromXMLParserHelper.h>
 #include <exception/AlibException.h>
 #include <factory/XmlDataFactory.hpp>
-#include <sax/SaxParseInterface.h>
-#include <sax/ParserException.h>
 #include <tree/Tree.h>
 #include <tree/ranked/RankedTree.h>
 #include <tree/unranked/UnrankedTree.h>
@@ -40,32 +39,25 @@ int main(int argc, char** argv) {
 		measurements::start("Overal", measurements::Type::OVERALL);
 		measurements::start("Input read", measurements::Type::AUXILIARY);
 
-		std::deque<sax::Token> tokens;
-		if(input.isSet()) {
-			if(input.getValue() == "-") {
-				sax::SaxParseInterface::parseStdin(tokens);
-			} else {
-				sax::SaxParseInterface::parseFile(input.getValue(), tokens);
-			}
-		} else {
-			sax::SaxParseInterface::parseStdin(tokens);
-		}
+		std::deque<sax::Token> tokens = sax::FromXMLParserHelper::parseInput(input);
 
 		if (alib::XmlDataFactory::first<tree::RankedTree>(tokens)) {
-			const tree::RankedTree & tree = alib::XmlDataFactory::fromTokens<tree::RankedTree>(tokens);
+			tree::RankedTree tree = alib::XmlDataFactory::fromTokens<tree::RankedTree>(std::move(tokens));
 
 			measurements::end();
 			measurements::start("Output write", measurements::Type::AUXILIARY);
 
 			tree.nicePrint(std::cout);
 		} else if (alib::XmlDataFactory::first<tree::UnrankedTree>(tokens)) {
-			const tree::UnrankedTree & tree = alib::XmlDataFactory::fromTokens<tree::UnrankedTree>(tokens);
+			tree::UnrankedTree tree = alib::XmlDataFactory::fromTokens<tree::UnrankedTree>(std::move(tokens));
 
 			measurements::end();
 			measurements::start("Output write", measurements::Type::AUXILIARY);
 
 			tree.nicePrint(std::cout);
-		} else throw exception::AlibException("no tree on input");
+		} else {
+			throw exception::AlibException("no tree on input");
+		}
 
 		measurements::end();
 		measurements::end();
-- 
GitLab