No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Mar 14, 4:44 AM

View Options

	diff --git a/cpp/src/compilation/targetinterpretation.cpp b/cpp/src/compilation/targetinterpretation.cpp
	index a424e37..702f5d0 100644
	--- a/cpp/src/compilation/targetinterpretation.cpp
	+++ b/cpp/src/compilation/targetinterpretation.cpp
	@@ -1,495 +1,494 @@
	/*
	* File: targetinterpretation.cpp
	* Author: pgess
	*
	* Created on June 29, 2016, 6:45 PM
	*/

	#include "compilation/targetinterpretation.h"
	#include "pass/interpretationpass.h"
	#include "analysis/typeinference.h"
	#include "llvmlayer.h"
	#include "compilation/scopedecorators.h"

	#include <boost/scoped_ptr.hpp>
	#include <iostream>
	#include <clang/AST/DeclBase.h>

	using namespace std;
	using namespace xreate::compilation;

	namespace xreate{ namespace interpretation{

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

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

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

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

	return expression.blocks.back();
	}

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

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

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

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

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

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

	CodeScope*
	InterpretationScope::processOperatorSwitchVariant(const Expression& expression){
	const Expression& condition = process(expression.operands.at(0));
	assert(condition.op == Operator::VARIANT);
	- const string identCondition = expression.operands.at(0).getValueString();
	-
	+ const string identCondition = expression.bindings.front();

	Expression opExpected(Atom<Number_t>(condition.getValueDouble()));
	auto itFoundValue = std::find(++expression.operands.begin(), expression.operands.end(), opExpected);
	assert(itFoundValue != expression.operands.end());

	int indexBlock = itFoundValue - expression.operands.begin() -1;
	auto blockFound = expression.blocks.begin();
	std::advance(blockFound, indexBlock);

	InterpretationScope* scopeI12n = function->getScope(*blockFound);

	if (condition.operands.size()) {
	const Expression& value = condition.operands.at(0);
	scopeI12n->overrideBinding(value, identCondition);
	}

	return *blockFound;
	}

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

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

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

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

	case SWITCH_VARIANT: {
	CodeScope* scopeResult = processOperatorSwitchVariant(expression);
	const Expression& condition = process(expression.operands.at(0));

	- const string identCondition = expression.operands.at(0).getValueString();
	+ const string identCondition = expression.bindings.front();
	auto scopeCompilation = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeResult));

	if(condition.operands.size()){
	//override value
	Symbol symbCondition{ScopedSymbol{scopeResult->__identifiers.at(identCondition), versions::VERSION_NONE}, scopeResult};
	scopeCompilation->overrideDeclaration(symbCondition, Expression(condition.operands.at(0)));

	//set correct type for binding:
	TypeAnnotation typeVariant = typeinference::getType(condition, *function->man->ast);
	int conditionIndex = condition.getValueDouble();
	ScopedSymbol symbolInternal = scopeResult->getSymbol(identCondition);
	scopeResult->__declarations[symbolInternal].bindType(typeVariant.__operands.at(conditionIndex));
	}

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

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

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

	const string& nameEl = expression.bindings[0];
	Symbol symbEl{ScopedSymbol{scopeBody->__identifiers.at(nameEl), versions::VERSION_NONE}, scopeBody};
	const std::string& idAccum = expression.bindings[1];
	llvm::Value* rawAccum = context.scope->process(expression.getOperands()[1]);

	InterpretationScope* intrBody = function->getScope(scopeBody);
	auto unitBody = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeBody));

	const std::vector<Expression> elementsInput= exprInput.getOperands();

	for (size_t i=0; i<elementsInput.size(); ++i){
	intrBody->reset();
	unitBody->reset();

	Expression exprElement = elementsInput[i];

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

	rawAccum = unitBody->compile();
	}

	return rawAccum;
	}

	/*
	case FOLD_INF_INTERPRET_INOUT{
	}
	*/

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

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

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

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

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

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

	default: break;
	}

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

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

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

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

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

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

	case Expression::IDENT:{
	Symbol s = Attachments::get<Symbol>(expression);
	return Parent::processSymbol(s);
	}

	case Expression::COMPOUND:
	break;

	default: assert(false);
	}

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

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

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

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

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


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

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

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

	return fnUnit->process(args);
	}

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

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

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

	case Operator::INDEX: {
	const Expression& exprKey = process(expression.operands[1]);
	const Expression& exprData = process(expression.operands[0]);

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

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

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

	assert(false);
	}

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

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

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

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

	accum = body->processScope();
	}

	return accum;
	}

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

	default: break;
	}

	return expression;
	}

	InterpretationFunction*
	TargetInterpretation::getFunction(IFunctionUnit* unit){
	if (__dictFunctionsByUnit.count(unit)) {
	return __dictFunctionsByUnit.at(unit);
	}

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

	return f;
	}

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

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

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

	return result;
	}

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

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

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

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

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

	return body->processScope();
	}

	// Partial function interpretation

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

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

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

	for(size_t no: argumentsActual){
	VNameId argId = entry->__identifiers.at(entry->__bindings.at(no));
	ScopedSymbol arg{argId, versions::VERSION_NONE};

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

	return signature;
	}

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

	for(size_t no: argumentsActual){
	ScopedSymbol arg{entry->__identifiers.at(entry->__bindings.at(no)), versions::VERSION_NONE};

	entryCompilation->bindArg(&*fargsI, arg);
	fargsI->setName(entry->__bindings.at(no));
	++fargsI;
	}

	return fargsI;
	}

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

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

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

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

	functionUnit = new PIFunctionUnit(signatureInstance.declaration, move(argumentsActual), id, target->pass);
	CodeScope* entry = signatureInstance.declaration->__entry;
	auto entryUnit = Decorators<CachedScopeDecoratorTag>::getInterface<>(functionUnit->getEntry());
	InterpretationScope* entryIntrp = InterpretationFunction::getScope(entry);

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

	VNameId argId = entry->__identifiers.at(entry->__bindings[no]);
	Symbol argSymbol{ScopedSymbol{argId, versions::VERSION_NONE}, entry};
	entryUnit->overrideDeclaration(argSymbol, Expression(signatureInstance.bindings[sigNo]));
	++sigNo;
	}
	}
	}

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

	return raw;
	}

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

	return lhs.bindings < rhs.bindings;
	}

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

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

	}}
	diff --git a/cpp/src/pass/interpretationpass.cpp b/cpp/src/pass/interpretationpass.cpp
	index 09e7ac4..6fd6cfd 100644
	--- a/cpp/src/pass/interpretationpass.cpp
	+++ b/cpp/src/pass/interpretationpass.cpp
	@@ -1,448 +1,448 @@
	/*
	* File: interpretationpass.cpp
	* Author: pgess
	*
	* Created on July 5, 2016, 5:21 PM
	*/

	#include "pass/interpretationpass.h"
	//#include "compilation/transformations.h"
	#include <compilation/targetinterpretation.h>
	#include <bits/stl_vector.h>
	#include "ast.h"
	//DEBT implement InterpretationPass purely in clasp
	//DEBT represent InterpretationPass as general type inference

	using namespace std;

	namespace xreate{

	template<>
	interpretation::InterpretationResolution
	defaultValue<interpretation::InterpretationResolution>(){
	return interpretation::CMPL_ONLY;
	}

	namespace interpretation{
	enum InterpretationQuery{QUERY_INTR_ONLY, QUERY_CMPL_ONLY};

	namespace details {
	template<InterpretationQuery FLAG_REQUIRED>
	bool checkConstraints(InterpretationResolution flag) {
	return ( (flag==INTR_ONLY && FLAG_REQUIRED == QUERY_INTR_ONLY)
	\|\| (flag==CMPL_ONLY && FLAG_REQUIRED == QUERY_CMPL_ONLY));
	}

	InterpretationResolution
	recognizeTags(const map<std::string, Expression>& tags){
	auto i = tags.find("interpretation");
	if (i== tags.end()){
	return ANY;
	}

	assert(i->second.op == Operator::CALL);
	const string& cmd = i->second.operands.at(0).getValueString();

	//TODO make consistent names of annotation and resolution
	if (cmd == "force"){
	return INTR_ONLY;

	} else if (cmd == "suppress"){
	return CMPL_ONLY;
	}

	return ANY;
	}
	}

	InterpretationResolution
	unify(InterpretationResolution flag) {
	return flag;
	}

	template<typename FLAG_A, typename FLAG_B, typename... FLAGS>
	InterpretationResolution
	unify(FLAG_A flagA, FLAG_B flagB, FLAGS... flags) {

	if (flagA== ANY){
	return unify(flagB, flags...);
	}

	if (flagB == ANY) {
	return unify(flagA, flags...);
	}

	assert(flagA == flagB);
	return flagA;
	}

	template<InterpretationQuery FLAG_REQUIRED>
	bool checkConstraints(std::vector<InterpretationResolution>&& flags) {
	assert(flags.size());

	InterpretationResolution flag = flags.front();
	return details::checkConstraints<FLAG_REQUIRED>(flag);
	}

	template<InterpretationQuery FLAG_REQUIRED_A, InterpretationQuery FLAG_REQUIRED_B, InterpretationQuery... FLAGS>
	bool checkConstraints(std::vector<InterpretationResolution>&& flags) {
	assert(flags.size());

	InterpretationResolution flag = flags.front();
	flags.pop_back();

	if (details::checkConstraints<FLAG_REQUIRED_A>(flag)){
	return checkConstraints<FLAG_REQUIRED_B, FLAGS...>(move(flags));
	}

	return false;
	}

	bool
	InterpretationData::isDefault() const{
	return (resolution == ANY && op == NONE);
	}

	void
	recognizeTags(const Expression& e){
	InterpretationData tag{details::recognizeTags(e.tags), NONE};
	if (!tag.isDefault())
	Attachments::put<InterpretationData>(e, tag);
	}

	InterpretationResolution
	recognizeTags(const ManagedFnPtr& f){
	return details::recognizeTags(f->getTags());
	}

	InterpretationPass::InterpretationPass(PassManager* manager)
	: AbstractPass(manager) {

	Attachments::init<FunctionInterpretationData>();
	Attachments::init<InterpretationData>();
	}

	void InterpretationPass::run(){
	ManagedFnPtr f = man->root->begin<Function>();
	auto& visitedSymbols = getSymbolCache();

	while (f.isValid()) {
	const Symbol& symbolFunction{ScopedSymbol::RetSymbol, f->getEntryScope()};

	if (!visitedSymbols.isCached(symbolFunction)){
	visitedSymbols.setCachedValue(symbolFunction, process(f));
	}

	++f;
	}
	}

	InterpretationResolution
	InterpretationPass::process(const Expression& expression, PassContext context, const std::string& decl){
	recognizeTags(expression);

	InterpretationResolution resolution = ANY;
	InterpretationOperator op = NONE;

	switch (expression.__state){

	case Expression::NUMBER:
	case Expression::STRING: {
	break;
	}

	case Expression::IDENT: {
	resolution = Parent::processSymbol(Attachments::get<Symbol>(expression), context);
	break;
	}

	case Expression::COMPOUND:
	break;

	default: { resolution = CMPL_ONLY; break;}
	}

	if (expression.__state == Expression::COMPOUND)
	switch(expression.op){
	case Operator::EQU:
	case Operator::NE: {
	InterpretationResolution left = process(expression.operands[0], context);
	InterpretationResolution right = process(expression.operands[1], context);

	resolution = unify(left, right);
	break;
	}

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

	case Operator::CALL: {
	//TODO cope with static/dynamic context
	//TODO BUG here: if several variants they all are processed as CMPL careless of signature
	list<ManagedFnPtr> callees = man->root->getFunctionVariants(expression.getValueString());
	if (callees.size()!=1){
	resolution = CMPL_ONLY;
	break;
	}

	ManagedFnPtr callee = callees.front();
	const Symbol& symbCalleeFunc{ScopedSymbol::RetSymbol, callee->getEntryScope()};

	//recursion-aware processing:
	// - skip self recursion
	const Symbol& symbSelfFunc{ScopedSymbol::RetSymbol, context.function->getEntryScope()};
	if (!(symbSelfFunc == symbCalleeFunc)){
	InterpretationResolution resCallee = processFnCall(callee, context);
	assert(resCallee != FUNC_POSTPONED && "Indirect recursion detected: can't decide on interpretation resolution");

	resolution = unify(resolution, resCallee);
	}

	//check arguments compatibility
	const FunctionInterpretationData& calleeSignature = FunctionInterpretationHelper::getSignature(callee);
	for (size_t op=0, size = expression.operands.size(); op < size; ++op){
	const Expression &operand = expression.operands[op];
	InterpretationResolution argActual = process(operand, context);
	InterpretationResolution argExpected = calleeSignature.signature[op];

	//TODO use args unification result to properly process function call
	unify(argActual, argExpected);
	}

	if (FunctionInterpretationHelper::needPartialInterpretation(callee)){
	op= CALL_INTERPRET_PARTIAL;
	}

	break;
	}

	case Operator::IF:{
	InterpretationResolution flagCondition = process(expression.getOperands()[0], context);
	InterpretationResolution flagScope1 = Parent::process(expression.blocks.front(), context);
	InterpretationResolution flagScope2 = Parent::process(expression.blocks.back(), context);

	//special case: IF_INTERPRET_CONDITION
	if (checkConstraints<QUERY_INTR_ONLY>({flagCondition})){
	op= IF_INTERPRET_CONDITION;
	flagCondition = ANY;
	}

	resolution = unify(flagCondition, flagScope1, flagScope2);
	break;
	}

	case Operator::FOLD: {
	InterpretationResolution flagInput = process(expression.getOperands()[0], context);
	InterpretationResolution flagAccumInit = process(expression.getOperands()[1], context);

	CodeScope* scopeBody = expression.blocks.front();
	const std::string& nameEl = expression.bindings[0];
	Symbol symbEl{ScopedSymbol{scopeBody->__identifiers.at(nameEl), versions::VERSION_NONE}, scopeBody};
	getSymbolCache().setCachedValue(symbEl, InterpretationResolution(flagInput));

	const std::string& nameAccum = expression.bindings[1];
	Symbol symbAccum{ScopedSymbol{scopeBody->__identifiers.at(nameAccum), versions::VERSION_NONE}, scopeBody};
	getSymbolCache().setCachedValue(symbAccum, InterpretationResolution(flagAccumInit));

	InterpretationResolution flagBody = Parent::process(expression.blocks.front(), context);

	//special case: FOLD_INTERPRET_INPUT
	if (checkConstraints<QUERY_INTR_ONLY>({flagInput})){
	op= FOLD_INTERPRET_INPUT;
	flagInput = ANY;
	}

	resolution = unify(flagInput, flagAccumInit, flagBody);
	break;
	}

	case Operator::INDEX: {
	resolution = unify(
	process(expression.operands[0], context),
	process(expression.operands[1], context)
	);

	break;
	}

	case Operator::SWITCH: {
	InterpretationResolution flagCondition = process(expression.operands[0], context);
	bool hasDefaultCase = expression.operands[1].op == Operator::CASE_DEFAULT;


	//determine conditions resolution
	InterpretationResolution flagHeaders = flagCondition;
	for (size_t size = expression.operands.size(), i= hasDefaultCase? 2: 1; i<size; ++i){
	const Expression& exprCase = expression.operands[i];

	flagHeaders = unify(flagHeaders, Parent::process(exprCase.blocks.front(), context));
	}

	if (checkConstraints<QUERY_INTR_ONLY>({flagHeaders})){
	op= SWITCH_INTERPRET_CONDITION;
	flagHeaders = ANY;
	}

	//determine body resolutions
	resolution = flagHeaders;
	for (size_t size = expression.operands.size(), i= 1; i<size; ++i){
	const Expression& exprCase = expression.operands[i];

	resolution = unify(resolution, Parent::process(exprCase.blocks.back(), context));
	}

	break;
	}

	case Operator::SWITCH_VARIANT: {
	InterpretationResolution resolutionCondition = process(expression.operands.at(0), context);
	resolution= resolutionCondition;

	if (checkConstraints<QUERY_INTR_ONLY>({resolution})){
	op= SWITCH_VARIANT;
	resolution = ANY;
	}

	- const string identCondition = expression.operands.at(0).getValueString();
	+ const string identCondition = expression.bindings.front();
	for(auto scope: expression.blocks){
	//set binding resolution
	ScopedSymbol symbolInternal = scope->getSymbol(identCondition);
	getSymbolCache().setCachedValue(Symbol{symbolInternal, scope}, InterpretationResolution(resolutionCondition));

	resolution = unify(resolution, Parent::process(scope, context));
	}

	for(auto scope: expression.blocks){
	resolution = unify(resolution, Parent::process(scope, context));
	}
	break;
	}

	case Operator::LIST:
	case Operator::LIST_NAMED: {
	for (const Expression &op: expression.getOperands()) {
	resolution = unify(resolution, process(op, context));
	}

	break;
	}

	case Operator::VARIANT: {
	if(expression.getOperands().size()){
	resolution = process(expression.getOperands().front(), context);
	} else {
	resolution = ANY;
	}

	break;
	}

	default: {
	resolution = CMPL_ONLY;

	for (const Expression &op: expression.getOperands()) {
	process(op, context);
	}

	for (CodeScope* scope: expression.blocks) {
	Parent::process(scope, context);
	}

	break;
	}
	}

	InterpretationResolution resolutionExpected =
	Attachments::get<InterpretationData>(expression, {ANY, NONE}).resolution;

	resolution = unify(resolution, resolutionExpected);
	if (resolution != resolutionExpected && (op!=NONE \|\| resolution == INTR_ONLY)){
	Attachments::put<InterpretationData>(expression, {resolution, op});
	}

	return resolution;
	}

	InterpretationResolution
	InterpretationPass::processFnCall(ManagedFnPtr function, PassContext context){
	return process(function);
	}

	InterpretationResolution
	InterpretationPass::process(ManagedFnPtr function){
	CodeScope* entry = function->getEntryScope();
	std::vector<std::string> arguments = entry->__bindings;
	const Symbol& symbSelfFunc{ScopedSymbol::RetSymbol, function->getEntryScope()};
	auto& cache = getSymbolCache();

	if (cache.isCached(symbSelfFunc))
	return cache.getCachedValue(symbSelfFunc);

	const FunctionInterpretationData& fnSignature = FunctionInterpretationHelper::getSignature(function);
	InterpretationResolution fnResolutionExpected = details::recognizeTags(function->getTags());

	//mark preliminary function resolution as expected
	if (fnResolutionExpected != ANY){
	cache.setCachedValue(symbSelfFunc, move(fnResolutionExpected));

	} else {
	// - in order to recognize indirect recursion mark this function resolution as POSTPONED
	cache.setCachedValue(symbSelfFunc, FUNC_POSTPONED);
	}

	//set resolution for function arguments as expected
	for (int argNo = 0, size = arguments.size(); argNo< size; ++argNo){
	Symbol symbArg{ScopedSymbol{entry->__identifiers.at(arguments[argNo]), versions::VERSION_NONE}, entry};
	cache.setCachedValue(symbArg, InterpretationResolution(fnSignature.signature[argNo]));
	}

	PassContext context;
	context.function = function;
	context.scope = entry;
	InterpretationResolution resActual = process(CodeScope::getDeclaration(symbSelfFunc), context);
	resActual = unify(resActual, fnResolutionExpected);
	return cache.setCachedValue(symbSelfFunc, move(resActual));
	}

	const FunctionInterpretationData
	FunctionInterpretationHelper::getSignature(ManagedFnPtr function){
	if (Attachments::exists<FunctionInterpretationData>(function)){
	return Attachments::get<FunctionInterpretationData>(function);
	}

	FunctionInterpretationData&& data = recognizeSignature(function);
	Attachments::put<FunctionInterpretationData>(function, data);
	return data;
	}

	FunctionInterpretationData
	FunctionInterpretationHelper::recognizeSignature(ManagedFnPtr function){
	CodeScope* entry = function->__entry;
	FunctionInterpretationData result;
	result.signature.reserve(entry->__bindings.size());

	bool flagPartialInterpretation = false;
	for(size_t no=0, size=entry->__bindings.size(); no < size; ++no){
	const std::string& argName = entry->__bindings[no];
	Symbol symbArg{ScopedSymbol{entry->__identifiers.at(argName), versions::VERSION_NONE}, entry};

	const Expression& arg = CodeScope::getDeclaration(symbArg);

	InterpretationResolution argResolution = details::recognizeTags(arg.tags);
	flagPartialInterpretation \|= (argResolution == INTR_ONLY);

	result.signature.push_back(argResolution);
	}
	result.flagPartialInterpretation = flagPartialInterpretation;
	return result;
	}

	bool FunctionInterpretationHelper::needPartialInterpretation(ManagedFnPtr function){
	const FunctionInterpretationData& data = getSignature(function);
	return data.flagPartialInterpretation;
	}
	}} //end of namespace xreate::interpretation

	diff --git a/cpp/tests/interpretation.cpp b/cpp/tests/interpretation.cpp
	index 5cc7e99..1c1feb4 100644
	--- a/cpp/tests/interpretation.cpp
	+++ b/cpp/tests/interpretation.cpp
	@@ -1,411 +1,438 @@
	#include "attachments.h"

	using namespace xreate;

	#include "xreatemanager.h"
	#include "compilation/targetinterpretation.h"

	#include "gtest/gtest.h"
	#include "boost/scoped_ptr.hpp"

	//#define FRIENDS_INTERPRETATION_TESTS \
	// friend class ::Modules_AST2_Test; \
	// friend class ::Modules_Discovery1_Test; \
	// friend class ::Modules_Solve1_Test;

	#include "pass/interpretationpass.h"

	using namespace xreate::grammar::main;
	using namespace xreate::interpretation;

	TEST(Interpretation, Analysis_StatementIF_1){
	XreateManager* man = XreateManager::prepare(

	R"Code(
	main = function::bool {
	x = "a":: string.

	y = if (x=="b"):: bool; interpretation(force) {
	true

	} else {
	false
	}.

	y
	}
	)Code" );

	InterpretationPass* pass = new InterpretationPass(man);
	pass->run();

	CodeScope* scopeEntry = man->root->findFunction("main")->getEntryScope();
	Symbol symbolY{scopeEntry->getSymbol("y"), scopeEntry};
	InterpretationData& dataSymbolY = Attachments::get<InterpretationData>(symbolY);

	ASSERT_EQ(INTR_ONLY, dataSymbolY.resolution);
	}

	TEST(Interpretation, Compilation_StatementIF_1){
	xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(

	R"Code(
	main = function::int; entry {
	x = "a":: string.

	y = if (x=="b"):: string; interpretation(force) {
	1

	} else {
	0
	}.

	y
	}
	)Code" );

	man->analyse();

	InterpretationPass* pass;
	if (man->isPassRegistered(PassId::InterpretationPass)){
	pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
	} else {
	pass = new InterpretationPass(man);
	pass->run();
	}


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

	ASSERT_EQ(0, result);
	}

	TEST(Interpretation, Analysis_StatementIF_InterpretCondition_1){
	XreateManager* man = XreateManager::prepare(

	R"Code(
	main = function(x:: int):: int {
	comm= "inc":: string; interpretation(force).

	y = if (comm == "inc")::int {x+1} else {x}.
	y
	}
	)Code" );

	InterpretationPass* pass = new InterpretationPass(man);
	pass->run();

	CodeScope* scopeEntry = man->root->findFunction("main")->getEntryScope();
	Symbol symbolY{scopeEntry->getSymbol("y"), scopeEntry};
	InterpretationData& dataSymbolY = Attachments::get<InterpretationData>(symbolY);

	ASSERT_EQ(CMPL_ONLY, dataSymbolY.resolution);
	ASSERT_EQ(IF_INTERPRET_CONDITION, dataSymbolY.op);
	}

	TEST(Interpretation, Compilation_StatementIF_InterpretCondition_1){
	xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(

	R"Code(
	main = function(x:: int):: int; entry {
	comm= "inc":: string; interpretation(force).

	y = if (comm == "inc")::int {x+1} else {x}.
	y
	}
	)Code" );

	man->analyse();

	InterpretationPass* pass;
	if (man->isPassRegistered(PassId::InterpretationPass)){
	pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
	} else {
	pass = new InterpretationPass(man);
	pass->run();
	}

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

	ASSERT_EQ(2, result);
	}

	TEST(Interpretation, Compilation_StatementFOLD_INTERPRET_INPUT_1){
	xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(

	R"Code(
	main = function(x:: int):: int; entry {
	commands = ["inc", "double", "dec"]:: [string]; interpretation(force).

	loop fold(commands->comm::string, x->operand):: int{
	switch(comm)::int

	case ("inc"){
	operand + 1
	}

	case ("dec"){
	operand - 1
	}

	case ("double"){
	operand * 2
	}
	}
	}
	)Code" );

	man->analyse();

	InterpretationPass* pass;
	if (man->isPassRegistered(PassId::InterpretationPass)){
	pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
	} else {
	pass = new InterpretationPass(man);
	pass->run();
	}

	const ManagedFnPtr& funcMain = man->root->findFunction("main");
	InterpretationData& dataBody = Attachments::get<InterpretationData>(funcMain);
	ASSERT_EQ(FOLD_INTERPRET_INPUT, dataBody.op);

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

	ASSERT_EQ(21, result);
	}

	TEST(Interpretation, StatementCall_RecursionNo_1){
	xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
	R"Code(
	unwrap = function(data::undef, keys::undef):: undef; interpretation(force){
	loop fold(keys->key::string, data->a):: undef {
	a[key]
	}
	}

	start = function::num; entry{
	result = unwrap(
	{
	a = {
	b =
	{
	c = "core"
	}
	}
	}, ["a", "b", "c"])::undef.

	result == "core"
	}
	)Code" );

	man->analyse();

	InterpretationPass* pass;
	if (man->isPassRegistered(PassId::InterpretationPass)){
	pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
	} else {
	pass = new InterpretationPass(man);
	pass->run();
	}

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

	ASSERT_EQ(1, result);
	}

	TEST(Interpretation, StatementCall_RecursionDirect_1){
	xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
	R"Code(
	unwrap = function(data:: X):: Y {
	if (data[0] == "a")::Y {0} else {unwrap(data[0])}
	}

	entry = function:: i8; entry {
	unwrap([[[["a"]]]]):: i8; interpretation(force)
	}
	)Code" );

	man->analyse();

	InterpretationPass* pass;
	if (man->isPassRegistered(PassId::InterpretationPass)){
	pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
	} else {
	pass = new InterpretationPass(man);
	pass->run();
	}

	InterpretationResolution resolutionActual = pass->process(man->root->findFunction("unwrap"));
	ASSERT_EQ(ANY, resolutionActual);

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

	ASSERT_EQ(0, result);
	}

	TEST(Interpretation, StatementCall_RecursionIndirect_1){
	XreateManager* man = XreateManager::prepare(
	R"Code(
	funcA = function(data:: X):: Y {
	if (data == "a")::Y {0} else {funcB(data)}
	}

	funcB = function(data:: X):: Y {
	if (data == "b")::Y {1} else {funcA(data)}
	}

	entry = function:: i8; entry {
	funcA(""):: i8; interpretation(force)
	}
	)Code" );

	InterpretationPass* pass = new InterpretationPass(man);
	ASSERT_DEATH(pass->run(), "Indirect recursion detected");
	}

	TEST(Interpretation, PartialIntr_1){
	XreateManager* man = XreateManager::prepare(
	R"Code(
	evaluate= function(argument:: num, code:: string; interpretation(force)):: num {
	switch(code)::int
	case ("inc") {argument + 1}
	case ("dec") {argument - 1}
	case ("double") {argument * 2}
	}

	main = function::int; entry {
	commands= ["inc", "double", "dec"]:: [string]; interpretation(force).

	loop fold(commands->comm::string, 10->operand):: int{
	evaluate(operand, comm)
	}
	}
	)Code" );

	InterpretationPass* pass = new InterpretationPass(man);
	pass->run();

	ManagedFnPtr fnEvaluate = man->root->findFunction("evaluate");
	InterpretationResolution resFnEvaluate= pass->process(fnEvaluate);
	ASSERT_EQ(CMPL_ONLY, resFnEvaluate);
	ASSERT_TRUE(FunctionInterpretationHelper::needPartialInterpretation(fnEvaluate));

	const Expression& exprLoop = man->root->findFunction("main")->__entry->getBody();
	Symbol symbCallEv{{0, versions::VERSION_NONE}, exprLoop.blocks.front()};
	InterpretationData dataCallEv = Attachments::get<InterpretationData>(symbCallEv);
	ASSERT_EQ(CMPL_ONLY, dataCallEv.resolution);
	ASSERT_EQ(CALL_INTERPRET_PARTIAL, dataCallEv.op);
	}

	TEST(Interpretation, Compilation_PartialIntr_2){
	xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
	R"Code(
	evaluate= function(argument:: num, code:: string; interpretation(force)):: num {
	switch(code)::int
	case ("inc") {argument + 1}
	case ("dec") {argument - 1}
	case ("double") {argument * 2}
	case default {argument}
	}

	main = function::int; entry {
	commands= ["inc", "double", "dec"]:: [string]; interpretation(force).

	loop fold(commands->comm::string, 10->operand):: int{
	evaluate(operand, comm)
	}
	}
	)Code" );

	man->analyse();
	if (!man->isPassRegistered(PassId::InterpretationPass)){
	InterpretationPass* pass = new InterpretationPass(man);
	pass->run();
	}

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

	ASSERT_EQ(21, result);
	}

	TEST(Interpretation, PartialIntr_3){
	xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
	R"Code(
	Command= type variant {INC, DEC, DOUBLE}.

	evaluate= function(argument:: num, code:: Command; interpretation(force)):: num {
	switch variant(code)::int
	case (INC) {argument + 1}
	case (DEC) {argument - 1}
	case (DOUBLE) {argument * 2}
	}

	main = function::int; entry {
	commands= [INC(), DOUBLE(), DEC()]:: [Command]; interpretation(force).

	loop fold(commands->comm::Command, 10->operand):: int{
	evaluate(operand, comm)
	}
	}
	)Code" );

	man->analyse();
	if (!man->isPassRegistered(PassId::InterpretationPass)){
	InterpretationPass* pass = new InterpretationPass(man);
	pass->run();
	}

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

	ASSERT_EQ(21, result);
	}

	TEST(Interpretation, SwitchVariant){
	xreate::XreateManager* man = xreate::XreateManager::prepare(
	R"Code(
	OneArgument = type{x::int}.
	TWoArgument = type {x::int, y::int}.

	Command= type variant {
	ADD::TwoArguments,
	DEC:: OneArgument,
	DOUBLE::OneArgument
	}.

	main = function::int; entry{
	program = ADD({x=2, y=3})::Command; interpretation(force).

	switch variant(program)::int
	case (ADD) {program["x"]+program["y"]}
	case (DEC) {1}
	case (DOUBLE) {2}
	}
	)Code" );

	int (main)() = (int ()())man->run();
	int result = main();
	ASSERT_EQ(5, result);

	}

	+TEST(Interpretation, SwitchVariantAlias){
	+ xreate::XreateManager* man = xreate::XreateManager::prepare(
	+R"Code(
	+OneArgument = type{x::int}.
	+TWoArgument = type {x::int, y::int}.
	+
	+Command= type variant {
	+ ADD::TwoArguments,
	+ DEC:: OneArgument,
	+ DOUBLE::OneArgument
	+}.
	+
	+main = function::int; entry{
	+ program = [ADD({x=2, y=3}), DEC({x=8})]::Command; interpretation(force).
	+
	+ switch variant(program[0]->program)::int
	+ case (ADD) {program["x"]+program["y"]}
	+ case (DEC) {1}
	+ case (DOUBLE) {2}
	+}
	+)Code" );
	+
	+ int (main)() = (int ()())man->run();
	+ int result = main();
	+ ASSERT_EQ(5, result);
	+}
	+
	TEST(InterpretationExamples, Regexp1){
	FILE* input = fopen("scripts/dsl/regexp.xreate","r");
	assert(input != nullptr);

	std::unique_ptr<XreateManager> man(XreateManager::prepare(input));

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

	ASSERT_EQ(4, result);
	}

	//TOTEST call indirect recursion(w/o tags)
	//TASk implement and test Loop Inf (fix acc types in coco grammar)
	diff --git a/grammar/xreate.ATG b/grammar/xreate.ATG
	index 11b2fa1..f534db7 100644
	--- a/grammar/xreate.ATG
	+++ b/grammar/xreate.ATG
	@@ -1,639 +1,653 @@
	//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::incomplete::AST* root = nullptr; // current program unit

	void ensureInitalizedAST(){
	if (root == nullptr) root = new details::incomplete::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
	\| 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> (. 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.

	/**
	* 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::ARRAY, {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::STRUCT, {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::STRUCT, {}); 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> (. f->addDeclaration(move(var), move(value)); .)
	.

	BDecl<CodeScope* scope> = lcurbrack (. Expression body; pushContextScope(scope); .)
	{(IF(checkAssignment()) VDecl<scope> '.'
	\| RuleContextDecl<scope>
	\| ContextDecl<scope>'.'
	\| ExprTyped<body> (. scope->setBody(body); .)
	)}
	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> BDecl<&*block>
	- (.
	- e.addBindings({Atom<Identifier_t>(varEl)});
	- block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
	- e.addBlock(block);
	- .)
	+ 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>
	- (.
	- block->addBinding(Atom<Identifier_t>(varAcc), Expression());
	- e.addBlock(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 Expr<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; expr = Expression(Operator::SWITCH_VARIANT, {}); .)
	+ (. Expression varTested; std::wstring varAlias; bool flagAliasFound = false; expr = Expression(Operator::SWITCH_VARIANT, {}); .)

	- "variant" lparen VarIdent<varTested> rparen tagcolon ExprAnnotations<expr>
	- (. recognizeIdentifier(varTested); expr.addArg(std::move(varTested)); .)
	+ "variant" lparen Expr<varTested> [implic Ident<varAlias>
	+ (. flagAliasFound = true; .)
	+
	+ ] rparen tagcolon ExprAnnotations<expr>
	+ (. expr.addArg(std::move(varTested));
	+ if (flagAliasFound) {
	+ expr.addBindings({Atom<Identifier_t>(varAlias)});
	+
	+ } else {
	+ if(varTested.__state != Expression::IDENT){
	+ SemErr(coco_string_create("Switch variant expects identifier"));
	+
	+ }
	+
	+ 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(Expression(expr.operands.at(0)), Expression()); .)
	+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 .

	/============================ 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>
	[lbrack (. e = Expression(Operator::INDEX, {e}); .)
	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>
	\| 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