Ignore:
Timestamp:
Oct 4, 2015, 9:11:55 PM (4 years ago)
Author:
nmedfort
Message:

Removed CC_NameMap

Location:
icGREP/icgrep-devel/icgrep/re
Files:
2 edited

Legend:

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

    r4819 r4820  
    1818#include <re/re_assertion.h>
    1919#include <re/re_analysis.h>
     20#include <re/re_memoizer.hpp>
    2021#include <re/printer_re.h>
    21 #include <cc/cc_namemap.hpp>
    2222#include <pablo/codegenstate.h>
    2323#include <UCD/ucd_compiler.hpp>
     
    194194RE * RE_Compiler::resolveUnicodeProperties(RE * re) {
    195195
    196     using PropertyMap = std::map<std::string, RE *>;
    197     using NamespacedPropertyMap = std::map<std::pair<std::string, std::string>, RE *>;
    198     using NameMap = UCD::UCDCompiler::NameMap;
    199 
    200     PropertyMap                 propertyMap;
    201     NamespacedPropertyMap       namespacedPropertyMap;
    202     NameMap                     nameMap;
     196    Memoizer memoizer;
    203197
    204198    std::function<RE*(RE*)> resolve = [&](RE * re) -> RE * {
    205199        if (Name * name = dyn_cast<Name>(re)) {
    206             if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    207                 name->setDefinition(resolve(name->getDefinition()));
    208             } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty)) {
    209                 // Attempt to look up an equivalently named Name object
    210                 if (name->hasNamespace()) {
    211                     const auto f = namespacedPropertyMap.find(std::make_pair(name->getNamespace(), name->getName()));
    212                     if (f != namespacedPropertyMap.end()) {
    213                         if (f->second != name) {
    214                             return f->second;
     200            auto f = memoizer.find(name);
     201            if (f == memoizer.end()) {
     202                if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
     203                    name->setDefinition(resolve(name->getDefinition()));
     204                } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty)) {
     205                    if (UCD::resolvePropertyDefinition(name)) {
     206                        resolve(name->getDefinition());
     207                    } else {
     208                        #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     209                        if (UsePregeneratedUnicode) {
     210                            const std::string functionName = UCD::resolvePropertyFunction(name);
     211                            const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
     212                            Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
     213                            name->setCompiled(mPB.createAnd(call, mNonLineBreak));
     214                        } else {
     215                        #endif
     216                            name->setDefinition(makeCC(std::move(UCD::resolveUnicodeSet(name))));
     217                        #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    215218                        }
     219                        #endif
    216220                    }
    217                     namespacedPropertyMap.insert(std::make_pair(std::make_pair(name->getNamespace(), name->getName()), name));
    218221                } else {
    219                     const auto f = propertyMap.find(name->getName());
    220                     if (f != propertyMap.end()) {
    221                         if (f->second != name) {
    222                             return f->second;
    223                         }
    224                     }
    225                     propertyMap.insert(std::make_pair(name->getName(), name));
    226                 }
    227                 if (UCD::resolvePropertyDefinition(name)) {
    228                     resolve(name->getDefinition());
    229                 } else {
    230                     #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    231                     if (UsePregeneratedUnicode) {
    232                         const std::string functionName = UCD::resolvePropertyFunction(name);
    233                         const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
    234                         Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
    235                         name->setCompiled(mPB.createAnd(call, mNonLineBreak));
    236                     } else {
    237                     #endif
    238                         name->setDefinition(makeCC(std::move(UCD::resolveUnicodeSet(name))));
    239                     #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    240                     }
    241                     #endif
     222                    throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
    242223                }
    243224            } else {
    244                 throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
     225                return *f;
    245226            }
    246227        } else if (Seq * seq = dyn_cast<Seq>(re)) {
     
    288269        return re;
    289270    };
     271
     272    UCD::UCDCompiler::NameMap nameMap;
    290273
    291274    std::function<void(RE*)> gather = [&](RE * re) {
  • icGREP/icgrep-devel/icgrep/re/re_memoizer.hpp

    r4819 r4820  
    2222}
    2323
    24 struct Memoizer : private std::set<RE *, MemoizerComparator> {
     24struct Memoizer : public std::set<RE *, MemoizerComparator> {
    2525
    2626    inline Name * memoize(CC * cc) {
Note: See TracChangeset for help on using the changeset viewer.