File Metadata

Created: Tue, Jul 7, 9:29 PM

cfagraph.cpp
View Options

	/*
	* File: CFAGraph.cpp
	* Author: pgess
	*
	* Created on June 27, 2016, 2:09 PM
	*/

	#include "analysis/cfagraph.h"
	#include "analysis/aux.h"

	using namespace xreate::analysis;
	using namespace std;

	void
	CFAGraph::print(std::ostringstream& output) const {
	const std::string& atomBinding = Config::get("clasp.bindings.function");
	const std::string& atomBindingScope = Config::get("clasp.bindings.scope");

	//show function tags
	int counterTags = 0;
	std::ostringstream bufFunctionNames;
	boost::format formatFunction("function(%1%).");
	boost::format formatBind(atomBinding + "(%1%, %2%).");
	for (auto function: this->__nodesFunction.left) {
	const auto tags = this->__functionTags.equal_range(function.first);
	if (tags.first == tags.second) {
	//no tags
	bufFunctionNames << "; " << function.second ;
	continue;
	}

	output << formatFunction % (function.second) << std::endl;
	for (const auto& tag_: boost::make_iterator_range(tags)){
	const Expression& tag = tag_.second;

	list<string> tagRaw = xreate::analysis::compile(tag);
	assert(tagRaw.size() == 1);

	output << formatBind
	% (function.second)
	% (tagRaw.front())
	<< endl;
	++counterTags;
	}
	}

	if (bufFunctionNames.tellp()){
	output << formatFunction % (bufFunctionNames.str().substr(2)) << std::endl;
	}

	if (counterTags == 0) {
	output << "%no functtion tags at all" << endl;
	}

	//declare scopes
	boost::format formatScope("scope(0..%1%).");
	output << formatScope % (__clasp->getScopesCount() - 1) << std::endl;

	//show context rules:
	for (auto rule: this->__contextRules) {
	output << ContextRule(rule.second).compile(rule.first) << std::endl;
	};

	//show scope tags:
	counterTags = 0;
	boost::format formatScopeBind(atomBindingScope + "(%1%, %2%, strong).");
	for (auto entry: this->__scopeTags) {
	ScopePacked scopeId = entry.first;
	const Expression& tag = entry.second;
	list<string> tagRaw = xreate::analysis::compile(tag);
	assert(tagRaw.size() == 1);

	output << formatScopeBind % scopeId %(tagRaw.front()) << endl;
	++counterTags;
	}

	if (counterTags == 0) {
	output << "%scope tags: no tags at all" << endl;
	}

	output << endl << "%\t\tStatic analysis: CFA" << endl;

	//parent connections
	//TOTEST CFG parent function
	boost::format formatFunctionParent("cfa_parent(%1%, function(%2%)).");
	for (const auto &relation: this->__parentFunctionRelations) {
	const string& function = this->__nodesFunction.left.at(relation.right);

	output << formatFunctionParent % relation.left % function << endl;
	}

	//TOTEST CFG parent scope
	boost::format formatScopeParent("cfa_parent(%1%, scope(%2%)).");
	for (const auto &relation: this->__parentScopeRelations) {
	output << formatScopeParent % relation.first % relation.second << endl;
	}

	//call connections
	boost::format formatCall("cfa_call(%1%, %2%).");

	for (const auto &relation: this->__callRelations) {
	const ScopePacked scopeFrom = relation.left;
	const string& functionTo = this->__nodesFunction.left.at(relation.right);

	output << formatCall % (scopeFrom) % (functionTo) << endl;
	}

	//function specializations descrtiption
	//SECTIONTAG late-context cfa_function_specializations
	boost::format formatSpecializations("cfa_function_specializations(%1%, %2%).");
	const list<ManagedFnPtr>& functions = __clasp->ast->getAllFunctions();
	for (auto f: functions){
	if (f->guardContext.isValid()){
	list<string> guardRaw = xreate::analysis::compile(f->guardContext);
	assert(guardRaw.size() == 1);
	output << formatSpecializations % (f->getName()) % (guardRaw.front()) << endl;
	}
	}
	}

	void
	CFAGraph::addFunctionAnnotations(const std::string& function, const std::map<std::string, Expression>& tags) {
	unsigned int fid = registerNodeFunction(function);

	for (auto& tag: tags){
	__functionTags.emplace(fid, tag.second);
	}
	}

	void
	CFAGraph::addScopeAnnotations(const ScopePacked& scope, const std::vector<Expression>& tags){
	for (Expression tag: tags){
	__scopeTags.emplace(scope, tag);
	}
	}

	void
	CFAGraph::addContextRules(const ScopePacked& scope, const std::vector<Expression>& rules){
	for (Expression rule: rules){
	__contextRules.emplace(scope, rule);
	}
	}

	void
	CFAGraph::addCallConnection(const ScopePacked& scopeFrom, const std::string& functionTo) {
	unsigned int idFuncTo = registerNodeFunction(functionTo);

	__callRelations.insert(CALL_RELATIONS::value_type(scopeFrom, idFuncTo));
	}

	void
	CFAGraph::addParentConnection(const ScopePacked& scope, const std::string& functionParent){
	__parentFunctionRelations.insert(PARENT_FUNCTION_RELATIONS::value_type(scope, registerNodeFunction(functionParent)));
	}

	void
	CFAGraph::addParentConnection(const ScopePacked& scope, const ScopePacked& scopeParent){
	__parentScopeRelations.emplace(scope, scopeParent);
	}

	unsigned int
	CFAGraph::registerNodeFunction(const std::string& fname){
	auto pos = __nodesFunction.left.insert(make_pair(__nodesFunction.size(), fname));

	return pos.first->first;
	}

cfagraph.cpp
No OneTemporary
Actions

File Metadata

cfagraph.cpp
View Options

Event Timeline

cfagraph.cppNo OneTemporaryActions

File Metadata

cfagraph.cppView Options

Event Timeline

cfagraph.cpp
No OneTemporary
Actions

cfagraph.cpp
View Options