Changeset 4415


Ignore:
Timestamp:
Jan 10, 2015, 3:14:51 PM (4 years ago)
Author:
nmedfort
Message:

More work on usedef info.

Location:
icGREP/icgrep-devel/icgrep
Files:
1 added
9 edited

Legend:

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

    r4414 r4415  
    66
    77#include <pablo/codegenstate.h>
    8 #include <iostream>
    98
    109namespace pablo {
     
    1615        return expr;
    1716    }
    18     return appendIfNew(mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount, mSymbolGenerator, this));
     17    return insertIfNew(mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount, mSymbolGenerator, this));
     18}
     19
     20Assign * PabloBlock::createImmutableAssign(const std::string prefix, PabloAST * expr, const int outputIndex) {
     21    return insertIfNew(mUnary.findOrMake<Assign>(PabloAST::ClassTypeId::Assign, expr, outputIndex, mSymbolGenerator->make(prefix), this));
    1922}
    2023
    2124Call * PabloBlock::createCall(const std::string name) {
    22     return appendIfNew(mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, mSymbolGenerator->get(name), this));
     25    return createCall(mSymbolGenerator->get(name));
     26}
     27
     28Call * PabloBlock::createCall(String * name) {
     29    return insertIfNew(mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, name, this));
    2330}
    2431
     
    2835
    2936Not * PabloBlock::createNotImm(PabloAST * expr) {
    30     return appendIfNew(mUnary.findOrMake<Not>(PabloAST::ClassTypeId::Not, expr, this));
     37    return insertIfNew(mUnary.findOrMake<Not>(PabloAST::ClassTypeId::Not, expr, this));
    3138}
    3239
     40Var * PabloBlock::createVar(const std::string name) {
     41    return createVar(mSymbolGenerator->get(name));
     42}
    3343
    34 Var * PabloBlock::createVar(const std::string name) {
    35     return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, mSymbolGenerator->get(name), this).first;
     44Var * PabloBlock::createVar(String * name) {
     45    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, name, this).first;
    3646}
    3747
     
    3949
    4050Next * PabloBlock::createNext(Assign * assign, PabloAST * expr) {
    41     return appendIfNew(mBinary.findOrMake<Next>(PabloAST::ClassTypeId::Next, assign, expr, this));
     51    return insertIfNew(mBinary.findOrMake<Next>(PabloAST::ClassTypeId::Next, assign, expr, this));
    4252}
    4353
     
    4656        return marker;
    4757    }
    48     return appendIfNew(mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass, mSymbolGenerator, this));
     58    return insertIfNew(mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass, mSymbolGenerator, this));
    4959}
    5060
     
    5363        return from;
    5464    }
    55     return appendIfNew(mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru, mSymbolGenerator, this));
     65    return insertIfNew(mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru, mSymbolGenerator, this));
    5666}
    5767
     
    6474
    6575And * PabloBlock::createAndImm(PabloAST * expr1, PabloAST * expr2) {
    66     return appendIfNew(mBinary.findOrMake<And>(PabloAST::ClassTypeId::And, expr1, expr2, this));
     76    return insertIfNew(mBinary.findOrMake<And>(PabloAST::ClassTypeId::And, expr1, expr2, this));
    6777}
    6878
     
    7585
    7686Or * PabloBlock::createOrImm(PabloAST * expr1, PabloAST * expr2) {
    77     return appendIfNew(mBinary.findOrMake<Or>(PabloAST::ClassTypeId::Or, expr1, expr2, this));
     87    return insertIfNew(mBinary.findOrMake<Or>(PabloAST::ClassTypeId::Or, expr1, expr2, this));
    7888}
    7989
     
    8696
    8797Xor * PabloBlock::createXorImm(PabloAST * expr1, PabloAST * expr2) {
    88     return appendIfNew(mBinary.findOrMake<Xor>(PabloAST::ClassTypeId::Xor, expr1, expr2,  this));
     98    return insertIfNew(mBinary.findOrMake<Xor>(PabloAST::ClassTypeId::Xor, expr1, expr2,  this));
    8999}
    90100
     
    96106
    97107Sel * PabloBlock::createSelImm(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
    98     return appendIfNew(mTernary.findOrMake<Sel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr, this));
     108    return insertIfNew(mTernary.findOrMake<Sel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr, this));
    99109}
    100110
    101 //PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
     111PabloAST * PabloBlock::setOperandOf(Statement * inst, const unsigned index, PabloAST * value) {
    102112
     113    assert (index < inst->getNumOperands() && inst->getOperand(index) != value);
    103114
     115    // get the current insertion point so we can restore it later
     116    Statement * const ip = getInsertPoint();
     117    const bool replacingCurrentIP = (ip == inst);
    104118
     119    // set the current ip to the position of the inst we're "updating"
     120    setInsertPoint(inst);
     121    // this will move the ip back to inst's prior node
     122    inst->removeFromParent();
    105123
    106 //}
     124    PabloAST * retVal = inst;
    107125
    108 //PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
    109 //    if (from == to) {
    110 //        return inst;
    111 //    }
    112 //    switch (inst->getClassTypeId()) {
    113 //        case PabloAST::ClassTypeId::Advance:
    114 //            {
    115 //                Advance * n = cast<Advance>(inst);
    116 //                if (n->getExpr() == from) {
    117 //                    return createAdvance(to, n->getAdvanceAmount());
    118 //                }
    119 //                return inst;
    120 //            }
     126    switch (inst->getClassTypeId()) {
     127        case PabloAST::ClassTypeId::Advance:
     128            retVal = createAdvance(value, cast<Advance>(inst)->getAdvanceAmount());
     129            break;
     130        case PabloAST::ClassTypeId::Not:
     131            retVal = createNot(value);
     132            break;
    121133//        case PabloAST::ClassTypeId::Assign:
    122 //            {
    123 //                Assign * n = cast<Assign>(inst);
    124 //                if (n->getExpr() == from) {
    125 //                    Assign * assign = createAssign(to);
    126 //                    n->replaceWith(assign);
    127 //                    return assign;
    128 //                }
    129 //                return inst;
    130 //            }
    131 //        case PabloAST::ClassTypeId::Var:
    132 //            {
    133 //                Var * n = cast<Var>(inst);
    134 //                if (n->getVar() == from) {
    135 //                    return createVar(to);
    136 //                }
    137 //                return inst;
    138 //            }
    139 //        case PabloAST::ClassTypeId::Next:
    140 //            {
    141 //                Next * n = cast<Next>(inst);
    142 //                if (n->getInitial() == from || n->getExpr() == from) {
    143 //                    return createNext(n->getInitial() == from ? to : n->getInitial(),
    144 //                                      n->getExpr() == from ? to : n->getExpr());
    145 //                }
    146 //                return inst;
    147 //            }
    148 ////        case PabloAST::ClassTypeId::Call:
    149 ////            {
    150 ////                Call * n = cast<Call>(node);
    151 ////                if (n->getCallee() == from) {
    152 ////                    return createCall(to, n->getExpr());
    153 ////                }
    154 ////                return node;
    155 ////            }
    156 //        case PabloAST::ClassTypeId::Not:
    157 //            {
    158 //                Not * n = cast<Not>(inst);
    159 //                if (n->getExpr() == from) {
    160 //                    return createNot(to);
    161 //                }
    162 //                return inst;
    163 //            }
    164 //        case PabloAST::ClassTypeId::And:
    165 //            {
    166 //                And * n = cast<And>(inst);
    167 //                if (n->getExpr1() == from || n->getExpr2() == from) {
    168 //                    return createAnd(n->getExpr1() == from ? to : n->getExpr1(),
    169 //                                     n->getExpr2() == from ? to : n->getExpr2());
    170 //                }
    171 //                return inst;
    172 //            }
    173 //        case PabloAST::ClassTypeId::Or:
    174 //            {
    175 //                Or * n = cast<Or>(inst);
    176 //                if (n->getExpr1() == from || n->getExpr2() == from) {
    177 //                    return createOr(n->getExpr1() == from ? to : n->getExpr1(),
    178 //                                    n->getExpr2() == from ? to : n->getExpr2());
    179 //                }
    180 //                return inst;
    181 //            }
    182 //        case PabloAST::ClassTypeId::Xor:
    183 //            {
    184 //                Xor * n = cast<Xor>(inst);
    185 //                if (n->getExpr1() == from || n->getExpr2() == from) {
    186 //                    return createXor(n->getExpr1() == from ? to : n->getExpr1(),
    187 //                                     n->getExpr2() == from ? to : n->getExpr2());
    188 //                }
    189 //                return inst;
    190 //            }
    191 //        case PabloAST::ClassTypeId::ScanThru:
    192 //            {
    193 //                ScanThru * n = cast<ScanThru>(inst);
    194 //                if (n->getScanFrom() == from || n->getScanThru() == from) {
    195 //                    return createScanThru(n->getScanFrom() == from ? to : n->getScanFrom(),
    196 //                                          n->getScanThru() == from ? to : n->getScanThru());
    197 //                }
    198 //                return inst;
    199 //            }
    200 //        case PabloAST::ClassTypeId::MatchStar:
    201 //            {
    202 //                MatchStar * n = cast<MatchStar>(inst);
    203 //                if (n->getMarker() == from || n->getScanThru() == from) {
    204 //                    return createMatchStar(n->getMarker() == from ? to : n->getMarker(),
    205 //                                           n->getScanThru() == from ? to : n->getScanThru());
    206 //                }
    207 //                return inst;
    208 //            }
    209 //        case PabloAST::ClassTypeId::Ones:
    210 //        case PabloAST::ClassTypeId::Zeroes:
    211 //        case PabloAST::ClassTypeId::If:
    212 //        case PabloAST::ClassTypeId::While:
    213 //            return inst;
    214 //        default:
    215 //            throw std::runtime_error("Unhandled node type (" + std::to_string(inst->getClassTypeId()) +
    216 //                                     ") given to PabloBlock::replaceUsesOfWith(...)")
    217 //    }
     134//            retVal = createAssign(value, cast<Assign>(inst)->getOutputIndex());
     135//            break;
     136        case PabloAST::ClassTypeId::Var:
     137            retVal = createVar(cast<String>(value));
     138            break;
     139        case PabloAST::ClassTypeId::Call:
     140            retVal = createCall(cast<String>(value));
     141            break;
     142        case PabloAST::ClassTypeId::And:
     143            retVal = createAnd(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     144            break;
     145        case PabloAST::ClassTypeId::Or:
     146            retVal = createOr(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     147            break;
     148        case PabloAST::ClassTypeId::Xor:
     149            retVal = createXor(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     150            break;
     151        case PabloAST::ClassTypeId::Next:
     152            retVal = createNext(cast<Assign>(index == 0 ? value : inst->getOperand(0)), index == 1 ? value : inst->getOperand(1));
     153            break;
     154        case PabloAST::ClassTypeId::ScanThru:
     155            retVal = createScanThru(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     156            break;
     157        case PabloAST::ClassTypeId::MatchStar:
     158            retVal = createMatchStar(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     159            break;
     160        case PabloAST::ClassTypeId::Sel:
     161            retVal = createSel(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1), index == 2 ? value : inst->getOperand(2));
     162            break;
     163        default:
     164            break;
     165    }
    218166
    219 //}
     167    // restore our insertion point
     168    setInsertPoint(replacingCurrentIP ? inst : ip);
    220169
     170    return retVal;
     171}
    221172
    222173}
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4414 r4415  
    2020#include <pablo/pe_scanthru.h>
    2121#include <pablo/pe_sel.h>
     22#include <pablo/pe_integer.h>
    2223#include <pablo/pe_string.h>
    2324#include <pablo/pe_var.h>
     
    6667    Call * createCall(const std::string name);
    6768
     69    Call * createCall(String * name);
     70
    6871    Assign * createAssign(const std::string prefix, PabloAST * expr, const int outputIndex = -1)  {
    6972        // Note: we cannot just use the findOrMake method to obtain this; an Assign node cannot be considered
     
    7174        // before the Next node. Should we create a "Constant" flag for this?
    7275        Assign * assign = new Assign(expr, outputIndex, mSymbolGenerator->make(prefix), this);
    73         push_back(assign);
     76        insert(assign);
    7477        return assign;
    7578    }
    7679
     80    Assign * createImmutableAssign(const std::string prefix, PabloAST * expr, const int outputIndex = -1);
     81
    7782    Var * createVar(const std::string name);
     83
     84    Var * createVar(String * name);
    7885
    7986    PabloAST * createVar(const PabloAST * const) {
     
    109116    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body) {
    110117        If * statement = new If(condition, std::move(definedVars), body, this);
    111         push_back(statement);
     118        insert(statement);
    112119        return statement;
    113120    }
     
    115122    inline While * createWhile(PabloAST * cond, PabloBlock & body) {
    116123        While * statement = new While(cond, body, this);
    117         push_back(statement);
     124        insert(statement);
    118125        return statement;
    119126    }
     127
     128    PabloAST * setOperandOf(Statement * inst, const unsigned index, PabloAST * value);
    120129
    121130    template<typename... Args>
     
    152161            Functor mf;
    153162            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            }
    154174            mMap.insert(std::make_pair(std::move(key), expr));
    155175            return expr;
     
    233253
    234254    template<typename Type>
    235     inline Type appendIfNew(std::pair<Type, bool> retVal) {
     255    inline Type insertIfNew(std::pair<Type, bool> retVal) {
    236256        if (std::get<1>(retVal)) {
    237             push_back(cast<Statement>(std::get<0>(retVal)));
     257            insert(cast<Statement>(std::get<0>(retVal)));
    238258        }
    239259        return std::get<0>(retVal);
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.cpp

    r4404 r4415  
    111111}
    112112
     113PabloAST * Statement::setOperand(const unsigned index, PabloAST * value) {
     114    assert (index < getNumOperands());
     115    return mParent->setOperandOf(this, index, value);
     116}
    113117
    114118void Statement::insertBefore(Statement * const statement) {
     
    154158            mParent->mLast = mPrev;
    155159        }
     160        if (mParent->mInsertionPoint == this) {
     161            mParent->mInsertionPoint = mParent->mInsertionPoint->mPrev;
     162        }
    156163        if (LLVM_LIKELY(mPrev != nullptr)) {
    157164            mPrev->mNext = mNext;
     
    160167            mNext->mPrev = mPrev;
    161168        }
    162     }
     169    }   
    163170    mPrev = nullptr;
    164171    mNext = nullptr;
     
    167174
    168175void Statement::replaceWith(Statement * const statement) {
    169     if (LLVM_UNLIKELY(mParent != nullptr)) {
     176    if (statement != this) {
    170177        statement->removeFromParent();
    171     }
    172     statement->mParent = mParent;
    173     statement->mNext = mNext;
    174     statement->mPrev = mPrev;
    175     if (LLVM_LIKELY(mPrev != nullptr)) {
    176         mPrev->mNext = statement;
    177     }
    178     if (LLVM_LIKELY(mNext != nullptr)) {
    179         mNext->mPrev = statement;
    180     }
    181     mParent=nullptr;
    182     mNext=nullptr;
    183     mPrev=nullptr;
     178        statement->mParent = mParent;
     179        statement->mNext = mNext;
     180        statement->mPrev = mPrev;
     181        if (LLVM_LIKELY(mPrev != nullptr)) {
     182            mPrev->mNext = statement;
     183        }
     184        if (LLVM_LIKELY(mNext != nullptr)) {
     185            mNext->mPrev = statement;
     186        }
     187        mParent=nullptr;
     188        mNext=nullptr;
     189        mPrev=nullptr;
     190    }
    184191}
    185192
     
    188195}
    189196
    190 void StatementList::push_back(Statement * const statement) {
    191     if (LLVM_UNLIKELY(mLast == nullptr)) {
    192         mFirst = mLast = statement;
     197void StatementList::setInsertPoint(Statement * const statement) {
     198    mInsertionPoint = statement;
     199}
     200
     201void StatementList::setInsertPoint(StatementList * const list) {
     202    mInsertionPoint = list->mLast;
     203}
     204
     205void StatementList::insert(Statement * const statement) {
     206    if (LLVM_UNLIKELY(mInsertionPoint == nullptr)) {
     207        statement->mNext = mFirst;
     208        if (mFirst) {
     209            assert (mFirst->mPrev == nullptr);
     210            mFirst->mPrev = statement;
     211        }
     212        mLast = (mLast == nullptr) ? statement : mLast;
     213        mInsertionPoint = mFirst = statement;
    193214    }
    194215    else {
    195         statement->insertAfter(mLast);
    196         mLast = statement;
    197     }
    198 }
    199 
    200 }
     216        statement->insertAfter(mInsertionPoint);
     217        mLast = (mLast == mInsertionPoint) ? statement : mLast;
     218        mInsertionPoint = statement;
     219    }
     220}
     221
     222void StatementList::insertAfterLastOperand(Statement * const statement) {
     223    assert (false);
     224}
     225
     226}
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r4414 r4415  
    4040        , Call
    4141        , If
     42        , Integer
    4243        , MatchStar
    4344        , Next
     
    115116    }
    116117
    117     inline void replaceUsesOfWith(PabloAST * from, PabloAST * to) {
    118         if (LLVM_UNLIKELY(from == to)) {
    119             return;
    120         }
    121         for (unsigned i = 0, operands = getNumOperands(); i != operands; ++i) {
     118    inline PabloAST * replaceUsesOfWith(PabloAST * from, PabloAST * to) {
     119        if (from == to) {
     120            return this;
     121        }
     122        for (unsigned i = 0; i != getNumOperands(); ++i) {
    122123            if (getOperand(i) == from) {
    123                 setOperand(i, to);
     124                return setOperand(i, to);
    124125            }
    125126        }
     127        return this;
    126128    }
    127129
     
    131133    }
    132134
     135    PabloAST * setOperand(const unsigned index, PabloAST * value);
     136
    133137    unsigned getNumOperands() const {
    134138        return mOperand.size();
    135     }
    136 
    137     void setOperand(const unsigned index, PabloAST * value) {
    138         assert (index < getNumOperands());
    139         mOperand[index] = value;
    140139    }
    141140
     
    170169        }
    171170    }
     171
    172172    virtual ~Statement() = 0;
    173173protected:
     
    334334
    335335    StatementList()
    336     : mFirst(nullptr)
     336    : mInsertionPoint(nullptr)
     337    , mFirst(nullptr)
    337338    , mLast(nullptr)
    338339    {
     
    404405    }
    405406
    406     void push_back(Statement * const statement);
     407    void setInsertPoint(Statement * const statement);
     408
     409    void setInsertPoint(StatementList * const list);
     410
     411    Statement * getInsertPoint() const {
     412        return mInsertionPoint;
     413    }
     414
     415    void insert(Statement * const statement);
     416
     417    void insertAfterLastOperand(Statement * const statement);
    407418
    408419private:
     420
     421    Statement   * mInsertionPoint;
    409422    Statement   * mFirst;
    410     Statement   * mLast;
     423    Statement   * mLast;   
    411424};
    412425
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r4410 r4415  
    167167    compileStatements(pb.statements());
    168168
    169     assert (mCarryQueueIdx == mCarryQueueSize);
     169    assert (mCarryQueueIdx <= mCarryQueueSize);
    170170    assert (mAdvanceQueueIdx <= mAdvanceQueueSize);
    171171    assert (mNestingDepth == 0);
  • icGREP/icgrep-devel/icgrep/pablo/pe_string.h

    r4410 r4415  
    2626    }
    2727protected:
    28     void* operator new (std::size_t size) noexcept {
    29         return mAllocator.allocate(size);
    30     }
    3128    String(const std::string && value) noexcept
    3229    : PabloAST(ClassTypeId::String)
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.cpp

    r4414 r4415  
    77: Statement(ClassTypeId::If, {expr}, nullptr, parent)
    88, mBody(body)
    9 , mDefined(std::move(definedVars))
     9, mDefined(definedVars.begin(), definedVars.end())
    1010, mCarryCount(0)
    1111, mAdvanceCount(0)
    1212{
     13    // Conceptually, having a defined var X is identical to having:
     14    //
     15    // Assign(X, 0)
     16    // If (...)
     17    //    Next(Assign(X), ...)
     18    //
     19    // Since the implied 'Next' node is a user of the Assign node, and the Assign node is
     20    // embedded into the If, the defined var is a user of the If node.
    1321
     22    for (Assign * x : mDefined) {
     23        addUser(x);
     24    }
    1425}
    1526
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.h

    r4414 r4415  
    3737        return mBody;
    3838    }
    39     inline const DefinedVars & getDefined() const {
     39    inline const SetVector<Assign*> & getDefined() const {
    4040        return mDefined;
    4141    }
     
    5555    If(PabloAST * expr, DefinedVars && definedVars, PabloBlock & body, PabloBlock * parent);
    5656private:
    57     PabloBlock &    mBody;
    58     DefinedVars     mDefined;
    59     unsigned        mCarryCount;
    60     unsigned        mAdvanceCount;
     57    PabloBlock &        mBody;
     58    SetVector<Assign*>  mDefined;
     59    unsigned            mCarryCount;
     60    unsigned            mAdvanceCount;
    6161};
    6262
  • icGREP/icgrep-devel/icgrep/re/re_analysis.cpp

    r4405 r4415  
    1616bool isByteLength(RE * re) {
    1717    if (Alt * alt = dyn_cast<Alt>(re)) {
    18         std::vector<RE*> list;
    1918        for (RE * re : *alt) {
    20             if (!isByteLength(re)) return false;
     19            if (!isByteLength(re)) {
     20                return false;
     21            }
    2122        }
    2223        return true;
     
    2829        return (rep->getLB() == 1) && (rep->getUB() == 1) && isByteLength(rep->getRE());
    2930    }
    30     else if (Assertion * a = dyn_cast<Assertion>(re)) {
     31    else if (isa<Assertion>(re)) {
    3132        return false;
    3233    }
     
    3738        return isByteLength(e->getLH()) && isByteLength(e->getRH());
    3839    }
    39     else if (isa<Any>(re)) return false;
     40    else if (isa<Any>(re)) {
     41        return false;
     42    }
    4043    else if (Name * n = dyn_cast<Name>(re)) {
    4144        return (n->getType() == Name::Type::Byte);
     
    4649bool isUnicodeUnitLength(RE * re) {
    4750    if (Alt * alt = dyn_cast<Alt>(re)) {
    48         std::vector<RE*> list;
    4951        for (RE * re : *alt) {
    50             if (!isUnicodeUnitLength(re)) return false;
     52            if (!isUnicodeUnitLength(re)) {
     53                return false;
     54            }
    5155        }
    5256        return true;
     
    5862        return (rep->getLB() == 1) && (rep->getUB() == 1) && isUnicodeUnitLength(rep->getRE());
    5963    }
    60     else if (Assertion * a = dyn_cast<Assertion>(re)) {
     64    else if (isa<Assertion>(re)) {
    6165        return false;
    6266    }
     
    6771        return isUnicodeUnitLength(e->getLH()) && isUnicodeUnitLength(e->getRH());
    6872    }
    69     else if (isa<Any>(re)) return true;
     73    else if (isa<Any>(re)) {
     74        return true;
     75    }
    7076    else if (Name * n = dyn_cast<Name>(re)) {
    7177        // Eventually names might be set up for not unit length items.
Note: See TracChangeset for help on using the changeset viewer.