source: icGREP/icgrep-devel/icgrep/re/re_star_normal.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: 3.5 KB
Line 
1#include "re_star_normal.h"
2#include <re/re_name.h>
3#include <re/re_any.h>
4#include <re/re_start.h>
5#include <re/re_end.h>
6#include <re/re_alt.h>
7#include <re/re_cc.h>
8#include <re/re_seq.h>
9#include <re/re_rep.h>
10#include <re/re_diff.h>
11#include <re/re_intersect.h>
12#include <re/re_assertion.h>
13#include <re/re_analysis.h>
14#include <re/re_nullable.h>
15
16using namespace llvm;
17
18namespace re {
19
20RE * RE_Star_Normal::optimize(RE * re) {
21    if (Alt * alt = dyn_cast<Alt>(re)) {
22        std::vector<RE *> list;
23        list.reserve(alt->size());
24        for (RE * re : *alt) {
25            list.push_back(optimize(re));
26        }
27        re = makeAlt(list.begin(), list.end());
28    } else if (Seq * seq = dyn_cast<Seq>(re)) {
29        RE * head = *(seq->begin());
30        RE * tail = makeSeq(seq->begin() + 1, seq->end());
31        const auto headNullable = RE_Nullable::isNullable(head);
32        head = headNullable ? optimize(head) : star_normal(head);
33        const auto tailNullable = RE_Nullable::isNullable(tail);
34        tail = tailNullable ? optimize(tail) : star_normal(tail);
35        if (LLVM_UNLIKELY(headNullable && tailNullable)) {
36            re = makeAlt({head, tail});
37        } else {
38            re = makeSeq({head, tail});
39        }
40    } else if (Assertion * a = dyn_cast<Assertion>(re)) {
41        re = makeAssertion(optimize(a->getAsserted()), a->getKind(), a->getSense());
42    } else if (Rep * rep = dyn_cast<Rep>(re)) {
43        RE * const expr = optimize(rep->getRE());
44        if (rep->getLB() == 0 && rep->getUB() == Rep::UNBOUNDED_REP) {
45            re = expr;
46        } else {
47            re = makeRep(expr, rep->getLB(), rep->getUB());
48        }
49    } else if (Diff * diff = dyn_cast<Diff>(re)) {
50        re = makeDiff(optimize(diff->getLH()), optimize(diff->getRH()));
51    } else if (Intersect * e = dyn_cast<Intersect>(re)) {
52        re = makeIntersect(optimize(e->getLH()), optimize(e->getRH()));
53    } else if (Name * name = dyn_cast<Name>(re)) {
54        if (name->getDefinition()) {
55            name->setDefinition(optimize(name->getDefinition()));
56        }
57    }
58    return re;
59}
60
61RE * RE_Star_Normal::star_normal(RE * re) {
62    if (Alt * alt = dyn_cast<Alt>(re)) {
63        std::vector<RE *> list;
64        list.reserve(alt->size());
65        for (RE * re : *alt) {
66            list.push_back(star_normal(re));
67        }
68        re = makeAlt(list.begin(), list.end());
69    } else if (Seq * seq = dyn_cast<Seq>(re)) {
70        std::vector<RE *> list;
71        list.reserve(seq->size());
72        for (RE * re : *seq) {
73            list.push_back(star_normal(re));
74        }
75        re = makeSeq(list.begin(), list.end());
76    } else if (Assertion * a = dyn_cast<Assertion>(re)) {
77        re = makeAssertion(star_normal(a->getAsserted()), a->getKind(), a->getSense());
78    } else if (Rep * rep = dyn_cast<Rep>(re)) {
79         if (rep->getLB() == 0 && rep->getUB() == Rep::UNBOUNDED_REP) {
80            RE * expr = optimize(rep->getRE());
81            re = makeRep(expr, 0, rep->getUB());
82        } else {
83            RE * expr = star_normal(rep->getRE());
84            re = makeRep(expr, rep->getLB(), rep->getUB());
85        }
86    } else if (Diff * diff = dyn_cast<Diff>(re)) {
87        re = makeDiff(star_normal(diff->getLH()), star_normal(diff->getRH()));
88    } else if (Intersect * e = dyn_cast<Intersect>(re)) {
89        re = makeIntersect(star_normal(e->getLH()), star_normal(e->getRH()));
90    } else if (Name * name = dyn_cast<Name>(re)) {
91        if (name->getDefinition()) {
92            name->setDefinition(star_normal(name->getDefinition()));
93        }
94    }
95    return re;
96}
97
98}
Note: See TracBrowser for help on using the repository browser.