Changeset 4214


Ignore:
Timestamp:
Oct 5, 2014, 5:27:31 PM (5 years ago)
Author:
nmedfort
Message:

Partial implementation of 'PabloBuilder?'.

Location:
icGREP/icgrep-devel/icgrep
Files:
29 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.cpp

    r4213 r4214  
    6161                    assert (name);
    6262                    CharClass * cc = mCG.createCharClass(name->getName());
    63                     PabloE * sym = marker ? makeAnd(marker, cc) : cc;
     63                    PabloE * sym = marker ? mCG.createAnd(marker, cc) : cc;
    6464                    if (++j != seq->end()) {
    65                         marker = makeAdvance(sym);
     65                        marker = mCG.createAdvance(sym);
    6666                        mCG.push_back(marker);
    6767                        continue;
     
    9494    }
    9595    else {
    96         return add_assignment(mCG.symgen(mGenSymPattern), expr);
     96        return add_assignment(mCG.ssa(mGenSymPattern), expr);
    9797    }
    9898}
     
    139139            if ((pattern & test_bit) == 0)
    140140            {
    141                 bit_terms.push_back(makeNot(getBasisVar(bit_no)));
     141                bit_terms.push_back(mCG.createNot(getBasisVar(bit_no)));
    142142            }
    143143            else
     
    160160        for (unsigned long i = 0; i < (bit_terms.size()/2); i++)
    161161        {
    162             new_terms.push_back(makeAnd(bit_terms[(2 * i) + 1], bit_terms[2 * i]));
     162            new_terms.push_back(mCG.createAnd(bit_terms[(2 * i) + 1], bit_terms[2 * i]));
    163163        }
    164164        if (bit_terms.size() % 2 == 1)
     
    198198    PabloE* hi_test = LE_Range(diff_count - 1, n2 & mask1);
    199199
    200     return makeAnd(common, makeSel(getBasisVar(diff_count - 1), hi_test, lo_test));
     200    return mCG.createAnd(common, mCG.createSel(getBasisVar(diff_count - 1), hi_test, lo_test));
    201201}
    202202
     
    208208    else if (((N % 2) == 0) && ((n >> (N - 2)) == 0))
    209209    {
    210         return makeOr(makeOr(getBasisVar(N - 1), getBasisVar(N - 2)), GE_Range(N - 2, n));
     210        return mCG.createOr(mCG.createOr(getBasisVar(N - 1), getBasisVar(N - 2)), GE_Range(N - 2, n));
    211211    }
    212212    else if (((N % 2) == 0) && ((n >> (N - 2)) == 3))
    213213    {
    214         return makeAnd(makeAnd(getBasisVar(N - 1), getBasisVar(N - 2)), GE_Range(N - 2, n - (3 << (N - 2))));
     214        return mCG.createAnd(mCG.createAnd(getBasisVar(N - 1), getBasisVar(N - 2)), GE_Range(N - 2, n - (3 << (N - 2))));
    215215    }
    216216    else if (N >= 1)
     
    226226              the value of GE_range(N-1), lo_range) is required.
    227227            */
    228             return makeOr(getBasisVar(N - 1), lo_range);
     228            return mCG.createOr(getBasisVar(N - 1), lo_range);
    229229        }
    230230        else
     
    234234              in the target for >= and GE_range(N-1, lo_bits) must also be true.
    235235            */
    236             return makeAnd(getBasisVar(N - 1), lo_range);
     236            return mCG.createAnd(getBasisVar(N - 1), lo_range);
    237237        }
    238238    }
     
    250250    }
    251251    else {
    252         return makeNot(GE_Range(N, n + 1));
     252        return mCG.createNot(GE_Range(N, n + 1));
    253253    }
    254254}
     
    285285                PabloE * bit0 = getBasisVar(0);
    286286                if ((lo & 1) == 0) {
    287                     bit0 = makeNot(bit0);
     287                    bit0 = mCG.createNot(bit0);
    288288                }
    289                 return makeAnd(expr, bit0);
     289                return mCG.createAnd(expr, bit0);
    290290            }
    291291        }
     
    294294    for (const CharSetItem & item : *cc) {
    295295        PabloE * temp = char_or_range_expr(item.lo_codepoint, item.hi_codepoint);
    296         expr = (expr == nullptr) ? temp : makeOr(expr, temp);
     296        expr = (expr == nullptr) ? temp : mCG.createOr(expr, temp);
    297297    }
    298298    return expr;
     
    372372    else if (Sel * pe_sel = dyn_cast<Sel>(expr))
    373373    {
    374         Expression* ret_sel = expr_to_variable(expr2pabloe(pe_sel->getIf_expr()));
    375         Expression* ret_true = expr_to_variable(expr2pabloe(pe_sel->getT_expr()));
    376         Expression* ret_false = expr_to_variable(expr2pabloe(pe_sel->getF_expr()));
     374        Expression* ret_sel = expr_to_variable(expr2pabloe(pe_sel->getCondition()));
     375        Expression* ret_true = expr_to_variable(expr2pabloe(pe_sel->getTrueExpr()));
     376        Expression* ret_false = expr_to_variable(expr2pabloe(pe_sel->getFalseExpr()));
    377377        retExpr->expr_string = "((" + ret_sel->expr_string + "&" + ret_true->expr_string + ")|(~("
    378378            + ret_sel->expr_string + ")&" + ret_false->expr_string + ")";       
  • icGREP/icgrep-devel/icgrep/llvm_gen.cpp

    r4211 r4214  
    807807    else if (Sel * pablo_sel = dyn_cast<Sel>(expr))
    808808    {
    809         DeclareCallFunctions_PabloE(pablo_sel->getIf_expr());
    810         DeclareCallFunctions_PabloE(pablo_sel->getT_expr());
    811         DeclareCallFunctions_PabloE(pablo_sel->getF_expr());
     809        DeclareCallFunctions_PabloE(pablo_sel->getCondition());
     810        DeclareCallFunctions_PabloE(pablo_sel->getTrueExpr());
     811        DeclareCallFunctions_PabloE(pablo_sel->getFalseExpr());
    812812    }
    813813    else if (Not * pablo_not = dyn_cast<Not>(expr))
     
    10581058    {
    10591059        IRBuilder<>b(mBasicBlock);
    1060         Value* ifMask = Generate_PabloE(pablo_sel->getIf_expr());
    1061         Value* and_if_true_result = b.CreateAnd(ifMask, Generate_PabloE(pablo_sel->getT_expr()));
    1062         Value* and_if_false_result = b.CreateAnd(genNot(ifMask), Generate_PabloE(pablo_sel->getF_expr()));
     1060        Value* ifMask = Generate_PabloE(pablo_sel->getCondition());
     1061        Value* and_if_true_result = b.CreateAnd(ifMask, Generate_PabloE(pablo_sel->getTrueExpr()));
     1062        Value* and_if_false_result = b.CreateAnd(genNot(ifMask), Generate_PabloE(pablo_sel->getFalseExpr()));
    10631063        Value* or_result = b.CreateOr(and_if_true_result, and_if_false_result);
    10641064
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

    r4213 r4214  
    99namespace pablo {
    1010
    11 String * CodeGenState::getString(const std::string string) {
    12     auto f = mStringMap.find(string);
    13     String * result;
    14     if (f == mStringMap.end()) {
    15         result = makeString(string);
    16         mStringMap.insert(std::make_pair(*result, result));
    17     }
    18     else {
    19         result = f->second;
    20     }
    21     return result;
     11/// UNARY CREATE FUNCTIONS
     12
     13Advance * CodeGenState::createAdvance(PabloE * expr) {
     14    return mUnary.findOrMake<Advance>(PabloE::ClassTypeId::Advance, expr);
    2215}
    2316
    2417Call * CodeGenState::createCall(const std::string name) {
    25     return makeCall(getString(name));
     18    return mUnary.findOrMake<Call>(PabloE::ClassTypeId::Call, mSymbolGenerator[name]);
     19}
     20
     21CharClass * CodeGenState::createCharClass(const std::string name) {
     22    return mUnary.findOrMake<CharClass>(PabloE::ClassTypeId::CharClass, mSymbolGenerator[name]);
     23}
     24
     25PabloE * CodeGenState::createNot(PabloE * expr) {
     26    return mUnary.findOrCall<OptimizeNot>(PabloE::ClassTypeId::Not, expr);
    2627}
    2728
    2829Var * CodeGenState::createVar(const std::string name) {
    29     return makeVar(getString(name));
     30    return mUnary.findOrMake<Var>(PabloE::ClassTypeId::Var, mSymbolGenerator[name]);
    3031}
    3132
    32 Var * CodeGenState::createVar(const Assign * assign) {
    33     return makeVar(assign);
     33Var * CodeGenState::createVar(Assign * assign) {
     34    return mUnary.findOrMake<Var>(PabloE::ClassTypeId::Var, const_cast<String *>(assign->mName));
    3435}
    3536
    36 CharClass * CodeGenState::createCharClass(const std::string name) {
    37     return makeCharClass(getString(name));
     37/// BINARY CREATE FUNCTIONS
     38
     39PabloE * CodeGenState::createAnd(PabloE * expr1, PabloE * expr2) {
     40    if (expr1 < expr2) {
     41        std::swap(expr1, expr2);
     42    }
     43    return mBinary.findOrCall<OptimizeAnd>(PabloE::ClassTypeId::And, expr1, expr2);
    3844}
    3945
    40 Assign *CodeGenState::createAssign(const std::string name, PabloE * expr) {
    41     return makeAssign(getString(name), expr);
     46Assign * CodeGenState::createAssign(const std::string name, PabloE * expr) {
     47    return mBinary.findOrMake<Assign>(PabloE::ClassTypeId::Assign, mSymbolGenerator[name], expr);
     48}
     49
     50MatchStar * CodeGenState::createMatchStar(PabloE * expr1, PabloE * expr2) {
     51    return mBinary.findOrMake<MatchStar>(PabloE::ClassTypeId::MatchStar, expr1, expr2);
     52}
     53
     54PabloE * CodeGenState::createOr(PabloE * expr1, PabloE * expr2) {
     55    if (expr1 < expr2) {
     56        std::swap(expr1, expr2);
     57    }
     58    return mBinary.findOrCall<OptimizeOr>(PabloE::ClassTypeId::Or, expr1, expr2);
     59}
     60
     61ScanThru * CodeGenState::createScanThru(PabloE * from, PabloE * thru) {
     62    return mBinary.findOrMake<ScanThru>(PabloE::ClassTypeId::ScanThru, from, thru);
     63}
     64
     65PabloE * CodeGenState::createXor(PabloE * expr1, PabloE * expr2) {
     66    if (expr1 < expr2) {
     67        std::swap(expr1, expr2);
     68    }
     69    return mBinary.findOrCall<OptimizeXor>(PabloE::ClassTypeId::Xor, expr1, expr2);
     70}
     71
     72/// TERNARY CREATE FUNCTION
     73
     74PabloE *CodeGenState::createSel(PabloE * condition, PabloE * trueExpr, PabloE * falseExpr) {
     75    return mTernary.findOrCall<OptimizeSel>(PabloE::ClassTypeId::Sel, condition, trueExpr, falseExpr);
    4276}
    4377
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4213 r4214  
    2626#include <pablo/ps_if.h>
    2727#include <pablo/ps_while.h>
     28#include <pablo/symbol_generator.h>
    2829#include <unordered_map>
    2930#include <vector>
    3031#include <string>
    3132#include <array>
    32 #include <pablo/symbol_generator.h>
     33#include <tuple>
    3334
    3435namespace pablo {
     
    3839    CodeGenState(SymbolGenerator & symgen)
    3940    : mSymbolGenerator(symgen)
    40     , mPredecessor(nullptr)
    4141    , mAll{{makeAll(0), makeAll(1)}}
     42    , mUnary(nullptr, this)
     43    , mBinary(nullptr, this)
     44    , mTernary(nullptr, this)
    4245    {
    4346
     
    4649    CodeGenState(CodeGenState & cg)
    4750    : mSymbolGenerator(cg.mSymbolGenerator)
    48     , mPredecessor(&cg)
    4951    , mAll(cg.mAll)    // inherit the original "All" variables for simplicity
     52    , mUnary(&(cg.mUnary), this)
     53    , mBinary(&(cg.mBinary), this)
     54    , mTernary(&(cg.mTernary), this)
    5055    {
    5156
    5257    }
     58
     59    Advance * createAdvance(PabloE * expr);
    5360
    5461    inline All * createAll(const bool value) const {
     
    5663    }
    5764
     65    Assign * createAssign(const std::string name, PabloE * expr);
     66
    5867    Call * createCall(const std::string name);
    59 
    60     Var * createVar(const Assign * assign);
    6168
    6269    Var * createVar(const std::string name);
    6370
     71    Var * createVar(Assign * assign);
     72
    6473    inline PabloE * createVarIfAssign(PabloE * const input) {
    65         return isa<Assign>(input) ? createVar(cast<const Assign>(input)) : input;
     74        return isa<Assign>(input) ? createVar(cast<Assign>(input)) : input;
    6675    }
    6776
    6877    CharClass * createCharClass(const std::string name);
    69     Assign * createAssign(const std::string name, PabloE * expr);
    7078
    71 //    PabloE * createAdvance(PabloE * expr);
    72 //    PabloE * createNot(PabloE * expr);
    73 //    PabloE * createCall(const std::string name);
    74 //    PabloE * createVar(const std::string name);
    75 //    PabloE * createCharClass(const std::string name);
    76 //    PabloE * createAssign(const std::string name, PabloE * expr);
    77 //    PabloE * createAnd(PabloE * expr1, PabloE * expr2);
    78 //    PabloE * createOr(PabloE * expr1, PabloE * expr2);
    79 //    PabloE * createXor(PabloE * expr1, PabloE * expr2);
    80 //    PabloE * createMatchStar(PabloE * expr1, PabloE * expr2);
    81 //    PabloE * createScanThru(PabloE * from, PabloE * thru);
     79    PabloE * createAnd(PabloE * expr1, PabloE * expr2);
    8280
     81    PabloE * createNot(PabloE * expr);
    8382
     83    PabloE * createOr(PabloE * expr1, PabloE * expr2);
    8484
    85 //    struct ExpressionTable {
    86 //        inline PabloE * find(PabloE * inst) {
    87 //            switch(inst->getClassTypeId()) {
    88 //                // UNARY
    89 //                case All:       // bool
    90 //                case Advance:   // pe
    91 //                case Not:       // pe
     85    PabloE * createXor(PabloE * expr1, PabloE * expr2);
    9286
    93 //                case Call:      // string
    94 //                case Var:       // string
    95 //                case CharClass: // string
    96 //                // BINARY
    97 //                case Assign:    // string, pe
     87    MatchStar * createMatchStar(PabloE * expr1, PabloE * expr2);
    9888
    99 //                case And:       // pe, pe
    100 //                case Or:        // pe, pe
    101 //                case Xor:       // pe, pe
    102 //                case MatchStar: // pe, pe
    103 //                case ScanThru:  // pe, pe
     89    ScanThru * createScanThru(PabloE * from, PabloE * thru);
    10490
    105 //                case If:        // pe, pe list
    106 //                case While:     // pe, pe list
    107 //                // TERNARY
    108 //                case Sel:       // pe, pe, pe
    109 //            }
     91    PabloE * createSel(PabloE * condition, PabloE * trueExpr, PabloE * falseExpr);
    11092
     93    template<typename... Args>
     94    struct ExpressionMap {
     95        typedef ExpressionMap<Args...> MapType;
     96        typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
    11197
    112 //            switch (inst.getNumOperands()) {
    113 //                case 1: return _unary.find(&inst, inst.getType(), inst.getOperand(0));
    114 //                case 2: return _binary.find(&inst, inst.getOperand(0), inst.getOperand(1));
    115 //                case 3: return _ternary.find(&inst, inst.getOperand(0), inst.getOperand(1), inst.getOperand(2));
    116 //                default: return nullptr;
    117 //            }
    118 //        }
    119 //    private:
    120 //        template<typename... Args>
    121 //        struct ExpressionMap {
    122 //            typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
    123 //            inline Instruction * find(Instruction * inst, Args... args) {
    124 //                auto key = std::make_tuple(inst->getOpcode(), args...);
    125 //                auto itr = _map.find(key);
    126 //                if (itr == _map.end()) {
    127 //                    _map.insert(std::make_pair(std::move(key), inst));
    128 //                    return nullptr;
    129 //                }
    130 //                return itr->second;
    131 //            }
    132 //        private:
    133 //            std::unordered_map<Key, PabloE *>                           _map;
    134 //        };
    135 //        ExpressionMap<const PabloE *>                                   _unary;
    136 //        ExpressionMap<const PabloE *, const PabloE *>                   _binary;
    137 //        ExpressionMap<const PabloE *, const PabloE *, const PabloE *>   _ternary;
    138 //    };
     98        inline ExpressionMap(MapType * predecessor, CodeGenState * parent)
     99        : mPredecessor(predecessor)
     100        , mCodeGenState(*parent)
     101        {
    139102
    140 //    template<typename... Args>
    141 //    struct ExpressionMap {
    142 //        typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
     103        }
    143104
    144 //        inline PabloE * find(const PabloE::ClassTypeId type, Args... args) {
    145 //            auto key = std::make_tuple(type, args...);
    146 //            auto itr = _map.find(key);
    147 //            if (itr == _map.end()) {
    148 //                _map.insert(std::make_pair(std::move(key), inst));
    149 //                return nullptr;
    150 //            }
    151 //            return itr->second;
    152 //        }
     105        template <class Type>
     106        inline Type * findOrMake(const PabloE::ClassTypeId type, Args... args) {
     107            auto key = std::make_tuple(type, args...);
     108            PabloE * f = find(key);
     109            if (f) {
     110                return cast<Type>(f);
     111            }
     112            Type * expr = new Type(args...);
     113            mMap.insert(std::make_pair(std::move(key), expr));
     114            return expr;
     115        }
    153116
    154 //        inline PabloE * find(const PabloE::ClassTypeId type, Args... args) {
    155 //            auto key = std::make_tuple(type, args...);
    156 //            auto itr = _map.find(key);
    157 //            if (itr == _map.end()) {
    158 //                _map.insert(std::make_pair(std::move(key), inst));
    159 //                return nullptr;
    160 //            }
    161 //            return itr->second;
    162 //        }
     117        template <class Functor>
     118        inline PabloE * findOrCall(const PabloE::ClassTypeId type, Args... args) {
     119            auto key = std::make_tuple(type, args...);
     120            PabloE * f = find(key);
     121            if (f) {
     122                return f;
     123            }
     124            Functor mf(mCodeGenState);
     125            PabloE * expr = mf(args...);
     126            mMap.insert(std::make_pair(std::move(key), expr));
     127            return expr;
     128        }
    163129
    164 //    private:
    165 //        std::unordered_map<Key, PabloE *> _map;
    166 //    };
     130    private:
    167131
     132        inline PabloE * find(const Key & key) {
     133            // check this map to see if we have it
     134            auto itr = mMap.find(key);
     135            if (itr != mMap.end()) {
     136                return itr->second;
     137            }
     138            // check any previous maps to see if it exists
     139            auto * pred = mPredecessor;
     140            while (pred) {
     141                itr = pred->mMap.find(key);
     142                if (itr == pred->mMap.end()) {
     143                    pred = pred->mPredecessor;
     144                    continue;
     145                }
     146                return itr->second;
     147            }
     148            return nullptr;
     149        }
    168150
     151    private:
     152        MapType * const         mPredecessor;
     153        CodeGenState &          mCodeGenState;
     154        std::map<Key, PabloE *> mMap;
     155    };
    169156
    170157    inline void push_back(PabloE * expr) {
     
    172159    }
    173160
    174     inline std::string symgen(std::string prefix) {
    175         return mSymbolGenerator.get(prefix);
     161    inline std::string ssa(std::string prefix) { // Static Single-Assignment
     162        return mSymbolGenerator.ssa(prefix);
    176163    }
    177164
     
    180167    }
    181168
    182 protected:
    183 
    184     String * getString(const std::string string);
    185 
    186169private:   
    187     SymbolGenerator &                           mSymbolGenerator;
    188     CodeGenState * const                        mPredecessor;
    189     const std::array<All *, 2>                  mAll;
    190     std::unordered_map<std::string, String *>   mStringMap;
    191 
    192 
    193     std::list<PabloE *>                         mExpressions;
     170    SymbolGenerator &                               mSymbolGenerator;
     171    const std::array<All *, 2>                      mAll;
     172    ExpressionMap<PabloE *>                         mUnary;
     173    ExpressionMap<PabloE *, PabloE *>               mBinary;
     174    ExpressionMap<PabloE *, PabloE *, PabloE *>     mTernary;
     175    std::list<PabloE *>                             mExpressions;
    194176};
    195177
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4209 r4214  
    1414class Advance : public PabloE {
    1515    friend Advance * makeAdvance(PabloE * expr);
     16    friend struct CodeGenState;
    1617public:
    1718    static inline bool classof(const PabloE * e) {
     
    2223    }
    2324    virtual ~Advance() {
    24         delete mExpr;
    2525    }
    26 
    2726    inline PabloE * getExpr() const {
    2827        return mExpr;
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4209 r4214  
    55 */
    66
    7 #include "pe_and.h"
    8 #include "pe_all.h"
    9 #include "pe_not.h"
    10 #include "pe_or.h"
     7#include <pablo/pe_and.h>
     8#include <pablo/codegenstate.h>
    119
    1210namespace pablo {
    1311
    14 PabloE * makeAnd(PabloE * expr1, PabloE *expr2) {
     12PabloE * OptimizeAnd::operator ()(PabloE * expr1, PabloE * expr2) {
    1513    if (All * all = dyn_cast<All>(expr1)) {
    1614        if (all->getValue()) {
     
    1816        }
    1917        else {
    20             return makeAll(0);
     18            return cg.createAll(0);
    2119        }
    2220    }
     
    2624        }
    2725        else {
    28             return makeAll(0);
     26            return cg.createAll(0);
    2927        }
    3028    }
     
    3432    else if (Not * pe_not_e1 = dyn_cast<Not>(expr1)) {
    3533        if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    36             return makeNot(makeOr(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
     34            return cg.createNot(cg.createOr(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
    3735        }
    3836        else if (equals(pe_not_e1->getExpr(), expr2)) {
    39             return makeAll(0);
     37            return cg.createAll(0);
    4038        }
    4139    }
    4240    else if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    4341        if (equals(expr1, pe_not_e2->getExpr())) {
    44             return makeAll(0);
     42            return cg.createAll(0);
    4543        }
    4644    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4209 r4214  
    88#define PE_AND_H
    99
    10 #include "pe_pabloe.h"
     10#include <pablo/pe_pabloe.h>
    1111
    1212namespace pablo {
    1313
     14struct CodeGenState;
     15
    1416class And : public PabloE {
    15     friend PabloE * makeAnd(PabloE *, PabloE *);
     17    friend struct OptimizeAnd;
     18    friend struct CodeGenState;
    1619public:
    1720    static inline bool classof(const PabloE * e) {
     
    2225    }
    2326    virtual ~And() {
    24         delete mExpr1;
    25         delete mExpr2;
    2627    }
    2728    PabloE * getExpr1() const {
     
    4445};
    4546
    46 PabloE * makeAnd(PabloE * expr1, PabloE * expr2);
     47struct OptimizeAnd {
     48    inline OptimizeAnd(CodeGenState & cg) : cg(cg) {}
     49    PabloE * operator()(PabloE * expr1, PabloE * expr2);
     50private:
     51    CodeGenState & cg;
     52};
     53
     54inline PabloE * makeAnd(PabloE * expr1, PabloE * expr2, CodeGenState & cg) {
     55    OptimizeAnd run(cg);
     56    return run(expr1, expr2);
     57}
    4758
    4859}
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r4213 r4214  
    88
    99class Call : public PabloE {
    10     friend Call * makeCall(const String *);
     10    friend Call * makeCall(PabloE *);
     11    friend struct CodeGenState;
    1112public:
    1213    static inline bool classof(const PabloE * e) {
     
    1718    }
    1819    virtual ~Call() {
    19 
    2020    }
    2121    inline const std::string & getCallee() const {
    2222        return *mCallee;
    2323    }
    24 protected:
    25     Call(const String * callee)
     24protected:   
     25    Call(const PabloE * callee)
    2626    : PabloE(ClassTypeId::Call)
    27     , mCallee(callee) {
     27    , mCallee(cast<String>(callee)) {
    2828
    2929    }
     
    3131    const String * const mCallee;
    3232};
    33 
    34 inline Call * makeCall(const String * callee) {
     33inline Call * makeCall(PabloE * callee) {
    3534    return new Call(callee);
    3635}
    37 
    3836}
    3937
  • icGREP/icgrep-devel/icgrep/pablo/pe_charclass.h

    r4213 r4214  
    1515class CharClass : public PabloE {
    1616    friend CharClass * makeCharClass(const String *);
     17    friend struct CodeGenState;
    1718public:
    1819    static inline bool classof(const PabloE * e) {
     
    2324    }
    2425    virtual ~CharClass(){
    25 
    2626    }
    2727    inline const std::string & getCharClass() const {
     
    2929    }
    3030protected:
    31     CharClass(const String * cc)
     31    CharClass(const PabloE * cc)
    3232    : PabloE(ClassTypeId::CharClass)
    33     , mCharClass(cc)
     33    , mCharClass(cast<String>(cc))
    3434    {
    3535
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4209 r4214  
    1414class MatchStar : public PabloE {
    1515    friend MatchStar * makeMatchStar(PabloE *, PabloE *);
     16    friend struct CodeGenState;
    1617public:
    1718    static inline bool classof(const PabloE * e) {
     
    2223    }
    2324    virtual ~MatchStar() {
    24         delete mExpr1;
    25         delete mExpr2;
    2625    }
    27 
    2826    inline PabloE * getExpr1() const {
    2927        return mExpr1;
    3028    }
    31 
    3229    inline PabloE * getExpr2() const  {
    3330        return mExpr2;
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.cpp

    r4209 r4214  
    55 */
    66
    7 #include "pe_not.h"
    8 #include "pe_all.h"
     7#include <pablo/pe_not.h>
     8#include <pablo/codegenstate.h>
     9
    910
    1011namespace pablo {
    1112
    12 PabloE * makeNot(PabloE * expr) {
     13PabloE * OptimizeNot::operator ()(PabloE * expr) {
    1314    if (All * all = dyn_cast<All>(expr)) {
    14         return makeAll(!all->getValue());
     15        return cg.createAll(!all->getValue());
    1516    }
    1617    else if (Not * pe_not = dyn_cast<Not>(expr)) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.h

    r4209 r4214  
    88#define PE_NOT_H
    99
    10 #include "pe_pabloe.h"
     10#include <pablo/pe_pabloe.h>
    1111
    1212namespace pablo {
    1313
     14struct CodeGenState;
     15
    1416class Not : public PabloE {
    15     friend PabloE * makeNot(PabloE *);
     17    friend struct OptimizeNot;
     18    friend struct CodeGenState;
    1619public:
    1720    static inline bool classof(const PabloE * e) {
     
    2124        return false;
    2225    }
    23 
    24 
    25     ~Not() {
    26         delete mExpr;
     26    virtual ~Not() {
    2727    }
    2828    PabloE * getExpr() const {
     
    3838    PabloE * const mExpr;
    3939};
     40struct OptimizeNot {
     41    inline OptimizeNot(CodeGenState & cg) : cg(cg) {}
     42    PabloE * operator()(PabloE * expr);
     43private:
     44    CodeGenState & cg;
    4045
    41 PabloE * makeNot(PabloE * expr);
    42 
     46};
     47inline PabloE * makeNot(PabloE * expr, CodeGenState & cg) {
     48    OptimizeNot run(cg);
     49    return run(expr);
     50}
    4351}
    4452
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.cpp

    r4209 r4214  
    55 */
    66
    7 #include "pe_or.h"
    8 #include "pe_all.h"
    9 #include "pe_not.h"
    10 #include "pe_and.h"
     7#include <pablo/pe_or.h>
     8#include <pablo/codegenstate.h>
    119
    1210namespace pablo {
    1311
    14 PabloE * makeOr(PabloE * expr1, PabloE * expr2) {
     12PabloE * OptimizeOr::operator ()(PabloE * expr1, PabloE * expr2) {
    1513    if (All * all = dyn_cast<All>(expr1)) {
    1614        if (all->getValue() == 1) {
     
    3129    else if (Not * not1 = dyn_cast<Not>(expr1)) {
    3230        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
    33         return makeNot(makeAnd(not1->getExpr(), makeNot(expr2)));
     31        return cg.createNot(cg.createAnd(not1->getExpr(), cg.createNot(expr2)));
    3432    }
    3533    else if (Not * not2 = dyn_cast<Not>(expr2)) {
    3634        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
    37         return makeNot(makeAnd(not2->getExpr(), makeNot(expr1)));
     35        return cg.createNot(cg.createAnd(not2->getExpr(), cg.createNot(expr1)));
    3836    }
    3937    else if (equals(expr1, expr2)) {
     
    4947            //(e.g., union of [a-z] and [A-Z].
    5048            if (equals(expr1a, expr2a)) {
    51                 return makeAnd(expr1a, makeOr(expr1b, expr2b));
     49                return cg.createAnd(expr1a, cg.createOr(expr1b, expr2b));
    5250            }
    5351            else if (equals(expr1b, expr2b)) {
    54                 return makeAnd(expr1b, makeOr(expr1a, expr2a));
     52                return cg.createAnd(expr1b, cg.createOr(expr1a, expr2a));
    5553            }
    5654            else if (equals(expr1a, expr2b)) {
    57                 return makeAnd(expr1a, makeOr(expr1b, expr2a));
     55                return cg.createAnd(expr1a, cg.createOr(expr1b, expr2a));
    5856            }
    5957            else if (equals(expr1b, expr2a)) {
    60                 return makeAnd(expr1b, makeOr(expr1a, expr2b));
     58                return cg.createAnd(expr1b, cg.createOr(expr1a, expr2b));
    6159            }
    6260        }
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4209 r4214  
    88#define PE_OR_H
    99
    10 #include "pe_pabloe.h"
     10#include <pablo/pe_pabloe.h>
    1111
    1212namespace pablo {
    1313
     14struct CodeGenState;
     15
    1416class Or : public PabloE {
    15     friend PabloE * makeOr(PabloE *, PabloE *);
     17    friend struct OptimizeOr;
     18    friend struct CodeGenState;
    1619public:
    1720    static inline bool classof(const PabloE * e) {
     
    2225    }
    2326    virtual ~Or() {
    24         delete mExpr1;
    25         delete mExpr2;
    2627    }
    27 
    2828    inline PabloE * getExpr1() const {
    2929        return mExpr1;
    3030    }
    31 
    3231    inline PabloE* getExpr2() const {
    3332        return mExpr2;
     
    4645};
    4746
    48 PabloE * makeOr(PabloE * expr1, PabloE * expr2);
     47struct OptimizeOr {
     48    inline OptimizeOr(CodeGenState & cg) : cg(cg) {}
     49    PabloE * operator()(PabloE * expr1, PabloE * expr2);
     50private:
     51    CodeGenState & cg;
     52};
     53
     54inline PabloE * makeOr(PabloE * expr1, PabloE * expr2, CodeGenState & cg) {
     55    OptimizeOr run(cg);
     56    return run(expr1, expr2);
     57}
    4958
    5059}
  • icGREP/icgrep-devel/icgrep/pablo/pe_pabloe.cpp

    r4211 r4214  
    7979        else if (const Sel* sel1 = dyn_cast<const Sel>(expr1)) {
    8080            if (const Sel* sel2 = cast<const Sel>(expr2)) {
    81                 if (equals(sel1->getIf_expr(), sel2->getIf_expr())) {
    82                     if (equals(sel1->getT_expr(), sel2->getT_expr())) {
    83                         return equals(sel1->getF_expr(), sel2->getF_expr());
     81                if (equals(sel1->getCondition(), sel2->getCondition())) {
     82                    if (equals(sel1->getTrueExpr(), sel2->getTrueExpr())) {
     83                        return equals(sel1->getFalseExpr(), sel2->getFalseExpr());
    8484                    }
    8585                }
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4209 r4214  
    1414class ScanThru : public  PabloE {
    1515    friend PabloE * makeScanThru(PabloE *, PabloE *);
     16    friend struct CodeGenState;
    1617public:
    1718    static inline bool classof(const PabloE * e) {
     
    2829
    2930    }
    30 
    3131    virtual ~ScanThru() {
    32         delete mScanFrom;
    33         delete mScanThru;
    3432    }
    35 
    3633    PabloE * getScanFrom() const {
    3734        return mScanFrom;
    3835    }
    39 
    4036    PabloE * getScanThru() const {
    4137        return mScanThru;
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.cpp

    r4209 r4214  
    55 */
    66
    7 #include "pe_sel.h"
    8 #include "pe_all.h"
    9 #include "pe_and.h"
    10 #include "pe_or.h"
    11 #include "pe_not.h"
     7#include <pablo/pe_sel.h>
     8#include <pablo/codegenstate.h>
    129
    1310namespace pablo {
    1411
    15 PabloE * makeSel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr) {
     12PabloE * OptimizeSel::operator()(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr) {
    1613    if (All * all_if_expr = dyn_cast<All>(if_expr)) {
    1714        if (all_if_expr->getValue()) {
     
    2421    else if (All * all_t_expr = dyn_cast<All>(t_expr)) {
    2522        if (all_t_expr->getValue()) {
    26             return makeOr(if_expr, f_expr);
     23            return cg.createOr(if_expr, f_expr);
    2724        }
    2825        else {
    29             return makeAnd(makeNot(if_expr), f_expr);
     26            return cg.createAnd(cg.createNot(if_expr), f_expr);
    3027        }
    3128    }
    3229    else if (All * all_f_expr = dyn_cast<All>(f_expr)) {
    3330        if (all_f_expr->getValue()) {
    34             return makeOr(makeNot(if_expr), t_expr);
     31            return cg.createOr(cg.createNot(if_expr), t_expr);
    3532        }
    3633        else {
    37             return makeAnd(if_expr, t_expr);
     34            return cg.createAnd(if_expr, t_expr);
    3835        }
    3936    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

    r4209 r4214  
    88#define PE_SEL_H
    99
    10 #include "pe_pabloe.h"
     10#include <pablo/pe_pabloe.h>
    1111
    1212namespace pablo {
    1313
     14struct CodeGenState;
     15
    1416class Sel : public PabloE {
    15     friend PabloE * makeSel(PabloE *, PabloE *, PabloE *);
     17    friend struct OptimizeSel;
     18    friend struct CodeGenState;
    1619public:
    1720    static inline bool classof(const PabloE * e) {
     
    2225    }
    2326    virtual ~Sel() {
    24         delete mIf_expr;
    25         delete mT_expr;
    26         delete mF_expr;
    2727    }
    28 
    29     inline PabloE * getIf_expr() const {
     28    inline PabloE * getCondition() const {
    3029        return mIf_expr;
    3130    }
    32 
    33     inline PabloE * getT_expr() const {
     31    inline PabloE * getTrueExpr() const {
    3432        return mT_expr;
    3533    }
    36 
    37     inline PabloE * getF_expr() const {
     34    inline PabloE * getFalseExpr() const {
    3835        return mF_expr;
    3936    }
     
    5350};
    5451
    55 PabloE * makeSel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr);
     52struct OptimizeSel {
     53    inline OptimizeSel(CodeGenState & cg) : cg(cg) {}
     54    PabloE * operator()(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr);
     55private:
     56    CodeGenState & cg;
     57};
     58
     59inline PabloE * makeSel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr, CodeGenState & cg) {
     60    OptimizeSel run(cg);
     61    return run(if_expr, t_expr, f_expr);
     62}
    5663
    5764}
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r4213 r4214  
    1515
    1616class Var : public PabloE {
    17     friend Var * makeVar(const String *);
     17    friend Var * makeVar(String *);
     18    friend Var * makeVar(Assign * assign);
     19    friend struct CodeGenState;
    1820public:
    1921    static inline bool classof(const PabloE * e) {
     
    2426    }
    2527    virtual ~Var(){
    26 
    2728    }
    2829    inline const std::string & getName() const {
     
    3031    }
    3132protected:
    32     Var(const String * var)
     33    Var(const PabloE * var)
    3334    : PabloE(ClassTypeId::Var)
    34     , mVar(var)
    35     {
     35    , mVar(cast<String>(var)) {
    3636
    3737    }
     
    4040};
    4141
    42 inline Var * makeVar(const String * var) {
     42inline Var * makeVar(String * var) {
    4343    return new Var(var);
    4444}
    4545
    46 inline Var * makeVar(const Assign * assign) {
    47     return makeVar(assign->mName);
     46inline Var * makeVar(Assign * assign) {
     47    return new Var(assign->mName);
    4848}
    4949
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.cpp

    r4209 r4214  
    55 */
    66
    7 #include "pe_xor.h"
    8 #include "pe_all.h"
    9 #include "pe_not.h"
     7#include <pablo/pe_xor.h>
     8#include <pablo/codegenstate.h>
    109
    1110namespace pablo {
    1211
    13 PabloE * makeXor(PabloE * expr1, PabloE * expr2) {
     12PabloE * OptimizeXor::operator()(PabloE * expr1, PabloE * expr2) {
    1413    if (All * all1 = dyn_cast<All>(expr1)) {
    1514        if (all1->getValue()) {
    16             return makeNot(expr2);
     15            return cg.createNot(expr2);
    1716        }
    1817        else {
     
    2221    else if (All* all2 = dyn_cast<All>(expr2)) {
    2322        if (all2->getValue() == 1) {
    24             return makeNot(expr1);
     23            return cg.createNot(expr1);
    2524        }
    2625        else { //if (all_expr2->getNum() == 0)
     
    3029    else if (Not * not1 = dyn_cast<Not>(expr1)) {
    3130        if (Not * not2 = dyn_cast<Not>(expr2)) {
    32             return makeXor(not1->getExpr(), not2->getExpr());
     31            return cg.createXor(not1->getExpr(), not2->getExpr());
    3332        }
    3433    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4209 r4214  
    88#define XOR_H
    99
    10 #include "pe_pabloe.h"
     10#include <pablo/pe_pabloe.h>
    1111
    1212namespace pablo {
    1313
     14struct CodeGenState;
     15
    1416class Xor : public PabloE {
    15     friend PabloE * makeXor(PabloE *, PabloE *);
     17    friend struct OptimizeXor;
     18    friend struct CodeGenState;
    1619public:
    1720    static inline bool classof(const PabloE * e) {
     
    2225    }
    2326    virtual ~Xor() {
    24         delete mExpr1;
    25         delete mExpr2;
    2627    }
    2728    inline PabloE * getExpr1() const {
     
    4445};
    4546
    46 PabloE * makeXor(PabloE * expr1, PabloE * expr2);
     47struct OptimizeXor {
     48    inline OptimizeXor(CodeGenState & cg) : cg(cg) {}
     49    PabloE * operator()(PabloE * expr1, PabloE * expr2);
     50private:
     51    CodeGenState & cg;
     52};
     53
     54inline PabloE * makeXor(PabloE * expr1, PabloE * expr2, CodeGenState & cg) {
     55    OptimizeXor run(cg);
     56    return run(expr1, expr2);
     57}
    4758
    4859}
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r4211 r4214  
    114114    else if (const Sel * pablo_sel = dyn_cast<const Sel>(expr))
    115115    {
    116         retVal = "((" + ShowPabloE(pablo_sel->getIf_expr()) + "And " + ShowPabloE(pablo_sel->getT_expr()) +
    117                 ")|(Not(" + ShowPabloE(pablo_sel->getIf_expr()) + ") And " + ShowPabloE(pablo_sel->getF_expr()) + ")";
     116        retVal = "((" + ShowPabloE(pablo_sel->getCondition()) + "And " + ShowPabloE(pablo_sel->getTrueExpr()) +
     117                ")|(Not(" + ShowPabloE(pablo_sel->getCondition()) + ") And " + ShowPabloE(pablo_sel->getFalseExpr()) + ")";
    118118    }
    119119    else if (const Not * pablo_not = dyn_cast<const Not>(expr))
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.h

    r4213 r4214  
    1616
    1717class Assign : public PabloE {
    18     friend Assign * makeAssign(const String *, PabloE *);
    19     friend Var * makeVar(const Assign *);
     18    friend Assign * makeAssign(String *, PabloE *);
     19    friend Var * makeVar(Assign *);
     20    friend struct CodeGenState;
    2021public:
    2122    static inline bool classof(const PabloE * e) {
     
    2627    }
    2728    virtual ~Assign() {
    28         delete mExpr;
    2929    }
    30 
    3130    inline const std::string & getName() const {
    3231        return *mName;
    3332    }
    34 
    3533    inline PabloE * getExpr() const {
    3634        return mExpr;
    3735    }
    3836protected:
    39     Assign(const String * name, PabloE * expr)
     37    Assign(PabloE * name, PabloE * expr)
    4038    : PabloE(ClassTypeId::Assign)
    41     , mName(name)
     39    , mName(cast<String>(name))
    4240    , mExpr(expr)
    4341    {
     
    4947};
    5048
    51 inline Assign * makeAssign(const String * marker, PabloE * expr) {
     49inline Assign * makeAssign(String * marker, PabloE * expr) {
    5250    return new Assign(marker, expr);
    5351}
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.h

    r4209 r4214  
    1414
    1515class If : public PabloE {
     16    friend struct CodeGenState;
    1617public:
    1718    typedef std::list<PabloE*> List;
     
    2425        return false;
    2526    }
    26 
    27 
    28 
    2927    virtual ~If() {
    30         delete mExpr;
    31         for (auto statement : mPSList) {
    32             delete statement;
    33         }
    3428    }
    35 
    3629    inline PabloE * getExpr() const {
    3730        return mExpr;
    3831    }
    39 
    4032    inline const List & getPSList() const {
    4133        return mPSList;
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.h

    r4209 r4214  
    1313namespace pablo {
    1414
    15 class While : public PabloE {   
     15class While : public PabloE {
     16    friend struct CodeGenState;
    1617public:
    1718    typedef std::list<PabloE*> List;
     
    2425        return false;
    2526    }
    26 
    2727    virtual ~While() {
    28         delete mExpr;
    29         for (auto statement : mPSList) {
    30             delete statement;
    31         }
    3228    }
    33 
    3429    inline PabloE * getExpr() const {
    3530        return mExpr;
    3631    }
    37 
    3832    inline const List & getPSList() const {
    3933        return mPSList;
  • icGREP/icgrep-devel/icgrep/pablo/symbol_generator.cpp

    r4210 r4214  
    66
    77#include <pablo/symbol_generator.h>
     8#include <pablo/pe_string.h>
    89
    910namespace pablo {
    1011
    1112SymbolGenerator::SymbolGenerator()
    12 : pfxmap()
     13: mPrefixMap()
    1314{
    1415}
    1516
    16 std::string SymbolGenerator::get(std::string prefix) {
    17     auto f = pfxmap.find(prefix);
     17std::string SymbolGenerator::ssa(std::string prefix) {
     18    auto f = mPrefixMap.find(prefix);
    1819    unsigned count = 0;
    19     if (f == pfxmap.end()) {
    20         pfxmap.insert(std::make_pair(prefix, 1));
     20    if (f == mPrefixMap.end()) {
     21        mPrefixMap.insert(std::make_pair(prefix, 1));
    2122    }
    2223    else {
     
    2627}
    2728
     29String * SymbolGenerator::operator[](const std::string string) {
     30    auto f = mStringMap.find(string);
     31    String * result;
     32    if (f == mStringMap.end()) {
     33        result = makeString(string);
     34        mStringMap.insert(std::make_pair(*result, result));
     35    }
     36    else {
     37        result = f->second;
     38    }
     39    return result;
    2840}
     41
     42}
  • icGREP/icgrep-devel/icgrep/pablo/symbol_generator.h

    r4210 r4214  
    1010#include <string>
    1111#include <map>
     12#include <unordered_map>
    1213
    1314namespace pablo {
     15
     16class String;
    1417
    1518class SymbolGenerator
     
    1720public:
    1821    SymbolGenerator();
    19     std::string get(std::string prefix);
     22
     23    std::string ssa(std::string prefix);
     24
     25    String * operator[](const std::string string);
     26
    2027private:
    21     std::map<std::string, unsigned> pfxmap;
     28    std::map<std::string, unsigned>             mPrefixMap;
     29    std::unordered_map<std::string, String *>   mStringMap;
    2230};
    2331
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4213 r4214  
    4949}
    5050
    51 void RE_Compiler::compile(RE * re) {
     51void RE_Compiler::compile(RE * re, CodeGenState & cg) {
    5252
    5353    if (hasUnicode(re)) {
    5454        //Set the 'internal.initial' bit stream for the utf-8 multi-byte encoding.
    55         std::string gs_initial = mCG.symgen("initial");
     55        std::string gs_initial = cg.ssa("initial");
    5656        m_name_map.insert(make_pair("initial", gs_initial));
    57         PabloE * u8single = mCG.createVar(m_name_map.find("UTF8-SingleByte")->second);
    58         PabloE * u8pfx2 = mCG.createVar(m_name_map.find("UTF8-Prefix2")->second);
    59         PabloE * u8pfx3 = mCG.createVar(m_name_map.find("UTF8-Prefix3")->second);
    60         PabloE * u8pfx4 = mCG.createVar(m_name_map.find("UTF8-Prefix4")->second);
    61         PabloE * u8pfx = makeOr(makeOr(u8pfx2, u8pfx3), u8pfx4);
    62         mCG.push_back(mCG.createAssign(gs_initial, makeOr(u8pfx, u8single)));
     57        PabloE * u8single = cg.createVar(m_name_map.find("UTF8-SingleByte")->second);
     58        PabloE * u8pfx2 = cg.createVar(m_name_map.find("UTF8-Prefix2")->second);
     59        PabloE * u8pfx3 = cg.createVar(m_name_map.find("UTF8-Prefix3")->second);
     60        PabloE * u8pfx4 = cg.createVar(m_name_map.find("UTF8-Prefix4")->second);
     61        PabloE * u8pfx = cg.createOr(cg.createOr(u8pfx2, u8pfx3), u8pfx4);
     62        cg.push_back(cg.createAssign(gs_initial, cg.createOr(u8pfx, u8single)));
    6363
    6464        //Set the 'internal.nonfinal' bit stream for the utf-8 multi-byte encoding.
    65         std::string gs_nonfinal = mCG.symgen("nonfinal");
     65        std::string gs_nonfinal = cg.ssa("nonfinal");
    6666        m_name_map.insert(make_pair("nonfinal", gs_nonfinal));
    6767        //#define USE_IF_FOR_NONFINAL
     
    6969        cg.push_back(make_assign(gs_nonfinal, make_all(0)));
    7070        #endif
    71         PabloE * u8scope32 = makeAdvance(u8pfx3);
    72         PabloE * u8scope42 = makeAdvance(u8pfx4);
    73         PabloE * u8scope43 = makeAdvance(u8scope42);
    74         PabloE * assign_non_final = mCG.createAssign(gs_nonfinal, makeOr(makeOr(u8pfx, u8scope32), makeOr(u8scope42, u8scope43)));
     71        PabloE * u8scope32 = cg.createAdvance(u8pfx3);
     72        PabloE * u8scope42 = cg.createAdvance(u8pfx4);
     73        PabloE * u8scope43 = cg.createAdvance(u8scope42);
     74        PabloE * assign_non_final = cg.createAssign(gs_nonfinal, cg.createOr(cg.createOr(u8pfx, u8scope32), cg.createOr(u8scope42, u8scope43)));
    7575        #ifdef USE_IF_FOR_NONFINAL
    7676        std::list<PabloE *> * if_body = new std::list<PabloE *> ();
     
    7878        mCG.push_back(makeIf(u8pfx, *if_body));
    7979        #else
    80         mCG.push_back(assign_non_final);
     80        cg.push_back(assign_non_final);
    8181        #endif
    8282    }
    8383
    84     PabloE * start_marker = mCG.createAll(1);
    85     mCG.push_back(start_marker);
    86     PabloE * result = process(re, start_marker, mCG);
     84    PabloE * start_marker = cg.createAll(1);
     85    cg.push_back(start_marker);
     86    PabloE * result = process(re, start_marker, cg);
    8787
    8888    //These three lines are specifically for grep.
    89     Assign * final = mCG.createAssign(mCG.symgen("marker"), makeAnd(makeMatchStar(mCG.createVarIfAssign(result),
    90         makeNot(mCG.createVar(m_name_map.find("LineFeed")->second))), mCG.createVar(m_name_map.find("LineFeed")->second)));
    91     mCG.push_back(final);
    92 }
     89    Assign * final = cg.createAssign(cg.ssa("marker"), cg.createAnd(cg.createMatchStar(cg.createVarIfAssign(result),
     90        cg.createNot(cg.createVar(m_name_map.find("LineFeed")->second))), cg.createVar(m_name_map.find("LineFeed")->second)));
     91    cg.push_back(final);
     92}
     93
    9394
    9495PabloE * RE_Compiler::process(RE * re, PabloE * target, CodeGenState & cg) {
     
    106107    }
    107108    else if (isa<Start>(re)) {
    108         target = makeAnd(cg.createVarIfAssign(target), makeNot(makeAdvance(makeNot(cg.createCharClass(m_name_map.find("LineFeed")->second)))));
     109        target = cg.createAnd(cg.createVarIfAssign(target), cg.createNot(cg.createAdvance(cg.createNot(cg.createCharClass(m_name_map.find("LineFeed")->second)))));
    109110        cg.push_back(target);
    110111    }
    111112    else if (isa<End>(re)) {
    112         target = makeAnd(cg.createVarIfAssign(target), cg.createCharClass(m_name_map.find("LineFeed")->second));
     113        target = cg.createAnd(cg.createVarIfAssign(target), cg.createCharClass(m_name_map.find("LineFeed")->second));
    113114        cg.push_back(target);
    114115    }
     
    121122    if (name->getType() != Name::Type::FixedLength) {
    122123        // Move the markers forward through any nonfinal UTF-8 bytes to the final position of each character.
    123         markerExpr = makeAnd(markerExpr, cg.createCharClass(m_name_map.find("initial")->second));
    124         markerExpr = makeScanThru(markerExpr, cg.createCharClass(m_name_map.find("nonfinal")->second));
     124        markerExpr = cg.createAnd(markerExpr, cg.createCharClass(m_name_map.find("initial")->second));
     125        markerExpr = cg.createScanThru(markerExpr, cg.createCharClass(m_name_map.find("nonfinal")->second));
    125126    }
    126127    PabloE * cc = nullptr;
     
    132133    }
    133134    if (name->isNegated()) {
    134         cc = makeNot(makeOr(makeOr(cc, cg.createCharClass(m_name_map.find("LineFeed")->second)),
     135        cc = cg.createNot(cg.createOr(cg.createOr(cc, cg.createCharClass(m_name_map.find("LineFeed")->second)),
    135136                                cg.createCharClass(m_name_map.find("nonfinal")->second)));
    136137    }
    137     target = cg.createAssign(cg.symgen("marker"), makeAdvance(makeAnd(cc, markerExpr)));
     138    target = cg.createAssign(cg.ssa("marker"), cg.createAdvance(cg.createAnd(cc, markerExpr)));
    138139    cg.push_back(target);
    139140    return target;
     
    158159        while (++i != alt->end()) {
    159160            PabloE * other = cg.createVarIfAssign(process(*i, base, cg));
    160             target = makeOr(target, other);
     161            target = cg.createOr(target, other);
    161162        }
    162163        cg.push_back(target);
     
    194195
    195196        if (rep_name->isNegated()) {
    196             ccExpr = makeNot(makeOr(makeOr(ccExpr, cg.createCharClass(m_name_map.find("LineFeed")->second)), cg.createCharClass(m_name_map.find("nonfinal")->second)));
     197            ccExpr = cg.createNot(cg.createOr(cg.createOr(ccExpr, cg.createCharClass(m_name_map.find("LineFeed")->second)), cg.createCharClass(m_name_map.find("nonfinal")->second)));
    197198        }
    198199
    199200        if (rep_name->getType() == Name::Type::FixedLength) {
    200             target = makeMatchStar(target, ccExpr);
     201            target = cg.createMatchStar(target, ccExpr);
    201202        }
    202203        else { // Name::Unicode and Name::UnicodeCategory
    203             target = makeAnd(makeMatchStar(target, makeOr(cg.createCharClass(m_name_map.find("nonfinal")->second), ccExpr)), cg.createCharClass(m_name_map.find("initial")->second));
     204            target = cg.createAnd(cg.createMatchStar(target, cg.createOr(cg.createCharClass(m_name_map.find("nonfinal")->second), ccExpr)), cg.createCharClass(m_name_map.find("initial")->second));
    204205        }
    205206    }
    206207    else {
    207208
    208         Assign * while_test = cg.createAssign(cg.symgen("while_test"), target);
    209         Assign * while_accum = cg.createAssign(cg.symgen("while_accum"), target);
     209        Assign * while_test = cg.createAssign(cg.ssa("while_test"), target);
     210        Assign * while_accum = cg.createAssign(cg.ssa("while_accum"), target);
    210211
    211212        CodeGenState wt(cg);
     
    218219        Var * var_while_test = cg.createVar(while_accum);
    219220
    220         wt.push_back(cg.createAssign(while_test->getName(), makeAnd(accum, makeNot(var_while_test))));
    221 
    222         target = cg.createAssign(while_accum->getName(), makeOr(var_while_test, accum));
     221        wt.push_back(cg.createAssign(while_test->getName(), cg.createAnd(accum, cg.createNot(var_while_test))));
     222
     223        target = cg.createAssign(while_accum->getName(), cg.createOr(var_while_test, accum));
    223224
    224225        wt.push_back(target);
     
    235236    while (ub-- != 0) {
    236237        PabloE * alt = process(repeated, target, cg);
    237         target = makeOr(cg.createVarIfAssign(target), cg.createVarIfAssign(alt));
     238        target = cg.createOr(cg.createVarIfAssign(target), cg.createVarIfAssign(alt));
    238239    }
    239240    cg.push_back(target);
  • icGREP/icgrep-devel/icgrep/re/re_compiler.h

    r4213 r4214  
    2121    RE_Compiler(pablo::CodeGenState & baseCG, std::map<std::string, std::string> name_map);
    2222
    23     void compile(RE * re);
     23    inline void compile(RE * re) {
     24        compile(re, mCG);
     25    }
    2426
    2527private:
     28
     29    void compile(RE * re, pablo::CodeGenState & cg);
     30
    2631    pablo::PabloE * process(RE * re, pablo::PabloE * target, pablo::CodeGenState & cg_state);
    2732    pablo::PabloE * process(Alt * alt, pablo::PabloE * target, pablo::CodeGenState & cg_state);
Note: See TracChangeset for help on using the changeset viewer.