File Metadata

Created: Wed, Jul 8, 7:41 AM

targets.h
View Options

	/*
	* File: targetabstract.h
	* Author: pgess
	*
	* Created on July 2, 2016, 1:25 PM
	*/

	#ifndef TARGETABSTRACT_H
	#define TARGETABSTRACT_H
	#include "ast.h"

	#include <boost/optional.hpp>
	#include <map>

	namespace xreate{ namespace compilation {

	template <typename ConcreteTarget>
	struct TargetInfo{
	//typedef Result
	//typedef Function
	//typedef Scope
	};

	template<typename ConcreteTarget>
	class Function;

	template<typename ConcreteTarget>
	class Target;

	template<typename ConcreteTarget>
	class Scope{
	public:
	CodeScope* scope;

	typename TargetInfo<ConcreteTarget>::Result
	processSymbol(const Symbol& s){
	CodeScope* scope = s.scope;
	typename TargetInfo<ConcreteTarget>::Scope* self = function->getScope(scope);

	if (self->__bindings.count(s.identifier)) {
	return self->__bindings[s.identifier];
	}

	const Expression& declaration = CodeScope::findDeclaration(s);
	if (!declaration.isDefined()){
	assert(false); //for bindings there should be result already
	}

	return self->__bindings[s.identifier] = self->process(declaration);
	}

	typename TargetInfo<ConcreteTarget>::Result
	processScope() {
	if (raw) return *raw;

	raw = process(scope->__body);
	return *raw;
	}

	virtual typename TargetInfo<ConcreteTarget>::Result
	process(const Expression& expression)=0;

	Scope(CodeScope* codeScope, Function<ConcreteTarget>* f)
	: scope(codeScope), function(f) {}

	virtual ~Scope(){}

	void
	bindArg(typename TargetInfo<ConcreteTarget>::Result arg, const std::string& name){
	assert(scope->__identifiers.count(name));

	VID id = scope->__identifiers.at(name);
	__bindings[id] = arg;

	//reset the result if any:
	raw.reset();
	}

	protected:
	Function<ConcreteTarget>* function;
	std::map<VID, typename TargetInfo<ConcreteTarget>::Result> __bindings;
	typename boost::optional<typename TargetInfo<ConcreteTarget>::Result> raw;

	//ResultType findFunction(const std::string& callee);
	};

	template<typename ConcreteTarget>
	class Function{
	typedef typename TargetInfo<ConcreteTarget>::Result Result;

	public:
	Function(const ManagedFnPtr& function, Target<ConcreteTarget>* target)
	: man(target), __function(function) {}

	typename TargetInfo<ConcreteTarget>::Scope*
	getScope(CodeScope* scope){
	if (!__scopes.count(scope)){
	typename TargetInfo<ConcreteTarget>::Scope* unit = new typename TargetInfo<ConcreteTarget>::Scope(scope, this);
	__scopes.emplace(scope, std::unique_ptr<typename TargetInfo<ConcreteTarget>::Scope>(unit));
	}

	return __scopes.at(scope).get();
	}

	virtual Result
	process(const std::vector<Result>& args)=0;

	Target<ConcreteTarget>* man;

	protected:
	ManagedFnPtr __function;


	std::map<CodeScope*, std::unique_ptr<typename TargetInfo<ConcreteTarget>::Scope>> __scopes;
	};

	template<typename ConcreteTarget>
	class Target {
	typedef typename TargetInfo<ConcreteTarget>::Function ConcreteFunction;

	public:
	Target(AST* root): ast(root){}

	ConcreteFunction*
	getFunction(const ManagedFnPtr& function){
	unsigned int id = function.id();

	if (!__functions.count(id)){
	ConcreteFunction* unit = new ConcreteFunction(function, this);
	__functions.emplace(id, std::unique_ptr<ConcreteFunction>(unit));
	return unit;
	}

	return __functions.at(id).get();
	}

	AST* ast;

	private:
	std::map<unsigned int, std::unique_ptr<ConcreteFunction>> __functions;
	};

	}}

	#endif /* TARGETABSTRACT_H */

targets.h
No OneTemporary
Actions

File Metadata

targets.h
View Options

Event Timeline

targets.hNo OneTemporaryActions

File Metadata

targets.hView Options

Event Timeline

targets.h
No OneTemporary
Actions

targets.h
View Options