source: icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp @ 5023

Last change on this file since 5023 was 5023, checked in by cameron, 3 years ago

pablo.InFile? initial support

File size: 20.9 KB
Line 
1/*
2 *  Copyright (c) 2014 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icgrep is a trademark of International Characters.
5 */
6
7#include <pablo/codegenstate.h>
8#include <iostream>
9#include <pablo/printer_pablos.h>
10
11namespace pablo {
12
13Zeroes PabloBlock::mZeroes;
14
15Ones PabloBlock::mOnes;
16
17inline PabloAST * PabloBlock::renameNonNamedNode(PabloAST * expr, const std::string && prefix) {
18    if (Statement * stmt = dyn_cast<Statement>(expr)) {
19        if (stmt->getName()->isGenerated()) {
20            stmt->setName(makeName(prefix, false));
21        }
22    }
23    return expr;
24}
25
26void PabloBlock::insert(Statement * const statement) {
27    assert (statement);
28    if (LLVM_UNLIKELY(mInsertionPoint == nullptr)) {
29        if (mFirst) {
30            statement->insertBefore(mFirst);
31        } else {
32            statement->removeFromParent();
33            statement->mParent = this;
34            mFirst = mLast = statement;
35        }
36    } else if (LLVM_LIKELY(statement != mInsertionPoint)) {
37        statement->insertAfter(mInsertionPoint);
38        mLast = (mLast == mInsertionPoint) ? statement : mLast;
39        assert (statement->mPrev == mInsertionPoint);
40    }
41    mInsertionPoint = statement;
42}
43
44/// UNARY CREATE FUNCTIONS
45
46Assign * PabloBlock::createAssign(const std::string && prefix, PabloAST * const expr)  {
47    assert ("Assign expression cannot be null!" && expr);
48    return insertAtInsertionPoint(new Assign(expr, makeName(prefix, false)));
49}
50
51PabloAST * PabloBlock::createAdvance(PabloAST * expr, PabloAST * shiftAmount) {
52    if (isa<Zeroes>(expr) || cast<Integer>(shiftAmount)->value() == 0) {
53        return expr;
54    }
55    return insertAtInsertionPoint(new Advance(expr, shiftAmount, makeName("advance")));
56}
57
58PabloAST * PabloBlock::createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix) {
59    if (isa<Zeroes>(expr) || cast<Integer>(shiftAmount)->value() == 0) {
60        return expr;
61    }
62    return insertAtInsertionPoint(new Advance(expr, shiftAmount, makeName(prefix, false)));
63}
64
65PabloAST * PabloBlock::createAdvance(PabloAST * expr, const Integer::Type shiftAmount) {
66    if (isa<Zeroes>(expr) || shiftAmount == 0) {
67        return expr;
68    }
69    return insertAtInsertionPoint(new Advance(expr, getInteger(shiftAmount), makeName("advance")));
70}
71
72PabloAST * PabloBlock::createAdvance(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
73    if (isa<Zeroes>(expr) || shiftAmount == 0) {
74        return renameNonNamedNode(expr, std::move(prefix));
75    }
76    return insertAtInsertionPoint(new Advance(expr, getInteger(shiftAmount), makeName(prefix, false)));
77}
78
79PabloAST * PabloBlock::createLookahead(PabloAST * expr, PabloAST * shiftAmount) {
80    if (isa<Zeroes>(expr) || cast<Integer>(shiftAmount)->value() == 0) {
81        return expr;
82    }
83    return insertAtInsertionPoint(new Lookahead(expr, shiftAmount, makeName("lookahead")));
84}
85
86PabloAST * PabloBlock::createLookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix) {
87    if (isa<Zeroes>(expr) || cast<Integer>(shiftAmount)->value() == 0) {
88        return expr;
89    }
90    return insertAtInsertionPoint(new Lookahead(expr, shiftAmount, makeName(prefix, false)));
91}
92
93PabloAST * PabloBlock::createLookahead(PabloAST * expr, const Integer::Type shiftAmount) {
94    if (isa<Zeroes>(expr) || shiftAmount == 0) {
95        return expr;
96    }
97    return insertAtInsertionPoint(new Lookahead(expr, getInteger(shiftAmount), makeName("lookahead")));
98}
99
100PabloAST * PabloBlock::createLookahead(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
101    if (isa<Zeroes>(expr) || shiftAmount == 0) {
102        return renameNonNamedNode(expr, std::move(prefix));
103    }
104    return insertAtInsertionPoint(new Lookahead(expr, getInteger(shiftAmount), makeName(prefix, false)));
105}
106
107Call * PabloBlock::createCall(PabloAST * prototype, const std::vector<PabloAST *> &) {
108    assert (prototype);
109    return insertAtInsertionPoint(new Call(prototype));
110}
111
112
113PabloAST * PabloBlock::createNot(PabloAST * expr) {
114    assert (expr);
115    if (isa<Ones>(expr)) {
116        return createZeroes();
117    }
118    else if (isa<Zeroes>(expr)){
119        return createOnes();
120    }
121    else if (Not * not1 = dyn_cast<Not>(expr)) {
122        return not1->getOperand(0);
123    }
124    return insertAtInsertionPoint(new Not(expr, makeName("not_")));
125}
126
127PabloAST * PabloBlock::createNot(PabloAST * expr, const std::string prefix) {
128    assert (expr);
129    if (isa<Ones>(expr)) {
130        return createZeroes();
131    }
132    else if (isa<Zeroes>(expr)){
133        return createOnes();
134    }
135    else if (Not * not1 = dyn_cast<Not>(expr)) {       
136        return renameNonNamedNode(not1->getOperand(0), std::move(prefix));
137    }
138    return insertAtInsertionPoint(new Not(expr, makeName(prefix, false)));
139}
140
141Var * PabloBlock::createVar(PabloAST * name) {
142    assert (name);
143    return new Var(name);
144}
145
146PabloAST * PabloBlock::createCount(PabloAST * expr) {
147    assert (expr);
148    return insertAtInsertionPoint(new Count(expr, makeName("count_")));
149}
150
151PabloAST * PabloBlock::createCount(PabloAST * expr, const std::string prefix) {
152    assert (expr);
153    return insertAtInsertionPoint(new Count(expr, makeName(prefix, false)));
154}
155
156PabloAST * PabloBlock::createInFile(PabloAST * expr) {
157    assert (expr);
158    return insertAtInsertionPoint(new InFile(expr, makeName("count_")));
159}
160
161PabloAST * PabloBlock::createInFile(PabloAST * expr, const std::string prefix) {
162    assert (expr);
163    return insertAtInsertionPoint(new InFile(expr, makeName(prefix, false)));
164}
165
166
167/// BINARY CREATE FUNCTIONS
168
169Next * PabloBlock::createNext(Assign * assign, PabloAST * expr) {
170    assert (assign && expr);
171    return insertAtInsertionPoint(new Next(assign, expr));
172}
173
174PabloAST * PabloBlock::createMatchStar(PabloAST * marker, PabloAST * charclass) {
175    assert (marker && charclass);
176    if (isa<Zeroes>(marker) || isa<Zeroes>(charclass)) {
177        return marker;
178    }
179    return insertAtInsertionPoint(new MatchStar(marker, charclass, makeName("matchstar")));
180}
181
182PabloAST * PabloBlock::createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix) {
183    assert (marker && charclass);
184    if (isa<Zeroes>(marker) || isa<Zeroes>(charclass)) {
185        return renameNonNamedNode(marker, std::move(prefix));
186    }
187    return insertAtInsertionPoint(new MatchStar(marker, charclass, makeName(prefix, false)));
188}
189
190PabloAST * PabloBlock::createScanThru(PabloAST * from, PabloAST * thru) {
191    assert (from && thru);
192    if (isa<Zeroes>(from) || isa<Zeroes>(thru)) {
193        return from;
194    }
195    return insertAtInsertionPoint(new ScanThru(from, thru, makeName("scanthru")));
196}
197
198PabloAST * PabloBlock::createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix) {
199    assert (from && thru);
200    if (isa<Zeroes>(from) || isa<Zeroes>(thru)) {       
201        return renameNonNamedNode(from, std::move(prefix));
202    }
203    return insertAtInsertionPoint(new ScanThru(from, thru, makeName(prefix, false)));
204}
205
206template<typename Type>
207static inline Type * isBinary(PabloAST * expr) {
208    if (isa<Type>(expr) && cast<Type>(expr)->getNumOperands() == 2) {
209        return cast<Type>(expr);
210    }
211    return nullptr;
212}
213
214PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2) {
215    assert (expr1 && expr2);
216    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
217        return expr2;
218    } else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
219        return expr1;
220    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
221        if (Not * not2 = dyn_cast<Not>(expr2)) {
222            return createNot(createOr(not1->getOperand(0), not2->getOperand(0)));
223        } else if (equals(not1->getOperand(0), expr2)) {
224            return createZeroes();
225        }
226    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
227        if (equals(expr1, not2->getOperand(0))) {
228            return createZeroes();
229        }
230    } else if (Or * or1 = isBinary<Or>(expr1)) {
231        if (equals(or1->getOperand(0), expr2) || equals(or1->getOperand(1), expr2)) {
232            return expr2;
233        }
234    } else if (Or * or2 = isBinary<Or>(expr2)) {
235        if (equals(or2->getOperand(0), expr1) || equals(or2->getOperand(1), expr1)) {
236            return expr1;
237        }
238    }
239    return insertAtInsertionPoint(new And(expr1, expr2, makeName("and_")));
240}
241
242PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
243    assert (expr1 && expr2);
244    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
245        return renameNonNamedNode(expr2, std::move(prefix));
246    }
247    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
248        return renameNonNamedNode(expr1, std::move(prefix));
249    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
250        if (Not * not2 = dyn_cast<Not>(expr2)) {
251            return createNot(createOr(not1->getOperand(0), not2->getOperand(0)), prefix);
252        }
253        else if (equals(not1->getOperand(0), expr2)) {
254            return createZeroes();
255        }
256    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
257        if (equals(expr1, not2->getOperand(0))) {
258            return createZeroes();
259        }
260    } else if (Or * or1 = isBinary<Or>(expr1)) {
261        if (equals(or1->getOperand(0), expr2) || equals(or1->getOperand(1), expr2)) {
262            return expr2;
263        }
264    } else if (Or * or2 = isBinary<Or>(expr2)) {
265        if (equals(or2->getOperand(0), expr1) || equals(or2->getOperand(1), expr1)) {
266            return expr1;
267        }
268    }
269    return insertAtInsertionPoint(new And(expr1, expr2, makeName(prefix, false)));
270}
271
272And * PabloBlock::createAnd(const unsigned reserved) {
273    return insertAtInsertionPoint(new And(reserved, makeName("and_")));
274}
275
276And * PabloBlock::createAnd(const unsigned reserved, const std::string prefix) {
277    return insertAtInsertionPoint(new And(reserved, makeName(prefix, false)));
278}
279
280PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2) {
281    assert (expr1 && expr2);
282    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
283        return expr2;
284    }
285    if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
286        return expr1;
287    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
288        // ¬a√b = ¬¬(¬a √ b) = ¬(a ∧ ¬b)
289        return createNot(createAnd(not1->getOperand(0), createNot(expr2)));
290    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
291        // a√¬b = ¬¬(¬b √ a) = ¬(b ∧ ¬a)
292        return createNot(createAnd(not2->getOperand(0), createNot(expr1)));
293    } else if (equals(expr1, expr2)) {
294        return expr1;
295    } else if (And * and1 = isBinary<And>(expr1)) {
296        if (And * and2 = isBinary<And>(expr2)) {
297            PabloAST * const expr1a = and1->getOperand(0);
298            PabloAST * const expr1b = and1->getOperand(1);
299            PabloAST * const expr2a = and2->getOperand(0);
300            PabloAST * const expr2b = and2->getOperand(1);
301            //These optimizations factor out common components that can occur when sets are formed by union
302            //(e.g., union of [a-z] and [A-Z].
303            if (equals(expr1a, expr2a)) {
304                return createAnd(expr1a, createOr(expr1b, expr2b));
305            } else if (equals(expr1b, expr2b)) {
306                return createAnd(expr1b, createOr(expr1a, expr2a));
307            } else if (equals(expr1a, expr2b)) {
308                return createAnd(expr1a, createOr(expr1b, expr2a));
309            } else if (equals(expr1b, expr2a)) {
310                return createAnd(expr1b, createOr(expr1a, expr2b));
311            }
312        } else if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)) {
313            // (a ∧ b) √ a = a
314            return expr2;
315        }
316    } else if (And * and2 = isBinary<And>(expr2)) {
317        if (equals(and2->getOperand(0), expr1) || equals(and2->getOperand(1), expr1)) {
318            return expr1;
319        }
320    }
321    return insertAtInsertionPoint(new Or(expr1, expr2, makeName("or_")));
322}
323
324PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
325    assert (expr1 && expr2);
326    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
327        return renameNonNamedNode(expr2, std::move(prefix));
328    }
329    else if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
330        return renameNonNamedNode(expr1, std::move(prefix));
331    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
332        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
333        return createNot(createAnd(not1->getOperand(0), createNot(expr2)), prefix);
334    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
335        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
336        return createNot(createAnd(not2->getOperand(0), createNot(expr1)), prefix);
337    } else if (And * and1 = isBinary<And>(expr1)) {
338        if (And * and2 = isBinary<And>(expr2)) {
339            PabloAST * const expr1a = and1->getOperand(0);
340            PabloAST * const expr1b = and1->getOperand(1);
341            PabloAST * const expr2a = and2->getOperand(0);
342            PabloAST * const expr2b = and2->getOperand(1);
343            //These optimizations factor out common components that can occur when sets are formed by union
344            //(e.g., union of [a-z] and [A-Z].
345            if (equals(expr1a, expr2a)) {
346                return createAnd(expr1a, createOr(expr1b, expr2b), prefix);
347            } else if (equals(expr1b, expr2b)) {
348                return createAnd(expr1b, createOr(expr1a, expr2a), prefix);
349            } else if (equals(expr1a, expr2b)) {
350                return createAnd(expr1a, createOr(expr1b, expr2a), prefix);
351            } else if (equals(expr1b, expr2a)) {
352                return createAnd(expr1b, createOr(expr1a, expr2b), prefix);
353            }
354        } else if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)) {
355            // (a∧b) √ a = a
356            return expr2;
357        }
358    } else if (And * and2 = isBinary<And>(expr2)) {
359        if (equals(and2->getOperand(0), expr1) || equals(and2->getOperand(1), expr1)) {
360            return expr1;
361        }
362    }
363    return insertAtInsertionPoint(new Or(expr1, expr2, makeName(prefix, false)));
364}
365
366Or * PabloBlock::createOr(const unsigned reserved) {
367    return insertAtInsertionPoint(new Or(reserved, makeName("or_")));
368}
369
370Or * PabloBlock::createOr(const unsigned reserved, const std::string prefix) {
371    return insertAtInsertionPoint(new Or(reserved, makeName(prefix, false)));
372}
373
374PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2) {
375    assert (expr1 && expr2);
376    if (expr1 == expr2) {
377        return PabloBlock::createZeroes();
378    }
379    if (isa<Ones>(expr1)) {
380        return createNot(expr2);
381    } else if (isa<Zeroes>(expr1)){
382        return expr2;
383    } else if (isa<Ones>(expr2)) {
384        return createNot(expr1);
385    } else if (isa<Zeroes>(expr2)){
386        return expr1;
387    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
388        if (Not * not2 = dyn_cast<Not>(expr2)) {
389            return createXor(not1->getOperand(0), not2->getOperand(0));
390        }
391    }
392    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName("xor_")));
393}
394
395PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
396    assert (expr1 && expr2);
397    if (expr1 == expr2) {
398        return PabloBlock::createZeroes();
399    }
400    if (isa<Ones>(expr1)) {
401        return createNot(expr2, prefix);
402    } else if (isa<Zeroes>(expr1)){
403        return expr2;
404    } else if (isa<Ones>(expr2)) {
405        return createNot(expr1, prefix);
406    } else if (isa<Zeroes>(expr2)){
407        return expr1;
408    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
409        if (Not * not2 = dyn_cast<Not>(expr2)) {
410            return createXor(not1->getOperand(0), not2->getOperand(0), prefix);
411        }
412    }
413    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName(prefix, false)));
414}
415
416Xor * PabloBlock::createXor(const unsigned reserved) {
417    return insertAtInsertionPoint(new Xor(reserved, makeName("xor_")));
418}
419
420Xor * PabloBlock::createXor(const unsigned reserved, const std::string prefix) {
421    return insertAtInsertionPoint(new Xor(reserved, makeName(prefix, false)));
422}
423
424/// TERNARY CREATE FUNCTION
425
426PabloAST * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
427    assert (condition && trueExpr && falseExpr);
428    if (isa<Ones>(condition)) {
429        return trueExpr;
430    } else if (isa<Zeroes>(condition)){
431        return falseExpr;
432    } else if (isa<Ones>(trueExpr)) {
433        return createOr(condition, falseExpr);
434    } else if (isa<Zeroes>(trueExpr)){
435        return createAnd(createNot(condition), falseExpr);
436    } else if (isa<Ones>(falseExpr)) {
437        return createOr(createNot(condition), trueExpr);
438    } else if (isa<Zeroes>(falseExpr)){
439        return createAnd(condition, trueExpr);
440    } else if (equals(trueExpr, falseExpr)) {
441        return trueExpr;
442    } else if (isa<Not>(trueExpr) && equals(cast<Not>(trueExpr)->getOperand(0), falseExpr)) {
443        return createXor(condition, falseExpr);
444    } else if (isa<Not>(falseExpr) && equals(trueExpr, cast<Not>(falseExpr)->getOperand(0))){
445        return createXor(condition, trueExpr);
446    }
447    return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, makeName("sel")));
448}
449
450PabloAST * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix) {
451    assert (condition && trueExpr && falseExpr);
452    if (isa<Zeroes>(condition)){
453        return renameNonNamedNode(falseExpr, std::move(prefix));
454    }
455    else if (isa<Ones>(condition) || equals(trueExpr, falseExpr)) {
456        return renameNonNamedNode(trueExpr, std::move(prefix));
457    }
458    else if (isa<Ones>(trueExpr)) {
459        return createOr(condition, falseExpr, prefix);
460    }
461    else if (isa<Zeroes>(trueExpr)){
462        return createAnd(createNot(condition), falseExpr, prefix);
463    }
464    else if (isa<Ones>(falseExpr)) {
465        return createOr(createNot(condition), trueExpr, prefix);
466    }
467    else if (isa<Zeroes>(falseExpr)){
468        return createAnd(condition, trueExpr, prefix);
469    }
470    else if (isa<Not>(trueExpr) && equals(cast<Not>(trueExpr)->getOperand(0), falseExpr)) {
471        return createXor(condition, falseExpr, prefix);
472    }
473    else if (isa<Not>(falseExpr) && equals(trueExpr, cast<Not>(falseExpr)->getOperand(0))){
474        return createXor(condition, trueExpr, prefix);
475    }
476    return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, makeName(prefix, false)));
477}
478
479If * PabloBlock::createIf(PabloAST * condition, const std::initializer_list<Assign *> definedVars, PabloBlock * body) {
480    assert (condition);
481    return insertAtInsertionPoint(new If(condition, definedVars, body));
482}
483
484If * PabloBlock::createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBlock * body) {
485    assert (condition);
486    return insertAtInsertionPoint(new If(condition, definedVars, body));
487}
488
489If * PabloBlock::createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock * body) {
490    assert (condition);
491    return insertAtInsertionPoint(new If(condition, definedVars, body));
492}
493
494While * PabloBlock::createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBlock * body) {
495    assert (condition);
496    return insertAtInsertionPoint(new While(condition, nextVars, body));
497}
498
499While * PabloBlock::createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBlock * body) {
500    assert (condition);
501    return insertAtInsertionPoint(new While(condition, nextVars, body));
502}
503
504While * PabloBlock::createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBlock * body) {
505    assert (condition);
506    return insertAtInsertionPoint(new While(condition, nextVars, body));
507}
508
509/** ------------------------------------------------------------------------------------------------------------- *
510 * @brief eraseFromParent
511 ** ------------------------------------------------------------------------------------------------------------- */
512void PabloBlock::eraseFromParent(const bool recursively) {
513    Statement * stmt = front();
514    // Note: by erasing the scope block, any Assign/Next nodes will be replaced with Zero and removed from
515    // the If/While node
516    while (stmt) {
517        stmt = stmt->eraseFromParent(recursively);
518    }
519    mAllocator.deallocate(reinterpret_cast<Allocator::pointer>(this));
520}
521
522
523// Assign sequential scope indexes, returning the next unassigned index   
524
525unsigned PabloBlock::enumerateScopes(unsigned baseScopeIndex) {
526    mScopeIndex = baseScopeIndex;
527    unsigned nextScopeIndex = baseScopeIndex + 1;
528    for (Statement * stmt : *this) {
529        if (If * ifStatement = dyn_cast<If>(stmt)) {
530            nextScopeIndex = ifStatement->getBody()->enumerateScopes(nextScopeIndex);
531        }
532        else if (While * whileStatement = dyn_cast<While>(stmt)) {
533            nextScopeIndex = whileStatement->getBody()->enumerateScopes(nextScopeIndex);
534        }
535    }
536    return nextScopeIndex;
537}   
538   
539/// CONSTRUCTOR
540
541PabloBlock::PabloBlock(SymbolGenerator * symbolGenerator) noexcept
542: PabloAST(PabloAST::ClassTypeId::Block)
543, mSymbolGenerator(symbolGenerator)
544, mParent(nullptr)
545, mBranch(nullptr)
546, mScopeIndex(0)
547{
548
549}
550
551PabloBlock::~PabloBlock() {
552
553}
554
555}
Note: See TracBrowser for help on using the repository browser.