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

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

Work on bracket matching problem

File size: 8.4 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    template<typename T>
13    struct not_null {
14        inline not_null(T const value) : _value(value) { assert(_value); }
15        inline not_null(std::nullptr_t) = delete;
16        inline not_null(unsigned) = delete;
17        operator T() const { return _value; }
18        T operator-> () const { return _value; }
19        T get() const { return _value; }
20    private:
21        T const  _value;
22    };
23
24    explicit PabloBuilder(PabloBlock * block)
25    : mPb(block), mParent(nullptr), mExprTable(nullptr) {
26
27    }
28
29    PabloBuilder & operator=(PabloBuilder) = delete;
30
31    PabloBuilder & operator=(PabloBuilder &) = delete;
32
33    PabloBuilder(PabloBuilder && builder)
34    : mPb(builder.mPb)
35    , mParent(builder.mParent)
36    , mExprTable(std::move(builder.mExprTable)) {
37
38    }
39
40    PabloBuilder & operator=(PabloBuilder && builder) {
41        mPb = builder.mPb;
42        mParent = builder.mParent;
43        mExprTable = std::move(builder.mExprTable);
44        return *this;
45    }
46
47    using iterator = PabloBlock::iterator;
48
49    using const_iterator = PabloBlock::const_iterator;
50
51    inline static PabloBuilder Create(PabloBlock * block) noexcept {
52        return PabloBuilder(block);
53    }
54
55    inline static PabloBuilder Create(PabloBuilder & builder) noexcept {
56        return PabloBuilder(PabloBlock::Create(builder.getPabloBlock()->getParent()), builder);
57    }
58
59    inline Zeroes * createZeroes(Type * const type = nullptr) {
60        return mPb->createZeroes(type);
61    }
62
63    inline Ones * createOnes(Type * const type = nullptr) {
64        return mPb->createOnes(type);
65    }
66
67    inline Var * createVar(const std::string name, Type * const type = nullptr) {
68        return createVar(makeName(name), type);
69    }
70
71    inline Var * createVar(const std::string name, PabloAST * value) {
72        Var * var = createVar(name, value->getType());
73        createAssign(var, value);
74        return var;
75    }
76
77    inline Var * createVar(String * const name, Type * const type = nullptr) {
78        return mPb->createVar(name, type);
79    }
80
81    Extract * createExtract(PabloAST * value, not_null<PabloAST *> index);
82
83    inline Extract * createExtract(PabloAST * value, const int64_t index) {
84        return createExtract(value, getInteger(index));
85    }
86
87    Extract * createExtract(PabloAST * value, not_null<PabloAST *> index, const std::string & prefix);
88
89    inline Extract * createExtract(PabloAST * value, const int64_t index, const std::string & prefix) {
90        return createExtract(value, getInteger(index), prefix);
91    }
92
93    inline Call * createCall(Prototype * prototype, const std::vector<Var *> & args) {
94        return createCall(prototype, reinterpret_cast<const std::vector<PabloAST *> &>(args));
95    }
96
97    Call * createCall(Prototype * prototype, const std::vector<PabloAST *> &vars);
98
99    inline PabloAST * createAdvance(PabloAST * expr, const int64_t shiftAmount) {
100        return createAdvance(expr, mPb->getInteger(shiftAmount));
101    }
102
103    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
104
105    inline PabloAST * createAdvance(PabloAST * expr, const int64_t shiftAmount, const std::string & prefix) {
106        return createAdvance(expr, mPb->getInteger(shiftAmount), prefix);
107    }
108
109    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string & prefix);
110
111    inline PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount) {
112        if (shiftAmount == 0) {
113            return expr;
114        }
115        return createLookahead(expr, mPb->getInteger(shiftAmount));
116    }
117
118    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount);
119
120    inline PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount, const std::string & prefix) {
121        if (shiftAmount == 0) {
122            return expr;
123        }
124        return createLookahead(expr, mPb->getInteger(shiftAmount), prefix);
125    }
126
127    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string & prefix);
128
129    PabloAST * createAssign(PabloAST * const variable, PabloAST * const value);
130
131    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
132
133    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
134
135    PabloAST * createNot(PabloAST * expr);
136
137    PabloAST * createNot(PabloAST * expr, const std::string & prefix);
138
139    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
140
141    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
142
143    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
144
145    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
146
147    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
148
149    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string & prefix);
150
151    PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
152
153    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const std::string & prefix);
154
155    PabloAST * createScanTo(PabloAST * from, PabloAST * to) {
156        return createScanThru(from, createNot(to));
157    }
158
159    PabloAST * createScanTo(PabloAST * from, PabloAST * to, const std::string & prefix) {
160        return createScanThru(from, createNot(to), prefix);
161    }
162
163    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
164
165    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string & prefix);
166
167    PabloAST * createCount(PabloAST * expr);
168   
169    PabloAST * createCount(PabloAST * expr, const std::string & prefix);
170
171    PabloAST * createInFile(PabloAST * expr);
172   
173    PabloAST * createInFile(PabloAST * expr, const std::string & prefix);
174   
175    PabloAST * createAtEOF(PabloAST * expr);
176   
177    PabloAST * createAtEOF(PabloAST * expr, const std::string & prefix);
178   
179    PabloAST * createAdd(PabloAST * expr1, PabloAST * expr2);
180
181    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2);
182
183    PabloAST * createLessThan(PabloAST * expr1, PabloAST * expr2);
184
185    inline If * createIf(PabloAST * condition, PabloBlock * body) {
186        return mPb->createIf(condition, body);
187    }
188
189    inline If * createIf(PabloAST * condition, PabloBuilder & builder) {
190        return mPb->createIf(condition, builder.mPb);
191    }
192
193    inline While * createWhile(PabloAST * condition, PabloBlock * body) {
194        return mPb->createWhile(condition, body);
195    }
196
197    inline While * createWhile(PabloAST * condition, PabloBuilder & builder) {
198        return mPb->createWhile(condition, builder.mPb);
199    }
200
201    Type * getStreamTy(const unsigned FieldWidth = 1) {
202        return mPb->getStreamTy(FieldWidth);
203    }
204   
205    Type * getStreamSetTy(const unsigned NumElements = 1, const unsigned FieldWidth = 1) {
206        return mPb->getStreamSetTy(NumElements, FieldWidth);
207    }
208   
209    /// Statement Iterator Wrappers
210
211    iterator begin() {
212        return mPb->begin();
213    }
214
215    iterator end() {
216        return mPb->end();
217    }
218
219    const_iterator begin() const {
220        return mPb->cbegin();
221    }
222
223    const_iterator end() const {
224        return mPb->cend();
225    }
226
227    const_iterator cbegin() const {
228        return mPb->cbegin();
229    }
230
231    const_iterator cend() const {
232        return mPb->cend();
233    }
234
235    inline Statement * front() const {
236        return mPb->front();
237    }
238
239    inline Statement * back() const {
240        return mPb->back();
241    }
242
243    inline Statement * getInsertPoint() const {
244        return mPb->getInsertPoint();
245    }
246
247    inline PabloBlock * getPabloBlock() const {
248        return mPb;
249    }
250
251    inline PabloBuilder * getParent() const {
252        return mParent;
253    }
254
255    inline String * getName(const std::string & name) const {
256        return mPb->getName(name);
257    }
258
259    inline String * makeName(const std::string & prefix) const {
260        return mPb->makeName(prefix);
261    }
262
263    inline Integer * getInteger(const uint64_t value) const {
264        return mPb->getInteger(value);
265    }
266
267    inline void print(raw_ostream & O, const bool expandNested = true) const {
268        mPb->print(O, expandNested);
269    }
270
271protected:
272
273    explicit PabloBuilder(PabloBlock * block, PabloBuilder & parent)
274    : mPb(block), mParent(&parent), mExprTable(&(parent.mExprTable)) {
275
276    }
277
278private:
279
280    PabloBlock *        mPb;
281    PabloBuilder *      mParent;
282    ExpressionTable     mExprTable;
283};
284
285
286}
287
288
289#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.