Ignore:
Timestamp:
Jun 25, 2015, 3:47:56 PM (4 years ago)
Author:
nmedfort
Message:

Upload of an untested (inactive) UCD compiler.

File:
1 edited

Legend:

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

    r4616 r4617  
    2222#include <string>
    2323#include <iostream>
     24#include <include/simd-lib/builtins.hpp>
    2425
    2526const size_t QUAD_BITS = (8 * sizeof(bitquad_t));
     
    2829const bitquad_t FULL_QUAD_MASK = -1;
    2930
    30 
    31 inline const RunStructure & get_run(UnicodeSet::iterator i) {
     31inline const RunStructure & get_run(UnicodeSet::quad_iterator i) {
    3232    return std::get<0>(*i);
    3333}
    3434
    35 inline bitquad_t get_quad(UnicodeSet::iterator i) {
     35inline bitquad_t get_quad(UnicodeSet::quad_iterator i) {
    3636    return std::get<1>(*i);
    3737}
    3838
    39 const std::pair<RunStructure, bitquad_t> UnicodeSet::iterator::dereference() const {
     39const std::pair<RunStructure, bitquad_t> UnicodeSet::quad_iterator::dereference() const {
    4040    const RunStructure & t = mUnicodeSet.runs[mRunIndex];
    4141    RunStructure s(t.mType, t.mRunLength - mOffset);
     
    4444}
    4545
    46 void UnicodeSet::iterator::advance(unsigned n) {
     46void UnicodeSet::quad_iterator::advance(unsigned n) {
    4747    while (n > 0) {
    4848        const RunStructure & t = mUnicodeSet.runs[mRunIndex];
     
    107107
    108108void Dump_uset(const UnicodeSet & s) {
    109     for (auto it = s.begin(); it != s.end(); ++it) {
     109    for (auto it = s.quad_begin(); it != s.quad_end(); ++it) {
    110110        RunStructure this_run = get_run(it);
    111111        if (this_run.mType == Empty) {
     
    170170    assert(s.quad_count == UNICODE_QUAD_COUNT);
    171171    UnicodeSet iset;
    172     for (auto itr = s.begin(); itr != s.end(); ) {
     172    for (auto itr = s.quad_begin(); itr != s.quad_end(); ) {
    173173        auto run = get_run(itr);
    174174        if (run.mType == Empty) {
     
    193193    assert(s2.quad_count == UNICODE_QUAD_COUNT);
    194194    UnicodeSet iset;
    195     for (auto i1 = s1.begin(), i2 = s2.begin(); i1 != s1.end(); ) {
     195    for (auto i1 = s1.quad_begin(), i2 = s2.quad_begin(); i1 != s1.quad_end(); ) {
    196196        auto run1 = get_run(i1);
    197197        auto run2 = get_run(i2);
     
    232232    assert(s2.quad_count == UNICODE_QUAD_COUNT);
    233233    UnicodeSet iset;
    234     for (auto i1 = s1.begin(), i2 = s2.begin(); i1 != s1.end(); ) {
     234    for (auto i1 = s1.quad_begin(), i2 = s2.quad_begin(); i1 != s1.quad_end(); ) {
    235235        auto run1 = get_run(i1);
    236236        auto run2 = get_run(i2);
     
    271271    assert(s2.quad_count == UNICODE_QUAD_COUNT);
    272272    UnicodeSet iset;
    273     for (auto i1 = s1.begin(), i2 = s2.begin(); i1 != s1.end(); ) {
     273    for (auto i1 = s1.quad_begin(), i2 = s2.quad_begin(); i1 != s1.quad_end(); ) {
    274274        auto run1 = get_run(i1);
    275275        auto run2 = get_run(i2);
     
    310310    assert(s2.quad_count == UNICODE_QUAD_COUNT);
    311311    UnicodeSet iset;
    312     for (auto i1 = s1.begin(), i2 = s2.begin(); i1 != s1.end(); ) {
     312    for (auto i1 = s1.quad_begin(), i2 = s2.quad_begin(); i1 != s1.quad_end(); ) {
    313313        auto run1 = get_run(i1);
    314314        auto run2 = get_run(i2);
     
    360360    int quad_no = codepoint / QUAD_BITS;
    361361    bitquad_t quad_val = 1 << (codepoint & MOD_QUAD_BIT_MASK);
    362     return (get_quad(s.begin() + quad_no) & quad_val) != 0;
    363 }
     362    return (get_quad(s.quad_begin() + quad_no) & quad_val) != 0;
     363}
     364
     365void UnicodeSet::iterator::advance(unsigned n) {
     366
     367    while (n) {
     368
     369        const RunStructure & t = mUnicodeSet.runs[mRunIndex];
     370
     371        if (t.mType == Full) {
     372            mRight = mBaseCodePoint + t.mRunLength * QUAD_BITS;
     373            --n;
     374        }
     375
     376        if (t.mType != Mixed) {
     377            ++mRunIndex;
     378            mBaseCodePoint += t.mRunLength * QUAD_BITS;
     379            mQuadOffset = 0;
     380            mQuadRunIndex = 0;
     381            continue;
     382        }
     383
     384        while (mQuadRunIndex < t.mRunLength) {
     385
     386            const bitquad_t q = mUnicodeSet.quads[mQuadIndex];
     387            const bitquad_t m = q &(MOD_QUAD_BIT_MASK >> mQuadOffset);
     388
     389            // Nothing left in this quad to add; skip to the next one.
     390            if (m == 0) {
     391                mBaseCodePoint += QUAD_BITS;
     392                mLeft = mBaseCodePoint;
     393                ++mQuadIndex;
     394                if (++mQuadRunIndex == t.mRunLength) {
     395                    ++mRunIndex;
     396                }
     397                continue;
     398            }
     399
     400            mQuadOffset = scan_forward_zeroes(m);
     401            mLeft = mBaseCodePoint + mQuadOffset;
     402            break;
     403        }
     404
     405
     406        while (mQuadRunIndex < t.mRunLength) {
     407
     408            // Although the initial position was in this quad, the final position isn't
     409            // unless this is the last quad of this mixed run and the subsequent quad is
     410            // Empty.
     411
     412            const bitquad_t q = mUnicodeSet.quads[mQuadIndex];
     413            const bitquad_t m = ~q & (MOD_QUAD_BIT_MASK >> mQuadOffset);
     414            // Nothing left in this quad to add; skip to the next one.
     415            if (m == 0) {
     416                mBaseCodePoint += QUAD_BITS;
     417                mRight = mBaseCodePoint;
     418                ++mQuadIndex;
     419                if (++mQuadRunIndex == t.mRunLength) {
     420                    ++mRunIndex;
     421                }
     422                continue;
     423            }
     424
     425            mQuadOffset = scan_forward_zeroes(m);
     426            mRight = mBaseCodePoint + mQuadOffset;
     427            --n;
     428            break;
     429        }
     430    }
     431}
     432
     433
Note: See TracChangeset for help on using the changeset viewer.