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

Last change on this file since 4723 was 4721, checked in by cameron, 4 years ago

Minor fixes

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