Ignore:
Timestamp:
Oct 3, 2015, 3:31:16 PM (4 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/UCD
Files:
4 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:
Note: See TracChangeset for help on using the changeset viewer.