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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/*
* MRustC - Rust Compiler
* - By John Hodge (Mutabah/thePowersGang)
*
* ast/pattern.hpp
* - AST Pattern representation
*/
#ifndef _AST__PATTERN_HPP_INCLUDED_
#define _AST__PATTERN_HPP_INCLUDED_
#include <vector>
#include <memory>
#include <string>
#include <tagged_union.hpp>
#include <ident.hpp>
#include "path.hpp"
namespace AST {
using ::std::unique_ptr;
using ::std::move;
class MacroInvocation;
class PatternBinding
{
public:
enum class Type {
MOVE,
REF,
MUTREF,
};
Ident m_name;
Type m_type;
bool m_mutable;
unsigned int m_slot;
PatternBinding():
m_name({}, ""),
m_type(Type::MOVE),
m_mutable(false),
m_slot( ~0u )
{}
PatternBinding(Ident name, Type ty, bool ismut):
m_name(::std::move(name)),
m_type(ty),
m_mutable(ismut),
m_slot( ~0u )
{}
PatternBinding(PatternBinding&& x) = default;
PatternBinding(const PatternBinding& x) = default;
PatternBinding& operator=(PatternBinding&& x) = default;
bool is_valid() const { return m_name.name != ""; }
};
class Pattern:
public Serialisable
{
public:
TAGGED_UNION(Value, Invalid,
(Invalid, struct {}),
(Integer, struct {
enum eCoreType type;
uint64_t value; // Signed numbers are encoded as 2's complement
}),
(Float, struct {
enum eCoreType type;
double value;
}),
(String, ::std::string),
(ByteString, struct { ::std::string v; }),
(Named, Path)
);
struct TuplePat {
::std::vector<Pattern> start;
bool has_wildcard;
::std::vector<Pattern> end;
};
TAGGED_UNION(Data, Any,
(MaybeBind, struct { Ident name; } ),
(Macro, struct { unique_ptr<::AST::MacroInvocation> inv; } ),
(Any, struct { } ),
(Box, struct { unique_ptr<Pattern> sub; } ),
(Ref, struct { bool mut; unique_ptr<Pattern> sub; } ),
(Value, struct { Value start; Value end; } ),
(Tuple, TuplePat ),
(StructTuple, struct { Path path; TuplePat tup_pat; } ),
(Struct, struct { Path path; ::std::vector< ::std::pair< ::std::string, Pattern> > sub_patterns; bool is_exhaustive; } ),
(Slice, struct { ::std::vector<Pattern> sub_pats; }),
(SplitSlice, struct { ::std::vector<Pattern> leading; PatternBinding extra_bind; ::std::vector<Pattern> trailing; } )
);
private:
Span m_span;
PatternBinding m_binding;
Data m_data;
public:
virtual ~Pattern();
Pattern()
{}
Pattern(Pattern&&) = default;
Pattern& operator=(Pattern&&) = default;
Pattern(Data dat):
m_binding(),
m_data( mv$(dat) )
{};
struct TagMaybeBind {};
Pattern(TagMaybeBind, Ident name):
m_binding(),
m_data( Data::make_MaybeBind({ mv$(name) }) )
{}
struct TagMacro {};
Pattern(TagMacro, unique_ptr<::AST::MacroInvocation> inv):
m_data( Data::make_Macro({ mv$(inv) }) )
{}
struct TagBind {};
Pattern(TagBind, Ident name, PatternBinding::Type ty = PatternBinding::Type::MOVE, bool is_mut=false):
m_binding( PatternBinding(mv$(name), ty, is_mut) )
{}
struct TagBox {};
Pattern(TagBox, Pattern sub):
m_data( Data::make_Box({ unique_ptr<Pattern>(new Pattern(mv$(sub))) }) )
{}
struct TagValue {};
Pattern(TagValue, Value val, Value end = Value()):
m_data( Data::make_Value({ ::std::move(val), ::std::move(end) }) )
{}
struct TagReference {};
Pattern(TagReference, bool is_mutable, Pattern sub_pattern):
m_data( Data::make_Ref( /*Data::Data_Ref */ {
is_mutable, unique_ptr<Pattern>(new Pattern(::std::move(sub_pattern)))
}) )
{
}
struct TagTuple {};
Pattern(TagTuple, ::std::vector<Pattern> pats):
m_data( Data::make_Tuple( TuplePat { mv$(pats), false, {} } ) )
{}
Pattern(TagTuple, TuplePat pat):
m_data( Data::make_Tuple( mv$(pat) ) )
{}
struct TagNamedTuple {};
Pattern(TagNamedTuple, Path path, ::std::vector<Pattern> pats):
m_data( Data::make_StructTuple( { mv$(path), TuplePat { mv$(pats), false, {} } } ) )
{}
Pattern(TagNamedTuple, Path path, TuplePat pat = TuplePat { {}, false, {} }):
m_data( Data::make_StructTuple( { ::std::move(path), ::std::move(pat) } ) )
{}
struct TagStruct {};
Pattern(TagStruct, Path path, ::std::vector< ::std::pair< ::std::string,Pattern> > sub_patterns, bool is_exhaustive):
m_data( Data::make_Struct( { ::std::move(path), ::std::move(sub_patterns), is_exhaustive } ) )
{}
// Mutators
void set_bind(Ident name, PatternBinding::Type type, bool is_mut) {
m_binding = PatternBinding(mv$(name), type, is_mut);
}
const Span& span() const { return m_span; }
void set_span(Span sp) { m_span = mv$(sp); }
Pattern clone() const;
// Accessors
PatternBinding& binding() { return m_binding; }
const PatternBinding& binding() const { return m_binding; }
Data& data() { return m_data; }
const Data& data() const { return m_data; }
Path& path() { return m_data.as_StructTuple().path; }
const Path& path() const { return m_data.as_StructTuple().path; }
friend ::std::ostream& operator<<(::std::ostream& os, const Pattern& pat);
SERIALISABLE_PROTOTYPES();
static ::std::unique_ptr<Pattern> from_deserialiser(Deserialiser& s) {
::std::unique_ptr<Pattern> ret(new Pattern);
s.item(*ret);
return ret;
}
};
extern ::std::ostream& operator<<(::std::ostream& os, const Pattern::Value& val);
extern ::std::ostream& operator<<(::std::ostream& os, const Pattern::TuplePat& val);
};
#endif
|
