Ignore:
Timestamp:
Dec 15, 2018, 11:18:21 AM (4 months ago)
Author:
cameron
Message:

Use RE_Transformer for reverse

File:
1 edited

Legend:

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

    r5812 r6232  
    11/*
    2  *  Copyright (c) 2017 International Characters.
     2 *  Copyright (c) 2018 International Characters.
    33 *  This software is licensed to the public under the Open Software License 3.0.
    44 *  icgrep is a trademark of International Characters.
     
    1919#include <re/re_intersect.h>
    2020#include <re/re_assertion.h>
     21#include <re/re_toolchain.h>
    2122#include <llvm/Support/ErrorHandling.h>
    2223#include <map>
     
    2627
    2728namespace re {
     29   
     30    using CaptureMap = std::map<std::string, Name *>;
    2831
    29 using CaptureMap = std::map<std::string, re::Name *>;
    30 
    31 RE * reverse(RE * re, CaptureMap & captureMap) {
    32     if (isa<CC>(re)) {
    33         return re;
    34     } else if (Range * rg = dyn_cast<Range>(re)) {
    35         return makeRange(rg->getLo(), rg->getHi());
    36     } else if (Seq * seq = dyn_cast<Seq>(re)) {
     32class ReverseTransformer : public RE_Transformer {
     33public:
     34    ReverseTransformer() : RE_Transformer("Reverse") {}
     35    RE * transformName(Name * n) override {
     36        Name::Type nType = n ->getType();
     37        if (nType == Name::Type::Capture) {
     38            std::string cname = n->getName();
     39            auto f = mCaptureMap.find(cname);
     40            if (f != mCaptureMap.end()) {
     41                return makeReference(f->second->getName(), f->second);
     42            }
     43            else {
     44                std::string newName = "\\" + std::to_string(mCaptureMap.size() + 1);
     45                Name * capture = makeCapture(newName, transform(n->getDefinition()));
     46                mCaptureMap.emplace(cname, capture);
     47                return capture;
     48            }
     49        }
     50        if (nType == Name::Type::Reference) {
     51            Name * referent = cast<Name>(n->getDefinition());
     52            std::string cname = referent->getName();
     53            auto f = mCaptureMap.find(cname);
     54            if (f != mCaptureMap.end()) {
     55                return makeReference(f->second->getName(), f->second);
     56            }
     57            else {
     58                std::string newName = "\\" + std::to_string(mCaptureMap.size() + 1);
     59                Name * capture = makeCapture(newName, transform(referent->getDefinition()));
     60                mCaptureMap.emplace(cname, capture);
     61                return capture;
     62            }
     63        }
     64        return n;
     65    }
     66    RE * transformSeq (Seq * seq) override {
    3767        std::vector<RE*> list;
    3868        for (auto i = seq->rbegin(); i != seq->rend(); ++i) {
    39             list.push_back(reverse(*i, captureMap));
     69            list.push_back(transform(*i));
    4070        }
    4171        return makeSeq(list.begin(), list.end());
    42     } else if (Alt * alt = dyn_cast<Alt>(re)) {
    43         std::vector<RE*> list;
    44         for (auto i = alt->begin(); i != alt->end(); ++i) {
    45             list.push_back(reverse(*i, captureMap));
     72    }
     73    RE * transformStart (Start *) override { return makeEnd();}
     74    RE * transformEnd (End *) override { return makeStart();}
     75    RE * transformAssertion (Assertion * a) override {
     76        RE * asserted = a->getAsserted();
     77        RE * reversed = transform(asserted);
     78        if ((a->getKind() == Assertion::Kind::Boundary) && (reversed == asserted)) {
     79            return a;
    4680        }
    47         return makeAlt(list.begin(), list.end());
    48     } else if (Rep * rep = dyn_cast<Rep>(re)) {
    49         return makeRep(reverse(rep->getRE(), captureMap), rep->getLB(), rep->getUB());
    50     } else if (Group * g = dyn_cast<Group>(re)) {
    51         return makeGroup(g->getMode(), reverse(g->getRE(), captureMap), g->getSense());
    52     } else if (Diff * diff = dyn_cast<Diff>(re)) {
    53         return makeDiff(reverse(diff->getLH(), captureMap), reverse(diff->getRH(), captureMap));
    54     } else if (Intersect * e = dyn_cast<Intersect>(re)) {
    55         return makeIntersect(reverse(e->getLH(), captureMap), reverse(e->getRH(), captureMap));
    56     } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    57         return makeAssertion(reverse(a->getAsserted(), captureMap), Assertion::reverseKind(a->getKind()), a->getSense());
    58     } else if (isa<Start>(re)) {
    59         return makeEnd();
    60     } else if (isa<End>(re)) {
    61         return makeStart();
    62     } else if (Name * n = dyn_cast<Name>(re)) {
    63         switch (n->getType()) {
    64             case Name::Type::Unicode:
    65                 return makeName(cast<CC>(n->getDefinition()));
    66             case Name::Type::UnicodeProperty:
    67                 return makeName(n->getNamespace(), n->getName(), Name::Type::UnicodeProperty);
    68             case Name::Type::ZeroWidth:
    69                 return makeZeroWidth(n->getName(), reverse(n->getDefinition(), captureMap));
    70             case Name::Type::Capture:
    71                 {
    72                     std::string cname = n->getName();
    73                     auto f = captureMap.find(cname);
    74                     if (f != captureMap.end()) {
    75                         return makeReference(f->second->getName(), f->second);
    76                     }
    77                     else {
    78                         std::string newName = "\\" + std::to_string(captureMap.size() + 1);
    79                         Name * capture = makeCapture(newName, reverse(n->getDefinition(), captureMap));
    80                         captureMap.insert(std::make_pair(cname, capture));
    81                         return capture;
    82                     }
    83                 }
    84             case Name::Type::Reference:
    85                 {
    86                     Name * referent = cast<Name>(n->getDefinition());
    87                     std::string cname = referent->getName();
    88                     auto f = captureMap.find(cname);
    89                     if (f != captureMap.end()) {
    90                        return makeReference(f->second->getName(), f->second);
    91                     }
    92                     else {
    93                         std::string newName = "\\" + std::to_string(captureMap.size() + 1);
    94                         Name * capture = makeCapture(newName, reverse(referent->getDefinition(), captureMap));
    95                         captureMap.insert(std::make_pair(cname, capture));
    96                         return capture;
    97                     }
    98                 }
    99             case Name::Type::Unknown:
    100                 return makeName(n->getName(), n->getDefinition());
    101             default:
    102                 llvm::report_fatal_error("re::reverse: unhandled Name type");
    103         }
    104     } else if (isa<Any>(re)) {
    105         return makeAny();
    106     } else {
    107         llvm::report_fatal_error("re::reverse: unhandled regexp type");
     81        return makeAssertion(reversed, Assertion::reverseKind(a->getKind()), a->getSense());
    10882    }
    109 
    110 }
     83   
     84private:
     85    CaptureMap mCaptureMap;
     86};
    11187
    11288RE * reverse(RE * re) {
    113     CaptureMap captureMap;
    114     return reverse(re, captureMap);
     89    return ReverseTransformer().transformRE(re);
    11590}
    11691
Note: See TracChangeset for help on using the changeset viewer.