Changeset 4244


Ignore:
Timestamp:
Oct 16, 2014, 3:47:48 PM (5 years ago)
Author:
lindanl
Message:

Change PabloE to PabloAST.

Location:
icGREP/icgrep-devel/icgrep
Files:
2 added
34 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/CMakeLists.txt

    r4237 r4244  
    5353#find_package(Boost 1.21 COMPONENTS system)
    5454
    55 add_library(PabloADT pablo/pe_advance.cpp pablo/pe_all.cpp pablo/pe_and.cpp pablo/pe_call.cpp pablo/pe_charclass.cpp  pablo/pe_matchstar.cpp pablo/pe_scanthru.cpp pablo/pe_not.cpp  pablo/pe_or.cpp  pablo/pe_pabloe.cpp  pablo/pe_sel.cpp  pablo/pe_var.cpp  pablo/pe_xor.cpp pablo/ps_assign.cpp  pablo/ps_if.cpp  pablo/codegenstate.cpp  pablo/symbol_generator.cpp pablo/ps_while.cpp pablo/printer_pablos.cpp pablo/pablo_compiler.cpp)
     55add_library(PabloADT pablo/pe_advance.cpp pablo/pe_all.cpp pablo/pe_and.cpp pablo/pe_call.cpp pablo/pe_charclass.cpp  pablo/pe_matchstar.cpp pablo/pe_scanthru.cpp pablo/pe_not.cpp  pablo/pe_or.cpp  pablo/pabloAST.cpp  pablo/pe_sel.cpp  pablo/pe_var.cpp  pablo/pe_xor.cpp pablo/ps_assign.cpp  pablo/ps_if.cpp  pablo/codegenstate.cpp  pablo/symbol_generator.cpp pablo/ps_while.cpp pablo/printer_pablos.cpp pablo/pablo_compiler.cpp)
    5656add_library(RegExpADT re/re_alt.cpp re/re_cc.cpp re/re_end.cpp re/re_name.cpp re/re_parser.cpp re/re_re.cpp re/re_rep.cpp re/re_seq.cpp re/re_start.cpp re/parsefailure.cpp re/re_reducer.cpp re/re_nullable.cpp re/re_simplifier.cpp re/re_compiler.cpp re/printer_re.cpp)
    5757add_library(CCADT cc/cc_compiler.cpp utf_encoding.cpp utf8_encoder.cpp unicode_categories.h)
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.cpp

    r4242 r4244  
    5858                assert (name);
    5959                CharClass * cc = mCG.createCharClass(name->getName());
    60                 PabloE * sym = assignment ? mCG.createAnd(mCG.createVar(assignment->getName()), cc) : cc;
     60                PabloAST * sym = assignment ? mCG.createAnd(mCG.createVar(assignment->getName()), cc) : cc;
    6161                if (++j != seq->end()) {
    6262                    assignment = mCG.createAssign(mCG.ssa("marker"), mCG.createAdvance(sym));
     
    7070}
    7171
    72 inline PabloE * CC_Compiler::charset_expr(const CC * cc) {
     72inline PabloAST * CC_Compiler::charset_expr(const CC * cc) {
    7373    if (cc->empty()) {
    7474        return mCG.createAll(0);
     
    9898                lo &= (mask - 1);
    9999                hi |= (mask ^ (mask - 1));
    100                 PabloE * expr = make_range(lo, hi);
    101                 PabloE * bit0 = getBasisVar(0);
     100                PabloAST * expr = make_range(lo, hi);
     101                PabloAST * bit0 = getBasisVar(0);
    102102                if ((lo & 1) == 0) {
    103103                    bit0 = mCG.createNot(bit0);
     
    107107        }
    108108    }
    109     PabloE * expr = nullptr;
     109    PabloAST * expr = nullptr;
    110110    for (const CharSetItem & item : *cc) {
    111         PabloE * temp = char_or_range_expr(item.lo_codepoint, item.hi_codepoint);
     111        PabloAST * temp = char_or_range_expr(item.lo_codepoint, item.hi_codepoint);
    112112        expr = (expr == nullptr) ? temp : mCG.createOr(expr, temp);
    113113    }
     
    115115}
    116116
    117 PabloE * CC_Compiler::bit_pattern_expr(const unsigned pattern, unsigned selected_bits)
     117PabloAST * CC_Compiler::bit_pattern_expr(const unsigned pattern, unsigned selected_bits)
    118118{
    119119    if (selected_bits == 0) {
     
    121121    }
    122122
    123     std::vector<PabloE*> bit_terms;
     123    std::vector<PabloAST*> bit_terms;
    124124    unsigned i = 0;
    125125
     
    149149    while (bit_terms.size() > 1)
    150150    {
    151         std::vector<PabloE*> new_terms;
     151        std::vector<PabloAST*> new_terms;
    152152        for (unsigned long i = 0; i < (bit_terms.size()/2); i++)
    153153        {
     
    163163}
    164164
    165 PabloE * CC_Compiler::char_test_expr(const CodePointType ch)
     165PabloAST * CC_Compiler::char_test_expr(const CodePointType ch)
    166166{
    167167    return bit_pattern_expr(ch, mEncoding.getMask());
    168168}
    169169
    170 PabloE * CC_Compiler::make_range(const CodePointType n1, const CodePointType n2)
     170PabloAST * CC_Compiler::make_range(const CodePointType n1, const CodePointType n2)
    171171{
    172172    CodePointType diff_count = 0;
     
    181181    const CodePointType mask0 = (static_cast<CodePointType>(1) << diff_count) - 1;
    182182
    183     PabloE * common = bit_pattern_expr(n1 & ~mask0, mEncoding.getMask() ^ mask0);
     183    PabloAST * common = bit_pattern_expr(n1 & ~mask0, mEncoding.getMask() ^ mask0);
    184184
    185185    if (diff_count == 0) return common;
     
    187187    const CodePointType mask1 = (static_cast<CodePointType>(1) << (diff_count - 1)) - 1;
    188188
    189     PabloE* lo_test = GE_Range(diff_count - 1, n1 & mask1);
    190     PabloE* hi_test = LE_Range(diff_count - 1, n2 & mask1);
     189    PabloAST* lo_test = GE_Range(diff_count - 1, n1 & mask1);
     190    PabloAST* hi_test = LE_Range(diff_count - 1, n2 & mask1);
    191191
    192192    return mCG.createAnd(common, mCG.createSel(getBasisVar(diff_count - 1), hi_test, lo_test));
    193193}
    194194
    195 PabloE * CC_Compiler::GE_Range(const unsigned N, const unsigned n) {
     195PabloAST * CC_Compiler::GE_Range(const unsigned N, const unsigned n) {
    196196    if (N == 0)
    197197    {
     
    210210        int hi_bit = n & (1 << (N - 1));
    211211        int lo_bits = n - hi_bit;
    212         PabloE * lo_range = GE_Range(N - 1, lo_bits);
     212        PabloAST * lo_range = GE_Range(N - 1, lo_bits);
    213213        if (hi_bit == 0)
    214214        {
     
    232232}
    233233
    234 PabloE * CC_Compiler::LE_Range(const unsigned N, const unsigned n)
     234PabloAST * CC_Compiler::LE_Range(const unsigned N, const unsigned n)
    235235{
    236236    /*
     
    246246}
    247247
    248 inline PabloE * CC_Compiler::char_or_range_expr(const CodePointType lo, const CodePointType hi) {
     248inline PabloAST * CC_Compiler::char_or_range_expr(const CodePointType lo, const CodePointType hi) {
    249249    if (lo == hi) {
    250250        return char_test_expr(lo);
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.h

    r4242 r4244  
    1010#include "utf_encoding.h"
    1111#include <pablo/codegenstate.h>
    12 #include <pablo/pe_pabloe.h>
     12#include <pablo/pabloAST.h>
    1313#include <re/re_cc.h>
    1414#include <unordered_map>
     
    3535private:
    3636    pablo::Var * getBasisVar(const int n) const;
    37     pablo::PabloE * bit_pattern_expr(const unsigned pattern, unsigned selected_bits);
    38     pablo::PabloE * char_test_expr(const re::CodePointType ch);
    39     pablo::PabloE * make_range(const re::CodePointType n1, const re::CodePointType n2);
    40     pablo::PabloE * GE_Range(const unsigned N, const unsigned n);
    41     pablo::PabloE * LE_Range(const unsigned N, const unsigned n);
    42     pablo::PabloE * char_or_range_expr(const re::CodePointType lo, const re::CodePointType hi);
    43     pablo::PabloE * charset_expr(const re::CC *cc);
     37    pablo::PabloAST * bit_pattern_expr(const unsigned pattern, unsigned selected_bits);
     38    pablo::PabloAST * char_test_expr(const re::CodePointType ch);
     39    pablo::PabloAST * make_range(const re::CodePointType n1, const re::CodePointType n2);
     40    pablo::PabloAST * GE_Range(const unsigned N, const unsigned n);
     41    pablo::PabloAST * LE_Range(const unsigned N, const unsigned n);
     42    pablo::PabloAST * char_or_range_expr(const re::CodePointType lo, const re::CodePointType hi);
     43    pablo::PabloAST * charset_expr(const re::CC *cc);
    4444
    4545    pablo::PabloBlock &         mCG;
  • icGREP/icgrep-devel/icgrep/icgrep-devel.files

    r4220 r4244  
    4747pe_or.cpp
    4848pe_or.h
    49 pe_pabloe.cpp
    50 pe_pabloe.h
     49pabloAST.cpp
     50pabloAST.h
    5151pe_scanthru.cpp
    5252pe_scanthru.h
     
    156156pablo/pe_or.cpp
    157157pablo/pe_or.h
    158 pablo/pe_pabloe.cpp
    159 pablo/pe_pabloe.h
     158pablo/pabloAST.cpp
     159pablo/pabloAST.h
    160160pablo/pe_scanthru.cpp
    161161pablo/pe_scanthru.h
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

    r4234 r4244  
    1111/// UNARY CREATE FUNCTIONS
    1212
    13 Advance * PabloBlock::createAdvance(PabloE * expr) {
    14     return mUnary.findOrMake<Advance>(PabloE::ClassTypeId::Advance, expr);
     13Advance * PabloBlock::createAdvance(PabloAST * expr) {
     14    return mUnary.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr);
    1515}
    1616
    1717Call * PabloBlock::createCall(const std::string name) {
    18     return mUnary.findOrMake<Call>(PabloE::ClassTypeId::Call, mSymbolGenerator[name]);
     18    return mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, mSymbolGenerator[name]);
    1919}
    2020
    2121CharClass * PabloBlock::createCharClass(const std::string name) {
    22     return mUnary.findOrMake<CharClass>(PabloE::ClassTypeId::CharClass, mSymbolGenerator[name]);
     22    return mUnary.findOrMake<CharClass>(PabloAST::ClassTypeId::CharClass, mSymbolGenerator[name]);
    2323}
    2424
    25 PabloE * PabloBlock::createNot(PabloE * expr) {
    26     return mUnary.findOrCall<OptimizeNot>(PabloE::ClassTypeId::Not, expr);
     25PabloAST * PabloBlock::createNot(PabloAST * expr) {
     26    return mUnary.findOrCall<OptimizeNot>(PabloAST::ClassTypeId::Not, expr);
    2727}
    2828
    2929Var * PabloBlock::createVar(const std::string name) {
    30     return mUnary.findOrMake<Var>(PabloE::ClassTypeId::Var, mSymbolGenerator[name]);
     30    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, mSymbolGenerator[name]);
    3131}
    3232
    3333Var * PabloBlock::createVar(Assign * assign) {
    34     return mUnary.findOrMake<Var>(PabloE::ClassTypeId::Var, const_cast<String *>(assign->mName));
     34    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, const_cast<String *>(assign->mName));
    3535}
    3636
    3737/// BINARY CREATE FUNCTIONS
    3838
    39 PabloE * PabloBlock::createAnd(PabloE * expr1, PabloE * expr2) {
     39PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2) {
    4040    if (expr1 < expr2) {
    4141        std::swap(expr1, expr2);
    4242    }
    43     return mBinary.findOrCall<OptimizeAnd>(PabloE::ClassTypeId::And, expr1, expr2);
     43    return mBinary.findOrCall<OptimizeAnd>(PabloAST::ClassTypeId::And, expr1, expr2);
    4444}
    4545
    46 Assign * PabloBlock::createAssign(const std::string name, PabloE * expr) {
    47 //    auto key = std::make_tuple(PabloE::ClassTypeId::Assign, expr);
     46Assign * PabloBlock::createAssign(const std::string name, PabloAST * expr) {
     47//    auto key = std::make_tuple(PabloAST::ClassTypeId::Assign, expr);
    4848//    Assign * assign = cast<Assign>(mUnary.find(key));
    4949//    if (assign == nullptr) {
     
    5454//        assign = new Assign(mSymbolGenerator[name], createVar(assign));
    5555//    }
    56     Assign * assign = mBinary.findOrMake<Assign>(PabloE::ClassTypeId::Assign, mSymbolGenerator[name], expr);
     56    Assign * assign = mBinary.findOrMake<Assign>(PabloAST::ClassTypeId::Assign, mSymbolGenerator[name], expr);
    5757    mStatements.push_back(assign);
    5858    return assign;
    5959}
    6060
    61 MatchStar * PabloBlock::createMatchStar(PabloE * expr1, PabloE * expr2) {
    62     return mBinary.findOrMake<MatchStar>(PabloE::ClassTypeId::MatchStar, expr1, expr2);
     61MatchStar * PabloBlock::createMatchStar(PabloAST * expr1, PabloAST * expr2) {
     62    return mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, expr1, expr2);
    6363}
    6464
    65 PabloE * PabloBlock::createOr(PabloE * expr1, PabloE * expr2) {
     65PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2) {
    6666    if (expr1 < expr2) {
    6767        std::swap(expr1, expr2);
    6868    }
    69     return mBinary.findOrCall<OptimizeOr>(PabloE::ClassTypeId::Or, expr1, expr2);
     69    return mBinary.findOrCall<OptimizeOr>(PabloAST::ClassTypeId::Or, expr1, expr2);
    7070}
    7171
    72 ScanThru * PabloBlock::createScanThru(PabloE * from, PabloE * thru) {
    73     return mBinary.findOrMake<ScanThru>(PabloE::ClassTypeId::ScanThru, from, thru);
     72ScanThru * PabloBlock::createScanThru(PabloAST * from, PabloAST * thru) {
     73    return mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru);
    7474}
    7575
    76 PabloE * PabloBlock::createXor(PabloE * expr1, PabloE * expr2) {
     76PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2) {
    7777    if (expr1 < expr2) {
    7878        std::swap(expr1, expr2);
    7979    }
    80     return mBinary.findOrCall<OptimizeXor>(PabloE::ClassTypeId::Xor, expr1, expr2);
     80    return mBinary.findOrCall<OptimizeXor>(PabloAST::ClassTypeId::Xor, expr1, expr2);
    8181}
    8282
    8383/// TERNARY CREATE FUNCTION
    8484
    85 PabloE *PabloBlock::createSel(PabloE * condition, PabloE * trueExpr, PabloE * falseExpr) {
    86     return mTernary.findOrCall<OptimizeSel>(PabloE::ClassTypeId::Sel, condition, trueExpr, falseExpr);
     85PabloAST *PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
     86    return mTernary.findOrCall<OptimizeSel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr);
    8787}
    8888
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4234 r4244  
    88#define PS_PABLOS_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111#include <pablo/pe_string.h>
    1212#include <pablo/pe_advance.h>
     
    1818#include <pablo/pe_not.h>
    1919#include <pablo/pe_or.h>
    20 #include <pablo/pe_pabloe.h>
     20#include <pablo/pabloAST.h>
    2121#include <pablo/pe_scanthru.h>
    2222#include <pablo/pe_sel.h>
     
    5858    }
    5959
    60     Advance * createAdvance(PabloE * expr);
     60    Advance * createAdvance(PabloAST * expr);
    6161
    6262    inline All * createAll(const bool value) const {
     
    6464    }
    6565
    66     Assign * createAssign(const std::string name, PabloE * expr);
     66    Assign * createAssign(const std::string name, PabloAST * expr);
    6767
    6868    Call * createCall(const std::string name);
     
    7272    Var * createVar(Assign * assign);
    7373
    74     inline PabloE * createVarIfAssign(PabloE * const input) {
     74    inline PabloAST * createVarIfAssign(PabloAST * const input) {
    7575        return isa<Assign>(input) ? createVar(cast<Assign>(input)) : input;
    7676    }
     
    7878    CharClass * createCharClass(const std::string name);
    7979
    80     PabloE * createAnd(PabloE * expr1, PabloE * expr2);
     80    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
    8181
    82     PabloE * createNot(PabloE * expr);
     82    PabloAST * createNot(PabloAST * expr);
    8383
    84     PabloE * createOr(PabloE * expr1, PabloE * expr2);
     84    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
    8585
    86     PabloE * createXor(PabloE * expr1, PabloE * expr2);
     86    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
    8787
    88     MatchStar * createMatchStar(PabloE * expr1, PabloE * expr2);
     88    MatchStar * createMatchStar(PabloAST * expr1, PabloAST * expr2);
    8989
    90     ScanThru * createScanThru(PabloE * from, PabloE * thru);
     90    ScanThru * createScanThru(PabloAST * from, PabloAST * thru);
    9191
    92     PabloE * createSel(PabloE * condition, PabloE * trueExpr, PabloE * falseExpr);
     92    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
    9393
    94     inline If * createIf(PabloE * condition, PabloBlock && body) {
     94    inline If * createIf(PabloAST * condition, PabloBlock && body) {
    9595        If * statement = new If(condition, std::move(body.mStatements));
    9696        mStatements.push_back(statement);
     
    9898    }
    9999
    100     inline While * createWhile(PabloE * cond, PabloBlock && body) {
     100    inline While * createWhile(PabloAST * cond, PabloBlock && body) {
    101101        While * statement = new While(cond, std::move(body.mStatements));
    102102        mStatements.push_back(statement);
     
    107107    struct ExpressionMap {
    108108        typedef ExpressionMap<Args...> MapType;
    109         typedef std::tuple<PabloE::ClassTypeId, Args...> Key;
     109        typedef std::tuple<PabloAST::ClassTypeId, Args...> Key;
    110110
    111111        inline ExpressionMap(MapType * predecessor, PabloBlock * parent)
     
    117117
    118118        template <class Type>
    119         inline Type * findOrMake(const PabloE::ClassTypeId type, Args... args) {
     119        inline Type * findOrMake(const PabloAST::ClassTypeId type, Args... args) {
    120120            auto key = std::make_tuple(type, args...);
    121             PabloE * f = find(key);
     121            PabloAST * f = find(key);
    122122            if (f) {
    123123                return cast<Type>(f);
     
    129129
    130130        template <class Functor>
    131         inline PabloE * findOrCall(const PabloE::ClassTypeId type, Args... args) {
     131        inline PabloAST * findOrCall(const PabloAST::ClassTypeId type, Args... args) {
    132132            auto key = std::make_tuple(type, args...);
    133             PabloE * f = find(key);
     133            PabloAST * f = find(key);
    134134            if (f) {
    135135                return f;
    136136            }
    137137            Functor mf(mCodeGenState);
    138             PabloE * expr = mf(args...);           
     138            PabloAST * expr = mf(args...);           
    139139            insert(std::move(key), expr);
    140140            return expr;
    141141        }
    142142
    143         inline void insert(Key && key, PabloE * expr) {
     143        inline void insert(Key && key, PabloAST * expr) {
    144144            mMap.insert(std::make_pair(std::move(key), expr));
    145145        }
    146146
    147         inline PabloE * find(const Key & key) const {
     147        inline PabloAST * find(const Key & key) const {
    148148            // check this map to see if we have it
    149149            auto itr = mMap.find(key);
     
    167167        MapType * const         mPredecessor;
    168168        PabloBlock &            mCodeGenState;
    169         std::map<Key, PabloE *> mMap;
     169        std::map<Key, PabloAST *> mMap;
    170170    };
    171171
     
    181181    SymbolGenerator &                               mSymbolGenerator;
    182182    const std::array<All *, 2>                      mAll;
    183     ExpressionMap<PabloE *>                         mUnary;
    184     ExpressionMap<PabloE *, PabloE *>               mBinary;
    185     ExpressionMap<PabloE *, PabloE *, PabloE *>     mTernary;
     183    ExpressionMap<PabloAST *>                         mUnary;
     184    ExpressionMap<PabloAST *, PabloAST *>               mBinary;
     185    ExpressionMap<PabloAST *, PabloAST *, PabloAST *>     mTernary;
    186186    ExpressionList                                  mStatements;
    187187};
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r4242 r4244  
    371371
    372372void PabloCompiler::DeclareCallFunctions(const ExpressionList & stmts) {
    373     for (const PabloE * stmt : stmts) {
     373    for (const PabloAST * stmt : stmts) {
    374374        if (const Assign * an = dyn_cast<const Assign>(stmt)) {
    375375            DeclareCallFunctions(an->getExpr());
     
    386386}
    387387
    388 void PabloCompiler::DeclareCallFunctions(const PabloE * expr)
     388void PabloCompiler::DeclareCallFunctions(const PabloAST * expr)
    389389{
    390390    if (const Call * pablo_call = dyn_cast<const Call>(expr)) {
     
    501501Value * PabloCompiler::compileStatements(const ExpressionList & stmts) {
    502502    Value * retVal = nullptr;
    503     for (PabloE * statement : stmts) {
     503    for (PabloAST * statement : stmts) {
    504504        retVal = compileStatement(statement);
    505505    }
     
    507507}
    508508
    509 Value * PabloCompiler::compileStatement(const PabloE * stmt)
     509Value * PabloCompiler::compileStatement(const PabloAST * stmt)
    510510{
    511511    Value * retVal = nullptr;
     
    624624}
    625625
    626 Value * PabloCompiler::compileExpression(const PabloE * expr)
     626Value * PabloCompiler::compileExpression(const PabloAST * expr)
    627627{
    628628    Value * retVal = nullptr;
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.h

    r4242 r4244  
    1313//Pablo Expressions
    1414#include <pablo/codegenstate.h>
    15 #include <pablo/pe_pabloe.h>
     15#include <pablo/pabloAST.h>
    1616#include <cc/cc_compiler.h>
    1717#include "unicode_categories.h"
     
    9393    void DeclareFunctions();
    9494    void DeclareCallFunctions(const ExpressionList & stmts);
    95     void DeclareCallFunctions(const PabloE * expr);
     95    void DeclareCallFunctions(const PabloAST * expr);
    9696    void LoadBitBlocksFromStaticExtern();
    9797    void SetReturnMarker(Value * marker, const unsigned output_idx);
     
    100100
    101101    Value* compileStatements(const ExpressionList & stmts);
    102     Value* compileStatement(const PabloE * stmt);
     102    Value* compileStatement(const PabloAST * stmt);
    103103
    104     Value* compileExpression(const PabloE * expr);
     104    Value* compileExpression(const PabloAST * expr);
    105105    Value* genCarryInLoad(Value* ptr_carry_q, int carryq_idx);
    106106    Value* genCarryOutStore(Value* carryout, Value* ptr_carry_q, int carryq_idx);
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4227 r4244  
    88#define PE_ADVANCE_H
    99
    10 #include "pe_pabloe.h"
     10#include "pabloAST.h"
    1111
    1212namespace pablo {
    1313
    14 class Advance : public PabloE {
     14class Advance : public PabloAST {
    1515    friend class PabloBlock;
    1616public:
    17     static inline bool classof(const PabloE * e) {
     17    static inline bool classof(const PabloAST * e) {
    1818        return e->getClassTypeId() == ClassTypeId::Advance;
    1919    }
     
    2323    virtual ~Advance() {
    2424    }
    25     inline PabloE * getExpr() const {
     25    inline PabloAST * getExpr() const {
    2626        return mExpr;
    2727    }
    2828protected:
    29     Advance(PabloE * expr)
    30     : PabloE(ClassTypeId::Advance)
     29    Advance(PabloAST * expr)
     30    : PabloAST(ClassTypeId::Advance)
    3131    , mExpr(expr) {
    3232
    3333    }
    3434private:
    35     PabloE * const mExpr;
     35    PabloAST * const mExpr;
    3636};
    3737
  • icGREP/icgrep-devel/icgrep/pablo/pe_all.h

    r4227 r4244  
    88#define PE_ALL_H
    99
    10 #include "pe_pabloe.h"
     10#include "pabloAST.h"
    1111
    1212namespace pablo {
    1313
    14 class All : public PabloE {
     14class All : public PabloAST {
    1515    friend class PabloBlock;
    1616public:
    17     static inline bool classof(const PabloE * e) {
     17    static inline bool classof(const PabloAST * e) {
    1818        return e->getClassTypeId() == ClassTypeId::All;
    1919    }
     
    3030        return mValue == other.mValue;
    3131    }
    32     virtual bool operator==(const PabloE & other) const {
     32    virtual bool operator==(const PabloAST & other) const {
    3333        return (isa<All>(other)) ? mValue == cast<All>(other).mValue : false;
    3434    }
    3535protected:
    3636    All(const bool value)
    37     : PabloE(ClassTypeId::All)
     37    : PabloAST(ClassTypeId::All)
    3838    , mValue(value)
    3939    {
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4214 r4244  
    1010namespace pablo {
    1111
    12 PabloE * OptimizeAnd::operator ()(PabloE * expr1, PabloE * expr2) {
     12PabloAST * OptimizeAnd::operator ()(PabloAST * expr1, PabloAST * expr2) {
    1313    if (All * all = dyn_cast<All>(expr1)) {
    1414        if (all->getValue()) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4227 r4244  
    88#define PE_AND_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111
    1212namespace pablo {
     
    1414class PabloBlock;
    1515
    16 class And : public PabloE {
     16class And : public PabloAST {
    1717    friend struct OptimizeAnd;
    1818    friend class PabloBlock;
    1919public:
    20     static inline bool classof(const PabloE * e) {
     20    static inline bool classof(const PabloAST * e) {
    2121        return e->getClassTypeId() == ClassTypeId::And;
    2222    }
     
    2626    virtual ~And() {
    2727    }
    28     PabloE * getExpr1() const {
     28    PabloAST * getExpr1() const {
    2929        return mExpr1;
    3030    }
    31     PabloE * getExpr2() const {
     31    PabloAST * getExpr2() const {
    3232        return mExpr2;
    3333    }
    3434protected:
    35     And(PabloE * expr1, PabloE * expr2)
    36     : PabloE(ClassTypeId::And)
     35    And(PabloAST * expr1, PabloAST * expr2)
     36    : PabloAST(ClassTypeId::And)
    3737    , mExpr1(expr1)
    3838    , mExpr2(expr2)
     
    4141    }
    4242private:
    43     PabloE * const mExpr1;
    44     PabloE * const mExpr2;
     43    PabloAST * const mExpr1;
     44    PabloAST * const mExpr2;
    4545};
    4646
    4747struct OptimizeAnd {
    4848    inline OptimizeAnd(PabloBlock & cg) : cg(cg) {}
    49     PabloE * operator()(PabloE * expr1, PabloE * expr2);
     49    PabloAST * operator()(PabloAST * expr1, PabloAST * expr2);
    5050private:
    5151    PabloBlock & cg;
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r4227 r4244  
    22#define PE_CALL_H
    33
    4 #include <pablo/pe_pabloe.h>
     4#include <pablo/pabloAST.h>
    55#include <pablo/pe_string.h>
    66
    77namespace pablo {
    88
    9 class Call : public PabloE {
     9class Call : public PabloAST {
    1010    friend class PabloBlock;
    1111public:
    12     static inline bool classof(const PabloE * e) {
     12    static inline bool classof(const PabloAST * e) {
    1313        return e->getClassTypeId() == ClassTypeId::Call;
    1414    }
     
    2222    }
    2323protected:   
    24     Call(const PabloE * callee)
    25     : PabloE(ClassTypeId::Call)
     24    Call(const PabloAST * callee)
     25    : PabloAST(ClassTypeId::Call)
    2626    , mCallee(cast<String>(callee)) {
    2727
  • icGREP/icgrep-devel/icgrep/pablo/pe_charclass.h

    r4227 r4244  
    88#define PE_CHARCLASS_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111#include <pablo/pe_string.h>
    1212
    1313namespace pablo {
    1414
    15 class CharClass : public PabloE {
     15class CharClass : public PabloAST {
    1616    friend class PabloBlock;
    1717public:
    18     static inline bool classof(const PabloE * e) {
     18    static inline bool classof(const PabloAST * e) {
    1919        return e->getClassTypeId() == ClassTypeId::CharClass;
    2020    }
     
    2828    }
    2929protected:
    30     CharClass(const PabloE * cc)
    31     : PabloE(ClassTypeId::CharClass)
     30    CharClass(const PabloAST * cc)
     31    : PabloAST(ClassTypeId::CharClass)
    3232    , mCharClass(cast<String>(cc))
    3333    {
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4227 r4244  
    88#define PE_MATCHSTAR_H
    99
    10 #include "pe_pabloe.h"
     10#include "pabloAST.h"
    1111
    1212namespace pablo {
    1313
    14 class MatchStar : public PabloE {
     14class MatchStar : public PabloAST {
    1515    friend class PabloBlock;
    1616public:
    17     static inline bool classof(const PabloE * e) {
     17    static inline bool classof(const PabloAST * e) {
    1818        return e->getClassTypeId() == ClassTypeId::MatchStar;
    1919    }
     
    2323    virtual ~MatchStar() {
    2424    }
    25     inline PabloE * getExpr1() const {
     25    inline PabloAST * getExpr1() const {
    2626        return mExpr1;
    2727    }
    28     inline PabloE * getExpr2() const  {
     28    inline PabloAST * getExpr2() const  {
    2929        return mExpr2;
    3030    }
    3131protected:
    32     MatchStar(PabloE * expr1, PabloE * expr2)
    33     : PabloE(ClassTypeId::MatchStar)
     32    MatchStar(PabloAST * expr1, PabloAST * expr2)
     33    : PabloAST(ClassTypeId::MatchStar)
    3434    , mExpr1(expr1)
    3535    , mExpr2(expr2)
     
    3838    }
    3939private:
    40     PabloE * const mExpr1;
    41     PabloE * const mExpr2;
     40    PabloAST * const mExpr1;
     41    PabloAST * const mExpr2;
    4242};
    4343
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.cpp

    r4214 r4244  
    1111namespace pablo {
    1212
    13 PabloE * OptimizeNot::operator ()(PabloE * expr) {
     13PabloAST * OptimizeNot::operator ()(PabloAST * expr) {
    1414    if (All * all = dyn_cast<All>(expr)) {
    1515        return cg.createAll(!all->getValue());
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.h

    r4227 r4244  
    88#define PE_NOT_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111
    1212namespace pablo {
     
    1414class PabloBlock;
    1515
    16 class Not : public PabloE {
     16class Not : public PabloAST {
    1717    friend struct OptimizeNot;
    1818    friend class PabloBlock;
    1919public:
    20     static inline bool classof(const PabloE * e) {
     20    static inline bool classof(const PabloAST * e) {
    2121        return e->getClassTypeId() == ClassTypeId::Not;
    2222    }
     
    2626    virtual ~Not() {
    2727    }
    28     PabloE * getExpr() const {
     28    PabloAST * getExpr() const {
    2929        return mExpr;
    3030    }
    3131protected:
    32     Not(PabloE * expr)
    33     : PabloE(ClassTypeId::Not)
     32    Not(PabloAST * expr)
     33    : PabloAST(ClassTypeId::Not)
    3434    , mExpr(expr) {
    3535
    3636    }
    3737private:
    38     PabloE * const mExpr;
     38    PabloAST * const mExpr;
    3939};
    4040
    4141struct OptimizeNot {
    4242    inline OptimizeNot(PabloBlock & cg) : cg(cg) {}
    43     PabloE * operator()(PabloE * expr);
     43    PabloAST * operator()(PabloAST * expr);
    4444private:
    4545    PabloBlock & cg;
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.cpp

    r4233 r4244  
    1010namespace pablo {
    1111
    12 PabloE * OptimizeOr::operator ()(PabloE * expr1, PabloE * expr2) {
     12PabloAST * OptimizeOr::operator ()(PabloAST * expr1, PabloAST * expr2) {
    1313
    1414    if (All * all = dyn_cast<All>(expr1)) {
     
    4141    else if (And * and_expr1 = dyn_cast<And>(expr1)) {
    4242        if (And * and_expr2 = dyn_cast<And>(expr2)) {
    43             PabloE * const expr1a = and_expr1->getExpr1();
    44             PabloE * const expr1b = and_expr1->getExpr2();
    45             PabloE * const expr2a = and_expr2->getExpr1();
    46             PabloE * const expr2b = and_expr2->getExpr2();
     43            PabloAST * const expr1a = and_expr1->getExpr1();
     44            PabloAST * const expr1b = and_expr1->getExpr2();
     45            PabloAST * const expr2a = and_expr2->getExpr1();
     46            PabloAST * const expr2b = and_expr2->getExpr2();
    4747            //These optimizations factor out common components that can occur when sets are formed by union
    4848            //(e.g., union of [a-z] and [A-Z].
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4227 r4244  
    88#define PE_OR_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111
    1212namespace pablo {
     
    1414class PabloBlock;
    1515
    16 class Or : public PabloE {
     16class Or : public PabloAST {
    1717    friend struct OptimizeOr;
    1818    friend class PabloBlock;
    1919public:
    20     static inline bool classof(const PabloE * e) {
     20    static inline bool classof(const PabloAST * e) {
    2121        return e->getClassTypeId() == ClassTypeId::Or;
    2222    }
     
    2626    virtual ~Or() {
    2727    }
    28     inline PabloE * getExpr1() const {
     28    inline PabloAST * getExpr1() const {
    2929        return mExpr1;
    3030    }
    31     inline PabloE* getExpr2() const {
     31    inline PabloAST* getExpr2() const {
    3232        return mExpr2;
    3333    }
    3434protected:
    35     Or(PabloE * expr1, PabloE * expr2)
    36     : PabloE(ClassTypeId::Or)
     35    Or(PabloAST * expr1, PabloAST * expr2)
     36    : PabloAST(ClassTypeId::Or)
    3737    , mExpr1(expr1)
    3838    , mExpr2(expr2)
     
    4141    }
    4242private:
    43     PabloE * const mExpr1;
    44     PabloE * const mExpr2;
     43    PabloAST * const mExpr1;
     44    PabloAST * const mExpr2;
    4545};
    4646
    4747struct OptimizeOr {
    4848    inline OptimizeOr(PabloBlock & cg) : cg(cg) {}
    49     PabloE * operator()(PabloE * expr1, PabloE * expr2);
     49    PabloAST * operator()(PabloAST * expr1, PabloAST * expr2);
    5050private:
    5151    PabloBlock & cg;
  • icGREP/icgrep-devel/icgrep/pablo/pe_pabloe.cpp

    r4214 r4244  
    55 */
    66
    7 #include "pe_pabloe.h"
     7#include "pabloAST.h"
    88#include "pe_advance.h"
    99#include "pe_all.h"
     
    1414#include "pe_not.h"
    1515#include "pe_or.h"
    16 #include "pe_pabloe.h"
     16#include "pabloAST.h"
    1717#include "pe_scanthru.h"
    1818#include "pe_sel.h"
     
    3030*/
    3131
    32 bool equals(const PabloE * expr1, const PabloE * expr2) {
     32bool equals(const PabloAST * expr1, const PabloAST * expr2) {
    3333    if (expr1->getClassTypeId() == expr2->getClassTypeId()) {
    3434        if (const All * all1 = dyn_cast<const All>(expr1)) {
     
    9292
    9393
    94 PabloE::~PabloE(){ }
     94PabloAST::~PabloAST(){ }
    9595
    9696
  • icGREP/icgrep-devel/icgrep/pablo/pe_pabloe.h

    r4227 r4244  
    55 */
    66
    7 #ifndef PE_PABLOE_H
    8 #define PE_PABLOE_H
     7#ifndef PE_PabloAST_H
     8#define PE_PabloAST_H
    99
    1010#include <llvm/Support/Casting.h>
     
    1616namespace pablo {
    1717
    18 class PabloE {
     18class PabloAST {
    1919public:
    2020    enum class ClassTypeId : unsigned {
     
    3939        return mClassTypeId;
    4040    }
    41     virtual ~PabloE() = 0;
     41    virtual ~PabloAST() = 0;
    4242protected:
    43     inline PabloE(const ClassTypeId id)
     43    inline PabloAST(const ClassTypeId id)
    4444    : mClassTypeId(id) {
    4545
     
    4949};
    5050
    51 bool equals(const PabloE * expr1, const PabloE *expr2);
     51bool equals(const PabloAST * expr1, const PabloAST *expr2);
    5252
    53 typedef std::list<PabloE *> ExpressionList;
     53typedef std::list<PabloAST *> ExpressionList;
    5454
    5555}
    5656
    57 #endif // PE_PABLOE_H
     57#endif // PE_PabloAST_H
    5858
    5959
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4227 r4244  
    88#define PS_SCANTHRU_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111
    1212namespace pablo {
    1313
    14 class ScanThru : public  PabloE {
     14class ScanThru : public  PabloAST {
    1515    friend class PabloBlock;
    1616public:
    17     static inline bool classof(const PabloE * e) {
     17    static inline bool classof(const PabloAST * e) {
    1818        return e->getClassTypeId() == ClassTypeId::ScanThru;
    1919    }
     
    2121        return false;
    2222    }
    23     ScanThru(PabloE * from, PabloE * thru)
    24     : PabloE(ClassTypeId::ScanThru)
     23    ScanThru(PabloAST * from, PabloAST * thru)
     24    : PabloAST(ClassTypeId::ScanThru)
    2525    , mScanFrom(from)
    2626    , mScanThru(thru)
     
    3030    virtual ~ScanThru() {
    3131    }
    32     PabloE * getScanFrom() const {
     32    PabloAST * getScanFrom() const {
    3333        return mScanFrom;
    3434    }
    35     PabloE * getScanThru() const {
     35    PabloAST * getScanThru() const {
    3636        return mScanThru;
    3737    }
    3838private:
    39     PabloE * const mScanFrom;
    40     PabloE * const mScanThru;
     39    PabloAST * const mScanFrom;
     40    PabloAST * const mScanThru;
    4141};
    4242
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.cpp

    r4214 r4244  
    1010namespace pablo {
    1111
    12 PabloE * OptimizeSel::operator()(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr) {
     12PabloAST * OptimizeSel::operator()(PabloAST * if_expr, PabloAST * t_expr, PabloAST * f_expr) {
    1313    if (All * all_if_expr = dyn_cast<All>(if_expr)) {
    1414        if (all_if_expr->getValue()) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

    r4227 r4244  
    88#define PE_SEL_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111
    1212namespace pablo {
     
    1414class PabloBlock;
    1515
    16 class Sel : public PabloE {
     16class Sel : public PabloAST {
    1717    friend struct OptimizeSel;
    1818    friend class PabloBlock;
    1919public:
    20     static inline bool classof(const PabloE * e) {
     20    static inline bool classof(const PabloAST * e) {
    2121        return e->getClassTypeId() == ClassTypeId::Sel;
    2222    }
     
    2626    virtual ~Sel() {
    2727    }
    28     inline PabloE * getCondition() const {
     28    inline PabloAST * getCondition() const {
    2929        return mIf_expr;
    3030    }
    31     inline PabloE * getTrueExpr() const {
     31    inline PabloAST * getTrueExpr() const {
    3232        return mT_expr;
    3333    }
    34     inline PabloE * getFalseExpr() const {
     34    inline PabloAST * getFalseExpr() const {
    3535        return mF_expr;
    3636    }
    3737protected:
    38     Sel(PabloE* if_expr, PabloE* t_expr, PabloE* f_expr)
    39     : PabloE(ClassTypeId::Sel)
     38    Sel(PabloAST* if_expr, PabloAST* t_expr, PabloAST* f_expr)
     39    : PabloAST(ClassTypeId::Sel)
    4040    , mIf_expr(if_expr)
    4141    , mT_expr(t_expr)
     
    4545    }
    4646private:
    47     PabloE * const mIf_expr;
    48     PabloE * const mT_expr;
    49     PabloE * const mF_expr;
     47    PabloAST * const mIf_expr;
     48    PabloAST * const mT_expr;
     49    PabloAST * const mF_expr;
    5050};
    5151
    5252struct OptimizeSel {
    5353    inline OptimizeSel(PabloBlock & cg) : cg(cg) {}
    54     PabloE * operator()(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr);
     54    PabloAST * operator()(PabloAST * if_expr, PabloAST * t_expr, PabloAST * f_expr);
    5555private:
    5656    PabloBlock & cg;
  • icGREP/icgrep-devel/icgrep/pablo/pe_string.h

    r4213 r4244  
    22#define PE_STRING_H
    33
    4 #include <pablo/pe_pabloe.h>
     4#include <pablo/pabloAST.h>
    55#include <string>
    66
    77namespace pablo {
    88
    9 class String : public PabloE, public std::string {
     9class String : public PabloAST, public std::string {
    1010    friend String * makeString(const std::string);
    1111public:
    12     static inline bool classof(const PabloE * e) {
     12    static inline bool classof(const PabloAST * e) {
    1313        return e->getClassTypeId() == ClassTypeId::String;
    1414    }
     
    2424protected:
    2525    String(const std::string string) noexcept
    26     : PabloE(ClassTypeId::String)
     26    : PabloAST(ClassTypeId::String)
    2727    , std::string(string)
    2828    {
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r4227 r4244  
    88#define PE_VAR_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111#include <pablo/ps_assign.h>
    1212#include <pablo/pe_string.h>
     
    1414namespace pablo {
    1515
    16 class Var : public PabloE {
     16class Var : public PabloAST {
    1717    friend class PabloBlock;
    1818public:
    19     static inline bool classof(const PabloE * e) {
     19    static inline bool classof(const PabloAST * e) {
    2020        return e->getClassTypeId() == ClassTypeId::Var;
    2121    }
     
    2929    }
    3030protected:
    31     Var(const PabloE * var)
    32     : PabloE(ClassTypeId::Var)
     31    Var(const PabloAST * var)
     32    : PabloAST(ClassTypeId::Var)
    3333    , mVar(cast<String>(var)) {
    3434
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.cpp

    r4214 r4244  
    1010namespace pablo {
    1111
    12 PabloE * OptimizeXor::operator()(PabloE * expr1, PabloE * expr2) {
     12PabloAST * OptimizeXor::operator()(PabloAST * expr1, PabloAST * expr2) {
    1313    if (All * all1 = dyn_cast<All>(expr1)) {
    1414        if (all1->getValue()) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4227 r4244  
    88#define XOR_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111
    1212namespace pablo {
     
    1414class PabloBlock;
    1515
    16 class Xor : public PabloE {
     16class Xor : public PabloAST {
    1717    friend struct OptimizeXor;
    1818    friend class PabloBlock;
    1919public:
    20     static inline bool classof(const PabloE * e) {
     20    static inline bool classof(const PabloAST * e) {
    2121        return e->getClassTypeId() == ClassTypeId::Xor;
    2222    }
     
    2626    virtual ~Xor() {
    2727    }
    28     inline PabloE * getExpr1() const {
     28    inline PabloAST * getExpr1() const {
    2929        return mExpr1;
    3030    }
    31     inline PabloE * getExpr2() const {
     31    inline PabloAST * getExpr2() const {
    3232        return mExpr2;
    3333    }
    3434protected:
    35     Xor(PabloE * expr1, PabloE * expr2)
    36     : PabloE(ClassTypeId::Xor)
     35    Xor(PabloAST * expr1, PabloAST * expr2)
     36    : PabloAST(ClassTypeId::Xor)
    3737    , mExpr1(expr1)
    3838    , mExpr2(expr2)
     
    4141    }
    4242private:
    43     PabloE * const mExpr1;
    44     PabloE * const mExpr2;
     43    PabloAST * const mExpr1;
     44    PabloAST * const mExpr2;
    4545};
    4646
    4747struct OptimizeXor {
    4848    inline OptimizeXor(PabloBlock & cg) : cg(cg) {}
    49     PabloE * operator()(PabloE * expr1, PabloE * expr2);
     49    PabloAST * operator()(PabloAST * expr1, PabloAST * expr2);
    5050private:
    5151    PabloBlock & cg;
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r4220 r4244  
    1717
    1818//Pablo Expressions
    19 #include <pablo/pe_pabloe.h>
     19#include <pablo/pabloAST.h>
    2020#include <pablo/pe_advance.h>
    2121#include <pablo/pe_all.h>
     
    6868}
    6969
    70 std::string StatementPrinter::ShowPabloS(const PabloE * stmt)
     70std::string StatementPrinter::ShowPabloS(const PabloAST * stmt)
    7171{
    7272    std::string retVal = "";
     
    7474    if (const Assign * an = dyn_cast<const Assign>(stmt))
    7575    {
    76         retVal = "Assign('" + an->getName() + "', " + ShowPabloE(an->getExpr()) + "),";
     76        retVal = "Assign('" + an->getName() + "', " + ShowPabloAST(an->getExpr()) + "),";
    7777    }
    7878    else if (const If * ifstmt = dyn_cast<const If>(stmt))
    7979    {
    80         retVal = "If(" + ShowPabloE(ifstmt->getCondition()) + ", " + Print_PB_PabloStmts(ifstmt->getBody(), retVal) + ")";
     80        retVal = "If(" + ShowPabloAST(ifstmt->getCondition()) + ", " + Print_PB_PabloStmts(ifstmt->getBody(), retVal) + ")";
    8181    }
    8282    else if (const While * whl = dyn_cast<const While>(stmt))
    8383    {
    84         retVal = "While(" + ShowPabloE(whl->getCondition()) + ", " + Print_PB_PabloStmts(whl->getBody(), retVal) + ")";
     84        retVal = "While(" + ShowPabloAST(whl->getCondition()) + ", " + Print_PB_PabloStmts(whl->getBody(), retVal) + ")";
    8585    }
    8686    else retVal = "UNKNOWN_STATEMENT_TYPE!!!";
     
    8888}
    8989
    90 std::string StatementPrinter::ShowPabloE(const PabloE *expr)
     90std::string StatementPrinter::ShowPabloAST(const PabloAST *expr)
    9191{
    9292    std::string retVal = "";
     
    106106    else if (const And * pablo_and = dyn_cast<const And>(expr))
    107107    {
    108         retVal = "And(" + ShowPabloE(pablo_and->getExpr1()) +", " + ShowPabloE(pablo_and->getExpr2()) + ")";
     108        retVal = "And(" + ShowPabloAST(pablo_and->getExpr1()) +", " + ShowPabloAST(pablo_and->getExpr2()) + ")";
    109109    }
    110110    else if (const Or * pablo_or = dyn_cast<const Or>(expr))
    111111    {
    112         retVal = "Or(" + ShowPabloE(pablo_or->getExpr1()) + ", " + ShowPabloE(pablo_or->getExpr2()) + ")";
     112        retVal = "Or(" + ShowPabloAST(pablo_or->getExpr1()) + ", " + ShowPabloAST(pablo_or->getExpr2()) + ")";
    113113    }
    114114    else if (const Sel * pablo_sel = dyn_cast<const Sel>(expr))
    115115    {
    116         retVal = "((" + ShowPabloE(pablo_sel->getCondition()) + "And " + ShowPabloE(pablo_sel->getTrueExpr()) +
    117                 ")|(Not(" + ShowPabloE(pablo_sel->getCondition()) + ") And " + ShowPabloE(pablo_sel->getFalseExpr()) + ")";
     116        retVal = "((" + ShowPabloAST(pablo_sel->getCondition()) + "And " + ShowPabloAST(pablo_sel->getTrueExpr()) +
     117                ")|(Not(" + ShowPabloAST(pablo_sel->getCondition()) + ") And " + ShowPabloAST(pablo_sel->getFalseExpr()) + ")";
    118118    }
    119119    else if (const Not * pablo_not = dyn_cast<const Not>(expr))
    120120    {
    121         retVal = "Not (" + ShowPabloE(pablo_not->getExpr()) + ")";
     121        retVal = "Not (" + ShowPabloAST(pablo_not->getExpr()) + ")";
    122122    }
    123123    else if (const CharClass * cc = dyn_cast<const CharClass>(expr))
     
    127127    else if (const Advance * adv = dyn_cast<const Advance>(expr))
    128128    {
    129         retVal = "Advance(" + ShowPabloE(adv->getExpr()) + ")";
     129        retVal = "Advance(" + ShowPabloAST(adv->getExpr()) + ")";
    130130    }
    131131    else if (const MatchStar * mstar = dyn_cast<const MatchStar>(expr))
    132132    {
    133         retVal = "MatchStar (" + ShowPabloE(mstar->getExpr1()) + ", " + ShowPabloE(mstar->getExpr2()) + ")";
     133        retVal = "MatchStar (" + ShowPabloAST(mstar->getExpr1()) + ", " + ShowPabloAST(mstar->getExpr2()) + ")";
    134134    }
    135135    else if (const ScanThru * sthru = dyn_cast<const ScanThru>(expr))
    136136    {
    137         retVal = "ScanThru (" + ShowPabloE(sthru->getScanFrom()) + ", " + ShowPabloE(sthru->getScanThru()) + ")";
     137        retVal = "ScanThru (" + ShowPabloAST(sthru->getScanFrom()) + ", " + ShowPabloAST(sthru->getScanThru()) + ")";
    138138    }
    139139    else retVal = "UNKNOWN_Pablo_EXPRESSION_TYPE!!!";
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.h

    r4220 r4244  
    88#define SHOW_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111#include <string>
    1212
     
    2020    static std::string Print_CC_PabloStmts(const pablo::ExpressionList & stmts);
    2121    static std::string Print_PB_PabloStmts(const pablo::ExpressionList & stmts, std::string strOut);
    22     static std::string ShowPabloE(const pablo::PabloE * expr);
    23     static std::string ShowPabloS(const pablo::PabloE *stmt);
     22    static std::string ShowPabloAST(const pablo::PabloAST * expr);
     23    static std::string ShowPabloS(const pablo::PabloAST *stmt);
    2424};
    2525
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.h

    r4227 r4244  
    88#define PS_SETMARKER_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111#include <pablo/pe_string.h>
    1212
    1313namespace pablo {
    1414
    15 class Assign : public PabloE {
     15class Assign : public PabloAST {
    1616    friend class PabloBlock;
    1717public:
    18     static inline bool classof(const PabloE * e) {
     18    static inline bool classof(const PabloAST * e) {
    1919        return e->getClassTypeId() == ClassTypeId::Assign;
    2020    }
     
    2727        return *mName;
    2828    }
    29     inline PabloE * getExpr() const {
     29    inline PabloAST * getExpr() const {
    3030        return mExpr;
    3131    }
    3232protected:
    33     Assign(PabloE * name, PabloE * expr)
    34     : PabloE(ClassTypeId::Assign)
     33    Assign(PabloAST * name, PabloAST * expr)
     34    : PabloAST(ClassTypeId::Assign)
    3535    , mName(cast<String>(name))
    3636    , mExpr(expr)
     
    4040private:
    4141    const String * const    mName;
    42     PabloE * const          mExpr;
     42    PabloAST * const          mExpr;
    4343};
    4444
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.h

    r4227 r4244  
    88#define PS_IF_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111
    1212namespace pablo {
    1313
    14 class If : public PabloE {
     14class If : public PabloAST {
    1515    friend class PabloBlock;
    1616public:
    17     static inline bool classof(const PabloE * e) {
     17    static inline bool classof(const PabloAST * e) {
    1818        return e->getClassTypeId() == ClassTypeId::If;
    1919    }
     
    2323    virtual ~If() {
    2424    }
    25     inline PabloE * getCondition() const {
     25    inline PabloAST * getCondition() const {
    2626        return mExpr;
    2727    }
     
    3030    }
    3131protected:
    32     If(PabloE * expr, ExpressionList && psl)
    33     : PabloE(ClassTypeId::If)
     32    If(PabloAST * expr, ExpressionList && psl)
     33    : PabloAST(ClassTypeId::If)
    3434    , mExpr(expr)
    3535    , mPSList(psl)
     
    3838    }
    3939private:
    40     PabloE * const mExpr;
     40    PabloAST * const mExpr;
    4141    ExpressionList mPSList;
    4242};
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.h

    r4227 r4244  
    88#define PS_WHILE_H
    99
    10 #include <pablo/pe_pabloe.h>
     10#include <pablo/pabloAST.h>
    1111
    1212namespace pablo {
    1313
    14 class While : public PabloE {
     14class While : public PabloAST {
    1515    friend class PabloBlock;
    1616public:
    17     static inline bool classof(const PabloE * e) {
     17    static inline bool classof(const PabloAST * e) {
    1818        return e->getClassTypeId() == ClassTypeId::While;
    1919    }
     
    2323    virtual ~While() {
    2424    }
    25     inline PabloE * getCondition() const {
     25    inline PabloAST * getCondition() const {
    2626        return mExpr;
    2727    }
     
    3030    }
    3131protected:
    32     While(PabloE * expr, ExpressionList && psl)
    33     : PabloE(ClassTypeId::While)
     32    While(PabloAST * expr, ExpressionList && psl)
     33    : PabloAST(ClassTypeId::While)
    3434    , mExpr(expr)
    3535    , mPSList(psl)
     
    3838    }
    3939private:
    40     PabloE * const  mExpr;
     40    PabloAST * const  mExpr;
    4141    ExpressionList  mPSList;
    4242};
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4235 r4244  
    2626#include <pablo/pe_not.h>
    2727#include <pablo/pe_or.h>
    28 #include <pablo/pe_pabloe.h>
     28#include <pablo/pabloAST.h>
    2929#include <pablo/pe_scanthru.h>
    3030#include <pablo/pe_sel.h>
     
    5555        std::string gs_initial = cg.ssa("initial");
    5656        m_name_map.insert(make_pair("initial", gs_initial));
    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);
     57        PabloAST * u8single = cg.createVar(m_name_map.find("UTF8-SingleByte")->second);
     58        PabloAST * u8pfx2 = cg.createVar(m_name_map.find("UTF8-Prefix2")->second);
     59        PabloAST * u8pfx3 = cg.createVar(m_name_map.find("UTF8-Prefix3")->second);
     60        PabloAST * u8pfx4 = cg.createVar(m_name_map.find("UTF8-Prefix4")->second);
     61        PabloAST * u8pfx = cg.createOr(cg.createOr(u8pfx2, u8pfx3), u8pfx4);
    6262        cg.createAssign(gs_initial, cg.createOr(u8pfx, u8single));
    6363
     
    6969        cg.createAssign(gs_nonfinal, cg.createAll(0));
    7070        #endif
    71         PabloE * u8scope32 = cg.createAdvance(u8pfx3);
    72         PabloE * u8scope42 = cg.createAdvance(u8pfx4);
    73         PabloE * u8scope43 = cg.createAdvance(u8scope42);
     71        PabloAST * u8scope32 = cg.createAdvance(u8pfx3);
     72        PabloAST * u8scope42 = cg.createAdvance(u8pfx4);
     73        PabloAST * u8scope43 = cg.createAdvance(u8scope42);
    7474        #ifdef USE_IF_FOR_NONFINAL
    7575        PabloBlock it(cg);
     
    8282
    8383    Assign * start_marker = cg.createAssign("start", cg.createAll(1));
    84     PabloE * result = process(re, start_marker, cg);
     84    PabloAST * result = process(re, start_marker, cg);
    8585
    8686    //These three lines are specifically for grep.
     
    104104    }
    105105    else if (isa<Start>(re)) {
    106         PabloE * sol = cg.createNot(cg.createAdvance(cg.createNot(cg.createCharClass(m_name_map.find("LineFeed")->second))));
     106        PabloAST * sol = cg.createNot(cg.createAdvance(cg.createNot(cg.createCharClass(m_name_map.find("LineFeed")->second))));
    107107        target = cg.createAssign(cg.ssa("sol"), cg.createAnd(cg.createVarIfAssign(target), sol));
    108108    }
    109109    else if (isa<End>(re)) {
    110         PabloE * eol = cg.createCharClass(m_name_map.find("LineFeed")->second);
     110        PabloAST * eol = cg.createCharClass(m_name_map.find("LineFeed")->second);
    111111        target = cg.createAssign(cg.ssa("eol"), cg.createAnd(cg.createVarIfAssign(target), eol));
    112112    }
     
    116116
    117117inline Assign * RE_Compiler::process(Name * name, Assign * target, PabloBlock & cg) {
    118     PabloE * marker = cg.createVar(target);
     118    PabloAST * marker = cg.createVar(target);
    119119    if (name->getType() != Name::Type::FixedLength) {
    120120        // Move the markers forward through any nonfinal UTF-8 bytes to the final position of each character.
     
    122122        marker = cg.createScanThru(marker, cg.createCharClass(m_name_map.find("nonfinal")->second));
    123123    }
    124     PabloE * cc = nullptr;
     124    PabloAST * cc = nullptr;
    125125    if (name->getType() == Name::Type::UnicodeCategory) {
    126126        cc = cg.createCall(name->getName());
     
    177177        Name * rep_name = dyn_cast<Name>(repeated);
    178178
    179         PabloE * ccExpr;
     179        PabloAST * ccExpr;
    180180        if (rep_name->getType() == Name::Type::UnicodeCategory) {
    181181            ccExpr = cg.createCall(rep_name->getName());
     
    189189        }
    190190
    191         PabloE * unbounded = cg.createVar(target);
     191        PabloAST * unbounded = cg.createVar(target);
    192192        if (rep_name->getType() == Name::Type::FixedLength) {
    193193            unbounded = cg.createMatchStar(unbounded, ccExpr);
     
    206206
    207207        PabloBlock wt(cg);
    208         PabloE * accum = cg.createVarIfAssign(process(repeated, while_test, wt));
     208        PabloAST * accum = cg.createVarIfAssign(process(repeated, while_test, wt));
    209209        Var * var_while_test = cg.createVar(while_accum);
    210210        wt.createAssign(while_test->getName(), wt.createAnd(accum, wt.createNot(var_while_test)));
Note: See TracChangeset for help on using the changeset viewer.