File Metadata

Created: Tue, Jul 7, 7:37 PM

targetinterpretation.h
View Options

	/*
	* To change this license header, choose License Headers in Project Properties.
	* To change this template file, choose Tools \| Templates
	* and open the template in the editor.
	*/

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

	#ifndef TARGETSTATIC_H
	#define TARGETSTATIC_H

	#include "ast.h"
	#include "pass/compilepass.h"
	#include "compilation/targets.h"
	#include "pass/interpretationpass.h"

	namespace xreate{ namespace interpretation{
	class TargetInterpretation;
	class InterpretationScope;
	class InterpretationFunction;
	}}

	namespace xreate{ namespace compilation{
	template <>
	struct TargetInfo<interpretation::TargetInterpretation> {
	typedef Expression Result;
	typedef interpretation::InterpretationScope Scope;
	typedef interpretation::InterpretationFunction Function;
	};
	}}

	namespace xreate{ namespace interpretation{
	class InterpretationScope: public compilation::Scope<TargetInterpretation>{
	typedef Scope<TargetInterpretation> Parent;

	public:
	InterpretationScope(CodeScope* scope, compilation::Function<TargetInterpretation>* f): Parent(scope, f) {}
	Expression process(const Expression& expression) override;

	llvm::Value* compile(const Expression& expression, const compilation::Context& context);

	private:
	llvm::Value* compileHybrid(const InterpretationOperator& op, const Expression& expression, const compilation::Context& context);
	//llvm::Value* compilePartialFnCall(const Expression& expression, const Context& context);

	CodeScope* processOperatorIf(const Expression& expression);
	CodeScope* processOperatorSwitch(const Expression& expression);
	};

	class InterpretationFunction: public compilation::Function<TargetInterpretation>{
	public:
	InterpretationFunction(const ManagedFnPtr& function, compilation::Target<TargetInterpretation>* target);
	Expression process(const std::vector<Expression>& args);
	};

	/*
	* Partially interpreted function signature
	*/
	struct PIFSignature{
	ManagedFnPtr declaration;
	std::vector<Expression> bindings;
	};

	class PIFunctionUnit;

	class PIFunction: public InterpretationFunction{
	public:
	PIFunctionUnit* functionUnit;
	PIFSignature signatureInstance;

	PIFunction(PIFSignature&& sig, size_t id, TargetInterpretation* target);
	llvm::Function* compile();
	};

	bool operator<(const PIFSignature& lhs, PIFunction* const rhs);
	bool operator<(PIFunction* const lhs, const PIFSignature& rhs);

	class TargetInterpretation: public compilation::Target<TargetInterpretation>{
	public:
	TargetInterpretation(AST* root, CompilePass* passCompilation): Target<TargetInterpretation>(root), pass(passCompilation){}

	//target:
	public:
	InterpretationFunction* getFunction(compilation::FunctionUnit* unit);
	PIFunction* getFunction(PIFSignature&& sig);

	private:
	std::map<PIFSignature, PIFunction*> __pifunctions;
	std::map<compilation::FunctionUnit, InterpretationFunction> __dictFunctionsByUnit;

	//self:
	public:
	CompilePass* pass;
	llvm::Value* compile(const Expression& expression, const compilation::Context& ctx);
	private:
	InterpretationScope* transformContext(const compilation::Context& c);
	};

	template<class Parent>
	class InterpretationScopeDecorator: public Parent{
	public:
	InterpretationScopeDecorator(CodeScope* codeScope, compilation::FunctionUnit* f, CompilePass* compilePass): Parent(codeScope, f, compilePass){}

	virtual llvm::Value* process(const Expression& expr, const std::string& hintVarDecl){
	const InterpretationData& data = Attachments::get<InterpretationData>(expr, {ANY, NONE});
	bool flagInterpretationEligible = (data.resolution == INTR_ONLY \|\| data.op != InterpretationOperator::NONE);

	if (flagInterpretationEligible){
	compilation::Context ctx{this, this->function, this->pass};
	return Parent::pass->targetInterpretation->compile(expr, ctx);
	}

	return Parent::process(expr, hintVarDecl);
	}
	};
	}} //end of xreate:: interpretation

	#endif /* TARGETSTATIC_H */


	//transformers:
	// template<>
	// struct TransformerInfo<TargetInterpretation> {
	// static const int id = 1;
	// };

targetinterpretation.h
No OneTemporary
Actions

File Metadata

targetinterpretation.h
View Options

Event Timeline

targetinterpretation.hNo OneTemporaryActions

File Metadata

targetinterpretation.hView Options

Event Timeline

targetinterpretation.h
No OneTemporary
Actions

targetinterpretation.h
View Options