Ignore:
Timestamp:
Oct 30, 2014, 1:19:34 PM (5 years ago)
Author:
nmedfort
Message:

Created an "insertion friendly" Pablo AST structure similar to LLVM; fixed engine builder bug when creating a unicode class.

File:
1 edited

Legend:

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

    r4272 r4276  
    1010#include <llvm/Support/Casting.h>
    1111#include <slab_allocator.h>
    12 #include <vector>
     12#include <iterator>
    1313
    1414using namespace llvm;
     
    5252
    5353    }
    54     static Allocator mAllocator;
     54    static Allocator    mAllocator;
    5555private:
    5656    const ClassTypeId   mClassTypeId;
     
    5959bool equals(const PabloAST * expr1, const PabloAST *expr2);
    6060
    61 typedef std::vector<PabloAST *> StatementList;
     61class Statement : public PabloAST {
     62    friend class StatementList;
     63public:
     64    Statement(const ClassTypeId id)
     65    : PabloAST(id)
     66    , mNext(nullptr)
     67    , mPrev(nullptr)
     68    {
     69
     70    }
     71    inline void insertBefore(Statement * const statement) {
     72        assert (statement);
     73        mNext = statement;
     74        mPrev = statement->mPrev;
     75        statement->mPrev = this;
     76    }
     77    inline void insertAfter(Statement * const statement) {
     78        assert (statement);
     79        mPrev = statement;
     80        mNext = statement->mNext;
     81        statement->mNext = this;
     82    }
     83private:
     84    Statement * mNext;
     85    Statement * mPrev;
     86};
     87
     88class StatementList {
     89
     90    class iterator: public std::iterator<std::forward_iterator_tag, Statement> {
     91    public:
     92        iterator(): mCurrent(nullptr) {}
     93
     94        iterator(Statement* base): mCurrent(base) {}
     95
     96        iterator(const iterator& other): mCurrent(other.mCurrent) {}
     97
     98        const iterator& operator=(const iterator& other) {
     99            mCurrent = other.mCurrent; return other;
     100        }
     101
     102        inline iterator& operator++() {
     103            assert (mCurrent);
     104            mCurrent = mCurrent->mNext;
     105            return *this;
     106        }
     107
     108        iterator  operator++(int) {
     109            iterator tmp(*this);
     110            ++(*this);
     111            return tmp;
     112        }
     113
     114        bool operator==(const iterator& other) const {
     115            return  mCurrent == other.mCurrent;
     116        }
     117
     118        bool operator!=(const iterator& other) const {
     119            return  mCurrent != other.mCurrent;
     120        }
     121
     122        Statement* operator*() {return mCurrent;}
     123        Statement* operator->(){return mCurrent;}
     124
     125    private:
     126        Statement * mCurrent;
     127        friend class const_iterator;
     128    };
     129
     130    class const_iterator: public std::iterator<std::forward_iterator_tag, Statement> {
     131    public:
     132        const_iterator(): mCurrent(nullptr) {}
     133        const_iterator(const Statement* base): mCurrent(base) {}
     134        const_iterator(const const_iterator& other): mCurrent(other.mCurrent) {}
     135        const const_iterator& operator=(const const_iterator& other) {mCurrent = other.mCurrent; return other;}
     136
     137        inline const_iterator& operator++() {
     138            assert (mCurrent);
     139            mCurrent = mCurrent->mNext;
     140            return *this;
     141        }
     142
     143        const_iterator  operator++(int) {
     144            const_iterator tmp(*this);
     145            ++(*this);
     146            return tmp;
     147        }
     148
     149        bool operator==(const const_iterator & other) const {
     150            return  mCurrent == other.mCurrent;
     151        }
     152        bool operator!=(const const_iterator & other) const {
     153            return  mCurrent != other.mCurrent;
     154        }
     155
     156        const Statement* operator*() {return mCurrent;}
     157        const Statement* operator->(){return mCurrent;}
     158
     159    private:
     160        const Statement * mCurrent;
     161        friend class iterator;
     162    };
     163
     164public:
     165
     166    StatementList()
     167    : mFirst(nullptr)
     168    , mLast(nullptr)
     169    {
     170
     171    }
     172
     173    StatementList(StatementList && other)
     174    : mFirst(other.mFirst)
     175    , mLast(other.mLast)
     176    {
     177        other.mFirst = nullptr;
     178        other.mLast = nullptr;
     179    }
     180
     181    iterator begin() {
     182        return iterator(mFirst);
     183    }
     184
     185    iterator end() {
     186        return iterator(nullptr);
     187    }
     188
     189    const_iterator begin() const {
     190        return const_iterator(mFirst);
     191    }
     192
     193    const_iterator end() const {
     194        return const_iterator(nullptr);
     195    }
     196
     197    const_iterator cbegin() const {
     198        return const_iterator(mFirst);
     199    }
     200
     201    const_iterator cend() const {
     202        return const_iterator(nullptr);
     203    }
     204
     205    void push_back(Statement * const statement);
     206
     207private:
     208    Statement * mFirst;
     209    Statement * mLast;
     210};
    62211
    63212}
Note: See TracChangeset for help on using the changeset viewer.