File Metadata

Created: Thu, Jul 9, 4:46 AM

adhocpass.cpp
View Options

	/*
	* adhoc.cpp
	*
	* Created on: Nov 28, 2015
	* Author: pgess
	*/

	#include "pass/adhocpass.h"
	#include "query/context.h"

	//TODO use ADT/templated types rather than adhocs. remove adhocs.
	namespace xreate { namespace adhoc {

	AdhocExpression::AdhocExpression(): Expression(Operator::ADHOC, {})
	{}

	AdhocExpression::AdhocExpression(const Expression& base): Expression(base)
	{}

	void
	AdhocExpression::setCommand(const Expression& comm){
	this->addTags({Expression(Operator::CALL, {Atom<Identifier_t>("adhoc"), comm})});
	}

	Expression
	AdhocExpression::getCommand() const{
	assert(this->tags.count("adhoc"));
	return this->tags.at("adhoc").getOperands().at(0);
	}

	AdhocScheme*
	AdhocPass::findAssotiatedScheme(CodeScope* entry){
	const ScopePacked scopeId = man->clasp->pack(entry);
	const context::Domain& domain = queryContext->getContext(scopeId);
	AdhocScheme* scheme = nullptr;

	for (const Expression& context: domain){
	if (!(context.__state == Expression::COMPOUND && context.op == Operator::CALL)) continue;

	if (__schemes.count(context.getValueString())){
	assert(!scheme && "Can't determine relevant scheme, ambiguous context");
	scheme = __schemes.at(context.getValueString());
	}
	}

	assert(scheme && "Context doesn't define any ad hoc scheme");
	return scheme;
	}

	const TypeAnnotation&
	AdhocScheme::getResultType(){
	return __resultType;
	}

	CodeScope*
	AdhocScheme::getCommandImplementation(const Expression& comm) {
	assert(comm.__state == Expression::COMPOUND && comm.op == Operator::CALL && comm.operands.size() == 0);

	const std::string commSerialized = comm.getValueString();
	assert(__commands.count(commSerialized) && "Command isn't defined for a selected scheme");
	return __commands.at(commSerialized);
	}

	AdhocScheme::AdhocScheme(const Expression& scheme):
	__resultType(scheme.type), __name(scheme.getValueString()) {

	Expression exprCasesList = scheme.getOperands()[0];
	for (const Expression& exprSingleCase: exprCasesList.getOperands()){
	std::string command = exprSingleCase.tags.begin()->second.getValueString();

	CodeScope* blockImpl = *(exprSingleCase.blocks.begin());
	__commands.emplace(command, blockImpl);
	}
	}

	const std::string&
	AdhocScheme::getName(){
	return __name;
	}

	void
	AdhocPass::run(){
	queryContext = reinterpret_cast<context::ContextQuery*>(man->clasp->registerQuery(new context::ContextQuery(), QueryId::ContextQuery));

	auto range = man->root->__interfacesData.equal_range(ASTInterface::Adhoc);
	for (auto i=range.first; i!= range.second; ++i){
	AdhocScheme* scheme = new AdhocScheme(i->second);
	__schemes.emplace(scheme->getName(), scheme);
	}
	}

	}} //end of namespace xreate::adhoc

adhocpass.cpp
No OneTemporary
Actions

File Metadata

adhocpass.cpp
View Options

Event Timeline

adhocpass.cppNo OneTemporaryActions

File Metadata

adhocpass.cppView Options

Event Timeline

adhocpass.cpp
No OneTemporary
Actions

adhocpass.cpp
View Options