Ignore:
Timestamp:
Jun 29, 2015, 1:46:55 PM (4 years ago)
Author:
nmedfort
Message:

Preliminary changes to inclusion of UCD Compiler into the RE Compiler.

Location:
icGREP/icgrep-devel/icgrep/UCD
Files:
4 edited

Legend:

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

    r4617 r4622  
    423423 * @brief constructor
    424424 ** ------------------------------------------------------------------------------------------------------------- */
    425 UCDCompiler::UCDCompiler(PabloBlock & entry, const Encoding & encoding)
    426 : mCharacterClassCompiler(entry, encoding)
     425UCDCompiler::UCDCompiler(cc::CC_Compiler & ccCompiler)
     426: mCharacterClassCompiler(ccCompiler)
    427427, mSuffix(makeCC(0x80, 0xBF)) { }
    428428
  • icGREP/icgrep-devel/icgrep/UCD/ucd_compiler.hpp

    r4617 r4622  
    2121
    2222public:
    23     UCDCompiler(pablo::PabloBlock & entry, const Encoding & encoding);
     23    UCDCompiler(cc::CC_Compiler & ccCompiler);
    2424
    2525    PabloAST * generateWithDefaultIfHierarchy(const UnicodeSet & set, PabloBuilder & entry);
     
    5454
    5555private:
    56     cc::CC_Compiler         mCharacterClassCompiler;
     56    cc::CC_Compiler &       mCharacterClassCompiler;
    5757    CC * const              mSuffix;
    5858};
  • icGREP/icgrep-devel/icgrep/UCD/unicode_set.cpp

    r4621 r4622  
    112112        }
    113113    }
    114     out.flush();
    115114}
    116115
     
    151150    const auto e2 = other.quad_end();
    152151    for (auto i1 = quad_begin(), i2 = other.quad_begin(); i1 != e1 && i2 != e2; ) {
    153         const auto run1 = i1.getRun();
    154         const auto run2 = i2.getRun();
     152        const auto run1 = i1.run();
     153        const auto run2 = i2.run();
    155154        const auto n = std::min(lengthOf(run1), lengthOf(run2));
    156155        if (typeOf(run1) == typeOf(run2) && typeOf(run1) != Mixed) {
     
    161160        else if (typeOf(run1) == Full) {
    162161            for (unsigned i = 0; i != n; ++i, ++i2) {
    163                 append_quad(i2.getQuad(), quads, runs);
     162                append_quad(i2.quad(), quads, runs);
    164163            }
    165164            i1 += n;
     
    167166        else if (typeOf(run2) == Full) {
    168167            for (unsigned i = 0; i != n; ++i, ++i1) {
    169                 append_quad(i1.getQuad(), quads, runs);
     168                append_quad(i1.quad(), quads, runs);
    170169            }
    171170            i2 += n;
     
    173172        else {
    174173            for (unsigned i = 0; i != n; ++i, ++i1, ++i2) {
    175                 append_quad(i1.getQuad() & i2.getQuad(), quads, runs);
     174                append_quad(i1.quad() & i2.quad(), quads, runs);
    176175            }
    177176        }
     
    191190    auto i1 = quad_begin(), i2 = other.quad_begin();
    192191    for (; i1 != e1 && i2 != e2; ) {
    193         const auto run1 = i1.getRun();
    194         const auto run2 = i2.getRun();
     192        const auto run1 = i1.run();
     193        const auto run2 = i2.run();
    195194        const auto n = std::min(lengthOf(run1), lengthOf(run2));
    196195        if ((typeOf(run1) == Empty) && (typeOf(run2) == Empty)) {
     
    206205        else if (typeOf(run1) == Empty) {
    207206            for (unsigned i = 0; i != n; ++i, ++i2) {
    208                 append_quad(i2.getQuad(), quads, runs);
     207                append_quad(i2.quad(), quads, runs);
    209208            }
    210209            i1 += n;
     
    212211        else if (typeOf(run2) == Empty) {
    213212            for (unsigned i = 0; i != n; ++i, ++i1) {
    214                 append_quad(i1.getQuad(), quads, runs);
     213                append_quad(i1.quad(), quads, runs);
    215214            }
    216215            i2 += n;
     
    218217        else {
    219218            for (unsigned i = 0; i < n; ++i, ++i1, ++i2) {
    220                 append_quad(i1.getQuad() | i2.getQuad(), quads, runs);
     219                append_quad(i1.quad() | i2.quad(), quads, runs);
    221220            }
    222221        }
     
    235234    const auto e2 = other.quad_end();
    236235    for (auto i1 = quad_begin(), i2 = other.quad_begin(); i1 != e1 && i2 != e2; ) {
    237         const auto run1 = i1.getRun();
    238         const auto run2 = i2.getRun();
     236        const auto run1 = i1.run();
     237        const auto run2 = i2.run();
    239238        unsigned n = std::min(lengthOf(run1), lengthOf(run2));
    240239        if ((typeOf(run1) == Empty) || (typeOf(run2) == Full) || (typeOf(run1) == Full && typeOf(run2) == Empty)) {
     
    245244        else if (typeOf(run1) == Full) {
    246245            for (unsigned i = 0; i != n; ++i, ++i2) {
    247                 append_quad(FULL_QUAD_MASK ^ i2.getQuad(), quads, runs);
     246                append_quad(FULL_QUAD_MASK ^ i2.quad(), quads, runs);
    248247            }
    249248            i1 += n;
     
    251250        else if (typeOf(run2) == Empty) {
    252251            for (unsigned i = 0; i != n; ++i, ++i1) {
    253                 append_quad(i1.getQuad(), quads, runs);
     252                append_quad(i1.quad(), quads, runs);
    254253            }
    255254            i2 += n;
     
    257256        else {
    258257            for (unsigned i = 0; i != n; ++i, ++i1, ++i2) {
    259                 append_quad(i1.getQuad() &~ i2.getQuad(), quads, runs);
     258                append_quad(i1.quad() &~ i2.quad(), quads, runs);
    260259            }
    261260        }
     
    274273    const auto e2 = other.quad_end();
    275274    for (auto i1 = quad_begin(), i2 = other.quad_begin(); i1 != e1 && i2 != e2; ) {
    276         const auto run1 = i1.getRun();
    277         const auto run2 = i2.getRun();
     275        const auto run1 = i1.run();
     276        const auto run2 = i2.run();
    278277        unsigned n = std::min(lengthOf(run1), lengthOf(run2));
    279278        if (typeOf(run1) != Mixed && typeOf(run2) != Mixed) {
     
    284283        else if (typeOf(run1) == Empty) {
    285284            for (unsigned i = 0; i < n; ++i, ++i2) {
    286                 append_quad(i2.getQuad(), quads, runs);
     285                append_quad(i2.quad(), quads, runs);
    287286            }
    288287            i1 += n;
     
    290289        else if (typeOf(run2) == Empty) {
    291290            for (unsigned i = 0; i < n; ++i, ++i1) {
    292                 append_quad(i1.getQuad(), quads, runs);
     291                append_quad(i1.quad(), quads, runs);
    293292            }
    294293            i2 += n;
     
    296295        else if (typeOf(run1) == Full) {
    297296            for (unsigned i = 0; i < n; ++i, ++i2) {
    298                 append_quad(FULL_QUAD_MASK ^ i2.getQuad(), quads, runs);
     297                append_quad(FULL_QUAD_MASK ^ i2.quad(), quads, runs);
    299298            }
    300299            i1 += n;
     
    302301        else if (typeOf(run2) == Empty) {
    303302            for (unsigned i = 0; i < n; ++i, ++i1) {
    304                 append_quad(FULL_QUAD_MASK ^ i1.getQuad(), quads, runs);
     303                append_quad(FULL_QUAD_MASK ^ i1.quad(), quads, runs);
    305304            }
    306305            i2 += n;
     
    308307        else {
    309308            for (unsigned i = 0; i != n; ++i, ++i1, ++i2) {
    310                 append_quad(i1.getQuad() ^ i2.getQuad(), quads, runs);
     309                append_quad(i1.quad() ^ i2.quad(), quads, runs);
    311310            }
    312311        }
     
    331330    return true;
    332331}
    333 
    334332
    335333/** ------------------------------------------------------------------------------------------------------------- *
     
    420418            // If we found nothing in the quad, restart the loop.
    421419            if (found) {
    422                 // std::cerr << "Min: " << mMinCodePoint << " = " << mBaseCodePoint << " + " << mQuadOffset << std::endl;
    423420                break;
    424421            }
     
    461458            // If we found nothing in the quad, restart the loop.
    462459            if (found) {
    463                 // std::cerr << "Max: " << mMinCodePoint << " = " << mBaseCodePoint << " + " << mQuadOffset << std::endl;
    464460                break;
    465461            }
  • icGREP/icgrep-devel/icgrep/UCD/unicode_set.h

    r4621 r4622  
    4444    using length_t = uint16_t;
    4545    using run_t = std::pair<run_type_t, length_t>;
     46    using quad_iterator_return_t = std::pair<run_t, bitquad_t>;
    4647
    4748    using codepoint_t = re::codepoint_t;
     
    6364        void advance(const unsigned n);
    6465
    65         re::interval_t dereference() const {
     66        inline interval_t dereference() const {
    6667            return std::make_pair(mMinCodePoint, mMaxCodePoint);
    6768        }
     
    7172        }
    7273
    73         inline bool equal(iterator const & other) const {
     74        inline bool equal(const iterator & other) const {
    7475            return (mRunIterator == other.mRunIterator) && (mQuadIterator == other.mQuadIterator) &&
    7576                   (mMixedRunIndex == other.mMixedRunIndex) && (mQuadOffset == other.mQuadOffset);
     
    9495    }
    9596
    96     class quad_iterator : public boost::iterator_facade<quad_iterator, std::pair<run_t, bitquad_t>, boost::random_access_traversal_tag> {
     97    class quad_iterator : public boost::iterator_facade<quad_iterator, quad_iterator_return_t, boost::random_access_traversal_tag, quad_iterator_return_t> {
    9798        friend class UnicodeSet;
    9899        friend class boost::iterator_core_access;
     
    103104        void advance(unsigned n);
    104105
    105         inline const std::pair<run_t, bitquad_t> dereference() const {
    106             return std::make_pair(getRun(), getQuad());
     106        inline quad_iterator_return_t dereference() const {
     107            return std::make_pair(run(), quad());
    107108        }
    108109
     
    111112        }
    112113
    113         inline run_t getRun() const {
     114        inline run_t run() const {
    114115            const auto & t = *mRunIterator;
    115116            return std::make_pair(std::get<0>(t), std::get<1>(t) - mOffset);
    116117        }
    117118
    118         inline bitquad_t getQuad() const {
     119        inline bitquad_t quad() const {
    119120            return *mQuadIterator;
    120121        }
     
    147148    UnicodeSet operator-(const UnicodeSet & other) const;
    148149    UnicodeSet operator^(const UnicodeSet & other) const;
     150    inline UnicodeSet & operator=(const UnicodeSet & other) = default;
     151    inline UnicodeSet & operator=(UnicodeSet && other) = default;
    149152    UnicodeSet operator==(const UnicodeSet & other) const;
    150153
     
    152155    UnicodeSet(const codepoint_t codepoint);
    153156    UnicodeSet(const codepoint_t lo_codepoint, const codepoint_t hi_codepoint);
     157    inline UnicodeSet(const UnicodeSet & other) = default;
    154158    UnicodeSet(std::initializer_list<run_t> r, std::initializer_list<bitquad_t> q) : mRuns(r), mQuads(q) {}
    155159    UnicodeSet(std::vector<run_t> && r, std::vector<bitquad_t> && q) : mRuns(r), mQuads(q) {}
     
    160164private:
    161165
    162     std::vector<run_t>   mRuns;
    163     std::vector<bitquad_t>      mQuads;
     166    RunVector       mRuns;
     167    QuadVector      mQuads;
    164168};
    165169
    166170inline void UnicodeSet::swap(UnicodeSet & other) {
    167     mRuns.swap(other.mRuns);
    168     mQuads.swap(other.mQuads);
     171    mRuns.swap(other.mRuns); mQuads.swap(other.mQuads);
    169172}
    170173
    171174inline void UnicodeSet::swap(UnicodeSet && other) {
    172     mRuns.swap(other.mRuns);
    173     mQuads.swap(other.mQuads);
     175    mRuns.swap(other.mRuns); mQuads.swap(other.mQuads);
    174176}
    175177
Note: See TracChangeset for help on using the changeset viewer.