transcendlayer.cpp
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Jul 7, 4:35 PM

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

	/**
	* \file transcendlayer.h
	* \brief Transcend reasoning implementation
	*/

	#include "transcendlayer.h"
	#include "analysis/utils.h"
	#include "utils.h"

	#include <gringo/scripts.hh>
	#include <boost/format.hpp>
	#include <boost/algorithm/string/join.hpp>
	#include <iostream>
	#include <memory>
	#include <boost/variant/detail/apply_visitor_binary.hpp>

	using namespace std;

	//TODO escape identifiers started with upper case symbol

	namespace xreate{

	bool operator==(const SymbolAnonymous& s1, const SymbolAnonymous& s2) {
	return s1.id == s2.id && s1.flagIsUsed == s2.flagIsUsed;
	}

	struct VisitorSymbolNodeHash : public boost::static_visitor<size_t>{

	std::size_t operator()(const xreate::SymbolPacked& node) const noexcept {
	return 2 * (node.identifier + 3 * node.scope + 5 * std::abs(node.version));
	}

	std::size_t operator()(const xreate::SymbolAnonymous& node) const noexcept {
	return 7 * node.id;
	}
	} ;
	}

	namespace std{

	std::size_t
	hash<xreate::SymbolNode>::operator()(xreate::SymbolNode const& s) const noexcept {
	return boost::apply_visitor(xreate::VisitorSymbolNodeHash(), s);
	}

	std::size_t
	hash<xreate::SymbolGeneralized>::operator()(xreate::SymbolGeneralized const& s) const noexcept {
	return xreate::AttachmentsId<xreate::SymbolGeneralized>::getId(s);
	}
	}

	namespace xreate{

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

	auto warningsModel = query(warningTag);

	if(warningsModel.size())
	for(auto warning : warningsModel) {
	unsigned int warningId;

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

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

	bool
	TranscendLayer::processSolution(Gringo::Model const &model) {
	cout << "Model: " << endl;

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

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

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

	__model.emplace(atomName, atom);
	}

	return true;
	}

	void
	TranscendLayer::registerReport(IAnalysisReport * report) {
	__reports.push_back(report);
	}

	void
	TranscendLayer::printReports() {
	for(IAnalysisReport* report : __reports) {
	report->print(__partGeneral);
	}
	}

	void
	TranscendLayer::deleteReports(){
	for(IAnalysisReport* report : __reports) {
	delete report;
	}
	__reports.clear();
	}

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

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

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

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

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

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

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

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

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

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

	if(ast)
	for(string fn : ast->__rawImports) {
	std::ifstream file(fn);
	if(!file) {
	std::cout << "Can't process script file: " << fn << std::endl;
	assert(false);
	}

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

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

	void
	TranscendLayer::run() {
	involveImports();
	printReports();

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

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

	ClingoLib ctl(scriptsDefault, 0, args.data(), { }, 0);

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

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

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

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

	TranscendLayer::TranscendLayer() : ast(nullptr) { }

	StaticModel
	TranscendLayer::query(const std::string & atom) const {
	StaticModel result;

	if (! __model.count(atom)) {
	return result;
	}

	auto currentDataRange = __model.equal_range(atom);
	std::copy(currentDataRange.first, currentDataRange.second, std::inserter(result, result.end()));
	return result;
	}

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

	return pos.first->second;
	}

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

	SymbolPacked
	TranscendLayer::pack(const Symbol& symbol, std::string hintSymbolName) {
	SymbolPacked result(symbol.identifier.id, symbol.identifier.version, pack(symbol.scope));
	__indexSymbolNameHints.emplace(result, hintSymbolName);

	return result;
	}

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

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

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

	IQuery *
	TranscendLayer::getQuery(const QueryId & id) {
	assert(__queries.count(id) && "Undefined query");
	return __queries.at(id);
	}

	class VisitorUnpackSymbol : public boost::static_visitor<SymbolGeneralized>{
	public:

	VisitorUnpackSymbol(const TranscendLayer* transcend) : __transcend(transcend) { }

	SymbolGeneralized operator()(const SymbolPacked& symbol) const {
	return __transcend->unpack(symbol);
	}

	SymbolGeneralized operator()(const SymbolAnonymous& symbol) const {
	return symbol;
	}

	private:
	const TranscendLayer* __transcend;
	} ;

	class VisitorPackSymbol : public boost::static_visitor<SymbolNode>{
	public:

	VisitorPackSymbol(TranscendLayer* transcend, const std::string& hintSymbolName)
	: __transcend(transcend), __hint(hintSymbolName) { }

	SymbolNode operator()(const Symbol& symbol) const {
	return __transcend->pack(symbol, __hint);
	}

	SymbolNode operator()(const SymbolAnonymous& symbol) const {
	return symbol;
	}

	private:
	TranscendLayer* __transcend;
	std::string __hint;
	} ;

	SymbolNode
	TranscendLayer::pack(const SymbolGeneralized& symbol, const std::string & hintSymbolName) {
	return boost::apply_visitor(VisitorPackSymbol(this, hintSymbolName), symbol);
	}

	SymbolGeneralized
	TranscendLayer::unpack(const SymbolNode & symbol) const {
	return boost::apply_visitor(VisitorUnpackSymbol(this), symbol);
	}

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

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

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

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

	return result;
	}

	default:
	{
	assert(false);
	}
	}
	}

	int
	ParseImplAtom<int>
	::get(const Gringo::Symbol & atom) {
	switch(atom.type()) {
	case Gringo::SymbolType::Num: return atom.num();
	default: break;
	}

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

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

	default: break;
	}

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

	SymbolPacked
	ParseImplAtom<SymbolPacked>
	::get(const Gringo::Symbol & atom) {
	auto result = TranscendLayer::parse<int, int, int>(atom);
	return SymbolPacked(std::get<0>(result), std::get<1>(result), std::get<2>(result));
	};

	Gringo::Symbol
	ParseImplAtom<Gringo::Symbol>
	::get(const Gringo::Symbol & atom) {
	return atom;
	}

	SymbolNode
	ParseImplAtom<SymbolNode>
	::get(const Gringo::Symbol & atom) {
	assert(atom.type() == Gringo::SymbolType::Fun
	&& "Inappropriate symbol type");

	if(atom.name() == "a") {
	return SymbolAnonymous{(unsigned int) std::get<0>(TranscendLayer::parse<int>(atom))};

	} else if(atom.name() == "s") {
	return ParseImplAtom<SymbolPacked>::get(atom);
	}

	assert(false && "Wrong symbol format");
	}

	class VisitorSymbolId : public boost::static_visitor<unsigned int>{
	public:

	unsigned int operator()(const Symbol& symbol) const {
	return AttachmentsId<Symbol>::getId(symbol);
	}

	unsigned int operator()(const SymbolAnonymous& symbol) const {
	return symbol.id;
	}
	} ;

	unsigned int
	AttachmentsId<SymbolGeneralized>
	::getId(const SymbolGeneralized & symbol) {
	return boost::apply_visitor(VisitorSymbolId(), symbol);
	}

	} //end of xreate namespace

	/**
	* \class xreate::TranscendLayer
	* \brief Logic reasoning implementation. Internally, it's a proxy to the external ASP solver [Clasp](https://potassco.org/clasp/)
	*
	* Performs reasoning over source codes in order to facilitate efficient compilation using results from a number of internal analyzers.
	* Clients implement \ref IAnalysisReport to supply Transcend with data and implement \ref IQuery to find out resolutions.
	*
	* Transcend uses the following sources to build a logic program before actual reasoning is performed:
	* - Raw content. Clients are free to include arbitrary ASP format data in the logic program. See \ref addRawScript().
	* - External scripts. External files with ASP scripts can be appended to the logic program. See `involveImports()` (private member).
	* - Diagnostic rules to produce diagnostic messages during
	* compilation(warnings) or even to signal to halt compilation with errors. See \ref addRuleWarning(), \ref registerWarning().
	* - Internal analyzers. The analyzer can publish logic facts and rules by implementing \ref IAnalysisReport interface.
	*
	* Generally, Transcend input could be loosely broke down into three categories:
	* - Internally derived data. CFA, DFA, and other analyzers automatically supply the reasoner with
	* useful insights about source codes, the structure and algorithms of a program.
	* - User provided custom data. Analyzers extract manual developer-provided annotations from the source codes.
	* - External data. External files supply reasoner with third-party data
	* which relates to different aspects of a program possibly produced by external analyzers.
	*
	* After Transcend has gathered data from all providers and the logic program is fully constructed,
	* it runs the external logic reasoner to receive back the solution.
	*
	* The solution from the external logic reasoner is accessible via queries.
	* Classes which want to request data from Transcend should implement the \ref IQuery interface. See \ref IQuery descendants to find out currently available queries.
	*
	* \section tl_adapt Adaptability
	* Decorators are used to extend %TranscendLayer functionality. The default bundle defined by \ref DefaultTranscendLayerImpl.
	*
	* \sa See xreate::dfa::DFAPass, xreate::cfa::CFAPass, xreate::IQuery, xreate::IAnalysisReport
	*/

transcendlayer.cppNo OneTemporaryActions

File Metadata

transcendlayer.cppView Options

Event Timeline

transcendlayer.cpp
No OneTemporary
Actions

transcendlayer.cpp
View Options