/
ast.h
182 lines (159 loc) · 4.78 KB
/
ast.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
#ifndef IV_AERO_AST_H_
#define IV_AERO_AST_H_
#include <iv/space.h>
#include <iv/aero/visitor.h>
#include <iv/aero/range.h>
namespace iv {
namespace aero {
static const int32_t kRegExpInfinity = std::numeric_limits<int32_t>::max();
#define ACCEPT_VISITOR\
inline void Accept(Visitor* visitor) {\
visitor->Visit(this);\
}
#define DECLARE_NODE_TYPE(type)\
inline const type* As##type() const { return this; }\
inline type* As##type() { return this; }
#define DECLARE_DERIVED_NODE_TYPE(type)\
DECLARE_NODE_TYPE(type)\
ACCEPT_VISITOR
#define DECLARE_NODE_TYPE_BASE(type)\
inline virtual const type* As##type() const { return NULL; }\
inline virtual type* As##type() { return NULL; }
class Expression : public core::SpaceObject {
public:
virtual ~Expression() { }
AERO_EXPRESSION_AST_NODES(DECLARE_NODE_TYPE_BASE)
virtual void Accept(Visitor* visitor) = 0;
};
inline void Expression::Accept(Visitor* visitor) { }
typedef core::SpaceVector<core::Space, Expression*>::type Expressions;
typedef core::SpaceVector<core::Space, Alternative*>::type Alternatives;
typedef core::SpaceVector<core::Space, Range>::type Ranges;
class Disjunction : public Expression {
public:
explicit Disjunction(Alternatives* alternatives)
: alternatives_(alternatives) { }
const Alternatives& alternatives() const {
return *alternatives_;
}
DECLARE_DERIVED_NODE_TYPE(Disjunction)
private:
Alternatives* alternatives_;
};
class Alternative : public Expression {
public:
explicit Alternative(Expressions* terms) : terms_(terms) { }
const Expressions& terms() const { return *terms_; }
DECLARE_DERIVED_NODE_TYPE(Alternative)
private:
Expressions* terms_;
};
class Term : public Expression {
public:
DECLARE_NODE_TYPE(Term)
};
class Atom : public Term {
public:
DECLARE_NODE_TYPE(Atom)
};
class Quantifiered : public Atom {
public:
Quantifiered(Expression* expr, int32_t min, int32_t max, bool greedy)
: expression_(expr), min_(min), max_(max), greedy_(greedy) { }
Expression* expression() const { return expression_; }
int32_t min() const { return min_; }
int32_t max() const { return max_; }
bool greedy() const { return greedy_; }
DECLARE_DERIVED_NODE_TYPE(Quantifiered)
private:
Expression* expression_;
int32_t min_;
int32_t max_;
bool greedy_;
};
class Assertion : public Term {
public:
DECLARE_NODE_TYPE(Assertion)
};
class HatAssertion : public Assertion {
public:
DECLARE_DERIVED_NODE_TYPE(HatAssertion)
};
class DollarAssertion : public Assertion {
public:
DECLARE_DERIVED_NODE_TYPE(DollarAssertion)
};
// \b or \B
class EscapedAssertion : public Assertion {
public:
explicit EscapedAssertion(bool uppercase) : uppercase_(uppercase) { }
bool uppercase() const { return uppercase_; }
DECLARE_DERIVED_NODE_TYPE(EscapedAssertion)
private:
bool uppercase_;
};
class DisjunctionAssertion : public Assertion {
public:
DisjunctionAssertion(Disjunction* disjunction, bool inverted)
: disjunction_(disjunction),
inverted_(inverted) {}
Disjunction* disjunction() const { return disjunction_; }
bool inverted() const { return inverted_; }
DECLARE_DERIVED_NODE_TYPE(DisjunctionAssertion)
private:
Disjunction* disjunction_;
bool inverted_;
};
class BackReferenceAtom : public Atom {
public:
explicit BackReferenceAtom(uint16_t ref, uint16_t octal)
: reference_(ref), octal_(octal) { }
uint16_t reference() const { return reference_; }
uint16_t octal() const { return octal_; }
DECLARE_DERIVED_NODE_TYPE(BackReferenceAtom)
private:
uint16_t reference_;
uint16_t octal_;
};
class CharacterAtom : public Atom {
public:
explicit CharacterAtom(uint16_t ch) : character_(ch) { }
uint16_t character() const { return character_; }
DECLARE_DERIVED_NODE_TYPE(CharacterAtom)
private:
uint16_t character_;
};
class RangeAtom : public Atom {
public:
explicit RangeAtom(bool inverted, Ranges* ranges)
: inverted_(inverted), ranges_(ranges) { }
const Ranges& ranges() const { return *ranges_; }
bool inverted() const { return inverted_; }
DECLARE_DERIVED_NODE_TYPE(RangeAtom)
private:
bool inverted_;
Ranges* ranges_;
};
class DisjunctionAtom : public Atom {
public:
explicit DisjunctionAtom(Disjunction* disjunction)
: disjunction_(disjunction),
captured_(false), num_(0) { }
DisjunctionAtom(Disjunction* disjunction, uint32_t num)
: disjunction_(disjunction),
captured_(true), num_(num) { }
Disjunction* disjunction() const { return disjunction_; }
bool captured() const { return captured_; }
uint32_t num() const { return num_; }
DECLARE_DERIVED_NODE_TYPE(DisjunctionAtom)
private:
Disjunction* disjunction_;
bool captured_;
uint32_t num_;
};
#undef ACCEPT_VISITOR
#undef DECLARE_NODE_TYPE
#undef DECLARE_DERIVED_NODE_TYPE
#undef DECLARE_NODE_TYPE_BASE
} } // namespace iv::aero
#endif // IV_AERO_AST_H_