OpenVDB 10.0.1
Loading...
Searching...
No Matches
Tokens.h
Go to the documentation of this file.
1// Copyright Contributors to the OpenVDB Project
2// SPDX-License-Identifier: MPL-2.0
3
4/// @file ast/Tokens.h
5///
6/// @authors Nick Avramoussis
7///
8/// @brief Various function and operator tokens used throughout the
9/// AST and code generation
10///
11
12#ifndef OPENVDB_AX_AST_TOKENS_HAS_BEEN_INCLUDED
13#define OPENVDB_AX_AST_TOKENS_HAS_BEEN_INCLUDED
14
15#include "../Exceptions.h"
16
17#include <openvdb/version.h>
18#include <openvdb/Types.h>
19
20#include <stdexcept>
21
22namespace openvdb {
24namespace OPENVDB_VERSION_NAME {
25
26namespace ax {
27namespace ast {
28
29namespace tokens {
30
32{
33 BOOL = 0,
40 //
44 //
48 //
52 //
55 //
58 //
61 //
64};
65
66inline CoreType tokenFromTypeString(const std::string& type)
67{
68 if (type[0] == 'v') {
69 if (type == "vec2i") return VEC2I;
70 if (type == "vec2f") return VEC2F;
71 if (type == "vec2d") return VEC2D;
72 if (type == "vec3i") return VEC3I;
73 if (type == "vec3f") return VEC3F;
74 if (type == "vec3d") return VEC3D;
75 if (type == "vec4i") return VEC4I;
76 if (type == "vec4f") return VEC4F;
77 if (type == "vec4d") return VEC4D;
78 }
79 else if (type[0] == 'm') {
80 if (type == "mat3f") return MAT3F;
81 if (type == "mat3d") return MAT3D;
82 if (type == "mat4f") return MAT4F;
83 if (type == "mat4d") return MAT4D;
84 }
85 else if (type[0] == 'q') {
86 if (type == "quatf") return QUATF;
87 if (type == "quatd") return QUATD;
88 }
89 else if (type[0] == 'i') {
90 if (type == "int16") return INT16;
91 if (type == "int") return INT32;
92 if (type == "int32") return INT32;
93 if (type == "int64") return INT64;
94 }
95 else if (type == "bool") return BOOL;
96 else if (type == "char") return CHAR;
97 else if (type == "float") return FLOAT;
98 else if (type == "double") return DOUBLE;
99 else if (type == "string") return STRING;
100
101 // also handle vdb types that have different type strings to our tokens
102 // @todo These should probably be separated out. The executables currently
103 // use this function to guarantee conversion
104 if (type[0] == 'v') {
105 if (type == "vec2s") return VEC2F;
106 if (type == "vec3s") return VEC3F;
107 if (type == "vec4s") return VEC4F;
108 }
109 else if (type[0] == 'm') {
110 if (type == "mat3s") return MAT3F;
111 if (type == "mat4s") return MAT4F;
112 }
113 else if (type == "quats") return QUATF;
114
115 return UNKNOWN;
116}
117
118inline std::string typeStringFromToken(const CoreType type)
119{
120 switch (type) {
121 case BOOL : return "bool";
122 case CHAR : return "char";
123 case INT16 : return "int16";
124 case INT32 : return "int32";
125 case INT64 : return "int64";
126 case FLOAT : return "float";
127 case DOUBLE : return "double";
128 case VEC2I : return "vec2i";
129 case VEC2F : return "vec2f";
130 case VEC2D : return "vec2d";
131 case VEC3I : return "vec3i";
132 case VEC3F : return "vec3f";
133 case VEC3D : return "vec3d";
134 case VEC4I : return "vec4i";
135 case VEC4F : return "vec4f";
136 case VEC4D : return "vec4d";
137 case MAT3F : return "mat3f";
138 case MAT3D : return "mat3d";
139 case MAT4F : return "mat4f";
140 case MAT4D : return "mat4d";
141 case QUATF : return "quatf";
142 case QUATD : return "quatd";
143 case STRING : return "string";
144 case UNKNOWN :
145 default :
146 return "unknown";
147 }
148}
149
151{
152 ////////////////////////////////////////////////////////////////
153 /// ARITHMETIC
154 ////////////////////////////////////////////////////////////////
155 PLUS = 0,
160 ////////////////////////////////////////////////////////////////
161 /// LOGICAL
162 ////////////////////////////////////////////////////////////////
166 ////////////////////////////////////////////////////////////////
167 /// RELATIONAL
168 ////////////////////////////////////////////////////////////////
175 ////////////////////////////////////////////////////////////////
176 /// BITWISE
177 ////////////////////////////////////////////////////////////////
184 ////////////////////////////////////////////////////////////////
185 /// ASSIGNMENT
186 ////////////////////////////////////////////////////////////////
199
201{
209
211{
212 const size_t idx = static_cast<size_t>(token);
213 if (idx <= static_cast<size_t>(MODULO)) return ARITHMETIC;
214 if (idx <= static_cast<size_t>(NOT)) return LOGICAL;
215 if (idx <= static_cast<size_t>(LESSTHANOREQUAL)) return RELATIONAL;
216 if (idx <= static_cast<size_t>(BITNOT)) return BITWISE;
217 if (idx <= static_cast<size_t>(BITOREQUALS)) return ASSIGNMENT;
218 return UNKNOWN_OPERATOR;
219}
220
221inline OperatorToken operatorTokenFromName(const std::string& name)
222{
223 if (name == "+") return PLUS;
224 if (name == "-") return MINUS;
225 if (name == "*") return MULTIPLY;
226 if (name == "/") return DIVIDE;
227 if (name == "%") return MODULO;
228 if (name == "&&") return AND;
229 if (name == "||") return OR;
230 if (name == "!") return NOT;
231 if (name == "==") return EQUALSEQUALS;
232 if (name == "!=") return NOTEQUALS;
233 if (name == ">") return MORETHAN;
234 if (name == "<") return LESSTHAN;
235 if (name == ">=") return MORETHANOREQUAL;
236 if (name == "<=") return LESSTHANOREQUAL;
237 if (name == "<<") return SHIFTLEFT;
238 if (name == ">>") return SHIFTRIGHT;
239 if (name == "&") return BITAND;
240 if (name == "|") return BITOR;
241 if (name == "^") return BITXOR;
242 if (name == "~") return BITNOT;
243 if (name == "=") return EQUALS;
244 if (name == "+=") return PLUSEQUALS;
245 if (name == "-=") return MINUSEQUALS;
246 if (name == "*=") return MULTIPLYEQUALS;
247 if (name == "/=") return DIVIDEEQUALS;
248 if (name == "%=") return MODULOEQUALS;
249 if (name == "<<=") return SHIFTLEFTEQUALS;
250 if (name == ">>=") return SHIFTRIGHTEQUALS;
251 if (name == "&=") return BITANDEQUALS;
252 if (name == "^=") return BITXOREQUALS;
253 if (name == "|=") return BITOREQUALS;
254 OPENVDB_THROW(AXTokenError, "Unsupported op \"" + name + "\"");
255}
256
257inline std::string operatorNameFromToken(const OperatorToken token)
258{
259 switch (token) {
260 case PLUS : return "+";
261 case MINUS : return "-";
262 case MULTIPLY : return "*";
263 case DIVIDE : return "/";
264 case MODULO : return "%";
265 case AND : return "&&";
266 case OR : return "||";
267 case NOT : return "!";
268 case EQUALSEQUALS : return "==";
269 case NOTEQUALS : return "!=";
270 case MORETHAN : return ">";
271 case LESSTHAN : return "<";
272 case MORETHANOREQUAL : return ">=";
273 case LESSTHANOREQUAL : return "<=";
274 case SHIFTLEFT : return "<<";
275 case SHIFTRIGHT : return ">>";
276 case BITAND : return "&";
277 case BITOR : return "|";
278 case BITXOR : return "^";
279 case BITNOT : return "~";
280 case EQUALS : return "=";
281 case PLUSEQUALS : return "+=";
282 case MINUSEQUALS : return "-=";
283 case MULTIPLYEQUALS : return "*=";
284 case DIVIDEEQUALS : return "/=";
285 case MODULOEQUALS : return "%=";
286 case SHIFTLEFTEQUALS : return "<<=";
287 case SHIFTRIGHTEQUALS : return ">>=";
288 case BITANDEQUALS : return "&=";
289 case BITXOREQUALS : return "^=";
290 case BITOREQUALS : return "|=";
291 default :
292 OPENVDB_THROW(AXTokenError, "Unsupported op");
293 }
294}
295
297{
298 FOR = 0,
300 WHILE
302
303inline std::string loopNameFromToken(const LoopToken loop)
304{
305 switch (loop) {
306 case FOR : return "for";
307 case DO : return "do";
308 case WHILE : return "while";
309 default :
310 OPENVDB_THROW(AXTokenError, "Unsupported loop");
311 }
312}
313
315{
320
321inline std::string keywordNameFromToken(const KeywordToken keyw)
322{
323 switch (keyw) {
324 case RETURN : return "return";
325 case BREAK : return "break";
326 case CONTINUE : return "continue";
327 default :
328 OPENVDB_THROW(AXTokenError, "Unsupported keyword");
329 }
330}
331
332
333} // namespace tokens
334
335} // namespace ast
336} // namespace ax
337} // namespace OPENVDB_VERSION_NAME
338} // namespace openvdb
339
340#endif // OPENVDB_AX_AST_TOKENS_HAS_BEEN_INCLUDED
341
@ NOT
Definition: axparser.h:154
@ VEC3D
Definition: axparser.h:93
@ BITOR
Definition: axparser.h:137
@ DIVIDE
Definition: axparser.h:151
@ LESSTHANOREQUAL
Definition: axparser.h:145
@ SHIFTRIGHT
Definition: axparser.h:147
@ MAT3F
Definition: axparser.h:102
@ MAT3D
Definition: axparser.h:103
@ MAT4D
Definition: axparser.h:105
@ WHILE
Definition: axparser.h:74
@ DOUBLE
Definition: axparser.h:83
@ BITNOT
Definition: axparser.h:155
@ MORETHANOREQUAL
Definition: axparser.h:144
@ INT64
Definition: axparser.h:86
@ MINUSEQUALS
Definition: axparser.h:126
@ SHIFTLEFTEQUALS
Definition: axparser.h:133
@ CONTINUE
Definition: axparser.h:77
@ BITOREQUALS
Definition: axparser.h:132
@ RETURN
Definition: axparser.h:75
@ BITXOREQUALS
Definition: axparser.h:131
@ VEC3F
Definition: axparser.h:92
@ MODULOEQUALS
Definition: axparser.h:129
@ PLUSEQUALS
Definition: axparser.h:125
@ EQUALSEQUALS
Definition: axparser.h:140
@ VEC2I
Definition: axparser.h:88
@ BITXOR
Definition: axparser.h:138
@ BITAND
Definition: axparser.h:139
@ MAT4F
Definition: axparser.h:104
@ AND
Definition: axparser.h:136
@ PLUS
Definition: axparser.h:148
@ LESSTHAN
Definition: axparser.h:143
@ VEC4F
Definition: axparser.h:95
@ DIVIDEEQUALS
Definition: axparser.h:128
@ EQUALS
Definition: axparser.h:124
@ BREAK
Definition: axparser.h:76
@ OR
Definition: axparser.h:135
@ VEC4I
Definition: axparser.h:94
@ FLOAT
Definition: axparser.h:84
@ MODULO
Definition: axparser.h:152
@ FOR
Definition: axparser.h:72
@ MORETHAN
Definition: axparser.h:142
@ VEC2D
Definition: axparser.h:90
@ VEC3I
Definition: axparser.h:91
@ MULTIPLYEQUALS
Definition: axparser.h:127
@ DO
Definition: axparser.h:73
@ VEC4D
Definition: axparser.h:96
@ INT32
Definition: axparser.h:85
@ BITANDEQUALS
Definition: axparser.h:130
@ NOTEQUALS
Definition: axparser.h:141
@ SHIFTRIGHTEQUALS
Definition: axparser.h:134
@ MULTIPLY
Definition: axparser.h:150
@ BOOL
Definition: axparser.h:87
@ SHIFTLEFT
Definition: axparser.h:146
@ VEC2F
Definition: axparser.h:89
@ STRING
Definition: axparser.h:82
@ MINUS
Definition: axparser.h:149
Definition: Exceptions.h:36
std::string operatorNameFromToken(const OperatorToken token)
Definition: Tokens.h:257
OperatorToken
Definition: Tokens.h:151
std::string typeStringFromToken(const CoreType type)
Definition: Tokens.h:118
std::string loopNameFromToken(const LoopToken loop)
Definition: Tokens.h:303
OperatorToken operatorTokenFromName(const std::string &name)
Definition: Tokens.h:221
OperatorType operatorType(const OperatorToken token)
Definition: Tokens.h:210
KeywordToken
Definition: Tokens.h:315
OperatorType
Definition: Tokens.h:201
@ ASSIGNMENT
Definition: Tokens.h:206
@ LOGICAL
Definition: Tokens.h:203
@ BITWISE
Definition: Tokens.h:205
@ ARITHMETIC
Definition: Tokens.h:202
@ RELATIONAL
Definition: Tokens.h:204
@ UNKNOWN_OPERATOR
Definition: Tokens.h:207
LoopToken
Definition: Tokens.h:297
CoreType tokenFromTypeString(const std::string &type)
Definition: Tokens.h:66
std::string keywordNameFromToken(const KeywordToken keyw)
Definition: Tokens.h:321
CoreType
Definition: Tokens.h:32
@ CHAR
Definition: Tokens.h:34
@ UNKNOWN
Definition: Tokens.h:63
@ INT16
Definition: Tokens.h:35
@ QUATF
Definition: Tokens.h:59
@ QUATD
Definition: Tokens.h:60
Definition: Exceptions.h:13
#define OPENVDB_THROW(exception, message)
Definition: Exceptions.h:74
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h.in:121
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h.in:212