Changeset 4814


Ignore:
Timestamp:
Oct 3, 2015, 3:31:16 PM (2 years ago)
Author:
nmedfort
Message:

Added union/diff/intersection functionality to RE_Compiler. Removed toUTF8 pass in favour of using the UCD_Compiler.

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

Legend:

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

    r4809 r4814  
    2828namespace UCD {
    2929
    30 RE * resolvePropertyDefinition(Name * const property) {
     30bool resolvePropertyDefinition(Name * const property) {
    3131    if (property->hasNamespace()) {
    3232        auto propit = alias_map.find(property->getNamespace());
     
    4141                    Name * binprop = makeName(property_enum_name[theprop], Name::Type::UnicodeProperty);
    4242                    property->setDefinition(makeDiff(makeAny(), binprop));
     43                    return true;
    4344                }
    4445            }
     
    4950        if (value == "any") {
    5051            property->setDefinition(makeAny());
    51         }
    52         else if (value == "ascii") {
     52            return true;
     53        } else if (value == "ascii") {
    5354            property->setDefinition(makeName("blk", "ascii", Name::Type::UnicodeProperty));
    54         }
    55         else if (value == "assigned") {
     55            return true;
     56        } else if (value == "assigned") {
    5657            Name * unassigned = makeName("cn", Name::Type::UnicodeProperty);
    5758            property->setDefinition(makeDiff(makeAny(), unassigned));
     59            return true;
    5860        }
    5961        // Now compatibility properties of UTR #18 Annex C
     
    6264            Name * hexdigit = makeName("hexdigit", Name::Type::UnicodeProperty);
    6365            property->setDefinition(makeAlt({digit, hexdigit}));
    64         }
    65         else if (value == "alnum") {
     66            return true;
     67        } else if (value == "alnum") {
    6668            Name * digit = makeName("nd", Name::Type::UnicodeProperty);
    6769            Name * alpha = makeName("alphabetic", Name::Type::UnicodeProperty);
    6870            property->setDefinition(makeAlt({digit, alpha}));
    69         }
    70         else if (value == "blank") {
     71            return true;
     72        } else if (value == "blank") {
    7173            Name * space_sep = makeName("space_separator", Name::Type::UnicodeProperty);
    7274            CC * tab = makeCC(0x09);
    7375            property->setDefinition(makeAlt({space_sep, tab}));
    74         }
    75         else if (value == "graph") {
     76            return true;
     77        } else if (value == "graph") {
    7678            Name * space = makeName("space", Name::Type::UnicodeProperty);
    7779            Name * ctrl = makeName("control", Name::Type::UnicodeProperty);
     
    7981            Name * unassigned = makeName("cn", Name::Type::UnicodeProperty);
    8082            property->setDefinition(makeDiff(makeAny(), makeAlt({space, ctrl, surr, unassigned})));
    81         }
    82         else if (value == "print") {
     83            return true;
     84        } else if (value == "print") {
    8385            Name * graph = makeName("graph", Name::Type::UnicodeProperty);
    8486            Name * space_sep = makeName("space_separator", Name::Type::UnicodeProperty);
    8587            property->setDefinition(makeAlt({graph, space_sep}));
    86         }
    87         else if (value == "word") {
     88            return true;
     89        } else if (value == "word") {
    8890            Name * alnum = makeName("alnum", Name::Type::UnicodeProperty);
    8991            Name * mark = makeName("mark", Name::Type::UnicodeProperty);
     
    9193            Name * join = makeName("joincontrol", Name::Type::UnicodeProperty);
    9294            property->setDefinition(makeAlt({alnum, mark, conn, join}));
     95            return true;
    9396        }
    9497    }
    95     return property->getDefinition();
     98    return false;
    9699}
    97100
  • icGREP/icgrep-devel/icgrep/UCD/resolve_properties.h

    r4809 r4814  
    2020};
    2121
    22 re::RE * resolvePropertyDefinition(re::Name * const property);
     22bool resolvePropertyDefinition(re::Name * const property);
    2323std::string resolvePropertyFunction(re::Name * const property);
    2424UCD::UnicodeSet resolveUnicodeSet(re::Name * const name);
  • icGREP/icgrep-devel/icgrep/UCD/ucd_compiler.cpp

    r4812 r4814  
    99
    1010namespace UCD {
     11
     12const UCDCompiler::RangeList UCDCompiler::defaultIfHierachy = {
     13    // Non-ASCII
     14    {0x80, 0x10FFFF},
     15    // Two-byte sequences
     16    {0x80, 0x7FF},
     17    {0x100, 0x3FF},
     18    // 0100..017F; Latin Extended-A
     19    // 0180..024F; Latin Extended-B
     20    // 0250..02AF; IPA Extensions
     21    // 02B0..02FF; Spacing Modifier Letters
     22    {0x100, 0x2FF}, {0x100, 0x24F}, {0x100, 0x17F}, {0x180, 0x24F}, {0x250, 0x2AF}, {0x2B0, 0x2FF},
     23    // 0300..036F; Combining Diacritical Marks
     24    // 0370..03FF; Greek and Coptic
     25    {0x300, 0x36F}, {0x370, 0x3FF},
     26    // 0400..04FF; Cyrillic
     27    // 0500..052F; Cyrillic Supplement
     28    // 0530..058F; Armenian
     29    // 0590..05FF; Hebrew
     30    // 0600..06FF; Arabic
     31    {0x400, 0x5FF}, {0x400, 0x4FF}, {0x500, 0x058F}, {0x500, 0x52F}, {0x530, 0x58F}, {0x590, 0x5FF}, {0x600, 0x6FF},
     32    // 0700..074F; Syriac
     33    // 0750..077F; Arabic Supplement
     34    // 0780..07BF; Thaana
     35    // 07C0..07FF; NKo
     36    {0x700, 0x77F}, {0x700, 0x74F}, {0x750, 0x77F}, {0x780, 0x7FF}, {0x780, 0x7BF}, {0x7C0, 0x7FF},
     37    // Three-byte sequences
     38    {0x800, 0xFFFF}, {0x800, 0x4DFF}, {0x800, 0x1FFF}, {0x800, 0x0FFF},
     39    // 0800..083F; Samaritan
     40    // 0840..085F; Mandaic
     41    // 08A0..08FF; Arabic Extended-A
     42    // 0900..097F; Devanagari
     43    // 0980..09FF; Bengali
     44    // 0A00..0A7F; Gurmukhi
     45    // 0A80..0AFF; Gujarati
     46    // 0B00..0B7F; Oriya
     47    // 0B80..0BFF; Tamil
     48    // 0C00..0C7F; Telugu
     49    // 0C80..0CFF; Kannada
     50    // 0D00..0D7F; Malayalam
     51    // 0D80..0DFF; Sinhala
     52    // 0E00..0E7F; Thai
     53    // 0E80..0EFF; Lao
     54    // 0F00..0FFF; Tibetan
     55    {0x1000, 0x1FFF},
     56    // 1000..109F; Myanmar
     57    // 10A0..10FF; Georgian
     58    // 1100..11FF; Hangul Jamo
     59    // 1200..137F; Ethiopic
     60    // 1380..139F; Ethiopic Supplement
     61    // 13A0..13FF; Cherokee
     62    // 1400..167F; Unified Canadian Aboriginal Syllabics
     63    // 1680..169F; Ogham
     64    // 16A0..16FF; Runic
     65    // 1700..171F; Tagalog
     66    // 1720..173F; Hanunoo
     67    // 1740..175F; Buhid
     68    // 1760..177F; Tagbanwa
     69    // 1780..17FF; Khmer
     70    // 1800..18AF; Mongolian
     71    // 18B0..18FF; Unified Canadian Aboriginal Syllabics Extended
     72    // 1900..194F; Limbu
     73    // 1950..197F; Tai Le
     74    // 1980..19DF; New Tai Lue
     75    // 19E0..19FF; Khmer Symbols
     76    // 1A00..1A1F; Buginese
     77    // 1A20..1AAF; Tai Tham
     78    // 1AB0..1AFF; Combining Diacritical Marks Extended
     79    // 1B00..1B7F; Balinese
     80    // 1B80..1BBF; Sundanese
     81    // 1BC0..1BFF; Batak
     82    // 1C00..1C4F; Lepcha
     83    // 1C50..1C7F; Ol Chiki
     84    // 1CC0..1CCF; Sundanese Supplement
     85    // 1CD0..1CFF; Vedic Extensions
     86    // 1D00..1D7F; Phonetic Extensions
     87    // 1D80..1DBF; Phonetic Extensions Supplement
     88    // 1DC0..1DFF; Combining Diacritical Marks Supplement
     89    // 1E00..1EFF; Latin Extended Additional
     90    // 1F00..1FFF; Greek Extended
     91    {0x2000, 0x4DFF}, {0x2000, 0x2FFF},
     92    {0x3000, 0x4DFF},
     93    {0x4E00, 0x9FFF},
     94    // 4E00..9FFF; CJK Unified Ideographs
     95    {0xA000, 0xFFFF},
     96
     97    {0x10000, 0x10FFFF}};
     98
     99const UCDCompiler::RangeList UCDCompiler::noIfHierachy = {{0x10000, 0x10FFFF}};
    11100
    12101/** ------------------------------------------------------------------------------------------------------------- *
     
    358447/** ------------------------------------------------------------------------------------------------------------- *
    359448 * @brief generateWithDefaultIfHierarchy
    360  * @param set the unicode set to generate
    361  * @param the entry block to the function we're filling
    362  * @return the output stream with a 1-bit in any position of a character in the unicode set
    363  ** ------------------------------------------------------------------------------------------------------------- */
    364 std::vector<PabloAST *> UCDCompiler::generateWithDefaultIfHierarchy(const std::vector<UnicodeSet> & sets, PabloBuilder & entry) {
    365 
    366     const RangeList defaultIfHierachy = {
    367         // Non-ASCII
    368         {0x80, 0x10FFFF},
    369         // Two-byte sequences
    370         {0x80, 0x7FF},
    371         {0x100, 0x3FF},
    372         // 0100..017F; Latin Extended-A
    373         // 0180..024F; Latin Extended-B
    374         // 0250..02AF; IPA Extensions
    375         // 02B0..02FF; Spacing Modifier Letters
    376         {0x100, 0x2FF}, {0x100, 0x24F}, {0x100, 0x17F}, {0x180, 0x24F}, {0x250, 0x2AF}, {0x2B0, 0x2FF},
    377         // 0300..036F; Combining Diacritical Marks
    378         // 0370..03FF; Greek and Coptic
    379         {0x300, 0x36F}, {0x370, 0x3FF},
    380         // 0400..04FF; Cyrillic
    381         // 0500..052F; Cyrillic Supplement
    382         // 0530..058F; Armenian
    383         // 0590..05FF; Hebrew
    384         // 0600..06FF; Arabic
    385         {0x400, 0x5FF}, {0x400, 0x4FF}, {0x500, 0x058F}, {0x500, 0x52F}, {0x530, 0x58F}, {0x590, 0x5FF}, {0x600, 0x6FF},
    386         // 0700..074F; Syriac
    387         // 0750..077F; Arabic Supplement
    388         // 0780..07BF; Thaana
    389         // 07C0..07FF; NKo
    390         {0x700, 0x77F}, {0x700, 0x74F}, {0x750, 0x77F}, {0x780, 0x7FF}, {0x780, 0x7BF}, {0x7C0, 0x7FF},
    391         // Three-byte sequences
    392         {0x800, 0xFFFF}, {0x800, 0x4DFF}, {0x800, 0x1FFF}, {0x800, 0x0FFF},
    393         // 0800..083F; Samaritan
    394         // 0840..085F; Mandaic
    395         // 08A0..08FF; Arabic Extended-A
    396         // 0900..097F; Devanagari
    397         // 0980..09FF; Bengali
    398         // 0A00..0A7F; Gurmukhi
    399         // 0A80..0AFF; Gujarati
    400         // 0B00..0B7F; Oriya
    401         // 0B80..0BFF; Tamil
    402         // 0C00..0C7F; Telugu
    403         // 0C80..0CFF; Kannada
    404         // 0D00..0D7F; Malayalam
    405         // 0D80..0DFF; Sinhala
    406         // 0E00..0E7F; Thai
    407         // 0E80..0EFF; Lao
    408         // 0F00..0FFF; Tibetan
    409         {0x1000, 0x1FFF},
    410         // 1000..109F; Myanmar
    411         // 10A0..10FF; Georgian
    412         // 1100..11FF; Hangul Jamo
    413         // 1200..137F; Ethiopic
    414         // 1380..139F; Ethiopic Supplement
    415         // 13A0..13FF; Cherokee
    416         // 1400..167F; Unified Canadian Aboriginal Syllabics
    417         // 1680..169F; Ogham
    418         // 16A0..16FF; Runic
    419         // 1700..171F; Tagalog
    420         // 1720..173F; Hanunoo
    421         // 1740..175F; Buhid
    422         // 1760..177F; Tagbanwa
    423         // 1780..17FF; Khmer
    424         // 1800..18AF; Mongolian
    425         // 18B0..18FF; Unified Canadian Aboriginal Syllabics Extended
    426         // 1900..194F; Limbu
    427         // 1950..197F; Tai Le
    428         // 1980..19DF; New Tai Lue
    429         // 19E0..19FF; Khmer Symbols
    430         // 1A00..1A1F; Buginese
    431         // 1A20..1AAF; Tai Tham
    432         // 1AB0..1AFF; Combining Diacritical Marks Extended
    433         // 1B00..1B7F; Balinese
    434         // 1B80..1BBF; Sundanese
    435         // 1BC0..1BFF; Batak
    436         // 1C00..1C4F; Lepcha
    437         // 1C50..1C7F; Ol Chiki
    438         // 1CC0..1CCF; Sundanese Supplement
    439         // 1CD0..1CFF; Vedic Extensions
    440         // 1D00..1D7F; Phonetic Extensions
    441         // 1D80..1DBF; Phonetic Extensions Supplement
    442         // 1DC0..1DFF; Combining Diacritical Marks Supplement
    443         // 1E00..1EFF; Latin Extended Additional
    444         // 1F00..1FFF; Greek Extended
    445         {0x2000, 0x4DFF}, {0x2000, 0x2FFF},
    446         {0x3000, 0x4DFF},
    447         {0x4E00, 0x9FFF},
    448         // 4E00..9FFF; CJK Unified Ideographs
    449         {0xA000, 0xFFFF},
    450 
    451         {0x10000, 0x10FFFF}};
    452 
    453     addTargets(sets);
     449 ** ------------------------------------------------------------------------------------------------------------- */
     450void UCDCompiler::generateWithDefaultIfHierarchy(NameMap & names, PabloBuilder & entry) {
     451    addTargets(names);
    454452    generateRange(defaultIfHierachy, entry);
    455     return std::move(returnMarkers(sets));
     453    updateNames(names);
     454}
     455
     456/** ------------------------------------------------------------------------------------------------------------- *
     457 * @brief generateWithDefaultIfHierarchy
     458 ** ------------------------------------------------------------------------------------------------------------- */
     459PabloAST * UCDCompiler::generateWithDefaultIfHierarchy(const UnicodeSet * set, PabloBuilder & entry) {
     460    // mTargetMap.insert(std::make_pair<const UnicodeSet *, PabloAST *>(set, PabloBlock::createZeroes()));
     461    mTargetMap.emplace(set, PabloBlock::createZeroes());
     462    generateRange(defaultIfHierachy, entry);
     463    return mTargetMap.begin()->second;
    456464}
    457465
    458466/** ------------------------------------------------------------------------------------------------------------- *
    459467 * @brief generateWithoutIfHierarchy
    460  * @param set the unicode set to generate
    461  * @param the entry block to the function we're filling
    462  * @return the output stream with a 1-bit in any position of a character in the unicode set
    463  ** ------------------------------------------------------------------------------------------------------------- */
    464 std::vector<PabloAST *> UCDCompiler::generateWithoutIfHierarchy(const std::vector<UnicodeSet> & sets, PabloBuilder & entry) {
    465     const RangeList noIfHierachy = {{0x10000, 0x10FFFF}};
    466 
    467     addTargets(sets);
     468 ** ------------------------------------------------------------------------------------------------------------- */
     469void UCDCompiler::generateWithoutIfHierarchy(NameMap & names, PabloBuilder & entry) {
     470    addTargets(names);
    468471    generateRange(noIfHierachy, entry);
    469     return std::move(returnMarkers(sets));
     472    updateNames(names);
     473}
     474
     475/** ------------------------------------------------------------------------------------------------------------- *
     476 * @brief generateWithoutIfHierarchy
     477 ** ------------------------------------------------------------------------------------------------------------- */
     478PabloAST * UCDCompiler::generateWithoutIfHierarchy(const UnicodeSet * set, PabloBuilder & entry) {
     479    mTargetMap.emplace(set, PabloBlock::createZeroes());
     480    generateRange(noIfHierachy, entry);
     481    return mTargetMap.begin()->second;
    470482}
    471483
     
    473485 * @brief addTargets
    474486 ** ------------------------------------------------------------------------------------------------------------- */
    475 inline void UCDCompiler::addTargets(const std::vector<UnicodeSet> &sets) {
    476     for (const UnicodeSet & set : sets) {
    477         mTargetMap.emplace(&set, PabloBlock::createZeroes());
    478     }
    479 }
    480 
    481 /** ------------------------------------------------------------------------------------------------------------- *
    482  * @brief returnMarkers
    483  ** ------------------------------------------------------------------------------------------------------------- */
    484 inline std::vector<PabloAST *> UCDCompiler::returnMarkers(const std::vector<UnicodeSet> & sets) const {
    485     std::vector<PabloAST *> markers(sets.size());
    486     unsigned i = 0;
    487     for (const UnicodeSet & set : sets) {
    488         auto f = mTargetMap.find(&set);
    489         assert (f != mTargetMap.end());
    490         assert (f->second);
    491         markers[i++] = f->second;
    492     }
    493     return std::move(markers);
     487inline void UCDCompiler::addTargets(const NameMap & names) {
     488    for (const auto t : names) {
     489        if (isa<CC>(t.first->getDefinition())) {
     490            mTargetMap.emplace(cast<CC>(t.first->getDefinition()), t.second ? t.second : PabloBlock::createZeroes());
     491        } else {
     492            throw std::runtime_error(t.first->getName() + " is not defined by a CC!");
     493        }
     494    }
     495    assert (mTargetMap.size() > 0);
     496}
     497
     498/** ------------------------------------------------------------------------------------------------------------- *
     499 * @brief updateNames
     500 ** ------------------------------------------------------------------------------------------------------------- */
     501inline void UCDCompiler::updateNames(NameMap & names) {
     502    for (auto & t : names) {
     503        auto f = mTargetMap.find(cast<CC>(t.first->getDefinition()));
     504        t.second = f->second;
     505    }
     506    mTargetMap.clear();
    494507}
    495508
  • icGREP/icgrep-devel/icgrep/UCD/ucd_compiler.hpp

    r4808 r4814  
    1212namespace cc {
    1313    class CC_Compiler;
     14}
     15
     16namespace re {
     17    class Name;
    1418}
    1519
     
    3842    using TargetVector = std::vector<Target>;
    3943
     44    static const RangeList defaultIfHierachy;
     45    static const RangeList noIfHierachy;
     46
    4047public:
     48
     49    #ifdef USE_BOOST
     50    using NameMap = boost::container::flat_map<re::Name *, PabloAST *>;
     51    #else
     52    using NameMap = std::unordered_map<re::Name *, PabloAST *>;
     53    #endif
     54
    4155    UCDCompiler(cc::CC_Compiler & ccCompiler);
    4256
    43     std::vector<PabloAST *> generateWithDefaultIfHierarchy(const std::vector<UnicodeSet> &sets, PabloBuilder & entry);
     57    void generateWithDefaultIfHierarchy(NameMap & names, PabloBuilder & entry);
    4458
    45     std::vector<PabloAST *> generateWithoutIfHierarchy(const std::vector<UnicodeSet> & sets, PabloBuilder & entry);
     59    void generateWithoutIfHierarchy(NameMap & names, PabloBuilder & entry);
     60
     61    PabloAST * generateWithDefaultIfHierarchy(const UnicodeSet * set, PabloBuilder & entry);
     62
     63    PabloAST * generateWithoutIfHierarchy(const UnicodeSet * set, PabloBuilder & entry);
    4664
    4765protected:
     
    7492    static RangeList innerRanges(const RangeList & list);
    7593
    76     void addTargets(const std::vector<UnicodeSet> & sets);
     94    void addTargets(const NameMap & names);
    7795
    78     std::vector<PabloAST *> returnMarkers(const std::vector<UnicodeSet> &sets) const;
     96    void updateNames(NameMap & names);
    7997
    8098private:
  • icGREP/icgrep-devel/icgrep/generate_predefined_ucd_functions.cpp

    r4808 r4814  
    252252    // Build the unicode set function
    253253    PabloAST * result = nullptr;
    254     std::vector<UnicodeSet> sets;
    255     sets.push_back(std::move(set));
    256254    if (IfHierarchyStrategy == IfHierarchy::DefaultIfHierarchy) {
    257         result = ucdCompiler.generateWithDefaultIfHierarchy(sets, builder).front();
     255        result = ucdCompiler.generateWithDefaultIfHierarchy(&set, builder);
    258256    } else if (IfHierarchyStrategy == IfHierarchy::NoIfHierarchy) {
    259         result = ucdCompiler.generateWithoutIfHierarchy(sets, builder).front();
     257        result = ucdCompiler.generateWithoutIfHierarchy(&set, builder);
    260258    } else {
    261259        throw std::runtime_error("Unknown if hierarchy strategy!");
  • icGREP/icgrep-devel/icgrep/icgrep-devel.files

    r4808 r4814  
    343343toolchain.h
    344344toolchain.cpp
     345re/re_compiler.cpp
     346re/re_compiler.h
     347re/re_cc.cpp
     348re/re_cc.h
     349re/re_parser.cpp
     350re/re_name.h
     351re/re_parser.h
     352re/re_nullable.cpp
     353re/printer_re.cpp
     354re/re_analysis.cpp
     355re/re_diff.h
     356re/re_assertion.h
     357re/re_re.h
     358re/re_end.h
     359re/re_simplifier.h
     360re/re_diff.cpp
     361re/re_re.cpp
     362re/re_intersect.h
     363re/re_simplifier.cpp
     364re/re_nullable.h
     365re/re_start.h
     366re/parsefailure.h
     367re/re_intersect.cpp
     368re/re_seq.h
     369re/parsefailure.cpp
     370re/re_any.h
     371re/re_rep.h
     372re/printer_re.h
     373re/re_analysis.h
     374re/re_rep.cpp
     375re/re_alt.h
  • icGREP/icgrep-devel/icgrep/re/re_cc.cpp

    r4812 r4814  
    1414CC::CC(const CC * cc1, const CC * cc2)
    1515: RE(ClassTypeId::CC)
    16 , mSparseCharSet(std::move(cc1->mSparseCharSet + cc2->mSparseCharSet)) {
     16, UCD::UnicodeSet(std::move(*cc1 + *cc2)) {
    1717
    1818}
     
    2020CC::CC(const CC & cc)
    2121: RE(ClassTypeId::CC)
    22 , mSparseCharSet(cc.mSparseCharSet) {
     22, UCD::UnicodeSet(cc) {
    2323
    2424}
     
    3333    }
    3434    char separator = '_';
    35     for (const interval_t & i : mSparseCharSet) {
     35    for (const interval_t & i : *this) {
    3636        name << separator;
    3737        if (lo_codepoint(i) == hi_codepoint(i)) {
     
    4545    return name.str();
    4646}
    47 
    48 CC * subtractCC(const CC * a, const CC * b) {
    49     return makeCC(a->mSparseCharSet - b->mSparseCharSet);
    50 }
    51    
    52 CC * intersectCC(const CC * a, const CC * b) {
    53     return makeCC(a->mSparseCharSet & b->mSparseCharSet);
    54 }
    5547   
    5648CC * caseInsensitize(const CC * cc) {
  • icGREP/icgrep-devel/icgrep/re/re_cc.h

    r4812 r4814  
    2222enum CC_type {UnicodeClass, ByteClass};
    2323
    24 class CC : public RE {
     24class CC : public RE, public UCD::UnicodeSet {
    2525public:
    2626
     
    3232    }
    3333
    34     using iterator = UCD::UnicodeSet::iterator;
    35     using size_type = UCD::UnicodeSet::size_type;
    3634
    3735    std::string canonicalName(const CC_type type) const;
    3836
    3937    inline codepoint_t min_codepoint() const {
    40         return mSparseCharSet.front().first;
     38        return front().first;
    4139    }
    4240
    4341    inline codepoint_t max_codepoint() const {
    44         return mSparseCharSet.back().second;
    45     }
    46 
    47     void insert_range(const codepoint_t lo, const codepoint_t hi) {
    48         mSparseCharSet.insert_range(lo, hi);
    49     }
    50 
    51     inline void insert(const codepoint_t codepoint) {
    52         mSparseCharSet.insert(codepoint);
    53     }
    54 
    55     inline iterator begin() const {
    56         return mSparseCharSet.begin();
    57     }
    58 
    59     inline iterator end() const {
    60         return mSparseCharSet.end();
    61     }
    62 
    63     inline interval_t front() const {
    64         return mSparseCharSet.front();
    65     }
    66 
    67     inline interval_t back() const {
    68         return mSparseCharSet.back();
    69     }
    70 
    71     inline size_type size() const {
    72         return mSparseCharSet.size();
    73     }
    74 
    75     inline bool empty() const {
    76         return mSparseCharSet.empty();
     42        return back().second;
    7743    }
    7844
     
    9258
    9359    inline CC()
    94     : RE(ClassTypeId::CC)
    95     , mSparseCharSet() {
     60    : RE(ClassTypeId::CC) {
    9661
    9762    }
     63
    9864    CC(const CC & cc);
     65
    9966    inline CC(const codepoint_t codepoint)
    10067    : RE(ClassTypeId::CC)
    101     , mSparseCharSet(codepoint) {
     68    , UCD::UnicodeSet(codepoint) {
    10269
    10370    }
     71
    10472    inline CC(const codepoint_t lo_codepoint, const codepoint_t hi_codepoint)
    10573    : RE(ClassTypeId::CC)
    106     , mSparseCharSet(lo_codepoint, hi_codepoint) {
     74    , UCD::UnicodeSet(lo_codepoint, hi_codepoint) {
    10775
    10876    }
     77
    10978    CC(const CC * cc1, const CC * cc2);
    11079
    11180    inline CC(UCD::UnicodeSet && set)
    11281    : RE(ClassTypeId::CC)
    113     , mSparseCharSet(std::move(set)) {
     82    , UCD::UnicodeSet(std::move(set)) {
    11483
    11584    }
     
    11786    template <typename itr>
    11887    CC * initialize(itr begin, itr end);
    119 private:   
    120     UCD::UnicodeSet mSparseCharSet;
     88
    12189};
    12290
     
    146114CC * CC::initialize(itr begin, itr end) {
    147115    for (auto i = begin; i != end; ++i) {
    148         mSparseCharSet.insert_range(i->first, i->second);
     116        insert_range(i->first, i->second);
    149117    }
    150118    return this;
     
    184152
    185153inline CC * makeCC(UCD::UnicodeSet && set) {
    186     return makeCC(std::move(set));
     154    return new CC(std::move(set));
    187155}
    188156
    189 CC * subtractCC(const CC * a, const CC * b);
    190    
    191 CC * intersectCC(const CC * cc1, const CC * cc2);
     157inline CC * subtractCC(const CC * a, const CC * b) {
     158    return makeCC(std::move(*a - *b));
     159}
     160
     161inline CC * intersectCC(const CC * a, const CC * b) {
     162    return makeCC(std::move(*a & *b));
     163}
    192164
    193165CC * caseInsensitize(const CC * cc);
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4809 r4814  
    2929#include <iostream>
    3030#include <pablo/printer_pablos.h>
     31#ifdef USE_BOOST
     32#include <boost/container/flat_set.hpp>
     33#else
     34#include <unordered_set>
     35#endif
    3136
    3237#include "llvm/Support/CommandLine.h"
     
    4651                     cl::desc("set mod64 approximate mode"), cl::cat(fREcompilationOptions));
    4752#ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    48 static cl::opt<bool> UsePregeneratedUnicode("use-pregenerated-unicode", cl::init(true),
     53static cl::opt<bool> UsePregeneratedUnicode("use-pregenerated-unicode", cl::init(false),
    4954                     cl::desc("use fixed pregenerated Unicode character class sets instead"), cl::cat(fREcompilationOptions));
    5055#endif
     
    5863, mCRLF(nullptr)
    5964, mUnicodeLineBreak(nullptr)
     65, mNonLineBreak(nullptr)
    6066, mInitial(nullptr)
    6167, mNonFinal(nullptr)
     
    176182    mUnicodeLineBreak = mPB.createAnd(LB_chars, mPB.createNot(mCRLF));  // count the CR, but not CRLF
    177183    PabloAST * const lb = UNICODE_LINE_BREAK ? mUnicodeLineBreak : mLineFeed;
     184    mNonLineBreak = mPB.createNot(lb);
    178185    mFunction.setResult(1, mPB.createAssign("lf", mPB.createAnd(lb, mPB.createNot(mCRLF))));
    179186}
    180187
    181 void RE_Compiler::gatherUnicodePropertyNames(RE * re, NameSet & nameSet) {
    182 
    183     struct UnicodePropertyNameMap {
    184         using PropertyMap = std::map<std::string, Name *>;
    185         using NamespacedPropertyMap = std::map<std::pair<std::string, std::string>, Name *>;
    186         void process(RE * re) {
     188
     189RE * RE_Compiler::resolveUnicodeProperties(RE * re) {
     190
     191    using PropertyMap = std::map<std::string, RE *>;
     192    using NamespacedPropertyMap = std::map<std::pair<std::string, std::string>, RE *>;
     193    using NameMap = UCD::UCDCompiler::NameMap;
     194
     195    struct UnicodePropertyResolver {
     196
     197        static inline CC * getNamedCC(RE * re) {
     198            if (LLVM_LIKELY(isa<Name>(re))) {
     199                Name * name = cast<Name>(re);
     200                if (name->getDefinition() && isa<CC>(name->getDefinition())) {
     201                    return cast<CC>(name->getDefinition());
     202                }
     203            }
     204            return nullptr;
     205        }
     206
     207        RE * resolve(RE * re) {
    187208            if (Name * name = dyn_cast<Name>(re)) {
    188                 if (name->getDefinition()) {
    189                     process(name->getDefinition());
    190                     return;
    191                 }
    192                 if (name->hasNamespace()) {
    193                     const auto f = mNamespacedPropertyMap.find(std::make_pair(name->getNamespace(), name->getName()));
    194                     if (f != mNamespacedPropertyMap.end()) {
    195                         if (f->second != name) {
    196                             name->setDefinition(f->second);
     209                if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
     210                    name->setDefinition(resolve(name->getDefinition()));
     211                } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty)) {
     212                    // Attempt to look up an equivalently named Name object
     213                    if (name->hasNamespace()) {
     214                        const auto f = mNamespacedPropertyMap.find(std::make_pair(name->getNamespace(), name->getName()));
     215                        if (f != mNamespacedPropertyMap.end()) {
     216                            if (f->second != name) {
     217                                return f->second;
     218                            }
    197219                        }
    198                         return;
     220                        mNamespacedPropertyMap.insert(std::make_pair(std::make_pair(name->getNamespace(), name->getName()), name));
     221                    } else {
     222                        const auto f = mPropertyMap.find(name->getName());
     223                        if (f != mPropertyMap.end()) {
     224                            if (f->second != name) {
     225                                return f->second;
     226                            }
     227                        }
     228                        mPropertyMap.insert(std::make_pair(name->getName(), name));
    199229                    }
    200                     mNamespacedPropertyMap.insert(std::make_pair(std::make_pair(name->getNamespace(), name->getName()), name));
     230                    if (UCD::resolvePropertyDefinition(name)) {
     231                        resolve(name->getDefinition());
     232                    } else {
     233                        #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     234                        if (UsePregeneratedUnicode) {
     235                            const std::string functionName = UCD::resolvePropertyFunction(name);
     236                            const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
     237                            Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
     238                            name->setCompiled(mPB.createAnd(call, mNonLineBreak));
     239                        } else {
     240                        #endif
     241                            name->setDefinition(makeCC(std::move(UCD::resolveUnicodeSet(name))));
     242                        #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     243                        }
     244                        #endif
     245                    }
    201246                } else {
    202                     const auto f = mPropertyMap.find(name->getName());
    203                     if (f != mPropertyMap.end()) {
    204                         if (f->second != name) {
    205                             name->setDefinition(f->second);
    206                         }
    207                         return;
     247                    throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
     248                }
     249            } else if (Seq * seq = dyn_cast<Seq>(re)) {
     250                for (auto si = seq->begin(); si != seq->end(); ) {
     251                    RE * re = resolve(*si);
     252                    if (LLVM_UNLIKELY(isa<Seq>(re))) {
     253                        auto sj = cast<Seq>(re)->begin();
     254                        *si = *sj;
     255                        si = seq->insert(++si, ++sj, cast<Seq>(re)->end());
     256                    } else {
     257                        *si++ = re;
    208258                    }
    209                     mPropertyMap.insert(std::make_pair(name->getName(), name));
    210                 }
    211                 if (name->getType() == Name::Type::UnicodeProperty) {
    212                     RE * definition = UCD::resolvePropertyDefinition(name);
    213                     if (definition) {
    214                         process(definition);
     259                }
     260            } else if (Alt * alt = dyn_cast<Alt>(re)) {
     261                CC * unionCC = nullptr;
     262                for (auto ai = alt->begin(); ai != alt->end(); ) {
     263                    RE * re = resolve(*ai);
     264                    if (CC * cc = getNamedCC(re)) {
     265                        unionCC = (unionCC == nullptr) ? cc : makeCC(unionCC, cc);
     266                        ai = alt->erase(ai);
     267                    } else if (LLVM_UNLIKELY(isa<Alt>(re))) {
     268                        auto aj = cast<Alt>(re)->begin();
     269                        *ai = *aj;
     270                        ai = alt->insert(++ai, ++aj, cast<Alt>(re)->end());
    215271                    } else {
    216                         mNameSet.insert(name);
     272                        *ai++ = re;
    217273                    }
    218274                }
    219             } else if (Seq* seq = dyn_cast<Seq>(re)) {
    220                 for (RE * re : *seq) {
    221                     process(re);
     275                if (unionCC) {
     276                    alt->push_back(makeName("union", unionCC));
     277                }
     278                if (alt->size() == 1) {
     279                    return alt->front();
     280                }
     281            } else if (Rep * rep = dyn_cast<Rep>(re)) {
     282                rep->setRE(resolve(rep->getRE()));
     283            } else if (Assertion * a = dyn_cast<Assertion>(re)) {
     284                a->setAsserted(resolve(a->getAsserted()));
     285            } else if (Diff * diff = dyn_cast<Diff>(re)) {
     286                diff->setLH(resolve(diff->getLH()));
     287                diff->setRH(resolve(diff->getRH()));
     288                #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     289                if (!UsePregeneratedUnicode) {
     290                #endif
     291                    CC * lh = getNamedCC(diff->getLH());
     292                    CC * rh = getNamedCC(diff->getRH());
     293                    if (lh && rh) {
     294                        return resolve(makeName("diff", subtractCC(lh, rh)));
     295                    }
     296                #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     297                }
     298                #endif
     299            } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
     300                ix->setLH(resolve(ix->getLH()));
     301                ix->setRH(resolve(ix->getRH()));
     302                #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     303                if (!UsePregeneratedUnicode) {
     304                #endif
     305                    CC * lh = getNamedCC(diff->getLH());
     306                    CC * rh = getNamedCC(diff->getRH());
     307                    if (lh && rh) {
     308                        return resolve(makeName("intersect", intersectCC(lh, rh)));
     309                    }
     310                #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     311                }
     312                #endif
     313            }
     314            return re;
     315        }
     316
     317        static void collect(RE * re, NameMap & nameMap) {
     318            if (Name * name = dyn_cast<Name>(re)) {
     319                if (isa<CC>(name->getDefinition())) {
     320                    nameMap.emplace(name, nullptr);
     321                } else {
     322                    collect(name->getDefinition(), nameMap);
     323                }
     324            } else if (Seq * seq = dyn_cast<Seq>(re)) {
     325                for (auto re : *seq) {
     326                    collect(re, nameMap);
    222327                }
    223328            } else if (Alt * alt = dyn_cast<Alt>(re)) {
    224                 for (RE * re : *alt) {
    225                     process(re);
     329                for (auto re : *alt) {
     330                    collect(re, nameMap);
    226331                }
    227332            } else if (Rep * rep = dyn_cast<Rep>(re)) {
    228                 process(rep->getRE());
     333                collect(rep->getRE(), nameMap);
    229334            } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    230                 process(a->getAsserted());
     335                collect(a->getAsserted(), nameMap);
    231336            } else if (Diff * diff = dyn_cast<Diff>(re)) {
    232                 process(diff->getLH());
    233                 process(diff->getRH());
    234             } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    235                 process(ix->getLH());
    236                 process(ix->getRH());
     337                collect(diff->getLH(), nameMap);
     338                collect(diff->getRH(), nameMap);
    237339            }
    238 
    239         }
    240 
    241         UnicodePropertyNameMap(NameSet & nameSet) : mNameSet(nameSet) {}
     340        }
    242341
    243342    private:
    244         NameSet &                   mNameSet;
    245343        PropertyMap                 mPropertyMap;
    246344        NamespacedPropertyMap       mNamespacedPropertyMap;
    247     } ;
    248 
    249     UnicodePropertyNameMap(nameSet).process(re);
    250 }
    251 
    252 void RE_Compiler::compileUnicodeNames(RE * re) {
    253     NameSet nameSet;
    254     gatherUnicodePropertyNames(re, nameSet);
    255 #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    256     if (UsePregeneratedUnicode) {
    257         for (Name * name : nameSet) {
    258             const std::string functionName = UCD::resolvePropertyFunction(name);
    259             const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
    260             Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
    261             name->setCompiled(mPB.createAnd(call, mPB.createNot(UNICODE_LINE_BREAK ? mUnicodeLineBreak : mLineFeed)));
    262         }
    263     } else {
    264 #endif
    265         std::vector<UCD::UnicodeSet> sets;
    266         for (Name * name : nameSet) {
    267             sets.push_back(std::move(UCD::resolveUnicodeSet(name)));
    268         }
    269         if (sets.size() > 0) {
    270             UCD::UCDCompiler ucdCompiler(mCCCompiler);
    271             std::vector<PabloAST *> classes(std::move(ucdCompiler.generateWithDefaultIfHierarchy(sets, mPB)));
    272             auto value = classes.begin();
    273             for (Name * name : nameSet) {
    274                 name->setCompiled(mPB.createAnd(*value++, mPB.createNot(UNICODE_LINE_BREAK ? mUnicodeLineBreak : mLineFeed)));
     345    };
     346
     347    UnicodePropertyResolver resolver;
     348    re = resolver.resolve(re);
     349    #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     350    if (UsePregeneratedUnicode) return re;
     351    #endif
     352    NameMap nameMap;
     353    resolver.collect(re, nameMap);
     354
     355    if (nameMap.size() > 0) {
     356        UCD::UCDCompiler ucdCompiler(mCCCompiler);
     357        ucdCompiler.generateWithDefaultIfHierarchy(nameMap, mPB);
     358        for (auto t : nameMap) {
     359            if (t.second) {
     360                t.first->setCompiled(mPB.createAnd(t.second, mNonLineBreak));
    275361            }
    276362        }
    277 #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    278     }
    279 #endif
     363    }
     364
     365    return re;
     366}
     367
     368void RE_Compiler::compileUnicodeNames(RE *& re) {
     369    re = resolveUnicodeProperties(re);
    280370}
    281371
    282372void RE_Compiler::finalizeMatchResult(MarkerType match_result) {
    283     //These three lines are specifically for grep.
    284     PabloAST * lb = UNICODE_LINE_BREAK ? mUnicodeLineBreak : mLineFeed;
    285     PabloAST * v = markerVar(match_result);
    286     mFunction.setResult(0, mPB.createAssign("matches", mPB.createAnd(mPB.createMatchStar(v, mPB.createNot(lb)), lb)));
     373    mFunction.setResult(0, mPB.createAssign("matches", mPB.createAnd(mPB.createMatchStar(markerVar(match_result), mNonLineBreak), UNICODE_LINE_BREAK ? mUnicodeLineBreak : mLineFeed)));
    287374}
    288375
     
    294381    if (markerPos(m) == MarkerPosition::FinalPostPositionByte) {
    295382        return markerVar(m);
    296     }
    297     else if (markerPos(m) == MarkerPosition::InitialPostPositionByte) {
     383    } else if (markerPos(m) == MarkerPosition::InitialPostPositionByte) {
    298384        return pb.createScanThru(pb.createAnd(mInitial, markerVar(m)), mNonFinal);
    299     }
    300     else {
     385    } else {
    301386        return pb.createScanThru(pb.createAnd(mInitial, pb.createAdvance(markerVar(m), 1)), mNonFinal);
    302387    }
     
    371456    if (LLVM_LIKELY(var != nullptr)) {
    372457        return var;
    373     } else if (name->getDefinition() != nullptr) {
     458    } else if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    374459        MarkerType m = compile(name->getDefinition(), pb);
    375460        assert(markerPos(m) == MarkerPosition::FinalMatchByte);
    376         var = markerVar(m);
     461        var = pb.createAnd(markerVar(m), mNonLineBreak);
     462        name->setCompiled(var);
     463        return var;
    377464    } else {
    378465        throw std::runtime_error("Unresolved name " + name->getName());
    379466    }
    380     var = pb.createAnd(var, pb.createNot(UNICODE_LINE_BREAK ? mUnicodeLineBreak : mLineFeed));
    381     name->setCompiled(var);
    382     return var;
    383467}
    384468
  • icGREP/icgrep-devel/icgrep/re/re_compiler.h

    r4808 r4814  
    1212#include <cc/cc_compiler.h>
    1313#include <pablo/builder.hpp>
    14 #ifdef USE_BOOST
    15 #include <boost/container/flat_set.hpp>
    16 #else
    17 #include <unordered_set>
    18 #endif
    1914
    2015namespace pablo {
     
    5954    RE_Compiler(pablo::PabloFunction & function, cc::CC_Compiler & ccCompiler);
    6055    void initializeRequiredStreams();
    61     void compileUnicodeNames(RE * re);
     56    void compileUnicodeNames(RE *& re);
    6257    void finalizeMatchResult(MarkerType match_result);
    6358    MarkerType compile(RE * re) {
     
    6661
    6762private:
    68 
    69     #ifdef USE_BOOST
    70     using NameSet = boost::container::flat_set<Name *>;
    71     #else
    72     using NameSet = std::unordered_set<Name *>;
    73     #endif
    7463
    7564    MarkerType compile(RE * re, pablo::PabloBuilder & cg);
     
    9584    MarkerType processUnboundedRep(RE * repeated, MarkerType marker, pablo::PabloBuilder & pb);
    9685    MarkerType processBoundedRep(RE * repeated, int ub, MarkerType marker, pablo::PabloBuilder & pb);
    97     static void gatherUnicodePropertyNames(RE * re, NameSet & nameSet);
     86    RE * resolveUnicodeProperties(RE * re);
    9887
    9988private:
     
    10392    pablo::PabloAST *                               mCRLF;
    10493    pablo::PabloAST *                               mUnicodeLineBreak;
     94    pablo::PabloAST *                               mNonLineBreak;
    10595    pablo::PabloAST *                               mInitial;
    10696    pablo::Assign *                                 mNonFinal;
  • icGREP/icgrep-devel/icgrep/toolchain.cpp

    r4808 r4814  
    110110        std::cerr << "NameMap:\n" << nameMap.printMap() << std::endl;
    111111    }
    112    
    113     //Add the UTF encoding.
    114     if (encoding.getType() == Encoding::Type::UTF_8) {
    115         re_ast = cc::UTF8_Encoder::toUTF8(nameMap, re_ast);
    116         if (PrintAllREs || PrintUTF8REs) {
    117             //Print to the terminal the AST that was generated by the utf8 encoder.
    118             std::cerr << "UTF8-encoder:" << std::endl << Printer_RE::PrintRE(re_ast) << std::endl;
    119             std::cerr << "NameMap:\n" << nameMap.printMap() << std::endl;
    120         }
    121     }
    122    
     112
    123113    re_ast = re::RE_Simplifier::simplify(re_ast);
    124114    if (PrintAllREs || PrintSimplifiedREs) {
  • icGREP/icgrep-devel/icgrep/utf8_encoder.cpp

    r4665 r4814  
    66
    77#include <utf8_encoder.h>
    8 #include <re/re_name.h>
    9 #include <re/re_seq.h>
    10 #include <re/re_alt.h>
    11 #include <re/re_rep.h>
    12 #include <cc/cc_namemap.hpp>
    138#include <assert.h>
    149#include <algorithm>
     
    1813
    1914namespace cc {
    20 
    21 RE * UTF8_Encoder::toUTF8(CC_NameMap & nameMap, RE * ast) {
    22     for (Name * name : nameMap) {
    23         if (const CC * cc = dyn_cast_or_null<CC>(name->getDefinition())) {
    24             if (cc->size() == 1) {
    25                 name->setDefinition(rangeToUTF8(cc->front()));
    26             }
    27             else if (cc->size() > 1) {
    28                 std::vector<RE *> alt;
    29                 for (const interval_t & i : *cc) {
    30                     alt.push_back(rangeToUTF8(i));
    31                 }
    32                 name->setDefinition(makeAlt(alt.begin(), alt.end()));
    33             }
    34         }
    35     }
    36     return nameMap.process(ast, ByteClass);
    37 }
    38 
    39 RE * UTF8_Encoder::rangeToUTF8(const interval_t & item) {
    40     const auto min = length(lo_codepoint(item));
    41     const auto max = length(hi_codepoint(item));
    42     if (min < max) {
    43         const auto m = maxCodePoint(min);
    44         return makeAlt({rangeToUTF8(std::make_pair(lo_codepoint(item), m)), rangeToUTF8(std::make_pair(m + 1, hi_codepoint(item)))});
    45     }
    46     else {
    47         return rangeToUTF8(lo_codepoint(item), hi_codepoint(item), 1, max);
    48     }
    49 }
    50 
    51 RE * UTF8_Encoder::rangeToUTF8(const codepoint_t lo, const codepoint_t hi, const unsigned index, const unsigned max)
    52 {
    53     const codepoint_t hbyte = encodingByte(hi, index);
    54     const codepoint_t lbyte = encodingByte(lo, index);
    55     if (index == max) {
    56         return makeByteRange(lbyte, hbyte);
    57     }
    58     else if (hbyte == lbyte) {
    59         return makeSeq({makeByteClass(hbyte), rangeToUTF8(lo, hi, index + 1, max)});
    60     }
    61     else {
    62         const unsigned suffix_mask = (static_cast<unsigned>(1) << ((max - index) * 6)) - 1;
    63         if ((hi & suffix_mask) != suffix_mask) {
    64             const unsigned hi_floor = (~suffix_mask) & hi;
    65             return makeAlt({rangeToUTF8(hi_floor, hi, index, max), rangeToUTF8(lo, hi_floor - 1, index, max)});
    66         }
    67         else if ((lo & suffix_mask) != 0) {
    68             const unsigned low_ceil = lo | suffix_mask;
    69             return makeAlt({rangeToUTF8(low_ceil + 1, hi, index, max), rangeToUTF8(lo, low_ceil, index, max)});
    70         }
    71         else {
    72             return makeSeq({makeByteRange(lbyte, hbyte), rangeToUTF8(lo, hi, index + 1, max)});
    73         }
    74     }
    75 }
    7615
    7716bool UTF8_Encoder::isPrefix(const codepoint_t cp) {
     
    16099}
    161100
    162 inline CC * UTF8_Encoder::makeByteRange(const codepoint_t lo, const codepoint_t hi) {
    163     return makeCC(lo, hi);
    164101}
    165 
    166 inline CC * UTF8_Encoder::makeByteClass(const codepoint_t cp) {
    167     return makeCC(cp, cp);
    168 }
    169 
    170 }
  • icGREP/icgrep-devel/icgrep/utf8_encoder.h

    r4615 r4814  
    1616class CC_NameMap;
    1717
    18 class UTF8_Encoder {
    19 public:
    20     static re::RE * toUTF8(CC_NameMap & nameMap, re::RE * ast);
    21 
     18struct UTF8_Encoder {
    2219    static bool isPrefix(const re::codepoint_t cp);
    2320    static unsigned length(const re::codepoint_t cp);
     
    2825    static re::codepoint_t minCodePointWithCommonBytes(const re::codepoint_t cp, const unsigned n);
    2926    static re::codepoint_t maxCodePointWithCommonBytes(const re::codepoint_t cp, const unsigned n);
    30 private:
    31     static re::RE * rangeToUTF8(const re::interval_t & item);
    32     static re::RE * rangeToUTF8(const re::codepoint_t lo, const re::codepoint_t hi, const unsigned index, const unsigned max);
    33     static re::CC * makeByteClass(const re::codepoint_t cp);
    34     static re::CC * makeByteRange(const re::codepoint_t lo, const re::codepoint_t hi);
    3527};
    3628
Note: See TracChangeset for help on using the changeset viewer.