source: icGREP/icgrep-devel/icgrep/re/re_name_resolve.cpp @ 5836

Last change on this file since 5836 was 5835, checked in by nmedfort, 16 months ago

Revised RE_Minimizer to use alphabets + minor optimizations to RE functions

File size: 4.5 KB
Line 
1#include <re/re_re.h>
2#include "re_name_resolve.h"
3#include <re/re_name.h>
4#include <re/re_alt.h>
5#include <re/re_cc.h>
6#include <re/re_seq.h>
7#include <re/re_rep.h>
8#include <re/re_range.h>
9#include <re/re_diff.h>
10#include <re/re_intersect.h>
11#include <re/re_assertion.h>
12#include <re/re_analysis.h>
13#include <re/re_group.h>
14#include <re/re_memoizer.hpp>
15#include <UCD/resolve_properties.h>
16#include <cc/alphabet.h>
17#include <boost/container/flat_set.hpp>
18#include <sstream>
19
20using namespace boost::container;
21using namespace llvm;
22
23namespace re {
24 
25static inline CC * extractCC(RE * re) {
26    if (isa<CC>(re)) {
27        return cast<CC>(re);
28    } else if (isa<Name>(re)) {
29        return extractCC(cast<Name>(re)->getDefinition());
30    }
31    return nullptr;
32}
33
34struct NameResolver {
35    RE * resolveUnicodeProperties(RE * re) {
36        if (Name * name = dyn_cast<Name>(re)) {
37            auto f = mMemoizer.find(name);
38            if (f == mMemoizer.end()) {
39                if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
40                    name->setDefinition(resolveUnicodeProperties(name->getDefinition()));
41                } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty || name->getType() == Name::Type::ZeroWidth)) {
42                    if (UCD::resolvePropertyDefinition(name)) {
43                        name->setDefinition(resolveUnicodeProperties(name->getDefinition()));
44                    } else {
45                        name->setDefinition(makeCC(UCD::resolveUnicodeSet(name), &cc::Unicode));
46                    }
47                } else {
48                    UndefinedNameError(name);
49                }
50                re = mMemoizer.memoize(name);
51            } else {
52                return *f;
53            }
54        } else if (Vector * vec = dyn_cast<Vector>(re)) {
55            for (RE *& re : *vec) {
56                re = resolveUnicodeProperties(re);
57            }
58        } else if (Rep * rep = dyn_cast<Rep>(re)) {
59            rep->setRE(resolveUnicodeProperties(rep->getRE()));
60        } else if (Assertion * a = dyn_cast<Assertion>(re)) {
61            a->setAsserted(resolveUnicodeProperties(a->getAsserted()));
62        } else if (Range * rg = dyn_cast<Range>(re)) {
63            return makeRange(resolveUnicodeProperties(rg->getLo()),
64                             resolveUnicodeProperties(rg->getHi()));
65        } else if (Diff * diff = dyn_cast<Diff>(re)) {
66            diff->setLH(resolveUnicodeProperties(diff->getLH()));
67            diff->setRH(resolveUnicodeProperties(diff->getRH()));
68        } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
69            ix->setLH(resolveUnicodeProperties(ix->getLH()));
70            ix->setRH(resolveUnicodeProperties(ix->getRH()));
71        } else if (Group * g = dyn_cast<Group>(re)) {
72            g->setRE(resolveUnicodeProperties(g->getRE()));
73        }
74        return re;
75    }
76   
77    RE * resolve(RE * re) {
78        if (Name * name = dyn_cast<Name>(re)) {
79            auto f = mMemoizer.find(name);
80            if (f == mMemoizer.end()) {
81                if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
82                    name->setDefinition(resolve(name->getDefinition()));
83                } else {
84                    UndefinedNameError(name);
85                }
86                re = mMemoizer.memoize(name);
87            } else {
88                return *f;
89            }
90        } else if (Vector * vec = dyn_cast<Vector>(re)) {
91            for (RE *& re : *vec) {
92                re = resolve(re);
93            }
94        } else if (Rep * rep = dyn_cast<Rep>(re)) {
95            rep->setRE(resolve(rep->getRE()));
96        } else if (Assertion * a = dyn_cast<Assertion>(re)) {
97            a->setAsserted(resolve(a->getAsserted()));
98        } else if (Range * rg = dyn_cast<Range>(re)) {
99            return makeRange(resolve(rg->getLo()), resolve(rg->getHi()));
100        } else if (Diff * diff = dyn_cast<Diff>(re)) {
101            diff->setLH(resolve(diff->getLH()));
102            diff->setRH(resolve(diff->getRH()));
103        } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
104            ix->setLH(resolve(ix->getLH()));
105            ix->setRH(resolve(ix->getRH()));
106        } else if (Group * g = dyn_cast<Group>(re)) {
107            g->setRE(resolve(g->getRE()));
108        }
109        return re;
110    }
111   
112private:
113    Memoizer                mMemoizer;
114};
115   
116    RE * resolveUnicodeProperties(RE * re) {
117        NameResolver nameResolver;
118        return nameResolver.resolveUnicodeProperties(re);
119    }
120   
121    RE * resolveNames(RE * re) {
122        NameResolver nameResolver;
123        return nameResolver.resolve(re);
124    }
125   
126}
Note: See TracBrowser for help on using the repository browser.