Ignore:
Timestamp:
Jun 23, 2015, 9:29:39 AM (4 years ago)
Author:
nmedfort
Message:

Replaced CharSetItem? with a std::pair.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/re/re_cc.cpp

    r4613 r4614  
    99#include <UCD/CaseFolding_txt.h>
    1010#include <sstream>
    11 #include <iostream>
    1211
    1312namespace re {
    14 CC::CharSetAllocator CC::mCharSetAllocator;
     13CC::IntervalAllocator CC::mCharSetAllocator;
    1514
    1615CC::CC(const CC * cc1, const CC * cc2)
    1716: RE(ClassTypeId::CC)
    1817, mSparseCharSet(cc1->cbegin(), cc1->cend(), mCharSetAllocator) {
    19     for (const CharSetItem & i : cc2->mSparseCharSet) {
    20         insert_range(i.lo_codepoint, i.hi_codepoint);
     18    for (const interval_t & i : cc2->mSparseCharSet) {
     19        insert_range(lo_codepoint(i), hi_codepoint(i));
    2120    }
    2221}
     
    3029std::string CC::canonicalName(const CC_type type) const {
    3130    std::stringstream name;
    32     // name << std::hex;
     31    name << std::hex;
    3332    if ((type == ByteClass) && (max_codepoint() >= 0x80)) {
    3433        name << "BC";
     
    3837    }
    3938    char separator = '_';
    40     for (const CharSetItem & i : mSparseCharSet) {
     39    for (const interval_t & i : mSparseCharSet) {
    4140        name << separator;
    42         if (i.lo_codepoint == i.hi_codepoint) {
    43             name << i.lo_codepoint;
    44         }
    45         else {
    46             name << i.lo_codepoint << '_' << i.hi_codepoint;
     41        if (lo_codepoint(i) == hi_codepoint(i)) {
     42            name << lo_codepoint(i);
     43        }
     44        else {
     45            name << lo_codepoint(i) << '_' << hi_codepoint(i);
    4746        }
    4847        separator = ',';
     
    5150}
    5251
    53 void CC::insert_range(const codepoint_t lo_codepoint, const codepoint_t hi_codepoint) {
     52void CC::insert_range(const codepoint_t lo, const codepoint_t hi) {
    5453    for (auto i = mSparseCharSet.begin(); i != mSparseCharSet.end(); ) {
    55         CharSetItem & range = *i;
    56         if (hi_codepoint < range.lo_codepoint - 1) {
    57             mSparseCharSet.emplace(i, lo_codepoint, hi_codepoint);
     54        if (hi < lo_codepoint(i) - 1) {
     55            mSparseCharSet.emplace(i, lo, hi);
    5856            return;
    5957        }
    60         else if (lo_codepoint > range.hi_codepoint + 1) {
     58        else if (lo > hi_codepoint(i) + 1) {
    6159            ++i;
    6260        }
     
    6462            // ranges overlap; expand the range to include the prior one and
    6563            // remove the old one from the list
    66             range.lo_codepoint = std::min(range.lo_codepoint, lo_codepoint);
    67             range.hi_codepoint = std::max(range.hi_codepoint, hi_codepoint);
     64            lo_codepoint(i) = std::min(lo_codepoint(i), lo);
     65            hi_codepoint(i) = std::max(hi_codepoint(i), hi);
    6866            return;
    6967        }
    7068    }
    71     mSparseCharSet.emplace_back(lo_codepoint, hi_codepoint);
    72 }
    73 
    74 void CC::remove_range(const codepoint_t lo_codepoint, const codepoint_t hi_codepoint) {
     69    mSparseCharSet.emplace_back(lo, hi);
     70}
     71
     72void CC::remove_range(const codepoint_t lo, const codepoint_t hi) {
    7573    for (auto i = mSparseCharSet.begin(); i != mSparseCharSet.end(); ) {
    76         CharSetItem & range = *i;
    77         if (lo_codepoint > range.hi_codepoint + 1) {
    78             ++i;
    79         }
    80         else if (hi_codepoint < range.lo_codepoint - 1) {
     74        if (lo > hi_codepoint(i) + 1) {
     75            ++i;
     76        }
     77        else if (hi < lo_codepoint(i) - 1) {
    8178            break;
    8279        }
    83         else if (lo_codepoint <= range.lo_codepoint && hi_codepoint >= range.hi_codepoint) {
     80        else if (lo <= lo_codepoint(i) && hi >= hi_codepoint(i)) {
    8481            i = mSparseCharSet.erase(i);
    8582        }
    86         else if (lo_codepoint <= range.lo_codepoint) {
    87             range.lo_codepoint = hi_codepoint + 1;
     83        else if (lo <= lo_codepoint(i)) {
     84            lo_codepoint(i) = hi + 1;
    8885            break;
    8986        }
    90         else if (hi_codepoint >= range.hi_codepoint) {
    91             range.hi_codepoint = lo_codepoint - 1;
    92             ++i;
    93         }
    94         else {
    95             CharSetItem item(hi_codepoint + 1, range.hi_codepoint);
    96             range.hi_codepoint = lo_codepoint - 1;
    97             mSparseCharSet.insert(++i, std::move(item));
     87        else if (hi >= hi_codepoint(i)) {
     88            hi_codepoint(i) = lo - 1;
     89            ++i;
     90        }
     91        else {         
     92            mSparseCharSet.emplace(++i, hi + 1, hi_codepoint(i));
     93            hi_codepoint(i) = lo - 1;
    9894            break;
    9995        }
     
    10197}
    10298
    103 CC * subtractCC(const CC * cc1, const CC * cc2) {
     99CC * subtractCC(const CC * a, const CC * b) {
    104100    CC * diff = makeCC();
    105     auto ai = cc1->cbegin();
    106     const auto ai_end = cc1->cend();
    107     auto bi = cc2->cbegin();
    108     const auto bi_end = cc2->cend();
    109     while (ai != ai_end && bi != bi_end) {
    110         const CharSetItem & ra = *ai;
    111         const CharSetItem & rb = *bi;
    112         if (rb.hi_codepoint < ra.lo_codepoint) {
    113             ++bi;
     101    auto i = a->cbegin();
     102    const auto i_end = a->cend();
     103    auto j = b->cbegin();
     104    const auto j_end = b->cend();
     105    while (i != i_end && j != j_end) {
     106        if (hi_codepoint(j) < lo_codepoint(i)) {
     107            ++j;
    114108        }
    115109        else { // test whether the intervals overlap
    116             if (ra.lo_codepoint < rb.lo_codepoint) {
    117                 diff->insert_range(ra.lo_codepoint, std::min(rb.lo_codepoint - 1, ra.hi_codepoint));
    118             }
    119             if (ra.hi_codepoint > rb.hi_codepoint) {
    120                 diff->insert_range(std::max(rb.hi_codepoint + 1, ra.lo_codepoint), ra.hi_codepoint);
    121             }
    122             ++ai;
    123         }
    124     }
    125     for (; ai != ai_end; ++ai) {
    126         const CharSetItem & ra = *ai;
    127         diff->insert_range(ra.lo_codepoint, ra.hi_codepoint);
     110            if (lo_codepoint(i) < lo_codepoint(j)) {
     111                diff->insert_range(lo_codepoint(i), std::min(lo_codepoint(j) - 1, hi_codepoint(i)));
     112            }
     113            if (hi_codepoint(i) > hi_codepoint(j)) {
     114                diff->insert_range(std::max(hi_codepoint(j) + 1, lo_codepoint(i)), hi_codepoint(i));
     115            }
     116            ++i;
     117        }
     118    }
     119    for (; i != i_end; ++i) {
     120        diff->insert_range(lo_codepoint(i), hi_codepoint(i));
    128121    }
    129122    return diff;
     
    137130    const auto bi_end = b->cend();
    138131    while (ai != ai_end && bi != bi_end) {
    139         const CharSetItem & ra = *ai;
    140         const CharSetItem & rb = *bi;
    141         if (ra.hi_codepoint < rb.lo_codepoint) {
     132        if (hi_codepoint(ai) < lo_codepoint(bi)) {
    142133            ++ai;
    143134        }
    144         else if (rb.hi_codepoint < ra.lo_codepoint) {
     135        else if (hi_codepoint(bi) < lo_codepoint(ai)) {
    145136            ++bi;
    146137        }
    147138        else {
    148             isect->insert_range(std::max(ra.lo_codepoint, rb.lo_codepoint), std::min(ra.hi_codepoint, rb.hi_codepoint));
    149             if (ra.hi_codepoint < rb.hi_codepoint) {
     139            isect->insert_range(std::max(lo_codepoint(ai), lo_codepoint(bi)), std::min(hi_codepoint(ai), hi_codepoint(bi)));
     140            if (hi_codepoint(ai) < hi_codepoint(bi)) {
    150141                ++ai;
    151142            }
     
    160151CC * caseInsensitize(const CC * cc) {
    161152    CC * cci = makeCC();
    162     for (const CharSetItem & i : *cc) {
    163         caseInsensitiveInsertRange(cci, i.lo_codepoint, i.hi_codepoint);
     153    for (const interval_t & i : *cc) {
     154        caseInsensitiveInsertRange(cci, lo_codepoint(i), hi_codepoint(i));
    164155    }
    165156    return cci;
     
    175166    assert ("cc cannot be null" && cc);
    176167    CC * intersect = makeCC();
    177     for (const auto & p : *cc) {
    178         if ((p.lo_codepoint <= hi) && (p.hi_codepoint >= lo)) {
    179             intersect->insert_range(std::max(lo, p.lo_codepoint), std::min(hi, p.hi_codepoint));
     168    for (const auto & i : *cc) {
     169        if ((lo_codepoint(i) <= hi) && (hi_codepoint(i) >= lo)) {
     170            intersect->insert_range(std::max(lo, lo_codepoint(i)), std::min(hi, hi_codepoint(i)));
    180171        }
    181172    }
     
    196187        auto i = cc->cbegin(), end = cc->cend();
    197188        for (; i != end && cp < hi; ++i) {
    198             if (i->hi_codepoint < cp) {
     189            if (hi_codepoint(i) < cp) {
    199190                continue;
    200191            }
    201             else if (i->lo_codepoint > cp) {
    202                 gaps->insert_range(cp, i->lo_codepoint - 1);
    203             }
    204             cp = i->hi_codepoint + 1;
     192            else if (lo_codepoint(i) > cp) {
     193                gaps->insert_range(cp, lo_codepoint(i) - 1);
     194            }
     195            cp = hi_codepoint(i) + 1;
    205196        }
    206197        if (cp < hi) {
     
    221212    const auto end = cc->cend();
    222213    for (auto j = i; ++j != end; ) {
    223         if (j->hi_codepoint > i->hi_codepoint) {
    224             ranges->insert_range(i->lo_codepoint, i->hi_codepoint);
     214        if (hi_codepoint(j) > hi_codepoint(i)) {
     215            ranges->insert_range(lo_codepoint(i), hi_codepoint(i));
    225216            i = j;
    226217        }
     
    239230    const auto end = cc->cend();
    240231    for (auto j = i; ++j != end; ) {
    241         if (j->hi_codepoint <= i->hi_codepoint) {
    242             ranges->insert_range(j->lo_codepoint, j->hi_codepoint);
     232        if (hi_codepoint(j) <= hi_codepoint(i)) {
     233            ranges->insert_range(lo_codepoint(j), hi_codepoint(j));
    243234        }
    244235        else {
Note: See TracChangeset for help on using the changeset viewer.