diff --git a/alib2str/src/regexp/RegExpFromStringParser.cpp b/alib2str/src/regexp/RegExpFromStringParser.cpp
index 11f7f6354d223a7ae01ba3068f7cd6d43d8252d7..5aca1664fa9c2be3ddd1f8006b419b1cae6bf133 100644
--- a/alib2str/src/regexp/RegExpFromStringParser.cpp
+++ b/alib2str/src/regexp/RegExpFromStringParser.cpp
@@ -21,9 +21,9 @@ RegExp RegExpFromStringParser::parseRegExp(std::istream& input) const {
 }
 
 RegExp RegExpFromStringParser::parseRegExp(std::istream& input, const std::set<FEATURES>& features) const {
-	UnboundedRegExpElement* element = this->alternation(input);
-	UnboundedRegExp regexp(std::move(*element));
-	delete element;
+	std::rvalue_ref < UnboundedRegExpElement > element = this->alternation(input);
+	UnboundedRegExp regexp(std::move(element));
+
 	if(features.count(FEATURES::UNBOUNDED)) return RegExp{regexp};
 
 	if(features.count(FEATURES::FORMAL)) return RegExp{FormalRegExp{regexp}};
@@ -31,129 +31,95 @@ RegExp RegExpFromStringParser::parseRegExp(std::istream& input, const std::set<F
 	throw exception::CommonException("Invalid input");
 }
 
-UnboundedRegExpElement* RegExpFromStringParser::alternation(std::istream& input) const {
+std::rvalue_ref < UnboundedRegExpElement > RegExpFromStringParser::alternation(std::istream& input) const {
 	return this->alternationCont(input, this->concatenation(input));
 }
 
-UnboundedRegExpElement* RegExpFromStringParser::alternationCont(std::istream& input, UnboundedRegExpElement* left) const {
+std::rvalue_ref < UnboundedRegExpElement > RegExpFromStringParser::alternationCont(std::istream& input, std::rvalue_ref < UnboundedRegExpElement > left) const {
 	RegExpFromStringLexer::Token token = m_RegexpLexer.next(input);
 	if(token.type == RegExpFromStringLexer::TokenType::PLUS) {
-		try {
-			UnboundedRegExpElement* right = this->concatenation(input);
-			UnboundedRegExpAlternation* res = new UnboundedRegExpAlternation();
-			res->appendElement(std::move(*left));
-			res->appendElement(std::move(*right));
-			delete right;
-			delete left;
-
-			return this->alternationContCont(input, res);
-		} catch (...) {
-			delete left;
-			throw;
-		}
+		UnboundedRegExpAlternation res;
+		res.appendElement(std::move(left));
+		res.appendElement(this->concatenation(input));
+
+		return this->alternationContCont(input, std::move ( res ) );
 	} else {
 		m_RegexpLexer.putback(input, token);
 		return left;
 	}
 }
 
-UnboundedRegExpElement* RegExpFromStringParser::alternationContCont(std::istream& input, UnboundedRegExpAlternation* res) const {
+std::rvalue_ref < UnboundedRegExpElement > RegExpFromStringParser::alternationContCont(std::istream& input, UnboundedRegExpAlternation res) const {
 	RegExpFromStringLexer::Token token = m_RegexpLexer.next(input);
 	if(token.type == RegExpFromStringLexer::TokenType::PLUS) {
-		try {
-			UnboundedRegExpElement* next = this->concatenation(input);
-			res->appendElement(std::move(*next));
-			delete next;
-
-			return this->alternationContCont(input, res);
-		} catch (...) {
-			delete res;
-			throw;
-		}
+		res.appendElement(this->concatenation(input));
+
+		return this->alternationContCont(input, std::move ( res ) );
 	} else {
 		m_RegexpLexer.putback(input, token);
-		return res;
+		return std::rvalue_ref < UnboundedRegExpElement > ( std::move ( res ).plunder() );
 	}
 }
 
-
-UnboundedRegExpElement* RegExpFromStringParser::concatenation(std::istream& input) const {
+std::rvalue_ref < UnboundedRegExpElement > RegExpFromStringParser::concatenation(std::istream& input) const {
 	return this->concatenationCont(input, this->factor(input));
 }
 
-UnboundedRegExpElement* RegExpFromStringParser::concatenationCont(std::istream& input, UnboundedRegExpElement* left) const {
+std::rvalue_ref < UnboundedRegExpElement > RegExpFromStringParser::concatenationCont(std::istream& input, std::rvalue_ref < UnboundedRegExpElement > left) const {
 	RegExpFromStringLexer::Token token = m_RegexpLexer.next(input);
 	if(token.type == RegExpFromStringLexer::TokenType::ERROR || token.type == RegExpFromStringLexer::TokenType::LPAR || token.type == RegExpFromStringLexer::TokenType::EPS || token.type == RegExpFromStringLexer::TokenType::EMPTY) {
-		try {
-			m_RegexpLexer.putback(input, token);
-			UnboundedRegExpElement* right = this->factor(input);
-			UnboundedRegExpConcatenation* res = new UnboundedRegExpConcatenation();
-			res->appendElement(std::move(*left));
-			res->appendElement(std::move(*right));
-			delete right;
-			delete left;
-
-			return this->concatenationContCont(input, res);
-		} catch (...) {
-			delete left;
-			throw;
-		}
+		m_RegexpLexer.putback(input, token);
+		UnboundedRegExpConcatenation res;
+		res.appendElement(std::move(left));
+		res.appendElement(this->factor(input));
+
+		return this->concatenationContCont(input, std::move ( res ) );
 	} else {
 		m_RegexpLexer.putback(input, token);
 		return left;
 	}
-	return NULL; //unreachable but produces warning if not present
 }
 
-UnboundedRegExpElement* RegExpFromStringParser::concatenationContCont(std::istream& input, UnboundedRegExpConcatenation* res) const {
+std::rvalue_ref < UnboundedRegExpElement > RegExpFromStringParser::concatenationContCont(std::istream& input, UnboundedRegExpConcatenation res) const {
 	RegExpFromStringLexer::Token token = m_RegexpLexer.next(input);
 	if(token.type == RegExpFromStringLexer::TokenType::ERROR || token.type == RegExpFromStringLexer::TokenType::LPAR || token.type == RegExpFromStringLexer::TokenType::EPS || token.type == RegExpFromStringLexer::TokenType::EMPTY) {
-		try {
-			m_RegexpLexer.putback(input, token);
-			UnboundedRegExpElement* next = this->factor(input);
-			res->appendElement(std::move(*next));
-			delete next;
-
-			return this->concatenationContCont(input, res);
-		} catch (...) {
-			delete res;
-			throw;
-		}
+		m_RegexpLexer.putback(input, token);
+		res.appendElement(this->factor(input));
+
+		return this->concatenationContCont(input, std::move ( res ) );
 	} else {
 		m_RegexpLexer.putback(input, token);
-		return res;
+		return std::rvalue_ref < UnboundedRegExpElement > ( std::move ( res ).plunder() );
 	}
-	return NULL; //unreachable but produces warning if not present
 }
 
-UnboundedRegExpElement* RegExpFromStringParser::factor(std::istream& input) const {
+std::rvalue_ref < UnboundedRegExpElement > RegExpFromStringParser::factor(std::istream& input) const {
 	RegExpFromStringLexer::Token token = m_RegexpLexer.next(input);
 	if(token.type == RegExpFromStringLexer::TokenType::LPAR) {
-		UnboundedRegExpElement* base = this->alternation(input);
+		std::rvalue_ref < UnboundedRegExpElement > base = this->alternation(input);
 		token = m_RegexpLexer.next(input);
 		if(token.type != RegExpFromStringLexer::TokenType::RPAR) throw exception::CommonException("Expected RPAR");
-		return this->star(input, base);
+		return this->star(input, std::move ( base ) );
 	} else if(token.type == RegExpFromStringLexer::TokenType::EPS) {
-		return this->star(input, new UnboundedRegExpEpsilon());
+		return this->star(input, std::rvalue_ref < UnboundedRegExpElement > ( new UnboundedRegExpEpsilon ( ) ) );
 	} else if(token.type == RegExpFromStringLexer::TokenType::EMPTY) {
-		return this->star(input, new UnboundedRegExpEmpty());
+		return this->star(input, std::rvalue_ref < UnboundedRegExpElement > ( new UnboundedRegExpEmpty ( ) ) );
 	} else if(token.type == RegExpFromStringLexer::TokenType::ERROR) {
-		UnboundedRegExpSymbol* res = new UnboundedRegExpSymbol(alib::stringApi<alphabet::Symbol>::parse(input));
-		return this->star(input, res);
+		UnboundedRegExpSymbol res(alib::stringApi<alphabet::Symbol>::parse(input));
+		return this->star(input, std::move ( res ) );
 	} else {
 		throw exception::CommonException("Unrecognised token at factor rule");
 	}
 }
 
-UnboundedRegExpElement* RegExpFromStringParser::star(std::istream& input, UnboundedRegExpElement* elem) const {
+std::rvalue_ref < UnboundedRegExpElement > RegExpFromStringParser::star(std::istream& input, UnboundedRegExpElement && elem) const {
 	RegExpFromStringLexer::Token token = m_RegexpLexer.next(input);
 	if(token.type == RegExpFromStringLexer::TokenType::STAR) {
-		UnboundedRegExpIteration* iter = new UnboundedRegExpIteration(std::move(*elem));
-		delete elem;
-		return this->star(input, iter);
+		UnboundedRegExpIteration iter ( std::move ( elem ) );
+		return this->star(input, std::move ( iter ) );
 	} else {
 		m_RegexpLexer.putback(input, token);
-		return elem;
+		return std::rvalue_ref < UnboundedRegExpElement > ( std::move ( elem ).plunder() );
 	}
 }
 
diff --git a/alib2str/src/regexp/RegExpFromStringParser.h b/alib2str/src/regexp/RegExpFromStringParser.h
index 04cafb95b70b4886ba3e3b53100bcbd0d3e91ad4..b0f786e23e30b6fb45434fac3679f0d7f0210509 100644
--- a/alib2str/src/regexp/RegExpFromStringParser.h
+++ b/alib2str/src/regexp/RegExpFromStringParser.h
@@ -12,6 +12,7 @@
 #include "RegExpFromStringLexer.h"
 
 #include <set>
+#include <memory>
 
 namespace alib {
 
@@ -27,16 +28,16 @@ public:
 	RegExpFromStringParser() {}
 
 private:
-	UnboundedRegExpElement* alternation(std::istream& input) const;
-	UnboundedRegExpElement* alternationCont(std::istream& input, UnboundedRegExpElement* left) const;
-	UnboundedRegExpElement* alternationContCont(std::istream& input, UnboundedRegExpAlternation* left) const;
+	std::rvalue_ref < UnboundedRegExpElement > alternation(std::istream& input) const;
+	std::rvalue_ref < UnboundedRegExpElement > alternationCont(std::istream& input, std::rvalue_ref < UnboundedRegExpElement > left) const;
+	std::rvalue_ref < UnboundedRegExpElement > alternationContCont(std::istream& input, UnboundedRegExpAlternation left) const;
 
-	UnboundedRegExpElement* concatenation(std::istream& input) const;
-	UnboundedRegExpElement* concatenationCont(std::istream& input, UnboundedRegExpElement* left) const;
-	UnboundedRegExpElement* concatenationContCont(std::istream& input, UnboundedRegExpConcatenation* left) const;
+	std::rvalue_ref < UnboundedRegExpElement > concatenation(std::istream& input) const;
+	std::rvalue_ref < UnboundedRegExpElement > concatenationCont(std::istream& input, std::rvalue_ref < UnboundedRegExpElement > left) const;
+	std::rvalue_ref < UnboundedRegExpElement > concatenationContCont(std::istream& input, UnboundedRegExpConcatenation left) const;
 
-	UnboundedRegExpElement* factor(std::istream& input) const;
-	UnboundedRegExpElement* star(std::istream& input, UnboundedRegExpElement* elem) const;
+	std::rvalue_ref < UnboundedRegExpElement > factor(std::istream& input) const;
+	std::rvalue_ref < UnboundedRegExpElement > star(std::istream& input, UnboundedRegExpElement && elem) const;
 
 	RegExpFromStringLexer m_RegexpLexer;