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
|
/*
* Copyright 2017 WebAssembly Community Group participants
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef WABT_TOKEN_H_
#define WABT_TOKEN_H_
#include <string_view>
#include "wabt/literal.h"
#include "wabt/opcode.h"
namespace wabt {
struct Literal {
Literal() = default;
Literal(LiteralType type, std::string_view text) : type(type), text(text) {}
LiteralType type;
std::string_view text;
};
enum class TokenType {
#define WABT_TOKEN(name, string) name,
#define WABT_TOKEN_FIRST(group, first) First_##group = first,
#define WABT_TOKEN_LAST(group, last) Last_##group = last,
#include "wabt/token.def"
#undef WABT_TOKEN
#undef WABT_TOKEN_FIRST
#undef WABT_TOKEN_LAST
First = First_Bare,
Last = Last_RefKind,
};
const char* GetTokenTypeName(TokenType);
inline bool IsTokenTypeBare(TokenType token_type) {
return token_type >= TokenType::First_Bare &&
token_type <= TokenType::Last_Bare;
}
inline bool IsTokenTypeString(TokenType token_type) {
return token_type >= TokenType::First_String &&
token_type <= TokenType::Last_String;
}
inline bool IsTokenTypeType(TokenType token_type) {
return token_type == TokenType::ValueType;
}
inline bool IsTokenTypeOpcode(TokenType token_type) {
return token_type >= TokenType::First_Opcode &&
token_type <= TokenType::Last_Opcode;
}
inline bool IsTokenTypeLiteral(TokenType token_type) {
return token_type >= TokenType::First_Literal &&
token_type <= TokenType::Last_Literal;
}
inline bool IsTokenTypeRefKind(TokenType token_type) {
return token_type >= TokenType::First_RefKind &&
token_type <= TokenType::Last_RefKind;
}
struct Token {
Token() : token_type_(TokenType::Invalid) {}
Token(Location, TokenType);
Token(Location, TokenType, Type);
Token(Location, TokenType, std::string_view);
Token(Location, TokenType, Opcode);
Token(Location, TokenType, const Literal&);
Location loc;
TokenType token_type() const { return token_type_; }
bool HasText() const { return IsTokenTypeString(token_type_); }
bool HasType() const {
return IsTokenTypeType(token_type_) || IsTokenTypeRefKind(token_type_);
}
bool HasOpcode() const { return IsTokenTypeOpcode(token_type_); }
bool HasLiteral() const { return IsTokenTypeLiteral(token_type_); }
std::string_view text() const {
assert(HasText());
return text_;
}
Type type() const {
assert(HasType());
return type_;
}
Opcode opcode() const {
assert(HasOpcode());
return opcode_;
}
const Literal& literal() const {
assert(HasLiteral());
return literal_;
}
std::string to_string() const;
std::string to_string_clamp(size_t max_length) const;
private:
TokenType token_type_;
union {
std::string_view text_;
Type type_;
Opcode opcode_;
Literal literal_;
};
};
} // namespace wabt
#endif // WABT_TOKEN_H_
|
