source: icGREP/icgrep-devel/icgrep/re/re_multiplex.cpp

Last change on this file was 5897, checked in by cameron, 4 months ago

RE compiler restructuring progress

File size: 5.5 KB
Line 
1#include "re_multiplex.h"
2#include <re/re_name.h>
3#include <re/re_alt.h>
4#include <re/re_cc.h>
5#include <re/re_seq.h>
6#include <re/re_rep.h>
7#include <re/re_diff.h>
8#include <re/re_intersect.h>
9#include <re/re_assertion.h>
10#include <re/re_group.h>
11#include <re/re_analysis.h>
12#include <re/re_memoizer.hpp>
13#include <re/printer_re.h>
14#include <UCD/ucd_compiler.hpp>
15#include <UCD/resolve_properties.h>
16#include <boost/container/flat_set.hpp>
17#include <cc/alphabet.h>
18#include <cc/multiplex_CCs.h>
19#include <sstream>
20#include <iostream>
21#include <functional>
22#include <llvm/Support/raw_ostream.h>
23
24using namespace boost::container;
25using namespace llvm;
26
27namespace re {
28 
29RE * multiplex(RE * const re,
30               const std::vector<const CC *> & UnicodeSets,
31               const std::vector<std::vector<unsigned>> & exclusiveSetIDs) {
32
33    Memoizer memoizer;
34
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    };
91
92    return multiplex(re);
93}   
94
95
96RE * 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
145}
Note: See TracBrowser for help on using the repository browser.