interpretationpass.cpp
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Jul 8, 5:07 AM

interpretationpass.cpp
View Options

	/* 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: interpretationpass.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* 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.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

interpretationpass.cppNo OneTemporaryActions

File Metadata

interpretationpass.cppView Options

Event Timeline

interpretationpass.cpp
No OneTemporary
Actions

interpretationpass.cpp
View Options