Changeset 5233


Ignore:
Timestamp:
Dec 21, 2016, 3:53:58 PM (12 months ago)
Author:
nmedfort
Message:

Bug fixes for Carry Manager and issues reported by Fahad

Location:
icGREP/icgrep-devel/icgrep
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/UCD/PropertyObjects.cpp

    r5206 r5233  
    5858std::vector<UnicodeSet> & EnumeratedPropertyObject::GetEnumerationBasisSets() {
    5959    // Return the previously computed vector of basis sets, if it exists.
    60     if (enumeration_basis_sets.size() > 0) return enumeration_basis_sets;
    61    
    62     // Otherwise compute and return.
    63     // Basis set i is the set of all codepoints whose numerical enumeration code e
    64     // has bit i set, i.e., (e >> i) & 1 == 1.
    65     unsigned basis_count = 1;
    66     while ((1 << basis_count) < independent_enum_count) basis_count++;
    67     for (unsigned i = 0; i < basis_count; i++) {
    68         enumeration_basis_sets.push_back(UnicodeSet());
    69         for (unsigned e = 0; e < independent_enum_count; e++) {
    70             if (((e >> i) & 1) == 0) {
    71                 enumeration_basis_sets[i] = enumeration_basis_sets[i] + *property_value_sets[e];
     60    if (LLVM_UNLIKELY(enumeration_basis_sets.empty())) {
     61        // Otherwise compute and return.
     62        // Basis set i is the set of all codepoints whose numerical enumeration code e
     63        // has bit i set, i.e., (e >> i) & 1 == 1.
     64        unsigned basis_count = 1;
     65        while ((1 << basis_count) < independent_enum_count) basis_count++;
     66        for (unsigned i = 0; i < basis_count; i++) {
     67            enumeration_basis_sets.push_back(UnicodeSet());
     68            for (unsigned e = 0; e < independent_enum_count; e++) {
     69                if (((e >> i) & 1) == 0) {
     70                    enumeration_basis_sets[i] = enumeration_basis_sets[i] + *property_value_sets[e];
     71                }
    7272            }
    7373        }
  • icGREP/icgrep-devel/icgrep/UCD/resolve_properties.cpp

    r5206 r5233  
    3939#define Ahead(x) makeLookAheadAssertion(x)
    4040
    41     RE * GCB_Control = makeName("gcb", "cn", Name::Type::UnicodeProperty);
     41//    RE * GCB_Control = makeName("gcb", "cn", Name::Type::UnicodeProperty);
    4242    RE * GCB_CR = makeName("gcb", "cr", Name::Type::UnicodeProperty);
    4343    RE * GCB_LF = makeName("gcb", "lf", Name::Type::UnicodeProperty);
  • icGREP/icgrep-devel/icgrep/kernels/kernel.cpp

    r5230 r5233  
    122122    Function::arg_iterator args = initFunction->arg_begin();
    123123    Value * self = &*(args++);
    124     iBuilder->CreateStore(Constant::getNullValue(mKernelStateType), self);
     124    initializeKernelState(self);
    125125    for (auto binding : mScalarInputs) {
    126126        Value * parm = &*(args++);
     
    130130    iBuilder->CreateRetVoid();
    131131    iBuilder->restoreIP(savePoint);
     132}
     133
     134void KernelBuilder::initializeKernelState(Value * self) {
     135    iBuilder->CreateStore(Constant::getNullValue(mKernelStateType), self);
    132136}
    133137
  • icGREP/icgrep-devel/icgrep/kernels/kernel.h

    r5229 r5233  
    5353    virtual llvm::Value * getProcessedItemCount(llvm::Value * kernelInstance) override;
    5454    virtual llvm::Value * getProducedItemCount(llvm::Value * kernelInstance) override;
     55    virtual void initializeKernelState(Value * self);
    5556    llvm::Value * getTerminationSignal(llvm::Value * kernelInstance);
    5657   
  • icGREP/icgrep-devel/icgrep/pablo/analysis/pabloverifier.cpp

    r5217 r5233  
    304304 ** ------------------------------------------------------------------------------------------------------------- */
    305305struct OrderingVerifier {
    306     OrderingVerifier() : mParent(nullptr) {}
     306    OrderingVerifier() : mParent(nullptr), mSet() {}
    307307    OrderingVerifier(const OrderingVerifier & parent) : mParent(&parent) {}
    308308    bool count(const PabloAST * expr) const {
  • icGREP/icgrep-devel/icgrep/pablo/carry_manager.cpp

    r5228 r5233  
    1818namespace pablo {
    1919
    20 inline static unsigned nearest_pow2(const unsigned v) {
     20inline static unsigned nearest_pow2(const uint32_t v) {
    2121    assert(v > 0 && v < (UINT32_MAX / 2));
    2222    return (v < 2) ? 1 : (1 << (32 - __builtin_clz(v - 1)));
     
    107107    if (LLVM_UNLIKELY(mCarryInfo->variableLength)) {
    108108        // Check whether we need to resize the carry state
    109         PHINode * index = iBuilder->CreatePHI(iBuilder->getSizeTy(), 2);
     109        PHINode * index = iBuilder->CreatePHI(iBuilder->getInt32Ty(), 2);
    110110        mLoopIndicies.push_back(index);
    111         index->addIncoming(iBuilder->getSize(0), entryBlock);
     111        index->addIncoming(iBuilder->getInt32(0), entryBlock);
    112112        Value * capacityPtr = iBuilder->CreateGEP(mCurrentFrame, {iBuilder->getInt32(0), iBuilder->getInt32(0)});
    113113        Value * capacity = iBuilder->CreateLoad(capacityPtr, false, "carryCapacity");
     
    122122
    123123        Type * const carryStateType = arrayPtr->getType()->getPointerElementType()->getPointerElementType();
    124         Value * newCapacity = iBuilder->CreateMul(iBuilder->CreateAdd(index, iBuilder->getSize(1)), iBuilder->getSize(2));
     124        Value * newCapacity = iBuilder->CreateMul(iBuilder->CreateAdd(index, iBuilder->getInt32(1)), iBuilder->getInt32(2));
    125125        Value * newArrayPtr = iBuilder->CreateAlignedMalloc(carryStateType, newCapacity, iBuilder->getCacheAlignment());
    126126        iBuilder->CreateMemCpy(newArrayPtr, arrayPtr, capacity, iBuilder->getCacheAlignment());
     
    151151        assert (mLoopIndicies.size() > 0);
    152152        PHINode * index = mLoopIndicies.back();
    153         index->addIncoming(iBuilder->CreateAdd(index, iBuilder->getSize(1)), exitBlock);
     153        index->addIncoming(iBuilder->CreateAdd(index, iBuilder->getInt32(1)), exitBlock);
    154154        mLoopIndicies.pop_back();
    155155    }
     
    183183        ConstantInt * zero = iBuilder->getInt32(0);
    184184        std::vector<Value *> indicies;
    185         // enter the (potentially nested) struct and extract the summary element (0)
     185        // enter the (potentially nested) struct and extract the summary element (always element 0)
    186186        unsigned count = 2;
    187187        if (LLVM_UNLIKELY(mCarryInfo->hasBorrowedSummary())) {
     
    301301 ** ------------------------------------------------------------------------------------------------------------- */
    302302Value * CarryManager::addCarryInCarryOut(const Statement * operation, Value * const e1, Value * const e2) {
     303    assert (dyn_cast_or_null<ScanThru>(operation) || dyn_cast_or_null<MatchStar>(operation));
    303304    Value * const carryIn = getNextCarryIn();
    304305    Value * carryOut, * result;
     
    404405    }
    405406    assert (carryInPtr->getType()->getPointerElementType() == mCarryPackType);
    406     return iBuilder->CreateBlockAlignedLoad(carryInPtr);
     407    Value * const carryIn = iBuilder->CreateBlockAlignedLoad(carryInPtr);
     408    if (mLoopDepth > 0) {
     409        iBuilder->CreateBlockAlignedStore(Constant::getNullValue(mCarryPackType), carryInPtr);
     410    }
     411    return carryIn;
    407412}
    408413
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/booleanreassociationpass.cpp

    r5202 r5233  
    424424        mBlock = block;
    425425        transformAST(C, G);
    426     } catch (std::runtime_error err) {
     426    } catch (std::exception &) {
    427427        printGraph(G, "E");
    428         throw err;
    429     } catch (std::exception err) {
    430         printGraph(G, "E");
    431         throw err;
     428        throw;
    432429    }
    433430}
  • icGREP/icgrep-devel/icgrep/pablo/pablo_kernel.cpp

    r5230 r5233  
    126126}
    127127
     128void PabloKernel::initializeKernelState(Value * self) {
     129    iBuilder->CreateStore(Constant::getNullValue(mKernelStateType), self);
     130}
     131
    128132PabloKernel::PabloKernel(IDISA::IDISA_Builder * builder, const std::string & kernelName)
    129133: KernelBuilder(builder, kernelName, {}, {}, {}, {}, {Binding{builder->getBitBlockType(), "EOFbit"}, Binding{builder->getBitBlockType(), "EOFmask"}})
  • icGREP/icgrep-devel/icgrep/pablo/pablo_kernel.h

    r5230 r5233  
    112112    void generateDoBlockMethod() override;
    113113   
     114    void initializeKernelState(Value * self) override;
     115
    114116    // The default method for Pablo final block processing sets the
    115117    // EOFmark bit and then calls the standard DoBlock function.
  • icGREP/icgrep-devel/icgrep/re/re_analysis.cpp

    r5091 r5233  
    175175    else if (isa<Any>(re)) {
    176176        return 1;
    177     }
    178     else if (const Name * n = dyn_cast<Name>(re)) {
    179     // Eventually names might be set up for not unit length items.
     177    } else if (const Name * n = dyn_cast<Name>(re)) {
     178        // Eventually names might be set up for not unit length items.
    180179        switch (n->getType()) {
    181180            case Name::Type::Byte:
     
    186185            case Name::Type::Reference:
    187186                return minMatchLength(n->getDefinition());
    188             case Name::Type::Unknown:
     187            default:
    189188                return 0;
    190189        }
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r5217 r5233  
    200200RE * RE_Compiler::resolveUnicodeProperties(RE * re) {
    201201    Name * ZeroWidth = nullptr;
    202     UCD::UCDCompiler::NameMap nameMap;
    203     nameMap = resolveNames(re, ZeroWidth);
    204    
     202    mCompiledName = &mBaseMap;
     203
     204    auto nameMap = resolveNames(re, ZeroWidth);
    205205    if (LLVM_LIKELY(nameMap.size() > 0)) {
    206206        UCD::UCDCompiler ucdCompiler(mCCCompiler);
     
    212212        for (auto t : nameMap) {
    213213            if (t.second) {
    214                 mCompiledName.insert(std::make_pair(t.first, makeMarker(MarkerPosition::FinalMatchUnit, mPB.createAnd(t.second, mAny))));
     214                mCompiledName->add(t.first, makeMarker(MarkerPosition::FinalMatchUnit, mPB.createAnd(t.second, mAny)));
    215215            }
    216216        }
     
    219219    // Now precompile any grapheme segmentation rules
    220220    if (ZeroWidth) {
    221         auto gcb = compileName(ZeroWidth, mPB);
    222         mCompiledName.insert(std::make_pair(ZeroWidth, gcb));
     221        mCompiledName->add(ZeroWidth, compileName(ZeroWidth, mPB));
    223222    }
    224223    return re;
     
    312311
    313312inline MarkerType RE_Compiler::compileName(Name * name, PabloBuilder & pb) {
    314     auto f = mCompiledName.find(name);
    315     if (LLVM_LIKELY(f != mCompiledName.end())) {
    316         return f->second;
     313    MarkerType m;
     314    if (LLVM_LIKELY(mCompiledName->get(name, m))) {
     315        return m;
    317316    } else if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    318         MarkerType m = compile(name->getDefinition(), pb);
    319         mCompiledName.insert(std::make_pair(name, m));
     317        m = compile(name->getDefinition(), pb);
     318        mCompiledName->add(name, m);
    320319        return m;
    321320    }
     
    345344    } else {
    346345        Var * m = pb.createVar("m", pb.createZeroes());
     346        NameMap nestedMap(mCompiledName);
     347        mCompiledName = &nestedMap;
    347348        PabloBuilder nested = PabloBuilder::Create(pb);
    348349        MarkerType m1 = compileSeqTail(current, end, 0, marker, nested);
    349350        nested.createAssign(m, markerVar(m1));
    350351        pb.createIf(markerVar(marker), nested);
     352        mCompiledName = nestedMap.getParent();
    351353        return makeMarker(m1.pos, m);
    352354    }
     
    354356
    355357MarkerType RE_Compiler::compileAlt(Alt * alt, MarkerType marker, PabloBuilder & pb) {
    356     std::vector<PabloAST *>  accum = {pb.createZeroes(), pb.createZeroes(), pb.createZeroes()};
     358    std::vector<PabloAST *>  accum(3, pb.createZeroes());
    357359    MarkerType const base = marker;
    358360    // The following may be useful to force a common Advance rather than separate
    359361    // Advances in each alternative.
    360362    for (RE * re : *alt) {
    361         MarkerType rslt = process(re, base, pb);
    362         MarkerPosition p = markerPos(rslt);
    363         accum[p] = pb.createOr(accum[p], markerVar(rslt), "alt");
     363        MarkerType m = process(re, base, pb);
     364        MarkerPosition p = markerPos(m);
     365        accum[p] = pb.createOr(accum[p], markerVar(m), "alt");
    364366    }
    365367    if (isa<Zeroes>(accum[MarkerPosition::FinalPostPositionUnit])) {
     
    643645, mWhileTest(nullptr)
    644646, mStarDepth(0)
    645 , mPB(ccCompiler.getBuilder()) {
     647, mPB(ccCompiler.getBuilder())
     648, mCompiledName(&mBaseMap) {
    646649
    647650}
  • icGREP/icgrep-devel/icgrep/re/re_compiler.h

    r5227 r5233  
    1212#include <cc/cc_compiler.h>
    1313#include <pablo/builder.hpp>
     14#include <boost/container/flat_map.hpp>
    1415
    1516namespace UCD {
     
    3637    MarkerPosition pos;
    3738    pablo::PabloAST * stream;
     39    MarkerType & operator =(const MarkerType &) = default;
    3840};
    3941
    40 inline MarkerPosition markerPos(MarkerType m) {return m.pos;}
     42inline MarkerPosition markerPos(const MarkerType & m) {return m.pos; }
    4143
    42 inline pablo::PabloAST * markerVar(MarkerType m) {return m.stream;}
    43    
     44inline pablo::PabloAST * markerVar(const MarkerType & m) {return m.stream; }
     45
    4446inline MarkerType makeMarker(MarkerPosition newpos, pablo::PabloAST * strm) {return {newpos, strm};}
    4547
     
    5860private:
    5961
     62    struct NameMap {
     63        NameMap(NameMap * parent = nullptr) : mParent(parent), mMap() {}
     64        bool get(const Name * name, MarkerType & marker) const {
     65            auto f = mMap.find(name);
     66            if (f == mMap.end()) {
     67                return mParent ? mParent->get(name, marker) : false;
     68            } else {
     69                marker = f->second;
     70                return true;
     71            }
     72        }
     73        void add(const Name * const name, MarkerType marker) {
     74            mMap.emplace(name, std::move(marker));
     75        }
     76        NameMap * getParent() const { return mParent; }
     77    private:
     78        NameMap * const mParent;
     79        boost::container::flat_map<const Name *, MarkerType> mMap;
     80    };
     81
    6082    void initializeRequiredStreams_utf8();
    6183    void initializeRequiredStreams_utf16();
     
    6587    MarkerType compileName(Name * name, MarkerType marker, pablo::PabloBuilder & pb);
    6688    MarkerType compileSeq(Seq * seq, MarkerType marker, pablo::PabloBuilder & pb);
    67     MarkerType compileSeqTail(Seq::iterator current, Seq::iterator end, int matchLenSoFar, MarkerType marker, pablo::PabloBuilder & pb);
     89    MarkerType compileSeqTail(Seq::iterator current, const Seq::iterator end, int matchLenSoFar, MarkerType marker, pablo::PabloBuilder & pb);
    6890    MarkerType compileAlt(Alt * alt, MarkerType marker, pablo::PabloBuilder & pb);
    6991    MarkerType compileAssertion(Assertion * a, MarkerType marker, pablo::PabloBuilder & pb);
     
    102124    int                                             mStarDepth;
    103125    pablo::PabloBuilder &                           mPB;
    104     std::unordered_map<Name *, MarkerType>          mCompiledName;
    105 
     126    NameMap *                                       mCompiledName;
     127    NameMap                                         mBaseMap;
    106128};
    107129
  • icGREP/icgrep-devel/icgrep/re/re_name.h

    r5202 r5233  
    7373    const length_t      mNameLength;
    7474    const char * const  mName;
    75     Type          mType;
     75    Type                mType;
    7676    RE *                mDefinition;
    7777};
  • icGREP/icgrep-devel/icgrep/re/re_name_resolve.cpp

    r5158 r5233  
    1414#include <UCD/ucd_compiler.hpp>
    1515#include <UCD/resolve_properties.h>
    16 #include <unordered_set>
     16#include <boost/container/flat_set.hpp>
    1717#include <sstream>
     18
     19#include <re/printer_re.h>
     20#include <iostream>
     21
     22using NameMap = UCD::UCDCompiler::NameMap;
     23
     24using namespace boost::container;
    1825
    1926namespace re {
    2027 
    21 static inline CC * getDefinitionIfCC(RE * re) {
    22     if (LLVM_LIKELY(isa<Name>(re))) {
    23         Name * name = cast<Name>(re);
    24         if (name->getDefinition() && isa<CC>(name->getDefinition())) {
    25             return cast<CC>(name->getDefinition());
    26         }
     28static inline CC * getDefinition(RE * re) {
     29    if (isa<CC>(re)) {
     30        return cast<CC>(re);
     31    } else if (isa<Name>(re)) {
     32        return getDefinition(cast<Name>(re)->getDefinition());
    2733    }
    2834    return nullptr;
    2935}
    3036
    31 Name * ZeroWidth = nullptr;
     37struct NameResolver {
    3238
    33 RE * resolve(RE * re) {
    34     Memoizer memoizer;
    35     if (Name * name = dyn_cast<Name>(re)) {
    36         auto f = memoizer.find(name);
    37         if (f == memoizer.end()) {
    38             if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    39                 name->setDefinition(resolve(name->getDefinition()));
    40             } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty || name->getType() == Name::Type::ZeroWidth)) {
    41                 if (UCD::resolvePropertyDefinition(name)) {
    42                     if (name->getType() == Name::Type::ZeroWidth) {
    43                         ZeroWidth = name;
     39    RE * resolve(RE * re) {
     40        if (Name * name = dyn_cast<Name>(re)) {
     41            auto f = mMemoizer.find(name);
     42            if (f == mMemoizer.end()) {
     43                if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
     44                    name->setDefinition(resolve(name->getDefinition()));
     45                } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty || name->getType() == Name::Type::ZeroWidth)) {
     46                    if (UCD::resolvePropertyDefinition(name)) {
     47                        if (name->getType() == Name::Type::ZeroWidth) {
     48                            mZeroWidth = name;
     49                        }
     50                        resolve(name->getDefinition());
     51                    } else {
     52                        #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     53                        if (AlgorithmOptionIsSet(UsePregeneratedUnicode)) {
     54                            const std::string functionName = UCD::resolvePropertyFunction(name);
     55                            const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
     56                            Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
     57                            name->setCompiled(call);
     58                        } else {
     59                        #endif
     60                            name->setDefinition(makeCC(UCD::resolveUnicodeSet(name)));
     61                        #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     62                        }
     63                        #endif
    4464                    }
    45                     resolve(name->getDefinition());
    4665                } else {
    47                     #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    48                     if (AlgorithmOptionIsSet(UsePregeneratedUnicode)) {
    49                         const std::string functionName = UCD::resolvePropertyFunction(name);
    50                         const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
    51                         Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
    52                         name->setCompiled(call);
    53                     } else {
    54                     #endif
    55                         name->setDefinition(makeCC(UCD::resolveUnicodeSet(name)));
    56                     #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    57                     }
    58                     #endif
     66                throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
    5967                }
    6068            } else {
    61             throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
     69                return *f;
    6270            }
    63         } else {
    64             return *f;
    65         }
    66     } else if (Seq * seq = dyn_cast<Seq>(re)) {
    67         for (auto si = seq->begin(); si != seq->end(); ++si) {
    68             *si = resolve(*si);
    69         }
    70     } else if (Alt * alt = dyn_cast<Alt>(re)) {
    71         CC * unionCC = nullptr;
    72         std::stringstream name;
    73         for (auto ai = alt->begin(); ai != alt->end(); ) {
    74             RE * re = resolve(*ai);
    75             if (CC * cc = getDefinitionIfCC(re)) {
    76                 if (unionCC == nullptr) {
    77                     unionCC = cc;
     71        } else if (Seq * seq = dyn_cast<Seq>(re)) {
     72            for (auto si = seq->begin(); si != seq->end(); ++si) {
     73                *si = resolve(*si);
     74            }
     75        } else if (Alt * alt = dyn_cast<Alt>(re)) {
     76            CC * unionCC = nullptr;
     77            std::stringstream name;
     78            for (auto ai = alt->begin(); ai != alt->end(); ) {
     79                RE * re = resolve(*ai);
     80                if (CC * cc = getDefinition(re)) {
     81                    if (unionCC == nullptr) {
     82                        unionCC = cc;
     83                    } else {
     84                        unionCC = makeCC(unionCC, cc);
     85                        name << '+';
     86                    }
     87                    if (LLVM_LIKELY(isa<Name>(re))) {
     88                        Name * n = cast<Name>(re);
     89                        if (n->hasNamespace()) {
     90                            name << n->getNamespace() << ':';
     91                        }
     92                        name << n->getName();
     93                    } else if (isa<CC>(re)) {
     94                        name << cast<CC>(re)->canonicalName(UnicodeClass);
     95                    }
     96                    ai = alt->erase(ai);
    7897                } else {
    79                     unionCC = makeCC(unionCC, cc);
    80                     name << '+';
     98                    *ai++ = re;
    8199                }
    82                 Name * n = cast<Name>(re);
    83                 if (n->hasNamespace()) {
    84                     name << n->getNamespace() << ':';
    85                 }
    86                 name << n->getName();
    87                 ai = alt->erase(ai);
    88             } else {
    89                 *ai++ = re;
     100            }
     101            if (unionCC) {
     102                alt->push_back(resolve(makeName(name.str(), unionCC)));
     103            }
     104            if (alt->size() == 1) {
     105                return alt->front();
     106            }
     107        } else if (Rep * rep = dyn_cast<Rep>(re)) {
     108            rep->setRE(resolve(rep->getRE()));
     109        } else if (Assertion * a = dyn_cast<Assertion>(re)) {
     110            a->setAsserted(resolve(a->getAsserted()));
     111        } else if (Diff * diff = dyn_cast<Diff>(re)) {
     112            diff->setLH(resolve(diff->getLH()));
     113            diff->setRH(resolve(diff->getRH()));
     114            CC * lh = getDefinition(diff->getLH());
     115            CC * rh = getDefinition(diff->getRH());
     116            if (lh && rh) {
     117                return resolve(makeName("diff", subtractCC(lh, rh)));
     118            }
     119        } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
     120            ix->setLH(resolve(ix->getLH()));
     121            ix->setRH(resolve(ix->getRH()));
     122            CC * lh = getDefinition(ix->getLH());
     123            CC * rh = getDefinition(ix->getRH());
     124            if (lh && rh) {
     125                return resolve(makeName("intersect", intersectCC(lh, rh)));
    90126            }
    91127        }
    92         if (unionCC) {
    93             alt->push_back(makeName(name.str(), unionCC));
    94         }
    95         if (alt->size() == 1) {
    96             return alt->front();
    97         }
    98     } else if (Rep * rep = dyn_cast<Rep>(re)) {
    99         rep->setRE(resolve(rep->getRE()));
    100     } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    101         a->setAsserted(resolve(a->getAsserted()));
    102     } else if (Diff * diff = dyn_cast<Diff>(re)) {
    103         diff->setLH(resolve(diff->getLH()));
    104         diff->setRH(resolve(diff->getRH()));
    105         CC * lh = getDefinitionIfCC(diff->getLH());
    106         CC * rh = getDefinitionIfCC(diff->getRH());
    107         if (lh && rh) {
    108             return resolve(makeName("diff", subtractCC(lh, rh)));
    109         }
    110     } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    111         ix->setLH(resolve(ix->getLH()));
    112         ix->setRH(resolve(ix->getRH()));
    113         CC * lh = getDefinitionIfCC(ix->getLH());
    114         CC * rh = getDefinitionIfCC(ix->getRH());
    115         if (lh && rh) {
    116             return resolve(makeName("intersect", intersectCC(lh, rh)));
     128        return re;
     129    }
     130
     131    void gather(RE * re) {
     132        assert ("RE object cannot be null!" && re);
     133        if (isa<Name>(re)) {
     134            if (mVisited.insert(cast<Name>(re)).second) {
     135                if (isa<CC>(cast<Name>(re)->getDefinition())) {
     136                    mNameMap.emplace(cast<Name>(re), nullptr);
     137                } else {
     138                    gather(cast<Name>(re)->getDefinition());
     139                }
     140            }
     141        } else if (isa<Seq>(re)) {
     142            for (RE * item : *cast<Seq>(re)) {
     143                gather(item);
     144            }
     145        } else if (isa<Alt>(re)) {
     146            for (RE * item : *cast<Alt>(re)) {
     147                gather(item);
     148            }
     149        } else if (isa<Rep>(re)) {
     150            gather(cast<Rep>(re)->getRE());
     151        } else if (isa<Assertion>(re)) {
     152            gather(cast<Assertion>(re)->getAsserted());
     153        } else if (isa<Diff>(re)) {
     154            gather(cast<Diff>(re)->getLH());
     155            gather(cast<Diff>(re)->getRH());
     156        } else if (isa<Intersect>(re)) {
     157            gather(cast<Intersect>(re)->getLH());
     158            gather(cast<Intersect>(re)->getRH());
    117159        }
    118160    }
    119     return re;
    120 }
    121161
    122 UCD::UCDCompiler::NameMap nameMap;
    123 std::unordered_set<Name *> visited;
     162    NameResolver(NameMap & nameMap, Name *& zeroWidth)
     163    : mZeroWidth(zeroWidth)
     164    , mNameMap(nameMap) {
     165
     166    }
     167
     168private:
     169
     170    Name *&                 mZeroWidth;
     171    NameMap &               mNameMap;
     172    Memoizer                mMemoizer;
     173    flat_set<Name *>        mVisited;
     174
     175};
    124176   
    125 void gather(RE * re) {
    126     assert ("RE object cannot be null!" && re);
    127     if (isa<Name>(re)) {
    128         if (visited.insert(cast<Name>(re)).second) {
    129             if (isa<CC>(cast<Name>(re)->getDefinition())) {
    130                 nameMap.emplace(cast<Name>(re), nullptr);
    131             } else {
    132                 gather(cast<Name>(re)->getDefinition());
    133             }
    134         }
    135     } else if (isa<Seq>(re)) {
    136         for (RE * item : *cast<Seq>(re)) {
    137             gather(item);
    138         }
    139     } else if (isa<Alt>(re)) {
    140         for (RE * item : *cast<Alt>(re)) {
    141             gather(item);
    142         }
    143     } else if (isa<Rep>(re)) {
    144         gather(cast<Rep>(re)->getRE());
    145     } else if (isa<Assertion>(re)) {
    146         gather(cast<Assertion>(re)->getAsserted());
    147     } else if (isa<Diff>(re)) {
    148         gather(cast<Diff>(re)->getLH());
    149         gather(cast<Diff>(re)->getRH());
    150     } else if (isa<Intersect>(re)) {
    151         gather(cast<Intersect>(re)->getLH());
    152         gather(cast<Intersect>(re)->getRH());
    153     }
    154 }
    155    
    156 UCD::UCDCompiler::NameMap resolveNames(RE * &re, Name * &zerowidth) {
    157 
    158     ZeroWidth = nullptr;
    159     re = resolve(re);
    160     gather(re);
    161     zerowidth = ZeroWidth;
    162    
     177NameMap resolveNames(RE *& re, Name *& zeroWidth) {
     178    NameMap nameMap;
     179    NameResolver nameResolver(nameMap, zeroWidth);
     180    re = nameResolver.resolve(re);
     181    nameResolver.gather(re);
    163182    return nameMap;
    164183   
  • icGREP/icgrep-devel/icgrep/re/re_name_resolve.h

    r5120 r5233  
    22#define RE_NAME_RESOLVE_H
    33
    4 #include <re/re_name.h>
    5 #include <re/re_re.h>
    6 #include <re/re_name.h>
    74#include <UCD/ucd_compiler.hpp>
     5
    86namespace re {
     7
     8    class RE;
     9    class Name;
     10
    911    UCD::UCDCompiler::NameMap resolveNames(RE * &re, Name * &zerowidth);
    10     Name * resolveOtherNames(RE * re);
    11     Name * generateGraphemeClusterBoundaryRule();
     12
    1213}
    1314#endif
  • icGREP/icgrep-devel/icgrep/re/re_parser_prosite.cpp

    r5218 r5233  
    9999   
    100100    RE * RE_Parser_PROSITE::extend_item(RE * re) {
    101          if (LLVM_LIKELY(mCursor.more())) {
    102              int lb = 0, ub = 0;
     101         if (LLVM_LIKELY(mCursor.more())) {             
    103102             if (*mCursor == '(') {
     103                int lb = 0, ub = 0;
    104104                std::tie(lb, ub) = parse_range_bound();
    105105                if (lb > MAX_REPETITION_LOWER_BOUND || ub > MAX_REPETITION_UPPER_BOUND) {
Note: See TracChangeset for help on using the changeset viewer.