Changeset 6167


Ignore:
Timestamp:
Sep 24, 2018, 2:24:26 PM (3 months ago)
Author:
cameron
Message:

Multiplexing using RE_transformer

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

Legend:

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

    r6160 r6167  
    2727namespace re {
    2828 
    29 RE * multiplex(RE * const re,
    30                const std::vector<const CC *> & UnicodeSets,
    31                const std::vector<std::vector<unsigned>> & exclusiveSetIDs) {
    3229
    33     Memoizer memoizer;
     30class CC_multiplexer : public RE_Transformer {
     31public:
     32    CC_multiplexer(cc::MultiplexedAlphabet * mpx) : RE_Transformer(), mMultiplexedAlphabet(mpx) {}
     33    RE * transformCC(CC *) override;
     34    RE * transformName(Name *) override;
     35private:
     36    cc::MultiplexedAlphabet * mMultiplexedAlphabet;
     37};
    3438
    35     std::function<RE *(RE *)> multiplex = [&](RE * const re) -> RE * {
    36         if (CC * cc = dyn_cast<CC>(re)) {
    37             if (cc->getAlphabet() != &cc::Unicode) return cc;
    38             const auto index = find(UnicodeSets.begin(), UnicodeSets.end(), cc) - UnicodeSets.begin();
    39             const auto exclusive_IDs = exclusiveSetIDs[index];
    40             CC * CC_union = makeCC();
    41             for (auto i : exclusive_IDs) {
    42                 CC_union = makeCC(CC_union, makeCC(i));
    43             }
    44             return CC_union;
    45         } else if (Name * name = dyn_cast<Name>(re)) {
    46             auto f = memoizer.find(name);
    47             if (f == memoizer.end()) {
    48                 if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    49                     if (CC * cc = dyn_cast<CC>(name->getDefinition())) {
    50                         if (cc->getAlphabet() != &cc::Unicode) return cc;
    51                         const auto index = find(UnicodeSets.begin(), UnicodeSets.end(), cc) - UnicodeSets.begin();
    52                         const auto exclusive_IDs = exclusiveSetIDs[index];
    53                         CC * CC_union = makeCC();
    54                         for (auto i : exclusive_IDs) {
    55                             CC_union = makeCC(CC_union, makeCC(i));
    56                         }
    57                         name->setDefinition(CC_union);
    58                     } else {
    59                         multiplex(name->getDefinition());
    60                     }
    61                 } else {
    62                     UndefinedNameError(name);
    63                 }
    64                 return memoizer.memoize(name);
    65             } else {
    66                 return *f;
    67             }
    68         } else if (Seq * seq = dyn_cast<Seq>(re)) {
    69             for (auto si = seq->begin(); si != seq->end(); ++si) {
    70                 *si = multiplex(*si);
    71             }
    72         } else if (Alt * alt = dyn_cast<Alt>(re)) {
    73             for (auto ai = alt->begin(); ai != alt->end(); ++ai) {
    74                 *ai = multiplex(*ai);
    75             }
    76         } else if (Rep * rep = dyn_cast<Rep>(re)) {
    77             rep->setRE(multiplex(rep->getRE()));
    78         } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    79             a->setAsserted(multiplex(a->getAsserted()));
    80         } else if (Diff * diff = dyn_cast<Diff>(re)) {
    81             diff->setLH(multiplex(diff->getLH()));
    82             diff->setRH(multiplex(diff->getRH()));
    83         } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    84             ix->setLH(multiplex(ix->getLH()));
    85             ix->setRH(multiplex(ix->getRH()));
    86         } else if (Group * g = dyn_cast<Group>(re)) {
    87             g->setRE(multiplex(g->getRE()));
    88         }
    89         return re;
    90     };
     39RE * CC_multiplexer::transformCC(CC * cc) {
     40    if (cc->getAlphabet() == mMultiplexedAlphabet->getSourceAlphabet()) {
     41        return mMultiplexedAlphabet->transformCC(cc);
     42    }
     43    return cc;
     44}
    9145
    92     return multiplex(re);
    93 }   
    94 
     46RE * CC_multiplexer::transformName(Name * name) {
     47    if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
     48        RE * xfrm = transform(name->getDefinition());
     49        if (name->getType() == Name::Type::ZeroWidth)
     50            return makeZeroWidth(name->getName(), xfrm);
     51        else if (name->getType() == Name::Type::Capture)
     52            return makeCapture(name->getName(), xfrm);
     53        else
     54            return makeName(name->getName(), xfrm);
     55    }
     56    return name;
     57}
    9558
    9659RE * transformCCs(cc::MultiplexedAlphabet * mpx, RE * re) {
    97     if (CC * cc = dyn_cast<CC>(re)) {
    98         if (cc->getAlphabet() == mpx->getSourceAlphabet()) {
    99             re = mpx->transformCC(cc);
    100         }
    101     } else if (Name * name = dyn_cast<Name>(re)) {
    102         if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    103             RE * xfrm = transformCCs(mpx, name->getDefinition());
    104             if (name->getType() == Name::Type::ZeroWidth)
    105                 re = makeZeroWidth(name->getName(), xfrm);
    106             else if (name->getType() == Name::Type::Capture)
    107                 re = makeCapture(name->getName(), xfrm);
    108             else
    109                 re = makeName(name->getName(), xfrm);
    110         } else {
    111             UndefinedNameError(name);
    112         }
    113     } else if (Seq * seq = dyn_cast<Seq>(re)) {
    114         std::vector<RE *> list;
    115         list.reserve(seq->size());
    116         for (RE * item : *seq) {
    117             item = transformCCs(mpx, item);
    118             list.push_back(item);
    119         }
    120         re = makeSeq(list.begin(), list.end());
    121     } else if (Alt * alt = dyn_cast<Alt>(re)) {
    122         std::vector<RE *> list;
    123         list.reserve(alt->size());
    124         for (RE * item : *alt) {
    125             item = transformCCs(mpx, item);
    126             list.push_back(item);
    127         }
    128         re = makeAlt(list.begin(), list.end());
    129     } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    130         re = makeAssertion(transformCCs(mpx, a->getAsserted()), a->getKind(), a->getSense());
    131     } else if (Rep * rep = dyn_cast<Rep>(re)) {
    132         RE * expr = transformCCs(mpx, rep->getRE());
    133         re = makeRep(expr, rep->getLB(), rep->getUB());
    134     } else if (Diff * diff = dyn_cast<Diff>(re)) {
    135         re = makeDiff(transformCCs(mpx, diff->getLH()), transformCCs(mpx, diff->getRH()));
    136     } else if (Intersect * e = dyn_cast<Intersect>(re)) {
    137         re = makeIntersect(transformCCs(mpx, e->getLH()), transformCCs(mpx, e->getRH()));
    138     } else if (Group * g = dyn_cast<Group>(re)) {
    139         re = makeGroup(g->getMode(), transformCCs(mpx, g->getRE()), g->getSense());
    140     }
    141     return re;
    142 };
    143 
    144     RE * CC_multiplexer::transformCC(CC * cc) {
    145         if (cc->getAlphabet() == mMultiplexedAlphabet->getSourceAlphabet()) {
    146             return mMultiplexedAlphabet->transformCC(cc);
    147         }
    148         return cc;
    149     }
    150    
    151     RE * CC_multiplexer::transformName(Name * name) {
    152         if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    153             RE * xfrm = transform(name->getDefinition());
    154             if (name->getType() == Name::Type::ZeroWidth)
    155                 return makeZeroWidth(name->getName(), xfrm);
    156             else if (name->getType() == Name::Type::Capture)
    157                 return makeCapture(name->getName(), xfrm);
    158             else
    159                 return makeName(name->getName(), xfrm);
    160         } else {
    161             UndefinedNameError(name);
    162         }
    163     }
    164    
     60    return CC_multiplexer(mpx).transform(re);
     61}
    16562
    16663}
  • icGREP/icgrep-devel/icgrep/re/re_multiplex.h

    r6160 r6167  
    1212    class CC;
    1313
    14     RE * multiplex(RE * const re,
    15                    const std::vector<const CC *> & UnicodeSets,
    16                    const std::vector<std::vector<unsigned>> & exclusiveSetIDs);
    17 
    1814    RE * transformCCs(cc::MultiplexedAlphabet * mpx, RE * r);
    1915
    2016   
    21     class CC_multiplexer : public RE_Transformer {
    22     public:
    23         CC_multiplexer(cc::MultiplexedAlphabet * mpx) : RE_Transformer(), mMultiplexedAlphabet(mpx) {}
    24         RE * transformCC(CC *) override;
    25         RE * transformName(Name *) override;
    26     private:
    27         cc::MultiplexedAlphabet * mMultiplexedAlphabet;
    28     };
    29 
    3017}
    3118#endif
Note: See TracChangeset for help on using the changeset viewer.