Changeset 5158


Ignore:
Timestamp:
Sep 16, 2016, 7:16:51 PM (3 years ago)
Author:
cameron
Message:

Support for enumeration basis sets

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

Legend:

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

    r4818 r5158  
    7171}
    7272
     73std::vector<UnicodeSet *> EnumeratedPropertyObject::GetEnumerationBasisSets() {
     74    // Basis set i is the set of all codepoints whose numerical enumeration code e
     75    // has bit i set, i.e., (e >> i) & 1 == 1.
     76    unsigned basis_count = 1;
     77    while ((1 << basis_count) < independent_enum_limit) basis_count++;
     78    std::vector<UnicodeSet *> basis_set;
     79    for (unsigned i == 0; i < basis_count; i++) {
     80        basis_set.push_back(new UnicodeSet());
     81        for (unsigned e = 0; e < independent_enum_limit; e++) {
     82            if (((e >> i) & 1) == 0) {
     83                basis_set[i] = basis_set[i] + property_value_sets[e];
     84            }
     85        }
     86    }
     87};
     88
     89   
     90   
    7391PropertyObject::iterator ExtensionPropertyObject::begin() const {
    7492    if (const auto * obj = dyn_cast<EnumeratedPropertyObject>(property_object_table[base_property])) {
  • icGREP/icgrep-devel/icgrep/UCD/PropertyObjects.h

    r4818 r5158  
    8888    const UnicodeSet & GetCodepointSet(const std::string & value_spec);
    8989    const UnicodeSet & GetCodepointSet(const int property_enum_val) const;
     90    std::vector<UnicodeSet *> GetEnumerationBasisSets();
    9091    const std::string & GetValueEnumName(const int property_enum_val) const {return property_value_enum_names[property_enum_val]; }
    9192    const std::string & GetValueFullName(const int property_enum_val) const {return property_value_full_names[property_enum_val]; }
  • icGREP/icgrep-devel/icgrep/re/re_name_resolve.cpp

    r5120 r5158  
    3434    Memoizer memoizer;
    3535    if (Name * name = dyn_cast<Name>(re)) {
    36         auto f = memoizer.find(name);
    37         if (f == memoizer.end()) {
    38             if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    39                 name->setDefinition(resolve(name->getDefinition()));
    40             } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty || name->getType() == Name::Type::ZeroWidth)) {
    41                 if (UCD::resolvePropertyDefinition(name)) {
    42                     if (name->getType() == Name::Type::ZeroWidth) {
     36        auto f = memoizer.find(name);
     37        if (f == memoizer.end()) {
     38            if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
     39                name->setDefinition(resolve(name->getDefinition()));
     40            } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty || name->getType() == Name::Type::ZeroWidth)) {
     41                if (UCD::resolvePropertyDefinition(name)) {
     42                    if (name->getType() == Name::Type::ZeroWidth) {
    4343                        ZeroWidth = name;
    4444                    }
    4545                    resolve(name->getDefinition());
    46                 } else {
    47                     #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    48                     if (AlgorithmOptionIsSet(UsePregeneratedUnicode)) {
    49                         const std::string functionName = UCD::resolvePropertyFunction(name);
    50                         const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
    51                         Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
    52                         name->setCompiled(call);
    53                     } else {
    54                     #endif
    55                         name->setDefinition(makeCC(UCD::resolveUnicodeSet(name)));
    56                     #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    57                     }
    58                     #endif
    59                 }
    60             } else {
    61                 throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
    62             }
    63         } else {
    64             return *f;
    65         }
     46                } else {
     47                    #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     48                    if (AlgorithmOptionIsSet(UsePregeneratedUnicode)) {
     49                        const std::string functionName = UCD::resolvePropertyFunction(name);
     50                        const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
     51                        Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
     52                        name->setCompiled(call);
     53                    } else {
     54                    #endif
     55                        name->setDefinition(makeCC(UCD::resolveUnicodeSet(name)));
     56                    #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     57                    }
     58                    #endif
     59                }
     60            } else {
     61            throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
     62            }
     63        } else {
     64            return *f;
     65        }
    6666    } else if (Seq * seq = dyn_cast<Seq>(re)) {
    67         for (auto si = seq->begin(); si != seq->end(); ++si) {
    68             *si = resolve(*si);
    69         }
     67        for (auto si = seq->begin(); si != seq->end(); ++si) {
     68            *si = resolve(*si);
     69        }
    7070    } else if (Alt * alt = dyn_cast<Alt>(re)) {
    71         CC * unionCC = nullptr;
    72         std::stringstream name;
    73         for (auto ai = alt->begin(); ai != alt->end(); ) {
    74             RE * re = resolve(*ai);
    75             if (CC * cc = getDefinitionIfCC(re)) {
    76                 if (unionCC == nullptr) {
    77                     unionCC = cc;
    78                 } else {
    79                     unionCC = makeCC(unionCC, cc);
    80                     name << '+';
    81                 }
    82                 Name * n = cast<Name>(re);
    83                 if (n->hasNamespace()) {
    84                     name << n->getNamespace() << ':';
    85                 }
    86                 name << n->getName();
    87                 ai = alt->erase(ai);
    88             } else {
    89                 *ai++ = re;
    90             }
    91         }
    92         if (unionCC) {
    93             alt->push_back(makeName(name.str(), unionCC));
    94         }
    95         if (alt->size() == 1) {
    96             return alt->front();
    97         }
     71        CC * unionCC = nullptr;
     72        std::stringstream name;
     73        for (auto ai = alt->begin(); ai != alt->end(); ) {
     74            RE * re = resolve(*ai);
     75            if (CC * cc = getDefinitionIfCC(re)) {
     76                if (unionCC == nullptr) {
     77                    unionCC = cc;
     78                } else {
     79                    unionCC = makeCC(unionCC, cc);
     80                    name << '+';
     81                }
     82                Name * n = cast<Name>(re);
     83                if (n->hasNamespace()) {
     84                    name << n->getNamespace() << ':';
     85                }
     86                name << n->getName();
     87                ai = alt->erase(ai);
     88            } else {
     89                *ai++ = re;
     90            }
     91        }
     92        if (unionCC) {
     93            alt->push_back(makeName(name.str(), unionCC));
     94        }
     95        if (alt->size() == 1) {
     96            return alt->front();
     97        }
    9898    } else if (Rep * rep = dyn_cast<Rep>(re)) {
    99         rep->setRE(resolve(rep->getRE()));
     99        rep->setRE(resolve(rep->getRE()));
    100100    } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    101         a->setAsserted(resolve(a->getAsserted()));
     101        a->setAsserted(resolve(a->getAsserted()));
    102102    } else if (Diff * diff = dyn_cast<Diff>(re)) {
    103         diff->setLH(resolve(diff->getLH()));
    104         diff->setRH(resolve(diff->getRH()));
    105         CC * lh = getDefinitionIfCC(diff->getLH());
    106         CC * rh = getDefinitionIfCC(diff->getRH());
    107         if (lh && rh) {
    108             return resolve(makeName("diff", subtractCC(lh, rh)));
    109         }
     103        diff->setLH(resolve(diff->getLH()));
     104        diff->setRH(resolve(diff->getRH()));
     105        CC * lh = getDefinitionIfCC(diff->getLH());
     106        CC * rh = getDefinitionIfCC(diff->getRH());
     107        if (lh && rh) {
     108            return resolve(makeName("diff", subtractCC(lh, rh)));
     109        }
    110110    } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    111         ix->setLH(resolve(ix->getLH()));
    112         ix->setRH(resolve(ix->getRH()));
    113         CC * lh = getDefinitionIfCC(ix->getLH());
    114         CC * rh = getDefinitionIfCC(ix->getRH());
    115         if (lh && rh) {
    116             return resolve(makeName("intersect", intersectCC(lh, rh)));
    117         }
     111        ix->setLH(resolve(ix->getLH()));
     112        ix->setRH(resolve(ix->getRH()));
     113        CC * lh = getDefinitionIfCC(ix->getLH());
     114        CC * rh = getDefinitionIfCC(ix->getRH());
     115        if (lh && rh) {
     116            return resolve(makeName("intersect", intersectCC(lh, rh)));
     117        }
    118118    }
    119119    return re;
     
    126126    assert ("RE object cannot be null!" && re);
    127127    if (isa<Name>(re)) {
    128         if (visited.insert(cast<Name>(re)).second) {
    129             if (isa<CC>(cast<Name>(re)->getDefinition())) {
    130                 nameMap.emplace(cast<Name>(re), nullptr);
    131             } else {
    132                 gather(cast<Name>(re)->getDefinition());
    133             }
    134         }
     128        if (visited.insert(cast<Name>(re)).second) {
     129            if (isa<CC>(cast<Name>(re)->getDefinition())) {
     130                nameMap.emplace(cast<Name>(re), nullptr);
     131            } else {
     132                gather(cast<Name>(re)->getDefinition());
     133            }
     134        }
    135135    } else if (isa<Seq>(re)) {
    136         for (RE * item : *cast<Seq>(re)) {
    137             gather(item);
    138         }
     136        for (RE * item : *cast<Seq>(re)) {
     137            gather(item);
     138        }
    139139    } else if (isa<Alt>(re)) {
    140         for (RE * item : *cast<Alt>(re)) {
    141             gather(item);
    142         }
     140        for (RE * item : *cast<Alt>(re)) {
     141            gather(item);
     142        }
    143143    } else if (isa<Rep>(re)) {
    144         gather(cast<Rep>(re)->getRE());
     144        gather(cast<Rep>(re)->getRE());
    145145    } else if (isa<Assertion>(re)) {
    146         gather(cast<Assertion>(re)->getAsserted());
     146        gather(cast<Assertion>(re)->getAsserted());
    147147    } else if (isa<Diff>(re)) {
    148         gather(cast<Diff>(re)->getLH());
    149         gather(cast<Diff>(re)->getRH());
     148        gather(cast<Diff>(re)->getLH());
     149        gather(cast<Diff>(re)->getRH());
    150150    } else if (isa<Intersect>(re)) {
    151         gather(cast<Intersect>(re)->getLH());
    152         gather(cast<Intersect>(re)->getRH());
     151        gather(cast<Intersect>(re)->getLH());
     152        gather(cast<Intersect>(re)->getRH());
    153153    }
    154154}
Note: See TracChangeset for help on using the changeset viewer.