OpenVDB  9.1.1
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 
22 namespace openvdb {
24 namespace OPENVDB_VERSION_NAME {
25 
26 namespace ax {
27 namespace ast {
28 
29 namespace tokens {
30 
32 {
33  BOOL = 0,
40  //
44  //
48  //
52  //
55  //
58  //
61  //
64 };
65 
66 inline 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 
118 inline 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  ////////////////////////////////////////////////////////////////
164  OR,
166  ////////////////////////////////////////////////////////////////
167  /// RELATIONAL
168  ////////////////////////////////////////////////////////////////
175  ////////////////////////////////////////////////////////////////
176  /// BITWISE
177  ////////////////////////////////////////////////////////////////
184  ////////////////////////////////////////////////////////////////
185  /// ASSIGNMENT
186  ////////////////////////////////////////////////////////////////
198 };
199 
201 {
208 };
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 
221 inline 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 
257 inline 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,
299  DO,
301 };
302 
303 inline 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 {
316  RETURN = 0,
319 };
320 
321 inline 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 
Definition: axparser.h:88
Definition: axparser.h:140
CoreType tokenFromTypeString(const std::string &type)
Definition: Tokens.h:66
Definition: axparser.h:95
Definition: axparser.h:76
Definition: axparser.h:128
Definition: axparser.h:86
Definition: axparser.h:133
Definition: axparser.h:127
Definition: axparser.h:141
Definition: axparser.h:103
#define OPENVDB_THROW(exception, message)
Definition: Exceptions.h:74
Definition: axparser.h:147
Definition: axparser.h:82
Definition: axparser.h:144
Definition: axparser.h:154
Definition: axparser.h:134
Definition: axparser.h:125
Definition: axparser.h:104
Definition: axparser.h:136
Definition: axparser.h:124
Definition: axparser.h:145
Definition: axparser.h:155
Definition: axparser.h:143
Definition: axparser.h:90
Definition: axparser.h:87
Definition: axparser.h:72
OperatorToken
Definition: Tokens.h:150
Definition: Exceptions.h:34
std::string operatorNameFromToken(const OperatorToken token)
Definition: Tokens.h:257
CoreType
Definition: Tokens.h:31
OperatorToken operatorTokenFromName(const std::string &name)
Definition: Tokens.h:221
Definition: axparser.h:151
Definition: axparser.h:137
std::string loopNameFromToken(const LoopToken loop)
Definition: Tokens.h:303
Definition: axparser.h:146
std::string keywordNameFromToken(const KeywordToken keyw)
Definition: Tokens.h:321
Definition: axparser.h:102
std::string typeStringFromToken(const CoreType type)
Definition: Tokens.h:118
Definition: axparser.h:85
Definition: axparser.h:92
Definition: axparser.h:96
Definition: Exceptions.h:13
Definition: axparser.h:74
Definition: axparser.h:135
Definition: axparser.h:150
Definition: axparser.h:73
Definition: axparser.h:142
Definition: axparser.h:149
Definition: axparser.h:148
Definition: axparser.h:139
Definition: axparser.h:89
Definition: axparser.h:77
Definition: axparser.h:93
LoopToken
Definition: Tokens.h:296
Definition: axparser.h:126
Definition: axparser.h:131
Definition: axparser.h:75
Definition: axparser.h:152
OperatorType operatorType(const OperatorToken token)
Definition: Tokens.h:210
Definition: axparser.h:138
KeywordToken
Definition: Tokens.h:314
Definition: axparser.h:94
Definition: axparser.h:132
Definition: axparser.h:84
Definition: axparser.h:129
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h.in:116
OperatorType
Definition: Tokens.h:200
Definition: axparser.h:105
Definition: axparser.h:83
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h.in:202
Definition: axparser.h:130
Definition: axparser.h:91