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

Last change on this file since 4687 was 4683, checked in by cameron, 4 years ago

Use #include <pablo/...> syntax uniformally for all pablo headers

File size: 6.7 KB
Line 
1#ifndef BUILDER_HPP
2#define BUILDER_HPP
3
4#include <pablo/codegenstate.h>
5#include <pablo/expression_map.hpp>
6
7namespace pablo {
8
9class PabloBuilder {
10public:
11
12    explicit PabloBuilder(PabloBlock & block) : mPb(&block), mParent(nullptr), mExprTable(nullptr) {}
13
14    explicit PabloBuilder(PabloBlock & block, PabloBuilder & parent) : mPb(&block), mParent(&parent), mExprTable(&(parent.mExprTable)) {}
15
16    PabloBuilder(PabloBuilder && builder) : mPb(builder.mPb), mParent(builder.mParent), mExprTable(std::move(builder.mExprTable)) {}
17
18    PabloBuilder & operator=(PabloBuilder) = delete;
19
20    PabloBuilder & operator=(PabloBuilder &) = delete;
21
22    PabloBuilder & operator=(PabloBuilder && builder) {
23        mPb = builder.mPb;
24        mParent = builder.mParent;
25        mExprTable = std::move(builder.mExprTable);
26        return *this;
27    }
28
29    inline static PabloBuilder Create(PabloBuilder & parent) noexcept {
30        return std::move(PabloBuilder(PabloBlock::Create(*(parent.mPb)), parent));
31    }
32
33    inline Zeroes * createZeroes() const {
34        return mPb->createZeroes();
35    }
36
37    inline Ones * createOnes() const {
38        return mPb->createOnes();
39    }
40
41    inline Var * createVar(const std::string name) {
42        return mPb->createVar(name);
43    }
44
45    inline Var * createVar(String * const name) {
46        return mPb->createVar(name);
47    }
48
49    inline Var * createVar(PabloAST * const name) {
50        return mPb->createVar(name);
51    }
52
53    Call * createCall(Prototype * prototype, const std::vector<Var *> & vars);
54
55    Assign * createAssign(const std::string && prefix, PabloAST * expr) {
56        return mPb->createAssign(std::move(prefix), expr);
57    }
58
59    inline PabloAST * createAdvance(PabloAST * expr, const Integer::integer_t shiftAmount) {
60        if (shiftAmount == 0) {
61            return expr;
62        }
63        return createAdvance(expr, mPb->getInteger(shiftAmount));
64    }
65
66    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
67
68    inline PabloAST * createAdvance(PabloAST * expr, const Integer::integer_t shiftAmount, const std::string prefix) {
69        if (shiftAmount == 0) {
70            return expr;
71        }
72        return createAdvance(expr, mPb->getInteger(shiftAmount), prefix);
73    }
74
75    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
76
77    inline Next * createNext(Assign * assign, PabloAST * expr) {
78        return mPb->createNext(assign, expr);
79    }
80
81    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
82
83    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
84
85    PabloAST * createNot(PabloAST * expr);
86
87    PabloAST * createNot(PabloAST * expr, const std::string prefix);
88
89    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
90
91    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
92
93    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
94
95    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
96
97    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
98
99    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix);
100
101    PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
102
103    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix);
104
105    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
106
107    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix);
108
109    /// CreateIf Wrappers
110
111    inline If * createIf(PabloAST * condition, std::initializer_list<Assign *> definedVars, PabloBlock & body) {
112        return mPb->createIf(condition, std::move(definedVars), body);
113    }
114
115    inline If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBlock & body) {
116        return mPb->createIf(condition, definedVars, body);
117    }
118
119    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body) {
120        return mPb->createIf(condition, std::move(definedVars), body);
121    }
122
123    inline If * createIf(PabloAST * condition, std::initializer_list<Assign *> definedVars, PabloBuilder & builder) {
124        return mPb->createIf(condition, std::move(definedVars), *builder.mPb);
125    }
126
127    inline If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBuilder & builder) {
128        return mPb->createIf(condition, definedVars, *builder.mPb);
129    }
130
131    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBuilder & builder) {
132        return mPb->createIf(condition, std::move(definedVars), *builder.mPb);
133    }
134
135    /// CreateWhile Wrappers
136
137    inline While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBlock & body) {
138        return mPb->createWhile(condition, nextVars, body);
139    }
140
141    inline While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBlock & body) {
142        return mPb->createWhile(condition, nextVars, body);
143    }
144
145    inline While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBlock & body) {
146        return mPb->createWhile(condition, std::move(nextVars), body);
147    }
148
149    inline While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBuilder & builder) {
150        return mPb->createWhile(condition, nextVars, *builder.mPb);
151    }
152
153    inline While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBuilder & builder) {
154        return mPb->createWhile(condition, nextVars, *builder.mPb);
155    }
156
157    inline While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBuilder & builder) {
158        return mPb->createWhile(condition, std::move(nextVars), *builder.mPb);
159    }
160
161    inline Statement * front() const {
162        return mPb->front();
163    }
164
165    inline Statement * back() const {
166        return mPb->back();
167    }
168
169    inline String * getName(const std::string name, const bool generated = true) const {
170        return mPb->getName(std::move(name), generated);
171    }
172
173    inline String * makeName(const std::string prefix, const bool generated = true) const {
174        return mPb->makeName(std::move(prefix), generated);
175    }
176
177    inline Integer * getInteger(Integer::integer_t value) {
178        return mPb->getInteger(value);
179    }
180
181
182    inline Statement * getInsertPoint() const {
183        return mPb->getInsertPoint();
184    }
185
186    inline PabloBlock * getPabloBlock() {
187        return mPb;
188    }
189
190    inline PabloBuilder * getParent() {
191        return mParent;
192    }
193
194private:
195
196    PabloBlock *        mPb;
197    PabloBuilder *      mParent;
198    ExpressionTable     mExprTable;
199};
200
201
202}
203
204
205#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.