Changeset 4438

Timestamp:

Jan 23, 2015, 1:52:33 PM (4 years ago)

Author:

nmedfort

Message:

Preliminary steps for removal of superfluous Assigns.

Location:

icGREP/icgrep-devel/icgrep

Files:

• CMakeLists.txt (modified) (1 diff)
• compiler.cpp (modified) (1 diff)
• pablo/codegenstate.cpp (modified) (11 diffs)
• pablo/codegenstate.h (modified) (3 diffs)
• pablo/pabloAST.h (modified) (1 diff)
• pablo/pablo_compiler.cpp (modified) (1 diff)
• pablo/pe_advance.h (modified) (1 diff)
• pablo/pe_and.cpp (deleted)
• pablo/pe_and.h (modified) (2 diffs)
• pablo/pe_call.h (modified) (1 diff)
• pablo/pe_matchstar.h (modified) (2 diffs)
• pablo/pe_not.cpp (deleted)
• pablo/pe_not.h (modified) (2 diffs)
• pablo/pe_or.cpp (deleted)
• pablo/pe_or.h (modified) (2 diffs)
• pablo/pe_scanthru.h (modified) (2 diffs)
• pablo/pe_sel.cpp (deleted)
• pablo/pe_sel.h (modified) (2 diffs)
• pablo/pe_xor.cpp (deleted)
• pablo/pe_xor.h (modified) (2 diffs)
• re/re_compiler.cpp (modified) (18 diffs)
• re/re_compiler.h (modified) (4 diffs)
• re/re_name.h (modified) (3 diffs)

icGREP/icgrep-devel/icgrep/CMakeLists.txt

@@ -53 +53 @@
 find_package(Boost)
 
-add_library(PabloADT pablo/pe_and.cpp pablo/pe_not.cpp pablo/pe_or.cpp pablo/pabloAST.cpp pablo/pe_sel.cpp pablo/pe_xor.cpp pablo/ps_assign.cpp pablo/ps_if.cpp pablo/ps_while.cpp pablo/codegenstate.cpp pablo/symbol_generator.cpp pablo/printer_pablos.cpp pablo/pablo_compiler.cpp pablo/optimizers/pablo_simplifier.cpp)
+add_library(PabloADT pablo/pabloAST.cpp pablo/ps_assign.cpp pablo/ps_if.cpp pablo/ps_while.cpp pablo/codegenstate.cpp pablo/symbol_generator.cpp pablo/printer_pablos.cpp pablo/pablo_compiler.cpp pablo/optimizers/pablo_simplifier.cpp)
 add_library(RegExpADT re/re_re.cpp re/re_cc.cpp re/re_parser.cpp re/re_rep.cpp re/parsefailure.cpp re/re_nullable.cpp re/re_simplifier.cpp re/re_compiler.cpp re/printer_re.cpp re/re_diff.cpp re/re_intersect.cpp re/re_analysis.cpp)
 add_library(CCADT cc/cc_namemap.cpp cc/cc_compiler.cpp utf8_encoder.cpp UCD/CaseFolding_txt.cpp)

icGREP/icgrep-devel/icgrep/compiler.cpp

@@ -130 +130 @@
     }
     
-    RE_Compiler re_compiler(main, nameMap);
+    RE_Compiler re_compiler(main);
     re_compiler.initializeRequiredStreams(cc_compiler);
     re_compiler.finalizeMatchResult(re_compiler.compile(re_ast));

icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

@@ -9 +9 @@
 namespace pablo {
 
+inline PabloAST * PabloBlock::renameNonNamedNode(PabloAST * expr, const std::string && prefix) {
+    if (Statement * stmt = dyn_cast<Statement>(expr)) {
+        if (stmt->getName()->isGenerated()) {
+            stmt->setName(makeName(prefix, false));
+        }
+    }
+    return expr;
+}
+
 /// UNARY CREATE FUNCTIONS
 
@@ -19 +28 @@
         return expr;
     }
-    return insertAtInsertionPoint(new Advance(expr, shiftAmount, mSymbolGenerator, this));
+    return insertAtInsertionPoint(new Advance(expr, shiftAmount, makeName("advance"), this));
+}
+
+PabloAST * PabloBlock::createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix) {
+    if (isa<Zeroes>(expr) || cast<Integer>(shiftAmount)->value() == 0) {
+        return expr;
+    }
+    return insertAtInsertionPoint(new Advance(expr, shiftAmount, makeName(prefix, false), this));
 }
 
@@ -25 +41 @@
     if (isa<Zeroes>(expr) || shiftAmount == 0) {
         return expr;
+    }
+    return insertAtInsertionPoint(new Advance(expr, mSymbolGenerator->getInteger(shiftAmount), makeName("advance"), this));
+}
+
+PabloAST * PabloBlock::createAdvance(PabloAST * expr, const int shiftAmount, const std::string prefix) {
+    if (isa<Zeroes>(expr) || shiftAmount == 0) {
+        return renameNonNamedNode(expr, std::move(prefix));
     }    
-    return insertAtInsertionPoint(new Advance(expr, mSymbolGenerator->getInteger(shiftAmount), mSymbolGenerator, this));
+    return insertAtInsertionPoint(new Advance(expr, mSymbolGenerator->getInteger(shiftAmount), makeName(prefix, false), this));
 }
 
@@ -45 +68 @@
         return not1->getExpr();
     }
-    return insertAtInsertionPoint(new Not(expr, this));
+    return insertAtInsertionPoint(new Not(expr, makeName("not"), this));
+}
+
+PabloAST * PabloBlock::createNot(PabloAST * expr, const std::string prefix) {
+    assert (expr);
+    if (isa<Ones>(expr)) {
+        return createZeroes();
+    }
+    else if (isa<Zeroes>(expr)){
+        return createOnes();
+    }
+    else if (Not * not1 = dyn_cast<Not>(expr)) {        
+        return renameNonNamedNode(not1->getExpr(), std::move(prefix));
+    }
+    return insertAtInsertionPoint(new Not(expr, makeName(prefix, false), this));
 }
 
@@ -65 +102 @@
         return marker;
     }
-    return insertAtInsertionPoint(new MatchStar(marker, charclass, mSymbolGenerator, this));
+    return insertAtInsertionPoint(new MatchStar(marker, charclass, makeName("matchstar"), this));
+}
+
+PabloAST * PabloBlock::createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix) {
+    assert (marker && charclass);
+    if (isa<Zeroes>(marker) || isa<Zeroes>(charclass)) {
+        return renameNonNamedNode(marker, std::move(prefix));
+    }
+    return insertAtInsertionPoint(new MatchStar(marker, charclass, makeName(prefix, false), this));
 }
 
@@ -73 +118 @@
         return from;
     }
-    return insertAtInsertionPoint(new ScanThru(from, thru, mSymbolGenerator, this));
+    return insertAtInsertionPoint(new ScanThru(from, thru, makeName("scanthru"), this));
+}
+
+PabloAST * PabloBlock::createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix) {
+    assert (from && thru);
+    if (isa<Zeroes>(from) || isa<Zeroes>(thru)) {        
+        return renameNonNamedNode(from, std::move(prefix));
+    }
+    return insertAtInsertionPoint(new ScanThru(from, thru, makeName(prefix, false), this));
 }
 
@@ -81 +134 @@
         return expr2;
     }
-    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
-        return expr1;
-    }
-    else if (equals(expr1, expr2)) {
+    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
         return expr1;
     }
@@ -103 +153 @@
         std::swap(expr1, expr2);
     }
-    return insertAtInsertionPoint(new And(expr1, expr2, this));
-}
-
+    return insertAtInsertionPoint(new And(expr1, expr2, makeName("and"), this));
+}
+
+
+PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
+    assert (expr1 && expr2);
+    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
+        return renameNonNamedNode(expr2, std::move(prefix));
+    }
+    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
+        return renameNonNamedNode(expr1, std::move(prefix));
+    }
+    else if (Not * not1 = dyn_cast<Not>(expr1)) {
+        if (Not * not2 = dyn_cast<Not>(expr2)) {
+            return createNot(createOr(not1->getExpr(), not2->getExpr()), prefix);
+        }
+        else if (equals(not1->getExpr(), expr2)) {
+            return createZeroes();
+        }
+    }
+    else if (Not * not2 = dyn_cast<Not>(expr2)) {
+        if (equals(expr1, not2->getExpr())) {
+            return createZeroes();
+        }
+    }
+    if (isa<Not>(expr1)) {
+        std::swap(expr1, expr2);
+    }
+    return insertAtInsertionPoint(new And(expr1, expr2, makeName(prefix, false), this));
+}
 
 PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2) {
     assert (expr1 && expr2);
-    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
-        return expr1;
-    }
-    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
+    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
         return expr2;
     }
-    else if (equals(expr1, expr2)) {
+    if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
         return expr1;
     }
@@ -151 +225 @@
         }
     }
-    return insertAtInsertionPoint(new Or(expr1, expr2, this));
+    return insertAtInsertionPoint(new Or(expr1, expr2, makeName("or"), this));
+}
+
+PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
+    assert (expr1 && expr2);
+    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
+        return renameNonNamedNode(expr2, std::move(prefix));
+    }
+    if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
+        return renameNonNamedNode(expr1, std::move(prefix));
+    }
+    else if (Not * not1 = dyn_cast<Not>(expr1)) {
+        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
+        return createNot(createAnd(not1->getExpr(), createNot(expr2)), prefix);
+    }
+    else if (Not * not2 = dyn_cast<Not>(expr2)) {
+        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
+        return createNot(createAnd(not2->getExpr(), createNot(expr1)), prefix);
+    }
+    else if (And * and_expr1 = dyn_cast<And>(expr1)) {
+        if (And * and_expr2 = dyn_cast<And>(expr2)) {
+            PabloAST * const expr1a = and_expr1->getExpr1();
+            PabloAST * const expr1b = and_expr1->getExpr2();
+            PabloAST * const expr2a = and_expr2->getExpr1();
+            PabloAST * const expr2b = and_expr2->getExpr2();
+            //These optimizations factor out common components that can occur when sets are formed by union
+            //(e.g., union of [a-z] and [A-Z].
+            if (equals(expr1a, expr2a)) {
+                return createAnd(expr1a, createOr(expr1b, expr2b), prefix);
+            }
+            else if (equals(expr1b, expr2b)) {
+                return createAnd(expr1b, createOr(expr1a, expr2a), prefix);
+            }
+            else if (equals(expr1a, expr2b)) {
+                return createAnd(expr1a, createOr(expr1b, expr2a), prefix);
+            }
+            else if (equals(expr1b, expr2a)) {
+                return createAnd(expr1b, createOr(expr1a, expr2b), prefix);
+            }
+        }
+    }
+    return insertAtInsertionPoint(new Or(expr1, expr2, makeName(prefix, false), this));
 }
 
@@ -173 +288 @@
         }
     }
-    return insertAtInsertionPoint(new Xor(expr1, expr2,  this));
+    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName("xor"), this));
+}
+
+PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
+    assert (expr1 && expr2);
+    if (isa<Ones>(expr1)) {
+        return createNot(expr2, prefix);
+    }
+    else if (isa<Zeroes>(expr1)){
+        return expr2;
+    }
+    else if (isa<Ones>(expr2)) {
+        return createNot(expr1, prefix);
+    }
+    else if (isa<Zeroes>(expr2)){
+        return expr1;
+    }
+    else if (Not * not1 = dyn_cast<Not>(expr1)) {
+        if (Not * not2 = dyn_cast<Not>(expr2)) {
+            return createXor(not1->getExpr(), not2->getExpr(), prefix);
+        }
+    }
+    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName(prefix, false), this));
 }
 
@@ -208 +345 @@
         return createXor(condition, falseExpr);
     }
-    return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, this));
+    return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, makeName("sel"), this));
+}
+
+PabloAST * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix) {
+    assert (condition && trueExpr && falseExpr);
+
+    if (isa<Zeroes>(condition)){
+        return renameNonNamedNode(falseExpr, std::move(prefix));
+    }
+    else if (isa<Ones>(condition) || equals(trueExpr, falseExpr)) {
+        return renameNonNamedNode(trueExpr, std::move(prefix));
+    }
+    else if (isa<Ones>(trueExpr)) {
+        return createOr(condition, falseExpr, prefix);
+    }
+    else if (isa<Zeroes>(trueExpr)){
+        return createAnd(createNot(condition), falseExpr, prefix);
+    }
+    else if (isa<Ones>(falseExpr)) {
+        return createOr(createNot(condition), trueExpr, prefix);
+    }
+    else if (isa<Zeroes>(falseExpr)){
+        return createAnd(condition, trueExpr, prefix);
+    }
+    else if (isa<Not>(trueExpr) && equals(cast<Not>(trueExpr)->getExpr(), falseExpr)) {
+        return createXor(condition, falseExpr, prefix);
+    }
+    else if (isa<Not>(falseExpr) && equals(trueExpr, cast<Not>(falseExpr)->getExpr())){
+        return createXor(condition, falseExpr, prefix);
+    }
+    return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, makeName(prefix, false), this));
 }
 

icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

@@ -82 +82 @@
     PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
 
+    PabloAST * createAdvance(PabloAST * expr, const int shiftAmount, const std::string prefix);
+
+    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
+
     inline Zeroes * createZeroes() const {
         return mZeroes;
@@ -112 +116 @@
     PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
 
+    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
+
     PabloAST * createNot(PabloAST * expr);
+
+    PabloAST * createNot(PabloAST * expr, const std::string prefix);
 
     PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
 
+    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
+
     PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
+
+    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
 
     PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
 
+    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix);
+
     PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
 
+    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix);
+
     PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
+
+    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix);
 
     If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body);
@@ -151 +169 @@
     PabloBlock(PabloBlock * predecessor);
 
+    PabloAST * renameNonNamedNode(PabloAST * expr, const std::string && prefix);
+
     template<typename Type>
     inline Type * insertAtInsertionPoint(Type * expr) {

icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

@@ -20 +20 @@
 
 class PabloBlock;
+class String;
 
 class PabloAST {

icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

@@ -58 +58 @@
 #include <llvm/Support/MemoryBuffer.h>
 #include <llvm/IR/IRBuilder.h>
-
 #include "llvm/Support/CommandLine.h"
-
+#include <iostream>
 
 cl::OptionCategory eIRDumpOptions("LLVM IR Dump Options", "These options control dumping of LLVM IR.");

icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

@@ -32 +32 @@
     }
 protected:
-    Advance(PabloAST * expr, PabloAST * shiftAmount, SymbolGenerator * sg, PabloBlock * parent)
-    : Statement(ClassTypeId::Advance, {expr, shiftAmount}, sg->make("advance"), parent)
+    Advance(PabloAST * expr, PabloAST * shiftAmount, String * name, PabloBlock * parent)
+    : Statement(ClassTypeId::Advance, {expr, shiftAmount}, name, parent)
     {
         assert(isa<Integer>(shiftAmount));

icGREP/icgrep-devel/icgrep/pablo/pe_and.h

@@ -9 +9 @@
 
 #include <pablo/pabloAST.h>
-#include <array>
 
 namespace pablo {
-
-class PabloBlock;
 
 class And : public Statement {
@@ -33 +30 @@
     }
 protected:
-    And(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
+    And(PabloAST * expr1, PabloAST * expr2, String * name, PabloBlock * parent)
+    : Statement(ClassTypeId::And, {expr1, expr2}, name, parent)
+    {
+
+    }
 };
 

icGREP/icgrep-devel/icgrep/pablo/pe_call.h

@@ -4 +4 @@
 #include <pablo/pabloAST.h>
 #include <pablo/pe_string.h>
-#include <iostream>
 
 namespace pablo {

icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

@@ -8 +8 @@
 #define PE_MATCHSTAR_H
 
-#include "pabloAST.h"
-#include <pablo/symbol_generator.h>
-#include <array>
+#include <pablo/pabloAST.h>
 
 namespace pablo {
@@ -31 +29 @@
     virtual ~MatchStar() {}
 protected:
-    MatchStar(PabloAST * marker, PabloAST * cc, SymbolGenerator * sg, PabloBlock * parent)
-    : Statement(ClassTypeId::MatchStar, {marker, cc}, sg->make("matchstar"), parent)
+    MatchStar(PabloAST * marker, PabloAST * cc, String * name, PabloBlock * parent)
+    : Statement(ClassTypeId::MatchStar, {marker, cc}, name, parent)
     {
 

icGREP/icgrep-devel/icgrep/pablo/pe_not.h

@@ -11 +11 @@
 
 namespace pablo {
-
-class PabloBlock;
 
 class Not : public Statement {
@@ -29 +27 @@
     }
 protected:
-    Not(PabloAST * expr, PabloBlock * parent);
+    Not(PabloAST * expr, String * name, PabloBlock * parent)
+    : Statement(ClassTypeId::Not, {expr}, name, parent)
+    {
+
+    }
 };
 

icGREP/icgrep-devel/icgrep/pablo/pe_or.h

@@ -9 +9 @@
 
 #include <pablo/pabloAST.h>
-#include <array>
 
 namespace pablo {
-
-class PabloBlock;
 
 class Or : public Statement {
@@ -33 +30 @@
     }
 protected:
-    Or(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
+    Or(PabloAST * expr1, PabloAST * expr2, String * name, PabloBlock * parent)
+    : Statement(ClassTypeId::Or, {expr1, expr2}, name, parent)
+    {
+
+    }
 };
 

icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

@@ -9 +9 @@
 
 #include <pablo/pabloAST.h>
-#include <pablo/symbol_generator.h>
-#include <array>
 
 namespace pablo {
@@ -32 +30 @@
     }
 protected:
-    ScanThru(PabloAST * from, PabloAST * thru, SymbolGenerator * sg, PabloBlock * parent)
-    : Statement(ClassTypeId::ScanThru, {from, thru}, sg->make("scanthru"), parent)
+    ScanThru(PabloAST * from, PabloAST * thru, String * name, PabloBlock * parent)
+    : Statement(ClassTypeId::ScanThru, {from, thru}, name, parent)
     {
 

icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

@@ -9 +9 @@
 
 #include <pablo/pabloAST.h>
-#include <array>
 
 namespace pablo {
-
-class PabloBlock;
 
 class Sel : public Statement {
@@ -36 +33 @@
     }
 protected:
-    Sel(PabloAST* if_expr, PabloAST* t_expr, PabloAST* f_expr, PabloBlock * parent);
+    Sel(PabloAST* if_expr, PabloAST* t_expr, PabloAST* f_expr, String * name, PabloBlock * parent)
+    : Statement(ClassTypeId::Sel, {if_expr, t_expr, f_expr}, name, parent)
+    {
+
+    }
 };
 

icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

@@ -12 +12 @@
 
 namespace pablo {
-
-class PabloBlock;
 
 class Xor : public Statement {
@@ -33 +31 @@
     }
 protected:
-    Xor(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
+    Xor(PabloAST * expr1, PabloAST * expr2, String * name, PabloBlock * parent)
+    : Statement(ClassTypeId::Xor, {expr1, expr2}, name, parent)
+    {
+
+    }
 };
 

icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

@@ -30 +30 @@
 
 
-RE_Compiler::RE_Compiler(PabloBlock & baseCG, const cc::CC_NameMap & nameMap)
-: mCG(baseCG)
+RE_Compiler::RE_Compiler(PabloBlock & baseCG)
+: mPB(baseCG)
 , mLineFeed(nullptr)
 , mInitial(nullptr)
@@ -43 +43 @@
     if (m.pos == newpos) return m;
     if (m.pos > newpos) throw std::runtime_error("icgrep internal error: attempt to AdvanceMarker backwards");
-    Assign * a = m.stream;
+    PabloAST * a = m.stream;
     if (m.pos == FinalMatchByte) {
         // Must advance at least to InitialPostPositionByte
@@ -77 +77 @@
     const std::string nonfinal = "nonfinal";
 
-    Assign * LF = mCG.createAssign("LF", ccc.compileCC(makeCC(0x0A)));
+    Assign * LF = mPB.createAssign("LF", ccc.compileCC(makeCC(0x0A)));
     mLineFeed = LF;
     PabloAST * CR = ccc.compileCC(makeCC(0x0D));
@@ -84 +84 @@
     mCRLF = mCG.createAnd(mCG.createAdvance(CR, 1), mLineFeed);
 #else
-    PabloBlock & crb = PabloBlock::Create(mCG);
+    PabloBlock & crb = PabloBlock::Create(mPB);
     Assign * cr1 = crb.createAssign("cr1", crb.createAdvance(CR, 1));
     Assign * acrlf = crb.createAssign("crlf", crb.createAnd(cr1, LF));
-    mCG.createIf(CR, std::move(std::vector<Assign *>{acrlf}), crb);
+    mPB.createIf(CR, std::move(std::vector<Assign *>{acrlf}), crb);
     mCRLF = acrlf;
 #endif
@@ -112 +112 @@
 #ifdef USE_IF_FOR_NONFINAL
     PabloAST * u8pfx = ccc.compileCC(makeCC(0xC0, 0xFF));
-    PabloBlock & it = PabloBlock::Create(mCG);
+    PabloBlock & it = PabloBlock::Create(mPB);
     PabloAST * u8pfx2 = ccc.compileCC(makeCC(0xC2, 0xDF), it);
     PabloAST * u8pfx3 = ccc.compileCC(makeCC(0xE0, 0xEF), it);
@@ -125 +125 @@
     PabloAST * LS_PS = it.createAnd(it.createAdvance(E2_80, 1), ccc.compileCC(makeCC(0xA8,0xA9), it));
     Assign * NEL_LS_PS = it.createAssign("NEL_LS_PS", it.createOr(NEL, LS_PS));
-    mCG.createIf(u8pfx, std::move(std::vector<Assign *>{valid_pfx, mNonFinal, NEL_LS_PS}), it);
-    PabloAST * LB_chars = mCG.createOr(LF_VT_FF_CR, NEL_LS_PS);
+    mPB.createIf(u8pfx, std::move(std::vector<Assign *>{valid_pfx, mNonFinal, NEL_LS_PS}), it);
+    PabloAST * LB_chars = mPB.createOr(LF_VT_FF_CR, NEL_LS_PS);
 
     PabloAST * u8single = ccc.compileCC(makeCC(0x00, 0x7F));
-    mInitial = mCG.createAssign(initial, mCG.createOr(u8single, valid_pfx));
-    mUnicodeLineBreak = mCG.createAnd(LB_chars, mCG.createNot(mCRLF));  // count the CR, but not CRLF
+    mInitial = mPB.createAssign(initial, mPB.createOr(u8single, valid_pfx));
+    mUnicodeLineBreak = mPB.createAnd(LB_chars, mPB.createNot(mCRLF));  // count the CR, but not CRLF
     #endif
 }
@@ -137 +137 @@
     //These three lines are specifically for grep.
     PabloAST * lb = UNICODE_LINE_BREAK ? mUnicodeLineBreak : mLineFeed;
-    Assign * v = markerVar(match_result);
-    mCG.createAssign("matches", mCG.createAnd(mCG.createMatchStar(v, mCG.createNot(lb)), lb), 0);
-    mCG.createAssign("lf", mCG.createAnd(lb, mCG.createNot(mCRLF)), 1);
+    PabloAST * v = markerVar(match_result);
+    mPB.createAssign("matches", mPB.createAnd(mPB.createMatchStar(v, mPB.createNot(lb)), lb), 0);
+    mPB.createAssign("lf", mPB.createAnd(lb, mPB.createNot(mCRLF)), 1);
 }
 
@@ -147 +147 @@
 
 PabloAST * RE_Compiler::character_class_strm(Name * name, PabloBlock & pb) {
-    Assign * var = name->getCompiled();
+    PabloAST * var = name->getCompiled();
     if (var) {
         return var;
@@ -154 +154 @@
         RE * def = name->getDefinition();
         if (def != nullptr) {
-            MarkerType m = compile(def, mCG);
+            MarkerType m = compile(def, mPB);
             assert(markerPos(m) == FinalMatchByte);
-            Assign * v = markerVar(m);
+            PabloAST * v = markerVar(m);
             name->setCompiled(v);
             return v;
@@ -177 +177 @@
     }
     else {
-        //return pb.createAdvanceThenScanThru(pb.createVar(markerVar(m), pb), mNonFinal);
         return pb.createScanThru(pb.createAnd(mInitial, pb.createAdvance(markerVar(m), 1)), mNonFinal);
     }
@@ -212 +211 @@
         MarkerType m = AdvanceMarker(marker, InitialPostPositionByte, pb);
         if (UNICODE_LINE_BREAK) {
-            PabloAST * line_end = mCG.createOr(mUnicodeLineBreak, mCRLF);
+            PabloAST * line_end = mPB.createOr(mUnicodeLineBreak, mCRLF);
             PabloAST * sol = pb.createNot(pb.createOr(pb.createAdvance(pb.createNot(line_end), 1), mCRLF));
             return makeMarker(InitialPostPositionByte, pb.createAssign("sol", pb.createAnd(markerVar(m), sol)));
@@ -279 +278 @@
         MarkerType lookback = compile(asserted, pb);
         AlignMarkers(m, lookback, pb);
-        Assign * lb = markerVar(lookback);
+        PabloAST * lb = markerVar(lookback);
         if (a->getSense() == Assertion::Sense::Negative) {
             lb = pb.createAssign("not", pb.createNot(lb));
@@ -288 +287 @@
         MarkerType lookahead = compile(asserted, pb);
         assert(markerPos(lookahead) == FinalMatchByte);
-        Assign * la = markerVar(lookahead);
+        PabloAST * la = markerVar(lookahead);
         if (a->getSense() == Assertion::Sense::Negative) {
             la = pb.createAssign("not", pb.createNot(la));
@@ -347 +346 @@
 */
 
-inline Assign * RE_Compiler::consecutive1(Assign * repeated, int repeated_lgth, int repeat_count, pablo::PabloBlock & pb) {
+inline PabloAST * RE_Compiler::consecutive1(PabloAST * repeated, int repeated_lgth, int repeat_count, pablo::PabloBlock & pb) {
         int i = repeated_lgth;
         int total_lgth = repeat_count * repeated_lgth;
-        Assign * consecutive_i = repeated;
+        PabloAST * consecutive_i = repeated;
         while (i * 2 <= total_lgth) {
             PabloAST * v = consecutive_i;
@@ -364 +363 @@
 }
 
-inline Assign * RE_Compiler::reachable(Assign * repeated, int repeated_lgth, int repeat_count, pablo::PabloBlock & pb) {
+inline PabloAST * RE_Compiler::reachable(PabloAST *repeated, int repeated_lgth, int repeat_count, pablo::PabloBlock & pb) {
         int i = repeated_lgth;
         int total_lgth = repeat_count * repeated_lgth;
@@ -370 +369 @@
             return repeated;
         }
-        Assign * reachable_i = pb.createAssign("within1", pb.createOr(repeated, pb.createAdvance(repeated, 1)));
+        PabloAST * reachable_i = pb.createAssign("within1", pb.createOr(repeated, pb.createAdvance(repeated, 1)));
         while (i * 2 < total_lgth) {
             PabloAST * v = reachable_i;
@@ -386 +385 @@
 MarkerType RE_Compiler::processLowerBound(RE * repeated, int lb, MarkerType marker, PabloBlock & pb) {
     if (isByteLength(repeated)) {
-        Assign * cc = markerVar(compile(repeated, pb));
-        Assign * cc_lb = consecutive1(cc, 1, lb, pb);
+        PabloAST * cc = markerVar(compile(repeated, pb));
+        PabloAST * cc_lb = consecutive1(cc, 1, lb, pb);
         PabloAST * marker_fwd = pb.createAdvance(markerVar(marker), markerPos(marker) == FinalMatchByte ? lb : lb-1);
         return makeMarker(FinalMatchByte, pb.createAssign("lowerbound", pb.createAnd(marker_fwd, cc_lb)));
@@ -403 +402 @@
         // Create a mask of positions reachable within ub from current marker.
         // Use matchstar, then apply filter.
-        Assign * match = markerVar(AdvanceMarker(marker, InitialPostPositionByte, pb));
-        Assign * upperLimitMask = reachable(match, 1, ub, pb);
+        PabloAST * match = markerVar(AdvanceMarker(marker, InitialPostPositionByte, pb));
+        PabloAST * upperLimitMask = reachable(match, 1, ub, pb);
         PabloAST * cursor = markerVar(AdvanceMarker(marker, InitialPostPositionByte, pb));
         PabloAST * rep_class_var = markerVar(compile(repeated, pb));

icGREP/icgrep-devel/icgrep/re/re_compiler.h

@@ -44 +44 @@
 struct MarkerType { 
     MarkerPosition pos;
-    pablo::Assign * stream;
+    pablo::PabloAST * stream;
 };
 
 inline MarkerPosition markerPos(MarkerType m) {return m.pos;}
 
-inline pablo::Assign * markerVar(MarkerType m) {return m.stream;}
+inline pablo::PabloAST * markerVar(MarkerType m) {return m.stream;}
     
 inline MarkerType makeMarker(MarkerPosition newpos, pablo::Assign * strm) {return {newpos, strm};}
@@ -57 +57 @@
 public:
 
-    RE_Compiler(pablo::PabloBlock & baseCG, const cc::CC_NameMap & nameMap);
+    RE_Compiler(pablo::PabloBlock & baseCG);
     void initializeRequiredStreams(cc::CC_Compiler & ccc);
     void finalizeMatchResult(MarkerType match_result);
     MarkerType compile(RE * re) {
-        return compile(re, mCG);
+        return compile(re, mPB);
     }
 
@@ -81 +81 @@
     MarkerType process(Diff * diff, MarkerType marker, pablo::PabloBlock & cg);
     MarkerType process(Intersect * x, MarkerType marker, pablo::PabloBlock & cg);
-    pablo::Assign * consecutive1(pablo::Assign * repeated,  int repeated_lgth, int repeat_count, pablo::PabloBlock & pb);
-    pablo::Assign * reachable(pablo::Assign * repeated,  int repeated_lgth, int repeat_count, pablo::PabloBlock & pb);
+    pablo::PabloAST *consecutive1(pablo::PabloAST *repeated,  int repeated_lgth, int repeat_count, pablo::PabloBlock & pb);
+    pablo::PabloAST * reachable(pablo::PabloAST * repeated,  int repeated_lgth, int repeat_count, pablo::PabloBlock & pb);
     static bool isFixedLength(RE * regexp);
     MarkerType processLowerBound(RE * repeated,  int lb, MarkerType marker, pablo::PabloBlock & pb);
@@ -88 +88 @@
     MarkerType processBoundedRep(RE * repeated, int ub, MarkerType marker, pablo::PabloBlock & pb);
 
-    pablo::PabloBlock &                             mCG;
+    pablo::PabloBlock &                             mPB;
     pablo::Assign *                                 mLineFeed;
     pablo::PabloAST *                               mCRLF;

icGREP/icgrep-devel/icgrep/re/re_name.h

@@ -5 +5 @@
 #include <re/re_cc.h>
 #include <string>
-#include <iostream>
 #include <re/printer_re.h>
 
 namespace pablo {
-    class Assign;
+    class PabloAST;
 }
 
@@ -34 +33 @@
     Type getType() const;
     RE *getDefinition() const;
-    pablo::Assign * getCompiled() const {
+    pablo::PabloAST * getCompiled() const {
         return mCompiled;
     }
-    void setCompiled(pablo::Assign * var) {
+    void setCompiled(pablo::PabloAST * var) {
         mCompiled = var;
     }
@@ -62 +61 @@
 
 private:
-    std::string     mNamespace;
-    std::string     mName;
-    const Type      mType;
-    RE *            mDefiningRE;
-    pablo::Assign * mCompiled;
+    std::string         mNamespace;
+    std::string         mName;
+    const Type          mType;
+    RE *                mDefiningRE;
+    pablo::PabloAST *   mCompiled;
 };