diff --git a/alib2data/src/RawApi.cpp b/alib2data/src/RawApi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fc57e691c43b568a69aa36a9331bee71809bc30a
--- /dev/null
+++ b/alib2data/src/RawApi.cpp
@@ -0,0 +1,16 @@
+/*
+ * RawApi.cpp
+ *
+ * Created on: Apr 1, 2013
+ * Author: Jan Travnicek
+ */
+
+#include "RawApi.hpp"
+
+namespace alib {
+
+const tree::TreeFromRawParser FromRawParsers::treeParser;
+
+const tree::TreeToRawComposer ToRawComposers::treeComposer;
+
+} /* namespace alib */
diff --git a/alib2data/src/RawApi.hpp b/alib2data/src/RawApi.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..384c435803f4e74ad977779f76523a68c4672448
--- /dev/null
+++ b/alib2data/src/RawApi.hpp
@@ -0,0 +1,29 @@
+/*
+ * RawApi.hpp
+ *
+ * Created on: Dec 27, 2014
+ * Author: Jan Travnicek
+ */
+
+#ifndef RAW_API_HPP_
+#define RAW_API_HPP_
+
+#include "tree/TreeFromRawParser.h"
+#include "tree/TreeToRawComposer.h"
+
+namespace alib {
+
+class FromRawParsers {
+public:
+ static const tree::TreeFromRawParser treeParser;
+
+};
+
+class ToRawComposers {
+public:
+ static const tree::TreeToRawComposer treeComposer;
+};
+
+} /* namespace alib */
+
+#endif /* RAW_API_HPP_ */
diff --git a/alib2data/src/tree/TreeFromRawParser.cpp b/alib2data/src/tree/TreeFromRawParser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..55d4139d28f7f4607b7a2dff62e3d5dec8935606
--- /dev/null
+++ b/alib2data/src/tree/TreeFromRawParser.cpp
@@ -0,0 +1,60 @@
+/*
+ * TreeFromRawParser.cpp
+ *
+ * Created on: Nov 23, 2013
+ * Author: Jan Travnicek
+ */
+
+#include "TreeFromRawParser.h"
+#include "TreeException.h"
+#include "ranked/RankedTree.h"
+#include "unranked/UnrankedTree.h"
+#include "../alphabet/LabeledSymbol.h"
+#include "../label/Label.h"
+
+namespace tree {
+
+Tree TreeFromRawParser::parseTree(std::deque<sax::Token>& input) const {
+ return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::UNRANKED_TREE}));
+}
+
+Tree TreeFromRawParser::parseTree(std::deque<sax::Token> &input, const std::set<FEATURES>& features) const {
+ UnrankedNode* root = NULL;
+ if (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+ root = this->parseContent(input);
+ } else if(isTokenType(input, sax::Token::TokenType::CHARACTER)) {
+ root = this->parseContentLeaf(input);
+ } else {
+ throw exception::AlibException("Invalid token stream");
+ }
+
+ UnrankedTree tree(std::move(*root));
+ delete root;
+ if(features.count(FEATURES::UNRANKED_TREE)) return Tree{tree};
+
+ if(features.count(FEATURES::RANKED_TREE)) return Tree{RankedTree{tree}};
+
+ throw exception::AlibException("Invalid input");
+}
+
+UnrankedNode* TreeFromRawParser::parseContent(std::deque<sax::Token>& input) const {
+ UnrankedNode* node = new UnrankedNode(alphabet::LabeledSymbol(label::labelFrom(popTokenData(input, sax::Token::TokenType::START_ELEMENT))), std::vector<UnrankedNode*> {});
+ while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+ UnrankedNode* child = this->parseContent(input);
+ node->pushBackChild(std::move(*child));
+ delete child;
+ }
+ if(isTokenType(input, sax::Token::TokenType::CHARACTER)) {
+ UnrankedNode* child = this->parseContentLeaf(input);
+ node->pushBackChild(std::move(*child));
+ delete child;
+ }
+ popTokenData(input, sax::Token::TokenType::END_ELEMENT);
+ return node;
+}
+
+UnrankedNode* TreeFromRawParser::parseContentLeaf(std::deque<sax::Token>& input) const {
+ return new UnrankedNode(alphabet::LabeledSymbol(label::labelFrom(popTokenData(input, sax::Token::TokenType::CHARACTER))), std::vector<UnrankedNode*> {});
+}
+
+} /* namespace tree */
diff --git a/alib2data/src/tree/TreeFromRawParser.h b/alib2data/src/tree/TreeFromRawParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..a506012637df2812010e03592b1b5ac7f0491351
--- /dev/null
+++ b/alib2data/src/tree/TreeFromRawParser.h
@@ -0,0 +1,34 @@
+/*
+ * TreeFromRawParser.h
+ *
+ * Created on: Nov 23, 2013
+ * Author: Jan Travnicek
+ */
+
+#ifndef TREE_FROM_RAW_PARSER
+#define TREE_FROM_RAW_PARSER
+
+#include "../sax/FromXMLParserHelper.h"
+#include "Tree.h"
+#include "TreeFeatures.h"
+#include <deque>
+#include <set>
+#include "unranked/UnrankedNode.h"
+
+namespace tree {
+
+class TreeFromRawParser : public sax::FromXMLParserHelper {
+public:
+ TreeFromRawParser() {}
+
+ Tree parseTree(std::deque<sax::Token> &input) const;
+ Tree parseTree(std::deque<sax::Token> &input, const std::set<FEATURES>& features) const;
+
+private:
+ UnrankedNode* parseContent(std::deque<sax::Token>& input) const;
+ UnrankedNode* parseContentLeaf(std::deque<sax::Token>& input) const;
+};
+
+} /* namespace tree */
+
+#endif /* TREE_FROM_RAW_PARSER */
diff --git a/alib2data/src/tree/TreeFromXMLParser.cpp b/alib2data/src/tree/TreeFromXMLParser.cpp
index fa3116986fa8a4eaa481606738211578a8a8c5aa..b69bc3f6deebd05df98f319d53ead32881ab676d 100644
--- a/alib2data/src/tree/TreeFromXMLParser.cpp
+++ b/alib2data/src/tree/TreeFromXMLParser.cpp
@@ -13,94 +13,94 @@
namespace tree {
- Tree TreeFromXMLParser::parseTree(std::deque<sax::Token> &input) const {
- return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::UNRANKED_TREE}));
+Tree TreeFromXMLParser::parseTree(std::deque<sax::Token> &input) const {
+ return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::UNRANKED_TREE}));
+}
+
+Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
+ if(alib::xmlApi<RankedTree>::first(input)) {
+ if(!features.count(FEATURES::RANKED_TREE)) throw exception::AlibException();
+ return Tree(parseRankedTree(input));
+ } else if(alib::xmlApi<UnrankedTree>::first(input)) {
+ if(!features.count(FEATURES::UNRANKED_TREE)) throw exception::AlibException();
+ return Tree(parseUnrankedTree(input));
+ } else
+ throw sax::ParserException(sax::Token("Tree / RankedTree / UnrankedTree", sax::Token::TokenType::START_ELEMENT), input.front());
+}
+
+RankedTree TreeFromXMLParser::parseRankedTree(std::deque<sax::Token>& input) const {
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_RANKED_TREE);
+
+ std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
+ RankedNode * root = parseRankedNode(input);
+ RankedTree tree(rankedAlphabet, std::move(*root));
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_RANKED_TREE);
+ return tree;
+}
+
+UnrankedTree TreeFromXMLParser::parseUnrankedTree(std::deque<sax::Token>& input) const {
+ popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_UNRANKED_TREE);
+
+ std::set<alphabet::LabeledSymbol> alphabet = parseAlphabet(input);
+ UnrankedNode * root = parseUnrankedNode(input);
+ UnrankedTree tree(alphabet, std::move(*root));
+ popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_UNRANKED_TREE);
+ return tree;
+}
+
+std::set<alphabet::RankedSymbol> TreeFromXMLParser::parseRankedAlphabet(std::deque<sax::Token> &input) const {
+ std::set<alphabet::RankedSymbol> rankedSymbols;
+ popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedAlphabet");
+ while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+ rankedSymbols.insert(alib::xmlApi<alphabet::RankedSymbol>::parse(input));
}
-
- Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
- if(alib::xmlApi<RankedTree>::first(input)) {
- if(!features.count(FEATURES::RANKED_TREE)) throw exception::AlibException();
- return Tree(parseRankedTree(input));
- } else if(alib::xmlApi<UnrankedTree>::first(input)) {
- if(!features.count(FEATURES::UNRANKED_TREE)) throw exception::AlibException();
- return Tree(parseUnrankedTree(input));
- } else
- throw sax::ParserException(sax::Token("Tree / RankedTree / UnrankedTree", sax::Token::TokenType::START_ELEMENT), input.front());
+ popToken(input, sax::Token::TokenType::END_ELEMENT, "rankedAlphabet");
+ return rankedSymbols;
+}
+
+std::set<alphabet::LabeledSymbol> TreeFromXMLParser::parseAlphabet(std::deque<sax::Token> &input) const {
+ std::set<alphabet::LabeledSymbol> symbols;
+ popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
+ while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+ symbols.insert(alib::xmlApi<alphabet::LabeledSymbol>::parse(input));
}
-
- RankedTree TreeFromXMLParser::parseRankedTree(std::deque<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_RANKED_TREE);
-
- std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
- RankedNode * root = parseRankedNode(input);
- RankedTree tree(rankedAlphabet, std::move(*root));
- popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_RANKED_TREE);
- return tree;
+ popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
+ return symbols;
+}
+
+RankedNode * TreeFromXMLParser::parseRankedNode(std::deque<sax::Token> &input) const {
+ popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedNode");
+ alphabet::RankedSymbol symbol = alib::xmlApi<alphabet::RankedSymbol>::parse(input);
+ int rank = symbol.getRank().getData();
+ std::vector<RankedNode *> children;
+ children.reserve(rank);
+ while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+ children.push_back(parseRankedNode(input));
}
+ popToken(input, sax::Token::TokenType::END_ELEMENT, "rankedNode");
- UnrankedTree TreeFromXMLParser::parseUnrankedTree(std::deque<sax::Token>& input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_UNRANKED_TREE);
+ return new RankedNode(symbol, children);
+}
- std::set<alphabet::LabeledSymbol> alphabet = parseAlphabet(input);
- UnrankedNode * root = parseUnrankedNode(input);
- UnrankedTree tree(alphabet, std::move(*root));
- popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_UNRANKED_TREE);
- return tree;
+UnrankedNode * TreeFromXMLParser::parseUnrankedNode(std::deque<sax::Token> &input) const {
+ popToken(input, sax::Token::TokenType::START_ELEMENT, "unrankedNode");
+ alphabet::LabeledSymbol symbol = alib::xmlApi<alphabet::LabeledSymbol>::parse(input);
+ std::vector<UnrankedNode *> children;
+ while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+ children.push_back(parseUnrankedNode(input));
}
+ popToken(input, sax::Token::TokenType::END_ELEMENT, "unrankedNode");
- std::set<alphabet::RankedSymbol> TreeFromXMLParser::parseRankedAlphabet(std::deque<sax::Token> &input) const {
- std::set<alphabet::RankedSymbol> rankedSymbols;
- popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedAlphabet");
- while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
- rankedSymbols.insert(alib::xmlApi<alphabet::RankedSymbol>::parse(input));
- }
- popToken(input, sax::Token::TokenType::END_ELEMENT, "rankedAlphabet");
- return rankedSymbols;
- }
-
- std::set<alphabet::LabeledSymbol> TreeFromXMLParser::parseAlphabet(std::deque<sax::Token> &input) const {
- std::set<alphabet::LabeledSymbol> symbols;
- popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
- while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
- symbols.insert(alib::xmlApi<alphabet::LabeledSymbol>::parse(input));
- }
- popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
- return symbols;
- }
-
- RankedNode * TreeFromXMLParser::parseRankedNode(std::deque<sax::Token> &input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedNode");
- alphabet::RankedSymbol symbol = alib::xmlApi<alphabet::RankedSymbol>::parse(input);
- int rank = symbol.getRank().getData();
- std::vector<RankedNode *> children;
- children.reserve(rank);
- while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
- children.push_back(parseRankedNode(input));
- }
- popToken(input, sax::Token::TokenType::END_ELEMENT, "rankedNode");
-
- return new RankedNode(symbol, children);
- }
-
- UnrankedNode * TreeFromXMLParser::parseUnrankedNode(std::deque<sax::Token> &input) const {
- popToken(input, sax::Token::TokenType::START_ELEMENT, "unrankedNode");
- alphabet::LabeledSymbol symbol = alib::xmlApi<alphabet::LabeledSymbol>::parse(input);
- std::vector<UnrankedNode *> children;
- while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
- children.push_back(parseUnrankedNode(input));
- }
- popToken(input, sax::Token::TokenType::END_ELEMENT, "unrankedNode");
-
- return new UnrankedNode(symbol, children);
- }
+ return new UnrankedNode(symbol, children);
+}
- bool TreeFromXMLParser::first(const std::deque<sax::Token>& input) const {
- if (alib::xmlApi<RankedTree>::first(input) || alib::xmlApi<UnrankedTree>::first(input)) {
- return true;
- } else {
- return false;
- }
+bool TreeFromXMLParser::first(const std::deque<sax::Token>& input) const {
+ if (alib::xmlApi<RankedTree>::first(input) || alib::xmlApi<UnrankedTree>::first(input)) {
+ return true;
+ } else {
+ return false;
}
+}
} /* namespace tree */
diff --git a/alib2data/src/tree/TreeToRawComposer.cpp b/alib2data/src/tree/TreeToRawComposer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f94f258ecf9cb71f5d5ab551212fe5693a6d661d
--- /dev/null
+++ b/alib2data/src/tree/TreeToRawComposer.cpp
@@ -0,0 +1,69 @@
+/*
+ * TreeToRawComposer.cpp
+ *
+ * Created on: Nov 16, 2014
+ * Author: Jan Travnicek
+ */
+
+#include "TreeToRawComposer.h"
+
+#include "../XmlApi.hpp"
+
+namespace tree {
+
+void TreeToRawComposer::compose(std::deque<sax::Token>& out, const TreeBase& tree) const {
+ tree.Accept((void*) &out, tree::TreeToRawComposer::TREE_TO_RAW_COMPOSER);
+}
+
+void TreeToRawComposer::compose(std::deque<sax::Token>& out, const Tree& tree) const {
+ tree.getData().Accept((void*) &out, tree::TreeToRawComposer::TREE_TO_RAW_COMPOSER);
+}
+
+void TreeToRawComposer::compose(std::deque<sax::Token>& out, const RankedTree& tree) const {
+ composeNode(out, tree.getRoot());
+}
+
+void TreeToRawComposer::compose(std::deque<sax::Token>& out, const UnrankedTree& tree) const {
+ composeNode(out, tree.getRoot());
+}
+
+void TreeToRawComposer::composeNode(std::deque<sax::Token>& out, const RankedNode& node) const {
+ if(node.getChildren().size() == 0) {
+ out.emplace_back(sax::Token((std::string) node.getSymbol(), sax::Token::TokenType::CHARACTER));
+ } else {
+ out.emplace_back(sax::Token((std::string) node.getSymbol(), sax::Token::TokenType::START_ELEMENT));
+ for(const auto& child : node.getChildren()) {
+ composeNode(out, *child);
+ }
+
+ out.emplace_back(sax::Token((std::string) node.getSymbol(), sax::Token::TokenType::END_ELEMENT));
+ }
+}
+
+void TreeToRawComposer::composeNode(std::deque<sax::Token>& out, const UnrankedNode& node) const {
+ if(node.getChildren().size() == 0) {
+
+ } else {
+ out.emplace_back(sax::Token((std::string) node.getSymbol(), sax::Token::TokenType::START_ELEMENT));
+ for(const auto& child : node.getChildren()) {
+ composeNode(out, *child);
+ }
+
+ out.emplace_back(sax::Token((std::string) node.getSymbol(), sax::Token::TokenType::END_ELEMENT));
+ }
+}
+
+void TreeToRawComposer::Visit(void* userData, const RankedTree& tree) const {
+ std::deque<sax::Token> &res = *((std::deque<sax::Token>*) userData);
+ this->compose(res, tree);
+}
+
+void TreeToRawComposer::Visit(void* userData, const UnrankedTree& tree) const {
+ std::deque<sax::Token> &res = *((std::deque<sax::Token>*) userData);
+ this->compose(res, tree);
+}
+
+const TreeToRawComposer TreeToRawComposer::TREE_TO_RAW_COMPOSER;
+
+} /* namespace automaton */
+
diff --git a/alib2data/src/tree/TreeToRawComposer.h b/alib2data/src/tree/TreeToRawComposer.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec0654a548c36cf1088827152636ab79fe32dc20
--- /dev/null
+++ b/alib2data/src/tree/TreeToRawComposer.h
@@ -0,0 +1,60 @@
+/*
+ * TreeToRawComposer.h
+ *
+ * Created on: Nov 16, 2014
+ * Author: Jan Travnicek
+ */
+
+#ifndef TREE_TO_RAW_COMPOSER_H_
+#define TREE_TO_RAW_COMPOSER_H_
+
+#include <deque>
+#include "Tree.h"
+#include "ranked/RankedTree.h"
+#include "unranked/UnrankedTree.h"
+#include "../sax/Token.h"
+
+namespace alib {
+
+template<typename T>
+struct xmlApi;
+
+} /* namespace alib */
+
+namespace tree {
+
+/**
+ * This class contains methods to print XML representation of tree to the output stream.
+ */
+class TreeToRawComposer : public VisitableTreeBase::const_visitor_type {
+public:
+ TreeToRawComposer() {}
+
+ void Visit(void*, const RankedTree& empty) const;
+ void Visit(void*, const UnrankedTree& empty) const;
+
+ void compose(std::deque<sax::Token>& out, const Tree& tree) const;
+
+ void compose(std::deque<sax::Token>& out, const RankedTree& tree) const;
+
+ void compose(std::deque<sax::Token>& out, const UnrankedTree& tree) const;
+
+private:
+ /**
+ * Prints XML representation of Tree to the output stream.
+ * @param tree tree to print
+ * @return list of xml tokens representing the tree
+ */
+ void compose(std::deque<sax::Token>& out, const TreeBase& tree) const;
+
+ void composeNode(std::deque<sax::Token>& out, const RankedNode& node) const;
+
+ void composeNode(std::deque<sax::Token>& out, const UnrankedNode& node) const;
+
+ static const TreeToRawComposer TREE_TO_RAW_COMPOSER;
+};
+
+} /* namespace tree */
+
+#endif /* TREE_TO_RAW_COMPOSER_H_ */
+
diff --git a/alib2data/src/tree/unranked/UnrankedNode.cpp b/alib2data/src/tree/unranked/UnrankedNode.cpp
index ef2b839c5b03e58bbb6587c0696320e82afbcc1f..f791b8cb81af8103b941ccbd2dfd0722d7d726ed 100644
--- a/alib2data/src/tree/unranked/UnrankedNode.cpp
+++ b/alib2data/src/tree/unranked/UnrankedNode.cpp
@@ -176,6 +176,8 @@ bool UnrankedNode::attachTree(const UnrankedTree * tree ) {
void UnrankedNode::computeMinimalAlphabet( std::set<alphabet::LabeledSymbol>& alphabet ) const {
alphabet.insert(this->symbol);
+ for(const auto& child : this->children)
+ child->computeMinimalAlphabet(alphabet);
}
const alphabet::LabeledSymbol& UnrankedNode::getSymbol() const {
diff --git a/araw2/makefile b/araw2/makefile
new file mode 100644
index 0000000000000000000000000000000000000000..73924b81cb6168a88d3446acf5633287a1e45f0d
--- /dev/null
+++ b/araw2/makefile
@@ -0,0 +1,178 @@
+SHELL:=/bin/bash
+EXECUTABLE:=araw2
+
+define NEW_LINE
+
+
+endef
+
+export NEW_LINE
+
+GCC_LDFLAGS_DEBUG:=-L../alib2std/lib-gcc-debug -L../alib2data/lib-gcc-debug -L../alib2algo/lib-gcc-debug -L../alib2elgo/lib-gcc-debug -rdynamic -lxml2 -lalib2std -lalib2data -lalib2algo -lalib2elgo -Wl,-rpath,.
+LLVM_LDFLAGS_DEBUG:=-L../alib2std/lib-llvm-debug -L../alib2data/lib-llvm-debug -L../alib2algo/lib-llvm-debug -L../alib2elgo/lib-llvm-debug -rdynamic -lxml2 -lalib2std -lalib2data -lalib2algo -lalib2elgo -Wl,-rpath,.
+
+GCC_LDFLAGS_RELEASE:=-L../alib2std/lib-gcc-release -L../alib2data/lib-gcc-release -L../alib2algo/lib-gcc-release -L../alib2elgo/lib-gcc-release -rdynamic -lxml2 -lalib2std -lalib2data -lalib2algo -lalib2elgo -Wl,-rpath,.
+LLVM_LDFLAGS_RELEASE:=-L../alib2std/lib-llvm-release -L../alib2data/lib-llvm-release -L../alib2algo/lib-llvm-release -L../alib2elgo/lib-llvm-release -rdynamic -lxml2 -lalib2std -lalib2data -lalib2algo -lalib2elgo -Wl,-rpath,.
+
+OBJECTS_GCC_DEBUG:=$(patsubst src/%.cpp, obj-gcc-debug/%.o, $(shell find src/ -name *cpp))
+OBJECTS_LLVM_DEBUG:=$(patsubst src/%.cpp, obj-llvm-debug/%.o, $(shell find src/ -name *cpp))
+
+OBJECTS_GCC_RELEASE:=$(patsubst src/%.cpp, obj-gcc-release/%.o, $(shell find src/ -name *cpp))
+OBJECTS_LLVM_RELEASE:=$(patsubst src/%.cpp, obj-llvm-release/%.o, $(shell find src/ -name *cpp))
+
+.PHONY: all build-gcc-debug build-llvm-debug build-gcc-release build-llvm-release clean-gcc-debug clean-llvm-debug clean-gcc-release clean-llvm-release doc
+
+all:
+ @echo "What to do master?"
+
+obj%/makefile: makefile
+ mkdir -p $(dir $@)
+ echo "\
+ SHELL:=/bin/bash$${NEW_LINE}\
+ CXXX:=$(patsubst obj-%-release/,%,$(patsubst obj-%-debug/,%,$(dir $@)))$${NEW_LINE}\
+ ifeq (gcc, \$$(CXXX))$${NEW_LINE}\
+ CXX:=g++$${NEW_LINE}\
+ else$${NEW_LINE}\
+ ifeq (llvm, \$$(CXXX))$${NEW_LINE}\
+ CXX:=clang++$${NEW_LINE}\
+ else$${NEW_LINE}\
+ \$$(error \"invalid compiler\")$${NEW_LINE}\
+ endif$${NEW_LINE}\
+ endif$${NEW_LINE}\
+ SRCDIR:=$${NEW_LINE}\
+ DEPTH:=$${NEW_LINE}\
+ OBJECTS_BASE_DIR:=$${NEW_LINE}\
+ $${NEW_LINE}\
+ define NEW_LINE$${NEW_LINE}\
+ $${NEW_LINE}\
+ $${NEW_LINE}\
+ endef$${NEW_LINE}\
+ $${NEW_LINE}\
+ export NEW_LINE$${NEW_LINE}\
+ $${NEW_LINE}\
+ CXXFLAGS:= -std=c++11 \$$(CXX_OTHER_FLAGS) -c -Wall -pedantic -Wextra -Werror -fPIC -I/usr/include/libxml2/ -I../../\$$(DEPTH)alib2std/src -I../../\$$(DEPTH)alib2data/src/ -I../../\$$(DEPTH)alib2algo/src/ -I../../\$$(DEPTH)alib2elgo/src/$${NEW_LINE}\
+ $${NEW_LINE}\
+ SOURCES:= \$$(shell find ../\$$(DEPTH)\$$(SOURCES_BASE_DIR)/\$$(SRCDIR) -maxdepth 1 -type f -name \"*.cpp\")$${NEW_LINE}\
+ DEPENDENCIES:= \$$(patsubst ../\$$(DEPTH)\$$(SOURCES_BASE_DIR)/\$$(SRCDIR)%.cpp, ../\$$(DEPTH)\$$(OBJECTS_BASE_DIR)/\$$(SRCDIR)%.d, \$$(SOURCES))$${NEW_LINE}\
+ OBJECTS:= \$$(patsubst %.d, %.o, \$$(DEPENDENCIES))$${NEW_LINE}\
+ SOURCES_DIRS:= \$$(shell find ../\$$(DEPTH)\$$(SOURCES_BASE_DIR)/\$$(SRCDIR) -maxdepth 1 -mindepth 1 -type d)$${NEW_LINE}\
+ OBJECTS_DIRS:= \$$(patsubst ../\$$(DEPTH)\$$(SOURCES_BASE_DIR)/\$$(SRCDIR)%, %/, \$$(SOURCES_DIRS))$${NEW_LINE}\
+ OBJECTS_DIRS_MAKEFILES:= \$$(patsubst %, %makefile, \$$(OBJECTS_DIRS))$${NEW_LINE}\
+ $${NEW_LINE}\
+ .PHONY: all$${NEW_LINE}\
+ .PRECIOUS: \$$(DEPENDECIES) \$$(OBJECTS_DIRS_MAKEFILES)$${NEW_LINE}\
+ $${NEW_LINE}\
+ all: \$$(OBJECTS_DIRS) \$$(OBJECTS)$${NEW_LINE}\
+ $${NEW_LINE}\
+ %.d: makefile$${NEW_LINE}\
+ @echo \"\\$${NEW_LINE}\
+ \$$(shell sha1sum <<< \"\$$@\" | sed \"s/ -//g\") = \\$$\$$(shell (\\$$\$$(CXX) -M \\$$\$$(CXXFLAGS) \$$(patsubst ../\$$(DEPTH)\$$(OBJECTS_BASE_DIR)/\$$(SRCDIR)%.d,../\$$(DEPTH)\$$(SOURCES_BASE_DIR)/\$$(SRCDIR)%.cpp, \$$@) 2>/dev/null || echo \\\"\$$(patsubst ../\$$(DEPTH)\$$(OBJECTS_BASE_DIR)/\$$(SRCDIR)%.d,../\$$(DEPTH)\$$(SOURCES_BASE_DIR)/\$$(SRCDIR)%.cpp, \$$@) FORCE\\\") | sed \\\"s/.*://g;s/\\\\\\\\\\\\\\\\//g\\\")\$$\$${NEW_LINE}\\$${NEW_LINE}\
+ \$$(patsubst %.d,%.o, \$$@): \\$$\$$(\$$(shell sha1sum <<< \"\$$@\" | sed \"s/ -//g\")) makefile\$$\$${NEW_LINE}\\$${NEW_LINE}\
+ \\$$\$$(CXX) \\$$\$$(CXXFLAGS) \\$$\$$< -o \$$(patsubst %.d,%.o, \$$@)\$$\$${NEW_LINE}\\$${NEW_LINE}\
+ \" > \$$@$${NEW_LINE}\
+ $${NEW_LINE}\
+ %/makefile: makefile$${NEW_LINE}\
+ mkdir -p \$$(dir \$$@)$${NEW_LINE}\
+ cp makefile \$$@$${NEW_LINE}\
+ $${NEW_LINE}\
+ %/: FORCE | %/makefile$${NEW_LINE}\
+ @accesstime=\`stat -c %Y \$$@\` && \\$${NEW_LINE}\
+ \$$(MAKE) -C \$$@ SRCDIR=\$$(SRCDIR)\$$(notdir \$$(patsubst %/, %, \$$@))/ DEPTH=\$$(DEPTH)../ OBJECTS_BASE_DIR=\$$(OBJECTS_BASE_DIR) SOURCES_BASE_DIR=\$$(SOURCES_BASE_DIR) CXX_OTHER_FLAGS=\"\$$(CXX_OTHER_FLAGS)\" && \\$${NEW_LINE}\
+ accesstime2=\`stat -c %Y \$$@\` && \\$${NEW_LINE}\
+ if [ "\$$\$$accesstime" -ne "\$$\$$accesstime2" ]; then \\$${NEW_LINE}\
+ touch .; \\$${NEW_LINE}\
+ fi$${NEW_LINE}\
+ $${NEW_LINE}\
+ FORCE:$${NEW_LINE}\
+ $${NEW_LINE}\
+ -include \$$(DEPENDENCIES)" > $@
+
+gcc-debug: build-gcc-debug
+
+llvm-debug: build-llvm-debug
+
+gcc-release: build-gcc-release
+
+llvm-release: build-llvm-release
+
+clean: clean-gcc-debug clean-gcc-release
+ $(RM) -r doc
+
+clean: clean-llvm-debug clean-llvm-release
+ $(RM) -r doc
+
+
+
+bin-gcc-debug/$(EXECUTABLE): obj-gcc-debug/ $(OBJECTS_GCC_DEBUG)
+ mkdir -p $(dir $@)
+ g++ $(OBJECTS_GCC_DEBUG) -o $@ $(GCC_LDFLAGS_DEBUG)
+
+bin-llvm-debug/$(EXECUTABLE): obj-llvm-debug/ $(OBJECTS_LLVM_DEBUG)
+ mkdir -p $(dir $@)
+ clang++ $(OBJECTS_LLVM_DEBUG) -o $@ $(LLVM_LDFLAGS_DEBUG)
+
+bin-gcc-release/$(EXECUTABLE): obj-gcc-release/ $(OBJECTS_GCC_RELEASE)
+ mkdir -p $(dir $@)
+ g++ $(OBJECTS_GCC_RELEASE) -o $@ $(GCC_LDFLAGS_RELEASE)
+
+bin-llvm-release/$(EXECUTABLE): obj-llvm-release/ $(OBJECTS_LLVM_RELEASE)
+ mkdir -p $(dir $@)
+ g++ $(OBJECTS_LLVM_RELEASE) -o $@ $(LLVM_LDFLAGS_RELEASE)
+
+
+
+obj-gcc-debug/: FORCE | obj-gcc-debug/makefile
+ $(MAKE) -C $@ OBJECTS_BASE_DIR=obj-gcc-debug SOURCES_BASE_DIR=src CXX_OTHER_FLAGS="-g -O0"
+
+obj-llvm-debug/: FORCE | obj-llvm-debug/makefile
+ $(MAKE) -C $@ OBJECTS_BASE_DIR=obj-llvm-debug SOURCES_BASE_DIR=src CXX_OTHER_FLAGS="-g -O0"
+
+obj-gcc-release/: FORCE | obj-gcc-release/makefile
+ $(MAKE) -C $@ OBJECTS_BASE_DIR=obj-gcc-release SOURCES_BASE_DIR=src CXX_OTHER_FLAGS="-O3"
+
+obj-llvm-release/: FORCE | obj-llvm-release/makefile
+ $(MAKE) -C $@ OBJECTS_BASE_DIR=obj-llvm-release SOURCES_BASE_DIR=src CXX_OTHER_FLAGS="-O3"
+
+
+
+$(OBJECTS_GCC_DEBUG): obj-gcc-debug/
+
+$(OBJECTS_LLVM_DEBUG): obj-llvm-debug/
+
+$(OBJECTS_GCC_RELEASE): obj-gcc-release/
+
+$(OBJECTS_LLVM_RELEASE): obj-llvm-release/
+
+
+
+build-gcc-debug: bin-gcc-debug/$(EXECUTABLE)
+
+build-llvm-debug: bin-llvm-debug/$(EXECUTABLE)
+
+build-gcc-release: bin-gcc-release/$(EXECUTABLE)
+
+build-llvm-release: bin-llvm-release/$(EXECUTABLE)
+
+
+
+clean-gcc-debug:
+ $(RM) -r *.o *.d bin-gcc-debug obj-gcc-debug
+
+clean-llvm-debug:
+ $(RM) -r *.o *.d bin-llvm-debug obj-llvm-debug
+
+clean-gcc-release:
+ $(RM) -r *.o *.d bin-gcc-release obj-gcc-release
+
+clean-llvm-release:
+ $(RM) -r *.o *.d bin-llvm-release obj-llvm-release
+
+
+
+FORCE:
+
+
+
+doc:
+ doxygen
+
diff --git a/araw2/src/araw.cpp b/araw2/src/araw.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..525417f1218ff5bbac77ce43760f1af7f6342924
--- /dev/null
+++ b/araw2/src/araw.cpp
@@ -0,0 +1,90 @@
+/*
+ * araw.cpp
+ *
+ * Created on: 24. 2. 2014
+ * Author: Jan Travnicek
+**/
+
+#include <tclap/CmdLine.h>
+#include <string>
+#include <exception/AlibException.h>
+#include <RawApi.hpp>
+#include <factory/XmlDataFactory.hpp>
+#include <sax/SaxParseInterface.h>
+#include <sax/ParserException.h>
+#include <object/Object.h>
+
+int main(int argc, char** argv) {
+ try {
+ TCLAP::CmdLine cmd("raw reading binary", ' ', "0.01");
+
+ TCLAP::ValueArg<std::string> input( "i", "input", "Input to read", false, "-", "file");
+ cmd.add( input );
+
+ TCLAP::SwitchArg tree_from_raw( "", "tree_from_raw", "Convert tree from raw representation (xml)");
+ cmd.add( tree_from_raw );
+
+ TCLAP::SwitchArg tree_to_raw( "", "tree_to_raw", "Convert tree to raw representation (xml)");
+ cmd.add( tree_to_raw );
+
+ TCLAP::SwitchArg string_from_raw( "", "string_from_raw", "Convert string from raw representation (string)");
+ cmd.add( string_from_raw );
+
+ TCLAP::SwitchArg string_to_raw( "", "string_to_raw", "Convert string to raw representation (string)");
+ cmd.add( string_to_raw );
+
+ TCLAP::SwitchArg matrix_from_raw( "", "matrix_from_raw", "Convert string from raw representation (csv)");
+ cmd.add( matrix_from_raw );
+
+ TCLAP::SwitchArg matrix_to_raw( "", "matrix_to_raw", "Convert string to raw representation (csv)");
+ cmd.add( matrix_to_raw );
+
+ cmd.parse(argc, argv);
+ 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);
+ }
+
+ tree::Tree tree = alib::FromRawParsers::treeParser.parseTree(tokens);
+ 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);
+ std::deque<sax::Token> tokens2;
+ alib::ToRawComposers::treeComposer.compose(tokens2, tree);
+ sax::SaxComposeInterface::printStdout(tokens2);
+ } else {
+ throw exception::AlibException("Invalid input format specified");
+ }
+ return 0;
+ } catch(const exception::AlibException& exception) {
+ alib::XmlDataFactory::toStdout(exception);
+ return 1;
+ } catch(const TCLAP::ArgException& exception) {
+ std::cerr << exception.error() << std::endl;
+ return 2;
+ } catch (const std::exception& exception) {
+ std::cerr << "Exception caught: " << exception.what() << std::endl;
+ return 3;
+ } catch(...) {
+ std::cerr << "Unknown exception caught." << std::endl;
+ return 127;
+ }
+}
diff --git a/makefile b/makefile
index fce47b54cd3d1ff93196541444d7753fe9912985..41eae4c46ea96752217750cbf19bcdf7ae54efe0 100644
--- a/makefile
+++ b/makefile
@@ -20,6 +20,7 @@ SUBDIRS_BINS = aecho2 \
alangop2 \
aminimize2 \
anormalize2 \
+ araw2 \
arand2 \
arename2 \
areverse2 \