Changeset 6140


Ignore:
Timestamp:
Aug 5, 2018, 9:06:54 PM (12 days ago)
Author:
xwa163
Message:

UTF-8 support for Multiplexing LZ4 Grep

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

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/cc/multiplex_CCs.cpp

    r6133 r6140  
    123123        cc::doMultiplexCCs(CCs, mExclusiveSetIDs, mMultiplexedCCs);
    124124}
    125    
     125
     126unsigned long MultiplexedAlphabet::findTargetCCIndex(const re::CC * sourceCC) const {
     127    auto f = find(mUnicodeSets.begin(), mUnicodeSets.end(), sourceCC);
     128    if (f != mUnicodeSets.end()) {
     129        return f - mUnicodeSets.begin();
     130    }
     131
     132    const UCD::UnicodeSet* sourceUcd = sourceCC;
     133    for (unsigned long i = 0; i < mUnicodeSets.size(); i++) {
     134        UCD::UnicodeSet* t = mUnicodeSets[i];
     135        if (*t == *sourceUcd) {
     136            return i;
     137        }
     138    }
     139    llvm::report_fatal_error(Printer_RE::PrintRE(sourceCC) + " not found");
     140}
     141
    126142re::CC * MultiplexedAlphabet::transformCC(const re::CC * sourceCC) const {
    127143    if (sourceCC->getAlphabet() != mSourceAlphabet) {
    128144        llvm::report_fatal_error("Mismatched source alphabets for transformCC");
    129145    }
    130     const auto f = find(mUnicodeSets.begin(), mUnicodeSets.end(), sourceCC);
    131     if (f == mUnicodeSets.end()) {
    132         llvm::report_fatal_error(Printer_RE::PrintRE(sourceCC) + " not found");
    133     }
    134     const auto index = f - mUnicodeSets.begin();
     146
     147    const auto index = this->findTargetCCIndex(sourceCC);
    135148    const auto exclusive_IDs = mExclusiveSetIDs[index];
    136149    re::CC * CC_union = re::makeCC(this);
  • icGREP/icgrep-devel/icgrep/cc/multiplex_CCs.h

    r5934 r6140  
    4343    std::vector<std::vector<unsigned>> mExclusiveSetIDs;
    4444    std::vector<re::CC *> mMultiplexedCCs;
     45
     46    unsigned long findTargetCCIndex(const re::CC * sourceCC) const;
    4547};
    4648}
  • icGREP/icgrep-devel/icgrep/kernels/charclasses.cpp

    r6126 r6140  
    118118
    119119
     120ByteClassesKernel::ByteClassesKernel(const std::unique_ptr<kernel::KernelBuilder> &iBuilder,
     121                                     std::vector<re::CC *> &&ccs, bool useDirectCC, BitNumbering basisNumbering):
     122        CharClassesSignature(ccs, useDirectCC, basisNumbering)
     123        , PabloKernel(iBuilder,
     124                      "ByteClassesKernel_" + sha1sum(mSignature),
     125                      {},
     126                      {Binding{iBuilder->getStreamSetTy(ccs.size(), 1), "charclasses"}})
     127        , mCCs(std::move(ccs)), mBasisSetNumbering(basisNumbering)
     128{
     129    if (useDirectCC) {
     130        mStreamSetInputs.push_back({Binding{iBuilder->getStreamSetTy(1, 8), "byteData"}});
     131    }
     132    else {
     133        mStreamSetInputs.push_back({Binding{iBuilder->getStreamSetTy(8), "basis"}});
     134    }
     135}
     136
     137std::string ByteClassesKernel::makeSignature(const std::unique_ptr<kernel::KernelBuilder> &iBuilder) {
     138    return mSignature;
     139}
     140
     141void ByteClassesKernel::generatePabloMethod() {
     142    PabloBuilder pb(getEntryScope());
     143    std::unique_ptr<CC_Compiler> ccc;
     144    if (mUseDirectCC) {
     145        ccc = make_unique<cc::Direct_CC_Compiler>(getEntryScope(), pb.createExtract(getInput(0), pb.getInteger(0)));
     146    } else {
     147        ccc = make_unique<cc::Parabix_CC_Compiler>(getEntryScope(), getInputStreamSet("basis"), mBasisSetNumbering);
     148    }
     149    unsigned n = mCCs.size();
     150
     151    NameMap nameMap;
     152    std::vector<Name *> names;
     153    for (unsigned i = 0; i < n; i++) {
     154        Name * name = re::makeName("mpx_basis" + std::to_string(i), mCCs[i]);
     155
     156        nameMap.emplace(name, ccc->compileCC(mCCs[i]));
     157        names.push_back(name);
     158
     159    }
     160
     161    if (mBasisSetNumbering == cc::BitNumbering::BigEndian) {
     162        // The first UnicodeSet in the vector ccs represents the last bit of the
     163        // character class basis bit streams.
     164        std::reverse(names.begin(), names.end());
     165    }
     166    for (unsigned i = 0; i < names.size(); i++) {
     167        auto t = nameMap.find(names[i]);
     168        if (t != nameMap.end()) {
     169            PabloAST * const r = pb.createExtract(getOutput(0), pb.getInteger(i));
     170            pb.createAssign(r, pb.createInFile(t->second));
     171        } else {
     172            llvm::report_fatal_error("Can't compile character classes.");
     173        }
     174    }
     175}
  • icGREP/icgrep-devel/icgrep/kernels/charclasses.h

    r6126 r6140  
    3535};
    3636
     37
     38class ByteClassesKernel: public CharClassesSignature, public pablo::PabloKernel {
     39public:
     40    ByteClassesKernel(const std::unique_ptr<kernel::KernelBuilder> & iBuilder, std::vector<re::CC *> && ccs, bool useDirectCC = false, cc::BitNumbering basisNumbering = cc::BitNumbering::LittleEndian);
     41    bool hasSignature() const override { return true; }
     42    std::string makeSignature(const std::unique_ptr<kernel::KernelBuilder> & iBuilder) override;
     43    bool isCachable() const override { return true; }
     44protected:
     45    void generatePabloMethod() override;
     46protected:
     47    std::vector<re::CC *> mCCs;
     48    cc::BitNumbering mBasisSetNumbering;
     49};
     50
     51
    3752}
    3853#endif
  • icGREP/icgrep-devel/icgrep/kernels/lz4/twist_kernel.cpp

    r6136 r6140  
    1515namespace kernel {
    1616
    17     TwistByPDEPKernel::TwistByPDEPKernel(const std::unique_ptr <kernel::KernelBuilder> &b, unsigned numberOfInputStream, unsigned twistWidth)
    18             : BlockOrientedKernel("TwistByPDEPKernel",
    19                                   {Binding{b->getStreamSetTy(numberOfInputStream, 1), "basisBits"}},
    20                                   {Binding{b->getStreamSetTy(1, twistWidth), "byteStream"}},
    21                                   {}, {}, {}),
    22               mNumberOfInputStream(numberOfInputStream),
    23               mTwistWidth(twistWidth)
    24     {
    25         assert(twistWidth == 2 || twistWidth == 4);
    26         assert(numberOfInputStream <= twistWidth);
    27     }
    28 
    29     void TwistByPDEPKernel::generateDoBlockMethod(const std::unique_ptr <kernel::KernelBuilder> &b) {
    30         Function *PDEPFunc = Intrinsic::getDeclaration(getModule(), Intrinsic::x86_bmi_pdep_64);
     17    void twistByPDEP(const std::unique_ptr <kernel::KernelBuilder> &b, Value *inputBlocks[], unsigned mTwistWidth, Value* outputBasePtr) {
     18        Function *PDEPFunc = Intrinsic::getDeclaration(b->getModule(), Intrinsic::x86_bmi_pdep_64);
    3119        uint64_t pdepBaseMask = mTwistWidth == 2? 0x5555555555555555 : 0x1111111111111111;
    32 
    33         Value *inputBlocks[mTwistWidth];
    34         for (unsigned i = 0; i < mTwistWidth; i++) {
    35             if (i < mNumberOfInputStream) {
    36                 inputBlocks[i] = b->loadInputStreamBlock("basisBits", b->getInt32(i));
    37 //            b->CallPrintRegister("input" + std::to_string(i), inputBlocks[i]);
    38 
    39             } else {
    40                 inputBlocks[i] = ConstantVector::getNullValue(b->getBitBlockType());
    41             }
    42         }
    43 
    44         Value *outputBasePtr = b->CreatePointerCast(b->getOutputStreamBlockPtr("byteStream", b->getSize(0)),
    45                                                     b->getInt64Ty()->getPointerTo());
    4620
    4721        for (unsigned i = 0; i < b->getBitBlockWidth() / 64; i++) {
     
    6842    }
    6943
     44
     45
     46
     47    TwistByPDEPKernel::TwistByPDEPKernel(const std::unique_ptr <kernel::KernelBuilder> &b, unsigned numberOfInputStream, unsigned twistWidth)
     48            : BlockOrientedKernel("TwistByPDEPKernel",
     49                                  {Binding{b->getStreamSetTy(numberOfInputStream, 1), "basisBits"}},
     50                                  {Binding{b->getStreamSetTy(1, twistWidth), "byteStream"}},
     51                                  {}, {}, {}),
     52              mNumberOfInputStream(numberOfInputStream),
     53              mTwistWidth(twistWidth)
     54    {
     55        assert(twistWidth == 2 || twistWidth == 4);
     56        assert(numberOfInputStream <= twistWidth);
     57    }
     58
     59    void TwistByPDEPKernel::generateDoBlockMethod(const std::unique_ptr <kernel::KernelBuilder> &b) {
     60        Value *inputBlocks[mTwistWidth];
     61
     62        for (unsigned i = 0; i < mTwistWidth; i++) {
     63            if (i < mNumberOfInputStream) {
     64                inputBlocks[i] = b->loadInputStreamBlock("basisBits", b->getInt32(i));
     65            } else {
     66                inputBlocks[i] = ConstantVector::getNullValue(b->getBitBlockType());
     67            }
     68        }
     69
     70        Value *outputBasePtr = b->CreatePointerCast(b->getOutputStreamBlockPtr("byteStream", b->getSize(0)),
     71                                                    b->getInt64Ty()->getPointerTo());
     72        twistByPDEP(b, inputBlocks, mTwistWidth, outputBasePtr);
     73    }
     74
     75
     76    TwistMultipleByPDEPKernel::TwistMultipleByPDEPKernel(const std::unique_ptr<kernel::KernelBuilder> &b,
     77                                                         unsigned numberOfInputStreamSet, unsigned twistWidth)
     78            : BlockOrientedKernel("TwistMultipleByPDEPKernel",
     79                                  {},
     80                                  {Binding{b->getStreamSetTy(1, twistWidth), "byteStream"}},
     81                                  {}, {}, {}),
     82              mNumberOfInputStreamSet(numberOfInputStreamSet),
     83              mTwistWidth(twistWidth)
     84    {
     85        for (unsigned i = 0; i < numberOfInputStreamSet; i++) {
     86            mStreamSetInputs.push_back(Binding{b->getStreamSetTy(1), "basisBits_" + std::to_string(i) });
     87        }
     88    }
     89
     90    void TwistMultipleByPDEPKernel::generateDoBlockMethod(const std::unique_ptr<kernel::KernelBuilder> &b) {
     91        Value *inputBlocks[mTwistWidth];
     92
     93        for (unsigned i = 0; i < mTwistWidth; i++) {
     94            if (i < mNumberOfInputStreamSet) {
     95                inputBlocks[i] = b->loadInputStreamBlock("basisBits_" + std::to_string(i), b->getInt32(0));
     96                if (i == 0) {
     97                    b->CallPrintRegister("basisBits_" + std::to_string(i), inputBlocks[i]);
     98                }
     99            } else {
     100                inputBlocks[i] = ConstantVector::getNullValue(b->getBitBlockType());
     101            }
     102        }
     103
     104        Value *outputBasePtr = b->CreatePointerCast(b->getOutputStreamBlockPtr("byteStream", b->getSize(0)),
     105                                                    b->getInt64Ty()->getPointerTo());
     106        twistByPDEP(b, inputBlocks, mTwistWidth, outputBasePtr);
     107    }
    70108}
  • icGREP/icgrep-devel/icgrep/kernels/lz4/twist_kernel.h

    r6136 r6140  
    1010
    1111namespace kernel {
     12
    1213    class TwistByPDEPKernel final : public BlockOrientedKernel {
    1314    public:
     
    2021        void generateDoBlockMethod(const std::unique_ptr <kernel::KernelBuilder> &b) override;
    2122    };
     23
     24
     25    class TwistMultipleByPDEPKernel final : public BlockOrientedKernel {
     26    public:
     27        TwistMultipleByPDEPKernel(const std::unique_ptr <kernel::KernelBuilder> &b, unsigned numberOfInputStreamSet, unsigned twistWidth);
     28
     29    private:
     30        const unsigned mNumberOfInputStreamSet;
     31        const unsigned mTwistWidth;
     32
     33        void generateDoBlockMethod(const std::unique_ptr <kernel::KernelBuilder> &b) override;
     34    };
     35
     36
    2237}
    2338
  • icGREP/icgrep-devel/icgrep/lz4/lz4_grep_generator.cpp

    r6137 r6140  
    5353#include <re/re_seq.h>
    5454#include <kernels/lz4/decompression/lz4_bytestream_decompression.h>
     55#include <kernels/lz4/twist_kernel.h>
     56#include <kernels/lz4/decompression/lz4_twist_decompression.h>
     57#include <kernels/lz4/untwist_kernel.h>
    5558
    5659namespace re { class CC; }
     
    106109}
    107110
    108 parabix::StreamSetBuffer * LZ4GrepGenerator::convertCompressedBitsStreamWithByteStreamAioApproach(
     111parabix::StreamSetBuffer * LZ4GrepGenerator::convertCompressedBitsStreamWithTwistApproach(
    109112        parabix::StreamSetBuffer *compressedByteStream,
    110113        parabix::StreamSetBuffer *compressedBitStream,
    111114        std::string prefix
    112115) {
    113     auto mGrepDriver = &mPxDriver;
    114     auto & b = mGrepDriver->getBuilder();
    115     unsigned numberOfStream = compressedBitStream->getNumOfStreams();
     116    auto & b = mPxDriver.getBuilder();
    116117
    117118    LZ4BlockInfo blockInfo = this->getBlockInfo(compressedByteStream);
    118119
     120    unsigned numOfStreams = compressedBitStream->getNumOfStreams();
     121
     122    if (numOfStreams == 1) {
     123        StreamSetBuffer* uncompressedBitStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 1),
     124                                                                                            this->getDefaultBufferBlocks());
     125        Kernel* lz4I4AioK = mPxDriver.addKernelInstance<LZ4TwistDecompressionKernel>(b, 1);
     126        lz4I4AioK->setInitialArguments({mFileSize});
     127        mPxDriver.makeKernelCall(lz4I4AioK, {
     128                compressedByteStream,
     129
     130                blockInfo.isCompress,
     131                blockInfo.blockStart,
     132                blockInfo.blockEnd,
     133
     134                compressedBitStream
     135        }, {
     136                uncompressedBitStream
     137                                 });
     138        return uncompressedBitStream;
     139    }
     140
     141    if (numOfStreams <= 2) {
     142        StreamSetBuffer* twistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 2),
     143                                                                                this->getDefaultBufferBlocks());
     144        kernel::Kernel* twistK = mPxDriver.addKernelInstance<kernel::TwistByPDEPKernel>(b, numOfStreams, 2);
     145        mPxDriver.makeKernelCall(twistK, {compressedBitStream}, {twistedCharClasses});
     146
     147
     148        StreamSetBuffer* uncompressedTwistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 2),
     149                                                                                            this->getDefaultBufferBlocks());
     150        Kernel* lz4I4AioK = mPxDriver.addKernelInstance<LZ4TwistDecompressionKernel>(b, 2);
     151        lz4I4AioK->setInitialArguments({mFileSize});
     152        mPxDriver.makeKernelCall(lz4I4AioK, {
     153                compressedByteStream,
     154
     155                blockInfo.isCompress,
     156                blockInfo.blockStart,
     157                blockInfo.blockEnd,
     158
     159                twistedCharClasses
     160        }, {
     161                                         uncompressedTwistedCharClasses
     162                                 });
     163
     164        StreamSetBuffer* untwistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(numOfStreams),
     165                                                                                  this->getDefaultBufferBlocks());
     166        kernel::Kernel* untwistK = mPxDriver.addKernelInstance<kernel::UntwistByPEXTKernel>(b, numOfStreams, 2);
     167        mPxDriver.makeKernelCall(untwistK, {uncompressedTwistedCharClasses}, {untwistedCharClasses});
     168        return untwistedCharClasses;
     169    }
     170
     171    if (numOfStreams <= 4) {
     172        StreamSetBuffer* twistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 4),
     173                                                                                this->getDefaultBufferBlocks());
     174        kernel::Kernel* twistK = mPxDriver.addKernelInstance<kernel::TwistByPDEPKernel>(b, numOfStreams, 4);
     175        mPxDriver.makeKernelCall(twistK, {compressedBitStream}, {twistedCharClasses});
     176
     177
     178        StreamSetBuffer* uncompressedTwistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 4),
     179                                                                                            this->getDefaultBufferBlocks());
     180
     181        Kernel* lz4I4AioK = mPxDriver.addKernelInstance<LZ4TwistDecompressionKernel>(b, 4);
     182        lz4I4AioK->setInitialArguments({mFileSize});
     183        mPxDriver.makeKernelCall(lz4I4AioK, {
     184                compressedByteStream,
     185
     186                blockInfo.isCompress,
     187                blockInfo.blockStart,
     188                blockInfo.blockEnd,
     189
     190                twistedCharClasses
     191        }, {
     192                                         uncompressedTwistedCharClasses
     193                                 });
     194
     195        StreamSetBuffer* untwistedCharClasses = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(numOfStreams),
     196                                                                                  this->getDefaultBufferBlocks());
     197        kernel::Kernel* untwistK = mPxDriver.addKernelInstance<kernel::UntwistByPEXTKernel>(b, numOfStreams, 4);
     198        mPxDriver.makeKernelCall(untwistK, {uncompressedTwistedCharClasses}, {untwistedCharClasses});
     199        return untwistedCharClasses;
     200    }
     201
     202    // <= 8
    119203    StreamSetBuffer * const mtxByteStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(1, 8),
    120204                                                                              this->getDefaultBufferBlocks());
    121     Kernel * p2sK = mPxDriver.addKernelInstance<P2SKernel>(b, cc::BitNumbering::BigEndian, prefix, numberOfStream);
     205    Kernel * p2sK = mPxDriver.addKernelInstance<P2SKernel>(b, cc::BitNumbering::BigEndian, prefix, numOfStreams);
    122206    mPxDriver.makeKernelCall(p2sK, {compressedBitStream}, {mtxByteStream});
    123207
     
    139223            });
    140224
    141     StreamSetBuffer * const uncompressedMtxBitStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(8),
     225    StreamSetBuffer * const uncompressedMtxBitStream = mPxDriver.addBuffer<StaticBuffer>(b, b->getStreamSetTy(numOfStreams),
    142226                                                                                         this->getDefaultBufferBlocks());
    143227
    144     Kernel * s2pk = mPxDriver.addKernelInstance<S2PKernel>(b, cc::BitNumbering::BigEndian, true, prefix, numberOfStream);
     228    Kernel * s2pk = mPxDriver.addKernelInstance<S2PKernel>(b, cc::BitNumbering::BigEndian, true, prefix, numOfStreams);
    145229    mPxDriver.makeKernelCall(s2pk, {decompressionMtxByteStream}, {uncompressedMtxBitStream});
    146 
    147230    return uncompressedMtxBitStream;
    148231}
     
    223306    std::set<re::Name *> UnicodeProperties;
    224307
    225     re::CC* linefeedCC = re::makeCC(0x0A);
     308    re::CC* linefeedCC = re::makeByte(0x0A);
    226309
    227310    re::Seq* seq = re::makeSeq();
    228     seq->push_back(mREs[0]);
     311    re::RE* targetRe = mREs[0];
     312    re::RE* utf8Re = re::toUTF8(targetRe, true);
     313
     314
     315    seq->push_back(utf8Re);
    229316    seq->push_back(std::move(linefeedCC));
    230317
    231 
    232     const auto UnicodeSets = re::collectCCs(seq, &cc::Unicode, std::set<re::Name *>({re::makeZeroWidth("\\b{g}")}));
     318    std::vector<re::CC*> UnicodeSets = re::collectCCs(seq, &cc::Byte, std::set<re::Name *>({re::makeZeroWidth("\\b{g}")}));
     319
    233320    StreamSetBuffer * const MatchResults = mGrepDriver->addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(1, 1), baseBufferSize);
    234321
    235322    mpx = make_unique<cc::MultiplexedAlphabet>("mpx", UnicodeSets);
    236     mREs[0] = transformCCs(mpx.get(), mREs[0]);
     323    re::RE* r = transformCCs(mpx.get(), utf8Re);
     324    mREs[0] = r;
     325
     326
    237327    std::vector<re::CC *> mpx_basis = mpx->getMultiplexedCCs();
    238328    auto numOfCharacterClasses = mpx_basis.size();
    239329    StreamSetBuffer * CharClasses = mGrepDriver->addBuffer<StaticBuffer>(idb, idb->getStreamSetTy(numOfCharacterClasses), baseBufferSize);
    240330
    241     kernel::Kernel * ccK = mGrepDriver->addKernelInstance<kernel::CharClassesKernel>(idb, std::move(mpx_basis), false, cc::BitNumbering::BigEndian);
     331
     332    kernel::Kernel * ccK = mGrepDriver->addKernelInstance<kernel::ByteClassesKernel>(idb, std::move(mpx_basis), false, cc::BitNumbering::BigEndian);
    242333    mGrepDriver->makeKernelCall(ccK, {compressedBitStream}, {CharClasses});
    243334
     
    246337        uncompressedCharClasses = this->convertCompressedBitsStreamWithSwizzledAioApproach(compressedByteStream, CharClasses, "combined");
    247338    } else if (useByteStream){
    248         uncompressedCharClasses = this->convertCompressedBitsStreamWithByteStreamAioApproach(compressedByteStream, CharClasses, "combined");
     339        uncompressedCharClasses = this->convertCompressedBitsStreamWithTwistApproach(compressedByteStream, CharClasses,
     340                                                                                     "combined");
    249341    } else {
    250342        auto ret = this->convertCompressedBitsStreamWithBitStreamAioApproach(compressedByteStream, {CharClasses});
     
    613705    StreamSetBuffer * LineBreakStream;
    614706    StreamSetBuffer * Matches;
     707
    615708    std::vector<re::RE*> res = {regex};
    616709    std::tie(LineBreakStream, Matches) = grepPipeline(res, uncompressedBitStream);
  • icGREP/icgrep-devel/icgrep/lz4/lz4_grep_generator.h

    r6137 r6140  
    8585    );
    8686
    87     parabix::StreamSetBuffer *convertCompressedBitsStreamWithByteStreamAioApproach(
     87    parabix::StreamSetBuffer *convertCompressedBitsStreamWithTwistApproach(
    8888            parabix::StreamSetBuffer *compressedByteStream,
    8989            parabix::StreamSetBuffer *compressedBitStream,
  • icGREP/icgrep-devel/icgrep/re/to_utf8.cpp

    r5908 r6140  
    6363}
    6464
    65 RE * toUTF8(RE * r) {
    66     if (isa<Name>(r) || isa<Start>(r) || isa<End>(r)) {
     65RE * toUTF8(RE * r, bool convertName) {
     66    if (const Name*  n = dyn_cast<Name>(r)) {
     67        if (convertName) {
     68            return toUTF8(n->getDefinition(), convertName);
     69        } else {
     70            return r;
     71        }
     72    }
     73    else if (isa<Name>(r) || isa<Start>(r) || isa<End>(r)) {
    6774        return r;
    6875    } else if (const CC * cc = dyn_cast<CC>(r)) {
     
    7784        list.reserve(alt->size());
    7885        for (RE * a : *alt) {
    79             list.push_back(toUTF8(a));
     86            list.push_back(toUTF8(a, convertName));
    8087        }
    8188        return makeAlt(list.begin(), list.end());
     
    8491        list.reserve(seq->size());
    8592        for (RE * s : *seq) {
    86             list.push_back(toUTF8(s));
     93            list.push_back(toUTF8(s, convertName));
    8794        }
    8895        return makeSeq(list.begin(), list.end());
    8996    } else if (Assertion * a = dyn_cast<Assertion>(r)) {
    90         return makeAssertion(toUTF8(a->getAsserted()), a->getKind(), a->getSense());
     97        return makeAssertion(toUTF8(a->getAsserted(), convertName), a->getKind(), a->getSense());
    9198    } else if (Rep * rep = dyn_cast<Rep>(r)) {
    92         RE * expr = toUTF8(rep->getRE());
     99        RE * expr = toUTF8(rep->getRE(), convertName);
    93100        return makeRep(expr, rep->getLB(), rep->getUB());
    94101    } else if (Diff * diff = dyn_cast<Diff>(r)) {
    95         return makeDiff(toUTF8(diff->getLH()), toUTF8(diff->getRH()));
     102        return makeDiff(toUTF8(diff->getLH(), convertName), toUTF8(diff->getRH(), convertName));
    96103    } else if (Intersect * e = dyn_cast<Intersect>(r)) {
    97         return makeIntersect(toUTF8(e->getLH()), toUTF8(e->getRH()));
     104        return makeIntersect(toUTF8(e->getLH(), convertName), toUTF8(e->getRH(), convertName));
    98105    }
    99106    llvm_unreachable("unexpected RE type given to toUTF8");
  • icGREP/icgrep-devel/icgrep/re/to_utf8.h

    r5760 r6140  
    1212namespace re {
    1313
    14 RE * toUTF8(RE * ast);
     14RE * toUTF8(RE * ast, bool convertName = false);
    1515}
    1616#endif // TO_UTF8_H
Note: See TracChangeset for help on using the changeset viewer.