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

Refactored UCD property resolution.

Location:
icGREP/icgrep-devel/icgrep/re
Files:
4 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        }
  • icGREP/icgrep-devel/icgrep/re/re_name.h

    r4808 r4809  
    3333    };
    3434    std::string getNamespace() const;
     35    bool hasNamespace() const;
    3536    std::string getName() const;
    36     void setFunctionName(const std::string &);
    37     std::string getFunctionName() const;
    38 
    3937    Type getType() const;
    4038    RE * getDefinition() const;
     
    5856    , mNameLength(nameLength)
    5957    , mName(replicateString(name, nameLength))
    60     , mFunctionNameLength(0)
    61     , mFunctionName(nullptr)
    6258    , mType(type)
    6359    , mDefiningRE(defn)
     
    8076    const length_t      mNameLength;
    8177    const char * const  mName;
    82     length_t            mFunctionNameLength;
    83     const char *        mFunctionName;
    8478    const Type          mType;
    8579    RE *                mDefiningRE;
     
    9185}
    9286
     87inline bool Name::hasNamespace() const {
     88    return (mNamespaceLength != 0);
     89}
     90
    9391inline std::string Name::getName() const {
    9492    return std::string(mName, mNameLength);
    95 }
    96 
    97 inline std::string Name::getFunctionName() const {
    98     return std::string(mFunctionName, mFunctionNameLength);
    99 }
    100 
    101 inline void Name::setFunctionName(const std::string & n) {
    102     mFunctionNameLength = n.length();
    103     mFunctionName = replicateString(n.c_str(), n.length());
    10493}
    10594   
     
    113102
    114103inline void Name::setDefinition(RE * d) {
     104    assert (d != this);
    115105    mDefiningRE = d;
    116106}
  • icGREP/icgrep-devel/icgrep/re/re_parser.cpp

    r4806 r4809  
    520520        return f->second;
    521521    }
    522 
    523     Name * property = UCD::resolveProperty(value, this);
    524 
     522    Name * property = makeName(value, Name::Type::UnicodeProperty);
    525523    mNameMap.insert(std::make_pair(std::move(key), property));
    526 
    527524    return property;
    528525}
    529526
    530527Name * RE_Parser::createName(const std::string prop, const std::string value) {
    531 
    532528    auto key = std::make_pair(prop, value);
    533 
    534529    auto f = mNameMap.find(key);
    535530    if (f != mNameMap.end()) {
    536531        return f->second;
    537532    }
    538 
    539     Name * property = UCD::resolveProperty(prop, value, this);
    540 
     533    Name * property = makeName(prop, value, Name::Type::UnicodeProperty);
    541534    mNameMap.insert(std::make_pair(std::move(key), property));
    542 
    543535    return property;
    544536}
  • icGREP/icgrep-devel/icgrep/re/re_parser.h

    r4798 r4809  
    3838{
    3939public:
    40 
    41     friend Name * UCD::resolveProperty(const std::string, RE_Parser *);
    42     friend Name * UCD::resolveProperty(const std::string, const std::string, RE_Parser *);
    4340
    4441    static RE * parse(const std::string &input_string, ModeFlagSet initialFlags);
Note: See TracChangeset for help on using the changeset viewer.