Ignore:
Timestamp:
Jan 13, 2015, 4:01:06 PM (4 years ago)
Author:
nmedfort
Message:

Many use def info changes; removed dependency on boost system library. More work still needed on CSE.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4415 r4416  
    99
    1010#include <pablo/pabloAST.h>
    11 #include <pablo/pabloAST.h>
     11#include <pablo/symbol_generator.h>
    1212#include <pablo/pe_advance.h>
    1313#include <pablo/pe_and.h>
     
    2828#include <pablo/ps_if.h>
    2929#include <pablo/ps_while.h>
    30 #include <pablo/symbol_generator.h>
    31 #include <map>
    32 #include <vector>
    33 #include <string>
    34 #include <array>
    35 #include <tuple>
    36 #include <pablo/printer_pablos.h>
     30#include <stdexcept>
    3731
    3832namespace pablo {
     33
     34class Assign;
     35class Advance;
     36class And;
     37class Call;
     38class MatchStar;
     39class Next;
     40class Not;
     41class Or;
     42class Ones;
     43class ScanThru;
     44class Sel;
     45class String;
     46class Integer;
     47class Var;
     48class Xor;
     49class Zeroes;
     50class If;
     51class While;
     52
    3953
    4054class PabloBlock : public StatementList {
     
    6983    Call * createCall(String * name);
    7084
    71     Assign * createAssign(const std::string prefix, PabloAST * expr, const int outputIndex = -1)  {
    72         // Note: we cannot just use the findOrMake method to obtain this; an Assign node cannot be considered
    73         // unique until we prove it has no Next node associated with it. But the Assign node must be created
    74         // before the Next node. Should we create a "Constant" flag for this?
    75         Assign * assign = new Assign(expr, outputIndex, mSymbolGenerator->make(prefix), this);
    76         insert(assign);
    77         return assign;
    78     }
    79 
    80     Assign * createImmutableAssign(const std::string prefix, PabloAST * expr, const int outputIndex = -1);
     85    Assign * createAssign(const std::string prefix, PabloAST * expr, const int outputIndex = -1);
    8186
    8287    Var * createVar(const std::string name);
     
    114119    Sel * createSelImm(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
    115120
    116     inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body) {
    117         If * statement = new If(condition, std::move(definedVars), body, this);
    118         insert(statement);
    119         return statement;
    120     }
     121    If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body);
    121122
    122     inline While * createWhile(PabloAST * cond, PabloBlock & body) {
    123         While * statement = new While(cond, body, this);
    124         insert(statement);
    125         return statement;
    126     }
    127 
    128     PabloAST * setOperandOf(Statement * inst, const unsigned index, PabloAST * value);
    129 
    130     template<typename... Args>
    131     struct ExpressionMap {
    132         enum {N = sizeof...(Args)};
    133         typedef ExpressionMap<Args...> MapType;
    134         typedef std::tuple<PabloAST::ClassTypeId, Args...> Key;
    135 
    136         inline ExpressionMap(MapType * predecessor)
    137         : mPredecessor(predecessor)
    138         {
    139 
    140         }
    141 
    142         template <class Type, typename... Params>
    143         inline std::pair<Type *, bool> findOrMake(const PabloAST::ClassTypeId type, Args... args, Params... params) {
    144             Key key = std::make_tuple(type, args...);
    145             PabloAST * const f = find(key);
    146             if (f) {
    147                 return std::make_pair(cast<Type>(f), false);
    148             }
    149             PabloAST * const expr = new Type(std::forward<Args>(args)..., std::forward<Params>(params)...);
    150             mMap.insert(std::make_pair(std::move(key), expr));
    151             return std::make_pair(cast<Type>(expr), isa<Statement>(expr));
    152         }
    153 
    154         template <class Functor, typename... Params>
    155         inline PabloAST * findOrCall(const PabloAST::ClassTypeId type, Args... args, Params... params) {
    156             Key key = std::make_tuple(type, args...);
    157             PabloAST * const f = find(key);
    158             if (f) {
    159                 return f;
    160             }
    161             Functor mf;
    162             PabloAST * const expr = mf(std::forward<Args>(args)..., std::forward<Params>(params)...);
    163             mMap.insert(std::make_pair(std::move(key), expr));
    164             return expr;
    165         }
    166 
    167         template <class Functor, typename... Params>
    168         inline PabloAST * findOrAdd(const PabloAST::ClassTypeId type, Args... args, PabloAST * expr) {
    169             Key key = std::make_tuple(type, args...);
    170             PabloAST * const f = find(key);
    171             if (f) {
    172                 return f;
    173             }
    174             mMap.insert(std::make_pair(std::move(key), expr));
    175             return expr;
    176         }
    177 
    178         inline bool erase(const PabloAST::ClassTypeId type, Args... args) {
    179             Key key = std::make_tuple(type, args...);
    180             auto itr = mMap.find(key);
    181             if (itr == mMap.end()) {
    182                 return mPredecessor ? mPredecessor->erase(type, args...) : false;
    183             }
    184             mMap.erase(itr);
    185             return true;
    186         }
    187 
    188         inline PabloAST * find(const Key & key) const {
    189             // check this map to see if we have it
    190             auto itr = mMap.find(key);
    191             if (itr != mMap.end()) {
    192                 return itr->second;
    193             }
    194             // check any previous maps to see if it exists
    195             auto * pred = mPredecessor;
    196             while (pred) {
    197                 itr = pred->mMap.find(key);
    198                 if (itr == pred->mMap.end()) {
    199                     pred = pred->mPredecessor;
    200                     continue;
    201                 }
    202                 return itr->second;
    203             }
    204             return nullptr;
    205         }
    206 
    207     private:
    208         MapType * const             mPredecessor;
    209         std::map<Key, PabloAST *>   mMap;
    210     };
     123    While * createWhile(PabloAST * cond, PabloBlock & body);
    211124
    212125    inline StatementList & statements() {
     
    217130        return *this;
    218131    }
     132
    219133    inline String * getName(const std::string name) const {
    220134        return mSymbolGenerator->get(name);
    221135    }
     136
    222137    inline String * makeName(const std::string prefix) const {
    223138        return mSymbolGenerator->make(prefix);
    224139    }
     140
    225141protected:
    226     PabloBlock()
    227     : mZeroes(new Zeroes())
    228     , mOnes(new Ones())
    229     , mSymbolGenerator(new SymbolGenerator())
    230     , mUnary(nullptr)
    231     , mUnaryWithInt(nullptr)
    232     , mBinary(nullptr)
    233     , mTernary(nullptr)
    234     {
     142    PabloBlock();
    235143
    236     }
     144    PabloBlock(PabloBlock * predecessor);
    237145
    238     PabloBlock(PabloBlock * predecessor)
    239     : mZeroes(predecessor->mZeroes) // inherit the original "Zeroes" variable for simplicity
    240     , mOnes(predecessor->mOnes) // inherit the original "Ones" variable for simplicity
    241     , mSymbolGenerator(predecessor->mSymbolGenerator)
    242     , mUnary(&(predecessor->mUnary))
    243     , mUnaryWithInt(&(predecessor->mUnaryWithInt))
    244     , mBinary(&(predecessor->mBinary))
    245     , mTernary(&(predecessor->mTernary))
    246     {
    247 
    248     }
    249 
    250     void* operator new (std::size_t size) noexcept {
     146    void * operator new (std::size_t size) noexcept {
    251147        return PabloAST::mAllocator.allocate(size);
    252148    }
    253149
    254150    template<typename Type>
    255     inline Type insertIfNew(std::pair<Type, bool> retVal) {
    256         if (std::get<1>(retVal)) {
    257             insert(cast<Statement>(std::get<0>(retVal)));
     151    inline Type * insertAtInsertionPoint(Type * expr) {
     152        if (isa<Statement>(expr)) {
     153            insert(cast<Statement>(expr));
    258154        }
    259         return std::get<0>(retVal);
     155        return expr;
    260156    }
    261157
     
    264160    Ones * const                                        mOnes;
    265161    SymbolGenerator * const                             mSymbolGenerator;
    266     ExpressionMap<PabloAST *>                           mUnary;
    267     ExpressionMap<PabloAST *, int>                      mUnaryWithInt;
    268     ExpressionMap<PabloAST *, PabloAST *>               mBinary;
    269     ExpressionMap<PabloAST *, PabloAST *, PabloAST *>   mTernary;
    270162};
    271163
Note: See TracChangeset for help on using the changeset viewer.