No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Mar 14, 4:37 AM

View Options

	diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt
	index d98c03e..e51bf9c 100644
	--- a/cpp/src/CMakeLists.txt
	+++ b/cpp/src/CMakeLists.txt
	@@ -1,218 +1,210 @@
	cmake_minimum_required(VERSION 2.8.11)
	project(xreate)
	cmake_policy(SET CMP0022 NEW)

	+message("MODULES" ${CMAKE_MODULE_PATH})
	+
	# LLVM
	#======================
	-#FIND_PACKAGE (LLVM REQUIRED CONFIG PATHS PATH-TO-CMAKE-DIR NO_DEFAULT_PATH)
	FIND_PACKAGE (LLVM REQUIRED)
	-set (CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake-tools")
	-#include(PCH_GCC4_v2)
	-
	set(LLVM_VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR})

	-message ("LLVM LIB PATH:" ${LLVM_LIBRARY_DIRS})
	-
	-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
	-message ("MPATH:" ${CMAKE_MODULE_PATH})
	-
	message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
	+message("LLVM LIB PATH:" ${LLVM_LIBRARY_DIRS})
	message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
	-message(STATUS "INCLUDE DIR: ${LLVM_INCLUDE_DIRS}")
	+
	INCLUDE_DIRECTORIES(${LLVM_INCLUDE_DIRS})
	-message("LLVM defs: " ${LLVM_DEFINITIONS})
	+message(STATUS "INCLUDE DIR: ${LLVM_INCLUDE_DIRS}")
	+
	add_definitions(${LLVM_DEFINITIONS})
	-llvm_map_components_to_libnames(LLVM_LIBS core nativecodegen native executionengine mcjit support)
	-message("LLVM libs: " ${LLVM_LIBS})
	+message("LLVM DEFS: " ${LLVM_DEFINITIONS})
	+
	+llvm_map_components_to_libnames(LLVM_LIBS core nativecodegen native executionengine mcjit support option)
	+message("LLVM LIBS: " ${LLVM_LIBS})



	# CLANG
	#======================
	set(CLANG_LIBS
	- ${LLVM_LIBRARY_DIRS}/libclangCodeGen.so
	- ${LLVM_LIBRARY_DIRS}/libclangASTMatchers.so
	- ${LLVM_LIBRARY_DIRS}/libclangQuery.so
	- ${LLVM_LIBRARY_DIRS}/libclangTooling.so
	- ${LLVM_LIBRARY_DIRS}/libclangFrontend.so
	- ${LLVM_LIBRARY_DIRS}/libclangSerialization.so
	- ${LLVM_LIBRARY_DIRS}/libclangDriver.so
	- ${LLVM_LIBRARY_DIRS}/libclangParse.so
	- ${LLVM_LIBRARY_DIRS}/libclangSema.so
	- ${LLVM_LIBRARY_DIRS}/libclangAnalysis.so
	- ${LLVM_LIBRARY_DIRS}/libclangAST.so
	- ${LLVM_LIBRARY_DIRS}/libclangEdit.so
	- ${LLVM_LIBRARY_DIRS}/libclangLex.so
	- ${LLVM_LIBRARY_DIRS}/libclangBasic.so
	+ clangCodeGen
	+ clangASTMatchers
	+ clangQuery
	+ clangTooling
	+ clangFrontend
	+ clangSerialization
	+ clangDriver
	+ clangParse
	+ clangSema
	+ clangAnalysis
	+ clangAST
	+ clangEdit
	+ clangLex
	+ clangBasic
	)
	-#find_package(Clang REQUIRED clangTooling libClang)
	-message(STATUS "CLANG LIBS: " ${CLANG_LIBS})



	# POTASSCO
	#======================
	set(POTASSCO_PATH "/opt/potassco/clingo" CACHE PATH "Path to potassco sources")
	set(POTASSCO_INCLUDE_PATH
	${POTASSCO_PATH}/libgringo
	${POTASSCO_PATH}/libclasp
	${POTASSCO_PATH}/libclingo
	${POTASSCO_PATH}/libprogram_opts
	${POTASSCO_PATH}/liblp
	)
	-
	INCLUDE_DIRECTORIES(${POTASSCO_INCLUDE_PATH})
	-
	-set (LIBCLASP_PATH ${POTASSCO_PATH}/build/debug)
	-
	set(LIBCLASP_LIBS
	clingo
	clasp
	gringo
	program_opts
	reify
	lp
	)
	-message(STATUS "CLASP LIBS: " ${LIBCLASP_LIBS})
	-link_directories(${LIBCLASP_PATH})
	+message("CLASP LIBS: " ${LIBCLASP_LIBS})



	# OTHER DEPENDENCIES
	#===========================
	set(JEAYESON_INCLUDE_PATH
	${CMAKE_HOME_DIRECTORY}/../vendors/jeayeson/include/
	)
	INCLUDE_DIRECTORIES(${JEAYESON_INCLUDE_PATH})



	# COCO
	#===========================

	set(COCO_EXECUTABLE "" CACHE PATH "Path to coco executable")

	set(COCO_GRAMMAR_PATH ${CMAKE_HOME_DIRECTORY}/../coco/)
	set(COCO_SOURCE_FILES
	${COCO_GRAMMAR_PATH}/Parser.cpp
	${COCO_GRAMMAR_PATH}/Scanner.cpp)
	INCLUDE_DIRECTORIES(${COCO_GRAMMAR_PATH})

	add_custom_command(OUTPUT ${COCO_SOURCE_FILES}
	COMMAND ${COCO_GRAMMAR_PATH}/gen-grammar ${COCO_EXECUTABLE}
	WORKING_DIRECTORY ${COCO_GRAMMAR_PATH}
	MAIN_DEPENDENCY ${COCO_GRAMMAR_PATH}/xreate.ATG
	)
	message(STATUS "COCO GRAMMAR BUILD STATUS:" ${COCO_OUTPUT})



	# XREATE
	#======================
	set(SOURCE_FILES
	- pass/compilepass.cpp
	- pass/interpretationpass.cpp
	- compilation/targetinterpretation.cpp
	-
	+ pass/compilepass.cpp
	ast.cpp
	ExternLayer.cpp
	attachments.cpp
	analysis/cfagraph.cpp
	analysis/dfagraph.cpp
	analysis/aux.cpp
	compilation/containers.cpp
	compilation/advanced.cpp
	compilation/transformations.cpp
	- analysis/DominatorsTreeAnalysisProvider.cpp
	clasplayer.cpp
	compilation/latecontextcompiler2.cpp
	query/context.cpp
	#compilation/latecontextcompiler.cpp
	- serialization/expressionserializer.cpp
	serialization/expressionserializer2.cpp
	llvmlayer.cpp
	utils.cpp
	passmanager.cpp
	pass/abstractpass.cpp pass/dfapass.cpp
	pass/cfapass.cpp
	- pass/loggerpass.cpp
	pass/adhocpass.cpp
	- query/containers.cpp
	contextrule.cpp
	+ query/containers.cpp
	+ pass/loggerpass.cpp
	+ pass/interpretationpass.cpp
	+ serialization/expressionserializer.cpp
	+ compilation/targetinterpretation.cpp
	+ analysis/DominatorsTreeAnalysisProvider.cpp

	#query/ptrvalid.cpp
	#pass/rulespass.cpp #
	)

	set(XREATE_INCLUDE_DIRS
	${CMAKE_CURRENT_SOURCE_DIR}/
	)

	INCLUDE_DIRECTORIES(${XREATE_INCLUDE_DIRS})

	set(XREATE_PRIVATE_INCLUDE_DIRS
	${XREATE_INCLUDE_DIRS}
	${COCO_GRAMMAR_PATH}
	${JEAYESON_INCLUDE_PATH}
	${LLVM_INCLUDE_DIRS}
	${POTASSCO_INCLUDE_PATH}
	)

	add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES} ${COCO_SOURCE_FILES})
	-target_link_libraries(${PROJECT_NAME} ${LIBCLASP_LIBS})
	+target_link_libraries(${PROJECT_NAME})


	target_include_directories(${PROJECT_NAME} INTERFACE
	${XREATE_INCLUDE_DIRS}
	${COCO_GRAMMAR_PATH}
	${JEAYESON_INCLUDE_PATH}
	${LLVM_INCLUDE_DIRS}
	${POTASSCO_INCLUDE_PATH}
	)

	get_directory_property(DEFINITIONS_ALL DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS)
	message("definitions all: " ${DEFINITIONS_ALL})
	target_compile_definitions(${PROJECT_NAME} INTERFACE ${DEFINITIONS_ALL})

	get_directory_property(COMPILATION_OPTIONS_ALL DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS)
	message("compilations all: " ${COMPILATION_OPTIONS_ALL})
	target_compile_options(${PROJECT_NAME} INTERFACE ${COMPILATION_OPTIONS_ALL})

	SET_PROPERTY(TARGET ${PROJECT_NAME} PROPERTY
	- INTERFACE_LINK_LIBRARIES ${LLVM_LIBS} ${CLANG_LIBS} tbb
	+ INTERFACE_LINK_LIBRARIES ${LIBCLASP_LIBS} ${CLANG_LIBS} ${LLVM_LIBS} tbb
	)

	+#${CLANG_LIBS}
	+
	+
	#set (LINK_INTERFACE_LIBRARIES "")

	# FUNCTION(PREPEND var prefix)
	# SET(listVar "")
	# FOREACH(f ${ARGN})
	# LIST(APPEND listVar "${prefix}/${f}")
	# ENDFOREACH(f)
	# SET(${var} "${listVar}" PARENT_SCOPE)
	# ENDFUNCTION(PREPEND)

	#set(COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "-j4")
	#cotire(xreate)


	# MACRO (ADD_PCH_RULE _header_filename _src_list)
	# SET(_gch_filename "${_header_filename}.gch")
	# LIST(APPEND ${_src_list} ${_gch_filename})
	# SET (_args ${CMAKE_CXX_FLAGS})
	# LIST(APPEND _args -c ${_header_filename} -o ${_gch_filename})
	# GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES)
	# foreach (_inc ${DIRINC})
	# LIST(APPEND _args "-I" ${_inc})
	# endforeach(_inc ${DIRINC})
	# SEPARATE_ARGUMENTS(_args)
	# add_custom_command(OUTPUT ${_gch_filename}
	# COMMAND rm -f ${_gch_filename}
	# COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} ${_args}
	# DEPENDS ${_header_filename})
	# ENDMACRO(ADD_PCH_RULE _header_filename _src_list)

	# ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/ast.h SOURCE_FILES)
	# ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/llvmlayer.h SOURCE_FILES)
	# ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/clasplayer.h SOURCE_FILES)
	# ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/pass/abstractpass.h SOURCE_FILES)
	diff --git a/cpp/src/analysis/DominatorsTreeAnalysisProvider.cpp b/cpp/src/analysis/DominatorsTreeAnalysisProvider.cpp
	index 7d08a2d..9bd280d 100644
	--- a/cpp/src/analysis/DominatorsTreeAnalysisProvider.cpp
	+++ b/cpp/src/analysis/DominatorsTreeAnalysisProvider.cpp
	@@ -1,233 +1,233 @@
	/*
	* To change this license header, choose License Headers in Project Properties.
	* To change this template file, choose Tools \| Templates
	* and open the template in the editor.
	*/

	-/*
	+/*
	* File: DominatorsTreeAnalysisProvider.cpp
	* Author: pgess
	- *
	+ *
	* Created on May 13, 2016, 11:39 AM
	*/

	#include "analysis/cfagraph.h"
	#include "analysis/DominatorsTreeAnalysisProvider.h"

	#include "llvm/ADT/GraphTraits.h"
	#include "llvm/Support/GenericDomTreeConstruction.h"
	#include "llvm/Support/GenericDomTree.h"

	#include <list>
	#include <iostream>
	#include <boost/format.hpp>

	using namespace std;
	using namespace xreate;
	using namespace boost;
	using namespace boost::bimaps;

	struct ControlFlowTree;

	struct Node {
	ScopePacked scope;
	ControlFlowTree* tree;
	};

	/*
	bool operator !=(const Node& a, const Node& b){
	return (a.tree != b.tree) \|\| (a.scope != b.scope);
	}

	Node& operator++(Node& a){
	++a.scope;
	return a;
	}
	*/

	struct ControlFlowTree{
	typedef bimap<multiset_of<ScopePacked>, multiset_of<ScopePacked>> CHILD_RELATIONS;
	CHILD_RELATIONS edges;
	std::vector<Node> nodes;
	Node* entry = nullptr;
	size_t size;
	-
	+
	ControlFlowTree(const size_t nodesCount): nodes(nodesCount), size(nodesCount){
	}
	-
	+
	static ControlFlowTree* build(const ClaspLayer* engine){
	ControlFlowTree* tree = new ControlFlowTree(engine->getScopesCount());
	-
	+
	xreate::analysis::CFAGraph* graph = engine->dataCFA.get();
	-
	+
	for (const auto& edge: graph->__parentScopeRelations){
	tree->edges.insert(CHILD_RELATIONS::value_type(edge.second, edge.first));
	}
	-
	+
	for (const auto& edge: graph->__callRelations){
	unsigned int calleeFunction = edge.right;
	ScopePacked caller = edge.left;
	-
	+
	auto range = graph->__parentFunctionRelations.right.equal_range(calleeFunction);
	for (auto& i=range.first; i!= range.second; ++i){
	tree->edges.insert(CHILD_RELATIONS::value_type(caller, i->second));
	}
	}
	-
	+
	for (size_t i=0; i<tree->size; ++i){
	tree->nodes[i]= Node{(unsigned int) i, tree};
	}
	-
	+
	return tree;
	}
	-
	+
	std::list<unsigned int> getRootFunctions() const{
	size_t idMax = size;
	size_t id =0;
	std::list<unsigned int> results;
	auto i = edges.right.begin();
	-
	+
	while (id < idMax) {
	if (i!= edges.right.end() && i->first == id){
	i = edges.right.upper_bound(i->first);
	-
	+
	} else {
	results.push_back(id);
	}
	-
	+
	++id;
	}
	-
	+
	return std::move(results);
	}
	};

	namespace llvm {
	template <> struct GraphTraits<Node*> {
	typedef Node* nodes_iterator;
	typedef Node NodeType;

	typedef std::function<Node*(ControlFlowTree::CHILD_RELATIONS::left_value_type)> Transformer;
	- typedef typename boost::iterators::transform_iterator<Transformer, ControlFlowTree::CHILD_RELATIONS::left_iterator> ChildIteratorType;
	-
	+ typedef typename boost::transform_iterator<Transformer, ControlFlowTree::CHILD_RELATIONS::left_iterator> ChildIteratorType;
	+
	static ChildIteratorType child_begin(const nodes_iterator& node) {
	auto range = node->tree->edges.left.equal_range(node->scope);
	Transformer x = [node](auto edge){return &node->tree->nodes[edge.second];};
	-
	+
	return boost::make_transform_iterator(range.first, x);
	}
	-
	+
	static ChildIteratorType child_end(const nodes_iterator& node) {
	auto range = node->tree->edges.left.equal_range(node->scope);
	Transformer x = [node](auto edge){return &node->tree->nodes[edge.second];};
	-
	- return boost::make_transform_iterator(range.second, x);
	+
	+ return boost::make_transform_iterator(range.second, x);
	}
	};
	-
	+
	template <> struct GraphTraits<Inverse<Node*>> {
	typedef Node* nodes_iterator;
	typedef Node NodeType;

	typedef std::function<Node*(ControlFlowTree::CHILD_RELATIONS::right_value_type)> Transformer;
	- typedef typename boost::iterators::transform_iterator<Transformer, ControlFlowTree::CHILD_RELATIONS::right_iterator> ChildIteratorType;
	-
	+ typedef typename boost::transform_iterator<Transformer, ControlFlowTree::CHILD_RELATIONS::right_iterator> ChildIteratorType;
	+
	static ChildIteratorType child_begin(const nodes_iterator& node) {
	auto range = node->tree->edges.right.equal_range(node->scope);
	Transformer x = [node](auto edge){return &node->tree->nodes[edge.second];};
	-
	+
	return boost::make_transform_iterator(range.first, x);
	}
	-
	+
	static ChildIteratorType child_end(const nodes_iterator& node) {
	auto range = node->tree->edges.right.equal_range(node->scope);
	Transformer x = [node](auto edge){return &node->tree->nodes[edge.second];};
	-
	- return boost::make_transform_iterator(range.second, x);
	+
	+ return boost::make_transform_iterator(range.second, x);
	}
	};
	-
	+
	template <> struct GraphTraits<ControlFlowTree>: public GraphTraits<Node> {
	static NodeType*
	- getEntryNode(ControlFlowTree* F) {
	+ getEntryNode(ControlFlowTree* F) {
	if (F->entry) return F->entry;
	-
	+
	list<unsigned int>&& roots = F->getRootFunctions();
	assert(roots.size()==1);
	-
	+
	return F->entry = &F->nodes[roots.front()];
	}

	static nodes_iterator nodes_begin(ControlFlowTree* F) { return &F->nodes[0]; }
	static nodes_iterator nodes_end(ControlFlowTree* F) { return &F->nodes[F->size]; }
	static size_t size(ControlFlowTree* F) { return F->size; }
	};
	}

	class xreate::DominatorTree: public llvm::DominatorTreeBase<Node> {
	public:
	DominatorsTreeAnalysisProvider::Dominators dominators;
	-
	+
	DominatorTree(bool isPostDom): llvm::DominatorTreeBase<Node>(isPostDom) {}
	-
	+
	void run(ControlFlowTree& program){
	recalculate(program);
	-
	+
	//extract dominators info
	for (auto& entry: DomTreeNodes){
	if (!entry.getFirst()) continue;
	-
	+
	dominators.emplace(entry.getFirst()->scope, make_pair(entry.getSecond()->getDFSNumIn(), entry.getSecond()->getDFSNumOut()));
	}
	}
	-
	+
	void print(std::ostringstream& output, const std::string& atom) const {
	boost::format formatAtom(atom + "(%1%, range(%2%, %3%)).");
	for (auto entry: dominators){
	output << formatAtom % (entry.first) % (entry.second.first) % (entry.second.second)
	<< endl;
	}
	}
	};

	void
	DominatorsTreeAnalysisProvider::run(const ClaspLayer* engine){
	boost::scoped_ptr<ControlFlowTree> program(ControlFlowTree::build(engine));
	-
	+
	treeForwardDominators->run(*program);
	treePostDominators->run(*program);
	}

	void
	DominatorsTreeAnalysisProvider::print(std::ostringstream& output) const{
	treeForwardDominators->print(output, "cfa_forwdom");
	treePostDominators->print(output, "cfa_postdom");
	}

	-const DominatorsTreeAnalysisProvider::Dominators&
	+const DominatorsTreeAnalysisProvider::Dominators&
	DominatorsTreeAnalysisProvider::getForwardDominators() const{
	return treeForwardDominators->dominators;
	}

	-const DominatorsTreeAnalysisProvider::Dominators&
	+const DominatorsTreeAnalysisProvider::Dominators&
	DominatorsTreeAnalysisProvider::getPostDominators() const{
	return treePostDominators->dominators;
	}

	DominatorsTreeAnalysisProvider::DominatorsTreeAnalysisProvider()
	: treeForwardDominators(new DominatorTree(false))
	, treePostDominators(new DominatorTree(true))
	{}

	DominatorsTreeAnalysisProvider::~DominatorsTreeAnalysisProvider() {}

	-//void
	+//void
	//CodeScopesTree::print(){
	// typedef llvm::GraphTraits<Node*> Traits;
	// for (size_t i=0; i<size; ++i){
	//
	// for (auto j = Traits::child_begin(&nodes[i]); j!= Traits::child_end(&nodes[i]); ++j){
	// cout << i << "->" << (*j)->scope << endl;
	// }
	// }
	//}
	\ No newline at end of file
	diff --git a/cpp/src/analysis/dfagraph.cpp b/cpp/src/analysis/dfagraph.cpp
	index 7ccf9e0..00a3006 100644
	--- a/cpp/src/analysis/dfagraph.cpp
	+++ b/cpp/src/analysis/dfagraph.cpp
	@@ -1,250 +1,250 @@
	#include "analysis/dfagraph.h"
	#include "analysis/aux.h"

	#include <list>


	using namespace xreate;
	using namespace xreate::analysis;
	using namespace std;

	namespace xreate {
	namespace analysis {

	void
	DFAGraph::print(std::ostringstream& output) const {
	std::set<SymbolPacked> symbols;

	output << endl << "%\t\tStatic analysis: DFA" << endl;

	std::vector<std::pair<SymbolPacked, SymbolPacked>>::const_iterator i1;
	std::vector<DFGConnection>::const_iterator i2;

	boost::format formatDfaConnection("dfa_connection(%1%, %2%, %3%).");
	for (i1 = this->__edges.begin(), i2 = this->__data.begin(); i1 != this->__edges.end(); ++i1, ++i2) {
	string edgeName;
	switch (*i2) {
	case DFGConnection::WEAK: edgeName = "weak";
	break;
	case DFGConnection::STRONG: edgeName = "strong";
	break;
	case DFGConnection::PROTOTYPE: edgeName = "proto";
	break;
	}

	output << formatDfaConnection
	% formatSymbol(i1->first)
	% formatSymbol(i1->second)
	% edgeName
	<< " %" << this->__clasp->getHintForPackedSymbol(i1->first) << " - " << this->__clasp->getHintForPackedSymbol(i1->second)
	<< endl;

	symbols.insert(i1->first);
	symbols.insert(i1->second);
	}

	boost::format formatDfaDependency("dfa_dependency(%1%, %2%).");
	for (auto i = this->__dependencies.begin(); i != this->__dependencies.end(); ++i) {
	output << formatDfaDependency
	% formatSymbol(i->first)
	% formatSymbol(i->second)
	<< " %"
	<< this->__clasp->getHintForPackedSymbol(i->first) << " - "
	<< this->__clasp->getHintForPackedSymbol(i->second)
	<< endl;
	}

	boost::format formatBind("bind(%1%, %2%).");
	for (const pair<SymbolPacked, Expression>& tag : this->__tags) {
	for (string variant : xreate::analysis::compile(tag.second)) {
	output << formatBind
	% formatSymbol(tag.first)
	% (variant)
	<< "%" << this->__clasp->getHintForPackedSymbol(tag.first)
	<< endl;
	}

	symbols.insert(tag.first);
	}

	for (const SymbolPacked& s : symbols) {
	output << "v(" << formatSymbol(s) << ")."
	<< " %" << this->__clasp->getHintForPackedSymbol(s)
	<< endl;
	}
	}

	class VisitorAddTag : public boost::static_visitor<> {
	public:

	void operator()(const SymbolPacked& symbol) {
	__graph->__tags.emplace(symbol, move(__tag));
	}

	void operator()(SymbolTransient& symbol) {
	symbol.tags.push_back(move(__tag));
	}

	void operator()(const SymbolInvalid& symbol) {
	assert(false && "Undefined behaviour");
	}

	VisitorAddTag(DFAGraph * const dfagraph, Expression&& tag) :
	__graph(dfagraph), __tag(tag) {
	}

	private:
	DFAGraph * const __graph;
	Expression __tag;
	};

	class VisitorAddLink : public boost::static_visitor<> {
	public:

	void operator()(const SymbolPacked& nodeFrom) {
	if (!__graph->isConnected(__nodeTo, nodeFrom)) {
	__graph->__edges.emplace_back(__nodeTo, nodeFrom);
	__graph->__data.push_back(__link);

	DFAGraph::EdgeId eid = __graph->__edges.size() - 1;
	__graph->__outEdges.emplace(nodeFrom, eid);
	}
	}

	void operator()(const SymbolTransient& symbolFrom) {
	switch (__link) {
	case DFGConnection::WEAK:
	{
	//virtual symbol to hold transient annotations
	SymbolPacked symbPivot = __graph->createAnonymousSymbol(symbolFrom.scope);

	__graph->addConnection(symbPivot, symbolFrom, DFGConnection::STRONG);
	__graph->addConnection(__nodeTo, symbPivot, DFGConnection::WEAK);
	break;
	}

	case DFGConnection::STRONG:
	{
	for (const Expression& tag : symbolFrom.tags) {
	__graph->__tags.emplace(__nodeTo, tag);
	}
	break;
	}

	default:
	assert(false && "Undefined behavior");
	}
	}

	void operator()(const SymbolInvalid&) {
	if (__link == DFGConnection::STRONG) return;
	if (__link == DFGConnection::WEAK) return;

	assert(false && "Undefined behavior");
	}

	VisitorAddLink(DFAGraph * const dfagraph, const SymbolPacked& nodeTo, DFGConnection link) :
	__graph(dfagraph), __nodeTo(nodeTo), __link(link) {
	}

	private:
	DFAGraph * const __graph;
	SymbolPacked __nodeTo;
	DFGConnection __link;
	};

	class VisitorGetDependencyConnection : public boost::static_visitor<list<SymbolPacked>>
	{
	public:

	list<SymbolPacked>
	operator()(const SymbolPacked & nodeFrom) {
	return
	{
	nodeFrom
	};
	}

	list<SymbolPacked>
	operator()(const SymbolTransient & nodeFrom) {
	return nodeFrom.dependencies;
	}

	list<SymbolPacked>
	operator()(const SymbolInvalid&) {
	assert(false && "Undefined behavior");
	}

	VisitorGetDependencyConnection(DFAGraph * const g) : graph(g) {
	}
	DFAGraph * const graph;
	};

	class VisitorSetDependencyConnection : public boost::static_visitor<> {
	public:

	void operator()(SymbolPacked& nodeTo) {
	VisitorGetDependencyConnection visitorGetDepenencies(graph);
	auto deps = boost::apply_visitor(visitorGetDepenencies, nodeFrom);

	for (const SymbolPacked& dep : deps) {
	graph->__dependencies.emplace(nodeTo, dep);
	}
	}

	void operator()(SymbolTransient& nodeTo) {
	VisitorGetDependencyConnection visitorGetDepenencies(graph);
	auto deps = boost::apply_visitor(visitorGetDepenencies, nodeFrom);

	for (const SymbolPacked& dep : deps) {
	nodeTo.dependencies.push_back(dep);
	}
	}

	void operator()(SymbolInvalid&) {
	assert(false && "Undefined behavior");
	}

	VisitorSetDependencyConnection(DFAGraph * const g, SymbolNode s) : graph(g), nodeFrom(s) {
	}
	DFAGraph * const graph;
	SymbolNode nodeFrom;
	};

	bool
	DFAGraph::isConnected(const SymbolPacked& identifierTo, const SymbolPacked& identifierFrom) {
	auto range = __outEdges.equal_range(identifierFrom);

	for (std::multimap<SymbolPacked, EdgeId>::iterator edge = range.first; edge != range.second; ++edge) {
	if (__edges[edge->second].second == identifierTo)
	return true;
	}

	return false;
	}

	void
	DFAGraph::addConnection(const SymbolPacked& nodeTo, const SymbolNode& nodeFrom, DFGConnection link) {
	VisitorAddLink visitor(this, nodeTo, link);
	boost::apply_visitor(visitor, nodeFrom);
	}

	void
	DFAGraph::addDependencyConnection(SymbolNode& identifierTo, SymbolNode& identifierFrom) {
	VisitorSetDependencyConnection visitor(this, identifierFrom);
	boost::apply_visitor(visitor, identifierTo);
	}

	void
	DFAGraph::addAnnotation(SymbolNode& node, Expression&& tag) {
	VisitorAddTag visitor(this, move(tag));
	boost::apply_visitor(visitor, node);
	}

	SymbolPacked
	DFAGraph::createAnonymousSymbol(const ScopePacked& scope) {
	- return SymbolPacked{__countAnonymousSymbols++, scope, true};
	+ return SymbolPacked(__countAnonymousSymbols++, scope, true);
	}

	}
	}
	\ No newline at end of file
	diff --git a/cpp/src/clasplayer.cpp b/cpp/src/clasplayer.cpp
	index 76509c6..6434235 100644
	--- a/cpp/src/clasplayer.cpp
	+++ b/cpp/src/clasplayer.cpp
	@@ -1,279 +1,275 @@
	#include "clasplayer.h"

	#include <iostream>
	#include "utils.h"
	#include <boost/format.hpp>
	#include <boost/algorithm/string/join.hpp>
	#include <gringo/scripts.hh>

	#include "analysis/aux.h"
	#include "analysis/DominatorsTreeAnalysisProvider.h"
	#include "analysis/cfagraph.h"
	#include "analysis/dfagraph.h"

	using namespace std;

	//TODO escape identifiers started from upper case symbol
	namespace xreate {

	void
	ClaspLayer::printWarnings(std::ostream& out)
	{
	const std::string warningTag = "warning";

	auto warningsRange = __model.equal_range(warningTag);

	for (auto warning=warningsRange.first; warning!= warningsRange.second; ++warning) {
	unsigned int warningId;

	Gringo::Symbol params;
	std::tie(warningId, params) = parse<unsigned int, Gringo::Symbol>(warning->second);

	cout << "Warning: " << __warnings.at(warningId) << " ";
	params.print(out);
	out<<params;
	}
	}

	bool
	ClaspLayer::handleSolution(Gringo::Model const &model) {
	std::list<std::string> warnings;
	cout << "Model: " << endl;

	const string& atomBindVar = Config::get("clasp.bindings.variable");
	const string& atomBindFunc = Config::get("clasp.bindings.function");
	const string& atomBindScope = Config::get("clasp.bindings.scope");

	for (Gringo::Symbol atom : model.atoms(clingo_show_type_atoms)) {
	atom.print(cout);
	cout <<" \| "<< endl;

	string atomName(atom.name().c_str());
	if (atomName == atomBindVar \|\| atomName == atomBindFunc \|\| atomName == atomBindScope){
	string name = std::get<1>(parse<Gringo::Symbol, Gringo::Symbol>(atom)).name().c_str();
	__model.emplace(move(name), move(atom));
	}

	__model.emplace(atomName, move(atom));
	}

	return true;
	}

	void
	ClaspLayer::setCFAData(xreate::analysis::CFAGraph* graph) {
	dataCFA.reset(graph);
	}

	void
	ClaspLayer::setDFAData(xreate::analysis::DFAGraph* graph){
	dataDFA.reset(graph);
	}

	void
	ClaspLayer::addRuleWarning(const RuleWarning &rule) {
	//__partGeneral << rule << endl;

	list<string> domains;
	boost::format formatDef("%1%(%2%)");
	std::transform(rule.__args.begin(), rule.__args.end(), std::inserter(domains, domains.begin()),
	[&formatDef](const std::pair<std::string, DomainAnnotation> &argument) {
	string domain;
	switch (argument.second) {
	case DomainAnnotation::FUNCTION:
	domain = "function";
	break;
	case DomainAnnotation::VARIABLE:
	domain = "variable";
	break;
	}

	return boost::str(formatDef % domain % argument.first);
	});

	list<string> vars;
	std::transform(rule.__args.begin(), rule.__args.end(), std::inserter(vars, vars.begin()),
	[](const std::pair<std::string, DomainAnnotation> &argument) {
	return argument.first.c_str();
	});

	list<list<string>> guardsRaw;
	std::transform(rule.__guards.begin(), rule.__guards.end(), std::inserter(guardsRaw, guardsRaw.begin()),
	[this](const Expression &guard) {
	return xreate::analysis::compile(guard);
	});

	const list<string>& guards = xreate::analysis::multiplyLists(std::move(guardsRaw));
	list<string> &&branches = xreate::analysis::compileNeg(rule.__condition);

	boost::format formatWarning("warning(%1%, (%2%)):- %3%, %4%, %5%.");
	for (const string &guardsJoined: guards)
	for (const string &branch: branches) {
	unsigned int hook = registerWarning(string(rule.__message));

	__partGeneral << formatWarning
	%(hook)
	%(boost::algorithm::join(vars, ", "))
	%(branch)
	%(guardsJoined)
	%(boost::algorithm::join(domains, ", "))
	<<endl;
	}
	}



	unsigned int
	ClaspLayer::registerWarning(std::string &&message) {
	static int warningId = 0;
	__warnings.emplace(warningId, message);
	return warningId++;;
	}

	void
	ClaspLayer::involveImports() {
	ostream &out = __partGeneral;

	for (string fn: ast->__rawImports)
	{
	std::ifstream file(fn);
	if (!file) continue;

	while(!file.eof()){
	string line;
	std::getline(file, line);
	out << line << endl;
	}
	}
	}

	void
	ClaspLayer::addRawScript(std::string&& script){
	__partGeneral << script;
	}

	void
	ClaspLayer::run() {
	involveImports();

	if (this->dataDFA){
	this->dataDFA->print(__partGeneral);
	}

	if (this->dataCFA){
	this->dataCFA->print(__partGeneral);
	}

	DominatorsTreeAnalysisProvider providerDominators;
	providerDominators.run(this);
	providerDominators.print(__partGeneral);

	ostringstream program;
	program << __partTags.str() << __partGeneral.str();
	cout << FYEL(program.str()) << endl;

	std::vector<char const *> args{"clingo", nullptr};
	DefaultGringoModule moduleDefault;
	Gringo::Scripts scriptsDefault(moduleDefault);
	ClingoLib ctl(scriptsDefault, 0, args.data(), {}, 0);

	ctl.add("base", {}, program.str());
	ctl.ground({{"base", {}}}, nullptr);

	// solve
	Gringo::SolveResult result = ctl.solve([this](Gringo::Model const &model) {
	this->handleSolution(model);
	return true;
	}, {});

	if (result.satisfiable() == Gringo::SolveResult::Satisfiable) {
	cout << FGRN("SUCCESSFULLY") << endl;
	} else {
	cout << FRED("UNSUCCESSFULLY") << endl;
	}

	// invoke all query plugins to process clasp data
	for (auto q: __queries)
	{
	q.second->init(this);
	}
	}

	ClaspLayer::ClaspLayer() {
	}

	ClaspLayer::ModelFragment
	ClaspLayer::query(const std::string& atom)
	{
	if (! __model.count(atom)){
	return boost::none;
	}

	return ModelFragment(__model.equal_range(atom));
	}

	ScopePacked
	ClaspLayer::pack(CodeScope* const scope) {
	auto pos = __indexScopes.emplace(scope, __indexScopes.size());
	if (pos.second)
	__registryScopes.push_back(scope);

	return pos.first->second;
	}

	size_t
	ClaspLayer::getScopesCount() const{
	return __registryScopes.size();
	}

	SymbolPacked
	ClaspLayer::pack(const Symbol& symbol, std::string hintSymbolName)
	{
	- SymbolPacked result;
	-
	- result.scope = pack(symbol.scope);
	- result.identifier = symbol.identifier;
	+ SymbolPacked result(symbol.identifier, pack(symbol.scope));
	__indexSymbolNameHints.emplace(result, hintSymbolName);

	return result;
	}

	Symbol
	ClaspLayer::unpack(const SymbolPacked& symbol)
	{
	return Symbol{symbol.identifier, __registryScopes[symbol.scope]};
	};

	std::string
	ClaspLayer::getHintForPackedSymbol(const SymbolPacked& symbol){
	if (!symbol.categoryTransient) {
	auto result = __indexSymbolNameHints.find(symbol);
	return (result == __indexSymbolNameHints.end())? "" : result->second;

	} else {
	return "anonym(" + to_string(symbol.identifier) + ")";
	}
	}

	bool operator==(const SymbolPacked& s1, const SymbolPacked& s2)
	{
	return s1.identifier == s2.identifier && s1.scope == s2.scope;
	}

	bool operator<(const SymbolPacked& s1, const SymbolPacked& s2)
	{
	return s1.scope < s2.scope \|\| (s1.scope == s2.scope && s1.identifier < s2.identifier);
	}

	IQuery*
	ClaspLayer::registerQuery(IQuery *query, const QueryId& id) {
	return __queries.emplace(id, query).first->second;
	}

	IQuery*
	ClaspLayer::getQuery(const QueryId& id){
	assert(__queries.count(id) && "Undefined query");
	return __queries.at(id);
	}
	-}
	-
	+}
	\ No newline at end of file
	diff --git a/cpp/src/clasplayer.h b/cpp/src/clasplayer.h
	index ad8da19..6961026 100644
	--- a/cpp/src/clasplayer.h
	+++ b/cpp/src/clasplayer.h
	@@ -1,227 +1,230 @@
	#ifndef CLASPLAYER_H
	#define CLASPLAYER_H

	#include "ast.h"
	#include "contextrule.h"

	#include <clingo/clingocontrol.hh>
	#include <string>
	#include <climits>
	#include <boost/bimap.hpp>
	#include <boost/bimap/multiset_of.hpp>
	#include <boost/optional.hpp>
	#include <boost/scoped_ptr.hpp>
	#include <list>

	namespace xreate {

	typedef unsigned int ScopePacked;

	struct SymbolPacked {
	VID identifier;
	ScopePacked scope;
	- bool categoryTransient = false;
	+ bool categoryTransient;
	+
	+ SymbolPacked(): categoryTransient(false){}
	+ SymbolPacked(VID i, ScopePacked s, bool isTransient = false): identifier(i), scope(s), categoryTransient(isTransient){}
	};

	bool operator==(const SymbolPacked& s1, const SymbolPacked& s2);
	bool operator<(const SymbolPacked& s1, const SymbolPacked& s2);

	enum class DFGConnection {
	STRONG, WEAK, PROTOTYPE
	};

	class IAnalysisData {
	public:
	void print(std::ostringstream& output) const;
	virtual ~IAnalysisData(){};
	};

	class IQuery {
	public:
	virtual void init(ClaspLayer* clasp) = 0;
	virtual ~IQuery() {}
	};

	enum class QueryId {
	ContainersQuery,
	ContextQuery,
	PtrvalidQuery
	};

	namespace analysis{
	class DFAGraph;
	class CFAGraph;
	}

	class ClaspLayer {
	friend class ContextRule;

	//PROVIDERS:
	public:
	boost::scoped_ptr<xreate::analysis::DFAGraph> dataDFA;
	void setDFAData(xreate::analysis::DFAGraph* graph);

	boost::scoped_ptr<xreate::analysis::CFAGraph> dataCFA;
	void setCFAData(xreate::analysis::CFAGraph* graph);

	void addRawScript(std::string&& script);

	private:
	void involveImports();

	//QUERIES
	public:
	IQuery* registerQuery(IQuery* query, const QueryId& id);
	IQuery* getQuery(const QueryId& id);

	template<class ...Types>
	static std::tuple<Types...> parse(const Gringo::Symbol& atom);

	typedef std::multimap<std::string, Gringo::Symbol>::const_iterator ModelIterator;
	typedef boost::optional<std::pair<ClaspLayer::ModelIterator, ClaspLayer::ModelIterator>> ModelFragment;
	ModelFragment query(const std::string& atom);

	size_t getScopesCount() const;
	SymbolPacked pack(const Symbol& symbol, std::string hintSymbolName = "");
	ScopePacked pack(CodeScope * const scope);
	Symbol unpack(const SymbolPacked& symbol);
	std::string getHintForPackedSymbol(const SymbolPacked& symbol);

	private:
	std::map<QueryId, IQuery*> __queries;
	std::multimap<std::string, Gringo::Symbol> __model;
	std::map<SymbolPacked, std::string> __indexSymbolNameHints;
	std::unordered_map<const CodeScope*, unsigned int> __indexScopes;
	std::vector<CodeScope*> __registryScopes;

	//WARNINGS
	//TODO move to separate provider/query
	public:
	void addRuleWarning(const RuleWarning &rule);
	unsigned int registerWarning(std::string &&message);

	private:
	std::map<unsigned int, std::string> __warnings;
	void printWarnings(std::ostream& out);

	//DEFAULT
	public:
	AST *ast;

	ClaspLayer();
	void run();

	private:
	std::ostringstream __partTags;
	std::ostringstream __partGeneral;

	bool handleSolution(Gringo::Model const &model);
	};

	template<class typ>
	struct ParseImplAtom {

	static typ get(const Gringo::Symbol& atom) {
	return atom.num();
	}
	};

	template<>
	struct ParseImplAtom<std::string> {
	static std::string get(const Gringo::Symbol& atom) {
	switch (atom.type()) {
	case Gringo::SymbolType::Str: return atom.string().c_str();
	case Gringo::SymbolType::Fun: return atom.name().c_str();

	default: break;
	}

	assert(false && "Inappropriate symbol type");
	}
	};

	template<>
	struct ParseImplAtom<SymbolPacked> {

	static SymbolPacked get(const Gringo::Symbol& atom) {
	auto result = ClaspLayer::parse<unsigned int, unsigned int>(atom);
	- return SymbolPacked{std::get<0>(result), std::get<1>(result)};
	+ return SymbolPacked(std::get<0>(result), std::get<1>(result));
	}
	};

	template<>
	struct ParseImplAtom<Gringo::Symbol> {

	static Gringo::Symbol get(const Gringo::Symbol& atom) {
	return atom;
	}
	};

	template<>
	struct ParseImplAtom<Expression> {

	static Expression get(const Gringo::Symbol& atom) {
	switch (atom.type()) {
	case Gringo::SymbolType::Num: return Expression(atom.num());
	case Gringo::SymbolType::Str: return Expression(std::string(atom.string().c_str()));

	case Gringo::SymbolType::Fun:
	{
	//ID
	if (!atom.args().size){
	return Expression(std::string(atom.name().c_str()));
	}

	//FUNC
	Expression result(Operator::CALL,{Expression(std::string(atom.name().c_str()))});
	for (const Gringo::Symbol& arg : atom.args()) {
	result.addArg(ParseImplAtom<Expression>::get(arg));
	}

	return result;
	}

	default:
	{
	assert(false);
	}
	}
	}
	};

	template<class Tuple, size_t index>
	struct Parse_Impl {

	static void parse(Tuple& tup, Gringo::SymSpan::iterator arg) {
	const size_t tupleSize = std::tuple_size<Tuple>::value;
	typedef typename std::tuple_element < tupleSize - index, Tuple>::type ElType;

	ElType& el = std::get < tupleSize - index > (tup);

	Gringo::Symbol atom = *arg;
	el = ParseImplAtom<ElType>::get(atom);

	Parse_Impl<Tuple, index - 1 > ::parse(tup, ++arg);
	}
	};

	template<class Tuple>
	struct Parse_Impl<Tuple, 0> {

	static void parse(Tuple& tup, Gringo::SymSpan::iterator arg) {
	}
	};

	template<class ...Types>
	std::tuple<Types...>
	ClaspLayer::parse(const Gringo::Symbol& atom) {
	typedef std::tuple < Types...> Tuple;
	Tuple tup;
	Parse_Impl<Tuple, std::tuple_size<Tuple>::value>::parse(tup, atom.args().first);

	return tup;
	}


	}
	-#endif
	+#endif
	\ No newline at end of file
	diff --git a/cpp/src/compilation/targetinterpretation.cpp b/cpp/src/compilation/targetinterpretation.cpp
	index 90c48fb..b50bf13 100644
	--- a/cpp/src/compilation/targetinterpretation.cpp
	+++ b/cpp/src/compilation/targetinterpretation.cpp
	@@ -1,447 +1,446 @@
	/*
	* File: targetinterpretation.cpp
	* Author: pgess
	*
	* Created on June 29, 2016, 6:45 PM
	*/

	#include "compilation/targetinterpretation.h"
	#include "pass/interpretationpass.h"
	#include "llvmlayer.h"
	#include <boost/scoped_ptr.hpp>
	#include <iostream>

	using namespace std;

	namespace xreate{ namespace compilation {

	const Expression EXPRESSION_FALSE = Expression(Atom<Number_t>(0));
	const Expression EXPRESSION_TRUE = Expression(Atom<Number_t>(1));

	//Expression
	//InterpretationScope::compile(const Expression& expression){}

	CodeScope*
	InterpretationScope::processOperatorIf(const Expression& expression){
	const Expression& exprCondition = process(expression.getOperands()[0]);

	if (exprCondition == EXPRESSION_TRUE){
	return expression.blocks.front();
	}

	return expression.blocks.back();
	}

	CodeScope*
	InterpretationScope::processOperatorSwitch(const Expression& expression) {
	const Expression& exprCondition = process(expression.operands[0]);

	bool flagHasDefault = expression.operands[1].op == Operator::CASE_DEFAULT;

	//TODO check that one and only one case variant is appropriate
	for (size_t size = expression.operands.size(), i= flagHasDefault? 2: 1; i<size; ++i){
	const Expression& exprCase = process(expression.operands[i]);

	if (function->getScope(exprCase.blocks.front())->processScope() == exprCondition){
	return exprCase.blocks.back();
	}
	}

	if (flagHasDefault){
	const Expression& exprCaseDefault = expression.operands[1];
	return exprCaseDefault.blocks.front();
	}

	assert(false && "Switch has no appropriate variant");
	return nullptr;
	}

	llvm::Value*
	InterpretationScope::compileHybrid(const InterpretationOperator& op, const Expression& expression, const Context& context){
	switch(op){
	case IF_INTERPRET_CONDITION: {
	CodeScope* scopeResult = processOperatorIf(expression);

	llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
	return result;
	}

	case SWITCH_INTERPRET_CONDITION:{
	CodeScope* scopeResult = processOperatorSwitch(expression);

	llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
	return result;
	}

	case FOLD_INTERPRET_INPUT: {
	//initialization
	const Expression& exprInput = process(expression.getOperands()[0]);
	assert(exprInput.op == Operator::LIST);

	CodeScope* scopeBody = expression.blocks.front();

	const string& nameEl = expression.bindings[0];
	const Symbol& symbolEl = scopeBody->findSymbol(nameEl);
	const std::string& idAccum = expression.bindings[1];
	llvm::Value* rawAccum = context.scope->process(expression.getOperands()[1]);
	compilation::CodeScopeUnit* unitBody = context.function->getScopeUnit(scopeBody);
	InterpretationScope* intrBody = function->getScope(scopeBody);
	const std::vector<Expression> elementsInput= exprInput.getOperands();

	for (size_t i=0; i<elementsInput.size(); ++i){
	Expression exprElement = elementsInput[i];

	unitBody->reset();

	intrBody->overrideBinding(exprElement, nameEl);
	unitBody->overrideDeclaration(symbolEl, move(exprElement));
	unitBody->bindArg(rawAccum, string(idAccum));

	rawAccum = unitBody->compile();
	}

	return rawAccum;
	}

	case CALL_INTERPRET_PARTIAL: {
	const std::string &calleeName = expression.getValueString();
	CodeScopeUnit* scopeUnitSelf = context.scope;
	ManagedFnPtr callee = this->function->man->ast->findFunction(calleeName);
	const FunctionInterpretationData& calleeData = FunctionInterpretationHelper::getSignature(callee);
	std::vector<llvm::Value *> argsActual;
	PIFSignature sig;
	sig.declaration = callee;

	for(size_t no=0, size = expression.operands.size(); no < size; ++no){
	const Expression& op = expression.operands[no];

	if (calleeData.signature.at(no) == INTR_ONLY){
	sig.bindings.push_back(process(op));
	continue;
	}

	argsActual.push_back(scopeUnitSelf->process(op));
	}

	TargetInterpretation* man = dynamic_cast<TargetInterpretation*>(this->function->man);
	PIFunction* pifunction = man->getFunction(move(sig));

	llvm::Function* raw = pifunction->compile();
	boost::scoped_ptr<CallStatementRaw> statement(new CallStatementRaw(raw, man->pass->man->llvm));
	return (*statement)(move(argsActual));
	}

	default: break;
	}

	assert(false&& "Unknown hybrid operator");
	return nullptr;
	}

	llvm::Value*
	InterpretationScope::compile(const Expression& expression, const Context& context){
	const InterpretationData& data = Attachments::get<Expression, InterpretationData>(expression);

	if (data.op != InterpretationOperator::NONE){
	return compileHybrid(data.op, expression, context);
	}

	Expression result = process(expression);
	return context.scope->processLowlevel(result);
	}

	Expression
	InterpretationScope::process(const Expression& expression){
	switch (expression.__state){
	case Expression::VARIANT:
	case Expression::INVALID:
	assert(false);

	case Expression::NUMBER:
	case Expression::STRING:
	return expression;

	case Expression::IDENT:{
	const std::string &ident = expression.getValueString();

	Symbol s = scope->findSymbol(ident);
	return Parent::processSymbol(s);
	}

	case Expression::COMPOUND:
	break;

	default: assert(false);
	}

	switch (expression.op) {
	case Operator::EQU: {
	const Expression& left = process(expression.operands[0]);
	const Expression& right = process(expression.operands[1]);

	if (left == right) return EXPRESSION_TRUE;
	return EXPRESSION_FALSE;
	}

	case Operator::NE: {
	const Expression& left = process(expression.operands[0]);
	const Expression& right = process(expression.operands[1]);

	if (left == right) return EXPRESSION_FALSE;
	return EXPRESSION_TRUE;
	}

	case Operator::LOGIC_AND: {
	assert(expression.operands.size() == 1);
	return process (expression.operands[0]);
	}


	// case Operator::LOGIC_OR:
	case Operator::CALL: {
	const std::string &fnName = expression.getValueString();
	ManagedFnPtr fnAst = this->function->man->ast->findFunction(fnName);
	- InterpretatonFunction* fnUnit = this->function->man->getFunction(fnAst);
	+ InterpretationFunction* fnUnit = this->function->man->getFunction(fnAst);

	vector<Expression> args;
	args.reserve(expression.getOperands().size());

	for(size_t i=0, size = expression.getOperands().size(); i<size; ++i) {
	args.push_back(process(expression.getOperands()[i]));
	}

	return fnUnit->process(args);
	}

	case Operator::IF:{
	CodeScope* scopeResult = processOperatorIf(expression);
	return function->getScope(scopeResult)->processScope();
	}

	case Operator::SWITCH: {
	CodeScope* scopeResult = processOperatorSwitch(expression);
	return function->getScope(scopeResult)->processScope();
	}

	case Operator::INDEX: {
	const Expression& exprKey = process(expression.operands[0]);
	const Expression& exprData = processSymbol(scope->findSymbol(expression.getValueString()));


	if (exprKey.__state == Expression::STRING){
	const string& key = exprKey.getValueString();
	assert(exprData.__indexBindings.count(key));

	return exprData.operands[exprData.__indexBindings.at(key)];
	}

	if (exprKey.__state == Expression::NUMBER){
	int key = exprKey.getValueDouble();
	return exprData.operands[key];
	}

	assert(false);
	}

	case Operator::FOLD: {
	const Expression& exprInput = process(expression.getOperands()[0]);
	const Expression& exprInit = process(expression.getOperands()[1]);

	const std::string& argEl = expression.bindings[0];
	const std::string& argAccum = expression.bindings[1];

	InterpretationScope* body = function->getScope(expression.blocks.front());

	Expression accum = exprInit;
	for(size_t size=exprInput.getOperands().size(), i=0; i<size; ++i){
	body->overrideBinding(exprInput.getOperands()[i], argEl);
	body->overrideBinding(accum, argAccum);

	accum = body->processScope();
	}

	return accum;
	}

	// case Operator::MAP: {
	// break;
	// }

	default: break;
	}

	return expression;
	}

	-InterpretatonFunction*
	+InterpretationFunction*
	TargetInterpretation::getFunction(FunctionUnit* unit){
	if (__dictFunctionsByUnit.count(unit)) {
	return __dictFunctionsByUnit.at(unit);
	}

	- InterpretatonFunction* f = new InterpretatonFunction(unit->function, this);
	+ InterpretationFunction* f = new InterpretationFunction(unit->function, this);
	__dictFunctionsByUnit.emplace(unit, f);
	assert(__functions.emplace(unit->function.id(), f).second);

	return f;
	}

	PIFunction*
	TargetInterpretation::getFunction(PIFSignature&& sig){

	- auto f = __pifunctions.find<PIFSignature>(sig);
	+ auto f = __pifunctions.find(sig);
	if (f != __pifunctions.end()){
	- return *f;
	+ return f->second;
	}

	- PIFunction* result = new PIFunction(move(sig), __pifunctions.size(), this);
	- __pifunctions.insert(result);
	+ PIFunction* result = new PIFunction(PIFSignature(sig), __pifunctions.size(), this);
	+ __pifunctions.emplace(move(sig), result);
	assert(__dictFunctionsByUnit.emplace(result->functionUnit, result).second);

	return result;
	}

	InterpretationScope*
	TargetInterpretation::transformContext(const Context& c){
	return this->getFunction(c.function)->getScope(c.scope->scope);
	}

	llvm::Value*
	TargetInterpretation::transform(const Expression& expression, llvm::Value* raw, const Context& ctx){
	return raw;
	}

	Expression
	TargetInterpretation::transform(const Expression& expression, const Context& ctx){
	return transformContext(ctx)->process(expression);
	}

	llvm::Value*
	TargetInterpretation::compile(const Expression& expression, const Context& ctx){
	return transformContext(ctx)->compile(expression, ctx);
	}

	bool
	TargetInterpretation::isAcceptable(const Expression& expression){
	const InterpretationData& data = Attachments::get<Expression, InterpretationData>(expression, {ANY, NONE});

	return (data.resolution == INTR_ONLY \|\| data.op != InterpretationOperator::NONE);
	}

	-InterpretatonFunction::InterpretatonFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target)
	+InterpretationFunction::InterpretationFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target)
	: Function<TargetInterpretation>(function, target)
	{}

	Expression
	-InterpretatonFunction::process(const std::vector<Expression>& args){
	+InterpretationFunction::process(const std::vector<Expression>& args){
	InterpretationScope* body = getScope(__function->__entry);

	for(size_t i=0, size = args.size(); i<size; ++i) {
	body->overrideBinding(args.at(i), string(body->scope->__bindings.at(i)));
	}

	return body->processScope();
	}

	// Partial function interpretation

	typedef BasicFunctionDecorator PIFunctionUnitParent;
	class PIFunctionUnit: public PIFunctionUnitParent{
	public:

	PIFunctionUnit(ManagedFnPtr f, std::set<size_t>&& arguments, size_t id, CompilePass* p)
	: PIFunctionUnitParent(f, p), argumentsActual(move(arguments)), __id(id)
	{}

	protected:
	std::vector<llvm::Type*> prepareArguments(){
	LLVMLayer* llvm = PIFunctionUnitParent::pass->man->llvm;
	AST* ast = PIFunctionUnitParent::pass->man->root;
	CodeScope* entry = PIFunctionUnitParent::function->__entry;
	std::vector<llvm::Type*> signature;

	for(size_t no: argumentsActual){
	Symbol arg = entry->findSymbol(entry->__bindings[no]);

	signature.push_back(llvm->toLLVMType(ast->expandType(entry->__declarations[arg.identifier].type)));
	}

	return signature;
	}

	llvm::Function::arg_iterator prepareBindings(){
	CodeScope* entry = PIFunctionUnitParent::function->__entry;
	CodeScopeUnit* entryCompilation = PIFunctionUnitParent::getScopeUnit(entry);
	llvm::Function::arg_iterator fargsI = PIFunctionUnitParent::raw->arg_begin();

	for(size_t no: argumentsActual){
	Symbol arg = entry->findSymbol(entry->__bindings[no]);

	entryCompilation->__rawVars[arg.identifier] = &*fargsI;
	fargsI->setName(entry->__bindings[no]);
	++fargsI;
	}

	return fargsI;
	}

	virtual std::string prepareName(){
	return PIFunctionUnitParent::prepareName() + "_" + std::to_string(__id);
	}

	private:
	std::set<size_t> argumentsActual;
	size_t __id;
	};

	PIFunction::PIFunction(PIFSignature&& sig, size_t id, TargetInterpretation* target)
	- : InterpretatonFunction(sig.declaration, target), signatureInstance(move(sig))
	+ : InterpretationFunction(sig.declaration, target), signatureInstance(move(sig))
	{
	const FunctionInterpretationData& functionData = FunctionInterpretationHelper::getSignature(signatureInstance.declaration);

	std::set<size_t> argumentsActual;
	for (size_t no=0, size=functionData.signature.size(); no < size; ++no){
	if (functionData.signature.at(no) != INTR_ONLY){
	argumentsActual.insert(no);
	}
	}

	functionUnit = new PIFunctionUnit(signatureInstance.declaration, move(argumentsActual), id, target->pass);
	CodeScope* entry = signatureInstance.declaration->__entry;
	CodeScopeUnit* entryUnit = functionUnit->getEntry();
	- InterpretationScope* entryIntrp = InterpretatonFunction::getScope(entry);
	+ InterpretationScope* entryIntrp = InterpretationFunction::getScope(entry);

	for(size_t no=0, sigNo=0, size = entry->__bindings.size(); no < size; ++no){
	if (functionData.signature.at(no) == INTR_ONLY){
	entryIntrp->overrideBinding(signatureInstance.bindings[sigNo], entry->__bindings[no]);
	entryUnit->overrideDeclaration(entry->findSymbol(entry->__bindings[no]), Expression(signatureInstance.bindings[sigNo]));
	++sigNo;
	}
	}
	}

	llvm::Function*
	PIFunction::compile(){
	llvm::Function* raw = functionUnit->compile();

	return raw;
	}

	bool operator<(const PIFSignature& lhs, const PIFSignature& rhs){
	if (lhs.declaration.id() != rhs.declaration.id()) {
	return lhs.declaration.id() < rhs.declaration.id();
	}

	return lhs.bindings < rhs.bindings;
	}

	bool operator<(const PIFSignature& lhs, PIFunction* const rhs){
	return lhs < rhs->signatureInstance;
	}

	bool operator<(PIFunction* const lhs, const PIFSignature& rhs){
	return lhs->signatureInstance < rhs;
	}

	-}}
	-
	+}}
	\ No newline at end of file
	diff --git a/cpp/src/compilation/targetinterpretation.h b/cpp/src/compilation/targetinterpretation.h
	index 2d7444e..0ef32e7 100644
	--- a/cpp/src/compilation/targetinterpretation.h
	+++ b/cpp/src/compilation/targetinterpretation.h
	@@ -1,117 +1,116 @@
	/*
	* To change this license header, choose License Headers in Project Properties.
	* To change this template file, choose Tools \| Templates
	* and open the template in the editor.
	*/

	/*
	* File: targetstatic.h
	* Author: pgess
	*
	* Created on July 2, 2016, 1:25 PM
	*/

	#ifndef TARGETSTATIC_H
	#define TARGETSTATIC_H

	#include "ast.h"
	#include "compilation/targets.h"
	#include "transformations.h"
	#include "pass/interpretationpass.h"

	namespace xreate{ namespace compilation {

	class TargetInterpretation;
	class InterpretationScope;
	-class InterpretatonFunction;
	+class InterpretationFunction;

	template <>
	struct TargetInfo<TargetInterpretation> {
	typedef Expression Result;
	typedef InterpretationScope Scope;
	- typedef InterpretatonFunction Function;
	+ typedef InterpretationFunction Function;
	};

	template<>
	struct TransformerInfo<TargetInterpretation> {
	static const int id = 1;
	};

	class InterpretationScope: public Scope<TargetInterpretation>{
	typedef Scope<TargetInterpretation> Parent;

	public:
	InterpretationScope(CodeScope* scope, Function<TargetInterpretation>* f): Parent(scope, f) {}
	Expression process(const Expression& expression) override;

	llvm::Value* compile(const Expression& expression, const Context& context);

	private:
	llvm::Value* compileHybrid(const InterpretationOperator& op, const Expression& expression, const Context& context);
	//llvm::Value* compilePartialFnCall(const Expression& expression, const Context& context);

	CodeScope* processOperatorIf(const Expression& expression);
	CodeScope* processOperatorSwitch(const Expression& expression);
	};

	-class InterpretatonFunction: public Function<TargetInterpretation>{
	+class InterpretationFunction: public Function<TargetInterpretation>{
	public:
	- InterpretatonFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target);
	+ InterpretationFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target);
	Expression process(const std::vector<Expression>& args);
	};

	/*
	* Partially interpreted function signature
	*/
	struct PIFSignature{
	ManagedFnPtr declaration;
	std::vector<Expression> bindings;
	};

	class PIFunctionUnit;

	-class PIFunction: public InterpretatonFunction{
	+class PIFunction: public InterpretationFunction{
	public:
	PIFunctionUnit* functionUnit;
	PIFSignature signatureInstance;

	PIFunction(PIFSignature&& sig, size_t id, TargetInterpretation* target);
	llvm::Function* compile();
	};

	bool operator<(const PIFSignature& lhs, PIFunction* const rhs);
	bool operator<(PIFunction* const lhs, const PIFSignature& rhs);

	class TargetInterpretation: public Target<TargetInterpretation>, public Transformer{
	public:
	TargetInterpretation(AST* root, CompilePass* passCompilation): Target<TargetInterpretation>(root), pass(passCompilation){}

	//transformer:
	public:
	virtual llvm::Value* transform(const Expression& expression, llvm::Value* raw, const Context& ctx) override;
	virtual Expression transform(const Expression& expression, const Context& ctx) override;
	virtual bool isAcceptable(const Expression& expression) override;

	//target:
	public:
	- InterpretatonFunction* getFunction(FunctionUnit* unit);
	+ InterpretationFunction* getFunction(FunctionUnit* unit);
	PIFunction* getFunction(PIFSignature&& sig);

	private:
	- std::set<PIFunction*, std::less<>> __pifunctions;
	- std::map<FunctionUnit, InterpretatonFunction> __dictFunctionsByUnit;
	+ std::map<PIFSignature, PIFunction*> __pifunctions;
	+ std::map<FunctionUnit, InterpretationFunction> __dictFunctionsByUnit;

	//self:
	public:
	CompilePass* pass;
	llvm::Value* compile(const Expression& expression, const Context& ctx);
	private:
	InterpretationScope* transformContext(const Context& c);
	};



	}}

	-#endif /* TARGETSTATIC_H */
	-
	+#endif /* TARGETSTATIC_H */
	\ No newline at end of file
	diff --git a/cpp/src/compilation/targets.h b/cpp/src/compilation/targets.h
	index b1821e3..f6b47bb 100644
	--- a/cpp/src/compilation/targets.h
	+++ b/cpp/src/compilation/targets.h
	@@ -1,156 +1,161 @@
	/*
	* File: targetabstract.h
	* Author: pgess
	*
	* Created on July 2, 2016, 1:25 PM
	*/

	#ifndef TARGETABSTRACT_H
	#define TARGETABSTRACT_H
	#include "ast.h"

	#include <boost/optional.hpp>
	#include <map>

	namespace xreate{ namespace compilation {

	template <typename ConcreteTarget>
	struct TargetInfo{
	//typedef Result
	//typedef Function
	//typedef Scope
	};

	template<typename ConcreteTarget>
	class Function;

	template<typename ConcreteTarget>
	class Target;

	template<typename ConcreteTarget>
	class Scope{
	public:
	CodeScope* scope;

	typename TargetInfo<ConcreteTarget>::Result
	processSymbol(const Symbol& s){
	CodeScope* scope = s.scope;
	typename TargetInfo<ConcreteTarget>::Scope* self = function->getScope(scope);

	if (self->__bindings.count(s.identifier)) {
	return self->__bindings[s.identifier];
	}

	const Expression& declaration = CodeScope::findDeclaration(s);
	if (!declaration.isDefined()){
	assert(false); //for bindings there should be result already
	}

	return self->__bindings[s.identifier] = self->process(declaration);
	}

	typename TargetInfo<ConcreteTarget>::Result
	processScope() {
	if (raw) return *raw;

	raw = process(scope->getBody());
	return *raw;
	}

	// typename TargetInfo<ConcreteTarget>::Result
	// processFunction(typename TargetInfo<ConcreteTarget>::Function* fnRemote, const std::vector<typename TargetInfo<ConcreteTarget>::Result>& args){
	// Scope<ConcreteTarget> scopeRemote = fnRemote->getScope(fnRemote->__function->__entry);
	//
	// if (scopeRemote->raw){
	// return scopeRemote->raw;
	// }
	//
	// return fnRemote->process(args);
	// }

	virtual typename TargetInfo<ConcreteTarget>::Result
	process(const Expression& expression)=0;

	Scope(CodeScope* codeScope, Function<ConcreteTarget>* f)
	: scope(codeScope), function(f) {}

	virtual ~Scope(){}

	void
	overrideBinding(typename TargetInfo<ConcreteTarget>::Result arg, const std::string& name){
	assert(scope->__identifiers.count(name));

	VID id = scope->__identifiers.at(name);
	__bindings[id] = arg;

	//reset the result if any:
	raw.reset();
	}

	protected:
	Function<ConcreteTarget>* function=0;
	std::map<VID, typename TargetInfo<ConcreteTarget>::Result> __bindings;
	typename boost::optional<typename TargetInfo<ConcreteTarget>::Result> raw;

	//ResultType findFunction(const std::string& callee);
	};

	template<typename ConcreteTarget>
	class Function{
	typedef typename TargetInfo<ConcreteTarget>::Result Result;

	public:
	Function(const ManagedFnPtr& function, Target<ConcreteTarget>* target)
	: man(target), __function(function) {}

	+ virtual ~Function(){};
	+
	typename TargetInfo<ConcreteTarget>::Scope*
	getScope(CodeScope* scope){
	if (!__scopes.count(scope)){
	typename TargetInfo<ConcreteTarget>::Scope* unit = new typename TargetInfo<ConcreteTarget>::Scope(scope, this);
	__scopes.emplace(scope, std::unique_ptr<typename TargetInfo<ConcreteTarget>::Scope>(unit));
	}

	return __scopes.at(scope).get();
	}

	virtual Result
	process(const std::vector<Result>& args)=0;

	Target<ConcreteTarget>* man=0;
	ManagedFnPtr __function;

	protected:
	std::map<CodeScope*, std::unique_ptr<typename TargetInfo<ConcreteTarget>::Scope>> __scopes;
	};

	template<typename ConcreteTarget>
	class Target {
	typedef typename TargetInfo<ConcreteTarget>::Function ConcreteFunction;

	public:
	Target(AST* root): ast(root){}

	ConcreteFunction*
	getFunction(const ManagedFnPtr& function){
	unsigned int id = function.id();

	if (!__functions.count(id)){
	ConcreteFunction* unit = new ConcreteFunction(function, this);
	- __functions.emplace(id, std::unique_ptr<ConcreteFunction>(unit));
	+ __functions.emplace(id, unit);
	return unit;
	}

	- return __functions.at(id).get();
	+ return __functions.at(id);
	}

	AST* ast;
	- virtual ~Target(){}
	+ virtual ~Target(){
	+ for (const auto& entry: __functions){
	+ delete entry.second;
	+ }
	+ }

	protected:
	- std::map<unsigned int, std::unique_ptr<ConcreteFunction>> __functions;
	+ std::map<unsigned int, ConcreteFunction*> __functions;
	};

	}}

	-#endif /* TARGETABSTRACT_H */
	-
	+#endif /* TARGETABSTRACT_H */
	\ No newline at end of file
	diff --git a/cpp/src/serialization/expressionserializer.cpp b/cpp/src/serialization/expressionserializer.cpp
	index 42b5a15..53d6ee5 100644
	--- a/cpp/src/serialization/expressionserializer.cpp
	+++ b/cpp/src/serialization/expressionserializer.cpp
	@@ -1,303 +1,316 @@
	/*
	* expressionserializer.cpp
	*
	* Created on: Jan 4, 2016
	* Author: pgess
	*/

	#include "serialization/expressionserializer.h"
	+#include <boost/utility.hpp>
	#include <cmath>

	using namespace std;
	//using namespace boost::bimaps;
	namespace xreate {

	struct Index {
	string name;
	size_t degree; //count of parameters
	unsigned char level; //level in expression tree (depth of tree layer)

	bool operator< (const Index other) const{
	if (name != other.name) return name < other.name;
	if (degree != other.degree) return degree < other.degree;
	if (name != other.name) return level < other.level;
	return false;
	}
	};

	class ExpressionSerializerPrivate {
	//boost::bimap<Index, multiset_of<size_t>> __registry;
	struct {
	map<Index,size_t> left;
	} __registry;
	map<unsigned char, size_t> __range;

	public:
	void pack(const Expression& e, unsigned char level, OptionalPackedExpression& target){
	if (!target) return;
	switch (e.op){
	case Operator::NONE: {
	switch (e.__state) {
	case Expression::NUMBER:
	case Expression::STRING:
	case Expression::IDENT : {
	-
	+
	Index index;
	if ((e.__state == Expression::NUMBER))
	index = {std::to_string(e.getValueDouble()), 0, level};
	else index = {e.getValueString(), 0, level};
	-
	+
	if (!__registry.left.count(index)){
	target = boost::none;
	return;
	}

	size_t id = __registry.left.at(index);
	size_t range = __range[level];
	(*target) << make_pair(id, range);
	return;
	}
	default: break;
	}
	break;
	}

	case Operator::CALL: {
	Index index{e.getValueString(), e.operands.size(), level};
	if(!__registry.left.count(index)){
	target = boost::none;
	return;
	}

	size_t id = __registry.left.at(index);
	size_t range = __range[level];
	(*target) << make_pair(id, range);

	for (const Expression& operand: e.operands){
	pack(operand, level+1, target);
	}
	return;
	}
	default: break;
	}

	assert(false && "Expression too complicate for serialization");
	}

	void registerExpression(const Expression&e, unsigned char level){
	switch (e.op){
	case Operator::CALL: {
	Index index{e.getValueString(), e.operands.size(), level};
	if (__registry.left.insert(make_pair(index, __range[level])).second){
	__range[level]++;
	}

	for (const Expression& operand: e.operands){
	registerExpression(operand, level+1);
	}
	return;
	}

	case Operator::NONE: {
	Index index;
	-
	+
	switch (e.__state) {
	case Expression::STRING:
	case Expression::IDENT: {
	index = {e.getValueString(), 0, level};
	if (__registry.left.insert(make_pair(index, __range[level])).second){
	__range[level]++;
	}
	return;
	}
	-
	+
	case Expression::NUMBER: {
	index = {std::to_string(e.getValueDouble()), 0, level};
	if (__registry.left.insert(make_pair(index, __range[level])).second){
	__range[level]++;
	}
	return;
	}
	-
	+
	default: break;
	}
	break;
	}

	default: break;
	}

	assert(false && "Expression too complicate for serialization");
	}
	};

	ExpressionSerializer::ExpressionSerializer()
	: strategy(new ExpressionSerializerPrivate()){
	}

	ExpressionSerializer::~ExpressionSerializer() {
	delete strategy;
	}

	void
	ExpressionSerializer::registerExpression(const Expression&e){
	if (e.isValid())
	strategy->registerExpression(e, 0);
	}

	PackedExpression
	ExpressionSerializer::getId(const Expression& e){
	- OptionalPackedExpression result(move(PackedExpression()));
	+ OptionalPackedExpression result(boost::in_place());
	+ //move(PackedExpression())
	+
	strategy->pack(e, 0, result);
	assert(result);
	return move(*result);
	}

	OptionalPackedExpression
	ExpressionSerializer::getIdOptional(const Expression& e) const{
	- OptionalPackedExpression result(move(PackedExpression()));
	+ OptionalPackedExpression result(boost::in_place());
	+ //move(PackedExpression())
	+
	strategy->pack(e, 0, result);
	return result;
	}

	ExpressionSerializerIntegral::ExpressionSerializerIntegral():serializer(*this){}

	ExpressionSerializerIntegral::ExpressionSerializerIntegral(const std::vector<Expression>&& expressions)
	: std::vector<Expression>(move(expressions)), serializer(*this){

	size_t id =0;
	for (const Expression& e: expressions){
	__registry.emplace(serializer.getId(e), id++);
	}
	}

	size_t
	ExpressionSerializerIntegral::size() const{
	return PARENT::size();
	}

	size_t
	ExpressionSerializerIntegral::count(const Expression& e) const {
	return (getIdOptional(e)? 1: 0);
	}

	ExpressionSerializerIntegral::const_iterator
	ExpressionSerializerIntegral::begin() const {
	return PARENT::begin();
	}

	ExpressionSerializerIntegral::const_iterator
	ExpressionSerializerIntegral::end() const {
	return PARENT::end();
	}

	size_t
	ExpressionSerializerIntegral::getId(const Expression& e) const{
	- const auto& exprPacked = serializer.getIdOptional(e);
	+ const OptionalPackedExpression exprPacked = serializer.getIdOptional(e);
	assert(exprPacked);

	return __registry.at(*exprPacked);
	}

	boost::optional<size_t>
	ExpressionSerializerIntegral::getIdOptional(const Expression& e) const{
	- const auto& exprPacked = serializer.getIdOptional(e);
	+ const OptionalPackedExpression exprPacked = serializer.getIdOptional(e);
	if (!exprPacked){
	return boost::none;
	}

	return __registry.at(*exprPacked);
	}

	const Expression&
	ExpressionSerializerIntegral::get(size_t id) const{
	return at(id);
	}


	void
	PackedExpression::operator<< (const std::pair<size_t, size_t>& value){
	static const size_t sizeSizeT = sizeof(size_t);

	const size_t& id = value.first;
	const size_t& range = value.second;

	int countSufficientBits = range <=1? 0 : ceil(log2(range));

	if (0 < countRemainedBits && countRemainedBits < countSufficientBits) {
	size_t* tail = reinterpret_cast<size_t*>(__storage + size- sizeSizeT);
	(*tail) += id >> (countSufficientBits - countRemainedBits);
	countSufficientBits-=countRemainedBits;
	countRemainedBits = 0;
	}

	if (countRemainedBits == 0) {
	if (countSufficientBits == 0) return;

	char* __storageNew = new char[size+sizeSizeT];
	std::memcpy (__storageNew, __storage, size);
	std::memset(__storageNew + size, 0, sizeSizeT);

	delete[] __storage;
	__storage = __storageNew;

	size += sizeSizeT;
	countRemainedBits = 8 * sizeSizeT;
	}

	if (countRemainedBits >= countSufficientBits) {
	size_t* tail = reinterpret_cast<size_t*>(__storage + size- sizeSizeT);
	(*tail) += id << (countRemainedBits - countSufficientBits);
	countRemainedBits -= countSufficientBits;
	return;
	}

	assert("Unreachable block");
	}

	+ #if BOOST_VERSION <= 105500
	+PackedExpression::PackedExpression(const PackedExpression& other){
	+ __storage = other.__storage;
	+ size = other.size;
	+ countRemainedBits = other.countRemainedBits;
	+}
	+ #endif
	+
	PackedExpression::PackedExpression(PackedExpression&& other){
	__storage = other.__storage;
	size = other.size;
	countRemainedBits = other.countRemainedBits;

	other.__storage = nullptr;
	}

	bool
	PackedExpression::operator==(const PackedExpression& other) const{
	if (size == other.size && countRemainedBits == other.countRemainedBits){
	return std::memcmp(__storage, other.__storage, size) == 0 ;
	}

	return false;
	}

	bool
	PackedExpression::operator<(const PackedExpression& other) const{
	if (size < other.size) { return true; }
	if (countRemainedBits < other.countRemainedBits) return true;

	if (size == other.size && countRemainedBits == other.countRemainedBits){
	return std::memcmp(__storage, other.__storage, size) < 0 ;
	}

	return false;
	}

	bool
	PackedExpression::operator!=(const PackedExpression& other) const{
	return ! ((*this) == other);
	}

	PackedExpression::~PackedExpression() {
	delete[] __storage;
	}

	//PackedExpression::PackedExpression (const PackedExpression& other)
	// : size(other.size), countRemainedBits(other.countRemainedBits)
	//{
	// __storage = new char[size];
	// std::memcpy (__storage, other.__storage, size);
	//}

	-} /* namespace xreate */
	+} /* namespace xreate */
	\ No newline at end of file
	diff --git a/cpp/src/serialization/expressionserializer.h b/cpp/src/serialization/expressionserializer.h
	index 9acf8c4..52daba8 100644
	--- a/cpp/src/serialization/expressionserializer.h
	+++ b/cpp/src/serialization/expressionserializer.h
	@@ -1,103 +1,111 @@
	/*
	* expressionserializer.h
	*
	* Created on: Jan 4, 2016
	* Author: pgess
	*/

	#ifndef SRC_EXPRESSIONSERIALIZER_H_
	#define SRC_EXPRESSIONSERIALIZER_H_

	#include "ast.h"
	#include <string>
	#include <boost/optional.hpp>
	+#include <boost/version.hpp>

	namespace xreate {

	struct PackedExpression{
	PackedExpression(){};
	PackedExpression(PackedExpression&& other);
	+
	+ #if BOOST_VERSION <= 105500
	+ PackedExpression (const PackedExpression&);
	+
	+ #else
	+ PackedExpression (const PackedExpression&)=delete;
	+ #endif
	+
	~PackedExpression();
	void operator<< (const std::pair<size_t, size_t>& value);
	char* operator*(){return __storage;}
	bool operator==(const PackedExpression& other) const;
	bool operator!=(const PackedExpression& other) const;
	bool operator<(const PackedExpression& other) const;
	private:
	- PackedExpression (const PackedExpression&)=delete;
	PackedExpression& operator=(const PackedExpression&)=delete;
	PackedExpression& operator=(PackedExpression&&)=delete;

	char* __storage = nullptr;
	size_t size =0;
	unsigned char countRemainedBits =0;
	};
	typedef boost::optional<PackedExpression> OptionalPackedExpression;

	class ExpressionSerializerPrivate;

	class ExpressionSerializer {
	public:
	template<class Container>
	ExpressionSerializer(const Container& source): ExpressionSerializer(){
	for (const Expression& e: source) {
	registerExpression(e);
	}
	}

	template<class Container, class Transformer>
	ExpressionSerializer(const Container& source, Transformer op): ExpressionSerializer(){
	for (const typename Container::value_type& e: source) {
	registerExpression(op(e));
	}
	}

	ExpressionSerializer(ExpressionSerializer&& other)
	: strategy(other.strategy) {other.strategy = 0; }

	virtual ~ExpressionSerializer();

	PackedExpression getId(const Expression& e);
	OptionalPackedExpression getIdOptional(const Expression& e) const;

	private:
	ExpressionSerializerPrivate* strategy;

	void registerExpression(const Expression&e);
	ExpressionSerializer();
	};

	class ExpressionSerializerIntegral: private std::vector<Expression>{
	typedef std::vector<Expression> PARENT;

	public:
	ExpressionSerializerIntegral();
	ExpressionSerializerIntegral(const std::vector<Expression>&& expressions);

	template<class Iterator>
	ExpressionSerializerIntegral(Iterator first, Iterator last)
	: ExpressionSerializerIntegral(std::vector<Expression>(first, last)){}

	ExpressionSerializerIntegral(ExpressionSerializerIntegral&& other)
	: PARENT(std::move(other)), __registry(std::move(other.__registry)), serializer(std::move(other.serializer)){}

	size_t getId(const Expression& e) const;
	boost::optional<size_t> getIdOptional(const Expression& e) const;
	const Expression& get(size_t id) const;
	size_t size() const;
	size_t count(const Expression& e) const;
	ExpressionSerializerIntegral::const_iterator begin() const;
	ExpressionSerializerIntegral::const_iterator end() const;

	private:
	ExpressionSerializerIntegral(const ExpressionSerializerIntegral&)=delete;

	std::map<PackedExpression, size_t> __registry;
	ExpressionSerializer serializer;
	};



	} /* namespace xreate */

	-#endif /* SRC_EXPRESSIONSERIALIZER_H_ */
	+#endif /* SRC_EXPRESSIONSERIALIZER_H_ */
	\ No newline at end of file
	diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt
	index e980a74..25f9a64 100644
	--- a/cpp/tests/CMakeLists.txt
	+++ b/cpp/tests/CMakeLists.txt
	@@ -1,18 +1,25 @@
	cmake_minimum_required(VERSION 2.8.11)
	project(xreate-tests)

	find_package(GTest REQUIRED)
	INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIRS})
	INCLUDE_DIRECTORIES("/usr/include/libxml2")
	INCLUDE_DIRECTORIES($<TARGET_PROPERTY:xreate,INCLUDE_DIRECTORIES>)


	# TESTS
	#=========================
	+FIND_PACKAGE (LLVM REQUIRED)
	+message("LLVM_LIBRARY_DIRS: " ${LLVM_LIBRARY_DIRS})
	+link_directories(${LLVM_LIBRARY_DIRS})
	+
	+set (LIBCLASP_PATH ${POTASSCO_PATH}/build/debug)
	+link_directories(${LIBCLASP_PATH})
	+
	aux_source_directory(. TEST_FILES)
	add_executable(${PROJECT_NAME} ${TEST_FILES})
	target_link_libraries(${PROJECT_NAME} xreate ${GTEST_LIBRARIES} pthread xml2 gcov)

	add_custom_target (coverage
	COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/src/code-coverage.sh
	WORKING_DIRECTORY ${CMAKE_BINARY_DIR})

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions