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

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

New kernel infrastructure

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