Page Menu
Home
Xreate
Search
Configure Global Search
Log In
Docs
Questions
Repository
Issues
Patches
Internal API
Files
F4819736
targetinterpretation.h
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Mon, Aug 24, 4:26 AM
Size
2 KB
Mime Type
text/x-c++
Expires
Wed, Aug 26, 4:26 AM (20 h, 19 m)
Engine
blob
Format
Raw Data
Handle
285180
Attached To
rXR Xreate
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 "compilation/targets.h"
#include "transformations.h"
#include "pass/interpretationpass.h"
namespace xreate{ namespace compilation {
class TargetInterpretation;
class InterpretationScope;
class InterpretatonFunction;
template <>
struct TargetInfo<TargetInterpretation> {
typedef Expression Result;
typedef InterpretationScope Scope;
typedef InterpretatonFunction Function;
};
template<>
struct TransformerInfo<TargetInterpretation> {
static const int id = 1;
};
class InterpretationScope: public Scope<TargetInterpretation>{
typedef Scope<TargetInterpretation> Parent;
public:
InterpretationScope(CodeScope* scope, Function<TargetInterpretation>* f): Parent(scope, f) {}
Expression process(const Expression& expression) override;
llvm::Value* compile(const Expression& expression, const Context& context);
private:
llvm::Value* compileHybrid(const InterpretationOperator& op, const Expression& expression, const Context& context);
llvm::Value* compilePartialFnCall(const Expression& expression, const Context& context);
CodeScope* processOperatorIf(const Expression& expression);
CodeScope* processOperatorSwitch(const Expression& expression);
};
class InterpretatonFunction: public Function<TargetInterpretation>{
public:
PIFSignature signature;
InterpretatonFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target);
Expression process(const std::vector<Expression>& args);
};
/*
* Partially interpreted function signature
*/
struct PIFSignature{
ManagedFnPtr declaration;
std::vector<Expression> bindings;
};
class TargetInterpretation: public Transformer, public Target<TargetInterpretation>{
public:
TargetInterpretation(AST* root): Target<TargetInterpretation>(root){}
//transformer:
public:
virtual llvm::Value* transform(const Expression& expression, llvm::Value* raw, const Context& ctx) override;
virtual Expression transform(const Expression& expression, const Context& ctx) override;
virtual bool isAcceptable(const Expression& expression) override;
//target:
public:
InterpretatonFunction* getFunction(const ManagedFnPtr& function);
private:
std::set<InterpretationFunction*> __functions;
//self:
public:
llvm::Value* compile(const Expression& expression, const Context& ctx);
private:
InterpretationScope* transformContext(const Context& c);
};
}}
#endif /* TARGETSTATIC_H */
Event Timeline
Log In to Comment