source: icGREP/icgrep-devel/icgrep/pablo/builder.hpp @ 5160

Last change on this file since 5160 was 5160, checked in by nmedfort, 3 years ago

Initial work for incorporating Types into Pablo AST.

File size: 8.8 KB
RevLine 
[4432]1#ifndef BUILDER_HPP
2#define BUILDER_HPP
3
[4683]4#include <pablo/codegenstate.h>
5#include <pablo/expression_map.hpp>
[4432]6
7namespace pablo {
8
[4443]9class PabloBuilder {
[4432]10public:
11
[4870]12    explicit PabloBuilder(PabloBlock * block) : mPb(block), mParent(nullptr), mExprTable(nullptr) {}
[4443]13
[4870]14    explicit PabloBuilder(PabloBlock * block, PabloBuilder & parent) : mPb(block), mParent(&parent), mExprTable(&(parent.mExprTable)) {}
[4622]15
[4646]16    PabloBuilder(PabloBuilder && builder) : mPb(builder.mPb), mParent(builder.mParent), mExprTable(std::move(builder.mExprTable)) {}
[4641]17
[4646]18    PabloBuilder & operator=(PabloBuilder) = delete;
19
[4641]20    PabloBuilder & operator=(PabloBuilder &) = delete;
21
[4646]22    PabloBuilder & operator=(PabloBuilder && builder) {
23        mPb = builder.mPb;
24        mParent = builder.mParent;
25        mExprTable = std::move(builder.mExprTable);
26        return *this;
27    }
[4641]28
[4711]29    using iterator = PabloBlock::iterator;
30
31    using const_iterator = PabloBlock::const_iterator;
32
[4870]33    inline static PabloBuilder Create(PabloBlock * block) noexcept {
[5037]34        return PabloBuilder(block);
[4617]35    }
36
[4870]37    inline static PabloBuilder Create(PabloBuilder & builder) noexcept {
[5160]38        return PabloBuilder(PabloBlock::Create(builder.getPabloBlock()), builder);
[4870]39    }
40
[5160]41    inline Zeroes * createZeroes(const PabloType * const type = nullptr) {
42        return mPb->createZeroes(type);
[4432]43    }
44
[5160]45    inline Ones * createOnes(const PabloType * const type = nullptr) {
46        return mPb->createOnes(type);
[4432]47    }
48
[5160]49    inline Var * createVar(const std::string name, const PabloType * const type) {
50        return mPb->createVar(name, type);
[4443]51    }
52
[5160]53    inline Var * createVar(String * const name, const PabloType * const type) {
54        return mPb->createVar(name, type);
[4612]55    }
[4443]56
[5160]57    inline Var * createVar(PabloAST * const name, const PabloType * const type) {
58        return mPb->createVar(name, type);
[4443]59    }
60
[4692]61    inline Call * createCall(Prototype * prototype, const std::vector<Var *> & args) {
62        return createCall(prototype, reinterpret_cast<const std::vector<PabloAST *> &>(args));
63    }
[4432]64
[4692]65    Call * createCall(Prototype * prototype, const std::vector<PabloAST *> &vars);
66
[4657]67    Assign * createAssign(const std::string && prefix, PabloAST * expr) {
68        return mPb->createAssign(std::move(prefix), expr);
[4602]69    }
[4432]70
[4699]71    inline PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount) {
[4443]72        if (shiftAmount == 0) {
73            return expr;
74        }
[4641]75        return createAdvance(expr, mPb->getInteger(shiftAmount));
[4432]76    }
77
[4443]78    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
[4432]79
[4699]80    inline PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
[4622]81        if (shiftAmount == 0) {
82            return expr;
83        }
[4641]84        return createAdvance(expr, mPb->getInteger(shiftAmount), prefix);
[4622]85    }
86
[4603]87    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
88
[4959]89    inline PabloAST * createLookahead(PabloAST * expr, const Integer::Type shiftAmount) {
90        if (shiftAmount == 0) {
91            return expr;
92        }
93        return createLookahead(expr, mPb->getInteger(shiftAmount));
94    }
95
96    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount);
97
98    inline PabloAST * createLookahead(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
99        if (shiftAmount == 0) {
100            return expr;
101        }
102        return createLookahead(expr, mPb->getInteger(shiftAmount), prefix);
103    }
104
105    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
106
[4622]107    inline Next * createNext(Assign * assign, PabloAST * expr) {
[4641]108        return mPb->createNext(assign, expr);
[4622]109    }
[4432]110
111    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
112
[4622]113    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
114
[4432]115    PabloAST * createNot(PabloAST * expr);
116
[4622]117    PabloAST * createNot(PabloAST * expr, const std::string prefix);
118
[4432]119    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
120
[4622]121    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
122
[4432]123    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
124
[4622]125    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
126
[4432]127    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
128
[4622]129    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix);
130
[4432]131    PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
132
[4622]133    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix);
134
[4432]135    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
136
[4622]137    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix);
[4717]138   
[5061]139    Count * createCount(const std::string counter, PabloAST * expr) {
140        return mPb->createCount(counter, expr);
141    }
[4718]142   
[5023]143    PabloAST * createInFile(PabloAST * expr);
144   
145    PabloAST * createInFile(PabloAST * expr, const std::string prefix);
146   
[5042]147    PabloAST * createAtEOF(PabloAST * expr);
148   
149    PabloAST * createAtEOF(PabloAST * expr, const std::string prefix);
150   
[4641]151    /// CreateIf Wrappers
[4622]152
[4870]153    inline If * createIf(PabloAST * condition, std::initializer_list<Assign *> definedVars, PabloBlock * body) {
[4641]154        return mPb->createIf(condition, std::move(definedVars), body);
[4443]155    }
[4432]156
[4870]157    inline If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBlock * body) {
[4641]158        return mPb->createIf(condition, definedVars, body);
[4622]159    }
160
[4870]161    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock * body) {
[4641]162        return mPb->createIf(condition, std::move(definedVars), body);
[4602]163    }
164
[4641]165    inline If * createIf(PabloAST * condition, std::initializer_list<Assign *> definedVars, PabloBuilder & builder) {
[4870]166        return mPb->createIf(condition, std::move(definedVars), builder.mPb);
[4622]167    }
168
[4641]169    inline If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBuilder & builder) {
[4870]170        return mPb->createIf(condition, definedVars, builder.mPb);
[4443]171    }
[4432]172
[4641]173    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBuilder & builder) {
[4870]174        return mPb->createIf(condition, std::move(definedVars), builder.mPb);
[4603]175    }
176
[4641]177    /// CreateWhile Wrappers
178
[4870]179    inline While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBlock * body) {
[4641]180        return mPb->createWhile(condition, nextVars, body);
[4603]181    }
182
[4870]183    inline While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBlock * body) {
[4641]184        return mPb->createWhile(condition, nextVars, body);
[4603]185    }
186
[4870]187    inline While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBlock * body) {
[4641]188        return mPb->createWhile(condition, std::move(nextVars), body);
[4603]189    }
190
[4641]191    inline While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBuilder & builder) {
[4870]192        return mPb->createWhile(condition, std::move(nextVars), builder.mPb);
[4641]193    }
194
195    inline While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBuilder & builder) {
[4870]196        return mPb->createWhile(condition, nextVars, builder.mPb);
[4641]197    }
198
199    inline While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBuilder & builder) {
[4870]200        return mPb->createWhile(condition, std::move(nextVars), builder.mPb);
[4641]201    }
202
[4711]203    /// Statement Iterator Wrappers
204
205    iterator begin() {
206        return mPb->begin();
207    }
208
209    iterator end() {
210        return mPb->end();
211    }
212
213    const_iterator begin() const {
214        return mPb->cbegin();
215    }
216
217    const_iterator end() const {
218        return mPb->cend();
219    }
220
221    const_iterator cbegin() const {
222        return mPb->cbegin();
223    }
224
225    const_iterator cend() const {
226        return mPb->cend();
227    }
228
[4641]229    inline Statement * front() const {
230        return mPb->front();
231    }
232
233    inline Statement * back() const {
234        return mPb->back();
235    }
236
[4680]237    inline String * getName(const std::string name, const bool generated = true) const {
238        return mPb->getName(std::move(name), generated);
239    }
240
241    inline String * makeName(const std::string prefix, const bool generated = true) const {
242        return mPb->makeName(std::move(prefix), generated);
243    }
244
[4699]245    inline Integer * getInteger(Integer::Type value) {
[4680]246        return mPb->getInteger(value);
247    }
248
249
[4603]250    inline Statement * getInsertPoint() const {
[4641]251        return mPb->getInsertPoint();
[4603]252    }
253
[4641]254    inline PabloBlock * getPabloBlock() {
[4617]255        return mPb;
256    }
257
[4622]258    inline PabloBuilder * getParent() {
259        return mParent;
260    }
[4617]261
[4711]262    inline void record(Statement * stmt) {
263        mExprTable.findOrAdd(stmt);
264    }
265
[4432]266private:
267
[4641]268    PabloBlock *        mPb;
[4622]269    PabloBuilder *      mParent;
[4443]270    ExpressionTable     mExprTable;
[4432]271};
272
273
274}
275
276
277#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.