source: icGREP/icgrep-devel/icgrep/re/re_memoizer.cpp @ 5765

Last change on this file since 5765 was 5765, checked in by cameron, 18 months ago

Regular expression group nodes; case-insensitive logic

File size: 4.0 KB
Line 
1#include "re_memoizer.hpp"
2#include <re/re_alt.h>
3#include <re/re_cc.h>
4#include <re/re_seq.h>
5#include <re/re_rep.h>
6#include <re/re_group.h>
7#include <re/re_range.h>
8#include <re/re_diff.h>
9#include <re/re_intersect.h>
10#include <re/re_assertion.h>
11#include <llvm/Support/ErrorHandling.h>
12
13using llvm::cast;
14
15namespace re {
16
17static bool compare(const RE * const lh, const RE * const rh);
18
19static bool lessThan(const Vector * const lh, const Vector * const rh) {
20    assert (lh->getClassTypeId() == rh->getClassTypeId());
21    assert (lh->getClassTypeId() == RE::ClassTypeId::Alt || lh->getClassTypeId() == RE::ClassTypeId::Seq);
22    if (LLVM_LIKELY(lh->size() != rh->size())) {
23        return lh->size() < rh->size();
24    }
25    for (auto i = lh->begin(), j = rh->begin(); i != lh->end(); ++i, ++j) {
26        assert (*i && *j);
27        if (compare(*i, *j)) {
28            return true;
29        }
30    }
31    return false;
32}
33
34inline bool lessThan(const Assertion * const lh, const Assertion * const rh) {
35    if (lh->getKind() != rh->getKind()) {
36        return lh->getKind() < rh->getKind();
37    }
38    if (lh->getSense() != rh->getSense()) {
39        return lh->getSense() < rh->getSense();
40    }
41    return compare(lh->getAsserted(), rh->getAsserted());
42}
43
44inline bool lessThan(const Rep * const lh, const Rep * const rh) {
45    if (lh->getLB() != rh->getLB()) {
46        return lh->getLB() < rh->getLB();
47    }
48    if (lh->getUB() != rh->getUB()) {
49        return lh->getUB() < rh->getUB();
50    }
51    return compare(lh->getRE(), rh->getRE());
52}
53
54inline bool lessThan(const Diff * const lh, const Diff * const rh) {
55    return compare(lh->getLH(), rh->getLH()) || compare(lh->getRH(), rh->getRH());
56}
57
58inline bool lessThan(const Range * const lh, const Range * const rh) {
59    return compare(lh->getLo(), rh->getLo()) || compare(lh->getHi(), rh->getHi());
60}
61
62static bool lessThan(const Intersect * const lh, const Intersect * const rh) {
63    return compare(lh->getLH(), rh->getLH()) || compare(lh->getRH(), rh->getRH());
64}
65
66inline bool lessThan(const Group * const lh, const Group * const rh) {
67    if (lh->getMode() != rh->getMode()) {
68        return lh->getMode() < rh->getMode();
69    }
70    if (lh->getSense() != rh->getSense()) {
71        return lh->getSense() < rh->getSense();
72    }
73    return compare(lh->getRE(), rh->getRE());
74}
75
76inline bool compare(const RE * const lh, const RE * const rh) {
77    using Type = RE::ClassTypeId;
78    assert (lh && rh);
79    const auto typeL = lh->getClassTypeId();
80    const auto typeR = rh->getClassTypeId();
81    if (LLVM_LIKELY(typeL != typeR)) {
82        if ((typeL == Type::CC || typeR == Type::CC) && (typeL == Type::Name || typeR == Type::Name)) {
83            if (typeL == Type::Name) {
84                return *cast<Name>(lh) < *cast<CC>(rh);
85            } else {
86                return *cast<Name>(rh) > *cast<CC>(lh);
87            }
88        }
89        return typeL < typeR;
90    }
91    switch (typeL) {
92        case Type::Alt:
93        case Type::Seq:
94            return lessThan(cast<Vector>(lh), cast<Vector>(rh));
95        case Type::Any: case Type::End: case Type::Start:
96            return false;
97        case Type::Assertion:
98            return lessThan(cast<Assertion>(lh), cast<Assertion>(rh));
99        case Type::CC:
100            return *cast<CC>(lh) < *cast<CC>(rh);
101        case Type::Name:
102            return *cast<Name>(lh) < *cast<Name>(rh);
103        case Type::Group:
104            return lessThan(cast<Group>(lh), cast<Group>(rh));
105        case Type::Range:
106            return lessThan(cast<Range>(lh), cast<Range>(rh));
107        case Type::Diff:
108            return lessThan(cast<Diff>(lh), cast<Diff>(rh));
109        case Type::Intersect:
110            return lessThan(cast<Intersect>(lh), cast<Intersect>(rh));
111        case Type::Rep:
112            return lessThan(cast<Rep>(lh), cast<Rep>(rh));
113        default:
114            llvm_unreachable("RE object of unknown type given to Memoizer");
115            return false;
116    }
117}
118
119bool MemoizerComparator::operator()(const RE * const lh, const RE * const rh) const {
120    return compare(lh, rh);
121}
122
123}
Note: See TracBrowser for help on using the repository browser.