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

Change PabloE to PabloAST.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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};
Note: See TracChangeset for help on using the changeset viewer.