Ignore:
Timestamp:
Sep 30, 2015, 3:18:09 PM (3 years ago)
Author:
nmedfort
Message:

Refactored UCD property resolution.

File:
1 edited

Legend:

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

    r4808 r4809  
    4646                     cl::desc("set mod64 approximate mode"), cl::cat(fREcompilationOptions));
    4747#ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    48 static cl::opt<bool> UsePregeneratedUnicode("use-pregenerated-unicode", cl::init(false),
     48static cl::opt<bool> UsePregeneratedUnicode("use-pregenerated-unicode", cl::init(true),
    4949                     cl::desc("use fixed pregenerated Unicode character class sets instead"), cl::cat(fREcompilationOptions));
    5050#endif
     
    180180
    181181void RE_Compiler::gatherUnicodePropertyNames(RE * re, NameSet & nameSet) {
    182     if (Name * name = dyn_cast<Name>(re)) {
    183         if (name->getDefinition()) {
    184             gatherUnicodePropertyNames(name->getDefinition(), nameSet);
    185         } else if (name->getType() == Name::Type::UnicodeProperty) {
    186             nameSet.insert(name);
    187         }
    188     } else if (Seq* seq = dyn_cast<Seq>(re)) {
    189         for (RE * re : *seq) {
    190             gatherUnicodePropertyNames(re, nameSet);
    191         }
    192     } else if (Alt * alt = dyn_cast<Alt>(re)) {
    193         for (RE * re : *alt) {
    194             gatherUnicodePropertyNames(re, nameSet);
    195         }
    196     } else if (Rep * rep = dyn_cast<Rep>(re)) {
    197         gatherUnicodePropertyNames(rep->getRE(), nameSet);
    198     } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    199         gatherUnicodePropertyNames(a->getAsserted(), nameSet);
    200     } else if (Diff * diff = dyn_cast<Diff>(re)) {
    201         gatherUnicodePropertyNames(diff->getLH(), nameSet);
    202         gatherUnicodePropertyNames(diff->getRH(), nameSet);
    203     } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    204         gatherUnicodePropertyNames(ix->getLH(), nameSet);
    205         gatherUnicodePropertyNames(ix->getRH(), nameSet);
    206     }
     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) {
     187            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);
     197                        }
     198                        return;
     199                    }
     200                    mNamespacedPropertyMap.insert(std::make_pair(std::make_pair(name->getNamespace(), name->getName()), name));
     201                } 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;
     208                    }
     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);
     215                    } else {
     216                        mNameSet.insert(name);
     217                    }
     218                }
     219            } else if (Seq* seq = dyn_cast<Seq>(re)) {
     220                for (RE * re : *seq) {
     221                    process(re);
     222                }
     223            } else if (Alt * alt = dyn_cast<Alt>(re)) {
     224                for (RE * re : *alt) {
     225                    process(re);
     226                }
     227            } else if (Rep * rep = dyn_cast<Rep>(re)) {
     228                process(rep->getRE());
     229            } else if (Assertion * a = dyn_cast<Assertion>(re)) {
     230                process(a->getAsserted());
     231            } 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());
     237            }
     238
     239        }
     240
     241        UnicodePropertyNameMap(NameSet & nameSet) : mNameSet(nameSet) {}
     242
     243    private:
     244        NameSet &                   mNameSet;
     245        PropertyMap                 mPropertyMap;
     246        NamespacedPropertyMap       mNamespacedPropertyMap;
     247    } ;
     248
     249    UnicodePropertyNameMap(nameSet).process(re);
    207250}
    208251
     
    213256    if (UsePregeneratedUnicode) {
    214257        for (Name * name : nameSet) {
    215             const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(name->getFunctionName());
    216             Call * call = mPB.createCall(Prototype::Create(name->getFunctionName(), std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
     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());
    217261            name->setCompiled(mPB.createAnd(call, mPB.createNot(UNICODE_LINE_BREAK ? mUnicodeLineBreak : mLineFeed)));
    218262        }
Note: See TracChangeset for help on using the changeset viewer.