Changeset 6251


Ignore:
Timestamp:
Dec 21, 2018, 9:31:22 PM (3 months ago)
Author:
cameron
Message:

Fix for multiposition negated assertions; lookbehind issues remain; disable assertion simplifier for now

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

Legend:

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

    r6227 r6251  
    3434    std::vector<RE *> makeContext(Iterator begin, Iterator end);
    3535    RE * transformAssertion(Assertion * a) override;
    36     RE * simplifyPositiveAsserted(RE * asserted, std::vector<RE *> const & context);
    37     RE * simplifyNegativeAsserted(RE * asserted, std::vector<RE *> const & context);
     36    RE * simplifyAsserted(RE * asserted, std::vector<RE *> const & context);
     37    RE * simplifyForwardAssertion(RE * asserted);
     38    RE * simplifyBackwardAssertion(RE * asserted);
    3839};
    3940
     
    6162        return ResolvesToCC{}.validateRE(d);
    6263    }
    63     inline bool validateSeq(Seq * s) {
     64    inline bool validateSeq(Seq * s) override {
    6465        auto ccValidator = ResolvesToCC{};
    6566        for (auto e : *s) {
     
    9798private:
    9899    Sense sense;
     100    Name * any;
    99101};
    100102
     
    165167RE * Context::transformAssertion(Assertion * a) {
    166168    using Kind = Assertion::Kind;
    167     using Sense = Assertion::Sense;
    168169    if (good() && ValidateAsserted{}.validateRE(a->getAsserted())) {
    169170        AssertionPrep prep{a};
    170171        RE * asserted = prep.transformRE(a->getAsserted());
    171         RE *(Context::* simpFunction)(RE *, std::vector<RE*> const &);
    172         switch(a->getSense()) {
    173         case Sense::Positive:
    174             simpFunction = &Context::simplifyPositiveAsserted;
    175             break;
    176         case Sense::Negative:       
    177             simpFunction = &Context::simplifyNegativeAsserted;
    178             break;
    179         default:
    180             llvm_unreachable("unexpected sense");
    181         }
    182 
     172        Assertion::Sense sense = a->getSense();
    183173        RE * simplifiedAsserted = nullptr;
    184174        if (a->getKind() == Kind::Lookahead) {
    185             simplifiedAsserted = (this->*simpFunction)(asserted, after);
     175            simplifiedAsserted = simplifyAsserted(asserted, after);
    186176        } else if (a->getKind() == Kind::Lookbehind) {
    187177            asserted = reverseAsserted(asserted);
    188             simplifiedAsserted = reverseAsserted((this->*simpFunction)(asserted, before));
     178            simplifiedAsserted = reverseAsserted(simplifyAsserted(asserted, before));
    189179        } else {
    190180            return a;
     
    195185                return a;
    196186            } else if (isEmptySet(simplifiedAsserted)) {
    197                 return makeAlt();
     187                if (sense == Assertion::Sense::Positive) return makeAlt();
     188                else return makeSeq();
    198189            } else if (isEmptySeq(simplifiedAsserted)) {
    199                 return makeSeq();
    200             } else {
    201                 return makeAssertion(simplifiedAsserted, a->getKind(), a->getSense());
     190                if (sense == Assertion::Sense::Positive) return makeSeq();
     191                else return makeAlt();
     192            } else {
     193                return makeAssertion(simplifiedAsserted, a->getKind(), sense);
    202194            }
    203195        } else {
     
    217209}
    218210
    219 RE * Context::simplifyPositiveAsserted(RE * asserted, std::vector<RE *> const & context) {
     211RE * Context::simplifyAsserted(RE * asserted, std::vector<RE *> const & context) {
    220212    if (LLVM_LIKELY(llvm::isa<CC>(asserted))) {
    221213        if (context.size() > 0) {
     
    234226        }
    235227        return asserted;
    236     }
    237    
    238     else if (llvm::isa<Seq>(asserted)) {
     228    } else if (llvm::isa<Seq>(asserted)) {
    239229        Seq * a = llvm::cast<Seq>(asserted);
    240230        std::vector<RE *> elems{a->begin(), a->end()};
    241231        bool isWholeSeqSuperSet = context.size() >= a->size();
    242232        bool didChange = false;
     233        elems.reserve(a->size());
    243234
    244235        for (size_t i = 0; i < std::min(a->size(), context.size()); ++i) {
    245             RE * simplifiedElem = simplifyPositiveAsserted((*a)[i], std::vector<RE *>{context[i]});
     236            RE * simplifiedElem = simplifyAsserted((*a)[i], std::vector<RE *>{context[i]});
    246237            if (isEmptySet(simplifiedElem)) {
    247238                return makeAlt();
     
    272263            return asserted;
    273264        }
    274     }
    275    
    276     else if (llvm::isa<Alt>(asserted)) {
     265    } else if (llvm::isa<Alt>(asserted)) {
    277266        Alt * a = llvm::cast<Alt>(asserted);
    278267        std::vector<RE *> elems{};
     
    280269        bool did_change = false;
    281270        for (auto e : *a) {
    282             RE * e0 = simplifyPositiveAsserted(e, context);
     271            RE * e0 = simplifyAsserted(e, context);
    283272            if (e0 != e) {
    284273                elems.push_back(e0);
     
    294283            return asserted;
    295284        }
    296     }
    297    
    298     else if (llvm::isa<Name>(asserted)) {
     285    } else if (llvm::isa<Name>(asserted)) {
    299286        RE * def = llvm::cast<Name>(asserted)->getDefinition();
    300287        if (LLVM_UNLIKELY(def == nullptr)) {
    301288            llvm_unreachable("undefined name");
    302289        }
    303         RE * simp = simplifyPositiveAsserted(def, context);
     290        RE * simp = simplifyAsserted(def, context);
    304291        if (simp == def) {
    305292            return asserted;
     
    307294            return simp;
    308295        }
    309     }
    310    
    311     else {
    312         llvm_unreachable("Context::simplifyPositiveAsserted: Unexpected asserted value");
    313     }
    314 }
    315 
    316 RE * Context::simplifyNegativeAsserted(RE * asserted, std::vector<RE *> const & context) {
    317     if (LLVM_LIKELY(llvm::isa<CC>(asserted))) {
    318         if (context.size() == 0) {
    319             return asserted;
    320         }
    321 
    322         CC * assertedCC = llvm::cast<CC>(asserted);
    323         CC * contextCC = llvm::dyn_cast<CC>(context.front());
    324         if (LLVM_UNLIKELY(contextCC == nullptr)) {
    325             llvm_unreachable("invalid context");
    326         }
    327         CC * intersect = intersectCC(contextCC, assertedCC);
    328         if (intersect->empty()) {
    329             return makeSeq();
    330         } else if (subtractCC(contextCC, assertedCC)->empty()) {
    331             return makeAlt();
    332         } else if (intersect->size() == assertedCC->size()) {
    333             return asserted;
    334         } else {
    335             return intersect;
    336         }
    337     }
    338 
    339     else if (llvm::isa<Seq>(asserted)) {
    340         Seq * a = llvm::cast<Seq>(asserted);
    341         std::vector<RE *> elems{a->begin(), a->end()};
    342         bool isWholeSeqSuperSet = context.size() >= a->size();
    343         bool didChange = false;
    344 
    345         for (size_t i = 0; i < std::min(a->size(), context.size()); ++i) {
    346             RE * simplifiedElem = simplifyNegativeAsserted((*a)[i], std::vector<RE *>{context[i]});
    347             if (isEmptySet(simplifiedElem)) {
    348                 return makeAlt();
    349             }
    350             if (simplifiedElem != (*a)[i]) {
    351                 didChange = true;
    352                 if (!isEmptySeq(simplifiedElem)) {
    353                     isWholeSeqSuperSet = false;
    354                     elems[i] = simplifiedElem;
    355                 }
    356             } else {
    357                 isWholeSeqSuperSet = false;
    358             }
    359         }
    360 
    361         if (isWholeSeqSuperSet) {
    362             return makeSeq();
    363         }
    364 
    365         if (didChange) {
    366             return makeSeq(elems.begin(), elems.end());
    367         } else {
    368             return asserted;
    369         }
    370     }
    371    
    372     else if (llvm::isa<Alt>(asserted)) {
    373         Alt * a = llvm::cast<Alt>(asserted);
    374         std::vector<RE *> elems{};
    375         elems.reserve(a->size());
    376         bool did_change = false;
    377         for (auto e : *a) {
    378             RE * e0 = simplifyNegativeAsserted(e, context);
    379             if (e0 != e) {
    380                 did_change = true;
    381             } else {
    382                 elems.push_back(e);
    383             }
    384         }
    385 
    386         if (did_change) {
    387             return makeAlt(elems.begin(), elems.end());
    388         } else {
    389             return asserted;
    390         }
    391     }
    392    
    393     else if (llvm::isa<Name>(asserted)) {
    394         RE * def = llvm::cast<Name>(asserted)->getDefinition();
    395         if (LLVM_UNLIKELY(def == nullptr)) {
    396             llvm_unreachable("undefined name");
    397         }
    398         RE * simp = simplifyNegativeAsserted(def, context);
    399         if (simp == def) {
    400             return asserted;
    401         } else {
    402             return simp;
    403         }
    404     }
    405    
    406     else {
    407         llvm_unreachable("Context::simplifyNegativeAsserted: Unexpected asserted value");
     296    } else {
     297        llvm_unreachable("Context::simplifyAsserted: Unexpected asserted value");
    408298    }
    409299}
     
    414304: RE_Transformer("", NameTransformationMode::TransformDefinition),
    415305  sense(assertion->getSense())
    416 {}
     306{
     307    this->any = llvm::cast<Name>(makeAny());
     308}
    417309
    418310RE * AssertionPrep::transformDiff(Diff * d) {
  • icGREP/icgrep-devel/icgrep/re/re_toolchain.cpp

    r6249 r6251  
    123123        r = simplifyRE(r);
    124124    }
    125     r = RE_ContextSimplifier().transformRE(r);
     125    //r = RE_ContextSimplifier().transformRE(r);
    126126    if (!DefiniteLengthBackReferencesOnly(r)) {
    127127        llvm::report_fatal_error("Future back reference support: references must be within a fixed distance from a fixed-length capture.");
Note: See TracChangeset for help on using the changeset viewer.