No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Mar 14, 4:39 AM

View Options

	diff --git a/config/default.json b/config/default.json
	index 95a6f34..338ac69 100644
	--- a/config/default.json
	+++ b/config/default.json
	@@ -1,72 +1,73 @@
	{
	"containers": {
	"id": {
	"implementations": "impl_fulfill_cluster",
	"clusters": "var_cluster",
	"prototypes": "proto_cluster",
	"linkedlist": "linkedlist"
	},

	"impl": {
	"solid": "solid",
	"onthefly": "on_the_fly"
	}
	},

	"logging": {
	"id": "logging"
	},

	"function-entry": "entry",

	"clasp": {
	"bindings" : {
	"variable": "bind",
	"function": "bind_func",
	"scope": "bind_scope",
	"function_demand" : "bind_function_demand",
	"scope_decision": "bind_scope_decision"
	},

	"context" : {
	"decisions":{
	"dependent": "resolution_dependency"
	}
	},

	"nonevalue": "nonevalue",
	"ret": {
	"symbol": "retv",
	"tag": "ret"
	}
	},

	"tests": {
	- "template": "default",
	+ "template": "sequence",

	"templates": {
	- "current-fix":"Compilation.full_IFStatementWithVariantType",
	+ "sequence": "Compilation.Sequence1",
	+ "current-fix":"",
	"default": "-Adhoc.:Containers.*:Compilation.full_IFStatementWithVariantType:Types.full_VariantType_Switch1:Context.full_LateContext:Context.pathDependentContext",
	"ast": "AST.*",
	"adhocs": "Adhoc.*",
	"effects": "Effects.*",
	"basic": "Attachments.*",
	"context": "Context.*",
	"compilation": "Compilation.*-Compilation.full_IFStatementWithVariantType",
	"communication": "Communication.*",
	"cfa": "CFA.*",
	"containers": "Containers.*",
	"dfa": "DFA.*",
	"diagnostic": "Diagnostic.*",
	"dsl": "Association.*:Interpretation.SwitchVariantAlias",
	"ExpressionSerializer": "ExpressionSerializer.*",
	"externc": "InterfaceExternC.*",
	"loops": "Loop.*",
	"modules": "Modules.*",
	"polymorphs": "Polymorphs.call1",
	"types": "Types.*",
	"vendorsAPI/clang": "ClangAPI.*",
	"vendorsAPI/xml2": "libxml2*"
	}
	}
	}
	diff --git a/cpp/src/ast.h b/cpp/src/ast.h
	index 0d3b02c..5e19dda 100644
	--- a/cpp/src/ast.h
	+++ b/cpp/src/ast.h
	@@ -1,734 +1,734 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* File: ast.h
	*/

	#ifndef AST_H
	#define AST_H

	#include "attachments.h"

	#include <vector>
	#include <stdlib.h>
	#include <string>
	#include <list>
	#include <unordered_map>
	#include <unordered_set>
	#include <climits>
	#include "utils.h"
	#include <algorithm>

	namespace llvm {
	class Value;
	}

	namespace xreate {
	struct ScopedSymbol;
	struct Symbol;
	}

	namespace std {
	template<>
	struct hash<xreate::ScopedSymbol> {
	std::size_t operator()(xreate::ScopedSymbol const& s) const;
	};

	template<>
	struct equal_to<xreate::ScopedSymbol> {
	bool operator()(const xreate::ScopedSymbol& __x, const xreate::ScopedSymbol& __y) const;
	};

	template<>
	struct hash<xreate::Symbol> {
	size_t operator()(xreate::Symbol const& s) const;
	};

	template<>
	struct equal_to<xreate::Symbol> {
	bool operator()(const xreate::Symbol& __x, const xreate::Symbol& __y) const;
	};
	}

	namespace xreate {

	struct String_t {
	};

	struct Identifier_t {
	};

	struct Number_t {
	};

	struct Type_t {
	};

	template<typename A>
	class Atom {
	};

	//DEBT store line:col for all atoms/identifiers
	template<> class
	Atom<Identifier_t> {
	public:
	Atom(const std::wstring& value);
	Atom(std::string && name);
	const std::string& get() const;

	private:
	std::string __value;
	};

	template<>
	class Atom<Number_t> {
	public:
	Atom(wchar_t* value);
	Atom(int value);
	double get()const;

	private:
	double __value;
	};

	template<>
	class Atom<String_t> {
	public:
	Atom(const std::wstring& value);
	Atom(std::string && name);
	const std::string& get() const;

	private:
	std::string __value;
	};

	enum class TypePrimitive {
	Invalid, Bool, I8, I32, I64, Num, Int, Float, String
	};

	enum class TypeOperator {
	NONE, CALL, CUSTOM, VARIANT, LIST, LIST_NAMED, ACCESS, LINK
	};

	struct llvm_array_tag {
	};

	struct struct_tag {
	};
	const llvm_array_tag tag_array = llvm_array_tag();
	const struct_tag tag_struct = struct_tag();

	/**
	* \brief Represents type to support type system
	*
	* This class represents type in denormalized form, i.e. without arguments and aliases substitution
	* \sa AST::expandType()
	*/
	class TypeAnnotation {
	public:
	TypeAnnotation();
	TypeAnnotation(const Atom<Type_t>& typ);
	TypeAnnotation(TypePrimitive typ);
	TypeAnnotation(llvm_array_tag, TypeAnnotation typ, int size);

	TypeAnnotation(TypeOperator op, std::initializer_list<TypeAnnotation> operands);
	TypeAnnotation(TypeOperator op, std::vector<TypeAnnotation>&& operands);
	void addBindings(std::vector<Atom<Identifier_t>>&& params);
	void addFields(std::vector<Atom<Identifier_t>>&& listFields);
	bool operator<(const TypeAnnotation& t) const;
	// TypeAnnotation (struct_tag, std::initializer_list<TypePrimitive>);

	bool isValid() const;

	TypeOperator __operator = TypeOperator::NONE;

	std::vector<TypeAnnotation> __operands;
	TypePrimitive __value;
	std::string __valueCustom;
	int conjuctionId = -1; //conjunction point id (relevant for recursive types)

	uint64_t __size = 0;
	std::vector<std::string> fields;
	std::vector<std::string> bindings;
	private:
	};

	enum class Operator {
	ADD, SUB, MUL, DIV,
	EQU, NE, NEG, LSS,
	LSE, GTR, GTE, LIST,
	LIST_RANGE, LIST_NAMED,
	CALL, CALL_INTRINSIC, NONE,
	IMPL/* implication */, MAP,
	FOLD, FOLD_INF, LOOP_CONTEXT,
	INDEX, IF, SWITCH, SWITCH_ADHOC, SWITCH_VARIANT,
	CASE, CASE_DEFAULT, LOGIC_AND,
	- ADHOC, CONTEXT_RULE, VARIANT
	+ ADHOC, CONTEXT_RULE, VARIANT, SEQUENCE
	};

	class Function;
	class AST;
	class CodeScope;
	class MetaRuleAbstract;

	typedef ManagedPtr<Function> ManagedFnPtr;
	typedef ManagedPtr<CodeScope> ManagedScpPtr;
	typedef ManagedPtr<MetaRuleAbstract> ManagedRulePtr;
	const ManagedScpPtr NO_SCOPE = ManagedScpPtr(UINT_MAX, 0);

	/**
	* \brief Represents every instruction in Xreate's syntax tree
	* \attention In case of any changes update xreate::ExpressionHints auxiliary helper as well
	*
	* Expression is generic building block of syntax tree able to hold node data
	* as well as child nodes as operands. Not only instructions use expression for representation in syntax tree
	* but annotation as well.
	*
	* Additionally, `types` as a special kind of annotations use Expression-like data structure TypeAnnotation
	* \sa xreate::AST, xreate::TypeAnnotation
	*/
	//
	struct Expression {
	friend class CodeScope;
	friend class ClaspLayer;
	friend class CFAPass;
	friend class ExpressionHints;

	Expression(const Operator &oprt, std::initializer_list<Expression> params);
	Expression(const Atom<Identifier_t>& ident);
	Expression(const Atom<Number_t>& number);
	Expression(const Atom<String_t>& a);

	Expression();

	void setOp(Operator oprt);
	void addArg(Expression&& arg);
	void addBindings(std::initializer_list<Atom<Identifier_t>> params);
	void bindType(TypeAnnotation t);

	template<class InputIt>
	void addBindings(InputIt paramsBegin, InputIt paramsEnd);
	void addTags(const std::list<Expression> tags) const;
	void addBlock(ManagedScpPtr scope);

	const std::vector<Expression>& getOperands() const;
	double getValueDouble() const;
	void setValueDouble(double value);
	const std::string& getValueString() const;
	void setValue(const Atom<Identifier_t>&& v);
	bool isValid() const;
	bool isDefined() const;


	bool operator==(const Expression& other) const;

	/**
	* \brief is it string, number, compound operation and so on
	*/
	enum {
	INVALID, COMPOUND, IDENT, NUMBER, STRING, BINDING
	} __state = INVALID;

	/**
	* \brief Valid for compound State. Holds type of compound operator
	*/
	Operator op;

	/**
	* \brief Unique id to identify expression within syntax tree
	*/
	unsigned int id;

	/**
	* \brief Exact meaning depends on particular instruction
	* \details As an example, named lists/structs hold field names in bindings
	*/
	std::vector<std::string> bindings;
	std::map<std::string, size_t> __indexBindings;

	/**
	* \brief Holds child instructions as arguments
	*/
	std::vector<Expression> operands;

	/**
	* \brief Holds type of instruction's result
	*/
	TypeAnnotation type;

	/**
	* \brief Holds additional annotations
	*/
	mutable std::map<std::string, Expression> tags;

	/**
	* \brief Child code blocks
	* \details For example, If statement holds TRUE-branch as first and FALSE-branch as second block here
	*/
	std::list<CodeScope*> blocks;

	private:
	std::string __valueS;
	double __valueD;

	static unsigned int nextVacantId;
	};

	bool operator<(const Expression&, const Expression&);

	template<class InputIt>
	void Expression::addBindings(InputIt paramsBegin, InputIt paramsEnd) {
	size_t index = bindings.size();

	std::transform(paramsBegin, paramsEnd, std::inserter(bindings, bindings.end()),
	[&index, this] (const Atom<Identifier_t> atom) {
	std::string key = atom.get();
	this->__indexBindings[key] = index++;
	return key;
	});
	}

	typedef std::list<Expression> ExpressionList;

	enum class TagModifier {
	NONE, ASSERT, REQUIRE
	};

	enum class DomainAnnotation {
	FUNCTION, VARIABLE
	};

	class RuleArguments : public std::vector<std::pair<std::string, DomainAnnotation>>
	{
	public:
	void add(const Atom<Identifier_t>& name, DomainAnnotation typ);
	};

	class RuleGuards : public std::vector<Expression> {
	public:
	void add(Expression&& e);
	};


	class ClaspLayer;
	class LLVMLayer;

	class MetaRuleAbstract {
	public:
	MetaRuleAbstract(RuleArguments&& args, RuleGuards&& guards);
	virtual ~MetaRuleAbstract();
	virtual void compile(ClaspLayer& layer) = 0;
	protected:
	RuleArguments __args;
	RuleGuards __guards;
	};

	class RuleWarning : public MetaRuleAbstract {
	friend class ClaspLayer;
	public:
	RuleWarning(RuleArguments&& args, RuleGuards&& guards, Expression&& condition, Atom<String_t>&& message);
	virtual void compile(ClaspLayer& layer);
	~RuleWarning();

	private:
	std::string __message;
	Expression __condition;
	};

	typedef unsigned int VNameId;

	namespace versions {
	typedef int VariableVersion;
	const VariableVersion VERSION_NONE = -2;
	const VariableVersion VERSION_INIT = 0;
	}

	template<>
	struct AttachmentsDict<versions::VariableVersion> {
	typedef versions::VariableVersion Data;
	static const unsigned int key = 6;
	};

	struct ScopedSymbol {
	VNameId id;
	versions::VariableVersion version;

	static const ScopedSymbol RetSymbol;
	};

	struct Symbol {
	ScopedSymbol identifier;
	const CodeScope * scope;
	};

	struct IdentifierSymbol{};
	struct SymbolAlias{};

	template<>
	struct AttachmentsDict<IdentifierSymbol> {
	typedef Symbol Data;
	static const unsigned int key = 7;
	};

	template<>
	struct AttachmentsDict<SymbolAlias> {
	typedef Symbol Data;
	static const unsigned int key = 9;
	};

	typedef std::pair<Expression, TagModifier> Tag;

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

	/**
	* \brief Represents code block and single scope of visibility
	*
	* Holds single expression as a body and set of variable assignments(declarations) used in body's expression
	* \sa xreate::AST
	*/
	class CodeScope {
	friend class Function;
	friend class PassManager;

	public:
	CodeScope(CodeScope* parent = 0);
	~CodeScope();

	/** \brief Set expression as a body */
	void setBody(const Expression& body);

	/** \brief Returns current code scope body */
	const Expression& getBody() const;

	/** \brief Adds variable definition to be used in body as well as in other declarations */
	Symbol addDefinition(Expression&& var, Expression&& body);

	/** \brief Returns symbols' definition */
	static const Expression& getDefinition(const Symbol& symbol, bool flagAllowUndefined = false);
	const Expression& getDefinition(const ScopedSymbol& symbol, bool flagAllowUndefined = false) const;

	/** \brief Adds variable defined elsewhere */
	void addBinding(Expression&& var, Expression&& argument);

	std::vector<std::string> __bindings;
	std::map<std::string, VNameId> __identifiers;
	CodeScope* __parent;

	//TODO move __definitions to SymbolsAttachments data
	//NOTE: definition of return type has index 0
	std::unordered_map<ScopedSymbol, Expression> __declarations;
	std::vector<Expression> tags;
	std::vector<Expression> contextRules;

	private:
	VNameId __vCounter = 1;
	ScopedSymbol registerIdentifier(const Expression& identifier);

	public:
	bool recognizeIdentifier(const Expression& identifier) const;
	ScopedSymbol getSymbol(const std::string& alias);
	};

	/**
	* \brief Represents single function in Xreate's syntax tree
	*
	* Holds an entry code scope and `guardContext` required for function to operate
	* \sa xreate::AST
	*/
	class Function {
	friend class Expression;
	friend class CodeScope;
	friend class AST;

	public:
	Function(const Atom<Identifier_t>& name);

	/**
	* \brief Adds function arguments
	*/
	void addBinding(Atom <Identifier_t>&& name, Expression&& argument);

	/**
	* \brief Adds additional function annotations
	*/
	void addTag(Expression&& tag, const TagModifier mod);

	const std::string& getName() const;
	const std::map<std::string, Expression>& getTags() const;
	CodeScope* getEntryScope() const;
	CodeScope* __entry;
	std::string __name;
	bool isPrefunction = false; //SECTIONTAG adhoc Function::isPrefunction flag

	Expression guardContext;
	Expression guard;
	private:

	std::map<std::string, Expression> __tags;
	};


	class ExternData;

	struct ExternEntry {
	std::string package;
	std::vector<std::string> headers;
	};

	typedef Expanded<TypeAnnotation> ExpandedType;

	struct TypeInferred{};
	template<>
	struct AttachmentsDict<TypeInferred> {
	typedef ExpandedType Data;
	static const unsigned int key = 11;
	};

	enum ASTInterface {
	CFA, DFA, Extern, Adhoc
	};

	struct FunctionSpecialization {
	std::string guard;
	size_t id;
	};

	struct FunctionSpecializationQuery {
	std::unordered_set<std::string> context;
	};

	template<>
	struct AttachmentsId<Expression>{
	static unsigned int getId(const Expression& expression){
	return expression.id;
	}
	};

	template<>
	struct AttachmentsId<Symbol>{
	static unsigned int getId(const Symbol& s){
	return s.scope->__declarations.at(s.identifier).id;
	}
	};

	template<>
	struct AttachmentsId<ManagedFnPtr>{
	static unsigned int getId(const ManagedFnPtr& f){
	const Symbol symbolFunction{ScopedSymbol::RetSymbol, f->getEntryScope()};

	return AttachmentsId<Symbol>::getId(symbolFunction);
	}
	};

	template<>
	struct AttachmentsId<unsigned int>{
	static unsigned int getId(const unsigned int id){
	return id;
	}
	};

	class TypesResolver;
	namespace details { namespace inconsistent {

	/**
	* \brief Syntax tree under construction in inconsistent form
	*
	* Represents Syntax Tree under construction(inconsistent state).
	* \attention Clients should use rather xreate::AST unless client's code explicitly works with Syntax Tree during construction.
	*
	* Typically instance only created by xreate::XreateManager and filled in by Parser
	* \sa xreate::XreateManager::prepare(std::string&&)
	*/
	class AST {
	friend class xreate::TypesResolver;
	public:
	AST();

	/**
	* \brief Adds new function to AST
	* \param f Function to register
	*/
	void add(Function* f);

	/**
	* \brief Adds new declarative rule to AST
	* \param r Declarative Rule
	*/
	void add(MetaRuleAbstract* r);

	/** \brief Registers new code block */
	ManagedScpPtr add(CodeScope* scope);

	/**
	* \brief Add new type to AST
	* @param t Type definition
	* @param alias Typer name
	*/
	void add(TypeAnnotation t, Atom<Identifier_t> alias);

	/** \brief Current module's name */
	std::string getModuleName();

	/**
	* \brief Looks for function with given name
	* \param name Function name to find
	* \note Requires that only one function exists under given name
	* \return Found function
	*/
	ManagedPtr<Function> findFunction(const std::string& name);

	/** \brief Returns all function in AST */
	std::list<ManagedFnPtr> getAllFunctions() const;

	/**
	* \brief Returns all specializations of a function with a given name
	* \param fnName function to find
	* \return list of found function specializations
	*/
	std::list<ManagedFnPtr> getFunctionSpecializations(const std::string& fnName) const;

	/**
	* \return First element in Functions/Scopes/Rules list depending on template parameter
	* \tparam Target either Function or CodeScope or MetaRuleAbstract
	*/
	template<class Target>
	ManagedPtr<Target> begin();

	/**
	* \brief Performs all necessary steps after AST is built
	*
	* Performs all finzalisation steps and move AST into consistent state represented by xreate::AST
	* \sa xreate::AST
	* \return AST in consistent state
	*/
	xreate::AST* finalize();

	typedef std::multimap<std::string, unsigned int> FUNCTIONS_REGISTRY;

	std::vector<ExternEntry> __externdata;
	std::list<Expression> __dfadata; //TODO move to more appropriate place
	std::list<std::string> __rawImports; //TODO move to more appropriate place
	std::multimap<ASTInterface, Expression> __interfacesData; //TODO CFA data here.

	private:
	std::vector<MetaRuleAbstract*> __rules;
	std::vector<Function*> __functions;
	std::vector<CodeScope*> __scopes;

	FUNCTIONS_REGISTRY __indexFunctions;

	protected:
	std::map<std::string, TypeAnnotation> __indexTypeAliases;

	public:
	/**
	* \brief Stores DFA scheme for later use by DFA Pass
	*
	* Treats expression as a DFA scheme and feeds to a DFA Pass later
	* \paramn Expression DFA Scheme
	* \sa xreate::DFAPass
	*/
	void addDFAData(Expression&& data);

	/** \brief Stores data for later use by xreate::ExternLayer */
	void addExternData(ExternData&& data);

	/**
	* \brief Generalized function to store particular data for later use by particular pass
	* \param interface Particular Interface
	* \param data Particular data
	*/
	void addInterfaceData(const ASTInterface& interface, Expression&& data);


	/*\name Symbols Recognition /
	///@{
	public:
	//TODO revisit enums/variants, move to codescope
	/**
	* \brief Tries to find out whether expression is Variant constructor
	*/
	void recognizeVariantConstructor(Expression& function);
	Atom<Number_t> recognizeVariantConstructor(Atom<Identifier_t> ident);

	private:
	std::map<std::string, std::pair<TypeAnnotation, int>> __dictVariants;

	public:
	std::set<std::pair<CodeScope*, Expression>> bucketUnrecognizedIdentifiers;

	public:
	/**
	* \brief Postpones unrecognized identifier for future second round of recognition
	* \param scope Code block identifier is encountered
	* \param id Identifier
	*/
	void postponeIdentifier(CodeScope* scope, const Expression& id);

	/** \brief Second round of identifiers recognition done right after AST is fully constructed */
	void recognizePostponedIdentifiers();
	///@}
	};

	template<>
	ManagedPtr<Function>
	AST::begin<Function>();

	template<>
	ManagedPtr<CodeScope>
	AST::begin<CodeScope>();

	template<>
	ManagedPtr<MetaRuleAbstract>
	AST::begin<MetaRuleAbstract>();

	} } // namespace details::incomplete

	/**
	* \brief Xreate's Syntax Tree in consistent state
	*
	* Syntax Tree has two mutually exclusive possible states:
	* - inconsistent state while AST is under construction. Represented by xreate::details::inconsistent::AST
	* - consistent state when AST is built and finalize() is done.
	*
	* This class represents consistent state and should be used everywhere unless client's code explicitly works with AST under construction.
	* Consistent AST enables access to additional functions(currently related to type management).
	* \sa xreate::details::inconsistent::AST
	*/
	class AST : public details::inconsistent::AST {
	public:

	AST() : details::inconsistent::AST() {}

	/**
	* \brief Computes fully expanded form of type by substituting all arguments and aliases
	* \param t Type to expand
	* \return Expdanded or normal form of type
	* \sa TypeAnnotation
	*/
	ExpandedType expandType(const TypeAnnotation &t) const;

	/**
	* Searches type by given name
	* \param name Typename to search
	* \return Expanded or normal form of desired type
	* \note if type name is not found returns new undefined type with this name
	*/
	ExpandedType findType(const std::string& name);

	/**
	* Invokes Type Inference Analysis to find out expanded(normal) form expressions's type
	* \sa typeinference.h
	* \param expression
	* \return Type of expression

	*/
	ExpandedType getType(const Expression& expression);
	};
	}
	#endif // AST_H
	diff --git a/cpp/src/compilation/advancedinstructions.cpp b/cpp/src/compilation/advancedinstructions.cpp
	index b0f9f8f..59bbdd4 100644
	--- a/cpp/src/compilation/advancedinstructions.cpp
	+++ b/cpp/src/compilation/advancedinstructions.cpp
	@@ -1,456 +1,460 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: InstructionsAdvanced.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 26, 2016, 6:00 PM
	*/

	/**
	* \file advanced.h
	* \brief Compilation of statements that require more than one LLVM instruction
	*/

	#include "compilation/advancedinstructions.h"
	#include "compilation/containers.h"
	#include "compilation/transformersaturation.h"

	#include "query/context.h"
	#include "query/containers.h"
	#include "llvmlayer.h"
	#include "ast.h"

	using namespace std;
	using namespace llvm;
	using namespace xreate;
	using namespace xreate::containers;
	using namespace xreate::compilation;

	#define NAME(x) (hintRetVar.empty()? x : hintRetVar)
	#define UNUSED(x) (void)(x)
	#define EXPAND_CONTEXT \
	LLVMLayer* llvm = context.pass->man->llvm; \
	compilation::ICodeScopeUnit* scope = context.scope; \
	compilation::IFunctionUnit* function = context.function;

	AdvancedInstructions::AdvancedInstructions(compilation::Context ctx)
	: context(ctx), tyNum(static_cast<llvm::IntegerType*> (ctx.pass->man->llvm->toLLVMType(ExpandedType(TypeAnnotation(TypePrimitive::Num))))) {
	}

	llvm::Value*
	AdvancedInstructions::compileMapSolidOutput(const Expression &expr, const std::string hintRetVar) {
	- EXPAND_CONTEXT
	- UNUSED(scope);
	+ EXPAND_CONTEXT UNUSED(scope);

	//initialization
	Symbol symbolIn = Attachments::get<IdentifierSymbol>(expr.getOperands()[0]);

	ImplementationRec<SOLID> implIn = containers::Query::queryImplementation(symbolIn).extract<SOLID>(); // impl of input list
	size_t size = implIn.size;
	CodeScope* scopeLoop = expr.blocks.front();
	std::string varEl = scopeLoop->__bindings[0];

	Iterator* it = Iterator::create(context, symbolIn);
	llvm::Value *rangeFrom = it->begin();
	llvm::Value *rangeTo = it->end();

	//definitions
	ArrayType* tyNumArray = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::Num, size))));
	llvm::IRBuilder<> &builder = llvm->builder;

	llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "loop", function->raw);
	llvm::BasicBlock *blockBeforeLoop = builder.GetInsertBlock();
	llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "postloop", function->raw);
	Value* dataOut = llvm->builder.CreateAlloca(tyNumArray, ConstantInt::get(tyNum, size), NAME("map"));

	// * initial check
	Value* condBefore = builder.CreateICmpSLE(rangeFrom, rangeTo);
	builder.CreateCondBr(condBefore, blockLoop, blockAfterLoop);

	// create PHI:
	builder.SetInsertPoint(blockLoop);
	llvm::PHINode *stateLoop = builder.CreatePHI(tyNum, 2, "mapIt");
	stateLoop->addIncoming(rangeFrom, blockBeforeLoop);

	// loop body:
	Value* elIn = it->get(stateLoop, varEl);
	compilation::ICodeScopeUnit* scopeLoopUnit = function->getScopeUnit(scopeLoop);
	scopeLoopUnit->bindArg(elIn, move(varEl));
	Value* elOut = scopeLoopUnit->compile();
	Value pElOut = builder.CreateGEP(dataOut, ArrayRef<Value >(std::vector<Value*>{ConstantInt::get(tyNum, 0), stateLoop}));
	builder.CreateStore(elOut, pElOut);

	//next iteration preparing
	Value *stateLoopNext = builder.CreateAdd(stateLoop, llvm::ConstantInt::get(tyNum, 1));
	stateLoop->addIncoming(stateLoopNext, builder.GetInsertBlock());

	//next iteration checks:
	Value* condAfter = builder.CreateICmpSLE(stateLoopNext, rangeTo);
	builder.CreateCondBr(condAfter, blockLoop, blockAfterLoop);

	//finalization:
	builder.SetInsertPoint(blockAfterLoop);

	return dataOut;
	}

	Value*
	AdvancedInstructions::compileArrayIndex(llvm::Value* aggregate, std::vector<llvm::Value *> indexes, std::string hintRetVar) {
	- EXPAND_CONTEXT
	- UNUSED(function);
	- UNUSED(scope);
	+ EXPAND_CONTEXT UNUSED(function); UNUSED(scope);

	indexes.insert(indexes.begin(), llvm::ConstantInt::get(tyNum, 0));
	llvm::Value pEl = llvm->builder.CreateGEP(aggregate, llvm::ArrayRef<llvm::Value >(indexes));
	return llvm->builder.CreateLoad(pEl, NAME("el"));
	}

	Value*
	AdvancedInstructions::compileStructIndex(llvm::Value* aggregate, const ExpandedType& t, const std::string& idx) {
	- EXPAND_CONTEXT
	- UNUSED(scope);
	- UNUSED(function);
	+ EXPAND_CONTEXT UNUSED(scope); UNUSED(function);
	+
	TypeUtils types(llvm);
	std::vector<std::string>&& fields = types.getStructFields(t);

	for (unsigned i = 0, size = fields.size(); i < size; ++i) {
	if (fields.at(i) == idx) {
	//dereference pointer
	if (types.isPointer(t)) {
	llvm::Value* addr = llvm->builder.CreateConstGEP2_32(nullptr, aggregate, 0, i);
	return llvm->builder.CreateLoad(addr);
	}

	return llvm->builder.CreateExtractValue(aggregate, llvm::ArrayRef<unsigned>{i});
	}
	}

	assert(false && "not found required struct field");
	return nullptr;
	}

	llvm::Value*
	AdvancedInstructions::compileFold(const Expression& fold, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	assert(fold.op == Operator::FOLD);

	//initialization:
	Symbol varInSymbol = Attachments::get<IdentifierSymbol>(fold.getOperands()[0]);
	Implementation info = Query::queryImplementation(varInSymbol);

	Iterator* it = Iterator::create(context, varInSymbol);
	llvm::Value* rangeBegin = it->begin();
	llvm::Value* rangeEnd = it->end();
	llvm::Value* accumInit = scope->process(fold.getOperands()[1]);
	std::string varIn = fold.getOperands()[0].getValueString();
	std::string varAccum = fold.bindings[1];
	std::string varEl = fold.bindings[0];

	llvm::BasicBlock *blockBeforeLoop = llvm->builder.GetInsertBlock();
	std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockBeforeLoop, context.pass->managerTransformations));


	llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold", function->raw);
	llvm::BasicBlock *blockLoopBody = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_body", function->raw);
	llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_after", function->raw);
	llvm::BasicBlock *blockNext = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_next", function->raw);

	llvm->builder.CreateBr(blockLoop);

	// * create phi
	llvm->builder.SetInsertPoint(blockLoop);
	llvm::PHINode *accum = llvm->builder.CreatePHI(accumInit->getType(), 2, varAccum);
	accum->addIncoming(accumInit, blockBeforeLoop);
	llvm::PHINode *itLoop = llvm->builder.CreatePHI(rangeBegin->getType(), 2, "foldIt");
	itLoop->addIncoming(rangeBegin, blockBeforeLoop);

	// * loop checks
	Value* condRange = llvm->builder.CreateICmpNE(itLoop, rangeEnd);
	llvm->builder.CreateCondBr(condRange, blockLoopBody, blockAfterLoop);

	// * loop body
	llvm->builder.SetInsertPoint(blockLoopBody);
	CodeScope* scopeLoop = fold.blocks.front();
	compilation::ICodeScopeUnit* loopUnit = function->getScopeUnit(scopeLoop);
	Value* elIn = it->get(itLoop);
	loopUnit->bindArg(accum, move(varAccum));
	loopUnit->bindArg(elIn, move(varEl));
	Value* accumNext = loopUnit->compile();

	// * Loop saturation checks
	bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockNext, blockAfterLoop, context);
	llvm::BasicBlock* blockSaturation = llvm->builder.GetInsertBlock();
	if (!flagSaturationTriggered){
	llvm->builder.CreateBr(blockNext);
	}

	// * computing next iteration state
	llvm->builder.SetInsertPoint(blockNext);
	Value *itLoopNext = it->advance(itLoop);
	accum->addIncoming(accumNext, llvm->builder.GetInsertBlock());
	itLoop->addIncoming(itLoopNext, llvm->builder.GetInsertBlock());
	llvm->builder.CreateBr(blockLoop);

	// * finalization:
	llvm->builder.SetInsertPoint(blockAfterLoop);
	if (!flagSaturationTriggered){
	return accum;
	}

	llvm::PHINode* result = llvm->builder.CreatePHI(accumInit->getType(), 2);
	result->addIncoming(accum, blockLoop);
	result->addIncoming(accumNext, blockSaturation);
	return result;
	}

	llvm::Value*
	AdvancedInstructions::compileFoldInf(const Expression& fold, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	assert(fold.op == Operator::FOLD_INF);

	std::string accumName = fold.bindings[0];
	llvm::Value* accumInit = scope->process(fold.getOperands()[0]);

	llvm::BasicBlock *blockBeforeLoop = llvm->builder.GetInsertBlock();
	llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf", function->raw);
	llvm::BasicBlock *blockNext = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf_next", function->raw);
	llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf_post", function->raw);
	std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockBeforeLoop, context.pass->managerTransformations));

	llvm->builder.CreateBr(blockLoop);

	// * create phi
	llvm->builder.SetInsertPoint(blockLoop);
	llvm::PHINode *accum = llvm->builder.CreatePHI(accumInit->getType(), 2, accumName);
	accum->addIncoming(accumInit, blockBeforeLoop);

	// * loop body
	CodeScope* scopeLoop = fold.blocks.front();
	compilation::ICodeScopeUnit* unitLoop = function->getScopeUnit(scopeLoop);
	unitLoop->bindArg(accum, move(accumName));
	Value* accumNext = unitLoop->compile();

	// * Loop saturation checks
	bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockNext, blockAfterLoop, context);
	assert(flagSaturationTriggered);

	// * computing next iteration state
	llvm->builder.SetInsertPoint(blockNext);
	accum->addIncoming(accumNext, llvm->builder.GetInsertBlock());
	llvm->builder.CreateBr(blockLoop);

	// finalization:
	llvm->builder.SetInsertPoint(blockAfterLoop);
	return accumNext;
	}

	llvm::Value*
	AdvancedInstructions::compileIf(const Expression& exprIf, const std::string& hintRetVar) {
	EXPAND_CONTEXT

	const Expression& condExpr = exprIf.getOperands()[0];
	llvm::IRBuilder<>& builder = llvm->builder;
	assert(builder.GetInsertBlock() == scope->currentBlockRaw);

	//initialization:
	llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifAfter", function->raw);
	llvm::BasicBlock *blockTrue = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifTrue", function->raw);
	llvm::BasicBlock *blockFalse = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifFalse", function->raw);

	llvm::Value* cond = scope->process(condExpr);

	builder.SetInsertPoint(blockTrue);
	CodeScope* scopeTrue = exprIf.blocks.front();
	llvm::Value* resultTrue = function->getScopeUnit(scopeTrue)->compile();
	llvm::BasicBlock * blockTrueEnd = builder.GetInsertBlock();
	builder.CreateBr(blockEpilog);

	builder.SetInsertPoint(blockFalse);
	CodeScope* scopeFalse = exprIf.blocks.back();
	llvm::Value* resultFalse = function->getScopeUnit(scopeFalse)->compile();
	llvm::BasicBlock * blockFalseEnd = builder.GetInsertBlock();
	builder.CreateBr(blockEpilog);

	builder.SetInsertPoint(scope->currentBlockRaw);
	llvm->builder.CreateCondBr(cond, blockTrue, blockFalse);

	builder.SetInsertPoint(blockEpilog);
	llvm::PHINode *ret = builder.CreatePHI(resultTrue->getType(), 2, NAME("if"));

	ret->addIncoming(resultTrue, blockTrueEnd);
	ret->addIncoming(resultFalse, blockFalseEnd);

	return ret;
	}

	//TODO Switch: default variant no needed when all possible conditions are considered
	llvm::Value*
	AdvancedInstructions::compileSwitch(const Expression& exprSwitch, const std::string& hintRetVar) {
	- EXPAND_CONTEXT
	- UNUSED(function);
	+ EXPAND_CONTEXT UNUSED(function);
	AST* root = context.pass->man->root;
	llvm::IRBuilder<>& builder = llvm->builder;
	assert(exprSwitch.operands.size() >= 2);
	assert(exprSwitch.operands[1].op == Operator::CASE_DEFAULT && "No default case in Switch Statement");

	int countCases = exprSwitch.operands.size() - 1;
	llvm::BasicBlock* blockProlog = builder.GetInsertBlock();
	llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm::getGlobalContext(), "switchAfter", function->raw);
	builder.SetInsertPoint(blockEpilog);
	llvm::Type* exprSwitchType = llvm->toLLVMType(root->getType(exprSwitch));
	llvm::PHINode *ret = builder.CreatePHI(exprSwitchType, countCases, NAME("switch"));

	builder.SetInsertPoint(blockProlog);
	llvm::Value * conditionSwitch = scope->process(exprSwitch.operands[0]);
	llvm::BasicBlock *blockDefault = llvm::BasicBlock::Create(llvm::getGlobalContext(), "caseDefault", function->raw);
	llvm::SwitchInst * instructionSwitch = builder.CreateSwitch(conditionSwitch, blockDefault, countCases);

	for (int size = exprSwitch.operands.size(), i = 2; i < size; ++i) {
	llvm::BasicBlock *blockCase = llvm::BasicBlock::Create(llvm::getGlobalContext(), "case" + std::to_string(i), function->raw);

	llvm::Value* condCase = function->getScopeUnit(exprSwitch.operands[i].blocks.front())->compile();
	builder.SetInsertPoint(blockCase);
	llvm::Value* resultCase = function->getScopeUnit(exprSwitch.operands[i].blocks.back())->compile();
	builder.CreateBr(blockEpilog);

	ret->addIncoming(resultCase, builder.GetInsertBlock());
	builder.SetInsertPoint(blockProlog);
	instructionSwitch->addCase(dyn_cast<llvm::ConstantInt>(condCase), blockCase);
	}

	//compile default block:
	builder.SetInsertPoint(blockDefault);
	CodeScope* scopeDefault = exprSwitch.operands[1].blocks.front();
	llvm::Value* resultDefault = function->getScopeUnit(scopeDefault)->compile();
	builder.CreateBr(blockEpilog);
	ret->addIncoming(resultDefault, builder.GetInsertBlock());
	builder.SetInsertPoint(blockEpilog);

	return ret;
	}

	llvm::Value*
	AdvancedInstructions::compileSwitchVariant(const Expression& exprSwitch, const std::string& hintRetVar) {
	- EXPAND_CONTEXT
	- UNUSED(function);
	+ EXPAND_CONTEXT UNUSED(function);
	AST* root = context.pass->man->root;
	llvm::IRBuilder<>& builder = llvm->builder;
	llvm::Type* typI8= llvm::Type::getInt8Ty(llvm::getGlobalContext());
	const ExpandedType& typVariant = root->getType(exprSwitch.operands.at(0));
	llvm::Type* typVariantRaw = llvm->toLLVMType(typVariant);

	assert(typVariant->__operands.size() == exprSwitch.operands.size() - 1 && "Ill-formed Switch Variant");

	int casesCount = exprSwitch.operands.size();
	llvm::BasicBlock* blockProlog = builder.GetInsertBlock();
	llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm::getGlobalContext(), "switchAfter", function->raw);
	builder.SetInsertPoint(blockEpilog);
	llvm::Type* resultType = llvm->toLLVMType(root->getType(exprSwitch));
	llvm::PHINode *ret = builder.CreatePHI(resultType, casesCount, NAME("switch"));

	builder.SetInsertPoint(blockProlog);
	llvm::Value * conditionSwitchRaw = scope->process(exprSwitch.operands.at(0));
	llvm::Value* idRaw = builder.CreateExtractValue(conditionSwitchRaw, llvm::ArrayRef<unsigned>({0}));

	//Dereference preparation
	const bool flagDoDerefence = llvm::cast<llvm::StructType>(typVariantRaw)->getStructNumElements() > 1;
	llvm::Value* addrAsStorage = nullptr;
	if (flagDoDerefence){
	llvm::Type* typStorageRaw = llvm::cast<llvm::StructType>(typVariantRaw)->getElementType(1);
	llvm::Value* storageRaw = builder.CreateExtractValue(conditionSwitchRaw, llvm::ArrayRef<unsigned>({1}));
	addrAsStorage = llvm->builder.CreateAlloca(typStorageRaw);
	llvm->builder.CreateStore(storageRaw, addrAsStorage);
	}

	llvm::SwitchInst * instructionSwitch = builder.CreateSwitch(idRaw, nullptr, casesCount);
	llvm::BasicBlock* blockDefaultUndefined;
	std::list<CodeScope*>::const_iterator scopeCaseIt = exprSwitch.blocks.begin();
	for (int instancesSize = exprSwitch.operands.size()-1, instId = 0; instId < instancesSize; ++instId) {
	llvm::BasicBlock *blockCase = llvm::BasicBlock::Create(llvm::getGlobalContext(), "case" + std::to_string(instId), function->raw);
	builder.SetInsertPoint(blockCase);
	ICodeScopeUnit* unitCase = function->getScopeUnit(*scopeCaseIt);

	//Actual variant Derefence
	if (flagDoDerefence) {
	assert(exprSwitch.bindings.size() && "Switch condition alias not found");
	string identCondition = exprSwitch.bindings.front();
	const ExpandedType& instType = ExpandedType(typVariant->__operands.at(instId));
	llvm::Type* instTypeRaw = llvm->toLLVMType(instType);
	llvm::Value* addrAsInst = llvm->builder.CreateBitOrPointerCast(addrAsStorage, instTypeRaw->getPointerTo());
	llvm::Value* instRaw = llvm->builder.CreateLoad(instTypeRaw, addrAsInst);
	const Symbol& identSymb = unitCase->bindArg(instRaw, move(identCondition));
	Attachments::put<TypeInferred>(identSymb, instType);
	}

	llvm::Value* resultCase = function->getScopeUnit(*scopeCaseIt)->compile();
	builder.CreateBr(blockEpilog);

	ret->addIncoming(resultCase, blockDefaultUndefined = builder.GetInsertBlock());
	builder.SetInsertPoint(blockProlog);
	instructionSwitch->addCase(dyn_cast<llvm::ConstantInt>(llvm::ConstantInt::get(typI8, exprSwitch.operands.at(instId+1).getValueDouble())), blockCase);
	++scopeCaseIt;
	}

	instructionSwitch->setDefaultDest(blockDefaultUndefined);
	builder.SetInsertPoint(blockEpilog);
	return ret;
	}

	//TODO recognize cases to make const arrays/stored in global mem/stack alloced.
	llvm::Value*
	AdvancedInstructions::compileListAsSolidArray(const Expression &expr, const std::string& hintRetVar) {
	- EXPAND_CONTEXT
	- UNUSED(scope);
	- UNUSED(function);
	+ EXPAND_CONTEXT UNUSED(scope); UNUSED(function);

	AST* root = context.pass->man->root;
	const size_t& length = expr.getOperands().size();
	const Expression& expression = expr;
	llvm::Value* zero = ConstantInt::get(tyNum, 0);
	llvm::Value* one = ConstantInt::get(tyNum, 1);

	ExpandedType typAggrExpanded = root->getType(expression);
	assert(typAggrExpanded->__operator == TypeOperator::LIST);
	llvm::Type* typEl = llvm->toLLVMType(ExpandedType(typAggrExpanded->__operands[0]));
	ArrayType* typAggr = (ArrayType*) llvm::ArrayType::get(typEl, length);
	llvm::Value* list = llvm->builder.CreateAlloca(typAggr, ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), length, false), hintRetVar);

	const std::vector<Expression>& operands = expression.getOperands();
	llvm::Value* addrOperand = llvm->builder.CreateGEP(typAggr, list, ArrayRef<Value >(std::vector<Value>{zero, zero}));
	llvm->builder.CreateStore(scope->process(operands.front()), addrOperand) ;
	for (auto i=++operands.begin(); i!=operands.end(); ++i){
	addrOperand = llvm->builder.CreateGEP(typEl, addrOperand, ArrayRef<Value >(std::vector<Value>{one}));
	llvm->builder.CreateStore(scope->process(*i), addrOperand) ;
	}

	return list;
	// Value* listDest = l.builder.CreateAlloca(typList, ConstantInt::get(typI32, __size), *hintRetVar);
	// l.buil1der.CreateMemCpy(listDest, listSource, __size, 16);
	}

	llvm::Value*
	- AdvancedInstructions::compileConstantStringAsPChar(const string& data, const std::string& hintRetVar) {
	- EXPAND_CONTEXT
	- UNUSED(function);
	- UNUSED(scope);
	+AdvancedInstructions::compileConstantStringAsPChar(const string& data, const std::string& hintRetVar) {
	+ EXPAND_CONTEXT UNUSED(function); UNUSED(scope);

	- Type* typPchar = PointerType::getUnqual(Type::getInt8Ty(llvm::getGlobalContext()));
	- //ArrayType* typStr = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::I8, size+1))));
	+ Type* typPchar = PointerType::getUnqual(Type::getInt8Ty(llvm::getGlobalContext()));
	+ //ArrayType* typStr = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::I8, size+1))));

	- /*
	- std::vector<Constant *> chars;
	- chars.reserve(size+1);
	+ /*
	+ std::vector<Constant *> chars;
	+ chars.reserve(size+1);

	- for (size_t i=0; i< size; ++i){
	- chars[i] = ConstantInt::get(typI8, (unsigned char) data[i]);
	- }
	- chars[size] = ConstantInt::get(typI8, 0);
	- */
	+ for (size_t i=0; i< size; ++i){
	+ chars[i] = ConstantInt::get(typI8, (unsigned char) data[i]);
	+ }
	+ chars[size] = ConstantInt::get(typI8, 0);
	+ */

	- Value* rawData = ConstantDataArray::getString(llvm::getGlobalContext(), data);
	- Value* rawPtrData = llvm->builder.CreateAlloca(rawData->getType(), ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), 1, false));
	- llvm->builder.CreateStore(rawData, rawPtrData);
	+ Value* rawData = ConstantDataArray::getString(llvm::getGlobalContext(), data);
	+ Value* rawPtrData = llvm->builder.CreateAlloca(rawData->getType(), ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), 1, false));
	+ llvm->builder.CreateStore(rawData, rawPtrData);
	return llvm->builder.CreateCast(llvm::Instruction::BitCast, rawPtrData, typPchar, hintRetVar);
	}
	+
	+llvm::Value*
	+AdvancedInstructions::compileSequence(const Expression &expr){
	+ EXPAND_CONTEXT UNUSED(scope); UNUSED(llvm);
	+
	+ llvm::Value* result;
	+ for(CodeScope* scope: expr.blocks){
	+ result = function->getScopeUnit(scope)->compile();
	+ }
	+
	+ return result;
	+}
	+
	+
	diff --git a/cpp/src/compilation/advancedinstructions.h b/cpp/src/compilation/advancedinstructions.h
	index 5c7bd16..22a97cb 100644
	--- a/cpp/src/compilation/advancedinstructions.h
	+++ b/cpp/src/compilation/advancedinstructions.h
	@@ -1,53 +1,54 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: AdvancedInstructions.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 26, 2016, 6:00 PM
	*/

	#ifndef INSTRUCTIONSADVANCED_H
	#define INSTRUCTIONSADVANCED_H

	#include "ast.h"
	#include "llvmlayer.h"
	#include "pass/compilepass.h"

	#include <vector>

	namespace xreate {
	namespace compilation {

	class AdvancedInstructions {
	public:
	AdvancedInstructions(compilation::Context ctx);
	llvm::Value* compileArrayIndex(llvm::Value* aggregate, std::vector<llvm::Value *> indexes, std::string ident = "");
	llvm::Value* compileStructIndex(llvm::Value* aggregate, const ExpandedType& t, const std::string& idx);
	/*
	* - map Computation -> Llvm_Array: Prohibited, we do not know a result size
	* - map Llvm_Array -> Computation: considered in `compileGetElement`
	* - map Llvm_Array -> Llvm_Array considered by this method
	*/
	llvm::Value* compileMapSolidOutput(const Expression &expr, const std::string hintRetVar = "");
	llvm::Value* compileFold(const Expression& fold, const std::string& ident="");
	llvm::Value* compileFoldInf(const Expression& fold, const std::string& ident="");

	//DISABLEDFEATURE Context Loop
	llvm::Value* compileLoopContext(const Expression& expression, const std::string& hintRetVar);
	llvm::Value* compileIf(const Expression& exprIf, const std::string& ident);
	llvm::Value* compileSwitch(const Expression& exprSwitch, const std::string& hintRetVar);
	llvm::Value* compileSwitchVariant(const Expression& exprSwitch, const std::string& hintRetVar);
	llvm::Value* compileConstantStringAsPChar(const std::string &data, const std::string& hintRetVar);
	llvm::Value* compileListAsSolidArray(const Expression &expr, const std::string& hintRetVar);
	+ llvm::Value* compileSequence(const Expression &expr);

	private:
	compilation::Context context;
	llvm::IntegerType* const tyNum;
	};

	}}

	#endif /* INSTRUCTIONSADVANCED_H */

	diff --git a/cpp/src/pass/compilepass.cpp b/cpp/src/pass/compilepass.cpp
	index 66d630c..bd83691 100644
	--- a/cpp/src/pass/compilepass.cpp
	+++ b/cpp/src/pass/compilepass.cpp
	@@ -1,865 +1,876 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* compilepass.cpp
	*/

	/**
	* \file compilepass.h
	* \brief Compilation pass
	*/

	#include "compilepass.h"
	#include "clasplayer.h"
	#include <ast.h>
	#include "llvmlayer.h"

	#include "query/containers.h"
	#include "query/context.h"
	#include "compilation/containers.h"
	#include "compilation/latecontextcompiler2.h"
	#include "ExternLayer.h"
	#include "pass/adhocpass.h"
	#include "compilation/targetinterpretation.h"
	#include "pass/versionspass.h"
	#include "compilation/scopedecorators.h"
	#include "compilation/adhocfunctiondecorator.h"
	#include "compilation/operators.h"
	#include "analysis/typeinference.h"

	#include <boost/optional.hpp>
	#include <memory>
	#include <iostream>

	using namespace std;
	using namespace llvm;

	//TODO use Scope<TargetLlvm>

	//SECTIONTAG late-context FunctionDecorator

	namespace xreate{namespace context{

	/** \brief Late Context enabled decorator for IFunctionUnit
	* \extends IFunctionUnit
	*/
	template<class Parent>
	class LateContextFunctionDecorator : public Parent {
	public:
	LateContextFunctionDecorator(ManagedFnPtr f, CompilePass* p)
	: Parent(f, p), contextCompiler(this, p) {
	}

	protected:
	std::vector<llvm::Type*> prepareArguments() {
	std::vector<llvm::Type*>&& arguments = Parent::prepareArguments();

	size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
	if (sizeLateContextDemand) {
	llvm::Type* ty32 = llvm::Type::getInt32Ty(llvm::getGlobalContext());
	llvm::Type* tyDemand = llvm::ArrayType::get(ty32, sizeLateContextDemand);

	arguments.push_back(tyDemand);
	}

	return arguments;
	}

	llvm::Function::arg_iterator prepareBindings() {
	llvm::Function::arg_iterator fargsI = Parent::prepareBindings();

	size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
	if (sizeLateContextDemand) {
	fargsI->setName("latecontext");
	contextCompiler.rawContextArgument = &*fargsI;
	++fargsI;
	}

	return fargsI;
	}

	public:
	context::LateContextCompiler2 contextCompiler;
	};

	}} //end of namespace xreate::context

	namespace xreate { namespace compilation{

	std::string
	BasicFunctionUnit::prepareName(){
	AST* ast = IFunctionUnit::pass->man->root;

	string name = ast->getFunctionSpecializations(IFunctionUnit::function->__name).size() > 1 ?
	IFunctionUnit::function->__name + std::to_string(IFunctionUnit::function.id()) :
	IFunctionUnit::function->__name;

	return name;
	}

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

	std::transform(entry->__bindings.begin(), entry->__bindings.end(), std::inserter(signature, signature.end()),
	[llvm, ast, entry](const std::string & arg)->llvm::Type* {
	assert(entry->__identifiers.count(arg));

	ScopedSymbol argid{entry->__identifiers.at(arg), versions::VERSION_NONE};
	return llvm->toLLVMType(ast->expandType(entry->__declarations.at(argid).type));
	});

	return signature;
	}

	llvm::Type*
	BasicFunctionUnit::prepareResult() {
	LLVMLayer* llvm = IFunctionUnit::pass->man->llvm;
	AST* ast = IFunctionUnit::pass->man->root;
	CodeScope* entry = IFunctionUnit::function->__entry;

	return llvm->toLLVMType(ast->expandType(entry->__declarations.at(ScopedSymbol::RetSymbol).type));
	}

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

	for (std::string &arg : entry->__bindings) {
	ScopedSymbol argid{entry->__identifiers[arg], versions::VERSION_NONE};

	entryCompilation->bindArg(&*fargsI, argid);
	fargsI->setName(arg);
	++fargsI;
	}

	return fargsI;
	}

	//DEBT compiler rigidly depends on exact definition of DefaultFunctionUnit
	typedef context::LateContextFunctionDecorator<
	adhoc::AdhocFunctionDecorator<
	BasicFunctionUnit>> DefaultFunctionUnit;

	ICodeScopeUnit::ICodeScopeUnit(const CodeScope* const codeScope, IFunctionUnit* f, CompilePass* compilePass)
	: pass(compilePass), function(f), scope(codeScope), currentBlockRaw(nullptr) {
	}

	llvm::Value*
	CallStatementRaw::operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
	llvm::Function* calleeInfo = dyn_cast<llvm::Function>(__callee);

	if (calleeInfo) {
	auto argsFormal = calleeInfo->args();

	int pos = 0;
	//SECTIONTAG types/convert function ret value
	for (auto argFormal = argsFormal.begin(); argFormal != argsFormal.end(); ++argFormal, ++pos) {
	args[pos] = typeinference::doAutomaticTypeConversion(args[pos], argFormal->getType(), llvm->builder);
	}
	}

	- return llvm->builder.CreateCall(__calleeTy, __callee, args, hintDecl);
	+ //Do not name function call that returns Void.
	+ std::string nameStatement = hintDecl;
	+ if (calleeInfo->getReturnType()->isVoidTy()){
	+ nameStatement.clear();
	+ }
	+
	+ return llvm->builder.CreateCall(__calleeTy, __callee, args, nameStatement);
	}

	//DESABLEDFEATURE implement inlining
	class CallStatementInline : public ICallStatement {
	public:
	CallStatementInline(IFunctionUnit* caller, IFunctionUnit* callee, LLVMLayer* l)
	: __caller(caller), __callee(callee), llvm(l) {
	}

	llvm::Value* operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
	//TOTEST inlining
	// CodeScopeUnit* entryCompilation = outer->getScopeUnit(function->__entry);
	// for(int i=0, size = args.size(); i<size; ++i) {
	// entryCompilation->bindArg(args.at(i), string(entryCompilation->scope->__bindings.at(i)));
	// }
	//
	//
	// return entryCompilation->compile();

	return nullptr;
	}

	private:
	IFunctionUnit* __caller;
	IFunctionUnit* __callee;
	LLVMLayer* llvm;

	bool isInline() {
	// Symbol ret = Symbol{0, function->__entry};
	// bool flagOnTheFly = SymbolAttachments::get<IsImplementationOnTheFly>(ret, false);
	//TODO consider inlining
	return false;
	}
	};

	BasicCodeScopeUnit::BasicCodeScopeUnit(const CodeScope* const codeScope, IFunctionUnit* f, CompilePass* compilePass)
	: ICodeScopeUnit(codeScope, f, compilePass) {
	}

	llvm::Value*
	BasicCodeScopeUnit::processSymbol(const Symbol& s, std::string hintRetVar) {
	Expression declaration = CodeScope::getDefinition(s);
	const CodeScope* scope = s.scope;
	ICodeScopeUnit* scopeExternal = ICodeScopeUnit::function->getScopeUnit(scope);

	llvm::Value* resultRaw;
	if (scopeExternal == this){
	resultRaw = process(declaration, hintRetVar);
	currentBlockRaw = pass->man->llvm->builder.GetInsertBlock();

	} else {
	assert(scopeExternal->currentBlockRaw);

	llvm::BasicBlock* blockOwn = pass->man->llvm->builder.GetInsertBlock();
	pass->man->llvm->builder.SetInsertPoint(scopeExternal->currentBlockRaw);
	resultRaw = scopeExternal->processSymbol(s, hintRetVar);
	pass->man->llvm->builder.SetInsertPoint(blockOwn);
	}

	return resultRaw;
	}

	//TASK Isolate out context functionalty in decorator
	//TOTEST static late context decisions
	//TOTEST dynamic late context decisions
	ICallStatement*
	BasicCodeScopeUnit::findFunction(const Expression& opCall) {
	const std::string& calleeName = opCall.getValueString();
	LLVMLayer* llvm = pass->man->llvm;
	ClaspLayer* clasp = pass->man->clasp;
	DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
	context::ContextQuery* queryContext = pass->queryContext;

	const std::list<ManagedFnPtr>& specializations = pass->man->root->getFunctionSpecializations(calleeName);

	//if no specializations registered - check external function
	if (specializations.size() == 0) {
	llvm::Function* external = llvm->layerExtern->lookupFunction(calleeName);

	llvm::outs() << "Debug/External function: " << calleeName;
	external->getType()->print(llvm::outs(), true);
	llvm::outs() << "\n";

	return new CallStatementRaw(external, llvm);
	}

	//no decisions required
	if (specializations.size() == 1) {
	if (!specializations.front()->guardContext.isValid()) {
	return new CallStatementRaw(pass->getFunctionUnit(specializations.front())->compile(), llvm);
	}
	}

	//TODO move dictSpecialization over to a separate function in order to perform cache, etc.
	//prepare specializations dictionary
	std::map<Expression, ManagedFnPtr> dictSpecializations;

	boost::optional<ManagedFnPtr> variantDefault;
	boost::optional<ManagedFnPtr> variant;

	for (const ManagedFnPtr& f : specializations) {
	const Expression& guard = f->guardContext;

	//default case:
	if (!guard.isValid()) {
	variantDefault = f;
	continue;
	}

	assert(dictSpecializations.emplace(guard, f).second && "Found several identical specializations");
	}

	//check static context
	ScopePacked scopeCaller = clasp->pack(this->scope);
	const string atomSpecialization = "specialization";
	const Expression topicSpecialization(Operator::CALL,{(Atom<Identifier_t>(string(atomSpecialization))),
	Expression(Operator::CALL,
	{Atom<Identifier_t>(string(calleeName))}),
	Atom<Number_t>(scopeCaller)});

	const context::Decisions& decisions = queryContext->getFinalDecisions(scopeCaller);
	if (decisions.count(topicSpecialization)) {
	variant = dictSpecializations.at(decisions.at(topicSpecialization));
	}

	//TODO check only demand for this particular topic.
	size_t sizeDemand = function->contextCompiler.getFunctionDemandSize();

	//decision made if static context found or no late context exists(and there is default variant)
	bool flagHasStaticDecision = variant \|\| (variantDefault && !sizeDemand);

	//if no late context exists
	if (flagHasStaticDecision) {
	IFunctionUnit* calleeUnit = pass->getFunctionUnit(variant ? variant : variantDefault);

	//inlining possible based on static decision only
	// if (calleeUnit->isInline()) {
	// return new CallStatementInline(function, calleeUnit);
	// }

	return new CallStatementRaw(calleeUnit->compile(), llvm);
	}

	//require default variant if no static decision made
	assert(variantDefault);

	llvm::Function* functionVariantDefault = this->pass->getFunctionUnit(*variantDefault)->compile();
	llvm::Value* resultFn = function->contextCompiler.findFunction(calleeName, functionVariantDefault, scopeCaller);
	llvm::PointerType *resultPTy = cast<llvm::PointerType>(resultFn->getType());
	llvm::FunctionType *resultFTy = cast<llvm::FunctionType>(resultPTy->getElementType());
	return new CallStatementRaw(resultFn, resultFTy, llvm);
	}



	//DISABLEDFEATURE transformations
	// if (pass->transformations->isAcceptable(expr)){
	// return pass->transformations->transform(expr, result, ctx);
	// }

	llvm::Value*
	BasicCodeScopeUnit::process(const Expression& expr, const std::string& hintVarDecl) {
	#define DEFAULT(x) (hintVarDecl.empty()? x: hintVarDecl)
	llvm::Value *left;
	llvm::Value *right;
	LLVMLayer& l = *pass->man->llvm;
	xreate::compilation::AdvancedInstructions instructions = xreate::compilation::AdvancedInstructions({this, function, pass});

	switch (expr.op) {
	case Operator::SUB: case Operator::MUL:
	case Operator::DIV: case Operator::EQU: case Operator::LSS:
	case Operator::GTR: case Operator::NE: case Operator::LSE:
	case Operator::GTE:

	assert(expr.__state == Expression::COMPOUND);
	assert(expr.operands.size() == 2);

	left = process(expr.operands[0]);
	right = process(expr.operands[1]);

	//SECTIONTAG types/convert binary operation
	right = typeinference::doAutomaticTypeConversion(right, left->getType(), l.builder);
	break;

	default:;
	}

	switch (expr.op) {
	case Operator::ADD:
	{
	left = process(expr.operands[0]);
	Context context{this, function, pass};

	llvm::Value* resultSU = StructUpdate::add(expr.operands[0], left, expr.operands[1], context, DEFAULT("tmp_add"));
	if (resultSU) return resultSU;

	right = process(expr.operands[1]);

	llvm::Value* resultAddPA = pointerarithmetic::PointerArithmetic::add(left, right, context, DEFAULT("tmp_add"));
	if (resultAddPA) {
	return resultAddPA;
	}

	return l.builder.CreateAdd(left, right, DEFAULT("tmp_add"));
	break;
	}

	case Operator::SUB:
	return l.builder.CreateSub(left, right, DEFAULT("tmp_sub"));
	break;

	case Operator::MUL:
	return l.builder.CreateMul(left, right, DEFAULT("tmp_mul"));
	break;

	case Operator::DIV:
	return l.builder.CreateSDiv(left, right, DEFAULT("tmp_div"));
	break;

	case Operator::EQU:
	if (left->getType()->isIntegerTy()) return l.builder.CreateICmpEQ(left, right, DEFAULT("tmp_equ"));
	if (left->getType()->isFloatingPointTy()) return l.builder.CreateFCmpOEQ(left, right, DEFAULT("tmp_equ"));
	break;

	case Operator::NE:
	return l.builder.CreateICmpNE(left, right, DEFAULT("tmp_ne"));
	break;

	case Operator::LSS:
	return l.builder.CreateICmpSLT(left, right, DEFAULT("tmp_lss"));
	break;

	case Operator::LSE:
	return l.builder.CreateICmpSLE(left, right, DEFAULT("tmp_lse"));
	break;

	case Operator::GTR:
	return l.builder.CreateICmpSGT(left, right, DEFAULT("tmp_gtr"));
	break;

	case Operator::GTE:
	return l.builder.CreateICmpSGE(left, right, DEFAULT("tmp_gte"));
	break;

	case Operator::NEG:
	left = process(expr.operands[0]);
	return l.builder.CreateNeg(left, DEFAULT("tmp_neg"));
	break;

	case Operator::CALL:
	{
	assert(expr.__state == Expression::COMPOUND);
	shared_ptr<ICallStatement> callee(findFunction(expr));
	const std::string& nameCallee = expr.getValueString();

	//prepare arguments
	std::vector<llvm::Value *> args;
	args.reserve(expr.operands.size());

	std::transform(expr.operands.begin(), expr.operands.end(), std::inserter(args, args.end()),
	[this](const Expression & operand) {
	return process(operand);
	}
	);

	ScopePacked outerScopeId = pass->man->clasp->pack(this->scope);

	//TASK a) refactor CALL/ADHOC/find function
	//SECTIONTAG late-context propagation arg
	size_t calleeDemandSize = pass->queryContext->getFunctionDemand(nameCallee).size();
	if (calleeDemandSize) {
	DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
	llvm::Value* argLateContext = function->contextCompiler.compileContextArgument(nameCallee, outerScopeId);
	args.push_back(argLateContext);
	}

	return (*callee)(move(args), DEFAULT("res_" + nameCallee));
	}

	case Operator::IF:
	{
	return instructions.compileIf(expr, DEFAULT("tmp_if"));
	}

	case Operator::SWITCH:
	{
	return instructions.compileSwitch(expr, DEFAULT("tmp_switch"));
	}

	case Operator::LOOP_CONTEXT:
	{
	assert(false);
	return nullptr;
	//return instructions.compileLoopContext(expr, DEFAULT("tmp_loop"));
	}

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

	case Operator::LIST:
	{
	return instructions.compileListAsSolidArray(expr, DEFAULT("tmp_list"));
	};

	case Operator::LIST_RANGE:
	{
	assert(false); //no compilation phase for a range list
	// return InstructionList(this).compileConstantArray(expr, l, hintRetVar);
	};

	case Operator::LIST_NAMED:
	{
	typedef Expanded<TypeAnnotation> ExpandedType;

	ExpandedType tyStructLiteral = l.ast->getType(expr);

	const std::vector<string> fieldsFormal = (tyStructLiteral.get().__operator == TypeOperator::CUSTOM) ?
	l.layerExtern->getStructFields(l.layerExtern->lookupType(tyStructLiteral.get().__valueCustom))
	: tyStructLiteral.get().fields;

	std::map<std::string, size_t> indexFields;
	for (size_t i = 0, size = fieldsFormal.size(); i < size; ++i) {
	indexFields.emplace(fieldsFormal[i], i);
	}

	llvm::StructType* tyLiteralRaw = llvm::cast<llvm::StructType>(l.toLLVMType(tyStructLiteral));
	llvm::Value* record = llvm::UndefValue::get(tyLiteralRaw);

	for (size_t i = 0; i < expr.operands.size(); ++i) {
	const Expression& operand = expr.operands.at(i);
	unsigned int fieldId = indexFields.at(expr.bindings.at(i));
	llvm::Value* result = process(operand);
	assert(result);
	record = l.builder.CreateInsertValue(record, result, llvm::ArrayRef<unsigned>({fieldId}));
	}

	return record;
	};

	case Operator::MAP:
	{
	assert(expr.blocks.size());
	return instructions.compileMapSolidOutput(expr, DEFAULT("map"));
	};

	case Operator::FOLD:
	{
	return instructions.compileFold(expr, DEFAULT("fold"));
	};

	case Operator::FOLD_INF:
	{
	return instructions.compileFoldInf(expr, DEFAULT("fold"));
	};

	case Operator::INDEX:
	{
	//TASK allow multiindex compilation
	assert(expr.operands.size() == 2);
	assert(expr.operands[0].__state == Expression::IDENT);

	const std::string& hintIdent = expr.operands[0].getValueString();
	Symbol s = Attachments::get<IdentifierSymbol>(expr.operands[0]);
	const ExpandedType& t2 = pass->man->root->getType(expr.operands[0]);

	llvm::Value* aggr = processSymbol(s, hintIdent);

	switch (t2.get().__operator) {
	case TypeOperator::LIST_NAMED: case TypeOperator::CUSTOM:
	{
	std::string idxField;
	const Expression& idx = expr.operands.at(1);
	switch (idx.__state) {

	//named struct field
	case Expression::STRING:
	idxField = idx.getValueString();
	break;

	//anonymous struct field
	case Expression::NUMBER:
	idxField = to_string((int) idx.getValueDouble());
	break;

	default:
	assert(false && "Wrong index for a struct");
	}

	return instructions.compileStructIndex(aggr, t2, idxField);
	};

	case TypeOperator::LIST:
	{
	std::vector<llvm::Value*> indexes;
	std::transform(++expr.operands.begin(), expr.operands.end(), std::inserter(indexes, indexes.end()),
	[this] (const Expression & op) {
	return process(op);
	}
	);

	return instructions.compileArrayIndex(aggr, indexes, DEFAULT(string("el_") + hintIdent));
	};

	default:
	assert(false);
	}
	};

	//SECTIONTAG adhoc actual compilation
	//TODO a) make sure that it's correct: function->adhocImplementation built for Entry scope and used in another scope
	case Operator::ADHOC:
	{
	DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
	assert(function->adhocImplementation && "Adhoc implementation not found");
	const Expression& comm = adhoc::AdhocExpression(expr).getCommand();

	CodeScope* scope = function->adhocImplementation->getCommandImplementation(comm);
	ICodeScopeUnit* unitScope = function->getScopeUnit(scope);

	//SECTIONTAG types/convert ADHOC ret convertation
	llvm::Type* resultTy = l.toLLVMType(pass->man->root->expandType(function->adhocImplementation->getResultType()));
	return typeinference::doAutomaticTypeConversion(unitScope->compile(), resultTy, l.builder);
	};

	case Operator::CALL_INTRINSIC:
	{
	const std::string op = expr.getValueString();

	if (op == "copy") {
	llvm::Value* result = process(expr.getOperands().at(0));

	auto decoratorVersions = Decorators<VersionsScopeDecoratorTag>::getInterface(this);
	llvm::Value* storage = decoratorVersions->processIntrinsicInit(result->getType());
	decoratorVersions->processIntrinsicCopy(result, storage);

	return l.builder.CreateLoad(storage, hintVarDecl);
	}

	assert(false && "undefined intrinsic");
	}

	case Operator::VARIANT:
	{
	const ExpandedType& typVariant = pass->man->root->getType(expr);
	llvm::Type* typVariantRaw = l.toLLVMType(typVariant);
	llvm::Type* typIdRaw = llvm::cast<llvm::StructType>(typVariantRaw)->getElementType(0);

	uint64_t id = expr.getValueDouble();
	llvm::Value* variantRaw = llvm::UndefValue::get(typVariantRaw);
	variantRaw = l.builder.CreateInsertValue(variantRaw, llvm::ConstantInt::get(typIdRaw, id), llvm::ArrayRef<unsigned>({0}));

	const bool flagDoReference = expr.operands.size();
	if (flagDoReference){
	const ExpandedType& subtyp = ExpandedType(typVariant->__operands.at(id));
	llvm::Type* subtypRaw = l.toLLVMType(subtyp);
	Attachments::put<TypeInferred>(expr.operands.at(0), subtyp);
	llvm::Value* subtypValue = process(expr.operands.at(0));

	llvm::Type* typStorageRaw = llvm::cast<llvm::StructType>(typVariantRaw)->getElementType(1);
	llvm::Value* addrAsStorage = l.builder.CreateAlloca(typStorageRaw);
	llvm::Value* addrAsSubtyp = l.builder.CreateBitOrPointerCast(addrAsStorage, subtypRaw->getPointerTo());

	l.builder.CreateStore(subtypValue, addrAsSubtyp);
	llvm::Value* storageRaw = l.builder.CreateLoad(typStorageRaw, addrAsStorage);
	variantRaw = l.builder.CreateInsertValue(variantRaw, storageRaw, llvm::ArrayRef<unsigned>({1}));
	}

	return variantRaw;
	}

	case Operator::SWITCH_VARIANT:
	{
	return instructions.compileSwitchVariant(expr, DEFAULT("tmpswitch"));
	}

	+ case Operator::SEQUENCE:
	+ {
	+ return instructions.compileSequence(expr);
	+ }
	+
	case Operator::NONE:
	assert(expr.__state != Expression::COMPOUND);

	switch (expr.__state) {
	case Expression::IDENT:
	{
	Symbol s = Attachments::get<IdentifierSymbol>(expr);
	return processSymbol(s, expr.getValueString());
	}

	case Expression::NUMBER:
	{
	llvm::Type* typConst;

	if (expr.type.isValid()) {
	typConst = l.toLLVMType(pass->man->root->getType(expr));

	} else {
	typConst = llvm::Type::getInt32Ty(llvm::getGlobalContext());
	}

	int literal = expr.getValueDouble();
	return llvm::ConstantInt::get(typConst, literal);
	}

	case Expression::STRING:
	{
	return instructions.compileConstantStringAsPChar(expr.getValueString(), DEFAULT("tmp_str"));
	};

	default:
	{
	break;
	}
	};

	break;

	default: break;

	}

	assert(false && "Can't compile expression");
	return 0;
	}

	llvm::Value*
	BasicCodeScopeUnit::compile(const std::string& hintBlockDecl) {
	if (!hintBlockDecl.empty()) {
	llvm::BasicBlock *block = llvm::BasicBlock::Create(llvm::getGlobalContext(), hintBlockDecl, function->raw);
	pass->man->llvm->builder.SetInsertPoint(block);
	}

	currentBlockRaw = pass->man->llvm->builder.GetInsertBlock();
	Symbol symbScope = Symbol{ScopedSymbol::RetSymbol, scope};
	return processSymbol(symbScope);
	}

	ICodeScopeUnit::~ICodeScopeUnit() {
	}

	IFunctionUnit::~IFunctionUnit() {
	}

	llvm::Function*
	IFunctionUnit::compile() {
	if (raw != nullptr) return raw;

	LLVMLayer* llvm = pass->man->llvm;
	llvm::IRBuilder<>& builder = llvm->builder;

	string&& functionName = prepareName();
	std::vector<llvm::Type*>&& types = prepareArguments();
	llvm::Type* expectedResultType = prepareResult();

	llvm::FunctionType *ft = llvm::FunctionType::get(expectedResultType, types, false);
	raw = llvm::cast<llvm::Function>(llvm->module->getOrInsertFunction(functionName, ft));
	prepareBindings();

	const std::string&blockName = "entry";
	llvm::BasicBlock* blockCurrent = builder.GetInsertBlock();

	llvm::Value* result = getScopeUnit(function->__entry)->compile(blockName);
	assert(result);

	//SECTIONTAG types/convert function ret value
	builder.CreateRet(typeinference::doAutomaticTypeConversion(result, expectedResultType, llvm->builder));

	if (blockCurrent) {
	builder.SetInsertPoint(blockCurrent);
	}

	llvm->moveToGarbage(ft);
	return raw;
	}

	ICodeScopeUnit*
	IFunctionUnit::getScopeUnit(const CodeScope * const scope) {
	if (__scopes.count(scope)) {
	auto result = __scopes.at(scope).lock();

	if (result) {
	return result.get();
	}
	}

	std::shared_ptr<ICodeScopeUnit> unit(pass->buildCodeScopeUnit(scope, this));

	if (scope->__parent != nullptr) {
	auto parentUnit = Decorators<CachedScopeDecoratorTag>::getInterface(getScopeUnit(scope->__parent));
	parentUnit->registerChildScope(unit);

	} else {
	__orphanedScopes.push_back(unit);
	}

	if (!__scopes.emplace(scope, unit).second) {
	__scopes[scope] = unit;
	}

	return unit.get();
	}

	ICodeScopeUnit*
	IFunctionUnit::getScopeUnit(ManagedScpPtr scope) {
	return getScopeUnit(&*scope);
	}

	ICodeScopeUnit*
	IFunctionUnit::getEntry() {
	return getScopeUnit(function->getEntryScope());
	}

	template<>
	compilation::IFunctionUnit*
	CompilePassCustomDecorators<void, void>::buildFunctionUnit(const ManagedFnPtr& function){
	return new DefaultFunctionUnit(function, this);
	}

	template<>
	compilation::ICodeScopeUnit*
	CompilePassCustomDecorators<void, void>::buildCodeScopeUnit(const CodeScope* const scope, IFunctionUnit* function){
	return new DefaultCodeScopeUnit(scope, function, this);
	}

	} // emf of compilation

	IFunctionUnit*
	CompilePass::getFunctionUnit(const ManagedFnPtr& function) {
	unsigned int id = function.id();

	if (!functions.count(id)) {
	IFunctionUnit* unit = buildFunctionUnit(function);
	functions.emplace(id, unit);
	return unit;
	}

	return functions.at(id);
	}

	void
	CompilePass::run() {
	managerTransformations = new TransformationsManager();
	targetInterpretation = new interpretation::TargetInterpretation(this->man->root, this);
	queryContext = reinterpret_cast<context::ContextQuery*> (man->clasp->getQuery(QueryId::ContextQuery));

	//Find out main function;
	ClaspLayer::ModelFragment model = man->clasp->query(Config::get("function-entry"));
	assert(model && "Error: No entry function found");
	assert(model->first != model->second && "Error: Ambiguous entry function");

	string nameMain = std::get<0>(ClaspLayer::parse<std::string>(model->first->second));
	IFunctionUnit* unitMain = getFunctionUnit(man->root->findFunction(nameMain));
	entry = unitMain->compile();
	}

	llvm::Function*
	CompilePass::getEntryFunction() {
	assert(entry);
	return entry;
	}

	void
	CompilePass::prepareQueries(ClaspLayer* clasp) {
	clasp->registerQuery(new containers::Query(), QueryId::ContainersQuery);
	clasp->registerQuery(new context::ContextQuery(), QueryId::ContextQuery);

	Attachments::init<PolymorphGuard>();
	clasp->registerQuery(new polymorph::PolymorphQuery(), QueryId::PolymorphQuery);
	}
	} //end of namespace xreate

	/**
	* \class xreate::CompilePass
	* \brief Encapsulates all compilation activities
	*
	* xreate::CompilePass iterates over xreate::AST tree and produces executable code fed by data(via xreate::Attachments) gathered by previous passes as well as data via queries(xreate::IQuery) from xreate:ClaspLayer reasoner.
	* Compilation's done using xreate::LLVMLayer(wrapper over LLVM toolchain) and based on following aspects:
	* - Containers support. See \ref compilation/containers.h
	* - Late Conext compilation. See xreate::context::LateContextCompiler2
	* - Interpretation support. See xreate::interpretation::TargetInterpretation
	* - Loop saturation support. See xreate::compilation::TransformerSaturation
	* - External Code access. See xreate::ExternLayer(wrapper over Clang library)
	*
	* \section adaptability_sect Adaptability
	* xreate::CompilePass's architecture provides adaptability by employing:
	* - %Function Decorators to alter function-level compilation. See xreate::compilation::IFunctionUnit
	* - Code Block Decorators to alter code block level compilation. See xreate::compilation::ICodeScopeUnit
	* Default functionality defined by \ref xreate::compilation::DefaultCodeScopeUnit
	* - Targets to allow more versitile extensions.
	* Currently only xreate::interpretation::TargetInterpretation use Targets infrastructure. See xreate::compilation::Target
	* - %Altering Function invocation. xreate::compilation::ICallStatement
	*
	* Client able to construct compiler with desired decorators using xreate::compilation::CompilePassCustomDecorators.
	* As a handy alias, `CompilePassCustomDecorators<void, void>` constructs default compiler
	*
	*/
	diff --git a/cpp/tests/cfa.cpp b/cpp/tests/cfa.cpp
	index 7681f73..65ee929 100644
	--- a/cpp/tests/cfa.cpp
	+++ b/cpp/tests/cfa.cpp
	@@ -1,122 +1,122 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* testsCFG.cpp
	*
	* Created on: Jul 17, 2015
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#include "xreatemanager.h"
	#include "pass/dfapass.h"
	#include "pass/cfapass.h"

	#include "analysis/DominatorsTreeAnalysisProvider.h"

	#include "gtest/gtest.h"

	#include <boost/scoped_ptr.hpp>
	#include <boost/smart_ptr/scoped_array.hpp>

	using namespace xreate;
	using namespace xreate::cfa;
	using namespace std;

	TEST(CFA, testFunctionAnnotationsClasp){
	string&& program =
	"f2 = function::int; annotationF2 {\n"
	" 0\n"
	"}\n"
	"\n"
	"f1 = function:: int; entry; annotationF1 {\n"
	" f2() + 10\n"
	"}";


	details::tier1::XreateManager* man = details::tier1::XreateManager::prepare(move(program));
	man->analyse();

	ClaspLayer::ModelFragment answer = man->clasp->query("annotationF1");
	int countNoneValue = 0;
	if (answer) countNoneValue = std::distance(answer->first, answer->second);
	EXPECT_EQ(1, countNoneValue);

	answer = man->clasp->query("annotationF2");
	countNoneValue = 0;
	if (answer) countNoneValue = std::distance(answer->first, answer->second);

	EXPECT_EQ(1, countNoneValue);
	}

	TEST(CFA, testLoopContextExists){
	details::tier1::XreateManager* man = details::tier1::XreateManager::prepare (
	"interface(cfa){\n"
	" operator fold:: annotation1.\n"
	"}\n"
	"\n"
	"main = function:: int; entry {\n"
	" x = [1..10]:: [int].\n"
	" sum = loop fold (x->el:: int, 0->sum):: int {\n"
	" el + sum + f1()\n"
	" }. \n"
	" sum\n"
	"}"
	"case context:: annotation1 {"
	" f1 = function::int {\n"
	" x = 0:: int. "
	" x\n"
	" }"
	"}"
	);

	man->analyse();
	ClaspLayer::ModelFragment model = man->clasp->query("annotation1");
	ScopePacked scopeIdActual = std::get<0>(ClaspLayer::parse<ScopePacked>(model->first->second));

	CodeScope* scopeEntry = man->root->findFunction("main")->getEntryScope();
	const Expression& exprSum = scopeEntry->getDefinition(scopeEntry->getSymbol("sum"));
	CodeScope* scopeExpected = exprSum.blocks.front();

	ScopePacked scopeIdExpected = man->clasp->pack(scopeExpected);
	ASSERT_EQ(scopeIdExpected, scopeIdActual);
	}

	TEST(CFA, CFGRoots){
	-// std::string program =
	-//R"CODE(
	-// main = function::int{a()+ b()}
	-// a= function::int {c1() + c2()}
	-// b= function::int {c2()}
	-// c1=function::int{0}
	-// c2=function::int{0}
	-//)CODE";
	-//
	-// boost::scoped_ptr<XreateManager> manager
	-// (XreateManager::prepare(move(program)));
	-//
	+ std::string program =
	+R"CODE(
	+ main = function::int{a()+ b()}
	+ a= function::int {c1() + c2()}
	+ b= function::int {c2()}
	+ c1=function::int{0}
	+ c2=function::int{0}
	+)CODE";
	+
	+ std::unique_ptr<details::tier1::XreateManager> man(details::tier1::XreateManager::prepare(move(program)));
	+ man->analyse();
	+
	// manager->registerPass(new CFAPass(manager.get()) , PassId::CFGPass);
	// manager->executePasses();
	// manager->clasp->run();
	//
	// dominators::DominatorsTreeAnalysisProvider domProvider;
	// domProvider.run(manager->clasp);
	//
	// dominators::DominatorsTreeAnalysisProvider::Dominators expectedFDom= {
	// {0, {0, 9}}
	// ,{1, {1, 4}}
	// ,{2, {7, 8}}
	// ,{3, {2, 3}}
	// ,{4, {5, 6}}
	// };
	//
	// dominators::DominatorsTreeAnalysisProvider::Dominators expectedPostDom= {
	// {0, {5, 6}}
	// ,{1, {3, 4}}
	// ,{2, {8, 9}}
	// ,{3, {1, 2}}
	// ,{4, {7, 10}}
	// };
	//
	// ASSERT_EQ(expectedFDom, domProvider.getForwardDominators());
	// ASSERT_EQ(expectedPostDom, domProvider.getPostDominators());
	}
	diff --git a/cpp/tests/compilation.cpp b/cpp/tests/compilation.cpp
	index 5e61494..11cef99 100644
	--- a/cpp/tests/compilation.cpp
	+++ b/cpp/tests/compilation.cpp
	@@ -1,201 +1,228 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* compilation.cpp
	*
	* Created on: -
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#include "xreatemanager.h"
	#include "gtest/gtest.h"
	using namespace xreate;
	//DEBT implement no pkgconfig ways to link libs
	//TOTEST FunctionUnit::compileInline

	TEST(Compilation, functionEntry1){
	std::unique_ptr<XreateManager> program(XreateManager::prepare(
	"func1 = function(a:: int):: int {a+8} \
	func2 = function::int; entry {12 + func1(4)} \
	"));

	void* entryPtr = program->run();
	int (entry)() = (int ()())(intptr_t)entryPtr;

	int answer = entry();
	ASSERT_EQ(24, answer);
	}

	TEST(Compilation, full_IFStatementWithVariantType){
	XreateManager* man = XreateManager::prepare(
	"Color = type variant {RED, BLUE, GREEN}.\n"
	"\n"
	" main = function(x::int):: bool; entry {\n"
	" color = if (x == 0 )::Color {RED()} else {BLUE()}.\n"
	" if (color == BLUE())::bool {true} else {false}\n"
	" }"
	);

	bool (main)(int) = (bool ()(int)) man->run();
	ASSERT_FALSE(main(0));
	ASSERT_TRUE(main(1));
	}

	TEST(Compilation, full_Variant1){
	XreateManager* man = XreateManager::prepare(R"Code(
	OneArgument = type{x::int}.
	TwoArguments = type{x::int, y::int}.

	Command= type variant{
	Add::TwoArguments,
	Dec::OneArgument
	}.

	main = function::Command; entry {
	Dec({x=2})::Command
	}
	)Code");

	void (main)() = (void ()()) man->run();
	}

	TEST(Compilation, full_SwitchVariant1){
	XreateManager* man = XreateManager::prepare(R"Code(
	OneArgument = type{x::int}.
	TwoArguments = type{x::int, y::int}.

	Command= type variant{
	Add::TwoArguments,
	Dec::OneArgument
	}.

	main = function::int; entry {
	//command = Dec({x = 8}):: Command.
	command = Add({x= 3, y= 5}):: Command.

	switch variant(command)::int
	case(Add){command["x"] + command["y"]}
	case(Dec){command["x"]}
	}
	)Code");

	int (mainFn)() = (int ()()) man->run();
	int result = mainFn();
	ASSERT_EQ(8, result);
	}

	TEST(Compilation, full_SwitchVariantNoArguments2){
	XreateManager* man = XreateManager::prepare(R"Code(
	Command= type variant{Add, Dec}.

	main = function::int; entry {
	command = Dec():: Command.

	switch variant(command)::int
	case(Add){0}
	case(Dec){1}
	}
	)Code");

	int (mainFn)() = (int ()()) man->run();
	int result = mainFn();
	ASSERT_EQ(1, result);
	}

	TEST(Compilation, full_SwitchVariantMixedArguments3){
	XreateManager* man = XreateManager::prepare(R"Code(
	TwoArguments = type{x::int, y::int}.
	Command= type variant{
	Add::TwoArguments,
	Dec
	}.

	main = function(arg::int):: int; entry {
	command = if (arg > 0)::Command {Dec()} else {Add({x=1,y=2})}.

	switch variant(command)::int
	case(Add){0}
	case(Dec){1}
	}
	)Code");

	int (mainFn)(int) = (int ()(int)) man->run();
	int result = mainFn(5);
	ASSERT_EQ(1, result);
	}

	TEST(Compilation, full_StructUpdate){
	XreateManager* man = XreateManager::prepare(
	R"Code(

	Rec = type {
	a :: int,
	b:: int
	}.

	test= function:: int; entry {
	a = {a = 18, b = 20}:: Rec.

	b = a + {a = 11}:: Rec.
	b["a"]
	}
	)Code");

	int (main)() = (int ()()) man->run();
	int result = main();

	ASSERT_EQ(11, result);
	}

	TEST(Compilation, AnonymousStruct_init_index){
	std::string code =
	R"Code(

	main = function:: int; entry {
	x = {10, 15} :: {int, int}.
	x[1]
	}

	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	int (main)() = (int ()()) man->run();

	EXPECT_EQ(15, main());
	}

	TEST(Compilation, AnonymousStruct_init_update){
	std::string code =
	R"Code(

	main = function:: int; entry {
	x = {10, 15} :: {int, int}.
	y = x + {6}:: {int, int}.
	y[0]
	}

	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	int (main)() = (int ()()) man->run();

	EXPECT_EQ(6, main());
	}

	TEST(Compilation, BugIncorrectScopes1){
	std::string code =
	R"Code(

	init = function:: int {10}
	main = function(cmd:: int):: int; entry {
	x = init():: int.
	if(cmd > 0):: int { x + 1 } else { x }
	}
	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	int (mainFn)(int) = (int ()(int)) man->run();

	EXPECT_EQ(11, mainFn(1));
	}

	+TEST(Compilation, Sequence1){
	+ std::string code =
	+R"Code(
	+ interface(extern-c){
	+ libbsd = library:: pkgconfig("libbsd").
	+
	+ include {
	+ libbsd = ["bsd/stdlib.h", "string.h"]
	+ }.
	+ }
	+
	+ start = function:: i32; entry {
	+ seq {
	+ nameNew = "TestingSequence":: string.
	+ setprogname(nameNew)
	+
	+ } {strlen(getprogname())}::i32
	+ }
	+)Code";
	+
	+ std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
	+ int (startFn)() = (int ()()) man->run();
	+
	+ int nameNewLen = startFn();
	+ ASSERT_EQ(15, nameNewLen);
	+}
	+
	diff --git a/grammar/xreate.ATG b/grammar/xreate.ATG
	index 455871e..5b18378 100644
	--- a/grammar/xreate.ATG
	+++ b/grammar/xreate.ATG
	@@ -1,657 +1,664 @@
	//TODO add ListLiteral
	//TODO ExprTyped: assign default(none) type

	#include "ast.h"
	#include "ExternLayer.h"
	#include "pass/adhocpass.h"
	#include <string>
	#include <stack>

	#define wprintf(format, ...) \
	char __buffer[100]; \
	wcstombs(__buffer, format, 100); \
	fprintf(stderr, __buffer, __VA_ARGS__)

	using namespace std;

	COMPILER Xreate

	details::inconsistent::AST* root = nullptr; // current program unit

	void ensureInitalizedAST(){
	if (root == nullptr) root = new details::inconsistent::AST();
	}

	struct {
	std::stack<CodeScope*> scopesOld;
	CodeScope* scope = nullptr;
	} context;

	void pushContextScope(CodeScope* scope){
	context.scopesOld.push(context.scope);
	context.scope = scope;
	}

	void popContextScope(){
	context.scope = context.scopesOld.top();
	context.scopesOld.pop();
	}

	int nextToken()
	{
	scanner->ResetPeek();
	return scanner->Peek()->kind;
	}

	bool checkTokenAfterIdent(int key){
	if (la->kind != _ident) return false;
	return nextToken() == key;
	}

	bool checkParametersList()
	{
	return la->kind == _ident && nextToken() == _lparen;
	}

	bool checkInfix()
	{
	return la->kind == _ident && nextToken() == _ident;
	}

	bool checkIndex()
	{
	return la->kind == _ident && nextToken() == _lbrack;
	}

	bool checkFuncDecl()
	{
	if (la->kind != _ident) return false;

	int token2 = nextToken();
	int token3 = scanner->Peek()->kind;

	return token2 == _assign && (token3 == _function \|\| token3 == _pre);
	}



	bool checkAssignment()
	{
	if (la->kind != _ident) return false;

	scanner->ResetPeek();
	int token2 = scanner->Peek()->kind;
	if (token2 == _lcurbrack) {
	scanner->Peek();
	int token3 = scanner->Peek()->kind;
	if (token3 != _rcurbrack) return false;

	int token4 = scanner->Peek()->kind;
	return token4 == _assign;
	}

	return token2 == _assign;
	}

	void recognizeIdentifier(Expression& i){
	if (!context.scope->recognizeIdentifier(i)){
	root->postponeIdentifier(context.scope, i);
	}
	}

	enum SwitchKind{SWITCH_NORMAL, SWITCH_META};

	CHARACTERS
	letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
	any = ANY - '"'.
	digit = "0123456789".
	cr = '\r'.
	lf = '\n'.
	tab = '\t'.

	TOKENS
	ident = (letter \| '_') {letter \| digit \| '_'}.
	number = (digit \| '-' digit) {digit}.
	string = '"' { any } '"'.
	function = "function".
	pre = "pre".
	lparen = '('.
	rparen = ')'.
	lbrack = '['.
	rbrack = ']'.
	lcurbrack = '{'.
	rcurbrack = '}'.
	equal = "==".
	assign = '='.
	implic = '-' '>'.
	colon = ':'.
	context = "context".
	tagcolon = "::".
	lse = "<=".
	lss = "<".
	gte = ">=".
	gtr = ">".

	ne1 = "!=".
	ne2= "<>".


	COMMENTS FROM "/" TO "/" NESTED
	COMMENTS FROM "//" TO lf

	IGNORE cr + lf + tab

	PRODUCTIONS

	Xreate = (. Function* function; ensureInitalizedAST(); .)
	{( RuleDecl
	\| InterfaceData \| Imprt \| ContextSection \| GuardSection
	\| IF(checkFuncDecl()) FDecl<function> (. root->add(function); .)
	\| TDecl
	\| SkipModulesSection
	)} (. .)
	.

	Ident<std::wstring& name>
	= ident (. name = t->val; .).

	VarIdent<Expression& e>
	= ident (. e = Expression(Atom<Identifier_t>(t->val)); .)
	[ lcurbrack (
	ident (. SemErr(coco_string_create("var version as ident is not implemented yet")); .)
	\| number (. Attachments::put<versions::VariableVersion>(e, Atom<Number_t>(t->val).get()); .)
	) rcurbrack ]
	.


	FDecl<Function*& f> = (. std::wstring fname; std::wstring argName; TypeAnnotation typIn; TypeAnnotation typOut; bool flagIsPrefunct = false; Expression binding; .)
	Ident<fname> assign
	[pre (. flagIsPrefunct = true; .)]
	function (. f = new Function(fname); f->isPrefunction = flagIsPrefunct; CodeScope* entry = f->getEntryScope(); .)

	['(' Ident<argName> tagcolon ExprAnnotations<binding> (. f->addBinding(Atom<Identifier_t>(argName), move(binding)); .)
	{',' Ident<argName> tagcolon ExprAnnotations<binding> (. f->addBinding(Atom <Identifier_t>(argName), move(binding));.)
	} ')']

	[ tagcolon
	( IF(flagIsPrefunct) FnTag<f>
	\| Type<typOut>
	)
	{';' FnTag<f> }]
	BDecl<entry> (. const_cast<Expression&>(entry->getBody()).bindType(move(typOut));.)
	.

	ContextSection<>= (. Expression context; Function* f; .)
	"case" "context" tagcolon MetaSimpExpr<context>
	lcurbrack { FDecl<f> (. f->guardContext = context; root->add(f); .)
	} rcurbrack.

	GuardSection<>= (. Expression guard; Function* f; .)
	"guard" tagcolon MetaSimpExpr<guard>
	lcurbrack { FDecl<f> (. f->guard = guard; root->add(f); .)
	} rcurbrack.

	/**
	* TYPES
	*
	*/
	TypeTerm<TypePrimitive& typ> = (. std::wstring tid; .)
	("string" (. typ = TypePrimitive::String;.)
	\| "num" (. typ = TypePrimitive::Num;.)
	\| "int" (. typ = TypePrimitive::Int;.)
	\| "float" (. typ = TypePrimitive::Float;.)
	\| "bool" (. typ = TypePrimitive::Bool; .)
	\| "i8" (. typ = TypePrimitive::I8; .)
	\| "i32" (. typ = TypePrimitive::I32; .)
	\| "i64" (. typ = TypePrimitive::I64; .)
	).

	Type<TypeAnnotation& typ> = (. TypeAnnotation typ2; TypePrimitive typ3; std::wstring tid, field; .)
	(
	TList<typ>
	\| TStruct<typ>
	\| TVariant<typ>
	\| TypeTerm<typ3> (. typ = typ3; .)
	\| IF (checkIndex()) Ident<tid> lbrack
	Ident<field> (. typ = TypeAnnotation(TypeOperator::ACCESS, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
	{',' Ident<field> (. typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
	} rbrack

	\| Ident<tid> (. typ = TypeAnnotation(TypeOperator::CUSTOM, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); .)
	['(' Type<typ2> (. typ.__operator = TypeOperator::CALL; typ.__operands.push_back(typ2); .)
	{',' Type<typ2> (. typ.__operands.push_back(typ2); .)
	} ')']
	) .

	TList<TypeAnnotation& typ> = (. TypeAnnotation ty; .)
	'[' Type<ty> ']' (. typ = TypeAnnotation(TypeOperator::LIST, {ty}); .)
	.

	TStruct<TypeAnnotation& typ> = (. TypeAnnotation t; std::wstring key; size_t keyCounter=0; .)
	lcurbrack
	(
	IF(checkTokenAfterIdent(_tagcolon)) Ident<key> tagcolon Type<t>
	\| Type<t> (. key = to_wstring(keyCounter++); .)

	) (. typ = TypeAnnotation(TypeOperator::LIST_NAMED, {t}); typ.fields.push_back(Atom<Identifier_t>(key).get()); .)
	{',' (
	IF(checkTokenAfterIdent(_tagcolon)) Ident<key> tagcolon Type<t>
	\| Type<t> (. key = to_wstring(keyCounter++); .)

	) (. typ.__operands.push_back(t); typ.fields.push_back(Atom<Identifier_t>(key).get()); .)
	} rcurbrack.

	TVariant<TypeAnnotation& typ>= (. TypeAnnotation t, typVoid(TypeOperator::LIST_NAMED, {}); std::vector<TypeAnnotation> operands; std::vector<Atom<Identifier_t>> keys; std::wstring variant; .)
	"variant" lcurbrack
	Ident<variant> (. t=typVoid; .)
	[tagcolon Type<t>] (. keys.push_back(Atom<Identifier_t>(variant)); operands.push_back(t); .)

	{',' Ident<variant> (. t=typVoid; .)
	[tagcolon Type<t>] (. keys.push_back(Atom<Identifier_t>(variant)); operands.push_back(t); .)
	}
	rcurbrack (. typ = TypeAnnotation(TypeOperator::VARIANT, {}); typ.__operands = operands; typ.addFields(std::move(keys)); .)
	.

	TDecl = (. TypeAnnotation t; std::wstring tname, arg; std::vector<Atom<Identifier_t>> args; .)
	Ident<tname> assign "type"
	['(' Ident<arg> (. args.push_back(Atom<Identifier_t>(arg)); .)
	{',' Ident<arg> (. args.push_back(Atom<Identifier_t>(arg)); .)
	} ')']
	Type<t>'.' (. t.addBindings(move(args)); root->add(move(t), Atom<Identifier_t>(tname)); .)
	.

	ContextDecl<CodeScope * scope> = (. Expression tag; .)
	context tagcolon
	MetaSimpExpr<tag> (. scope->tags.push_back(tag); .)
	{';' MetaSimpExpr<tag> (. scope->tags.push_back(tag); .)
	}.

	VDecl<CodeScope* f> = (. std::wstring vname; Expression var, value;.)
	VarIdent<var> assign ExprTyped<value> (. Symbol identSymbol = f->addDefinition(move(var), move(value));
	Attachments::put<SymbolAlias>(value, identSymbol);
	.)
	.

	BDecl<CodeScope* scope> = lcurbrack (. Expression body; pushContextScope(scope); .)
	{(IF(checkAssignment()) VDecl<scope> '.'
	\| RuleContextDecl<scope>
	\| ContextDecl<scope>'.'
	\| ExprTyped<body> (. scope->setBody(body); Attachments::put<SymbolAlias>(body, Symbol{ScopedSymbol::RetSymbol, scope});.)
	)}
	rcurbrack (. popContextScope(); .)
	.

	IfDecl<Expression& e> = (. Expression cond; ManagedScpPtr blockTrue = root->add(new CodeScope(context.scope)); ManagedScpPtr blockFalse = root->add(new CodeScope(context.scope)); .)
	"if" '(' Expr<cond> ')' (. e = Expression(Operator::IF, {cond}); .)
	tagcolon ExprAnnotations<e>
	BDecl<&blockTrue> "else" BDecl<&blockFalse> (. e.addBlock(blockTrue); e.addBlock(blockFalse); .)
	.

	LoopDecl<Expression& e> =
	(. Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc, contextClass; Expression tagsEl;
	ManagedScpPtr block = root->add(new CodeScope(context.scope)); .)
	"loop"
	("map" '(' Expr<eIn> implic Ident<varEl> (. e = Expression(Operator::MAP, {eIn}); .)
	tagcolon ExprAnnotations<tagsEl> ')' tagcolon ExprAnnotations<e>
	(.
	e.addBindings({Atom<Identifier_t>(varEl)});
	block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
	.)
	BDecl<&*block>
	(. e.addBlock(block); .)

	\|"fold"
	("inf" '(' Expr<eAcc> implic Ident<varAcc> ')'
	(.
	e = Expression(Operator::FOLD_INF, {eAcc});
	e.addBindings({Atom<Identifier_t>(varAcc)});
	block->addBinding(Atom<Identifier_t>(varAcc), Expression());
	.)
	tagcolon ExprAnnotations<e> BDecl<&*block>
	(. e.addBlock(block); .)

	\| '(' Expr<eIn> implic Ident<varEl> tagcolon ExprAnnotations<tagsEl> ['\|' Expr<eFilters> ] ',' Expr<eAcc> implic Ident<varAcc>')'
	(.
	e = Expression(Operator::FOLD, {eIn, eAcc});
	e.addBindings({Atom<Identifier_t>(varEl), Atom<Identifier_t>(varAcc)});
	.)
	tagcolon ExprAnnotations<e>
	(.
	block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
	block->addBinding(Atom<Identifier_t>(varAcc), Expression());
	.)
	BDecl<&*block>
	(. e.addBlock(block); .)
	)
	\| "context" '(' string (. contextClass = t->val; .)
	')' BDecl<&*block>
	(. e = Expression(Operator::LOOP_CONTEXT, {Expression(Atom<String_t>(std::move(contextClass)))});
	e.addBlock(block);
	.)
	).

	// Switches
	SwitchDecl<Expression& eSwitch, SwitchKind flagSwitchKind> = (. TypeAnnotation typ; eSwitch = Expression(Operator::SWITCH, {}); Expression eCondition; Expression tag;.)
	"switch"
	(
	SwitchVariantDecl<eSwitch>
	\| lparen ExprTyped<eCondition> rparen tagcolon ExprAnnotations<eSwitch> (. eSwitch.operands.push_back(eCondition);.)
	CaseDecl<eSwitch, flagSwitchKind> {CaseDecl<eSwitch, flagSwitchKind>}
	)
	.

	CaseDecl<Expression& outer, SwitchKind flagSwitchKind> = (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); Expression condition; .)
	"case"
	( IF(flagSwitchKind == SWITCH_META)
	lparen MetaSimpExpr<condition> rparen BDecl<&*scope> (. Expression exprCase(Operator::CASE, {}); exprCase.addTags({condition}); exprCase.addBlock(scope); outer.addArg(move(exprCase));.)

	\| "default" BDecl<&*scope> (. Expression exprCase(Operator::CASE_DEFAULT, {});
	exprCase.addBlock(scope);
	outer.operands.insert(++outer.operands.begin(), exprCase); .)

	\| lparen CaseParams<&scope> rparen (. ManagedScpPtr scopeBody = root->add(new CodeScope(&scope)); Expression exprCase(Operator::CASE, {}); .)
	BDecl<&*scopeBody> (. exprCase.addBlock(scope); exprCase.addBlock(scopeBody); outer.addArg(move(exprCase)); .)
	).

	CaseParams<CodeScope* scope> = (. Expression condition; Expression guard(Operator::LOGIC_AND, {}); pushContextScope(scope); .)
	ExprTyped<condition> (. guard.addArg(Expression(condition)); .)
	{',' ExprTyped<condition> (. guard.addArg(Expression(condition)); .)
	} (. scope->setBody(guard); popContextScope(); .)
	.

	SwitchVariantDecl<Expression& expr> =
	(. Expression varTested; std::wstring varAlias; bool flagAliasFound = false; expr = Expression(Operator::SWITCH_VARIANT, {}); .)

	"variant" lparen Expr<varTested> [implic Ident<varAlias>
	(. flagAliasFound = true; .)

	] [tagcolon ExprAnnotations<varTested>] rparen tagcolon ExprAnnotations<expr>
	(. expr.addArg(std::move(varTested));
	if (flagAliasFound) {
	expr.addBindings({Atom<Identifier_t>(varAlias)});

	} else {
	if(varTested.__state == Expression::IDENT){
	expr.addBindings({Atom<Identifier_t>(string(varTested.getValueString()))});
	}
	}
	.)

	CaseVariantDecl<expr> {CaseVariantDecl<expr>}
	.

	CaseVariantDecl<Expression& expr> = (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); std::wstring key; scope->addBinding(Atom<Identifier_t>(string(expr.bindings.front())), Expression()); .)
	"case" lparen Ident<key> rparen (. expr.addArg(root->recognizeVariantConstructor(Atom<Identifier_t>(std::move(key)))); .)
	BDecl<&*scope> (. expr.addBlock(scope); .)
	.

	IntrinsicDecl<Expression& outer>= (. std::wstring name; .)
	"intrinsic" Ident< name> (. outer = Expression(Operator::CALL_INTRINSIC, {}); outer.setValue(Atom<Identifier_t>(name)); .)
	lparen [CalleeParams<outer>] rparen .
	+
	+SequenceDecl<Expression& sequence> = (. sequence = Expression(); sequence.setOp(Operator::SEQUENCE); ManagedScpPtr scope = root->add(new CodeScope(context.scope)); .)
	+ "seq" BDecl<&scope> (. sequence.blocks.push_back(&scope); scope = root->add(new CodeScope(&*scope)); .)
	+ { (. scope = root->add(new CodeScope(&*scope)); .)
	+ BDecl<&scope> (. sequence.blocks.push_back(&scope); .)
	+ }.

	/============================ INTERFACES ===============================/
	Imprt<> =
	"import" "raw" lparen string (. root->__rawImports.push_back(Atom<String_t>(t->val).get()); .)
	rparen '.'.

	InterfaceData<> = "interface" '('
	( "dfa" ')' InterfaceDFA
	\| "extern-c" ')' InterfaceExternC
	\| "cfa" ')' InterfaceCFA
	\| "adhoc" ')' InterfaceAdhoc

	).

	InterfaceAdhoc<> =
	'{' { PrefunctionSchemeDecl } '}'.

	PrefunctionSchemeDecl<> = (. TypeAnnotation typReturn; std::wstring prefName; Expression exprCases; .)
	pre function Ident<prefName> tagcolon Type<typReturn>
	lcurbrack SwitchDecl<exprCases, SWITCH_META> rcurbrack
	(. Expression prefData(Operator::CALL, {Atom<Identifier_t>(prefName), exprCases});
	prefData.bindType(typReturn);
	root->addInterfaceData(Adhoc, move(prefData));
	.).


	InterfaceExternC<> = (. ExternData data; .)
	'{' {IncludeExternDecl<data> \| LibExternDecl<data> } '}'
	(. root->addExternData(move(data)); .)
	.

	LibExternDecl<ExternData& data> = (. std::wstring pkgname, libname; .)
	Ident<libname> assign "library" tagcolon "pkgconfig"
	'(' string (. pkgname = t->val; .)
	')' '.' (. data.addLibrary(Atom<Identifier_t>(libname), Atom<String_t>(pkgname)); .)
	.

	IncludeExternDecl<ExternData& data> = (. Expression inc; .)
	"include" StructLiteral<inc> '.' (. data.addIncludeDecl(move(inc)); .)
	.

	InterfaceDFA<> = '{' { InstructDecl } '}' .

	InstructDecl = (.Operator op; Expression tag;
	Expression scheme;
	std::vector<Expression>& tags = scheme.operands;
	tags.push_back(Expression()); /* return value */ .)
	"operator" InstructAlias<op> tagcolon '(' (.scheme.setOp(op); .)
	[
	MetaSimpExpr<tag> (. tags.push_back(tag); .)
	{
	',' MetaSimpExpr<tag> (. tags.push_back(tag); .)
	}
	] ')' [ implic MetaSimpExpr<tag> (. tags[0] = tag; .)
	] (. root->addDFAData(move(scheme)); .)
	'.'.

	InstructAlias<Operator& op> =
	(
	"map" (. op = Operator::MAP; .)
	\| "list_range" (. op = Operator::LIST_RANGE; .)
	\| "list" (. op = Operator::LIST; .)
	\| "fold" (. op = Operator::FOLD; .)
	\| "index" (. op = Operator::INDEX; .)
	).


	InterfaceCFA<> = '{' { InstructCFADecl } '}' .

	InstructCFADecl<> = (.Operator op; Expression tag;
	Expression scheme;
	std::vector<Expression>& tags = scheme.operands; .)

	"operator" InstructAlias<op> tagcolon (. scheme.setOp(op); .)
	[
	MetaSimpExpr<tag> (. tags.push_back(tag); .)
	{
	',' MetaSimpExpr<tag> (. tags.push_back(tag); .)
	}
	] '.' (. root->addInterfaceData(CFA, move(scheme)); .).

	/============================ METAPROGRAMMING ===============================/
	// TagsDecl<CodeScope* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
	// ':' { MetaSimpExpr<tag> (. /f.addTag(std::move(tag), mod); / .)
	// }.


	FnTag<Function* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
	MetaSimpExpr<tag>
	['-' TagMod<mod>] (. f->addTag(std::move(tag), mod); .).

	TagMod<TagModifier& mod> =
	( "assert" (. mod = TagModifier::ASSERT; .)
	\| "require" (. mod = TagModifier::REQUIRE; .)
	).

	RuleDecl<> =
	"rule" tagcolon (. RuleArguments args; RuleGuards guards; DomainAnnotation typ; std::wstring arg; .)
	'(' Ident<arg> tagcolon Domain<typ> (. args.add(arg, typ); .)
	{',' Ident<arg> tagcolon Domain<typ> (. args.add(arg, typ); .)
	} ')'
	["case" RGuard<guards> {',' RGuard<guards>}]
	'{' RBody<args, guards> '}' .

	/* - TODO use RGuard for guards-*/
	RuleContextDecl<CodeScope* scope> = (.Expression eHead, eGuards, eBody; .)
	"rule" "context" tagcolon MetaSimpExpr<eHead>
	"case" lparen MetaSimpExpr<eGuards> rparen
	'{' MetaSimpExpr<eBody> '}' (.scope->contextRules.push_back(Expression(Operator::CONTEXT_RULE, {eHead, eGuards, eBody})); .).

	Domain<DomainAnnotation& dom> =
	(
	"function" (. dom = DomainAnnotation::FUNCTION; .)
	\| "variable" (. dom = DomainAnnotation::VARIABLE; .)
	).

	RGuard<RuleGuards& guards>= (. Expression e; .)
	MetaExpr<e> (. guards.add(std::move(e)); .).

	MetaExpr<Expression& e>= (.Operator op; Expression e2; .)
	MetaExpr2<e>
	[MetaOp<op> MetaExpr2<e2> (. e = Expression(op, {e, e2}); .)
	].

	MetaExpr2<Expression& e>=
	(
	'(' MetaExpr<e> ')'
	\| MetaSimpExpr<e>
	).

	MetaSimpExpr<Expression& e>= (. std::wstring i1, infix; Expression e2; .)
	( '-' MetaSimpExpr<e2> (. e = Expression(Operator::NEG, {e2}); .)
	\| IF(checkParametersList()) Ident<i1> (. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(i1))}); .)
	'(' [ MetaCalleeParams<e> ] ')'
	\| IF(checkInfix()) Ident<i1> Ident<infix> MetaSimpExpr<e2>
	(. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(infix))});
	e.addArg(Expression(Atom<Identifier_t>(i1)));
	e.addArg(std::move(e2));
	.)
	\| Ident<i1> (. e = Expression(Operator::CALL, {Atom<Identifier_t>(i1)}); .)
	).

	MetaCalleeParams<Expression& e> = (. Expression e2; .)
	MetaSimpExpr<e2> (. e.addArg(Expression(e2)); .)
	{',' MetaSimpExpr<e2> (. e.addArg(Expression(e2)); .)
	}.

	RBody<const RuleArguments& args, const RuleGuards& guards> =
	(. Expression e; std::wstring msg; .)
	"warning" MetaExpr<e> ["message" string (. msg = t->val; .)
	] (. root->add(new RuleWarning(RuleArguments(args), RuleGuards(guards), std::move(e), Atom<String_t>(msg))); .)
	.

	MetaOp< Operator& op> =
	implic (. op = Operator::IMPL; .)
	.

	/============================ Expressions ===============================/
	ExprAnnotations<Expression& e> = (. TypeAnnotation typ; std::list<Expression> tags; Expression tag; e.tags.clear();.)
	Type<typ> (. e.bindType(move(typ)); .)
	{';' MetaSimpExpr<tag> (. tags.push_back(tag); .)
	} (. e.addTags(tags); .)
	.

	ExprTyped<Expression&e> = Expr<e> [tagcolon ExprAnnotations<e>].

	Expr< Expression& e> (. Operator op; Expression e2; .)
	= ExprArithmAdd<e>
	[ RelOp<op>
	ExprArithmAdd<e2> (. e = Expression(op, {e, e2}); .)
	].

	ExprArithmAdd< Expression& e>= (. Operator op; Expression e2; .)
	ExprArithmMul< e>
	[ AddOp< op>
	ExprArithmAdd< e2> (. e = Expression(op, {e, e2});.)
	].

	ExprArithmMul< Expression& e> (. Operator op; Expression e2; .)
	= ExprPostfix< e>
	[ MulOp< op>
	ExprArithmMul< e2> (. e = Expression(op, {e, e2}); .)
	].

	ExprPostfix<Expression& e>
	= Term<e>
	[ (. e = Expression(Operator::INDEX, {e}); .)
	{lbrack CalleeParams<e> rbrack }
	].


	Term< Expression& e> (. std::wstring name; e = Expression(); .)
	=
	(IF (checkParametersList()) Ident< name>
	(. e = Expression(Operator::CALL, {Atom<Identifier_t>(name)}); root->recognizeVariantConstructor(e); .)
	'(' [CalleeParams<e>] ')'
	\| VarIdent<e> (. recognizeIdentifier(e); .)
	\| ListLiteral<e> (. /* tuple */.)
	\| StructLiteral<e> (. /* struct */.)
	\| LoopDecl<e>
	\| IfDecl<e>
	\| SwitchDecl<e, SWITCH_NORMAL>
	\| AdhocDecl<e>
	\| IntrinsicDecl<e>
	+ \| SequenceDecl<e>
	\| number (. e = Expression(Atom<Number_t>(t->val)); .)
	\| string (. e = Expression(Atom<String_t>(t->val)); .)
	\| "true" (. e = Expression(Atom<Number_t>(1)); e.bindType(TypePrimitive::Bool); .)
	\| "false" (. e = Expression(Atom<Number_t>(0)); e.bindType(TypePrimitive::Bool); .)
	\| '-' Term<e> (. e = Expression(Operator::NEG, {e}); .)
	\| '(' ExprTyped<e> ')'
	).

	StructLiteral<Expression& e> = (. std::wstring key; Expression val; std::list<Atom<Identifier_t>> keys; size_t keyCounter=0; .)
	lcurbrack
	(IF(checkTokenAfterIdent(_assign)) Ident<key> '=' Expr<val>
	\| Expr<val> (. key = to_wstring(keyCounter++); .)
	) (. keys.push_back(Atom<Identifier_t>(key)); e = Expression(Operator::LIST_NAMED, {val}); .)
	{',' (IF(checkTokenAfterIdent(_assign)) Ident<key> '=' Expr<val>
	\| Expr<val> (. key = to_wstring(keyCounter++); .)
	) (. e.addArg(Expression(val)); keys.push_back(Atom<Identifier_t>(key)); .)
	} rcurbrack (. e.addBindings(keys.begin(), keys.end()); .)
	.

	ListLiteral<Expression& e> = (. Expression eFrom, eTo; .)
	'['
	[ Expr<eFrom> (. e.addArg(Expression(eFrom)); .)
	(".." Expr<eTo> (. e.addArg(Expression(eTo)); e.setOp(Operator::LIST_RANGE); .)
	\|{',' Expr<eFrom> (. e.addArg(Expression(eFrom)); .)
	} (. e.setOp(Operator::LIST); .)
	) ] ']'.

	AdhocDecl<Expression& e> = (. Expression command; .)
	"ad" "hoc" MetaSimpExpr<command> (. adhoc::AdhocExpression exprAdhoc; exprAdhoc.setCommand(command); e = exprAdhoc; .).

	CalleeParams<Expression& e> = (. Expression e2; .)
	ExprTyped<e2> (. e.addArg(Expression(e2)); .)
	{',' ExprTyped<e2> (. e.addArg(Expression(e2)); .)
	}.

	AddOp< Operator& op>
	= (. op = Operator::ADD; .)
	( '+'
	\| '-' (. op = Operator::SUB; .)
	).

	MulOp< Operator& op>
	= (. op = Operator::MUL; .)
	( '*'
	\| '/' (. op = Operator::DIV; .)
	).

	RelOp< Operator& op>
	= (. op = Operator::EQU; .)
	( equal
	\| (ne1 \| ne2) (. op = Operator::NE; .)

	\| lse (. op = Operator::LSE; .)
	\| lss (. op = Operator::LSS; .)

	\| gte (. op = Operator::GTE; .)
	\| gtr (. op = Operator::GTR; .)

	).

	SkipModulesSection = "module" '{' {ANY} '}'.

	END Xreate.

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions